ssi-security-commons 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# SsiSecurityCommons
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project ssi-security-commons` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ssi-security-commons`.
+> Note: Don't forget to add `--project ssi-security-commons` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build ssi-security-commons` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build ssi-security-commons`, go to the dist folder `cd dist/ssi-security-commons` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test ssi-security-commons` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2020/lib/alert/alert.component.mjs

@@ -0,0 +1,27 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/button";
+export class AlertComponent {
+    constructor(dialogRef, data) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+    }
+    onConfirm() {
+        this.dialogRef.close(true);
+    }
+    onCancel() {
+        this.dialogRef.close(null);
+    }
+}
+AlertComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AlertComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+AlertComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: AlertComponent, selector: "lib-app-alert", ngImport: i0, template: "<h1 mat-dialog-title>{{data.title?data.title:'Alert'}}</h1>\n<div mat-dialog-content class=\"alert-min-width\">\n    <div>\n        {{data.message}}\n    </div>\n</div>\n<div mat-dialog-actions align=\"end\">\n    <button *ngIf=\"data?.cancelText\" mat-button (click)=\"onCancel()\">{{data.cancelText ? data.cancelText : 'Cancel'}}</button>\n    <button mat-button color=\"primary\" (click)=\"onConfirm()\">{{data.okText ? data.okText : 'OK'}}</button>\n</div>\n", styles: [""], components: [{ type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AlertComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-app-alert', template: "<h1 mat-dialog-title>{{data.title?data.title:'Alert'}}</h1>\n<div mat-dialog-content class=\"alert-min-width\">\n    <div>\n        {{data.message}}\n    </div>\n</div>\n<div mat-dialog-actions align=\"end\">\n    <button *ngIf=\"data?.cancelText\" mat-button (click)=\"onCancel()\">{{data.cancelText ? data.cancelText : 'Cancel'}}</button>\n    <button mat-button color=\"primary\" (click)=\"onConfirm()\">{{data.okText ? data.okText : 'OK'}}</button>\n</div>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/auth-interceptor.service.mjs

@@ -0,0 +1,110 @@
+/* eslint-disable */
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { BehaviorSubject, throwError } from 'rxjs';
+import { catchError, filter, switchMap, take } from 'rxjs/operators';
+import { MessagesService } from './messages.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./crypto.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./session.service";
+export class AuthInterceptor {
+    constructor(cryptoService) {
+        this.cryptoService = cryptoService;
+    }
+    intercept(request, next) {
+        const token = window.localStorage.getItem('TOKEN');
+        console.log(request);
+        console.log(request.headers.get('encrypted'));
+        let encrypt = request.headers.get('encrypted');
+        if (encrypt && encrypt === 'true') {
+            let body = request.body;
+            let bodyStr = JSON.stringify(body);
+            var newBody = {
+                encrypted: this.cryptoService.encrypt(bodyStr)
+            };
+            request = request.clone({
+                body: newBody
+            });
+        }
+        if (token) {
+            request = request.clone({
+                setHeaders: {
+                    Authorization: 'Bearer ' + token,
+                }
+            });
+        }
+        return next.handle(request);
+    }
+}
+AuthInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthInterceptor, deps: [{ token: i1.CryptoService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.CryptoService }]; } });
+export class ResponseInterceptor {
+    constructor(injector, router, sessionService) {
+        this.injector = injector;
+        this.router = router;
+        this.sessionService = sessionService;
+        this.isRefreshing = false;
+        this.refreshTokenSubject = new BehaviorSubject(null);
+        setTimeout(() => {
+            this.messages = this.injector.get(MessagesService);
+        });
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError(error => {
+            if (error instanceof HttpErrorResponse) {
+                console.error(error);
+                if (error.status === 401) {
+                    console.log(this.router.url);
+                    if (this.router.url != '/login') {
+                        console.log('401--->' + request.url);
+                        return this.handle401Error(request, next);
+                    }
+                }
+                else {
+                    this.messages?.showErrorMessage(error);
+                }
+            }
+        }));
+    }
+    handle401Error(request, next) {
+        console.log('handle401Error');
+        console.log(this.isRefreshing);
+        if (!this.isRefreshing) {
+            this.isRefreshing = true;
+            this.refreshTokenSubject.next(null);
+            const refreshToken = this.sessionService.getRefreshToken();
+            console.log(refreshToken);
+            if (refreshToken) {
+                return this.sessionService.getNewToken(refreshToken).pipe(switchMap((res) => {
+                    console.log(res);
+                    this.isRefreshing = false;
+                    this.sessionService.setToken(res.data.accessToken);
+                    this.sessionService.setRefreshToken(res.data.refreshToken);
+                    this.refreshTokenSubject.next(res.data.accessToken);
+                    return next.handle(this.addTokenHeader(request, res.data.accessToken));
+                }), catchError((err) => {
+                    this.isRefreshing = false;
+                    this.sessionService.logout();
+                    this.router.navigate(['/login']);
+                    return throwError(err);
+                }));
+            }
+        }
+        else {
+            return this.refreshTokenSubject.pipe(filter(token => token !== null), take(1), switchMap((token) => next.handle(this.addTokenHeader(request, token))));
+        }
+    }
+    addTokenHeader(request, token) {
+        return request.clone({ headers: request.headers.set('Authorization', 'Bearer ' + token) });
+    }
+}
+ResponseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ResponseInterceptor, deps: [{ token: i0.Injector }, { token: i2.Router }, { token: i3.SessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+ResponseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ResponseInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ResponseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i2.Router }, { type: i3.SessionService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-interceptor.service.js","sourceRoot":"","sources":["../../../../../projects/ssi-security-commons/src/lib/services/auth-interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\nimport { Injectable, Injector } from '@angular/core';\nimport {\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n  HttpInterceptor,\n  HttpErrorResponse,\n  HttpResponse\n} from '@angular/common/http';\nimport { BehaviorSubject, Observable, throwError } from 'rxjs';\nimport { catchError, filter, switchMap, take, tap } from 'rxjs/operators';\nimport { MessagesService } from './messages.service';\nimport { CryptoService } from './crypto.service';\nimport { Router } from '@angular/router';\nimport { SessionService } from './session.service';\n\n\n@Injectable()\nexport class AuthInterceptor implements HttpInterceptor {\n\n  constructor(private cryptoService: CryptoService) { }\n\n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n\n    const token = window.localStorage.getItem('TOKEN');\n\n    console.log(request);\n    console.log(request.headers.get('encrypted'));\n\n    let encrypt = request.headers.get('encrypted');\n    if(encrypt && encrypt === 'true'){\n      let body = request.body;\n      let bodyStr = JSON.stringify(body);\n      var newBody = {\n        encrypted: this.cryptoService.encrypt(bodyStr)\n      }\n      request = request.clone({\n        body: newBody\n      });\n    }\n\n    if (token) {\n      request = request.clone({\n        setHeaders: {\n          Authorization: 'Bearer ' + token,\n        }\n      });\n    }\n    return next.handle(request);\n  }\n}\n\n\n@Injectable()\nexport class ResponseInterceptor implements HttpInterceptor {\n\n  private messages: MessagesService | undefined;\n  private isRefreshing = false;\n  private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);\n\n  constructor(private injector: Injector,\n    private router: Router,\n    private sessionService: SessionService) {\n    setTimeout(() => {\n      this.messages = this.injector.get(MessagesService);\n    })\n  }\n\n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n\n    return next.handle(request).pipe(catchError(error => {\n      if (error instanceof HttpErrorResponse) {\n            console.error(error);\n            if (error.status === 401) {\n              console.log(this.router.url);\n              if (this.router.url != '/login') {\n                  console.log('401--->'+ request.url);\n                  return this.handle401Error(request, next);\n              }\n            } else {\n              this.messages?.showErrorMessage(error);\n            }\n        }\n      })) as Observable<HttpEvent<any>>;\n  }\n\n\n  private handle401Error(request: HttpRequest<any>, next: HttpHandler) {\n    console.log('handle401Error');\n    console.log(this.isRefreshing);\n    if (!this.isRefreshing) {\n        this.isRefreshing = true;\n        this.refreshTokenSubject.next(null);\n        const refreshToken = this.sessionService.getRefreshToken();\n        console.log(refreshToken);\n        if (refreshToken){\n            return this.sessionService.getNewToken(refreshToken).pipe(\n                switchMap((res: any) => {\n                    console.log(res);\n                    this.isRefreshing = false;\n                    this.sessionService.setToken(res.data.accessToken);\n                    this.sessionService.setRefreshToken(res.data.refreshToken);\n                    this.refreshTokenSubject.next(res.data.accessToken);\n                    return next.handle(this.addTokenHeader(request, res.data.accessToken));\n                }),\n                catchError((err) => {\n                    this.isRefreshing = false;\n                    this.sessionService.logout();\n                    this.router.navigate(['/login']);\n                    return throwError(err);\n                })\n            );\n        }\n    } else {\n        return this.refreshTokenSubject.pipe(\n            filter(token => token !== null),\n            take(1),\n            switchMap((token) => next.handle(this.addTokenHeader(request, token)))\n        );\n    }\n  }\n\n  private addTokenHeader(request: HttpRequest<any>, token: string) {\n    return request.clone({ headers: request.headers.set('Authorization', 'Bearer ' + token) });\n  }\n\n}\n\n\n\n\n"]}

