@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm2015/core/gipi-components/services/base.service.js

@@ -0,0 +1,102 @@
+import { __decorate, __metadata } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { ChangeDetectorRef, Injectable, Injector, OnDestroy } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Router } from '@angular/router';
+import { ConfirmationService } from '../../services/confirmation.service';
+import { DialogService } from '../../services/dialog.service';
+import { MessageService } from '../../services/message.service';
+import { ObjectUtil } from '../../utils/object.util';
+import { GIPIFileService } from './file.service';
+import { GIPISessionStorageService } from './session-storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+let GIPIBaseService = class GIPIBaseService {
+    constructor(_injector, _router) {
+        this._injector = _injector;
+        this._router = _router;
+        this._sessionStorageService = null;
+        this._confirmationService = null;
+        this._messageService = null;
+        this._dialogService = null;
+        this._fileService = null;
+        this._matDialog = null;
+        this._httpClient = null;
+        this._changeDetectorRef = null;
+        this._matSnackBar = null;
+    }
+    ngOnDestroy() { }
+    get sessionStorageService() {
+        if (ObjectUtil.isNull(this._sessionStorageService)) {
+            this._sessionStorageService = this._injector.get(GIPISessionStorageService);
+        }
+        return this._sessionStorageService;
+    }
+    get confirmationService() {
+        if (ObjectUtil.isNull(this._confirmationService)) {
+            this._confirmationService = this._injector.get(ConfirmationService);
+        }
+        return this._confirmationService;
+    }
+    get messageService() {
+        if (ObjectUtil.isNull(this._messageService)) {
+            this._messageService = this._injector.get(MessageService);
+        }
+        return this._messageService;
+    }
+    get dialogService() {
+        if (ObjectUtil.isNull(this._dialogService)) {
+            this._dialogService = this._injector.get(DialogService);
+        }
+        return this._dialogService;
+    }
+    get fileService() {
+        if (ObjectUtil.isNull(this._fileService)) {
+            this._fileService = this._injector.get(GIPIFileService);
+        }
+        return this._fileService;
+    }
+    get matDialog() {
+        if (ObjectUtil.isNull(this._matDialog)) {
+            this._matDialog = this._injector.get(MatDialog);
+        }
+        return this._matDialog;
+    }
+    get httpClient() {
+        if (ObjectUtil.isNull(this._httpClient)) {
+            this._httpClient = this._injector.get(HttpClient);
+        }
+        return this._httpClient;
+    }
+    get router() {
+        if (ObjectUtil.isNull(this._router)) {
+            this._router = this._injector.get(Router);
+        }
+        return this._router;
+    }
+    get changeDetectorRef() {
+        if (ObjectUtil.isNull(this._changeDetectorRef)) {
+            this._changeDetectorRef = this._injector.get(ChangeDetectorRef);
+        }
+        return this._changeDetectorRef;
+    }
+    get matSnackBar() {
+        if (ObjectUtil.isNull(this._matSnackBar)) {
+            this._matSnackBar = this._injector.get(MatSnackBar);
+        }
+        return this._matSnackBar;
+    }
+};
+GIPIBaseService.ctorParameters = () => [
+    { type: Injector },
+    { type: Router }
+];
+GIPIBaseService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function GIPIBaseService_Factory() { return new GIPIBaseService(i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.Router)); }, token: GIPIBaseService, providedIn: "root" });
+GIPIBaseService = __decorate([
+    Injectable({ providedIn: 'root' }),
+    __metadata("design:paramtypes", [Injector,
+        Router])
+], GIPIBaseService);
+export { GIPIBaseService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.service.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/gipi-components/services/base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { ChangeDetectorRef, Injectable, Injector, OnDestroy } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { Router } from '@angular/router';\n\nimport { ConfirmationService } from '../../services/confirmation.service';\nimport { DialogService } from '../../services/dialog.service';\nimport { MessageService } from '../../services/message.service';\nimport { ObjectUtil } from '../../utils/object.util';\nimport { GIPIFileService } from './file.service';\nimport { GIPISessionStorageService } from './session-storage.service';\n\n@Injectable({ providedIn: 'root' })\nexport class GIPIBaseService implements OnDestroy {\n\n    private _sessionStorageService: GIPISessionStorageService = null;\n    private _confirmationService: ConfirmationService = null;\n    private _messageService: MessageService = null;\n    private _dialogService: DialogService = null;\n    private _fileService: GIPIFileService = null;\n    private _matDialog: MatDialog = null;\n    private _httpClient: HttpClient = null;\n    private _changeDetectorRef: ChangeDetectorRef = null;\n    private _matSnackBar: MatSnackBar = null;\n\n    constructor(\n        private _injector: Injector,\n        private _router: Router,\n    ) { }\n\n    ngOnDestroy(): void { }\n\n    get sessionStorageService(): GIPISessionStorageService {\n        if (ObjectUtil.isNull(this._sessionStorageService)) {\n            this._sessionStorageService = this._injector.get(GIPISessionStorageService);\n        }\n        return this._sessionStorageService;\n    }\n\n    get confirmationService(): ConfirmationService {\n        if (ObjectUtil.isNull(this._confirmationService)) {\n            this._confirmationService = this._injector.get(ConfirmationService);\n        }\n        return this._confirmationService;\n    }\n\n    get messageService(): MessageService {\n        if (ObjectUtil.isNull(this._messageService)) {\n            this._messageService = this._injector.get(MessageService);\n        }\n        return this._messageService;\n    }\n\n    get dialogService(): DialogService {\n        if (ObjectUtil.isNull(this._dialogService)) {\n            this._dialogService = this._injector.get(DialogService);\n        }\n        return this._dialogService;\n    }\n\n    get fileService(): GIPIFileService {\n        if (ObjectUtil.isNull(this._fileService)) {\n            this._fileService = this._injector.get(GIPIFileService);\n        }\n        return this._fileService;\n    }\n\n    get matDialog(): MatDialog {\n        if (ObjectUtil.isNull(this._matDialog)) {\n            this._matDialog = this._injector.get(MatDialog);\n        }\n        return this._matDialog;\n    }\n\n    get httpClient(): HttpClient {\n        if (ObjectUtil.isNull(this._httpClient)) {\n            this._httpClient = this._injector.get(HttpClient);\n        }\n        return this._httpClient;\n    }\n\n    get router(): Router {\n        if (ObjectUtil.isNull(this._router)) {\n            this._router = this._injector.get(Router);\n        }\n        return this._router;\n    }\n\n    get changeDetectorRef(): ChangeDetectorRef {\n        if (ObjectUtil.isNull(this._changeDetectorRef)) {\n            this._changeDetectorRef = this._injector.get(ChangeDetectorRef);\n        }\n        return this._changeDetectorRef;\n    }\n\n    get matSnackBar(): MatSnackBar {\n        if (ObjectUtil.isNull(this._matSnackBar)) {\n            this._matSnackBar = this._injector.get(MatSnackBar);\n        }\n        return this._matSnackBar;\n    }\n\n}\n"]}

package/esm2015/core/gipi-components/services/file.service.js

@@ -0,0 +1,51 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+let GIPIFileService = class GIPIFileService {
+    constructor() { }
+    download(data, fileName, mimeType) {
+        const blob = new Blob([data], { type: mimeType });
+        const link = document.createElement('a');
+        if (link.download !== undefined) {
+            const url = URL.createObjectURL(blob);
+            link.setAttribute('href', url);
+            link.setAttribute('download', fileName);
+            link.style.visibility = 'hidden';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    }
+    downloadContent(response) {
+        this.download(response.body, response.headers.get('content-disposition').split(';')[1].split('filename')[1].split('=')[1].trim(), response.headers.get('content-type'));
+    }
+    printArchive(data, mimeType) {
+        const blob = new Blob([data], { type: mimeType });
+        const url = URL.createObjectURL(blob);
+        const htmlIFrameElement = document.createElement('iframe');
+        document.body.appendChild(htmlIFrameElement);
+        htmlIFrameElement.style.display = 'none';
+        htmlIFrameElement.style.position = 'fixed';
+        htmlIFrameElement.style.right = '0';
+        htmlIFrameElement.style.bottom = '0';
+        htmlIFrameElement.style.width = '0';
+        htmlIFrameElement.style.height = '0';
+        htmlIFrameElement.style.border = '0';
+        htmlIFrameElement.src = url;
+        htmlIFrameElement.onload = () => {
+            setTimeout(() => {
+                htmlIFrameElement.focus();
+                htmlIFrameElement.contentWindow.print();
+            }, 1);
+        };
+    }
+};
+GIPIFileService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function GIPIFileService_Factory() { return new GIPIFileService(); }, token: GIPIFileService, providedIn: "root" });
+GIPIFileService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], GIPIFileService);
+export { GIPIFileService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/core/gipi-components/services/session-storage.service.js

@@ -0,0 +1,44 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { ObjectUtil } from '../../utils/object.util';
+import * as i0 from "@angular/core";
+let GIPISessionStorageService = class GIPISessionStorageService {
+    constructor() {
+        this._storage = window.sessionStorage;
+    }
+    set(key, value) {
+        if (this._storage) {
+            this._storage.setItem(key, JSON.stringify(value));
+            return true;
+        }
+        return false;
+    }
+    get(key) {
+        if (this._storage) {
+            const json = JSON.parse(this._storage.getItem(key));
+            return !ObjectUtil.isNull(json) ? json : null;
+        }
+        return null;
+    }
+    remove(key) {
+        if (this._storage) {
+            this._storage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+    clear() {
+        if (this._storage) {
+            this._storage.clear();
+            return true;
+        }
+        return false;
+    }
+};
+GIPISessionStorageService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function GIPISessionStorageService_Factory() { return new GIPISessionStorageService(); }, token: GIPISessionStorageService, providedIn: "root" });
+GIPISessionStorageService = __decorate([
+    Injectable({ providedIn: 'root' }),
+    __metadata("design:paramtypes", [])
+], GIPISessionStorageService);
+export { GIPISessionStorageService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/core/gipi-components/types/generic.type.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJpYy50eXBlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9naXBpLWNvbXBvbmVudHMvdHlwZXMvZ2VuZXJpYy50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBHSVBJR2VuZXJpY1R5cGU8VDEsIFQyPiA9IChUMSBleHRlbmRzIHZvaWQgPyAoVDIgZXh0ZW5kcyB2b2lkID8gYW55IDogVDIpIDogVDEpO1xuIl19

package/esm2015/core/gipi-components/types/uuid.type.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXVpZC50eXBlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9naXBpLWNvbXBvbmVudHMvdHlwZXMvdXVpZC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBHSVBJVXVpZCA9IG51bWJlciB8IHN0cmluZztcbiJdfQ==

package/esm2015/core/guards/auth.guard.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AuthenticationService } from '../services/authentication.service';
+import { ObjectUtil } from '../utils/object.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../services/authentication.service";
+let AuthGuard = class AuthGuard {
+    constructor(router, authenticationService) {
+        this.router = router;
+        this.authenticationService = authenticationService;
+    }
+    canActivate(route, state) {
+        if (!ObjectUtil.isNull(this.authenticationService.tokenValueLocalStorage)) {
+            return this.authenticationService.token.pipe(map(token => {
+                if (this.authenticationService.isValidToken(token)) {
+                    return true;
+                }
+                else if (!ObjectUtil.isNull(token)) {
+                    this.authenticationService.removeToken();
+                }
+                this.router.navigate(['oauth/login'], { queryParams: { returnUrl: state.url } });
+                return false;
+            }));
+        }
+        this.router.navigate(['oauth/login'], { queryParams: { returnUrl: state.url } });
+        return of(false);
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+};
+AuthGuard.ctorParameters = () => [
+    { type: Router },
+    { type: AuthenticationService }
+];
+AuthGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function AuthGuard_Factory() { return new AuthGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.AuthenticationService)); }, token: AuthGuard, providedIn: "root" });
+AuthGuard = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [Router, AuthenticationService])
+], AuthGuard);
+export { AuthGuard };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/core/guards/permission.guard.js

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AuthenticationService } from '../services/authentication.service';
+import { ObjectUtil } from '../utils/object.util';
+import { ArrayUtil } from './../utils/array.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../services/authentication.service";
+let PermissionGuard = class PermissionGuard {
+    constructor(router, authenticationService) {
+        this.router = router;
+        this.authenticationService = authenticationService;
+    }
+    canActivate(route, state) {
+        if (!ObjectUtil.isNull(this.authenticationService.tokenValueLocalStorage)) {
+            return this.authenticationService.token.pipe(map(token => {
+                if (this.authenticationService.isValidToken(token)
+                    && (!this.hasPermission(token.user.menuList, state.url) && !this.hasAuthority(token.user, route.data.authority))) {
+                    this.router.navigate(['errors/403']);
+                    return false;
+                }
+                return true;
+            }));
+        }
+        this.router.navigate(['errors/403']);
+        return of(false);
+    }
+    hasAuthority(user, permission) {
+        return !!user.authorities.find(authority => authority.authority.match(permission));
+    }
+    hasPermission(menuList, url) {
+        for (const menu of menuList) {
+            if (url.split('/').pop() === menu.route) {
+                return true;
+            }
+            else if (!ArrayUtil.isEmpty(menu.menuList)) {
+                return this.hasPermission(menu.menuList, url);
+            }
+        }
+        return false;
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+};
+PermissionGuard.ctorParameters = () => [
+    { type: Router },
+    { type: AuthenticationService }
+];
+PermissionGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PermissionGuard_Factory() { return new PermissionGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.AuthenticationService)); }, token: PermissionGuard, providedIn: "root" });
+PermissionGuard = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [Router, AuthenticationService])
+], PermissionGuard);
+export { PermissionGuard };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbImNvcmUvZ3VhcmRzL3Blcm1pc3Npb24uZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLHNCQUFzQixFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNySCxPQUFPLEVBQWMsRUFBRSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUdyQyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUMzRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHVCQUF1QixDQUFDOzs7O0FBS2xELElBQWEsZUFBZSxHQUE1QixNQUFhLGVBQWU7SUFFeEIsWUFBb0IsTUFBYyxFQUFVLHFCQUFzRDtRQUE5RSxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQVUsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUFpQztJQUFJLENBQUM7SUFFdkcsV0FBVyxDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDakUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLHNCQUFzQixDQUFDLEVBQUU7WUFDdkUsT0FBTyxJQUFJLENBQUMscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FDeEMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUNSLElBQUksSUFBSSxDQUFDLHFCQUFxQixDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUM7dUJBQzNDLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUU7b0JBQ2xILElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztvQkFDckMsT0FBTyxLQUFLLENBQUM7aUJBQ2hCO2dCQUNELE9BQU8sSUFBSSxDQUFDO1lBQ2hCLENBQUMsQ0FBQyxDQUNMLENBQUM7U0FDTDtRQUNELElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztRQUNyQyxPQUFPLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNyQixDQUFDO0lBRUQsWUFBWSxDQUFDLElBQVMsRUFBRSxVQUFrQjtRQUN0QyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDdkYsQ0FBQztJQUVELGFBQWEsQ0FBQyxRQUFtQixFQUFFLEdBQVc7UUFDMUMsS0FBSyxNQUFNLElBQUksSUFBSSxRQUFRLEVBQUU7WUFDekIsSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLElBQUksQ0FBQyxLQUFLLEVBQUU7Z0JBQ3JDLE9BQU8sSUFBSSxDQUFDO2FBQ2Y7aUJBQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFO2dCQUMxQyxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQzthQUNqRDtTQUNKO1FBQ0QsT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztJQUVELGdCQUFnQixDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDdEUsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQztJQUMxQyxDQUFDO0NBRUosQ0FBQTs7WUF0QytCLE1BQU07WUFBaUMscUJBQXFCOzs7QUFGL0UsZUFBZTtJQUgzQixVQUFVLENBQUM7UUFDUixVQUFVLEVBQUUsTUFBTTtLQUNyQixDQUFDO3FDQUc4QixNQUFNLEVBQWlDLHFCQUFxQjtHQUYvRSxlQUFlLENBd0MzQjtTQXhDWSxlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgQ2FuQWN0aXZhdGUsIENhbkFjdGl2YXRlQ2hpbGQsIFJvdXRlciwgUm91dGVyU3RhdGVTbmFwc2hvdCB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBvZiB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5pbXBvcnQgeyBCYXNlVXNlciB9IGZyb20gJy4uL21vZGVscy9iYXNlLXVzZXIubW9kZWwnO1xuaW1wb3J0IHsgQXV0aGVudGljYXRpb25TZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvYXV0aGVudGljYXRpb24uc2VydmljZSc7XG5pbXBvcnQgeyBPYmplY3RVdGlsIH0gZnJvbSAnLi4vdXRpbHMvb2JqZWN0LnV0aWwnO1xuaW1wb3J0IHsgTWVudURUTyB9IGZyb20gJy4vLi4vbW9kZWxzL2R0by9tZW51LmR0byc7XG5pbXBvcnQgeyBBcnJheVV0aWwgfSBmcm9tICcuLy4uL3V0aWxzL2FycmF5LnV0aWwnO1xuXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFBlcm1pc3Npb25HdWFyZCBpbXBsZW1lbnRzIENhbkFjdGl2YXRlLCBDYW5BY3RpdmF0ZUNoaWxkIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgcm91dGVyOiBSb3V0ZXIsIHByaXZhdGUgYXV0aGVudGljYXRpb25TZXJ2aWNlOiBBdXRoZW50aWNhdGlvblNlcnZpY2U8QmFzZVVzZXI+KSB7IH1cblxuICAgIGNhbkFjdGl2YXRlKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgICAgICBpZiAoIU9iamVjdFV0aWwuaXNOdWxsKHRoaXMuYXV0aGVudGljYXRpb25TZXJ2aWNlLnRva2VuVmFsdWVMb2NhbFN0b3JhZ2UpKSB7XG4gICAgICAgICAgICByZXR1cm4gdGhpcy5hdXRoZW50aWNhdGlvblNlcnZpY2UudG9rZW4ucGlwZShcbiAgICAgICAgICAgICAgICBtYXAodG9rZW4gPT4ge1xuICAgICAgICAgICAgICAgICAgICBpZiAodGhpcy5hdXRoZW50aWNhdGlvblNlcnZpY2UuaXNWYWxpZFRva2VuKHRva2VuKVxuICAgICAgICAgICAgICAgICAgICAgICAgJiYgKCF0aGlzLmhhc1Blcm1pc3Npb24odG9rZW4udXNlci5tZW51TGlzdCwgc3RhdGUudXJsKSAmJiAhdGhpcy5oYXNBdXRob3JpdHkodG9rZW4udXNlciwgcm91dGUuZGF0YS5hdXRob3JpdHkpKSkge1xuICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5yb3V0ZXIubmF2aWdhdGUoWydlcnJvcnMvNDAzJ10pO1xuICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICAgICAgICAgIH0pXG4gICAgICAgICAgICApO1xuICAgICAgICB9XG4gICAgICAgIHRoaXMucm91dGVyLm5hdmlnYXRlKFsnZXJyb3JzLzQwMyddKTtcbiAgICAgICAgcmV0dXJuIG9mKGZhbHNlKTtcbiAgICB9XG5cbiAgICBoYXNBdXRob3JpdHkodXNlcjogYW55LCBwZXJtaXNzaW9uOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuICEhdXNlci5hdXRob3JpdGllcy5maW5kKGF1dGhvcml0eSA9PiBhdXRob3JpdHkuYXV0aG9yaXR5Lm1hdGNoKHBlcm1pc3Npb24pKTtcbiAgICB9XG5cbiAgICBoYXNQZXJtaXNzaW9uKG1lbnVMaXN0OiBNZW51RFRPW10sIHVybDogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgICAgIGZvciAoY29uc3QgbWVudSBvZiBtZW51TGlzdCkge1xuICAgICAgICAgICAgaWYgKHVybC5zcGxpdCgnLycpLnBvcCgpID09PSBtZW51LnJvdXRlKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICAgICAgICB9IGVsc2UgaWYgKCFBcnJheVV0aWwuaXNFbXB0eShtZW51Lm1lbnVMaXN0KSkge1xuICAgICAgICAgICAgICAgIHJldHVybiB0aGlzLmhhc1Blcm1pc3Npb24obWVudS5tZW51TGlzdCwgdXJsKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuXG4gICAgY2FuQWN0aXZhdGVDaGlsZChyb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgc3RhdGU6IFJvdXRlclN0YXRlU25hcHNob3QpOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuY2FuQWN0aXZhdGUocm91dGUsIHN0YXRlKTtcbiAgICB9XG5cbn1cbiJdfQ==

