ets-fe-ng-sdk 0.0.7 → 1.0.0

package/README.md

@@ -4,18 +4,6 @@ This library was generated for use in Angular ETS projects
 
 # New Features
 
-Added the following:
-
-environment.model
-
-form-schema.model
-
-form.class
-
-IMenuItem
-
-index.model
-
-RouteItem.class
+Migrated Shared modules. This is the first stable build.
 
 # Bug Fixes

package/esm2020/lib/Reusables/reusable-pages/logger/logger.interface.mjs

@@ -0,0 +1,21 @@
+export class Log {
+    constructor(data) {
+        Object.assign(this, data);
+        if (data.payload instanceof FormData) {
+            this.payload = null;
+            data.payload.forEach((file) => {
+                if (!(!file || file == undefined || file == null))
+                    if (file instanceof File) {
+                        this.files.push({ size: file.size, title: file.name, type: file.type });
+                    }
+                    else {
+                        this.payload = { ...this.payload, ...JSON.parse(file) };
+                    }
+            });
+        }
+        this.route = this.route || location.pathname;
+        this.time = Date.now();
+        this.id = 'id' + Math.round(Math.random() * 1000000);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/Reusables/reusable-pages/logger/logger.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { Log } from './logger.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "@Services/storage.service";
+export class LoggerService {
+    constructor(sS) {
+        this.sS = sS;
+        this.logAuthKey = 'logAuth';
+        this.logsKey = 'logs';
+        this._logs = [];
+        this.pwd = '1234';
+        setInterval(() => {
+            this.getLogs();
+        }, 1000);
+        this.checkAuth();
+    }
+    get logs() {
+        return this._logs;
+    }
+    addLog(log) {
+        this.pushLog(new Log(log));
+    }
+    pushLog(log) {
+        if (!Array.isArray(this._logs))
+            this._logs = [];
+        this._logs?.sort2('time').reverse();
+        if (this._logs.length >= 30)
+            this._logs.pop();
+        this._logs.unshift(log);
+        this.saveToLocal();
+    }
+    saveToLocal() {
+        this.sS.saveItem(this.logsKey, this._logs);
+    }
+    unlock() {
+        this.sS.saveItem(this.logAuthKey, this.pwd);
+        this.checkAuth();
+    }
+    lock() {
+        this.sS.removeItem(this.logAuthKey);
+        this.checkAuth();
+    }
+    getLogs() {
+        this.sS
+            .getItemA(this.logsKey)
+            .then((r) => (this._logs = r?.sort2('time').reverse() || []));
+        return this._logs;
+    }
+    checkAuth() {
+        this._isAuthed = this.sS.getItem(this.logAuthKey) == this.pwd;
+    }
+    get isAuthed() {
+        return this._isAuthed;
+    }
+}
+LoggerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: LoggerService, deps: [{ token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+LoggerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: LoggerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.StorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/Reusables/reusable-pages/user-activity/ua-extras/user-activity.model.mjs

@@ -0,0 +1,25 @@
+import { environment } from "@environments/environment";
+export class UserActivity {
+    constructor(data) {
+        Object.assign(this, data);
+        this.activityDescription = (codeToDescriptionMap.find((x) => x.key == this.code)?.value +
+            ' ' +
+            (this.activityDescription ? `{${this.activityDescription}}` : ''))?.trim();
+        this.pageUrl = this.pageUrl || location.href;
+        this.pageTitle = this.pageTitle || environment.pageTitle;
+    }
+}
+export var EUA;
+(function (EUA) {
+    EUA["exported"] = "export";
+    EUA["visited"] = "visited";
+    EUA["searched"] = "searched";
+    EUA["downloaded"] = "downloaded";
+})(EUA || (EUA = {}));
+const codeToDescriptionMap = [
+    { key: EUA.exported, value: 'Exported data' },
+    { key: EUA.visited, value: 'User visited new page' },
+    { key: EUA.searched, value: 'User performed a search' },
+    { key: EUA.downloaded, value: 'User downloaded an item' },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/Reusables/reusable-pages/user-activity/ua-extras/user-activity.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { clone } from 'lodash-es';
+import { environment } from '@environments/environment';
+import { UserActivity } from './user-activity.model';
+import * as i0 from "@angular/core";
+export class UserActivityService {
+    constructor() {
+        this.activities = [];
+        this.add = (data) => {
+            if (environment.production)
+                this.activities.push(new UserActivity(data));
+        };
+        setInterval(() => {
+            if (!this.activities?.length)
+                return;
+            const activities = clone(this.activities);
+            this.activities = [];
+            this.submissionFunc(activities).toPromise();
+        }, 1000);
+    }
+}
+UserActivityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UserActivityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+UserActivityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UserActivityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: UserActivityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1hY3Rpdml0eS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXRzLWZlLW5nLXNkay9zcmMvbGliL1JldXNhYmxlcy9yZXVzYWJsZS1wYWdlcy91c2VyLWFjdGl2aXR5L3VhLWV4dHJhcy91c2VyLWFjdGl2aXR5LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV4RCxPQUFPLEVBQWlCLFlBQVksRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQUtwRSxNQUFNLE9BQU8sbUJBQW1CO0lBRzlCO1FBRlEsZUFBVSxHQUFvQixFQUFFLENBQUM7UUFXekMsUUFBRyxHQUFHLENBQUMsSUFBbUIsRUFBRSxFQUFFO1lBQzVCLElBQUksV0FBVyxDQUFDLFVBQVU7Z0JBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUMzRSxDQUFDLENBQUM7UUFWQSxXQUFXLENBQUMsR0FBRyxFQUFFO1lBQ2YsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsTUFBTTtnQkFBRSxPQUFPO1lBQ3JDLE1BQU0sVUFBVSxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDMUMsSUFBSSxDQUFDLFVBQVUsR0FBRyxFQUFFLENBQUM7WUFDckIsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUM5QyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDWCxDQUFDOztnSEFWVSxtQkFBbUI7b0hBQW5CLG1CQUFtQixjQUZsQixNQUFNOzJGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBjbG9uZSB9IGZyb20gJ2xvZGFzaC1lcyc7XG5pbXBvcnQgeyBlbnZpcm9ubWVudCB9IGZyb20gJ0BlbnZpcm9ubWVudHMvZW52aXJvbm1lbnQnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgSVVzZXJBY3Rpdml0eSwgVXNlckFjdGl2aXR5IH0gZnJvbSAnLi91c2VyLWFjdGl2aXR5Lm1vZGVsJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFVzZXJBY3Rpdml0eVNlcnZpY2Uge1xuICBwcml2YXRlIGFjdGl2aXRpZXM6IElVc2VyQWN0aXZpdHlbXSA9IFtdO1xuICBzdWJtaXNzaW9uRnVuYzogKGFjdGl2aXRpZXM6IFVzZXJBY3Rpdml0eVtdKSA9PiBPYnNlcnZhYmxlPGFueT47XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHNldEludGVydmFsKCgpID0+IHtcbiAgICAgIGlmICghdGhpcy5hY3Rpdml0aWVzPy5sZW5ndGgpIHJldHVybjtcbiAgICAgIGNvbnN0IGFjdGl2aXRpZXMgPSBjbG9uZSh0aGlzLmFjdGl2aXRpZXMpO1xuICAgICAgdGhpcy5hY3Rpdml0aWVzID0gW107XG4gICAgICB0aGlzLnN1Ym1pc3Npb25GdW5jKGFjdGl2aXRpZXMpLnRvUHJvbWlzZSgpO1xuICAgIH0sIDEwMDApO1xuICB9XG5cbiAgYWRkID0gKGRhdGE6IElVc2VyQWN0aXZpdHkpID0+IHtcbiAgICBpZiAoZW52aXJvbm1lbnQucHJvZHVjdGlvbikgdGhpcy5hY3Rpdml0aWVzLnB1c2gobmV3IFVzZXJBY3Rpdml0eShkYXRhKSk7XG4gIH07XG59XG4iXX0=

package/esm2020/lib/Services/api.service.mjs

@@ -0,0 +1,280 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders, HttpRequest, } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError, map, retry, tap } from 'rxjs/operators';
+import { environment } from '@environments/environment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./cache/cache.service";
+import * as i3 from "./cache/local-cache.service";
+export class ApiService {
+    constructor(http, cacheS, lCacheS) {
+        this.http = http;
+        this.cacheS = cacheS;
+        this.lCacheS = lCacheS;
+        this.showRoutes = 0;
+        this.retryCount = 0;
+        this.handleRequestError = (err) => {
+            let message;
+            if (err?.error instanceof ArrayBuffer)
+                message = String.fromCharCode.apply(null, new Uint8Array(err?.error));
+            return throwError(message || err?.error?.message);
+        };
+        //#endregion
+        //#region GET
+        this.get = (route, parameters, extras) => {
+            this.logRoutes('get', route, parameters);
+            return new Observable((res) => {
+                const query = route + this.getRequestParse(parameters);
+                // if (this.cacheS.has(query)) {
+                //   res.next(this.cacheS.getItem<T>(route));
+                // }
+                this.http
+                    .get(query, {
+                    headers: new HttpHeaders(this.headers),
+                    responseType: 'json',
+                    ...extras?.options,
+                })
+                    .pipe(retry(this.retryCount), tap((x) => (this.showRoutes ? console.log(x) : null)), map((res) => {
+                    if (Array.isArray(res))
+                        if (res[0]?.code)
+                            return res.sort().sort2('code', true);
+                        else if (res[0]?.columnName)
+                            return res.sort().sort2('columnName', true);
+                        else
+                            return res.sort();
+                    return res;
+                }), catchError(this.handleRequestError))
+                    .toPromise()
+                    .then((r) => {
+                    res.next(r);
+                    this.cacheS.setItem(query, r);
+                    res.complete();
+                })
+                    .catch((err) => res.error(err));
+            });
+        };
+        this.getCodes = (route) => this.get(route).pipe(map((res) => this.sortCodes(res)));
+        this.getText = (route, parameters) => this.get(route, parameters, {
+            options: {
+                headers: new HttpHeaders(this.headers),
+                responseType: 'text',
+            },
+        });
+        this.getFile = (route, parameters) => this.get(route, parameters, {
+            options: {
+                headers: new HttpHeaders(this.headers),
+                responseType: 'arrayBuffer',
+            },
+        });
+        this.getWithBody = (route, body, extras) => {
+            this.logRoutes('get', route);
+            // debugger
+            const req = new HttpRequest('GET', route, body, extras?.options || {
+                headers: new HttpHeaders(this.headers),
+                responseType: 'json',
+            });
+            return this.http
+                .request(req)
+                .pipe(catchError(this.handleRequestError));
+        };
+        this.getFromlocal = (route, parameters, options) => {
+            return new Observable((res) => {
+                const query = route + this.getRequestParse(parameters);
+                if (this.lCacheS.has(query)) {
+                    res.next(this.lCacheS.getItem(query));
+                    res.complete();
+                }
+                else
+                    this.get(query, null, options)
+                        .toPromise()
+                        .then((r) => {
+                        // if (!this.cS.has(route))
+                        res.next(r);
+                        this.lCacheS.setItem(query, r);
+                        res.complete();
+                    });
+            });
+        };
+        this.getWithLocalCache = (route, parameters, options) => {
+            return new Observable((res) => {
+                const query = route + this.getRequestParse(parameters);
+                if (this.lCacheS.has(query)) {
+                    res.next(this.lCacheS.getItem(query));
+                }
+                this.get(query, null, options)
+                    .toPromise()
+                    .then((r) => {
+                    // if (!this.cS.has(route))
+                    res.next(r);
+                    this.lCacheS.setItem(query, r);
+                    res.complete();
+                })
+                    .catch((e) => {
+                    res.error(e);
+                    res.complete();
+                });
+            });
+        };
+        //#endregion
+        //#region DELETE
+        this.delete = (route, options) => {
+            this.logRoutes('delete', route);
+            return this.http
+                .delete(route, options || {
+                headers: new HttpHeaders(this.headers),
+                responseType: 'json',
+            })
+                .pipe(catchError(this.handleRequestError));
+        };
+        this.deleteWithBody = (route, body, options) => {
+            this.logRoutes('delete', route);
+            const req = new HttpRequest('DELETE', route, body, options || {
+                headers: new HttpHeaders(this.headers),
+                responseType: 'json',
+            });
+            return this.http
+                .request(req)
+                .pipe(catchError(this.handleRequestError));
+        };
+        this.deleteText = (route) => this.delete(route, {
+            headers: new HttpHeaders(this.headers),
+            responseType: 'text',
+        });
+        //#endregion
+        this.sortCodes = (data) => {
+            return data?.sort2('code', true)?.sort2('code');
+        };
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+        };
+    }
+    get fileHeaders() {
+        return {
+            enctype: 'multipart/form-data',
+        };
+    }
+    logRoutes(method, route, ...extras) {
+        if (this.showRoutes) {
+            console.log(method, route, ...extras);
+        }
+    }
+    //#region PATCH
+    patch(route, body, options) {
+        this.logRoutes('post', route, body);
+        console.log(body);
+        return this.http
+            .patch(encodeURI(route), body, {
+            headers: new HttpHeaders(this.headers),
+            responseType: 'json',
+            ...options,
+        })
+            .pipe(catchError(this.handleRequestError));
+    }
+    //#endregion
+    //#region POST
+    post(route, body, extras) {
+        this.logRoutes('post', route, body);
+        console.log(body);
+        return this.http
+            .post(encodeURI(route), body, {
+            headers: new HttpHeaders(this.headers),
+            responseType: 'json',
+            ...extras?.options,
+        })
+            .pipe(catchError(this.handleRequestError));
+    }
+    postFile(route, body) {
+        return this.post(route, body, {
+            options: {
+                headers: new HttpHeaders(this.fileHeaders),
+                responseType: 'json',
+            },
+        });
+    }
+    postFileWithEndorsement(route, body) {
+        return this.post(route, body, {
+            options: {
+                headers: new HttpHeaders(this.fileHeaders).set('useEndorsement', 'true'),
+                responseType: 'json',
+            },
+        });
+    }
+    postString(route, body) {
+        console.log('requestCount', ++environment.requestCount);
+        return this.post(route, body, {
+            options: {
+                headers: new HttpHeaders({
+                    'Content-Type': 'text/plain',
+                }),
+                responseType: 'text',
+            },
+        });
+    }
+    postStringWithLocalCache(route, body) {
+        return new Observable((res) => {
+            const bdy = body?.trim();
+            // debugger
+            if (this.lCacheS.has(route + '_' + bdy)) {
+                res.next(this.lCacheS.getItem(route + '_' + bdy));
+            }
+            this.postString(route, bdy)
+                .toPromise()
+                .then((r) => {
+                res.next(r);
+                this.lCacheS.setItem(route + '_' + bdy, r);
+                res.complete();
+            })
+                .catch((e) => {
+                res.error(e);
+            });
+        });
+    }
+    getRequestParse(parameters) {
+        // const nbody = new URLSearchParams();
+        // for (const key in parameters) {
+        //   if (Object.prototype.hasOwnProperty.call(parameters, key)) {
+        //     const element = parameters[key];
+        //     if (element != null) nbody.set(key, element + '');
+        //   }
+        // }
+        // const str = nbody.toString();
+        // if(parameters)
+        // debugger;
+        if (!parameters)
+            return '';
+        return ('?' +
+            Object.keys(parameters)
+                .filter((key) => parameters[key]?.toString()?.trim() != null)
+                .map((key) => `${key}=${parameters[key]?.toString()?.trim()}`)
+                .join('&'));
+    }
+    //#endregion
+    //#region PUT
+    put(route, body, extras) {
+        this.logRoutes('put', route, body);
+        let query = route + '', nbody = body;
+        if (extras?.requestType == 'queryParams') {
+            query += this.getRequestParse(body);
+            nbody = null;
+        }
+        return this.http
+            .put(query, nbody, {
+            headers: new HttpHeaders(this.headers),
+            responseType: 'json',
+            ...extras?.options,
+        })
+            .pipe(catchError(this.handleRequestError));
+    }
+}
+ApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ApiService, deps: [{ token: i1.HttpClient }, { token: i2.CacheService }, { token: i3.LocalCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.CacheService }, { type: i3.LocalCacheService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../projects/ets-fe-ng-sdk/src/lib/Services/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  HttpClient,\n  HttpErrorResponse,\n  HttpHeaders,\n  HttpRequest,\n} from '@angular/common/http';\nimport { iif, Observable, throwError } from 'rxjs';\nimport { catchError, map, retry, tap } from 'rxjs/operators';\nimport { ICodeDescription, ICodeTitle } from '../Shared/models/index.model';\nimport { environment } from '@environments/environment';\nimport { CacheService } from './cache/cache.service';\nimport { LocalCacheService } from './cache/local-cache.service';\nexport interface IResponse {\n  message: string;\n  result: any;\n  status: 'success' | 'error' | 'failure';\n  statusCode: 'SM000' | 'SM001' | 'SM002' | 'SM003';\n}\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApiService {\n  private showRoutes = 0;\n  private get headers() {\n    return {\n      'Content-Type': 'application/json',\n    };\n  }\n  private get fileHeaders() {\n    return {\n      enctype: 'multipart/form-data',\n    };\n  }\n  private retryCount = 0;\n  constructor(\n    public http: HttpClient,\n    public cacheS: CacheService,\n    public lCacheS: LocalCacheService\n  ) {}\n\n  private logRoutes(\n    method: 'get' | 'post' | 'put' | 'delete',\n    route,\n    ...extras\n  ) {\n    if (this.showRoutes) {\n      console.log(method, route, ...extras);\n    }\n  }\n  private handleRequestError = (err: HttpErrorResponse) => {\n    let message;\n    if (err?.error instanceof ArrayBuffer)\n      message = String.fromCharCode.apply(null, new Uint8Array(err?.error));\n    return throwError(message || err?.error?.message);\n  };\n\n  //#region PATCH\n  patch<T = any>(route: string, body?, options?: any): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    return this.http\n      .patch(encodeURI(route), body, {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'json',\n        ...options,\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  //#endregion\n  //#region POST\n  post<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    return this.http\n      .post(encodeURI(route), body, {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'json',\n        ...extras?.options,\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  postFile<T = any>(route: string, body: FormData) {\n    return this.post<T>(route, body, {\n      options: {\n        headers: new HttpHeaders(this.fileHeaders),\n        responseType: 'json',\n      },\n    });\n  }\n  postFileWithEndorsement<T = any>(route: string, body: FormData) {\n    return this.post<T>(route, body, {\n      options: {\n        headers: new HttpHeaders(this.fileHeaders).set(\n          'useEndorsement',\n          'true'\n        ),\n        responseType: 'json',\n      },\n    });\n  }\n  postString(route: string, body?) {\n    console.log('requestCount', ++environment.requestCount);\n    return this.post<string>(route, body, {\n      options: {\n        headers: new HttpHeaders({\n          'Content-Type': 'text/plain',\n        }),\n        responseType: 'text',\n      },\n    });\n  }\n  postStringWithLocalCache(route: string, body: string) {\n    return new Observable<string>((res) => {\n      const bdy = body?.trim();\n      // debugger\n      if (this.lCacheS.has(route + '_' + bdy)) {\n        res.next(this.lCacheS.getItem<string>(route + '_' + bdy));\n      }\n\n      this.postString(route, bdy)\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          this.lCacheS.setItem(route + '_' + bdy, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n        });\n    });\n  }\n  //#endregion\n\n  //#region GET\n  get = <T = any>(\n    route: string,\n    parameters?: Object,\n    extras?: IExtras\n  ): Observable<T> => {\n    this.logRoutes('get', route, parameters);\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      // if (this.cacheS.has(query)) {\n      //   res.next(this.cacheS.getItem<T>(route));\n      // }\n      this.http\n        .get(query, {\n          headers: new HttpHeaders(this.headers),\n          responseType: 'json',\n          ...extras?.options,\n        })\n        .pipe(\n          retry(this.retryCount),\n          tap((x) => (this.showRoutes ? console.log(x) : null)),\n          map((res: any) => {\n            if (Array.isArray(res))\n              if (res[0]?.code) return res.sort().sort2('code', true);\n              else if (res[0]?.columnName)\n                return res.sort().sort2('columnName', true);\n              else return res.sort();\n            return res;\n          }),\n          catchError(this.handleRequestError)\n        )\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          this.cacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((err) => res.error(err));\n    });\n  };\n\n  getCodes = <T = ICodeTitle & ICodeDescription>(route: string) =>\n    this.get<T[]>(route).pipe(map((res) => this.sortCodes(res)));\n\n  getText = <T = string>(route: string, parameters?: Object) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'text',\n      },\n    });\n  getFile = <T = string>(route: string, parameters?: Object) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'arrayBuffer',\n      },\n    });\n  getWithBody = <T = any>(route: string, body?: any, extras?: IExtras) => {\n    this.logRoutes('get', route);\n    // debugger\n    const req = new HttpRequest(\n      'GET',\n      route,\n      body,\n      extras?.options || {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'json',\n      }\n    );\n    return this.http\n      .request<T>(req)\n      .pipe(catchError(this.handleRequestError)) as Observable<T>;\n  };\n\n  getFromlocal = <T = any>(\n    route: string,\n    parameters?: Object,\n    options?: any\n  ) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n        res.complete();\n      } else\n        this.get(query, null, options)\n          .toPromise()\n          .then((r) => {\n            // if (!this.cS.has(route))\n            res.next(r);\n            this.lCacheS.setItem(query, r);\n            res.complete();\n          });\n    });\n  };\n  getWithLocalCache = <T = any>(\n    route: string,\n    parameters?: Object,\n    options?: any\n  ) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n      }\n      this.get(query, null, options)\n        .toPromise()\n        .then((r) => {\n          // if (!this.cS.has(route))\n          res.next(r);\n          this.lCacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n          res.complete();\n        });\n    });\n  };\n  getRequestParse(parameters?: Object) {\n    // const nbody = new URLSearchParams();\n    // for (const key in parameters) {\n    //   if (Object.prototype.hasOwnProperty.call(parameters, key)) {\n    //     const element = parameters[key];\n    //     if (element != null) nbody.set(key, element + '');\n    //   }\n    // }\n    // const str = nbody.toString();\n    // if(parameters)\n    // debugger;\n    if (!parameters) return '';\n    return (\n      '?' +\n      Object.keys(parameters)\n        .filter((key) => parameters[key]?.toString()?.trim() != null)\n        .map((key) => `${key}=${parameters[key]?.toString()?.trim()}`)\n        .join('&')\n    );\n  }\n  //#endregion\n\n  //#region PUT\n  put<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('put', route, body);\n    let query = route + '',\n      nbody = body;\n    if (extras?.requestType == 'queryParams') {\n      query += this.getRequestParse(body);\n      nbody = null;\n    }\n    return this.http\n      .put(query, nbody, {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'json',\n        ...extras?.options,\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  //#endregion\n\n  //#region DELETE\n  delete = <T = any>(route: string, options?) => {\n    this.logRoutes('delete', route);\n    return this.http\n      .delete<T>(\n        route,\n        options || {\n          headers: new HttpHeaders(this.headers),\n          responseType: 'json',\n        }\n      )\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteWithBody = <T = any>(route: string, body?: any, options?) => {\n    this.logRoutes('delete', route);\n    const req = new HttpRequest(\n      'DELETE',\n      route,\n      body,\n      options || {\n        headers: new HttpHeaders(this.headers),\n        responseType: 'json',\n      }\n    );\n    return this.http\n      .request<T>(req)\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteText = (route: string) =>\n    this.delete<string>(route, {\n      headers: new HttpHeaders(this.headers),\n      responseType: 'text',\n    });\n  //#endregion\n\n  sortCodes = <T>(data: T[]) => {\n    return data?.sort2('code', true)?.sort2('code') as any as T[];\n  };\n}\n\ninterface IExtras {\n  noFormat?: boolean;\n  options?: any;\n  requestType?: 'queryParams';\n}\n"]}

package/esm2020/lib/Services/app.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { environment } from '@environments/environment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "./translation.service";
+export class AppService {
+    constructor(titleS, translator) {
+        this.titleS = titleS;
+        this.translator = translator;
+        this.topMenu = environment.menus;
+        this.bottomMenu = [];
+        this.systemMetadataMap = new Map([]);
+        this.addTitle = (title, translate = environment.translate) => {
+            environment.pageTitle = title;
+            if (!translate)
+                this.titleS.setTitle((title ? title + ' | ' : '') +
+                    environment.appName +
+                    ' | ' +
+                    environment.name);
+            else
+                this.translator
+                    .translateHTML((title ? title + ' | ' : '') +
+                    environment.appName +
+                    ' | ' +
+                    environment.name)
+                    .subscribe((r) => {
+                    this.titleS.setTitle(r);
+                }, (e) => {
+                    this.addTitle(title, false);
+                });
+        };
+        this.filterNavMenuFunc = (value) => !value.locations?.size;
+        this.busLines = [];
+    }
+    get system() {
+        return this._system;
+    }
+    set system(value) {
+        this._system = value;
+        environment.currentSystem = value;
+        document.getElementsByTagName('body')[0].className =
+            value?.toString() || value;
+        this.bottomMenu = this.topMenu.find((x) => x.system == value)?.subs;
+        // debugger
+        document.documentElement.style.setProperty('--primary', this.getCurrentSystemMetadata.colourCode);
+    }
+    get currentTopMenu() {
+        return this._currentTopMenu;
+    }
+    set currentTopMenu(value) {
+        this._currentTopMenu = value;
+        this.bottomMenu = value.subs;
+        // debugger
+    }
+    async setCurrentTopMenu(system) {
+        this.currentTopMenu = this.topMenu.find((x) => x.system == system);
+    }
+    get getFirstAvailableSystem() {
+        return this.systemMetadataMap.get(environment.activeSystems?.length
+            ? environment.activeSystems[0]
+            : this.systemMetadataMap.keys[0]);
+    }
+    get getCurrentSystemMetadata() {
+        return this.systemMetadataMap.get(this.system);
+    }
+    setDefaultClass() {
+        document.getElementsByTagName('body')[0].className =
+            this.getFirstAvailableSystem.name?.toString();
+    }
+    get busLine() {
+        return this.getCurrentSystemMetadata?.busline;
+    }
+    get activeSystems() {
+        return environment.activeSystems?.length
+            ? this.topMenu.filter((x) => environment.activeSystems.includes(x.system))
+            : this.topMenu;
+    }
+    get hasBusLine() {
+        return !!this.getCurrentSystemMetadata?.busline;
+    }
+    //#region pagename
+    get pageName() {
+        return this._pageName;
+    }
+    set pageName(value) {
+        this._pageName = value;
+        this.addTitle(this._pageName);
+    }
+    //#endregion
+    setMetaTheme() {
+        const metaTag = document.getElementById('metaThemeColour');
+        metaTag.content = this.getCurrentSystemMetadata.colourCode;
+    }
+}
+AppService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AppService, deps: [{ token: i1.Title }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AppService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AppService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Title }, { type: i2.TranslationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.service.js","sourceRoot":"","sources":["../../../../../projects/ets-fe-ng-sdk/src/lib/Services/app.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Title } from '@angular/platform-browser';\nimport { environment } from '@environments/environment';\nimport {\n  ESystem,\n  ESystemBusLine,\n  ISystem,\n  IValueLabel,\n} from '../Shared/models/index.model';\nimport { MenuItem } from '../Shared/models/IMenuItem';\nimport { TranslationService } from './translation.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AppService {\n  topMenu = environment.menus;\n  bottomMenu: MenuItem[] = [];\n  private _currentTopMenu: MenuItem;\n  private _system: ESystem;\n  private _pageName: string;\n  public get system(): ESystem {\n    return this._system;\n  }\n  public set system(value: ESystem) {\n    this._system = value;\n    environment.currentSystem = value;\n    document.getElementsByTagName('body')[0].className =\n      value?.toString() || (value as any);\n    this.bottomMenu = this.topMenu.find((x) => x.system == value)?.subs;\n    // debugger\n    document.documentElement.style.setProperty(\n      '--primary',\n      this.getCurrentSystemMetadata.colourCode\n    );\n  }\n  public get currentTopMenu(): MenuItem {\n    return this._currentTopMenu;\n  }\n  public set currentTopMenu(value: MenuItem) {\n    this._currentTopMenu = value;\n    this.bottomMenu = value.subs;\n    // debugger\n  }\n  async setCurrentTopMenu(system: ESystem) {\n    this.currentTopMenu = this.topMenu.find((x) => x.system == system);\n  }\n  systemMetadataMap = new Map<ESystem, ISystem>([]);\n  get getFirstAvailableSystem() {\n    return this.systemMetadataMap.get(\n      environment.activeSystems?.length\n        ? environment.activeSystems[0]\n        : this.systemMetadataMap.keys[0]\n    );\n  }\n  get getCurrentSystemMetadata() {\n    return this.systemMetadataMap.get(this.system);\n  }\n\n  constructor(public titleS: Title, public translator: TranslationService) {}\n\n  setDefaultClass() {\n    document.getElementsByTagName('body')[0].className =\n      this.getFirstAvailableSystem.name?.toString();\n  }\n  get busLine() {\n    return this.getCurrentSystemMetadata?.busline;\n  }\n  get activeSystems() {\n    return environment.activeSystems?.length\n      ? this.topMenu.filter((x) => environment.activeSystems.includes(x.system))\n      : this.topMenu;\n  }\n  get hasBusLine() {\n    return !!this.getCurrentSystemMetadata?.busline;\n  }\n\n  //#region pagename\n  get pageName() {\n    return this._pageName;\n  }\n  set pageName(value: string) {\n    this._pageName = value;\n    this.addTitle(this._pageName);\n  }\n  addTitle = (title, translate = environment.translate) => {\n    environment.pageTitle = title;\n    if (!translate)\n      this.titleS.setTitle(\n        (title ? title + ' | ' : '') +\n          environment.appName +\n          ' | ' +\n          environment.name\n      );\n    else\n      this.translator\n        .translateHTML(\n          (title ? title + ' | ' : '') +\n            environment.appName +\n            ' | ' +\n            environment.name\n        )\n        .subscribe(\n          (r) => {\n            this.titleS.setTitle(r);\n          },\n          (e) => {\n            this.addTitle(title, false);\n          }\n        );\n  };\n  //#endregion\n  setMetaTheme() {\n    const metaTag: HTMLMetaElement = document.getElementById(\n      'metaThemeColour'\n    ) as any;\n    metaTag.content = this.getCurrentSystemMetadata.colourCode;\n  }\n  filterNavMenuFunc = (value: MenuItem) => !value.locations?.size;\n  busLines: IValueLabel<ESystemBusLine>[] = [];\n}\n"]}