package/esm2020/lib/services/crypto.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import * as i0 from "@angular/core";
+export class CryptoService {
+    constructor() {
+        this.secret = '&E)H@McQfThWmZq4';
+        this.configuration = {
+            mode: CryptoJS.mode.ECB
+        };
+        const hash = CryptoJS.SHA1(this.secret);
+        this.key = CryptoJS.lib.WordArray.create(hash.words.slice(0, 16 / 4));
+    }
+    encrypt(text) {
+        return CryptoJS.AES.encrypt(text, this.key, this.configuration).toString();
+    }
+    decrypt(text) {
+        return CryptoJS.AES.decrypt(text, this.key, this.configuration).toString(CryptoJS.enc.Utf8);
+    }
+    encryptWithSecret(text, secret) {
+        const hash = CryptoJS.SHA1(secret);
+        const key = CryptoJS.lib.WordArray.create(hash.words.slice(0, 16 / 4));
+        return CryptoJS.AES.encrypt(text, key, this.configuration).toString();
+    }
+    decryptWithSecret(text, secret) {
+        const hash = CryptoJS.SHA1(secret);
+        const key = CryptoJS.lib.WordArray.create(hash.words.slice(0, 16 / 4));
+        return CryptoJS.AES.decrypt(text, key, this.configuration).toString(CryptoJS.enc.Utf8);
+    }
+}
+CryptoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CryptoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CryptoService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CryptoService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3J5cHRvLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zc2ktc2VjdXJpdHktY29tbW9ucy9zcmMvbGliL3NlcnZpY2VzL2NyeXB0by5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxXQUFXLENBQUM7O0FBR3RDLE1BQU0sT0FBTyxhQUFhO0lBTXhCO1FBRlEsV0FBTSxHQUFHLGtCQUFrQixDQUFDO1FBR2xDLElBQUksQ0FBQyxhQUFhLEdBQUc7WUFDbkIsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRztTQUN4QixDQUFDO1FBQ0YsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDeEMsSUFBSSxDQUFDLEdBQUcsR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3hFLENBQUM7SUFFRCxPQUFPLENBQUMsSUFBWTtRQUNsQixPQUFPLFFBQVEsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUM3RSxDQUFDO0lBRUQsT0FBTyxDQUFDLElBQVk7UUFDbEIsT0FBTyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEdBQUcsRUFBRSxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDOUYsQ0FBQztJQUVELGlCQUFpQixDQUFDLElBQVksRUFBRSxNQUFjO1FBQzVDLE1BQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDbkMsTUFBTSxHQUFHLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN2RSxPQUFPLFFBQVEsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3hFLENBQUM7SUFFRCxpQkFBaUIsQ0FBQyxJQUFZLEVBQUUsTUFBYztRQUM1QyxNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ25DLE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdkUsT0FBTyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN6RixDQUFDOzswR0FoQ1UsYUFBYTs4R0FBYixhQUFhOzJGQUFiLGFBQWE7a0JBRHpCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgKiBhcyBDcnlwdG9KUyBmcm9tICdjcnlwdG8tanMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ3J5cHRvU2VydmljZSB7XG5cbiAgcHJpdmF0ZSBjb25maWd1cmF0aW9uOiBhbnk7XG4gIHByaXZhdGUga2V5OiBhbnk7XG4gIHByaXZhdGUgc2VjcmV0ID0gJyZFKUhATWNRZlRoV21acTQnO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuY29uZmlndXJhdGlvbiA9IHtcbiAgICAgIG1vZGU6IENyeXB0b0pTLm1vZGUuRUNCXG4gICAgfTtcbiAgICBjb25zdCBoYXNoID0gQ3J5cHRvSlMuU0hBMSh0aGlzLnNlY3JldCk7XG4gICAgdGhpcy5rZXkgPSBDcnlwdG9KUy5saWIuV29yZEFycmF5LmNyZWF0ZShoYXNoLndvcmRzLnNsaWNlKDAsIDE2IC8gNCkpO1xuICB9XG5cbiAgZW5jcnlwdCh0ZXh0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBDcnlwdG9KUy5BRVMuZW5jcnlwdCh0ZXh0LCB0aGlzLmtleSwgdGhpcy5jb25maWd1cmF0aW9uKS50b1N0cmluZygpO1xuICB9XG5cbiAgZGVjcnlwdCh0ZXh0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBDcnlwdG9KUy5BRVMuZGVjcnlwdCh0ZXh0LCB0aGlzLmtleSwgdGhpcy5jb25maWd1cmF0aW9uKS50b1N0cmluZyhDcnlwdG9KUy5lbmMuVXRmOCk7XG4gIH1cblxuICBlbmNyeXB0V2l0aFNlY3JldCh0ZXh0OiBzdHJpbmcsIHNlY3JldDogc3RyaW5nKTogc3RyaW5nIHtcbiAgICBjb25zdCBoYXNoID0gQ3J5cHRvSlMuU0hBMShzZWNyZXQpO1xuICAgIGNvbnN0IGtleSA9IENyeXB0b0pTLmxpYi5Xb3JkQXJyYXkuY3JlYXRlKGhhc2gud29yZHMuc2xpY2UoMCwgMTYgLyA0KSk7XG4gICAgcmV0dXJuIENyeXB0b0pTLkFFUy5lbmNyeXB0KHRleHQsIGtleSwgdGhpcy5jb25maWd1cmF0aW9uKS50b1N0cmluZygpO1xuICB9XG5cbiAgZGVjcnlwdFdpdGhTZWNyZXQodGV4dDogc3RyaW5nLCBzZWNyZXQ6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgY29uc3QgaGFzaCA9IENyeXB0b0pTLlNIQTEoc2VjcmV0KTtcbiAgICBjb25zdCBrZXkgPSBDcnlwdG9KUy5saWIuV29yZEFycmF5LmNyZWF0ZShoYXNoLndvcmRzLnNsaWNlKDAsIDE2IC8gNCkpO1xuICAgIHJldHVybiBDcnlwdG9KUy5BRVMuZGVjcnlwdCh0ZXh0LCBrZXksIHRoaXMuY29uZmlndXJhdGlvbikudG9TdHJpbmcoQ3J5cHRvSlMuZW5jLlV0ZjgpO1xuICB9XG5cbn1cbiJdfQ==

