@openziti/ziti-console-lib 0.3.0

package/esm2022/lib/features/projectable-forms/identity/identity-form.service.mjs

@@ -0,0 +1,144 @@
+/*
+    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 { Injectable, Inject, InjectionToken } from "@angular/core";
+import { isEmpty, unset, keys } from 'lodash';
+import { ZITI_DATA_SERVICE } from "../../../services/ziti-data.service";
+import { GrowlerModel } from "../../messaging/growler.model";
+import { Identity } from "../../../models/identity";
+import { SETTINGS_SERVICE } from "../../../services/settings.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../../messaging/growler.service";
+import * as i2 from "../../../services/settings.service";
+import * as i3 from "../../../services/ziti-data.service";
+export const IDENTITY_EXTENSION_SERVICE = new InjectionToken('IDENTITY_EXTENSION_SERVICE');
+class IdentityFormService {
+    constructor(settingsService, zitiService, growlerService) {
+        this.settingsService = settingsService;
+        this.zitiService = zitiService;
+        this.growlerService = growlerService;
+    }
+    save(formData) {
+        const isUpdate = !isEmpty(formData.id);
+        const data = this.getIdentityDataModel(formData, isUpdate);
+        const svc = isUpdate ? this.zitiService.patch.bind(this.zitiService) : this.zitiService.post.bind(this.zitiService);
+        return svc('identities', data, formData.id).then((result) => {
+            const growlerData = new GrowlerModel('success', 'Success', `Identity ${isUpdate ? 'Updated' : 'Created'}`, `Successfully ${isUpdate ? 'updated' : 'created'} Identity: ${formData.name}`);
+            this.growlerService.show(growlerData);
+        }).catch((resp) => {
+            let errorMessage;
+            if (resp?.error?.error?.cause?.message) {
+                errorMessage = resp?.error?.error?.cause?.message;
+            }
+            else if (resp?.error?.error?.cause?.reason) {
+                errorMessage = resp?.error?.error?.cause?.reason;
+            }
+            else if (resp?.error?.message) {
+                errorMessage = resp?.error?.message;
+            }
+            else {
+                errorMessage = 'An unknown error occurred';
+            }
+            const growlerData = new GrowlerModel('error', 'Error', `Error Creating Identity`, errorMessage);
+            this.growlerService.show(growlerData);
+            throw resp;
+        });
+    }
+    getIdentityDataModel(formData, isUpdate) {
+        const saveModel = new Identity();
+        const modelProperties = keys(saveModel);
+        modelProperties.forEach((prop) => {
+            switch (prop) {
+                case 'type':
+                    if (isUpdate) {
+                        saveModel[prop] = formData[prop].id;
+                    }
+                    else {
+                        saveModel[prop] = formData[prop];
+                    }
+                    break;
+                case 'enrollment':
+                    if (isUpdate) {
+                        unset(saveModel, 'enrollment');
+                    }
+                    else {
+                        saveModel[prop] = formData[prop];
+                    }
+                    break;
+                default:
+                    saveModel[prop] = formData[prop];
+            }
+        });
+        return saveModel;
+    }
+    testService(identityId, serviceId) {
+        const url = `/identities/${identityId}/policy-advice/${serviceId}`;
+        return this.zitiService.call(url).then((result) => {
+            var errors = [];
+            var info = result.data;
+            if (!info?.isDialAllowed && !info?.isBindAllowed)
+                errors.push("No access to service. Adjust service policies.");
+            if (info?.identityRouterCount < 1)
+                errors.push("Identity has no edge routers assigned. Adjust edge router policies.");
+            if (info?.serviceRouterCount < 1)
+                errors.push("Service has no edge routers assigned. Adjust edge router policies.");
+            if (info?.identityRouterCount > 0 && info?.serviceRouterCount > 0) {
+                if (info?.commonCount < 1)
+                    errors.push("Identity and services have no edge routers in common. Adjust edge router policies and/or service edge router policies.");
+                else if (info?.onlineCount < 1)
+                    errors.push("Common edge routers are all off-line. Bring routers back on-line or adjust edge router policies and/or service edge router policies.");
+            }
+            var status = "";
+            if (info?.isDialAllowed) {
+                if (info?.isBindAllowed)
+                    status = "(Dial,Bind)";
+                else
+                    status = "(Dial)";
+            }
+            else {
+                if (info?.isBindAllowed)
+                    status = "(Bind)";
+            }
+            if (errors.length > 0) {
+                for (var i = 0; i < errors.length; i++) {
+                    status += "<br/>" + errors[i];
+                }
+            }
+            else
+                status += "<br/>Everything is configured properly";
+            return status;
+        });
+    }
+    refreshIdentity(id) {
+        const url = `/identities/${id}`;
+        return this.zitiService.call(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdentityFormService, deps: [{ token: SETTINGS_SERVICE }, { token: ZITI_DATA_SERVICE }, { token: i1.GrowlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdentityFormService, providedIn: 'root' }); }
+}
+export { IdentityFormService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdentityFormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i2.SettingsService, decorators: [{
+                    type: Inject,
+                    args: [SETTINGS_SERVICE]
+                }] }, { type: i3.ZitiDataService, decorators: [{
+                    type: Inject,
+                    args: [ZITI_DATA_SERVICE]
+                }] }, { type: i1.GrowlerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity-form.service.js","sourceRoot":"","sources":["../../../../../../../projects/ziti-console-lib/src/lib/features/projectable-forms/identity/identity-form.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 {Injectable, Inject, InjectionToken} from \"@angular/core\";\nimport moment from 'moment';\n\nimport {isEmpty, unset, keys} from 'lodash';\nimport {ZITI_DATA_SERVICE, ZitiDataService} from \"../../../services/ziti-data.service\";\nimport {GrowlerService} from \"../../messaging/growler.service\";\nimport {GrowlerModel} from \"../../messaging/growler.model\";\nimport {Identity} from \"../../../models/identity\";\nimport {SETTINGS_SERVICE, SettingsService} from \"../../../services/settings.service\";\n\n\nexport const IDENTITY_EXTENSION_SERVICE = new InjectionToken<any>('IDENTITY_EXTENSION_SERVICE');\n\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class IdentityFormService {\n\n    constructor(\n        @Inject(SETTINGS_SERVICE) public settingsService: SettingsService,\n        @Inject(ZITI_DATA_SERVICE) private zitiService: ZitiDataService,\n        private growlerService: GrowlerService\n    ) {}\n \n    save(formData) {\n        const isUpdate = !isEmpty(formData.id);\n        const data: any = this.getIdentityDataModel(formData, isUpdate);\n        const svc = isUpdate ? this.zitiService.patch.bind(this.zitiService) : this.zitiService.post.bind(this.zitiService);\n        return svc('identities', data, formData.id).then((result) => {\n            const growlerData = new GrowlerModel(\n                'success',\n                'Success',\n                `Identity ${isUpdate ? 'Updated' : 'Created'}`,\n                `Successfully ${isUpdate ? 'updated' : 'created'} Identity: ${formData.name}`,\n            );\n            this.growlerService.show(growlerData);\n        }).catch((resp) => {\n            let errorMessage;\n            if (resp?.error?.error?.cause?.message) {\n                errorMessage = resp?.error?.error?.cause?.message;\n            } else if (resp?.error?.error?.cause?.reason) {\n                errorMessage = resp?.error?.error?.cause?.reason;\n            }else if (resp?.error?.message) {\n                errorMessage = resp?.error?.message;\n            } else {\n                errorMessage = 'An unknown error occurred';\n            }\n            const growlerData = new GrowlerModel(\n                'error',\n                'Error',\n                `Error Creating Identity`,\n                errorMessage,\n            );\n            this.growlerService.show(growlerData);\n            throw resp;\n        })\n    }\n\n    getIdentityDataModel(formData, isUpdate) {\n        const saveModel = new Identity();\n        const modelProperties = keys(saveModel);\n        modelProperties.forEach((prop) => {\n            switch(prop) {\n                case 'type':\n                    if(isUpdate) {\n                        saveModel[prop] = formData[prop].id;\n                    } else {\n                        saveModel[prop] = formData[prop];\n                    }\n                    break;\n                case 'enrollment':\n                    if(isUpdate) {\n                        unset(saveModel, 'enrollment');\n                    } else {\n                        saveModel[prop] = formData[prop];\n                    }\n                    break;\n                default:\n                    saveModel[prop] = formData[prop];\n            }\n        });\n        return saveModel;\n    }\n\n    testService(identityId, serviceId) {\n        const url = `/identities/${identityId}/policy-advice/${serviceId}`;\n        return this.zitiService.call(url).then((result) => {\n            var errors = [];\n            var info = result.data;\n            if (!info?.isDialAllowed&&!info?.isBindAllowed) errors.push(\"No access to service. Adjust service policies.\");\n            if (info?.identityRouterCount<1) errors.push(\"Identity has no edge routers assigned. Adjust edge router policies.\");\n            if (info?.serviceRouterCount<1) errors.push(\"Service has no edge routers assigned. Adjust edge router policies.\");\n            if (info?.identityRouterCount>0&&info?.serviceRouterCount>0) {\n                if (info?.commonCount<1) errors.push(\"Identity and services have no edge routers in common. Adjust edge router policies and/or service edge router policies.\");\n                else if (info?.onlineCount<1) errors.push(\"Common edge routers are all off-line. Bring routers back on-line or adjust edge router policies and/or service edge router policies.\");\n            }\n            var status = \"\";\n            if (info?.isDialAllowed) {\n                if (info?.isBindAllowed) status = \"(Dial,Bind)\";\n                else status = \"(Dial)\";\n            } else {\n                if (info?.isBindAllowed) status = \"(Bind)\";\n            }\n            if (errors.length>0) {\n                for (var i=0; i<errors.length; i++) {\n                    status += \"<br/>\"+errors[i];\n                }\n            } else status += \"<br/>Everything is configured properly\";\n            return status;\n        });\n    }\n\n    refreshIdentity(id) {\n        const url: any = `/identities/${id}`\n        return this.zitiService.call(url);\n    }\n}\n"]}

package/esm2022/lib/features/projectable-forms/projectable-form.class.mjs

@@ -0,0 +1,172 @@
+/*
+    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 { ExtendableComponent } from "../extendable/extendable.component";
+import { Component, EventEmitter, Inject, Input, Output, ViewChild } from "@angular/core";
+import { defer, isEqual, unset, debounce } from "lodash";
+import { GrowlerModel } from "../messaging/growler.model";
+import { SHAREDZ_EXTENSION } from "../extendable/extensions-noop.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../messaging/growler.service";
+// @ts-ignore
+const { context, tags, resources, service, app } = window;
+class ProjectableForm extends ExtendableComponent {
+    constructor(growlerService, extService) {
+        super();
+        this.growlerService = growlerService;
+        this.extService = extService;
+        this.dataChange = new EventEmitter();
+        this.errors = {};
+        this.entityType = 'identity';
+        this.moreActions = [];
+        this.tagElements = [];
+        this.tagData = [];
+        this.hideTags = false;
+        this.initData = {};
+        this._dataChange = false;
+        this.checkDataChangeDebounced = debounce(this.checkDataChange, 100, { maxWait: 100 });
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.errors = {};
+        this.nameFieldInput.nativeElement.focus();
+        if (this.extService?.moreActions) {
+            this.moreActions = [...this.moreActions, ...this.extService.moreActions];
+        }
+    }
+    showMoreChanged(showMore) {
+        if (!showMore || this.hideTags) {
+            return;
+        }
+        this.resetTags();
+    }
+    loadTags() {
+        this.hideTags = localStorage.getItem("hideTags") == "yes";
+        if (this.hideTags) {
+            return;
+        }
+        service.call("tags", {}, this.tagsLoaded.bind(this));
+    }
+    tagsLoaded(results) {
+        tags.data = results;
+        context.set(tags.name, tags.data);
+        tags.tagData = [];
+        tags.data.forEach((tag) => {
+            let html;
+            if (tag.objects == "all" || tag.objects.indexOf(this.entityType) >= 0) {
+                tags.tagData[tags.tagData.length] = tag;
+                html = this.getTagContent(tag);
+                const tagEl = {
+                    label: tag.label,
+                    content: html
+                };
+                this.tagElements.push(tagEl);
+            }
+        });
+    }
+    resetTags() {
+        unset(tags, 'map');
+        if (this.hideTags) {
+            return;
+        }
+        defer(() => {
+            tags.reset(this.formData);
+            tags.events();
+        });
+    }
+    getTagContent(tag) {
+        let html = '';
+        if (tag.value == "string") {
+            html += '<input id="Tag_' + tag.id + '" type="text" data-tag="' + tag.id + '" maxlength="500" placeholder="' + tag.description + '" />';
+        }
+        else if (tag.value == "boolean") {
+            html += '<input id="Tag_' + tag.id + '" type="checkbox" data-tag="' + tag.id + '" />';
+        }
+        else if (tag.value == "map") {
+            html += '<div id="Tag_' + tag.id + '_Map" data-map="' + tag.id + '" class="map"></div>';
+            html += '<input id="Tag_' + tag.id + '" type="text" data-tag="' + tag.id + '" maxlength="500" placeholder="' + tag.description + '" />';
+        }
+        else if (tag.value == "avatar") {
+            html += '<div class="formRow">';
+            html += '<div id="Tag_' + tag.id + '" data-id="' + tag.id + '" data-resource="avatar" class="resource icon profile" title="' + tag.description + '" style="background-image: url(' + tag.default + ')"></div><div id="Tag_Resources_' + tag.id + '" class="resources" data-id="' + tag.id + '" data-resources="avatar"></div>';
+            html += '<input id="Tag_' + tag.id + '_Hider" data-tag="' + tag.id + '" type="hidden"/>';
+            resources.get(tag.id);
+            context.addListener("resources-" + tag.id, tags.loaded);
+        }
+        else if (tag.value == "icon") {
+            html += '<div class="formRow">';
+            html += '<div id="Tag_' + tag.id + '" data-id="' + tag.id + '" data-resource="icon" class="resource icon" title="' + tag.description + '" style="background-image: url(' + tag.default + ')"></div><div id="Tag_Resources_' + tag.id + '" class="resources" data-id="' + tag.id + '" data-resources="icon"></div>';
+            html += '<input id="Tag_' + tag.id + '_Hider" data-tag="' + tag.id + '" type="hidden"/>';
+            resources.get(tag.id);
+            context.addListener("resources-" + tag.id, tags.loaded);
+        }
+        else if (tag.value == "array") {
+            html += '<div id="Tag_' + tag.id + '_Selected"></div>';
+            html += '<input id="Tag_' + tag.id + '" type="text" data-tag="' + tag.id + '" data-array="' + tag.id + '" maxlength="500" placeholder="' + tag.description + '" />';
+        }
+        return html;
+    }
+    getTagValues() {
+        return tags.val();
+    }
+    closeModal(refresh = true, ignoreChanges = false, data, event) {
+        if (!ignoreChanges && this._dataChange) {
+            const confirmed = confirm('You have unsaved changes. Do you want to leave this page and discard your changes or stay on this page?');
+            if (!confirmed) {
+                return;
+            }
+        }
+        this.close.emit({ refresh: refresh });
+        if (event) {
+            event.stopPropagation();
+        }
+    }
+    ngDoCheck() {
+        this.checkDataChangeDebounced();
+    }
+    checkDataChange() {
+        const dataChange = !isEqual(this.initData, this.formData);
+        if (dataChange !== this._dataChange) {
+            this.dataChange.emit(dataChange);
+        }
+        this._dataChange = dataChange;
+        app.isDirty = false;
+    }
+    copyToClipboard(val) {
+        navigator.clipboard.writeText(val);
+        const growlerData = new GrowlerModel('success', 'Success', `Text Copied`, `API call URL copied to clipboard`);
+        this.growlerService.show(growlerData);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ProjectableForm, deps: [{ token: i1.GrowlerService }, { token: SHAREDZ_EXTENSION }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ProjectableForm, selector: "ng-component", inputs: { formData: "formData" }, outputs: { close: "close", dataChange: "dataChange" }, viewQueries: [{ propertyName: "nameFieldInput", first: true, predicate: ["nameFieldInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [""] }); }
+}
+export { ProjectableForm };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ProjectableForm, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }], ctorParameters: function () { return [{ type: i1.GrowlerService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SHAREDZ_EXTENSION]
+                }] }]; }, propDecorators: { formData: [{
+                type: Input
+            }], close: [{
+                type: Output
+            }], dataChange: [{
+                type: Output
+            }], nameFieldInput: [{
+                type: ViewChild,
+                args: ['nameFieldInput']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projectable-form.class.js","sourceRoot":"","sources":["../../../../../../projects/ziti-console-lib/src/lib/features/projectable-forms/projectable-form.class.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 {ExtendableComponent} from \"../extendable/extendable.component\";\nimport {Component, DoCheck, ElementRef, EventEmitter, Inject, Input, OnInit, Output, ViewChild} from \"@angular/core\";\n\nimport {defer, isEqual, unset, debounce} from \"lodash\";\nimport {GrowlerModel} from \"../messaging/growler.model\";\nimport {GrowlerService} from \"../messaging/growler.service\";\nimport {ExtensionService, SHAREDZ_EXTENSION} from \"../extendable/extensions-noop.service\";\n\n// @ts-ignore\nconst {context, tags, resources, service, app} = window;\n\n@Component({\n    template: '',\n    styleUrls: ['./projectable-form.class.scss']\n})\nexport abstract class ProjectableForm extends ExtendableComponent implements DoCheck {\n    @Input() abstract formData: any;\n    @Output() abstract close: EventEmitter<any>;\n    @Output() dataChange: EventEmitter<any> = new EventEmitter<any>();\n    @ViewChild('nameFieldInput') nameFieldInput: ElementRef;\n\n    abstract clear(): void;\n    abstract save(): void;\n\n    public errors: any = {};\n    protected entityType = 'identity';\n\n    moreActions: any[] = [];\n    tagElements: any = [];\n    tagData: any = [];\n    hideTags = false;\n    initData: any = {};\n    _dataChange = false;\n\n    checkDataChangeDebounced = debounce(this.checkDataChange, 100, {maxWait: 100});\n\n    protected constructor(\n        protected growlerService: GrowlerService,\n        @Inject(SHAREDZ_EXTENSION) protected extService: ExtensionService\n    ) {\n        super();\n    }\n\n    override ngAfterViewInit() {\n        super.ngAfterViewInit();\n        this.errors = {};\n        this.nameFieldInput.nativeElement.focus();\n        if (this.extService?.moreActions) {\n            this.moreActions = [...this.moreActions, ...this.extService.moreActions];\n        }\n    }\n\n    showMoreChanged(showMore) {\n        if (!showMore || this.hideTags) {\n            return;\n        }\n        this.resetTags()\n    }\n\n    loadTags() {\n        this.hideTags = localStorage.getItem(\"hideTags\")==\"yes\";\n        if (this.hideTags) {\n            return;\n        }\n        service.call(\"tags\", {}, this.tagsLoaded.bind(this));\n    }\n\n    tagsLoaded(results) {\n        tags.data = results;\n        context.set(tags.name, tags.data);\n        tags.tagData = [];\n        tags.data.forEach((tag) => {\n            let html;\n            if (tag.objects==\"all\" || tag.objects.indexOf(this.entityType)>=0) {\n                tags.tagData[tags.tagData.length] = tag;\n                html = this.getTagContent(tag);\n                const tagEl = {\n                    label: tag.label,\n                    content: html\n                }\n                this.tagElements.push(tagEl)\n            }\n        });\n    }\n\n    resetTags() {\n        unset(tags, 'map');\n        if (this.hideTags) {\n            return;\n        }\n        defer(() => {\n            tags.reset(this.formData);\n            tags.events();\n        })\n    }\n\n    getTagContent(tag) {\n        let html = '';\n        if (tag.value==\"string\") {\n            html += '<input id=\"Tag_'+tag.id+'\" type=\"text\" data-tag=\"'+tag.id+'\" maxlength=\"500\" placeholder=\"'+tag.description+'\" />';\n        } else if (tag.value==\"boolean\") {\n            html += '<input id=\"Tag_'+tag.id+'\" type=\"checkbox\" data-tag=\"'+tag.id+'\" />';\n        } else if (tag.value==\"map\") {\n            html += '<div id=\"Tag_'+tag.id+'_Map\" data-map=\"'+tag.id+'\" class=\"map\"></div>';\n            html += '<input id=\"Tag_'+tag.id+'\" type=\"text\" data-tag=\"'+tag.id+'\" maxlength=\"500\" placeholder=\"'+tag.description+'\" />';\n        } else if (tag.value==\"avatar\") {\n            html += '<div class=\"formRow\">';\n            html += '<div id=\"Tag_'+tag.id+'\" data-id=\"'+tag.id+'\" data-resource=\"avatar\" class=\"resource icon profile\" title=\"'+tag.description+'\" style=\"background-image: url('+tag.default+')\"></div><div id=\"Tag_Resources_'+tag.id+'\" class=\"resources\" data-id=\"'+tag.id+'\" data-resources=\"avatar\"></div>';\n            html += '<input id=\"Tag_'+tag.id+'_Hider\" data-tag=\"'+tag.id+'\" type=\"hidden\"/>';\n            resources.get(tag.id);\n            context.addListener(\"resources-\"+tag.id, tags.loaded);\n        } else if (tag.value==\"icon\") {\n            html += '<div class=\"formRow\">';\n            html += '<div id=\"Tag_'+tag.id+'\" data-id=\"'+tag.id+'\" data-resource=\"icon\" class=\"resource icon\" title=\"'+tag.description+'\" style=\"background-image: url('+tag.default+')\"></div><div id=\"Tag_Resources_'+tag.id+'\" class=\"resources\" data-id=\"'+tag.id+'\" data-resources=\"icon\"></div>';\n            html += '<input id=\"Tag_'+tag.id+'_Hider\" data-tag=\"'+tag.id+'\" type=\"hidden\"/>';\n            resources.get(tag.id);\n            context.addListener(\"resources-\"+tag.id, tags.loaded);\n        } else if (tag.value==\"array\") {\n            html += '<div id=\"Tag_'+tag.id+'_Selected\"></div>';\n            html += '<input id=\"Tag_'+tag.id+'\" type=\"text\" data-tag=\"'+tag.id+'\" data-array=\"'+tag.id+'\" maxlength=\"500\" placeholder=\"'+tag.description+'\" />';\n        }\n        return html;\n    }\n\n    getTagValues() {\n        return tags.val();\n    }\n\n    closeModal(refresh = true, ignoreChanges = false, data?, event?): void {\n        if (!ignoreChanges && this._dataChange) {\n            const confirmed = confirm('You have unsaved changes. Do you want to leave this page and discard your changes or stay on this page?');\n            if (!confirmed) {\n                return;\n            }\n        }\n        this.close.emit({refresh: refresh});\n        if (event) {\n            event.stopPropagation();\n        }\n    }\n\n    ngDoCheck() {\n        this.checkDataChangeDebounced();\n    }\n\n    protected checkDataChange() {\n        const dataChange = !isEqual(this.initData, this.formData);\n        if (dataChange !== this._dataChange) {\n            this.dataChange.emit(dataChange);\n        }\n        this._dataChange = dataChange;\n        app.isDirty = false;\n    }\n\n    copyToClipboard(val) {\n        navigator.clipboard.writeText(val);\n        const growlerData = new GrowlerModel(\n            'success',\n            'Success',\n            `Text Copied`,\n            `API call URL copied to clipboard`,\n        );\n        this.growlerService.show(growlerData);\n    }\n}\n"]}