1import { Injectable } from '@angular/core';
2import { HttpInterceptor, HttpEvent, HttpResponse, HttpRequest, HttpHandler } from '@angular/common/http';
3import { Observable } from 'rxjs';
4
5@Injectable()
6export class MyInterceptor implements HttpInterceptor {
7 intercept(httpRequest: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
8 return next.handle(httpRequest);
9 }
10}
11
1// src/app/auth/auth.service.ts
2
3import { Injectable } from '@angular/core';
4import decode from 'jwt-decode';
5
6@Injectable()
7export class AuthService {
8 public getToken(): string {
9 return localStorage.getItem('token');
10 }
11
12 public isAuthenticated(): boolean {
13 // get the token
14 const token = this.getToken();
15 // return a boolean reflecting
16 // whether or not the token is expired
17 return tokenNotExpired(null, token);
18 }
19}
20
21// src/app/auth/token.interceptor.ts
22import { Injectable } from '@angular/core';
23import {
24 HttpRequest,
25 HttpHandler,
26 HttpEvent,
27 HttpInterceptor
28} from '@angular/common/http';
29import { AuthService } from './auth/auth.service';
30import { Observable } from 'rxjs/Observable';
31@Injectable()
32export class TokenInterceptor implements HttpInterceptor {
33 constructor(public auth: AuthService) {}
34 intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
35
36 request = request.clone({
37 setHeaders: {
38 Authorization: `Bearer ${this.auth.getToken()}`
39 }
40 });
41 return next.handle(request);
42 }
43}
44
45// src/app/app.module.ts
46import { HTTP_INTERCEPTORS } from '@angular/common/http';
47import { TokenInterceptor } from './../auth/token.interceptor';
48
49@NgModule({ bootstrap: [AppComponent],
50 imports: [...],
51 providers: [
52 {
53 provide: HTTP_INTERCEPTORS,
54 useClass: TokenInterceptor,
55 multi: true
56 }
57 ]})
58export class AppModule {}
1// src/app/app.module.ts
2
3import { HTTP_INTERCEPTORS } from '@angular/common/http';
4import { TokenInterceptor } from './../auth/token.interceptor';
5
6@NgModule({
7 bootstrap: [AppComponent],
8 imports: [...],
9 providers: [
10 {
11 provide: HTTP_INTERCEPTORS,
12 useClass: TokenInterceptor,
13 multi: true
14 }
15 ]
16})
17export class AppModule {}
18
1
2 interface HttpInterceptor {
3 intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>
4}
5
1// register the interceptor as a service
2$provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
3 return {
4 // optional method
5 'request': function(config) {
6 // do something on success
7 return config;
8 },
9
10 // optional method
11 'requestError': function(rejection) {
12 // do something on error
13 if (canRecover(rejection)) {
14 return responseOrNewPromise
15 }
16 return $q.reject(rejection);
17 },
18
19
20
21 // optional method
22 'response': function(response) {
23 // do something on success
24 return response;
25 },
26
27 // optional method
28 'responseError': function(rejection) {
29 // do something on error
30 if (canRecover(rejection)) {
31 return responseOrNewPromise
32 }
33 return $q.reject(rejection);
34 }
35 };
36});
37
38$httpProvider.interceptors.push('myHttpInterceptor');
39
40
41// alternatively, register the interceptor via an anonymous factory
42$httpProvider.interceptors.push(function($q, dependency1, dependency2) {
43 return {
44 'request': function(config) {
45 // same as above
46 },
47
48 'response': function(response) {
49 // same as above
50 }
51 };
52});