haskell.service.ts 5.66 KB
Newer Older
1
import { Injectable } from '@angular/core';
2
import { Router } from '@angular/router';
3
4
5
6
7
8
import { Http, Response, Headers, RequestOptions, URLSearchParams } from '@angular/http';
import { Observable } from 'rxjs/Observable';
import { Archivo, Evaluacion } from '../objects/archivo';
import { Grupo } from '../objects/grupo';

import { SERVER } from '../config';
9
import { TranslateService } from '@ngx-translate/core';
10
11
12
13
14
15
import { AuthenticationService } from './authentication.service';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/catch';

@Injectable()
export class HaskellService {
16
  translateService: any;
17
18
19
20
21
22

  /**
   * Creates a new HaskellService with the injected Http.
   * @param {Http} http - The injected Http.
   * @constructor
   */
23
24
25
26
27
28
   constructor(
      private http: Http, private router: Router,
      private authService: AuthenticationService,
      public translate: TranslateService) {
    this.translateService = translate;
   }
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

   getArchivos(cedula:string): Observable<Archivo[]> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken() });
     let params: URLSearchParams = new URLSearchParams();
     params.set('cedula', cedula);
     let options = new RequestOptions({ headers: headers, search: params });
     return this.http.get(SERVER+'/servicios/archivo',options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   getArchivosCompartidosAlumno(cedula:string): Observable<Archivo[]> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let params: URLSearchParams = new URLSearchParams();
     params.set('cedula', cedula);
     params.set('compartidos','true');
     let options = new RequestOptions({ headers: headers, search: params });
     return this.http.get(SERVER+'/servicios/archivo',options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   crearArchivo(archivo: Archivo): Observable<Archivo> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let options = new RequestOptions({ headers: headers });
     return this.http.post(SERVER+'/servicios/archivo', archivo, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   editarArchivo(archivoId, archivo: Archivo): Observable<Archivo> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken() });
     let options = new RequestOptions({ headers: headers });
     return this.http.put(SERVER+'/servicios/archivo/'+archivoId, archivo, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   eliminarArchivo(archivoId): Observable<Response> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let options = new RequestOptions({ headers: headers });
     return this.http.delete(SERVER+'/servicios/archivo/'+archivoId, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   getCopiaArchivoCompartidoGrupo(cedula, archivoId): Observable<Archivo> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let params: URLSearchParams = new URLSearchParams();
     params.set('cedula', cedula);
     let options = new RequestOptions({ headers: headers, search: params });
     return this.http.get(SERVER+'/servicios/archivo/compartido/'+archivoId, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   compartirArchivoGrupo(grupo,archivoId): Observable<Archivo> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let options = new RequestOptions({ headers: headers });
     var archId = {
       id:archivoId
     }
     return this.http.post(SERVER+'/servicios/grupo/'+grupo.liceoId+'/'+grupo.anio+'/'+grupo.grado+'/'+grupo.grupo+'/archivo', archId, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }

   calificarArchivo(archivoId, evaluacion): Observable<Evaluacion> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let options = new RequestOptions({ headers: headers });
     return this.http.post(SERVER+'/servicios/archivo/'+archivoId+'/evaluacion', evaluacion, options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }


   getGrupos(cedula:string): Observable<Grupo[]> {
     let headers = new Headers({ 'Content-Type': 'application/json', 'Authorization':'Bearer '+this.authService.getToken()  });
     let params: URLSearchParams = new URLSearchParams();
     params.set('cedula', cedula);
     let options = new RequestOptions({ headers: headers, search: params });
     return this.http.get(SERVER+'/servicios/grupo',options)
     .map((res: Response) => res.json())
     .catch(this.handleError);
   }
   
  /**
    * Handle HTTP error
    */
    private handleError (error: any) {
119
      if(error.status == 401){
120
        this.router.navigate(['/'+this.translateService.get('i18n.code').value+'/login']);
121
      }
122
123
124
125
126
127
128
129
      // In a real world app, we might use a remote logging infrastructure
      // We'd also dig deeper into the error to get a better message
      let errMsg = (error.message) ? error.message :
      error.status ? `${error.status} - ${error.statusText}` : 'Server error';
      console.error(errMsg); // log to console instead
      return Observable.throw(errMsg);
    }
  }