@esfaenza/core 15.2.0

package/esm2020/services/classes/app.accesstoken.mjs

@@ -0,0 +1,51 @@
+// Angular
+import { Inject, Injectable, Optional } from "@angular/core";
+// Applicazione
+import { JaceIdentity, USE_FAKE_ACCESS_TOKEN } from "@esfaenza/core/domain";
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+export class TokenService {
+    constructor(cs, USE_FAKE_ACCESS_TOKEN) {
+        this.cs = cs;
+        this.USE_FAKE_ACCESS_TOKEN = USE_FAKE_ACCESS_TOKEN;
+    }
+    clearTokens() {
+        this.cs.delete("access_token");
+    }
+    getAccessToken() {
+        return this.USE_FAKE_ACCESS_TOKEN ? this.getFakeToken() : this.cs.get("accessToken");
+    }
+    getJaceIdentity() {
+        let token = this.USE_FAKE_ACCESS_TOKEN ? this.getFakeToken() : this.cs.get("accessToken");
+        if (!token)
+            return null;
+        let base64Url = token.split(".")[1];
+        let base64 = base64Url.replace("-", "+").replace("_", "/");
+        let tokenData = JSON.parse(decodeURIComponent(window.atob(base64).split("").map(c => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")));
+        let identity = new JaceIdentity(this.accountScope);
+        identity.IdAccount = tokenData.ACCOUNTID;
+        identity.IdUser = tokenData.USERID;
+        identity.DsUser = tokenData.USERNAME;
+        identity.FullName = tokenData.USERDESCRIPTION;
+        identity.Idtenant = tokenData.TENANT;
+        identity.TenantName = tokenData.TENANTNAME;
+        identity.ExpirationTime = new Date(tokenData.exp * 1000); //unix-epoch in secondi -> millisecondi
+        return identity;
+    }
+    //Accesstoken fittizio ma valido, per simulare la connession corretta col backend
+    getFakeToken() {
+        return "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYmYiOjE1OTA0MTU4NDYsImV4cCI6MTk5MDQyMDA2NSwiaXNzIjoiaHR0cDovL2F1dGhhcGlzdGFnaW5nYS5qYWNlLmVuZXJneXNvZnR3YXJlLnByaXYiLCJhdWQiOlsiaHR0cDovL2F1dGhhcGlzdGFnaW5nYS5qYWNlLmVuZXJneXNvZnR3YXJlLnByaXYvcmVzb3VyY2VzIiwiYXV0aGVudGljYXRpbyJdLCJjbGllbnRfaWQiOiJtZXRlcmluZ3N0YWdpbmciLCJzdWIiOiIxMDAzIiwiYXV0aF90aW1lIjoxNTkwNDE1ODQ2LCJpZHAiOiJsb2NhbCIsIkFDQ09VTlRJRCI6IjEwMDMiLCJVU0VSSUQiOiIyNTkiLCJVU0VSREVTQ1JJUFRJT04iOiJUZXN0IFVzZXIiLCJVU0VSTkFNRSI6IlRFU1QiLCJURU5BTlQiOiJGWCIsIlRFTkFOVE5BTUUiOiJGZW5peCBTcmwiLCJyb2xlIjpbIkJhY2tvZmZpY2UiLCJEYXRhIE1hbmFnZXIiLCJUcmFkaW5nIiwiUmVtaXQgTWFuYWdlciIsIlRlbmFudCBSZWFkZXIiLCJDb21wbC4gQVJFUkEgUmVhZGVyIiwiQ29tcGwuIEFSRVJBIFdyaXRlciBMMSIsIkNvbXBsLiBBUkVSQSBXcml0ZXIgTDIiLCJKYWNlIEFkbWluIl0sIk1PRFVMRSI6WyIzNiIsIjM3IiwiMTQiLCI1IiwiMzIiLCIxNSIsIjQyIiwiOCIsIjE3IiwiMTEiLCIyMSIsIjkiLCIzOCIsIjE4IiwiNyIsIjM0IiwiMTYiLCIyMCIsIjE5IiwiMSIsIjIiLCIzMSIsIjEyIiwiMTAiLCIzMyIsIjQwIiwiMjIiLCIxMyIsIjYiXSwiUEVSTUlTU0lPTiI6WyJleHRyYWN0X2RhdGEiLCJtZG1fcmVhZCIsIm1kbV9hZHZfb3AiLCJtZG1fY2ZnX2Jhc2UiLCJjcmVhdGVfdHJhZGUiLCJtZG1fbWFzc19kZWwiLCJzZW5kX2NvbW0iLCJtZG1fZmN0IiwibWRtX2NmZ19hZHYiLCJtZG1fY2ZnX3JlYWQiLCJtYW5hZ2VfZWxlIiwibWFuYWdlX2dhcyIsImNvbmZpcm1fdHJhZGUiLCJtZG1fY3VzdG9taXplIiwibmV3X2NvbW0iLCJtZG1fbWFzc19mY3QiLCJtZG1fb3AiLCJ2aWV3X2JpbGxpbmciLCJtZG1fbWFzc19vcCIsIm1kbV9hZHZfcmVhZCJdLCJqdGkiOiIwZTUzMDc1NjE2MDZlNDQ0ZTI4ODViMTFhMzE0NDQyMSIsInNjb3BlIjpbImF1dGgiLCJvZmZsaW5lX2FjY2VzcyJdLCJhbXIiOlsicGFzc3dvcmQiXSwiaWF0IjoxNTkwNDE2NDY1fQ.MNcphwkIwvLFDDpLaFDN3GK11lgT2aqvXa8s7bQJgdE";
+    }
+}
+TokenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TokenService, deps: [{ token: i1.CookieService }, { token: USE_FAKE_ACCESS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TokenService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.CookieService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_FAKE_ACCESS_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/classes/app.errorhandler.mjs

@@ -0,0 +1,41 @@
+// Angular
+import { Injectable } from "@angular/core";
+import { HttpErrorResponse } from "@angular/common/http";
+import { Router } from "@angular/router";
+import * as i0 from "@angular/core";
+export class APPErrorHandler {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    handleError(error) {
+        if (this.router == null)
+            this.router = this.injector.get(Router);
+        //Ignoro eventuali errori di javascript quando il redirect è attivo
+        if (myconfig && myconfig.redirectInProgress) {
+            console.log("Javascript error on redirect in progress, ignoring this event");
+            return;
+        }
+        //In caso io abbia impostato succesresultmandatory nell'httprequest e questa abbia dato errore tiro fuori un exception che dev'essere mostrata come si deve
+        var newError = "";
+        if (!error.message && !error.stack)
+            newError = error;
+        else if (error instanceof HttpErrorResponse)
+            newError = error.message;
+        else
+            newError = error.stack && error.stack.length > 1000 ? error.stack.substring(0, 999) + "[...]" : error.stack;
+        var pars = { errorMessage: this.b64EncodeUnicode(newError), fromUrl: this.router.url };
+        this.router.navigate(["/anerr", pars]);
+    }
+    b64EncodeUnicode(str) {
+        // first we use encodeURIComponent to get percent-encoded UTF-8,
+        // then we convert the percent encodings into raw bytes which
+        // can be fed into btoa.
+        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(("0x" + p1))));
+    }
+}
+APPErrorHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: APPErrorHandler, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+APPErrorHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: APPErrorHandler });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: APPErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/classes/app.event.mjs

@@ -0,0 +1,27 @@
+// Angular
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class OutZoneEventPlugin {
+    constructor(zone) {
+        this.zone = zone;
+    }
+    supports(eventName) {
+        return eventName.endsWith('out-zone');
+    }
+    addEventListener(element, eventName, originalHandler) {
+        let eventOriginalName = eventName.split('.')[0];
+        let standardHandler = (event) => originalHandler(event);
+        if (eventName.endsWith('out-zone'))
+            this.zone.runOutsideAngular(() => { element.addEventListener(eventOriginalName, standardHandler); });
+        else
+            element.addEventListener(eventOriginalName, standardHandler);
+        return () => element.removeEventListener(eventOriginalName, standardHandler);
+    }
+}
+OutZoneEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OutZoneEventPlugin, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+OutZoneEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OutZoneEventPlugin, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OutZoneEventPlugin, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/classes/app.httpextensions.loc.mjs

@@ -0,0 +1,15 @@
+import { Injectable } from "@angular/core";
+import { LocalizationService } from "@esfaenza/localizations";
+import * as i0 from "@angular/core";
+export class HTTPServiceExtensionsLoc extends LocalizationService {
+    constructor(injector) {
+        super(injector);
+        super.set("it->en", "Il Server sembra essere offline, prova a ricaricare la pagina", ["Server seems to be offline, try to reload this page"]);
+    }
+}
+HTTPServiceExtensionsLoc.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensionsLoc, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+HTTPServiceExtensionsLoc.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensionsLoc });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensionsLoc, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmh0dHBleHRlbnNpb25zLmxvYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc2VydmljZXMvc3JjL2NsYXNzZXMvYXBwLmh0dHBleHRlbnNpb25zLmxvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQUc5RCxNQUFNLE9BQU8sd0JBQXlCLFNBQVEsbUJBQW1CO0lBQzdELFlBQVksUUFBa0I7UUFDMUIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ2hCLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLCtEQUErRCxFQUFFLENBQUMscURBQXFELENBQUMsQ0FBQyxDQUFDO0lBQ2xKLENBQUM7O3FIQUpRLHdCQUF3Qjt5SEFBeEIsd0JBQXdCOzJGQUF4Qix3QkFBd0I7a0JBRHBDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBJbmplY3RvciB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IExvY2FsaXphdGlvblNlcnZpY2UgfSBmcm9tIFwiQGVzZmFlbnphL2xvY2FsaXphdGlvbnNcIjtcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIEhUVFBTZXJ2aWNlRXh0ZW5zaW9uc0xvYyBleHRlbmRzIExvY2FsaXphdGlvblNlcnZpY2Uge1xyXG4gICAgY29uc3RydWN0b3IoaW5qZWN0b3I6IEluamVjdG9yKSB7XHJcbiAgICAgICAgc3VwZXIoaW5qZWN0b3IpO1xyXG4gICAgICAgIHN1cGVyLnNldChcIml0LT5lblwiLCBcIklsIFNlcnZlciBzZW1icmEgZXNzZXJlIG9mZmxpbmUsIHByb3ZhIGEgcmljYXJpY2FyZSBsYSBwYWdpbmFcIiwgW1wiU2VydmVyIHNlZW1zIHRvIGJlIG9mZmxpbmUsIHRyeSB0byByZWxvYWQgdGhpcyBwYWdlXCJdKTtcclxuICAgIH1cclxufSJdfQ==