package/esm2020/lib/services/messages.service.mjs

@@ -0,0 +1,161 @@
+import { Injectable } from '@angular/core';
+import { AlertComponent } from '../alert/alert.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./session.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/material/snack-bar";
+import * as i4 from "@angular/material/dialog";
+export class MessagesService {
+    constructor(auth, router, snackBar, dialog) {
+        this.auth = auth;
+        this.router = router;
+        this.snackBar = snackBar;
+        this.dialog = dialog;
+    }
+    // eslint-disable-next-line max-lines-per-function
+    showErrorMessage(error) {
+        console.log('error: ', error);
+        const msgs = this.getInterceptorMessages();
+        switch (error.status) {
+            case 302: {
+                this.messageSnackError(error);
+                break;
+            }
+            case 400: {
+                this.showSnackError(error.message, ['snack-error']);
+                break;
+            }
+            case 403: {
+                this.goNavigateLogin(msgs);
+                break;
+            }
+            case 404: {
+                this.showSnackError(msgs.auth_interceptor.not_found, ['snack-error']);
+                break;
+            }
+            case 409: {
+                this.messageAlertDialog(error, msgs);
+                break;
+            }
+            case 412: {
+                this.showSnackError(error.error.responseMessage, ['snack-error']);
+                break;
+            }
+            case 428: {
+                this.showSnackError(error.error.responseMessage, ['snack-error']);
+                break;
+            }
+            case 500: {
+                this.messageAlertDialog(error, msgs);
+                break;
+            }
+            case 503: {
+                this.showSnackError(msgs.auth_interceptor.unavailable, ['snack-error']);
+                break;
+            }
+            case -1: {
+                this.showSnackError(msgs.auth_interceptor.connection_error);
+                break;
+            }
+            case 0: {
+                this.showSnackError(msgs.auth_interceptor.connection_error);
+                break;
+            }
+        }
+    }
+    messageSnackError(error) {
+        const errorMessage = error.error && error.error.responseMessage ? error.error.responseMessage :
+            error.error.message ? error.error.message : error.message;
+        this.showSnackError(errorMessage, ['snack-error']);
+    }
+    goNavigateLogin(msgs) {
+        if (this.router.url !== '/login') {
+            this.showSnackError(msgs.auth_interceptor.session_lost, ['snack-error']);
+            this.router.navigate(['/login']);
+            this.auth.destroyCredentials();
+        }
+    }
+    messageAlertDialog(error, msgs) {
+        console.log(error);
+        let message = '';
+        if (error.error.responseMessage) {
+            message = error.error.responseMessage;
+            if (error.error.exceptionId) {
+                message = message + '\n\n' + msgs.auth_interceptor.code + ': ' + error.error.exceptionId;
+            }
+        }
+        else if (error.error.message) {
+            message = error.error.message;
+            if (error.error.exceptionId) {
+                message = message + '\n\n' + msgs.auth_interceptor.code + ': ' + error.error.exceptionId;
+            }
+        }
+        else if (error.message) {
+            message = error.message;
+            if (error.error.exceptionId) {
+                message = message + '\n\n' + msgs.auth_interceptor.code + ': ' + error.error.exceptionId;
+            }
+        }
+        else {
+            message = msgs.auth_interceptor.message;
+        }
+        this.dialog.open(AlertComponent, {
+            disableClose: true,
+            data: { title: msgs.auth_interceptor.title, message }
+        });
+    }
+    showSnackError(message, panelClass = []) {
+        console.log(message);
+        setTimeout(() => {
+            this.snackBar.open(message, undefined, {
+                duration: 5000,
+                panelClass,
+                verticalPosition: 'top'
+            });
+        });
+    }
+    setInterceptorMessages(message) {
+        this.interceptorMessages = message;
+    }
+    // eslint-disable-next-line max-lines-per-function
+    getInterceptorMessages() {
+        if (!this.interceptorMessages) {
+            const lang = window.localStorage.getItem('LANG');
+            const messagesEn = {
+                auth_interceptor: {
+                    session_lost: 'Session lost, you have to login again.',
+                    not_found: 'Resource not found',
+                    title: 'We are sorry!',
+                    message: 'We had a problem trying to process your request.',
+                    code: 'Code',
+                    unavailable: 'Service unavailable, please try again in a few minutes.',
+                    connection_error: 'Could not connect to server, please check your network connection.'
+                }
+            };
+            const messagesEs = {
+                auth_interceptor: {
+                    session_lost: 'Su sesión expiró, debe iniciar sesión nuevamente.',
+                    not_found: 'Recurso no encontrado',
+                    title: '¡Lo sentimos!',
+                    message: 'Tuvimos un problema al tratar de procesar su solicitud.',
+                    code: 'Código',
+                    unavailable: 'Servicio no disponible, inténtelo de nuevo en unos minutos.',
+                    connection_error: 'No se pudo conectar al servidor, verifique su conexión de red.'
+                }
+            };
+            if (lang && lang === 'es') {
+                this.interceptorMessages = messagesEs;
+            }
+            else {
+                this.interceptorMessages = messagesEn;
+            }
+        }
+        return this.interceptorMessages;
+    }
+}
+MessagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MessagesService, deps: [{ token: i1.SessionService }, { token: i2.Router }, { token: i3.MatSnackBar }, { token: i4.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+MessagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MessagesService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MessagesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.Router }, { type: i3.MatSnackBar }, { type: i4.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"messages.service.js","sourceRoot":"","sources":["../../../../../projects/ssi-security-commons/src/lib/services/messages.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable quote-props */\n/* eslint-disable @typescript-eslint/naming-convention */\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { Router } from '@angular/router';\nimport { AlertComponent } from '../alert/alert.component';\nimport { SessionService } from './session.service';\n\n\n@Injectable()\nexport class MessagesService {\n\n  private interceptorMessages: any;\n\n  constructor(\n    public auth: SessionService,\n    private router: Router,\n    private snackBar: MatSnackBar,\n    public dialog: MatDialog\n  ) { }\n\n\n  // eslint-disable-next-line max-lines-per-function\n  showErrorMessage(error: HttpErrorResponse): void {\n    console.log('error: ', error);\n    const msgs: any = this.getInterceptorMessages();\n    switch (error.status) {\n      case 302: {\n        this.messageSnackError(error);\n        break;\n      }\n      case 400: {\n        this.showSnackError(error.message, ['snack-error']);\n        break;\n      }\n      case 403: {\n        this.goNavigateLogin(msgs);\n        break;\n      }\n      case 404: {\n        this.showSnackError(msgs.auth_interceptor.not_found, ['snack-error']);\n        break;\n      }\n      case 409: {\n        this.messageAlertDialog(error, msgs);\n        break;\n      }\n      case 412: {\n        this.showSnackError(error.error.responseMessage, ['snack-error']);\n        break;\n      }\n      case 428: {\n        this.showSnackError(error.error.responseMessage, ['snack-error']);\n        break;\n      }\n      case 500: {\n        this.messageAlertDialog(error, msgs);\n        break;\n      }\n      case 503: {\n        this.showSnackError(msgs.auth_interceptor.unavailable, ['snack-error']);\n        break;\n      }\n      case -1: {\n        this.showSnackError(msgs.auth_interceptor.connection_error);\n        break;\n      }\n      case 0: {\n        this.showSnackError(msgs.auth_interceptor.connection_error);\n        break;\n      }\n    }\n  }\n\n  messageSnackError(error: any): void {\n    const errorMessage = error.error && error.error.responseMessage ? error.error.responseMessage :\n      error.error.message ? error.error.message : error.message;\n    this.showSnackError(errorMessage, ['snack-error']);\n  }\n\n  goNavigateLogin(msgs: any): void {\n    if (this.router.url !== '/login') {\n      this.showSnackError(msgs.auth_interceptor.session_lost, ['snack-error']);\n      this.router.navigate(['/login']);\n      this.auth.destroyCredentials();\n    }\n  }\n\n  messageAlertDialog(error: any, msgs: any): void {\n    console.log(error);\n    let message = '';\n    if (error.error.responseMessage) {\n      message = error.error.responseMessage;\n      if (error.error.exceptionId)\n      {message = message + '\\n\\n'+msgs.auth_interceptor.code+': ' + error.error.exceptionId;}\n    } else if (error.error.message) {\n      message = error.error.message;\n      if (error.error.exceptionId)\n      {message = message + '\\n\\n'+msgs.auth_interceptor.code+': ' + error.error.exceptionId;}\n    }  else if (error.message) {\n      message = error.message;\n      if (error.error.exceptionId)\n      {message = message + '\\n\\n'+msgs.auth_interceptor.code+': ' + error.error.exceptionId;}\n    } else {\n      message = msgs.auth_interceptor.message;\n    }\n    this.dialog.open(AlertComponent, {\n      disableClose: true,\n      data: { title: msgs.auth_interceptor.title, message }\n    });\n  }\n\n  showSnackError(message: any, panelClass: any[] = []): void {\n    console.log(message);\n    setTimeout(() => {\n      this.snackBar.open(message, undefined, {\n        duration: 5000,\n        panelClass,\n        verticalPosition: 'top'\n      });\n    });\n  }\n\n  setInterceptorMessages(message: any): void {\n    this.interceptorMessages = message;\n  }\n\n  // eslint-disable-next-line max-lines-per-function\n  getInterceptorMessages(): string {\n    if (!this.interceptorMessages) {\n      const lang = window.localStorage.getItem('LANG');\n      const messagesEn = {\n        auth_interceptor : {\n          session_lost :'Session lost, you have to login again.',\n          not_found: 'Resource not found',\n          title: 'We are sorry!',\n          message: 'We had a problem trying to process your request.',\n          code:'Code',\n          unavailable:'Service unavailable, please try again in a few minutes.',\n          connection_error:'Could not connect to server, please check your network connection.'\n        }\n      };\n      const messagesEs = {\n        auth_interceptor: {\n          session_lost: 'Su sesión expiró, debe iniciar sesión nuevamente.',\n          not_found: 'Recurso no encontrado',\n          title: '¡Lo sentimos!',\n          message: 'Tuvimos un problema al tratar de procesar su solicitud.',\n          code: 'Código',\n          unavailable: 'Servicio no disponible, inténtelo de nuevo en unos minutos.',\n          connection_error: 'No se pudo conectar al servidor, verifique su conexión de red.'\n        }\n      };\n      if (lang && lang==='es') {\n        this.interceptorMessages = messagesEs;\n      } else {\n        this.interceptorMessages = messagesEn;\n      }\n    }\n    return this.interceptorMessages;\n  }\n\n}\n"]}

package/esm2020/lib/services/session.service.mjs

@@ -0,0 +1,77 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class SessionService {
+    constructor(http, environment) {
+        this.http = http;
+        this.endPoint = environment.endPoint;
+    }
+    setUserdata(userdata) {
+        this.userdata = userdata;
+    }
+    getUserdata() {
+        return this.userdata;
+    }
+    setRefreshToken(refreshToken) {
+        this.refreshToken = refreshToken;
+        window.localStorage.setItem('REFRESH_TOKEN', refreshToken);
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setToken(token) {
+        this.token = token;
+        window.localStorage.setItem('TOKEN', token);
+    }
+    getToken() {
+        return this.token;
+    }
+    destroyCredentials() {
+        this.token = undefined;
+        this.refreshToken = undefined;
+        window.localStorage.removeItem('TOKEN');
+        window.localStorage.removeItem('REFRESH_TOKEN');
+    }
+    destroyUserData() {
+        this.userdata = undefined;
+        window.localStorage.removeItem('USERDATA');
+    }
+    saveCredentials(token, refreshToken) {
+        this.token = token;
+        this.refreshToken = refreshToken;
+        window.localStorage.setItem('TOKEN', token);
+        window.localStorage.setItem('REFRESH_TOKEN', refreshToken);
+    }
+    saveUserData(userdata) {
+        this.userdata = userdata;
+        window.localStorage.setItem('USERDATA', JSON.stringify(this.userdata));
+    }
+    isLoggedIn() {
+        return !!this.userdata;
+    }
+    logout() {
+        return new Promise((resolve) => {
+            this.destroyCredentials();
+            this.destroyUserData();
+            resolve(null);
+        });
+    }
+    getNewToken(refreshToken) {
+        console.log('getNewToken');
+        const httpOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'application/json' })
+        };
+        return this.http.post(this.endPoint + '/auth/refresh-token', { refreshToken }, httpOptions);
+    }
+}
+SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SessionService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SessionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ssi-security-commons.component.mjs

