@pepperi/ngx-lib
Version:
Pepperi Angular Components and Services
109 lines • 18.3 kB
JavaScript
import { Injectable } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "../../common/services/session.service";
export class AuthInterceptor {
// private SESSION_TOKEN_KEY = 'auth_token';
// private token = 'secrettoken';
// private refreshTokenInProgress = false;
// private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);
constructor(sessionService) {
this.sessionService = sessionService;
this.AUTH_HEADER = 'Authorization';
this.PEPPERI_TOKEN_HEADER = 'PepperiSessionToken';
this.PEPPERI_CONSUMER_KEY_HEADER = 'X-Pepperi-ConsumerKey';
}
// Add authorization token if the token exist.
addAuthorizationToken(request) {
if (!request.headers.has(this.AUTH_HEADER)) {
const idpToken = this.sessionService.getIdpToken();
if (idpToken) {
request = request.clone({
headers: request.headers.set(this.AUTH_HEADER, `Bearer ${idpToken}`)
});
}
}
return request;
}
// Add pepperi consumer token if calling to papi domain.
addPepperiConsumerToken(request) {
if (!request.headers.has(this.PEPPERI_CONSUMER_KEY_HEADER)) {
const papiBaseUrl = this.sessionService.getPapiBaseUrl();
if (papiBaseUrl && request.url.match(new RegExp(papiBaseUrl, 'g'))) {
const pepperiConsumerToken = this.sessionService.getPepperiConsumerToken();
if (pepperiConsumerToken) {
request = request.clone({
headers: request.headers.set(this.PEPPERI_CONSUMER_KEY_HEADER, pepperiConsumerToken)
});
}
}
}
return request;
}
// Add web api token if calling to wapi domain.
addWebApiToken(request) {
if (!request.headers.has(this.PEPPERI_TOKEN_HEADER)) {
const wapiBaseUrl = this.sessionService.getWapiBaseUrl();
if (wapiBaseUrl && request.url.match(new RegExp(wapiBaseUrl, 'g'))) {
const webApiToken = this.sessionService.gettWapiToken();
if (webApiToken) {
request = request.clone({
headers: request.headers.set(this.PEPPERI_TOKEN_HEADER, webApiToken)
});
}
}
}
return request;
}
intercept(req, next) {
console.warn('AuthInterceptor');
// Add content type
if (!req.headers.has('Content-Type')) {
req = req.clone({
headers: req.headers.set('Content-Type', 'application/json')
});
}
req = this.addAuthorizationToken(req);
req = this.addPepperiConsumerToken(req);
req = this.addWebApiToken(req);
return next.handle(req);
// TODO: Check if we need this - this is an advance code that try to refresh the token in case of expired.
// return next.handle(req).pipe(
// catchError((error: HttpErrorResponse) => {
// if (error && error.status === 401) {
// // 401 errors are most likely going to be because we have an expired token that we need to refresh.
// if (this.refreshTokenInProgress) {
// // If refreshTokenInProgress is true, we will wait until refreshTokenSubject has a non-null value
// // which means the new token is ready and we can retry the request again
// return this.refreshTokenSubject.pipe(
// filter(result => result !== null),
// take(1),
// switchMap(() => next.handle(this.addAuthenticationToken(req)))
// );
// } else {
// this.refreshTokenInProgress = true;
// // Set the refreshTokenSubject to null so that subsequent API calls will
// // wait until the new token has been retrieved
// this.refreshTokenSubject.next(null);
// return this.refreshAccessToken().pipe(
// switchMap((success: boolean) => {
// this.refreshTokenSubject.next(success);
// return next.handle(this.addAuthenticationToken(req));
// }),
// // When the call to refreshToken completes we reset the refreshTokenInProgress to false
// // for the next time the token needs to be refreshed
// finalize(() => (this.refreshTokenInProgress = false))
// );
// }
// } else {
// return throwError(error);
// }
// })
// );
}
}
AuthInterceptor.ɵfac = function AuthInterceptor_Factory(t) { return new (t || AuthInterceptor)(i0.ɵɵinject(i1.SessionService)); };
AuthInterceptor.ɵprov = i0.ɵɵdefineInjectable({ token: AuthInterceptor, factory: AuthInterceptor.ɵfac });
/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(AuthInterceptor, [{
type: Injectable
}], function () { return [{ type: i1.SessionService }]; }, null); })();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/http/interceptors/auth.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n    HttpEvent,\r\n    HttpInterceptor,\r\n    HttpHandler,\r\n    HttpRequest,\r\n    HttpErrorResponse\r\n} from '@angular/common/http';\r\nimport { throwError, Observable, BehaviorSubject, of } from 'rxjs';\r\nimport { catchError, filter, finalize, take, switchMap } from 'rxjs/operators';\r\nimport { SessionService } from '../../common/services/session.service';\r\n\r\n@Injectable()\r\nexport class AuthInterceptor implements HttpInterceptor {\r\n    private AUTH_HEADER = 'Authorization';\r\n    private PEPPERI_TOKEN_HEADER = 'PepperiSessionToken';\r\n    private PEPPERI_CONSUMER_KEY_HEADER = 'X-Pepperi-ConsumerKey';\r\n\r\n    // private SESSION_TOKEN_KEY = 'auth_token';\r\n    // private token = 'secrettoken';\r\n    // private refreshTokenInProgress = false;\r\n    // private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);\r\n\r\n    constructor(private sessionService: SessionService) {}\r\n\r\n    // Add authorization token if the token exist.\r\n    private addAuthorizationToken(request: HttpRequest<any>): HttpRequest<any> {\r\n        if (!request.headers.has(this.AUTH_HEADER)) {\r\n            const idpToken = this.sessionService.getIdpToken();\r\n\r\n            if (idpToken) {\r\n                request = request.clone({\r\n                    headers: request.headers.set(this.AUTH_HEADER, `Bearer ${idpToken}`)\r\n                });\r\n            }\r\n        }\r\n\r\n        return request;\r\n    }\r\n\r\n    // Add pepperi consumer token if calling to papi domain.\r\n    private addPepperiConsumerToken(request: HttpRequest<any>): HttpRequest<any> {\r\n        if (!request.headers.has(this.PEPPERI_CONSUMER_KEY_HEADER)) {\r\n            const papiBaseUrl = this.sessionService.getPapiBaseUrl();\r\n\r\n            if (papiBaseUrl && request.url.match(new RegExp(papiBaseUrl, 'g'))) {\r\n                const pepperiConsumerToken = this.sessionService.getPepperiConsumerToken();\r\n                if (pepperiConsumerToken) {\r\n                    request = request.clone({\r\n                        headers: request.headers.set(this.PEPPERI_CONSUMER_KEY_HEADER, pepperiConsumerToken)\r\n                    });\r\n                }\r\n            }\r\n        }\r\n\r\n        return request;\r\n    }\r\n\r\n    // Add web api token if calling to wapi domain.\r\n    private addWebApiToken(request: HttpRequest<any>): HttpRequest<any> {\r\n        if (!request.headers.has(this.PEPPERI_TOKEN_HEADER)) {\r\n            const wapiBaseUrl = this.sessionService.getWapiBaseUrl();\r\n\r\n            if (wapiBaseUrl && request.url.match(new RegExp(wapiBaseUrl, 'g'))) {\r\n                const webApiToken = this.sessionService.gettWapiToken();\r\n                if (webApiToken) {\r\n                    request = request.clone({\r\n                        headers: request.headers.set(this.PEPPERI_TOKEN_HEADER, webApiToken)\r\n                    });\r\n                }\r\n            }\r\n        }\r\n\r\n        return request;\r\n    }\r\n\r\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n        console.warn('AuthInterceptor');\r\n\r\n        // Add content type\r\n        if (!req.headers.has('Content-Type')) {\r\n            req = req.clone({\r\n                headers: req.headers.set('Content-Type', 'application/json')\r\n            });\r\n        }\r\n\r\n        req = this.addAuthorizationToken(req);\r\n\r\n        req = this.addPepperiConsumerToken(req);\r\n\r\n        req = this.addWebApiToken(req);\r\n\r\n        return next.handle(req);\r\n\r\n        // TODO: Check if we need this - this is an advance code that try to refresh the token in case of expired.\r\n        // return next.handle(req).pipe(\r\n        //     catchError((error: HttpErrorResponse) => {\r\n        //         if (error && error.status === 401) {\r\n        //             // 401 errors are most likely going to be because we have an expired token that we need to refresh.\r\n        //             if (this.refreshTokenInProgress) {\r\n        //                 // If refreshTokenInProgress is true, we will wait until refreshTokenSubject has a non-null value\r\n        //                 // which means the new token is ready and we can retry the request again\r\n        //                 return this.refreshTokenSubject.pipe(\r\n        //                     filter(result => result !== null),\r\n        //                     take(1),\r\n        //                     switchMap(() => next.handle(this.addAuthenticationToken(req)))\r\n        //                 );\r\n        //             } else {\r\n        //                 this.refreshTokenInProgress = true;\r\n\r\n        //                 // Set the refreshTokenSubject to null so that subsequent API calls will\r\n        //                 // wait until the new token has been retrieved\r\n        //                 this.refreshTokenSubject.next(null);\r\n\r\n        //                 return this.refreshAccessToken().pipe(\r\n        //                     switchMap((success: boolean) => {\r\n        //                         this.refreshTokenSubject.next(success);\r\n        //                         return next.handle(this.addAuthenticationToken(req));\r\n        //                     }),\r\n        //                     // When the call to refreshToken completes we reset the refreshTokenInProgress to false\r\n        //                     // for the next time the token needs to be refreshed\r\n        //                     finalize(() => (this.refreshTokenInProgress = false))\r\n        //                 );\r\n        //             }\r\n        //         } else {\r\n        //             return throwError(error);\r\n        //         }\r\n        //     })\r\n        // );\r\n    }\r\n\r\n    // private refreshAccessToken(): Observable<any> {\r\n    //     return of('secret token');\r\n    // }\r\n\r\n    // private addAuthenticationToken(request: HttpRequest<any>): HttpRequest<any> {\r\n    //     // If we do not have a token yet then we should not set the header.\r\n    //     // Here we could first retrieve the token from where we store it.\r\n    //     if (!this.token) {\r\n    //         return request;\r\n    //     }\r\n    //     // If you are calling an outside domain then do not add the token.\r\n    //     if (!request.url.match(/www.mydomain.com\\//)) {\r\n    //         return request;\r\n    //     }\r\n    //     return request.clone({\r\n    //         headers: request.headers.set(this.AUTH_HEADER, `Bearer ${this.token}`)\r\n    //     });\r\n    // }\r\n}"]}