package/esm2020/services/classes/app.httpextensions.mjs

@@ -0,0 +1,90 @@
+// Angular
+import { Injectable } from "@angular/core";
+// Applicazione
+import { HTTPServiceExtensionsLoc } from "./app.httpextensions.loc";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/localizations";
+import * as i2 from "./app.accesstoken";
+import * as i3 from "./app.state";
+import * as i4 from "@angular/router";
+import * as i5 from "@esfaenza/access-control";
+import * as i6 from "@esfaenza/extensions";
+export class HTTPServiceExtensions {
+    constructor(lc, tks, as, router, ac, msgs) {
+        this.lc = lc;
+        this.tks = tks;
+        this.as = as;
+        this.router = router;
+        this.ac = ac;
+        this.msgs = msgs;
+        this.lc = this.lc.generateFromType(HTTPServiceExtensionsLoc);
+    }
+    //Gestione Auth
+    retrieveAccessToken() {
+        return this.tks.getAccessToken().toString();
+    }
+    retrieveIdentity() {
+        return this.tks.getJaceIdentity();
+    }
+    //Gestione ridirezione al login / altre pagine
+    readRedirectingToLogin() {
+        return this.as.redirectingToLogin;
+    }
+    writeRedirectingToLogin(status) {
+        this.as.redirectingToLogin = status;
+    }
+    redirectToLogin() {
+        console.log("httpextensions: redirecting to login");
+        this.router.navigate(["login", { fromUrl: this.router.url }]);
+    }
+    readRedirectionStatus() {
+        return myconfig?.redirectInProgress;
+    }
+    writeRedirectionStatus(status) {
+        myconfig.redirectInProgress = status;
+    }
+    //Gestione error handling flag
+    readHandlingErrorStatus() {
+        return this.as.handlingError;
+    }
+    writeHandlingErrorStatus(status) {
+        this.as.handlingError = status;
+    }
+    // 444, se false passa a handleBlockingException
+    handleNotConfiguredException() {
+        if (this.ac.has("P:mdm_customize")) {
+            myconfig.redirectInProgress = true;
+            this.as.handlingError = false;
+            this.router.navigate(["pages/adm/tenantconfig"]);
+            return true;
+        }
+        return false;
+    }
+    // 400, 403, 404, 444
+    handleBlockingException(status, text) {
+        this.msgs.simpleError(status + ": " + text);
+        this.as.handlingError = false;
+    }
+    // Tutto quello che non è gestito da handleBlockingException
+    handleException(status, text) {
+        if (status == 503) {
+            this.msgs.simpleError(this.lc.loc("Il Server sembra essere offline, prova a ricaricare la pagina"));
+            this.as.handlingError = false;
+        }
+        else if (status == 542) {
+            this.msgs.simpleError(text);
+            this.as.handlingError = false;
+        }
+        else {
+            var st = btoa(encodeURIComponent(text).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(("0x" + p1))));
+            var pars = { statusCode: status, statusText: st, fromUrl: this.router.url };
+            this.router.navigate(["iserr", pars]);
+        }
+    }
+}
+HTTPServiceExtensions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensions, deps: [{ token: i1.LocalizationService }, { token: i2.TokenService }, { token: i3.AppState }, { token: i4.Router }, { token: i5.AccessControlService }, { token: i6.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+HTTPServiceExtensions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensions });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPServiceExtensions, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }, { type: i2.TokenService }, { type: i3.AppState }, { type: i4.Router }, { type: i5.AccessControlService }, { type: i6.MessageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.httpextensions.js","sourceRoot":"","sources":["../../../../../projects/core/services/src/classes/app.httpextensions.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable } from \"@angular/core\";\r\nimport { Router } from \"@angular/router\";\r\n\r\n// Configurazioni\r\nimport { AccessControlService } from \"@esfaenza/access-control\";\r\nimport { HttpServiceExtensions } from \"@esfaenza/httpservice\";\r\nimport { LocalizationService } from \"@esfaenza/localizations\";\r\nimport { MessageService } from \"@esfaenza/extensions\";\r\n\r\n// Applicazione\r\nimport { HTTPServiceExtensionsLoc } from \"./app.httpextensions.loc\";\r\nimport { AppState } from \"./app.state\";\r\nimport { TokenService } from \"./app.accesstoken\";\r\n\r\nimport { EnvOptions } from \"@esfaenza/core/domain\";\r\n\r\ndeclare var myconfig: EnvOptions;\r\n\r\n@Injectable()\r\nexport class HTTPServiceExtensions implements HttpServiceExtensions {\r\n\r\n    constructor(private lc: LocalizationService, private tks: TokenService, private as: AppState, private router: Router, private ac: AccessControlService, private msgs: MessageService) {\r\n        this.lc = this.lc.generateFromType(HTTPServiceExtensionsLoc)\r\n    }\r\n\r\n    //Gestione Auth\r\n    retrieveAccessToken(): string {\r\n        return this.tks.getAccessToken().toString();\r\n    }\r\n\r\n    retrieveIdentity(): { IdUser: string; Idtenant: string; } {\r\n        return <any>this.tks.getJaceIdentity();\r\n    }\r\n\r\n    //Gestione ridirezione al login / altre pagine\r\n    readRedirectingToLogin(): boolean {\r\n        return this.as.redirectingToLogin;\r\n    }\r\n\r\n    writeRedirectingToLogin(status: boolean) {\r\n        this.as.redirectingToLogin = status;\r\n    }\r\n\r\n    redirectToLogin(): void {\r\n        console.log(\"httpextensions: redirecting to login\");\r\n        this.router.navigate([\"login\", { fromUrl: this.router.url }]);\r\n    }\r\n\r\n    readRedirectionStatus(): boolean {\r\n        return myconfig?.redirectInProgress;\r\n    }\r\n\r\n    writeRedirectionStatus(status: boolean): void {\r\n        myconfig.redirectInProgress = status;\r\n    }\r\n\r\n    //Gestione error handling flag\r\n    readHandlingErrorStatus(): boolean {\r\n        return this.as.handlingError;\r\n    }\r\n\r\n    writeHandlingErrorStatus(status: boolean) {\r\n        this.as.handlingError = status;\r\n    }\r\n\r\n    // 444, se false passa a handleBlockingException\r\n    handleNotConfiguredException(): boolean {\r\n        if (this.ac.has(\"P:mdm_customize\")) {\r\n            myconfig.redirectInProgress = true;\r\n            this.as.handlingError = false;\r\n            this.router.navigate([\"pages/adm/tenantconfig\"]);\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    // 400, 403, 404, 444\r\n    handleBlockingException(status: number, text: string) {\r\n        this.msgs.simpleError(status + \": \" + text)\r\n        this.as.handlingError = false;\r\n    }\r\n\r\n    // Tutto quello che non è gestito da handleBlockingException\r\n    handleException(status: number, text: string) {\r\n        if (status == 503) {\r\n            this.msgs.simpleError(this.lc.loc(\"Il Server sembra essere offline, prova a ricaricare la pagina\"));\r\n            this.as.handlingError = false;\r\n        }\r\n        else if (status == 542) {\r\n            this.msgs.simpleError(text);\r\n            this.as.handlingError = false;\r\n        }\r\n        else {\r\n            var st = btoa(encodeURIComponent(text).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(<any>(\"0x\" + p1))));\r\n            var pars = { statusCode: status, statusText: st, fromUrl: this.router.url };\r\n            this.router.navigate([\"iserr\", pars]);\r\n        }\r\n    }\r\n}"]}