package/esm2015/core/guards/public.guard.js

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, Router, RouterStateSnapshot } from '@angular/router';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AuthenticationService } from '../services/authentication.service';
+import { ObjectUtil } from '../utils/object.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../services/authentication.service";
+let PublicGuard = class PublicGuard {
+    constructor(router, authenticationService) {
+        this.router = router;
+        this.authenticationService = authenticationService;
+    }
+    canActivate(route, state) {
+        if (!ObjectUtil.isNull(this.authenticationService.tokenValueLocalStorage)) {
+            return this.authenticationService.token.pipe(map(token => {
+                if (this.authenticationService.isValidToken(token)) {
+                    this.router.navigate(['dashboard']);
+                    return false;
+                }
+                return true;
+            }));
+        }
+        this.router.navigate(['dashboard']);
+        return of(false);
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+};
+PublicGuard.ctorParameters = () => [
+    { type: Router },
+    { type: AuthenticationService }
+];
+PublicGuard.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PublicGuard_Factory() { return new PublicGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.AuthenticationService)); }, token: PublicGuard, providedIn: "root" });
+PublicGuard = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [Router, AuthenticationService])
+], PublicGuard);
+export { PublicGuard };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLmd1YXJkLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9ndWFyZHMvcHVibGljLmd1YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxXQUFXLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDckgsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN0QyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHckMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDM0UsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDOzs7O0FBS2xELElBQWEsV0FBVyxHQUF4QixNQUFhLFdBQVc7SUFFcEIsWUFBb0IsTUFBYyxFQUFVLHFCQUFzRDtRQUE5RSxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQVUsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUFpQztJQUNsRyxDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDakUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLHNCQUFzQixDQUFDLEVBQUU7WUFDdkUsT0FBTyxJQUFJLENBQUMscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FDeEMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFO2dCQUNSLElBQUksSUFBSSxDQUFDLHFCQUFxQixDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsRUFBRTtvQkFDaEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO29CQUNwQyxPQUFPLEtBQUssQ0FBQztpQkFDaEI7Z0JBQ0QsT0FBTyxJQUFJLENBQUM7WUFDaEIsQ0FBQyxDQUFDLENBQ0wsQ0FBQztTQUNMO1FBQ0QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1FBQ3BDLE9BQU8sRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxLQUE2QixFQUFFLEtBQTBCO1FBQ3RFLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNKLENBQUE7O1lBdEIrQixNQUFNO1lBQWlDLHFCQUFxQjs7O0FBRi9FLFdBQVc7SUFIdkIsVUFBVSxDQUFDO1FBQ1IsVUFBVSxFQUFFLE1BQU07S0FDckIsQ0FBQztxQ0FHOEIsTUFBTSxFQUFpQyxxQkFBcUI7R0FGL0UsV0FBVyxDQXdCdkI7U0F4QlksV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIENhbkFjdGl2YXRlLCBDYW5BY3RpdmF0ZUNoaWxkLCBSb3V0ZXIsIFJvdXRlclN0YXRlU25hcHNob3QgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcblxuaW1wb3J0IHsgQmFzZVVzZXIgfSBmcm9tICcuLi9tb2RlbHMvYmFzZS11c2VyLm1vZGVsJztcbmltcG9ydCB7IEF1dGhlbnRpY2F0aW9uU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2VzL2F1dGhlbnRpY2F0aW9uLnNlcnZpY2UnO1xuaW1wb3J0IHsgT2JqZWN0VXRpbCB9IGZyb20gJy4uL3V0aWxzL29iamVjdC51dGlsJztcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBQdWJsaWNHdWFyZCBpbXBsZW1lbnRzIENhbkFjdGl2YXRlLCBDYW5BY3RpdmF0ZUNoaWxkIHtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgcm91dGVyOiBSb3V0ZXIsIHByaXZhdGUgYXV0aGVudGljYXRpb25TZXJ2aWNlOiBBdXRoZW50aWNhdGlvblNlcnZpY2U8QmFzZVVzZXI+KSB7XG4gICAgfVxuXG4gICAgY2FuQWN0aXZhdGUocm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90KTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgICAgIGlmICghT2JqZWN0VXRpbC5pc051bGwodGhpcy5hdXRoZW50aWNhdGlvblNlcnZpY2UudG9rZW5WYWx1ZUxvY2FsU3RvcmFnZSkpIHtcbiAgICAgICAgICAgIHJldHVybiB0aGlzLmF1dGhlbnRpY2F0aW9uU2VydmljZS50b2tlbi5waXBlKFxuICAgICAgICAgICAgICAgIG1hcCh0b2tlbiA9PiB7XG4gICAgICAgICAgICAgICAgICAgIGlmICh0aGlzLmF1dGhlbnRpY2F0aW9uU2VydmljZS5pc1ZhbGlkVG9rZW4odG9rZW4pKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICB0aGlzLnJvdXRlci5uYXZpZ2F0ZShbJ2Rhc2hib2FyZCddKTtcbiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTtcbiAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgICAgICAgICB9KVxuICAgICAgICAgICAgKTtcbiAgICAgICAgfVxuICAgICAgICB0aGlzLnJvdXRlci5uYXZpZ2F0ZShbJ2Rhc2hib2FyZCddKTtcbiAgICAgICAgcmV0dXJuIG9mKGZhbHNlKTtcbiAgICB9XG5cbiAgICBjYW5BY3RpdmF0ZUNoaWxkKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgICAgICByZXR1cm4gdGhpcy5jYW5BY3RpdmF0ZShyb3V0ZSwgc3RhdGUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/core/interceptors/auth.interceptor.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@angular/core';
+import { AuthenticationService } from '../services/authentication.service';
+let AuthInterceptor = class AuthInterceptor {
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+    }
+    intercept(request, next) {
+        const token = this.authenticationService.tokenValue;
+        if (token && token.accessToken && !request.headers.get('skip')) {
+            request = request.clone({
+                setHeaders: {
+                    Authorization: `Bearer ${token.accessToken}`
+                }
+            });
+        }
+        return next.handle(request);
+    }
+};
+AuthInterceptor.ctorParameters = () => [
+    { type: AuthenticationService }
+];
+AuthInterceptor = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AuthenticationService])
+], AuthInterceptor);
+export { AuthInterceptor };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/core/interceptors/error.interceptor.js

