@openziti/ziti-console-lib 0.3.0

package/esm2022/lib/services/deactivate-guard.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const DEACTIVATE_GUARD = new InjectionToken('DEACTIVATE_GUARD');
+class DeactivateGuardService {
+    canDeactivate(component) {
+        return component.canDeactivate ? component.canDeactivate() : true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeactivateGuardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeactivateGuardService, providedIn: 'root' }); }
+}
+export { DeactivateGuardService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeactivateGuardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVhY3RpdmF0ZS1ndWFyZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMveml0aS1jb25zb2xlLWxpYi9zcmMvbGliL3NlcnZpY2VzL2RlYWN0aXZhdGUtZ3VhcmQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFFLGNBQWMsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFJekQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQXlCLGtCQUFrQixDQUFDLENBQUM7QUFNL0YsTUFHYSxzQkFBc0I7SUFFL0IsYUFBYSxDQUFDLFNBQWlDO1FBQzNDLE9BQU8sU0FBUyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDdEUsQ0FBQzsrR0FKUSxzQkFBc0I7bUhBQXRCLHNCQUFzQixjQUZuQixNQUFNOztTQUVULHNCQUFzQjs0RkFBdEIsc0JBQXNCO2tCQUhsQyxVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZSwgSW5qZWN0aW9uVG9rZW59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ2FuRGVhY3RpdmF0ZSB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBjb25zdCBERUFDVElWQVRFX0dVQVJEID0gbmV3IEluamVjdGlvblRva2VuPERlYWN0aXZhdGVHdWFyZFNlcnZpY2U+KCdERUFDVElWQVRFX0dVQVJEJyk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2FuQ29tcG9uZW50RGVhY3RpdmF0ZSB7XG4gICAgY2FuRGVhY3RpdmF0ZTogKCkgPT4gT2JzZXJ2YWJsZTxib29sZWFuPiB8IFByb21pc2U8Ym9vbGVhbj4gfCBib29sZWFuO1xufVxuXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIERlYWN0aXZhdGVHdWFyZFNlcnZpY2UgaW1wbGVtZW50cyAgQ2FuRGVhY3RpdmF0ZTxDYW5Db21wb25lbnREZWFjdGl2YXRlPntcblxuICAgIGNhbkRlYWN0aXZhdGUoY29tcG9uZW50OiBDYW5Db21wb25lbnREZWFjdGl2YXRlKSB7XG4gICAgICAgIHJldHVybiBjb21wb25lbnQuY2FuRGVhY3RpdmF0ZSA/IGNvbXBvbmVudC5jYW5EZWFjdGl2YXRlKCkgOiB0cnVlO1xuICAgIH1cbn0iXX0=

package/esm2022/lib/services/login-service.class.mjs

@@ -0,0 +1,28 @@
+import { __decorate, __param } from "tslib";
+import { Inject } from "@angular/core";
+import { InjectionToken } from '@angular/core';
+import { SETTINGS_SERVICE } from "./settings.service";
+export const ZAC_LOGIN_SERVICE = new InjectionToken('ZAC_LOGIN_SERVICE');
+let LoginServiceClass = class LoginServiceClass {
+    constructor(httpClient, settingsService, router, growlerService) {
+        this.httpClient = httpClient;
+        this.settingsService = settingsService;
+        this.router = router;
+        this.growlerService = growlerService;
+    }
+    getHttpOptions() {
+        const options = {
+            headers: {
+                accept: '*',
+            },
+            params: {},
+            responseType: 'text',
+        };
+        return options;
+    }
+};
+LoginServiceClass = __decorate([
+    __param(1, Inject(SETTINGS_SERVICE))
+], LoginServiceClass);
+export { LoginServiceClass };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/node-data.service.mjs

@@ -0,0 +1,292 @@
+/*
+    Copyright NetFoundry Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+import { Inject, Injectable } from '@angular/core';
+import { SETTINGS_SERVICE } from "./settings.service";
+import { firstValueFrom, map } from "rxjs";
+import { catchError } from "rxjs/operators";
+import { isEmpty, get } from "lodash";
+import { ZitiDataService } from "./ziti-data.service";
+import { Resolver } from "@stoplight/json-ref-resolver";
+import moment from "moment";
+import * as i0 from "@angular/core";
+import * as i1 from "../features/messaging/logger.service";
+import * as i2 from "../features/messaging/growler.service";
+import * as i3 from "@angular/common/http";
+import * as i4 from "@angular/router";
+import * as i5 from "./settings.service";
+class NodeDataService extends ZitiDataService {
+    constructor(logger, growler, settingsService, httpClient, router) {
+        super(logger, growler, settingsService, httpClient, router);
+        this.logger = logger;
+        this.growler = growler;
+        this.settingsService = settingsService;
+        this.httpClient = httpClient;
+        this.router = router;
+    }
+    post(type, model, chained = false) {
+        let clientSub;
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/dataSave';
+        const body = { paging: this.DEFAULT_PAGING, type: type, save: model, chained: chained };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code !== "ECONNREFUSED")
+                throw (err);
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    patch(type, model, id, chained = false) {
+        let clientSub;
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/dataSave';
+        const body = { paging: this.DEFAULT_PAGING, type: type, save: model, id: id, chained: chained };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code !== "ECONNREFUSED")
+                throw (err);
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    get(type, paging, filters = [], url) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/data';
+        const body = { paging: paging, type: type, url: url };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (filters.length > 0) {
+                filters.forEach((filter) => {
+                    let newData = [];
+                    if (filter.columnId !== 'name' && !isEmpty(filter.value)) {
+                        results.data.forEach(row => {
+                            if (get(row, filter.columnId)?.indexOf(filter.value) >= 0)
+                                newData.push(row);
+                        });
+                        results.data = newData;
+                    }
+                });
+            }
+            else if (results.error) {
+                this.handleError(results);
+            }
+            return results;
+        })));
+    }
+    getSubdata(entityType, id, dataType) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/subdata';
+        const body = { url: `./${entityType}/${id}/${dataType}`, name: entityType, type: dataType };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            else if (results.error) {
+                this.handleError(results);
+            }
+            return results;
+        })));
+    }
+    saveSubdata(entityType, id, dataType, data) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/subSave';
+        const body = {
+            type: dataType,
+            parentType: entityType,
+            id: id,
+            doing: "POST",
+            save: data
+        };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    resetEnrollment(id, date) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/resetEnroll';
+        const dateStr = moment(date).format("M/D/YYYY hh:mm A");
+        const body = {
+            date: dateStr,
+            id: id
+        };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    reissueEnrollment(id, date) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/reissueEnroll';
+        const dateStr = moment(date).format("M/D/YYYY hh:mm A");
+        const body = {
+            date: dateStr,
+            id: id
+        };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    deleteSubdata(entityType, id, dataType, data) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/subSave';
+        const body = {
+            type: dataType,
+            parentType: entityType,
+            id: id,
+            doing: "DELETE",
+            save: data
+        };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    delete(type, id) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/delete';
+        const body = { paging: this.DEFAULT_PAGING, type: type, ids: [id] };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    call(url) {
+        const nodeServerURL = window.location.origin;
+        const serviceUrl = nodeServerURL + '/api/call';
+        const body = { url: url };
+        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(catchError((err) => {
+            const error = "Server Not Accessible";
+            if (err.code != "ECONNREFUSED")
+                throw ({ error: err.code });
+            throw ({ error: error });
+        }), map((results) => {
+            if (!isEmpty(results.error)) {
+                throw ({ error: results.error });
+            }
+            return results;
+        })));
+    }
+    schema(data) {
+        const resolver = new Resolver();
+        return resolver.resolve(data).then((schema) => {
+            return schema.result;
+        });
+    }
+    getUrlFilter(paging) {
+        let urlFilter = '';
+        let toSearchOn = "name";
+        let noSearch = false;
+        if (paging && paging.sort != null) {
+            if (paging.searchOn)
+                toSearchOn = paging.searchOn;
+            if (paging.noSearch)
+                noSearch = true;
+            if (!paging.filter)
+                paging.filter = "";
+            paging.filter = paging.filter.split('#').join('');
+            if (noSearch) {
+                if (paging.page !== -1)
+                    urlFilter = "?limit=" + paging.total + "&offset=" + ((paging.page - 1) * paging.total) + "&sort=" + paging.sort + " " + paging.order;
+            }
+            else {
+                if (paging.page !== -1)
+                    urlFilter = "?filter=(" + toSearchOn + " contains \"" + paging.filter + "\")&limit=" + paging.total + "&offset=" + ((paging.page - 1) * paging.total) + "&sort=" + paging.sort + " " + paging.order;
+                if (paging.params) {
+                    for (const key in paging.params) {
+                        urlFilter += ((urlFilter.length === 0) ? "?" : "&") + key + "=" + paging.params[key];
+                    }
+                }
+            }
+        }
+        return urlFilter;
+    }
+    handleError(results) {
+        if (results?.errorObj?.code === 'UNAUTHORIZED') {
+            localStorage.removeItem('ziti.settings');
+            window.location.href = '/login';
+        }
+        else {
+            this.logger.error(results?.error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodeDataService, deps: [{ token: i1.LoggerService }, { token: i2.GrowlerService }, { token: SETTINGS_SERVICE }, { token: i3.HttpClient }, { token: i4.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodeDataService, providedIn: 'root' }); }
+}
+export { NodeDataService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NodeDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LoggerService }, { type: i2.GrowlerService }, { type: i5.SettingsService, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_SERVICE]
+                }] }, { type: i3.HttpClient }, { type: i4.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-data.service.js","sourceRoot":"","sources":["../../../../../projects/ziti-console-lib/src/lib/services/node-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n    Copyright NetFoundry Inc.\n\n    Licensed under the Apache License, Version 2.0 (the \"License\");\n    you may not use this file except in compliance with the License.\n    You may obtain a copy of the License at\n\n    https://www.apache.org/licenses/LICENSE-2.0\n\n    Unless required by applicable law or agreed to in writing, software\n    distributed under the License is distributed on an \"AS IS\" BASIS,\n    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n    See the License for the specific language governing permissions and\n    limitations under the License.\n*/\n\nimport {Inject, Injectable} from '@angular/core';\nimport { Router } from \"@angular/router\";\nimport {LoggerService} from \"../features/messaging/logger.service\";\nimport {GrowlerService} from \"../features/messaging/growler.service\";\nimport {SETTINGS_SERVICE, SettingsService} from \"./settings.service\";\nimport {firstValueFrom, map} from \"rxjs\";\nimport {catchError} from \"rxjs/operators\";\nimport {HttpClient} from \"@angular/common/http\";\nimport {FilterObj} from \"../features/data-table/data-table-filter.service\";\nimport {isEmpty, get} from \"lodash\";\nimport {ZitiDataService} from \"./ziti-data.service\";\nimport {Resolver} from \"@stoplight/json-ref-resolver\";\nimport moment from \"moment\";\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class NodeDataService extends ZitiDataService {\n\n    constructor(override logger: LoggerService,\n                override growler: GrowlerService,\n                @Inject(SETTINGS_SERVICE) override settingsService: SettingsService,\n                override httpClient: HttpClient,\n                override router: Router\n    ) {\n        super(logger, growler, settingsService, httpClient, router)\n    }\n\n    post(type, model, chained = false) {\n        let clientSub;\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/dataSave';\n        const body = {paging: this.DEFAULT_PAGING, type: type, save: model, chained: chained};\n\n        return firstValueFrom(this.httpClient.post(serviceUrl,body,{}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code !== \"ECONNREFUSED\") throw(err);\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    patch(type, model, id, chained = false) {\n        let clientSub;\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/dataSave';\n        const body = {paging: this.DEFAULT_PAGING, type: type, save: model, id: id, chained: chained};\n\n        return firstValueFrom(this.httpClient.post(serviceUrl,body,{}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code !== \"ECONNREFUSED\") throw(err);\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    get(type: string, paging: any, filters: FilterObj[] = [], url?) {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/data';\n        const body = {paging: paging, type: type, url: url};\n\n        return firstValueFrom(this.httpClient.post(serviceUrl,body,{}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(filters.length > 0) {\n                        filters.forEach((filter:FilterObj) => {\n                            let newData: any[] = [];\n                            if(filter.columnId !== 'name' && !isEmpty(filter.value )) {\n                                results.data.forEach(row => {\n                                    if(get(row, filter.columnId)?.indexOf(filter.value) >= 0)\n                                        newData.push(row);\n                                })\n                                results.data = newData;\n                            }\n                        });\n                    } else if (results.error) {\n                        this.handleError(results)\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    getSubdata(entityType: string, id: any, dataType: string) {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/subdata';\n        const body = {url:`./${entityType}/${id}/${dataType}`, name: entityType, type: dataType };\n        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    } else if (results.error) {\n                        this.handleError(results)\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    override saveSubdata(entityType: string, id: any, dataType: string, data: any): Promise<any> {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/subSave';\n        const body = {\n            type: dataType,\n            parentType: entityType,\n            id: id,\n            doing: \"POST\",\n            save: data\n        }\n        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    override resetEnrollment(id: string, date: any): Promise<any> {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/resetEnroll';\n        const dateStr = moment(date).format(\"M/D/YYYY hh:mm A\");\n        const body = {\n            date: dateStr,\n            id: id\n        }\n        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    override reissueEnrollment(id: string, date: string): Promise<any> {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/reissueEnroll';\n        const dateStr = moment(date).format(\"M/D/YYYY hh:mm A\");\n        const body = {\n            date: dateStr,\n            id: id\n        }\n        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    override deleteSubdata(entityType: string, id: any, dataType: string, data: any): Promise<any> {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/subSave';\n        const body = {\n            type: dataType,\n            parentType: entityType,\n            id: id,\n            doing: \"DELETE\",\n            save: data\n        }\n        return firstValueFrom(this.httpClient.post(serviceUrl, body, {}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    delete(type: string, id: string) {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/delete';\n        const body = {paging: this.DEFAULT_PAGING, type: type, ids: [id]};\n\n        return firstValueFrom(this.httpClient.post(serviceUrl,body,{}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    call(url) {\n        const nodeServerURL = window.location.origin;\n        const serviceUrl = nodeServerURL + '/api/call';\n        const body = {url: url};\n\n        return firstValueFrom(this.httpClient.post(serviceUrl,body,{}).pipe(\n                catchError((err: any) => {\n                    const error = \"Server Not Accessible\";\n                    if (err.code != \"ECONNREFUSED\") throw({error: err.code});\n                    throw({error: error});\n                }),\n                map((results: any) => {\n                    if(!isEmpty(results.error)) {\n                        throw({error: results.error});\n                    }\n                    return results;\n                })\n            )\n        );\n    }\n\n    schema(data: any): Promise<any> {\n        const resolver = new Resolver();\n        return resolver.resolve(data).then((schema) => {\n            return schema.result\n        });\n    }\n\n    private getUrlFilter(paging: any) {\n        let urlFilter = '';\n        let toSearchOn = \"name\";\n        let noSearch = false;\n        if (paging && paging.sort != null) {\n            if (paging.searchOn) toSearchOn = paging.searchOn;\n            if (paging.noSearch) noSearch = true;\n            if (!paging.filter) paging.filter = \"\";\n            paging.filter = paging.filter.split('#').join('');\n            if (noSearch) {\n                if (paging.page !== -1) urlFilter = \"?limit=\" + paging.total + \"&offset=\" + ((paging.page - 1) * paging.total)  + \"&sort=\" + paging.sort + \" \" + paging.order;\n            } else {\n                if (paging.page !== -1) urlFilter = \"?filter=(\" + toSearchOn + \" contains \\\"\" + paging.filter + \"\\\")&limit=\" + paging.total + \"&offset=\" + ((paging.page - 1) * paging.total) + \"&sort=\" + paging.sort + \" \" + paging.order;\n                if (paging.params) {\n                    for (const key in paging.params) {\n                        urlFilter += ((urlFilter.length === 0) ? \"?\" : \"&\") + key + \"=\" + paging.params[key];\n                    }\n                }\n            }\n        }\n        return urlFilter;\n    }\n\n    handleError(results) {\n        if (results?.errorObj?.code === 'UNAUTHORIZED') {\n            localStorage.removeItem('ziti.settings');\n            window.location.href = '/login';\n        } else {\n            this.logger.error(results?.error)\n        }\n    }\n}\n"]}

