@falcon-ng/tailwind 0.0.6 → 0.0.7

package/esm2022/lib/service/http/generic-http-client.mjs

@@ -0,0 +1,198 @@
+import { HttpRequest, HttpEventType } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../model/environments";
+import * as i3 from "@angular/material/snack-bar";
+import * as i4 from "../logger.service";
+class GenericHttpClient {
+    constructor(httpClient, environment, _snackBar, logger) {
+        this.httpClient = httpClient;
+        this.environment = environment;
+        this._snackBar = _snackBar;
+        this.logger = logger;
+        this.snackBarViewModel = {};
+        this.isHttpError = false;
+    }
+    /**
+    * @description
+    * Generic Http GET method to Get the response and bind to the view model
+    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+    * @param {IRequestOptions} options options of the request like headers, body, etc.
+    * @returns {Observable<T>}
+    * @usageNotes
+    * The following snippet shows how to use this method
+    * ```ts
+    *    this.genericHttpService.Get("get_url").subscribe(data => {
+    *        console.log('success');
+    *      }, error => {
+    *      console.log(error);
+    *      });
+    * ```
+  */
+    get(destinationUrl, options) {
+        return this.request("GET" /* HttpMethod.Get */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http post method to post the view model and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {
+      *        console.log(item);
+      *      },
+      *      err => {
+      *        console.log(err);
+      *      });
+      * ```
+    */
+    post(destinationUrl, options) {
+        return this.request("POST" /* HttpMethod.Post */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http Put method to post the view model and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Put(post-url, post-view-model).subscribe(item => {
+      *        console.log(item);
+      *      },
+      *      err => {
+      *        console.log(err);
+      *      });
+      * ```
+    */
+    put(destinationUrl, options) {
+        return this.request("PUT" /* HttpMethod.Put */, destinationUrl, options);
+    }
+    /**
+        * @description
+        * Generic Http post method to post the view model and bind the return view model
+        * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+        * @param {IRequestOptions} options options of the request like headers, body, etc.
+        * @returns {Observable<T>}
+        * @usageNotes
+        * The following snippet shows how to use this method
+        * ```ts
+        *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {
+        *        console.log(item);
+        *      },
+        *      err => {
+        *        console.log(err);
+        *      });
+        * ```
+      */
+    patch(destinationUrl, options) {
+        return this.request("PATCH" /* HttpMethod.Patch */, destinationUrl, options);
+    }
+    /**
+      * @description
+      * Generic Http Delete method to Delete the item and bind the return view model
+      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+      * @param {IRequestOptions} options options of the request like headers, body, etc.
+      * @returns {Observable<T>}
+      * @usageNotes
+      * The following snippet shows how to use this method
+      * ```ts
+      *    this.genericHttpClientService.Delete(this.deleteUserUrl).subscribe(item => {
+      *         console.log('success');
+      *      }, error => {
+      *        console.log(error);
+      *      });
+      * ```
+    */
+    delete(destinationUrl, options) {
+        return this.request("DELETE" /* HttpMethod.Delete */, destinationUrl, options);
+    }
+    /**
+        * @description
+        * Http request method to accept different method type and params
+        * @param {string} method Http methods - GET, POST, PUT, DELETE.
+        * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.
+        * @param {IRequestOptions} options options of the request like headers, body, etc.
+        * @returns {Observable<T>}
+        * @usageNotes
+        * The following snippet shows how to use this method
+        * ```ts
+        *    this.request<T>(HttpMethod.Delete, destinationUrl, options);
+        * ```
+      */
+    request(method, url, options) {
+        return Observable.create((observer) => {
+            let destinationUrl = '';
+            if (this.environment.baseUrl != undefined)
+                destinationUrl = (this.environment.baseUrl) + url;
+            else
+                destinationUrl = url;
+            this.httpClient.request(new HttpRequest(method, destinationUrl, options)).subscribe((response) => {
+                const responsTye = response;
+                switch (responsTye.type) {
+                    case HttpEventType.Sent:
+                        this.logger.info('Http Client : Sent ->', 'Request sent!');
+                        break;
+                    case HttpEventType.ResponseHeader:
+                        this.logger.info('Http Client : ResponseHeader ->', 'Response header received!');
+                        break;
+                    case HttpEventType.DownloadProgress:
+                        const kbLoaded = Math.round(responsTye.loaded / 1024);
+                        this.logger.info('Http Client : DownloadProgress ->', `Download in progress! ${kbLoaded}Kb loaded`);
+                        break;
+                    case HttpEventType.Response:
+                        observer.next(response.body);
+                        this.logger.info('Http Client : Response -> 😺 Done!', responsTye.body);
+                }
+            }, (error) => {
+                switch (error.status) {
+                    case 403 /* HttpStatusCode.Forbidden */:
+                        // observer.complete();
+                        this.snackBarViewModel.messageText = 'Access to the requested resource is forbidden.';
+                        this.snackBarViewModel.actionText = 'Forbidden';
+                        this.isHttpError = true;
+                        break;
+                    case 400 /* HttpStatusCode.BadRequest */:
+                        this.snackBarViewModel.messageText = 'Server cannot or will not process the request.';
+                        this.snackBarViewModel.actionText = 'Bad Request';
+                        this.isHttpError = true;
+                        break;
+                    case 401 /* HttpStatusCode.Unauthorized */:
+                        this.snackBarViewModel.messageText = 'Request has not been applied because it lacks valid authentication credentials.';
+                        this.snackBarViewModel.actionText = 'Unauthorized';
+                        this.isHttpError = true;
+                        break;
+                    case 500 /* HttpStatusCode.InternalServerError */:
+                        this.snackBarViewModel.messageText = 'Server encountered an unexpected condition.';
+                        this.snackBarViewModel.actionText = 'Internal server error';
+                        this.isHttpError = true;
+                        break;
+                    case 0:
+                        this.snackBarViewModel.messageText = 'Not connected to the service.';
+                        this.snackBarViewModel.actionText = 'Service not available';
+                        this.isHttpError = true;
+                        break;
+                }
+                observer.error(error);
+                if ((this.environment.snackBarEnable != undefined && this.environment.snackBarEnable) && this.isHttpError)
+                    this._snackBar.open(this.snackBarViewModel.messageText, this.snackBarViewModel.actionText);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: GenericHttpClient, deps: [{ token: i1.HttpClient }, { token: i2.EnvironmentViewModel }, { token: i3.MatSnackBar }, { token: i4.LoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: GenericHttpClient, providedIn: 'root' }); }
+}
+export { GenericHttpClient };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: GenericHttpClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EnvironmentViewModel }, { type: i3.MatSnackBar }, { type: i4.LoggerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-http-client.js","sourceRoot":"","sources":["../../../../../../../projects/falcon-ng/tailwind/src/lib/service/http/generic-http-client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpClient,\n  HttpRequest,\n  HttpEventType,\n  HttpEvent,\n  HttpStatusCode\n} from '@angular/common/http';\nimport { Observable, from } from 'rxjs';\nimport { IGenericHttpClient } from './igeneric-http-client';\nimport { Injectable } from '@angular/core';\nimport {IRequestOptions, SnackbarModel} from '../../model/interface';\nimport { LoggerService } from '../logger.service';\nimport {EnvironmentViewModel} from \"../../model/environments\";\nimport {HttpMethod} from \"../../model/enum\";\nimport {MatSnackBar} from \"@angular/material/snack-bar\";\n@Injectable({\n  providedIn: 'root'\n})\nexport class GenericHttpClient<T> implements IGenericHttpClient<T>{\n  private snackBarViewModel: SnackbarModel = {} as SnackbarModel;\n  private isHttpError: boolean = false;\n\n  constructor(private httpClient: HttpClient, private environment: EnvironmentViewModel,\n    private _snackBar: MatSnackBar, private logger: LoggerService) { }\n\n\n  /**\n  * @description\n  * Generic Http GET method to Get the response and bind to the view model\n  * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n  * @param {IRequestOptions} options options of the request like headers, body, etc.\n  * @returns {Observable<T>}\n  * @usageNotes\n  * The following snippet shows how to use this method\n  * ```ts\n  *    this.genericHttpService.Get(\"get_url\").subscribe(data => {\n  *        console.log('success');\n  *      }, error => {\n  *      console.log(error);\n  *      });\n  * ```\n*/\n  public get(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Get, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http post method to post the view model and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {\n    *        console.log(item);\n    *      },\n    *      err => {\n    *        console.log(err);\n    *      });\n    * ```\n  */\n  public post(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Post, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http Put method to post the view model and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Put(post-url, post-view-model).subscribe(item => {\n    *        console.log(item);\n    *      },\n    *      err => {\n    *        console.log(err);\n    *      });\n    * ```\n  */\n  public put(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Put, destinationUrl, options);\n  }\n\n  /**\n      * @description\n      * Generic Http post method to post the view model and bind the return view model\n      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n      * @param {IRequestOptions} options options of the request like headers, body, etc.\n      * @returns {Observable<T>}\n      * @usageNotes\n      * The following snippet shows how to use this method\n      * ```ts\n      *    this.genericHttpClientService.Post(post-url,post-view-model).subscribe(item => {\n      *        console.log(item);\n      *      },\n      *      err => {\n      *        console.log(err);\n      *      });\n      * ```\n    */\n  public patch(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Patch, destinationUrl, options);\n  }\n\n  /**\n    * @description\n    * Generic Http Delete method to Delete the item and bind the return view model\n    * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n    * @param {IRequestOptions} options options of the request like headers, body, etc.\n    * @returns {Observable<T>}\n    * @usageNotes\n    * The following snippet shows how to use this method\n    * ```ts\n    *    this.genericHttpClientService.Delete(this.deleteUserUrl).subscribe(item => {\n    *         console.log('success');\n    *      }, error => {\n    *        console.log(error);\n    *      });\n    * ```\n  */\n  public delete(destinationUrl: string, options?: IRequestOptions | any): Observable<T> {\n    return this.request<T>(HttpMethod.Delete, destinationUrl, options);\n  }\n  \n  /**\n      * @description\n      * Http request method to accept different method type and params\n      * @param {string} method Http methods - GET, POST, PUT, DELETE.\n      * @param {string} destinationUrl endPoint it doesn't need / in front of the end point.\n      * @param {IRequestOptions} options options of the request like headers, body, etc.\n      * @returns {Observable<T>}\n      * @usageNotes\n      * The following snippet shows how to use this method\n      * ```ts\n      *    this.request<T>(HttpMethod.Delete, destinationUrl, options);\n      * ```\n    */\n  private request<T>(method: string, url: string, options?: IRequestOptions): Observable<T> {\n    return Observable.create((observer: any) => {\n      let destinationUrl = '';\n      if (this.environment.baseUrl != undefined)\n        destinationUrl = (this.environment.baseUrl) + url\n      else\n        destinationUrl = url\n      this.httpClient.request<T>(new HttpRequest(method, destinationUrl, options)).subscribe(\n        (response: any) => {\n          const responsTye = response as HttpEvent<any>\n          switch (responsTye.type) {\n            case HttpEventType.Sent:\n              this.logger.info('Http Client : Sent ->', 'Request sent!');\n              break;\n            case HttpEventType.ResponseHeader:\n              this.logger.info('Http Client : ResponseHeader ->', 'Response header received!');\n              break;\n            case HttpEventType.DownloadProgress:\n              const kbLoaded = Math.round(responsTye.loaded / 1024);\n              this.logger.info('Http Client : DownloadProgress ->', `Download in progress! ${kbLoaded}Kb loaded`);\n              break;\n            case HttpEventType.Response:\n              observer.next(response.body);\n              this.logger.info('Http Client : Response -> 😺 Done!', responsTye.body);\n          }\n        },\n        (error) => {\n          switch (error.status) {\n            case HttpStatusCode.Forbidden:\n              // observer.complete();\n              this.snackBarViewModel.messageText = 'Access to the requested resource is forbidden.';\n              this.snackBarViewModel.actionText = 'Forbidden';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.BadRequest:\n              this.snackBarViewModel.messageText = 'Server cannot or will not process the request.';\n              this.snackBarViewModel.actionText = 'Bad Request';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.Unauthorized:\n              this.snackBarViewModel.messageText = 'Request has not been applied because it lacks valid authentication credentials.';\n              this.snackBarViewModel.actionText = 'Unauthorized';\n              this.isHttpError = true;\n              break;\n            case HttpStatusCode.InternalServerError:\n              this.snackBarViewModel.messageText = 'Server encountered an unexpected condition.';\n              this.snackBarViewModel.actionText = 'Internal server error';\n              this.isHttpError = true;\n              break;\n            case 0:\n              this.snackBarViewModel.messageText = 'Not connected to the service.';\n              this.snackBarViewModel.actionText = 'Service not available';\n              this.isHttpError = true;\n              break;\n          }\n          observer.error(error);\n          if ((this.environment.snackBarEnable != undefined && this.environment.snackBarEnable) && this.isHttpError)\n            this._snackBar.open(this.snackBarViewModel.messageText, this.snackBarViewModel.actionText);\n        }\n      );\n    });\n  }\n}\n"]}

package/esm2022/lib/service/http/igeneric-http-client.mjs

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class IGenericHttpClient {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: IGenericHttpClient, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: IGenericHttpClient }); }
+}
+export { IGenericHttpClient };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: IGenericHttpClient, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/logger.service.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class LoggerService {
+    constructor() {
+        this.initialized = false;
+        this._level = "Warnings" /* LoggingLevel.Warnings */;
+    }
+    async initialize(appSettings) {
+        if (this.initialized)
+            return;
+        this._level = appSettings.loggingLevel;
+        this.initialized = true;
+    }
+    log(message, level = "Warnings" /* LoggingLevel.Warnings */, ...optionalParams) {
+        if (this.shouldLog(level)) {
+            switch (level) {
+                case "Errors" /* LoggingLevel.Errors */:
+                    console.error(message, optionalParams);
+                    break;
+                case "Warnings" /* LoggingLevel.Warnings */:
+                    console.warn(message, optionalParams);
+                    break;
+                case "Info" /* LoggingLevel.Info */:
+                    console.info(message, optionalParams);
+                    break;
+                default:
+                    console.debug(message, optionalParams);
+            }
+        }
+    }
+    shouldLog(level) {
+        if (this._level === "None" /* LoggingLevel.None */) {
+            return false;
+        }
+        else if (this._level === "Errors" /* LoggingLevel.Errors */) {
+            return level === "Errors" /* LoggingLevel.Errors */;
+        }
+        else if (this._level === "Warnings" /* LoggingLevel.Warnings */) {
+            return level === "Errors" /* LoggingLevel.Errors */ || level === "Warnings" /* LoggingLevel.Warnings */;
+        }
+        else if (this._level === "Info" /* LoggingLevel.Info */) {
+            return level === "Errors" /* LoggingLevel.Errors */ || level === "Warnings" /* LoggingLevel.Warnings */ || level === "Info" /* LoggingLevel.Info */;
+        }
+        else {
+            return true;
+        }
+    }
+    error(message, ...optionalParams) {
+        this.log(message, "Errors" /* LoggingLevel.Errors */, optionalParams);
+    }
+    warning(message, ...optionalParams) {
+        this.log(message, "Warnings" /* LoggingLevel.Warnings */, optionalParams);
+    }
+    info(message, ...optionalParams) {
+        this.log(message, "Info" /* LoggingLevel.Info */, optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this.log(message, "Verbose" /* LoggingLevel.Verbose */, optionalParams);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LoggerService, providedIn: 'root' }); }
+}
+export { LoggerService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+export function loggerServiceFactory(loggerService, appSettings) {
+    return async () => {
+        appSettings.isServiceReady.subscribe(item => {
+            if (item)
+                loggerService.initialize(appSettings.getAppsettingValue());
+        });
+    };
+}
+;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/open-id/TokenHelperService.mjs

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class TokenHelperService {
+    constructor() { }
+    getTokenExpirationDate(dataIdToken) {
+        if (!dataIdToken.hasOwnProperty('exp')) {
+            return new Date();
+        }
+        const date = new Date(0); // The 0 here is the key, which sets the date to the epoch
+        date.setUTCSeconds(dataIdToken.exp);
+        return date;
+    }
+    getPayloadFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[1];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    getHeaderFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[0];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    getSignatureFromToken(token, encode) {
+        let data = {};
+        if (typeof token !== 'undefined') {
+            const encoded = token.split('.')[2];
+            if (encode) {
+                return encoded;
+            }
+            data = JSON.parse(this.urlBase64Decode(encoded));
+        }
+        return data;
+    }
+    urlBase64Decode(str) {
+        let output = str.replace('-', '+').replace('_', '/');
+        switch (output.length % 4) {
+            case 0:
+                break;
+            case 2:
+                output += '==';
+                break;
+            case 3:
+                output += '=';
+                break;
+            default:
+                throw Error('Illegal base64url string!');
+        }
+        return window.atob(output);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: TokenHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: TokenHelperService, providedIn: 'root' }); }
+}
+export { TokenHelperService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: TokenHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/open-id/auth-guard.service.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+class AuthGuardService {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    canActivate(route, state) {
+        return new Promise(resolve => {
+            this.authService.isServiceReady().then(() => {
+                if (this.authService.isLoggedIn()) {
+                    resolve(true);
+                }
+                else {
+                    this.authService.startAuthentication(state.url);
+                    resolve(false);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthGuardService, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthGuardService, providedIn: 'root' }); }
+}
+export { AuthGuardService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthGuardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/open-id/auth.service.mjs

@@ -0,0 +1,155 @@
+import { Injectable } from '@angular/core';
+import { UserManager } from 'oidc-client';
+import * as i0 from "@angular/core";
+import * as i1 from "../logger.service";
+import * as i2 from "./TokenHelperService";
+class AuthService {
+    static { this.USER_LOADED_EVENT = "USER_LOADED"; }
+    static { this.USER_UNLOADED_EVENT = "USER_UNLOADED"; }
+    constructor(logger, tokenHelperService) {
+        this.logger = logger;
+        this.tokenHelperService = tokenHelperService;
+        this.initialized = false;
+        this.signingOut = false;
+    }
+    async initialize(environment) {
+        if (this.initialized)
+            return;
+        this.settings = this.getClientSettings(environment);
+        this.userManager = new UserManager(this.settings);
+        this.userManager.events.addUserLoaded(user => {
+            this.user = user;
+        });
+        this.userManager.events.addAccessTokenExpiring(() => {
+            this.logger.info("IdSvr token expiring " + new Date().toLocaleString());
+        });
+        this.userManager.events.addAccessTokenExpired(() => {
+            this.logger.info("IdSvr token expired " + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.userManager.events.addSilentRenewError(e => {
+            this.logger.error("IdSvr silent renew error " + e.message + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.userManager.events.addUserLoaded(user => {
+            this.logger.info("IdSvr user session is ready " + new Date().toLocaleString());
+            this.accessToken = this.tokenHelperService.getPayloadFromToken(user.access_token, false);
+            this.user = user;
+        });
+        this.userManager.events.addUserUnloaded(() => {
+            this.logger.info("IdSvr user session has ended " + new Date().toLocaleString());
+            if (!this.signingOut) {
+                this.startAuthentication(window.location.pathname + window.location.search);
+            }
+        });
+        this.userManager.events.addUserSignedOut(() => {
+            this.logger.info("IdSvr user signed out " + new Date().toLocaleString());
+            this.logout(false);
+        });
+        this.user = await this.userManager.getUser();
+        this.initialized = true;
+    }
+    isLoggedIn() {
+        return this.user != null && !this.user.expired;
+    }
+    getUser() {
+        return this.userManager.getUser();
+    }
+    getProfile() {
+        return this.user.profile;
+    }
+    getClaims() {
+        return this.user.profile;
+    }
+    getAuthorizationHeaderValue() {
+        if (this.user != null)
+            return `${this.user.token_type} ${this.user.access_token}`;
+        return '';
+    }
+    getAccessToken() {
+        return this.accessToken || this.tokenHelperService.getPayloadFromToken(this.user.access_token, false);
+        ;
+    }
+    async startAuthentication(returnUrl) {
+        this.logger.info("[AuthService] startAuthentication", returnUrl);
+        await this.userManager.clearStaleState();
+        await this.userManager.signinRedirect({ data: { returnUrl: returnUrl } }).catch(err => {
+            //this.$log.debug("IdSvr sign in failed", err);
+            return err;
+        });
+    }
+    async completeAuthentication() {
+        this.logger.info("[AuthService] completeAuthentication");
+        let user = await new Promise((resolve, reject) => {
+            this.userManager.signinRedirectCallback().then(user => {
+                resolve(user);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+        this.user = user;
+        return this.user;
+    }
+    login() {
+        return this.userManager.signinRedirect();
+    }
+    renewToken() {
+        return this.userManager.signinSilent();
+    }
+    logout(signoutRedirect) {
+        if (signoutRedirect === undefined || signoutRedirect !== false) {
+            this.signingOut = true;
+            signoutRedirect = true;
+        }
+        return this.userManager.signoutRedirect();
+    }
+    getClientSettings(environment) {
+        return {
+            authority: environment?.openID?.authority,
+            client_id: environment?.openID?.client_id,
+            redirect_uri: environment?.openID?.redirect_uri,
+            post_logout_redirect_uri: environment?.openID?.post_logout_redirect_uri,
+            response_type: environment?.openID?.response_type,
+            scope: environment?.openID?.scope,
+            filterProtocolClaims: environment?.openID?.filterProtocolClaims,
+            loadUserInfo: true,
+            monitorSession: true,
+            silent_redirect_uri: environment?.openID?.silent_redirect_uri,
+            automaticSilentRenew: environment?.openID?.automaticSilentRenew,
+            accessTokenExpiringNotificationTime: 20,
+            checkSessionInterval: 2000,
+            silentRequestTimeout: 20000,
+        };
+    }
+    async isServiceReady() {
+        return new Promise(async (resolve, reject) => {
+            if (this.initialized) {
+                this.logger.info("[AuthService] isServiceReady", true);
+                resolve(true);
+            }
+            else {
+                this.logger.info("[AuthService] isServiceReady", false);
+                reject(false);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthService, deps: [{ token: i1.LoggerService }, { token: i2.TokenHelperService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+export { AuthService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LoggerService }, { type: i2.TokenHelperService }]; } });
+export function authServiceFactory(authService, appSettings, environment) {
+    return async () => {
+        appSettings.isServiceReady.subscribe(item => {
+            if (item)
+                authService.initialize(environment);
+        });
+    };
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../projects/falcon-ng/tailwind/src/lib/service/open-id/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {Profile, User, UserManager, UserManagerSettings} from 'oidc-client';\nimport {LoggerService} from '../logger.service';\nimport {TokenHelperService} from './TokenHelperService';\nimport {EnvironmentViewModel} from \"../../model/environments\";\nimport {AppSettingService} from \"../appsetting.service\";\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthService {\n  static USER_LOADED_EVENT = \"USER_LOADED\";\n  static USER_UNLOADED_EVENT = \"USER_UNLOADED\";\n\n  private initialized: boolean = false;\n  private userManager!: UserManager;\n  private user: any;\n  public settings!: UserManagerSettings;\n\n  private accessToken!: Object;\n  private signingOut: boolean = false;\n\n  constructor(private logger: LoggerService, private tokenHelperService: TokenHelperService) {\n\n  }\n\n  async initialize(environment: EnvironmentViewModel): Promise<void> {\n    if (this.initialized) return;\n    this.settings = this.getClientSettings(environment);\n    this.userManager = new UserManager(this.settings);\n    this.userManager.events.addUserLoaded(user => {\n      this.user = user;\n    });\n\n\n    this.userManager.events.addAccessTokenExpiring(() => {\n      this.logger.info(\"IdSvr token expiring \" + new Date().toLocaleString());\n    });\n\n    this.userManager.events.addAccessTokenExpired(() => {\n      this.logger.info(\"IdSvr token expired \" + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.userManager.events.addSilentRenewError(e => {\n      this.logger.error(\"IdSvr silent renew error \" + e.message + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.userManager.events.addUserLoaded(user => {\n      this.logger.info(\"IdSvr user session is ready \" + new Date().toLocaleString());\n      this.accessToken = this.tokenHelperService.getPayloadFromToken(user.access_token, false);\n      this.user = user;\n    });\n\n    this.userManager.events.addUserUnloaded(() => {\n      this.logger.info(\"IdSvr user session has ended \" + new Date().toLocaleString());\n\n      if (!this.signingOut) {\n        this.startAuthentication(window.location.pathname + window.location.search);\n      }\n    });\n\n    this.userManager.events.addUserSignedOut(() => {\n      this.logger.info(\"IdSvr user signed out \" + new Date().toLocaleString());\n      this.logout(false);\n    });\n\n    this.user = await this.userManager.getUser();\n    this.initialized = true;\n  }\n\n  public isLoggedIn(): boolean {\n    return this.user != null && !this.user.expired;\n  }\n\n  public getUser(): Promise<User | null> {\n    return this.userManager.getUser();\n  }\n\n  public getProfile(): Profile {\n    return this.user.profile;\n  }\n\n  public getClaims(): Profile {\n    return this.user.profile;\n  }\n\n  public getAuthorizationHeaderValue(): string {\n    if (this.user != null)\n      return `${this.user.token_type} ${this.user.access_token}`;\n    return '';\n  }\n\n  getAccessToken(): any {\n    return this.accessToken || this.tokenHelperService.getPayloadFromToken(this.user.access_token, false);\n    ;\n  }\n\n  async startAuthentication(returnUrl: string): Promise<void> {\n    this.logger.info(\"[AuthService] startAuthentication\", returnUrl);\n    await this.userManager.clearStaleState();\n    await this.userManager.signinRedirect({data: {returnUrl: returnUrl}}).catch(err => {\n      //this.$log.debug(\"IdSvr sign in failed\", err);\n      return err;\n    });\n  }\n\n  async completeAuthentication(): Promise<Oidc.User> {\n    this.logger.info(\"[AuthService] completeAuthentication\");\n    let user = await new Promise<Oidc.User>((resolve, reject) => {\n      this.userManager.signinRedirectCallback().then(user => {\n        resolve(user)\n      }).catch(error => {\n        reject(error);\n      });\n    });\n    this.user = user;\n    return this.user;\n  }\n\n  public login(): Promise<void> {\n    return this.userManager.signinRedirect();\n  }\n\n  public renewToken(): Promise<User> {\n    return this.userManager.signinSilent();\n  }\n\n  public logout(signoutRedirect?: boolean): Promise<void> {\n\n    if (signoutRedirect === undefined || signoutRedirect !== false) {\n      this.signingOut = true;\n      signoutRedirect = true;\n    }\n\n    return this.userManager.signoutRedirect();\n  }\n\n  private getClientSettings(environment: EnvironmentViewModel): UserManagerSettings {\n    return {\n      authority: environment?.openID?.authority,\n      client_id: environment?.openID?.client_id,\n      redirect_uri: environment?.openID?.redirect_uri,\n      post_logout_redirect_uri: environment?.openID?.post_logout_redirect_uri,\n      response_type: environment?.openID?.response_type,\n      scope: environment?.openID?.scope,\n      filterProtocolClaims: environment?.openID?.filterProtocolClaims,\n      loadUserInfo: true,\n      monitorSession: true,\n      silent_redirect_uri: environment?.openID?.silent_redirect_uri,\n      automaticSilentRenew: environment?.openID?.automaticSilentRenew,\n      accessTokenExpiringNotificationTime: 20, //default 60\n      checkSessionInterval: 2000, //default 2000\n      silentRequestTimeout: 20000,\n    };\n  }\n\n  async isServiceReady(): Promise<boolean> {\n    return new Promise(async (resolve, reject) => {\n      if (this.initialized) {\n        this.logger.info(\"[AuthService] isServiceReady\", true);\n        resolve(true);\n      } else {\n        this.logger.info(\"[AuthService] isServiceReady\", false);\n        reject(false);\n      }\n    });\n  }\n}\n\nexport function authServiceFactory(authService: AuthService, appSettings: AppSettingService, environment: EnvironmentViewModel) {\n  return async () => {\n    appSettings.isServiceReady.subscribe(item => {\n      if (item)\n        authService.initialize(environment);\n    });\n  }\n};"]}