@@ -0,0 +1,110 @@
+import { __awaiter, __decorate, __metadata } from "tslib";
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { Router } from '@angular/router';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { AuthenticationService } from '../services/authentication.service';
+import { ArrayUtil } from '../utils/array.util';
+import { ObjectUtil } from '../utils/object.util';
+let ErrorInterceptor = class ErrorInterceptor {
+    constructor(_injector) {
+        this._injector = _injector;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError((err) => __awaiter(this, void 0, void 0, function* () {
+            this._router = this._injector.get(Router);
+            let error = null;
+            if (err instanceof HttpErrorResponse && err.error instanceof Blob && err.error.type === 'application/json') {
+                yield this.blobToJson(err).then(httpErrorResponse => {
+                    if ((!ObjectUtil.isNull(httpErrorResponse)) && (httpErrorResponse instanceof HttpErrorResponse)) {
+                        error = httpErrorResponse;
+                    }
+                });
+            }
+            else if (err instanceof HttpErrorResponse) {
+                error = err;
+            }
+            return yield (yield this.validateErrors(error)).toPromise().then(e => e);
+        })));
+    }
+    validateErrors(err) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let error = err.error.message || err.statusText;
+                const apiError = err.error.apierror;
+                if (!ObjectUtil.isNull(apiError)) {
+                    if ((apiError.status === 'INTERNAL_SERVER_ERROR')
+                        && (apiError.debugMessage && apiError.debugMessage.toUpperCase().includes('QUERY DID NOT RETURN A UNIQUE RESULT'))) {
+                        error = 'A consulta não retornou resultado único';
+                    }
+                    else if ((apiError.status === 'INTERNAL_SERVER_ERROR')
+                        && (apiError.message && apiError.message.toUpperCase().includes('NENHUM REGISTRO FOI ENCONTRADO'))) {
+                        error = 'Nenhum registro foi encontrado';
+                    }
+                    else if ((apiError.status === 'INTERNAL_SERVER_ERROR')
+                        && (apiError.message && apiError.message.toUpperCase().includes('OCORREU UM PROBLEMA INESPERADO'))) {
+                        error = 'Ocorreu um problema inesperado';
+                    }
+                    else if (apiError.status === 'FORBIDDEN') {
+                        this._injector.get(NgZone).run(() => this._router.navigate(['/errors/403']));
+                        return;
+                    }
+                    else if (apiError.status === 'UNAUTHORIZED') {
+                        error = 'Sua sessão expirou';
+                        this._injector.get(AuthenticationService).logout();
+                    }
+                    else if (!ArrayUtil.isEmpty(apiError.subErrorList)) {
+                        error = apiError.subErrorList[0].rejectedMessage;
+                    }
+                    else {
+                        error = apiError.message;
+                    }
+                }
+                else if (!navigator.onLine) {
+                    error = 'Sem internet';
+                }
+                else if (err.status === 504) {
+                    this._injector.get(NgZone).run(() => this._router.navigate(['/errors/504']));
+                    return;
+                }
+                return resolve(throwError(error));
+            });
+        });
+    }
+    blobToJson(err) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    let httpErrorResponse = null;
+                    const reader = new FileReader();
+                    reader.onload = (e) => {
+                        const errmsg = JSON.parse(e.target.result);
+                        httpErrorResponse = new HttpErrorResponse({
+                            error: errmsg,
+                            headers: err.headers,
+                            status: err.status,
+                            statusText: err.statusText,
+                            url: err.url
+                        });
+                        resolve(httpErrorResponse);
+                    };
+                    reader.readAsText(err.error);
+                }
+                catch (e) {
+                    reject(null);
+                    throwError(e);
+                }
+            });
+        });
+    }
+};
+ErrorInterceptor.ctorParameters = () => [
+    { type: Injector }
+];
+ErrorInterceptor = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Injector])
+], ErrorInterceptor);
+export { ErrorInterceptor };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error.interceptor.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["core/interceptors/error.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';\nimport { Injectable, Injector, NgZone } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\n\nimport { ApiErrorDTO } from '../models/dto/api-error.dto';\nimport { AuthenticationService } from '../services/authentication.service';\nimport { ArrayUtil } from '../utils/array.util';\nimport { ObjectUtil } from '../utils/object.util';\n\n@Injectable()\nexport class ErrorInterceptor implements HttpInterceptor {\n\n    private _router: Router;\n\n    constructor(private _injector: Injector) { }\n\n    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        return next.handle(request).pipe(\n            catchError(async (err: any) => {\n                this._router = this._injector.get(Router);\n                let error: any = null;\n\n                if (err instanceof HttpErrorResponse && err.error instanceof Blob && err.error.type === 'application/json') {\n\n                    await this.blobToJson(err).then(httpErrorResponse => {\n                        if ((!ObjectUtil.isNull(httpErrorResponse)) && (httpErrorResponse instanceof HttpErrorResponse)) {\n                            error = httpErrorResponse;\n                        }\n                    });\n\n                } else if (err instanceof HttpErrorResponse) {\n                    error = err;\n                }\n\n                return await (await this.validateErrors(error)).toPromise().then(e => e);\n            })\n        ) as Observable<HttpEvent<any>>;\n    }\n\n    private async validateErrors(err: any): Promise<Observable<never>> {\n        return new Promise((resolve, reject) => {\n            let error: any = err.error.message || err.statusText;\n            const apiError: ApiErrorDTO = err.error.apierror as ApiErrorDTO;\n\n            if (!ObjectUtil.isNull(apiError)) {\n                if ((apiError.status === 'INTERNAL_SERVER_ERROR')\n                    && (apiError.debugMessage && apiError.debugMessage.toUpperCase().includes('QUERY DID NOT RETURN A UNIQUE RESULT'))) {\n                    error = 'A consulta não retornou resultado único';\n                } else if ((apiError.status === 'INTERNAL_SERVER_ERROR')\n                    && (apiError.message && apiError.message.toUpperCase().includes('NENHUM REGISTRO FOI ENCONTRADO'))) {\n                    error = 'Nenhum registro foi encontrado';\n                } else if ((apiError.status === 'INTERNAL_SERVER_ERROR')\n                    && (apiError.message && apiError.message.toUpperCase().includes('OCORREU UM PROBLEMA INESPERADO'))) {\n                    error = 'Ocorreu um problema inesperado';\n                } else if (apiError.status === 'FORBIDDEN') {\n                    this._injector.get(NgZone).run(() => this._router.navigate(['/errors/403']));\n                    return;\n                } else if (apiError.status === 'UNAUTHORIZED') {\n                    error = 'Sua sessão expirou';\n                    this._injector.get(AuthenticationService).logout();\n                } else if (!ArrayUtil.isEmpty(apiError.subErrorList)) {\n                    error = apiError.subErrorList[0].rejectedMessage;\n                } else {\n                    error = apiError.message;\n                }\n            } else if (!navigator.onLine) {\n                error = 'Sem internet';\n            } else if (err.status === 504) {\n                this._injector.get(NgZone).run(() => this._router.navigate(['/errors/504']));\n                return;\n            }\n\n            return resolve(throwError(error));\n        });\n    }\n\n    private async blobToJson(err: any): Promise<HttpErrorResponse> {\n        return new Promise((resolve, reject) => {\n            try {\n                let httpErrorResponse: HttpErrorResponse = null;\n                const reader: FileReader = new FileReader();\n                reader.onload = (e: Event) => {\n                    const errmsg = JSON.parse((<any>e.target).result);\n                    httpErrorResponse = new HttpErrorResponse({\n                        error: errmsg,\n                        headers: err.headers,\n                        status: err.status,\n                        statusText: err.statusText,\n                        url: err.url\n                    });\n                    resolve(httpErrorResponse);\n                };\n                reader.readAsText(err.error);\n            } catch (e) {\n                reject(null);\n                throwError(e);\n            }\n        });\n    }\n\n}\n"]}