package/esm2022/lib/services/noop-login.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable, Inject } from '@angular/core';
+import { LoginServiceClass } from "./login-service.class";
+import { SETTINGS_SERVICE } from "./settings.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+import * as i3 from "../features/messaging/growler.service";
+import * as i4 from "./settings-service.class";
+class NoopLoginService extends LoginServiceClass {
+    constructor(httpClient, settingsService, router, growlerService) {
+        super(httpClient, settingsService, router, growlerService);
+        this.httpClient = httpClient;
+        this.settingsService = settingsService;
+        this.router = router;
+        this.growlerService = growlerService;
+    }
+    init() { }
+    clearSession() {
+    }
+    hasSession() {
+        return false;
+    }
+    login(prefix, url, username, password) {
+    }
+    logout() {
+    }
+    observeLogin(serviceUrl, username, password) {
+    }
+    checkOriginForController() {
+        return Promise.resolve(true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NoopLoginService, deps: [{ token: i1.HttpClient }, { token: SETTINGS_SERVICE }, { token: i2.Router }, { token: i3.GrowlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NoopLoginService, providedIn: 'root' }); }
+}
+export { NoopLoginService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NoopLoginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i4.SettingsServiceClass, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_SERVICE]
+                }] }, { type: i2.Router }, { type: i3.GrowlerService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC1sb2dpbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMveml0aS1jb25zb2xlLWxpYi9zcmMvbGliL3NlcnZpY2VzL25vb3AtbG9naW4uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUdqRCxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQzs7Ozs7O0FBSXBELE1BR2EsZ0JBQWlCLFNBQVEsaUJBQWlCO0lBRW5ELFlBQ2EsVUFBc0IsRUFDSSxlQUFxQyxFQUMvRCxNQUFjLEVBQ2QsY0FBOEI7UUFFdkMsS0FBSyxDQUFDLFVBQVUsRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBTGxELGVBQVUsR0FBVixVQUFVLENBQVk7UUFDSSxvQkFBZSxHQUFmLGVBQWUsQ0FBc0I7UUFDL0QsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUNkLG1CQUFjLEdBQWQsY0FBYyxDQUFnQjtJQUczQyxDQUFDO0lBRVEsSUFBSSxLQUFJLENBQUM7SUFFbEIsWUFBWTtJQUNaLENBQUM7SUFFRCxVQUFVO1FBQ04sT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztJQUVELEtBQUssQ0FBQyxNQUFjLEVBQUUsR0FBVyxFQUFFLFFBQWdCLEVBQUUsUUFBZ0I7SUFDckUsQ0FBQztJQUVELE1BQU07SUFDTixDQUFDO0lBRUQsWUFBWSxDQUFDLFVBQWtCLEVBQUUsUUFBZ0IsRUFBRSxRQUFnQjtJQUNuRSxDQUFDO0lBRUQsd0JBQXdCO1FBQ3BCLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNqQyxDQUFDOytHQS9CUSxnQkFBZ0IsNENBSWIsZ0JBQWdCO21IQUpuQixnQkFBZ0IsY0FGYixNQUFNOztTQUVULGdCQUFnQjs0RkFBaEIsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQjs7MEJBS1EsTUFBTTsyQkFBQyxnQkFBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGUsIEluamVjdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vbi9odHRwXCI7XG5pbXBvcnQgeyBSb3V0ZXIgfSBmcm9tIFwiQGFuZ3VsYXIvcm91dGVyXCI7XG5pbXBvcnQge0xvZ2luU2VydmljZUNsYXNzfSBmcm9tIFwiLi9sb2dpbi1zZXJ2aWNlLmNsYXNzXCI7XG5pbXBvcnQge1NFVFRJTkdTX1NFUlZJQ0V9IGZyb20gXCIuL3NldHRpbmdzLnNlcnZpY2VcIjtcbmltcG9ydCB7U2V0dGluZ3NTZXJ2aWNlQ2xhc3N9IGZyb20gXCIuL3NldHRpbmdzLXNlcnZpY2UuY2xhc3NcIjtcbmltcG9ydCB7R3Jvd2xlclNlcnZpY2V9IGZyb20gXCIuLi9mZWF0dXJlcy9tZXNzYWdpbmcvZ3Jvd2xlci5zZXJ2aWNlXCI7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTm9vcExvZ2luU2VydmljZSBleHRlbmRzIExvZ2luU2VydmljZUNsYXNzIHtcblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBvdmVycmlkZSBodHRwQ2xpZW50OiBIdHRwQ2xpZW50LFxuICAgICAgICBASW5qZWN0KFNFVFRJTkdTX1NFUlZJQ0UpIG92ZXJyaWRlIHNldHRpbmdzU2VydmljZTogU2V0dGluZ3NTZXJ2aWNlQ2xhc3MsXG4gICAgICAgIG92ZXJyaWRlIHJvdXRlcjogUm91dGVyLFxuICAgICAgICBvdmVycmlkZSBncm93bGVyU2VydmljZTogR3Jvd2xlclNlcnZpY2VcbiAgICApIHtcbiAgICAgICAgc3VwZXIoaHR0cENsaWVudCwgc2V0dGluZ3NTZXJ2aWNlLCByb3V0ZXIsIGdyb3dsZXJTZXJ2aWNlKTtcbiAgICB9XG5cbiAgICBvdmVycmlkZSBpbml0KCkge31cblxuICAgIGNsZWFyU2Vzc2lvbigpIHtcbiAgICB9XG5cbiAgICBoYXNTZXNzaW9uKCk6IGJvb2xlYW4ge1xuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuXG4gICAgbG9naW4ocHJlZml4OiBzdHJpbmcsIHVybDogc3RyaW5nLCB1c2VybmFtZTogc3RyaW5nLCBwYXNzd29yZDogc3RyaW5nKSB7XG4gICAgfVxuXG4gICAgbG9nb3V0KCkge1xuICAgIH1cblxuICAgIG9ic2VydmVMb2dpbihzZXJ2aWNlVXJsOiBzdHJpbmcsIHVzZXJuYW1lOiBzdHJpbmcsIHBhc3N3b3JkOiBzdHJpbmcpIHtcbiAgICB9XG5cbiAgICBjaGVja09yaWdpbkZvckNvbnRyb2xsZXIoKTogUHJvbWlzZTxhbnk+IHtcbiAgICAgICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh0cnVlKTtcbiAgICB9XG59Il19