package/esm2020/services/classes/app.routeguard.mjs

@@ -0,0 +1,22 @@
+// Angular
+import { Injectable } from "@angular/core";
+// Configurazioni
+import { AccessControlRouteGuard } from "@esfaenza/access-control";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/extensions";
+import * as i2 from "@esfaenza/access-control";
+import * as i3 from "@angular/router";
+import * as i4 from "./app.accesstoken";
+export class BaseRouterGuard extends AccessControlRouteGuard {
+    constructor(ms, acc, router, ts) {
+        super(ms, acc, router);
+        if (!acc.Initialized)
+            acc.initializeIdentity(ts.getJaceIdentity());
+    }
+}
+BaseRouterGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseRouterGuard, deps: [{ token: i1.MessageService }, { token: i2.AccessControlService }, { token: i3.Router }, { token: i4.TokenService }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseRouterGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseRouterGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseRouterGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MessageService }, { type: i2.AccessControlService }, { type: i3.Router }, { type: i4.TokenService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLnJvdXRlZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NlcnZpY2VzL3NyYy9jbGFzc2VzL2FwcC5yb3V0ZWd1YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFVBQVU7QUFDVixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRzNDLGlCQUFpQjtBQUNqQixPQUFPLEVBQUUsdUJBQXVCLEVBQXdCLE1BQU0sMEJBQTBCLENBQUM7Ozs7OztBQU16RixNQUFNLE9BQU8sZUFBZ0IsU0FBUSx1QkFBdUI7SUFDeEQsWUFBWSxFQUFrQixFQUFFLEdBQXlCLEVBQUUsTUFBYyxFQUFFLEVBQWdCO1FBQ3ZGLEtBQUssQ0FBQyxFQUFFLEVBQUUsR0FBRyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBRXZCLElBQUksQ0FBQyxHQUFHLENBQUMsV0FBVztZQUNoQixHQUFHLENBQUMsa0JBQWtCLENBQUMsRUFBRSxDQUFDLGVBQWUsRUFBRSxDQUFDLENBQUM7SUFDckQsQ0FBQzs7NEdBTlEsZUFBZTtnSEFBZixlQUFlOzJGQUFmLGVBQWU7a0JBRDNCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBBbmd1bGFyXHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQgeyBSb3V0ZXIgfSBmcm9tIFwiQGFuZ3VsYXIvcm91dGVyXCI7XHJcblxyXG4vLyBDb25maWd1cmF6aW9uaVxyXG5pbXBvcnQgeyBBY2Nlc3NDb250cm9sUm91dGVHdWFyZCwgQWNjZXNzQ29udHJvbFNlcnZpY2UgfSBmcm9tIFwiQGVzZmFlbnphL2FjY2Vzcy1jb250cm9sXCI7XHJcbmltcG9ydCB7IE1lc3NhZ2VTZXJ2aWNlIH0gZnJvbSBcIkBlc2ZhZW56YS9leHRlbnNpb25zXCI7XHJcblxyXG5pbXBvcnQgeyBUb2tlblNlcnZpY2UgfSBmcm9tIFwiLi9hcHAuYWNjZXNzdG9rZW5cIjtcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIEJhc2VSb3V0ZXJHdWFyZCBleHRlbmRzIEFjY2Vzc0NvbnRyb2xSb3V0ZUd1YXJkIHtcclxuICAgIGNvbnN0cnVjdG9yKG1zOiBNZXNzYWdlU2VydmljZSwgYWNjOiBBY2Nlc3NDb250cm9sU2VydmljZSwgcm91dGVyOiBSb3V0ZXIsIHRzOiBUb2tlblNlcnZpY2UpIHtcclxuICAgICAgICBzdXBlcihtcywgYWNjLCByb3V0ZXIpO1xyXG5cclxuICAgICAgICBpZiAoIWFjYy5Jbml0aWFsaXplZClcclxuICAgICAgICAgICAgYWNjLmluaXRpYWxpemVJZGVudGl0eSh0cy5nZXRKYWNlSWRlbnRpdHkoKSk7XHJcbiAgICB9XHJcbn0iXX0=

package/esm2020/services/classes/app.session.mjs

@@ -0,0 +1,33 @@
+// Angular
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./app.accesstoken";
+import * as i2 from "@angular/router";
+export class SessionRetriever {
+    constructor(bts, router) {
+        this.bts = bts;
+        this.router = router;
+    }
+    /** Tenant§Account§User§ModuleId */
+    getSessionKey() {
+        if (this.SessionIdentity)
+            return this.SessionIdentity;
+        // Se non ho un id mi manca il login, quindi via di qua
+        var id = this.bts.getJaceIdentity();
+        if (!id) {
+            console.log("no identity, redirecting to login");
+            this.router.navigate(["login"]);
+            return "";
+        }
+        // TODO: FUCK THIS SHIT
+        this.SessionIdentity = "" + id.Idtenant + "§" + id.IdAccount + "§" + id.IdUser + "§" + "metering";
+        return this.SessionIdentity;
+    }
+}
+SessionRetriever.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionRetriever, deps: [{ token: i1.TokenService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionRetriever.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionRetriever, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionRetriever, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.TokenService }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/classes/app.state.mjs

@@ -0,0 +1,172 @@
+import { Injectable } from "@angular/core";
+// Configurazioni
+import { InboundMessageTypes } from "@esfaenza/extensions";
+import { AdmMessageTypes, MK_ADM } from "@esfaenza/admin-module";
+// Direttive, Componenti, Librerie
+import * as customParseFormat from 'dayjs/plugin/customParseFormat';
+import * as isBetween from 'dayjs/plugin/isBetween';
+import * as minMax from 'dayjs/plugin/minMax';
+import * as utc from 'dayjs/plugin/utc';
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/localizations";
+import * as i2 from "./app.accesstoken";
+import * as i3 from "@esfaenza/signalr-notifications";
+import * as i4 from "@esfaenza/extensions";
+export class AppState {
+    constructor(lc, bts, notifications, MessageDef, intercom) {
+        this.lc = lc;
+        this.bts = bts;
+        this.notifications = notifications;
+        this.MessageDef = MessageDef;
+        this.intercom = intercom;
+        this.Embedded = false;
+        this.redirectingToLogin = false;
+        this.handlingError = false;
+        this.christmasTime = false;
+        this.halloweenTime = false;
+        this.jobsInProgress = 0;
+        this.allJobs = [];
+        this.jobWithIdsCache = {};
+        this.notifyOnCompletedJobs = true;
+        this._data = new Subject();
+        this._dataStream$ = this._data.asObservable();
+        this._subscriptions = new Map();
+        this.ModulesLocalizations = {};
+        this.setupDayjs();
+        this.setupSignalRJobListening();
+        this.JaceIdentity = null;
+        this._dataStream$.subscribe((data) => this._onEvent(data));
+        //Decide se siamo attorno a natale
+        var today = dayjs();
+        var lowerBound = dayjs("18/12/" + today.year(), "DD/MM/YYYY");
+        var upperBound = dayjs("07/01/" + (today.year() + 1), "DD/MM/YYYY");
+        this.christmasTime = today > lowerBound && today < upperBound;
+        //Decide se siamo attorno ad halloween
+        var lowerBound = dayjs("28/10/" + today.year(), "DD/MM/YYYY");
+        var upperBound = dayjs("05/11/" + today.year(), "DD/MM/YYYY");
+        this.halloweenTime = today > lowerBound && today < upperBound;
+        this.intercom.inbounds.subscribe((t) => { this.handleInboundMessage(t); });
+    }
+    registerNavigation(route) {
+        let title = route.data["title"];
+        let internal = route.data["internalNavigation"];
+        /*
+         *  Parent ({url: [{path: "{module}"}]})
+         *      Parent ({url: [{path: ""}]}) (Root del modulo lazy)
+         *          -> Navigazione attuale <-
+         */
+        let module = route.parent?.parent?.url[0]?.path;
+        let loc = module ? this.ModulesLocalizations[module] : null;
+        if (!module)
+            console.error("Impossibile estrapolare il modulo dalla navigazione (Atteso Modulo al secondo livello di parentela partendo dal componente attuale): " + route.pathFromRoot.map(v => v.url.map(segment => segment.toString()).join('/')).join('/'));
+        this.notifyDataChanged(internal ? "menu.adjustSubNavigationTo" : "menu.adjustNavigationTo", loc ? loc.loc(title) : title);
+    }
+    handleInboundMessage(t) {
+        switch (t.type) {
+            case InboundMessageTypes.Navigation:
+                {
+                    this.notifyDataChanged(t.message.sub ? "menu.adjustSubNavigationTo" : "menu.adjustNavigationTo", t.message.routeTitle);
+                    this.intercom.send(AdmMessageTypes.Message, "Navigation Message Received", MK_ADM);
+                }
+        }
+    }
+    setupDayjs() {
+        dayjs.extend(customParseFormat);
+        dayjs.extend(minMax);
+        dayjs.extend(isBetween);
+        dayjs.extend(utc);
+        // Require e collegamento con la localizzazione per dayjs
+        import("dayjs/locale/" + this.lc.SmallLocale + ".js").then(locale => {
+            dayjs.locale(locale);
+        });
+    }
+    setupSignalRJobListening() {
+        this.notifications.observe(this.MessageDef.IN_JobProgressNotification).subscribe((ev) => {
+            var desc = ev.description + " (" + ev.user + ")";
+            let job = {
+                id: ev.instance,
+                description: desc,
+                smalldescription: desc.length > 35 ? desc.substring(0, 30) + "..." : desc,
+                percentage: this.roundToTwo(ev.progress),
+                completed: ev.type == 'Completed',
+                fileid: ev.resultfile,
+                reportid: ev.resultreport,
+                reportpars: ev.resultreportparams,
+                complexreportid: ev.resultcomplexreport
+            };
+            switch (ev.type) {
+                case "Started":
+                    this.jobWithIdsCache[ev.instance] = job;
+                    this.allJobs.splice(0, 0, job);
+                    break;
+                case "Progress":
+                    // Se mi arriva un progress di un job che non ho significa che mi sono loggato ora con dei Job in corso
+                    // quindi per prima cosa devo metterlo in lista
+                    if (!this.jobWithIdsCache[ev.instance]) {
+                        this.jobWithIdsCache[ev.instance] = job;
+                        this.allJobs.splice(0, 0, job);
+                    }
+                    this.jobWithIdsCache[ev.instance].percentage = this.roundToTwo(ev.progress);
+                    break;
+                case "Completed":
+                    if (!this.jobWithIdsCache[ev.instance]) {
+                        this.jobWithIdsCache[ev.instance] = job;
+                        this.allJobs.splice(0, 0, job);
+                    }
+                    var jobToUpdate = this.jobWithIdsCache[ev.instance];
+                    jobToUpdate.percentage = 100;
+                    jobToUpdate.fileid = ev.resultfile;
+                    jobToUpdate.reportid = ev.resultreport;
+                    jobToUpdate.reportpars = ev.resultreportparams;
+                    jobToUpdate.completed = true;
+                    if (this.notifyOnCompletedJobs)
+                        this.notifyDataChanged("app.completedJob", jobToUpdate.description);
+                    break;
+            }
+            this.jobsInProgress = this.allJobs.filter(t => !t.completed).length;
+        });
+    }
+    roundToTwo(num) {
+        return Math.round(num * 100) / 100;
+    }
+    getJaceIDentity() {
+        if (this.JaceIdentity)
+            return this.JaceIdentity;
+        this.JaceIdentity = this.bts.getJaceIdentity();
+        return this.JaceIdentity;
+    }
+    notifyDataChanged(event, value) {
+        this._data[event] = value;
+        this._data.next({
+            event: event,
+            data: this._data[event]
+        });
+    }
+    subscribe(event, callback) {
+        var subscribers = this._subscriptions.get(event) || [];
+        subscribers.push(callback);
+        this._subscriptions.set(event, subscribers);
+    }
+    _onEvent(data) {
+        var subscribers = this._subscriptions.get(data["event"]) || [];
+        subscribers.forEach((callback) => {
+            callback.call(null, data["data"]);
+        });
+    }
+    setSidebarWidth(width) {
+        this.sidebarWidth = width;
+    }
+    setHeaderHeight(height) {
+        this.headerHeight = height;
+    }
+}
+AppState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppState, deps: [{ token: i1.LocalizationService }, { token: i2.TokenService }, { token: i3.NotificationsService }, { token: i3.BaseMessageService }, { token: i4.InterComService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppState, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AppState, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }, { type: i2.TokenService }, { type: i3.NotificationsService }, { type: i3.BaseMessageService }, { type: i4.InterComService }]; } });
+export class ApplicationJob {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.state.js","sourceRoot":"","sources":["../../../../../projects/core/services/src/classes/app.state.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { ActivatedRouteSnapshot } from \"@angular/router\";\r\nimport { Injectable } from \"@angular/core\";\r\n\r\n// Configurazioni\r\nimport { InboundMessageTypes, InterComMessage, InterComService } from \"@esfaenza/extensions\";\r\nimport { BaseMessageService, NotificationsService, JobProgressDto } from \"@esfaenza/signalr-notifications\";\r\nimport { AdmMessageTypes, MK_ADM } from \"@esfaenza/admin-module\";\r\nimport { LocalizationService } from \"@esfaenza/localizations\";\r\nimport { ReportParam } from \"@esfaenza/es-table\";\r\nimport { TokenService } from \"./app.accesstoken\";\r\n\r\nimport { JaceIdentity } from \"@esfaenza/core/domain\";\r\n\r\n// Direttive, Componenti, Librerie\r\nimport * as customParseFormat from 'dayjs/plugin/customParseFormat';\r\nimport * as isBetween from 'dayjs/plugin/isBetween';\r\nimport * as minMax from 'dayjs/plugin/minMax';\r\nimport * as utc from 'dayjs/plugin/utc';\r\nimport { Subject } from \"rxjs\";\r\n\r\ndeclare var dayjs: any;\r\n\r\n@Injectable({ providedIn: \"root\" })\r\nexport class AppState {\r\n\r\n    public Embedded: boolean = false;\r\n\r\n    public sidebarWidth: number;\r\n    public headerHeight: number;\r\n    public redirectingToLogin: boolean = false;\r\n    public handlingError: boolean = false;\r\n    public christmasTime: boolean = false;\r\n    public halloweenTime: boolean = false;\r\n\r\n    // TODO: for the glory of memes\r\n    //public memes: boolean = ((new Date()).getMonth() == 3 && (new Date()).getDate() == 1) || (<any>myconfig).MEMES;\r\n\r\n    private JaceIdentity: JaceIdentity;\r\n\r\n    private msgDef: BaseMessageService;\r\n    public jobsInProgress: number = 0;\r\n    public allJobs: ApplicationJob[] = [];\r\n    private jobWithIdsCache: { [index: string]: ApplicationJob } = {};\r\n    public notifyOnCompletedJobs: boolean = true;\r\n\r\n    private _data = new Subject<Object>();\r\n    private _dataStream$ = this._data.asObservable();\r\n\r\n    private _subscriptions: Map<string, Array<Function>> = new Map<string, Array<Function>>();\r\n\r\n    public ModulesLocalizations: { [id: string]: LocalizationService } = {};\r\n\r\n    constructor(private lc: LocalizationService, private bts: TokenService, private notifications: NotificationsService, private MessageDef: BaseMessageService, private intercom: InterComService) {\r\n        this.setupDayjs();\r\n        this.setupSignalRJobListening();\r\n\r\n        this.JaceIdentity = null;\r\n        this._dataStream$.subscribe((data) => this._onEvent(data));\r\n\r\n        //Decide se siamo attorno a natale\r\n        var today = dayjs();\r\n        var lowerBound = dayjs(\"18/12/\" + today.year(), \"DD/MM/YYYY\");\r\n        var upperBound = dayjs(\"07/01/\" + (today.year() + 1), \"DD/MM/YYYY\");\r\n        this.christmasTime = today > lowerBound && today < upperBound;\r\n\r\n        //Decide se siamo attorno ad halloween\r\n        var lowerBound = dayjs(\"28/10/\" + today.year(), \"DD/MM/YYYY\");\r\n        var upperBound = dayjs(\"05/11/\" + today.year(), \"DD/MM/YYYY\");\r\n        this.halloweenTime = today > lowerBound && today < upperBound;\r\n\r\n        this.intercom.inbounds.subscribe((t: InterComMessage) => { this.handleInboundMessage(t); });\r\n    }\r\n\r\n    registerNavigation(route?: ActivatedRouteSnapshot) {\r\n        let title = route.data[\"title\"];\r\n        let internal = route.data[\"internalNavigation\"]\r\n\r\n        /*\r\n         *  Parent ({url: [{path: \"{module}\"}]})\r\n         *      Parent ({url: [{path: \"\"}]}) (Root del modulo lazy)\r\n         *          -> Navigazione attuale <-\r\n         */\r\n        let module = route.parent?.parent?.url[0]?.path;\r\n        let loc = module ? this.ModulesLocalizations[module] : null;\r\n\r\n        if (!module)\r\n            console.error(\"Impossibile estrapolare il modulo dalla navigazione (Atteso Modulo al secondo livello di parentela partendo dal componente attuale): \" + route.pathFromRoot.map(v => v.url.map(segment => segment.toString()).join('/')).join('/'));\r\n\r\n        this.notifyDataChanged(internal ? \"menu.adjustSubNavigationTo\" : \"menu.adjustNavigationTo\", loc ? loc.loc(title) : title);\r\n    }\r\n\r\n    handleInboundMessage(t: InterComMessage) {\r\n        switch (t.type) {\r\n            case InboundMessageTypes.Navigation:\r\n                {\r\n                    this.notifyDataChanged(t.message.sub ? \"menu.adjustSubNavigationTo\" : \"menu.adjustNavigationTo\", t.message.routeTitle);\r\n                    this.intercom.send(AdmMessageTypes.Message, \"Navigation Message Received\", MK_ADM);\r\n                }\r\n        }\r\n    }\r\n\r\n    setupDayjs() {\r\n        dayjs.extend(customParseFormat);\r\n        dayjs.extend(minMax);\r\n        dayjs.extend(isBetween);\r\n        dayjs.extend(utc);\r\n\r\n        // Require e collegamento con la localizzazione per dayjs\r\n        import(\"dayjs/locale/\" + this.lc.SmallLocale + \".js\").then(locale => {\r\n            dayjs.locale(locale);\r\n        });\r\n    }\r\n\r\n    setupSignalRJobListening() {\r\n        this.notifications.observe(this.MessageDef.IN_JobProgressNotification).subscribe((ev: JobProgressDto) => {\r\n            var desc = ev.description + \" (\" + ev.user + \")\";\r\n            let job: ApplicationJob = {\r\n                id: ev.instance,\r\n                description: desc,\r\n                smalldescription: desc.length > 35 ? desc.substring(0, 30) + \"...\" : desc,\r\n                percentage: this.roundToTwo(ev.progress),\r\n                completed: ev.type == 'Completed',\r\n                fileid: ev.resultfile,\r\n                reportid: ev.resultreport,\r\n                reportpars: ev.resultreportparams,\r\n                complexreportid: ev.resultcomplexreport\r\n            };\r\n\r\n            switch (ev.type) {\r\n                case \"Started\":\r\n                    this.jobWithIdsCache[ev.instance] = job;\r\n                    this.allJobs.splice(0, 0, job);\r\n                    break;\r\n                case \"Progress\":\r\n                    // Se mi arriva un progress di un job che non ho significa che mi sono loggato ora con dei Job in corso\r\n                    // quindi per prima cosa devo metterlo in lista\r\n                    if (!this.jobWithIdsCache[ev.instance]) {\r\n                        this.jobWithIdsCache[ev.instance] = job;\r\n                        this.allJobs.splice(0, 0, job);\r\n                    }\r\n                    this.jobWithIdsCache[ev.instance].percentage = this.roundToTwo(ev.progress);\r\n                    break;\r\n                case \"Completed\":\r\n                    if (!this.jobWithIdsCache[ev.instance]) {\r\n                        this.jobWithIdsCache[ev.instance] = job;\r\n                        this.allJobs.splice(0, 0, job);\r\n                    }\r\n                    var jobToUpdate = this.jobWithIdsCache[ev.instance];\r\n                    jobToUpdate.percentage = 100;\r\n                    jobToUpdate.fileid = ev.resultfile;\r\n                    jobToUpdate.reportid = ev.resultreport;\r\n                    jobToUpdate.reportpars = ev.resultreportparams;\r\n                    jobToUpdate.completed = true;\r\n\r\n                    if (this.notifyOnCompletedJobs)\r\n                        this.notifyDataChanged(\"app.completedJob\", jobToUpdate.description);\r\n\r\n                    break;\r\n            }\r\n\r\n            this.jobsInProgress = this.allJobs.filter(t => !t.completed).length;\r\n        });\r\n    }\r\n\r\n    roundToTwo(num) {\r\n        return Math.round(num * 100) / 100;\r\n    }\r\n\r\n    getJaceIDentity(): JaceIdentity {\r\n        if (this.JaceIdentity)\r\n            return this.JaceIdentity;\r\n        this.JaceIdentity = this.bts.getJaceIdentity();\r\n        return this.JaceIdentity;\r\n    }\r\n\r\n    notifyDataChanged(event, value) {\r\n        this._data[event] = value;\r\n        this._data.next({\r\n            event: event,\r\n            data: this._data[event]\r\n        });\r\n    }\r\n\r\n    subscribe(event: string, callback: Function) {\r\n        var subscribers = this._subscriptions.get(event) || [];\r\n        subscribers.push(callback);\r\n\r\n        this._subscriptions.set(event, subscribers);\r\n    }\r\n\r\n    _onEvent(data: any) {\r\n        var subscribers = this._subscriptions.get(data[\"event\"]) || [];\r\n\r\n        subscribers.forEach((callback) => {\r\n            callback.call(null, data[\"data\"]);\r\n        });\r\n    }\r\n\r\n    public setSidebarWidth(width: number) {\r\n        this.sidebarWidth = width;\r\n    }\r\n\r\n    public setHeaderHeight(height: number) {\r\n        this.headerHeight = height;\r\n    }\r\n}\r\n\r\nexport class ApplicationJob {\r\n    id: string;\r\n    description: string;\r\n    smalldescription: string;\r\n    percentage: number;\r\n    completed: boolean;\r\n    fileid: string;\r\n    reportid: string;\r\n    complexreportid: string;\r\n    reportpars: ReportParam[];\r\n}"]}