package/esm2015/core/models/abstract.model.js

@@ -0,0 +1,3 @@
+export class AbstractModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJjb3JlL21vZGVscy9hYnN0cmFjdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQWdCLGFBQWE7Q0FJbEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RNb2RlbCB7XG5cbiAgICBpZDogbnVtYmVyIHwgc3RyaW5nO1xuXG59XG4iXX0=

package/esm2015/core/models/archive.model.js

@@ -0,0 +1,3 @@
+export class Archive {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJjaGl2ZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbImNvcmUvbW9kZWxzL2FyY2hpdmUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLE9BQU87Q0FNbkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQXJjaGl2ZSB7XG5cbiAgbmFtZTogc3RyaW5nO1xuXG4gIGNvbnRlbnQ6IGFueTtcblxufVxuIl19

package/esm2015/core/models/authority.model.js

@@ -0,0 +1,3 @@
+export class Authority {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaXR5Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9tb2RlbHMvYXV0aG9yaXR5Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxTQUFTO0NBSXJCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEF1dGhvcml0eSB7XG5cbiAgYXV0aG9yaXR5OiBzdHJpbmc7XG5cbn1cbiJdfQ==

package/esm2015/core/models/base-user.model.js

@@ -0,0 +1,8 @@
+import { AbstractModel } from './abstract.model';
+export class BaseUser extends AbstractModel {
+    constructor() {
+        super();
+        this.menuList = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS11c2VyLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9tb2RlbHMvYmFzZS11c2VyLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQztBQUkvQyxNQUFNLE9BQU8sUUFBUyxTQUFRLGFBQWE7SUFjdkM7UUFDSSxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0lBQ3ZCLENBQUM7Q0FFSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QWJzdHJhY3RNb2RlbH0gZnJvbSAnLi9hYnN0cmFjdC5tb2RlbCc7XG5pbXBvcnQge01lbnVEVE99IGZyb20gJy4vZHRvL21lbnUuZHRvJztcbmltcG9ydCB7QXV0aG9yaXR5fSBmcm9tICcuL2F1dGhvcml0eS5tb2RlbCc7XG5cbmV4cG9ydCBjbGFzcyBCYXNlVXNlciBleHRlbmRzIEFic3RyYWN0TW9kZWwge1xuXG4gICAgbmFtZTogc3RyaW5nO1xuXG4gICAgdXNlcm5hbWU6IHN0cmluZztcblxuICAgIHBhc3N3b3JkOiBzdHJpbmc7XG5cbiAgICBsYXN0QWNjZXNzOiBEYXRlO1xuXG4gICAgYXV0aG9yaXRpZXM6IEF1dGhvcml0eVtdO1xuXG4gICAgbWVudUxpc3Q6IE1lbnVEVE9bXTtcblxuICAgIGNvbnN0cnVjdG9yKCkge1xuICAgICAgICBzdXBlcigpO1xuICAgICAgICB0aGlzLm1lbnVMaXN0ID0gW107XG4gICAgfVxuXG59XG4iXX0=

package/esm2015/core/models/dto/abstract.dto.js

@@ -0,0 +1,3 @@
+export class AbstractDTO {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuZHRvLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsiY29yZS9tb2RlbHMvZHRvL2Fic3RyYWN0LmR0by50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQWdCLFdBQVc7Q0FDaEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3REVE8ge1xufVxuIl19

package/esm2015/core/models/dto/api-error.dto.js

@@ -0,0 +1,8 @@
+import { AbstractDTO } from './abstract.dto';
+export class ApiErrorDTO extends AbstractDTO {
+    constructor() {
+        super();
+        this.subErrorList = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWVycm9yLmR0by5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbImNvcmUvbW9kZWxzL2R0by9hcGktZXJyb3IuZHRvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUczQyxNQUFNLE9BQU8sV0FBWSxTQUFRLFdBQVc7SUFVMUM7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxZQUFZLEdBQUcsRUFBRSxDQUFDO0lBQ3pCLENBQUM7Q0FFRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QWJzdHJhY3REVE99IGZyb20gJy4vYWJzdHJhY3QuZHRvJztcbmltcG9ydCB7QXBpU3ViRXJyb3JEVE99IGZyb20gJy4vYXBpLXN1Yi1lcnJvci5kdG8nO1xuXG5leHBvcnQgY2xhc3MgQXBpRXJyb3JEVE8gZXh0ZW5kcyBBYnN0cmFjdERUTyB7XG5cbiAgZGVidWdNZXNzYWdlOiBzdHJpbmc7XG5cbiAgbWVzc2FnZTogc3RyaW5nO1xuXG4gIHN0YXR1czogc3RyaW5nO1xuXG4gIHN1YkVycm9yTGlzdDogQXBpU3ViRXJyb3JEVE9bXTtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMuc3ViRXJyb3JMaXN0ID0gW107XG4gIH1cblxufVxuXG5cbiJdfQ==