@@ -0,0 +1,26 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SsiSecurityCommonsComponent {
+    constructor() { }
+    ngOnInit() {
+    }
+}
+SsiSecurityCommonsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SsiSecurityCommonsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SsiSecurityCommonsComponent, selector: "lib-ssi-security-commons", ngImport: i0, template: `
+    <p>
+      ssi-security-commons works!
+    </p>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-ssi-security-commons',
+                    template: `
+    <p>
+      ssi-security-commons works!
+    </p>
+  `,
+                    styles: []
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NpLXNlY3VyaXR5LWNvbW1vbnMuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvc3NpLXNlY3VyaXR5LWNvbW1vbnMvc3JjL2xpYi9zc2ktc2VjdXJpdHktY29tbW9ucy5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQzs7QUFZbEQsTUFBTSxPQUFPLDJCQUEyQjtJQUV0QyxnQkFBZ0IsQ0FBQztJQUVqQixRQUFRO0lBQ1IsQ0FBQzs7d0hBTFUsMkJBQTJCOzRHQUEzQiwyQkFBMkIsZ0VBUjVCOzs7O0dBSVQ7MkZBSVUsMkJBQTJCO2tCQVZ2QyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSwwQkFBMEI7b0JBQ3BDLFFBQVEsRUFBRTs7OztHQUlUO29CQUNELE1BQU0sRUFBRSxFQUNQO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnbGliLXNzaS1zZWN1cml0eS1jb21tb25zJyxcbiAgdGVtcGxhdGU6IGBcbiAgICA8cD5cbiAgICAgIHNzaS1zZWN1cml0eS1jb21tb25zIHdvcmtzIVxuICAgIDwvcD5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgU3NpU2VjdXJpdHlDb21tb25zQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICBjb25zdHJ1Y3RvcigpIHsgfVxuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICB9XG5cbn1cbiJdfQ==

package/esm2020/lib/ssi-security-commons.module.mjs

@@ -0,0 +1,55 @@
+import { NgModule } from '@angular/core';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { CryptoService } from './services/crypto.service';
+import { AlertComponent } from './alert/alert.component';
+import { MessagesService } from './services/messages.service';
+import { SessionService } from './services/session.service';
+import { SsiSecurityCommonsComponent } from './ssi-security-commons.component';
+import { MatButtonModule } from '@angular/material/button';
+import * as i0 from "@angular/core";
+export class SsiSecurityCommonsModule {
+    static forRoot(environment) {
+        return {
+            ngModule: SsiSecurityCommonsModule,
+            providers: [{ provide: 'environment', useValue: environment }]
+        };
+    }
+}
+SsiSecurityCommonsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SsiSecurityCommonsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsModule, declarations: [SsiSecurityCommonsComponent,
+        AlertComponent], imports: [MatSnackBarModule,
+        MatDialogModule,
+        MatButtonModule], exports: [SsiSecurityCommonsComponent] });
+SsiSecurityCommonsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsModule, providers: [
+        MessagesService,
+        SessionService,
+        CryptoService
+    ], imports: [[
+            MatSnackBarModule,
+            MatDialogModule,
+            MatButtonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SsiSecurityCommonsComponent,
+                        AlertComponent
+                    ],
+                    imports: [
+                        MatSnackBarModule,
+                        MatDialogModule,
+                        MatButtonModule
+                    ],
+                    exports: [
+                        SsiSecurityCommonsComponent
+                    ],
+                    providers: [
+                        MessagesService,
+                        SessionService,
+                        CryptoService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ssi-security-commons.service.mjs

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SsiSecurityCommonsService {
+    constructor() { }
+}
+SsiSecurityCommonsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SsiSecurityCommonsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SsiSecurityCommonsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NpLXNlY3VyaXR5LWNvbW1vbnMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3NzaS1zZWN1cml0eS1jb21tb25zL3NyYy9saWIvc3NpLXNlY3VyaXR5LWNvbW1vbnMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8seUJBQXlCO0lBRXBDLGdCQUFnQixDQUFDOztzSEFGTix5QkFBeUI7MEhBQXpCLHlCQUF5QixjQUZ4QixNQUFNOzJGQUVQLHlCQUF5QjtrQkFIckMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFNzaVNlY3VyaXR5Q29tbW9uc1NlcnZpY2Uge1xuXG4gIGNvbnN0cnVjdG9yKCkgeyB9XG59XG4iXX0=

package/esm2020/lib/user.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3NzaS1zZWN1cml0eS1jb21tb25zL3NyYy9saWIvdXNlci5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBVc2VyIHtcbiAgZnVsbG5hbWU6IHN0cmluZztcbiAgbGFuZ3VhZ2U6IHN0cmluZztcbiAgcGVyc29uSWQ6IG51bWJlcjtcbiAgcm9sZXM6IHN0cmluZ1tdO1xuICB1c2VySWQ6IG51bWJlcjtcbiAgdXNlcm5hbWU6IHN0cmluZztcbiAgd29ya1BsYWNlOiBXb3JrUGxhY2U7XG4gIGNoYW5uZWw6IENoYW5uZWw7XG4gIHVzZXJUeXBlPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENoYW5uZWwge1xuICBjaGFubmVsQ29kZTogc3RyaW5nO1xuICBjaGFubmVsRGVzY3JpcHRpb246IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXb3JrUGxhY2Uge1xuICB3b3JrUGxhY2VDb2RlOiBzdHJpbmc7XG4gIHdvcmtQbGFjZURlc2NyaXB0aW9uOiBzdHJpbmc7XG59XG4iXX0=