@netgrif/components-core 6.0.1

package/esm2015/lib/panel/workflow-panel/abstract-workflow-panel.component.js

@@ -0,0 +1,103 @@
+import { Input } from '@angular/core';
+import { PanelWithHeaderBinding } from '../abstract/panel-with-header-binding';
+import { toMoment } from '../../resources/types/nae-date-type';
+import { DATE_TIME_FORMAT_STRING } from '../../moment/time-formats';
+import { TextField } from '../../data-fields/text-field/models/text-field';
+import { DateTimeField } from '../../data-fields/date-time-field/models/date-time-field';
+import { WorkflowMetaField } from '../../header/workflow-header/workflow-meta-enum';
+export class AbstractWorkflowPanelComponent extends PanelWithHeaderBinding {
+    constructor(_log, _translate, _workflowService) {
+        super();
+        this._log = _log;
+        this._translate = _translate;
+        this._workflowService = _workflowService;
+        this.responsiveBody = true;
+        this.showDeleteMenu = false;
+        this.TRANSLATION_NET = 'panel.workflow.net';
+        this.TRANSLATION_TITLE = 'panel.workflow.title';
+        this.TRANSLATION_VERSION = 'panel.workflow.version';
+        this.TRANSLATION_AUTHOR = 'panel.workflow.author';
+        this.TRANSLATION_UPLOAD = 'panel.workflow.upload';
+        this.dataFieldsBehaviour = { visible: true, editable: false };
+        this._subscription = _translate.onLangChange.subscribe((event) => {
+            this.panelContent.netIdentifier.title = this._translate.instant(this.TRANSLATION_NET);
+            this.panelContent.title.title = this._translate.instant(this.TRANSLATION_TITLE);
+            this.panelContent.version.title = this._translate.instant(this.TRANSLATION_VERSION);
+            this.panelContent.author.title = this._translate.instant(this.TRANSLATION_AUTHOR);
+            this.panelContent.uploaded.title = this._translate.instant(this.TRANSLATION_UPLOAD);
+        });
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.panelContent = this.createPanelContent();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._subscription.unsubscribe();
+    }
+    show(event) {
+        event.stopPropagation();
+        return false;
+    }
+    collapse() {
+    }
+    setPanelRef(panelRef) {
+        this.panelRef = panelRef;
+    }
+    /**
+     * Handles the logic that should be executed when the "delete workflow" button is clicked.
+     *
+     * Calls the appropriate method in the {@link WorkflowViewService}.
+     */
+    deleteWorkflow() {
+        this._workflowService.deleteWorkflow(this.workflow);
+    }
+    /**
+     * Populate data fields group for every petri net model
+     */
+    createPanelContent() {
+        return {
+            netIdentifier: new TextField('', this._translate.instant(this.TRANSLATION_NET), this.workflow.identifier, this.dataFieldsBehaviour),
+            title: new TextField('', this._translate.instant(this.TRANSLATION_TITLE), this.workflow.title, this.dataFieldsBehaviour),
+            version: new TextField('', this._translate.instant(this.TRANSLATION_VERSION), this.workflow.version, this.dataFieldsBehaviour),
+            author: new TextField('', this._translate.instant(this.TRANSLATION_AUTHOR), this.workflow.author.fullName, this.dataFieldsBehaviour),
+            uploaded: new DateTimeField('', this._translate.instant(this.TRANSLATION_UPLOAD), toMoment(this.workflow.createdDate), this.dataFieldsBehaviour)
+        };
+    }
+    resolveFeaturedFieldsValues() {
+        if (!this._lastSelectedHeaders) {
+            return;
+        }
+        this.featuredFieldsValues.splice(0, this.featuredFieldsValues.length);
+        this._lastSelectedHeaders.forEach(header => {
+            this.featuredFieldsValues.push(this.getFeaturedValue(header));
+        });
+    }
+    getFeaturedMetaValue(selectedHeader) {
+        switch (selectedHeader.fieldIdentifier) {
+            case WorkflowMetaField.INITIALS:
+                return { value: this.workflow.initials, icon: '', type: 'meta' };
+            case WorkflowMetaField.TITLE:
+                return { value: this.workflow.title, icon: '', type: 'meta' };
+            case WorkflowMetaField.NET_ID:
+                return { value: this.workflow.stringId, icon: '', type: 'meta' };
+            case WorkflowMetaField.VERSION:
+                return { value: this.workflow.version, icon: '', type: 'meta' };
+            case WorkflowMetaField.AUTHOR:
+                return { value: this.workflow.author.fullName, icon: 'account_circle', type: 'meta' };
+            case WorkflowMetaField.CREATION_DATE:
+                return { value: toMoment(this.workflow.createdDate).format(DATE_TIME_FORMAT_STRING), icon: 'event', type: 'meta' };
+        }
+    }
+    getFeaturedImmediateValue(selectedHeader) {
+        this._log.warn('Immediate data in workflow panel headers are currently not supported');
+        return { value: '', icon: '', type: '' };
+    }
+}
+AbstractWorkflowPanelComponent.propDecorators = {
+    workflow: [{ type: Input }],
+    selectedHeaders$: [{ type: Input }],
+    responsiveBody: [{ type: Input }],
+    showDeleteMenu: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-workflow-panel.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/panel/workflow-panel/abstract-workflow-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Input, OnDestroy, OnInit} from '@angular/core';\nimport {MatExpansionPanel} from '@angular/material/expansion';\nimport {PanelWithHeaderBinding} from '../abstract/panel-with-header-binding';\nimport {HeaderColumn} from '../../header/models/header-column';\nimport {Observable, Subscription} from 'rxjs';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {toMoment} from '../../resources/types/nae-date-type';\nimport {DATE_TIME_FORMAT_STRING} from '../../moment/time-formats';\nimport {TextField} from '../../data-fields/text-field/models/text-field';\nimport {DateTimeField} from '../../data-fields/date-time-field/models/date-time-field';\nimport {Behavior} from '../../data-fields/models/behavior';\nimport {Net} from '../../process/net';\nimport {TranslateService, TranslationChangeEvent} from '@ngx-translate/core';\nimport {WorkflowMetaField} from '../../header/workflow-header/workflow-meta-enum';\nimport {WorkflowViewService} from '../../view/workflow-view/workflow-view.service';\nimport {FeaturedValue} from '../abstract/featured-value';\n\n\nexport interface WorkflowPanelContent {\n    netIdentifier: TextField;\n    title: TextField;\n    version: TextField;\n    author: TextField;\n    uploaded: DateTimeField;\n}\n\nexport abstract class AbstractWorkflowPanelComponent extends PanelWithHeaderBinding implements OnInit, OnDestroy {\n\n    @Input() public workflow: Net;\n    @Input() public selectedHeaders$: Observable<Array<HeaderColumn>>;\n    @Input() responsiveBody = true;\n    @Input() showDeleteMenu = false;\n    public panelRef: MatExpansionPanel;\n    public panelContent: WorkflowPanelContent;\n    private _subscription: Subscription;\n    private readonly TRANSLATION_NET = 'panel.workflow.net';\n    private readonly TRANSLATION_TITLE = 'panel.workflow.title';\n    private readonly TRANSLATION_VERSION = 'panel.workflow.version';\n    private readonly TRANSLATION_AUTHOR = 'panel.workflow.author';\n    private readonly TRANSLATION_UPLOAD = 'panel.workflow.upload';\n\n    protected dataFieldsBehaviour: Behavior = {visible: true, editable: false};\n\n    protected constructor(protected _log: LoggerService,\n                          protected _translate: TranslateService,\n                          protected _workflowService: WorkflowViewService) {\n        super();\n\n        this._subscription = _translate.onLangChange.subscribe((event: TranslationChangeEvent) => {\n            this.panelContent.netIdentifier.title = this._translate.instant(this.TRANSLATION_NET);\n            this.panelContent.title.title = this._translate.instant(this.TRANSLATION_TITLE);\n            this.panelContent.version.title = this._translate.instant(this.TRANSLATION_VERSION);\n            this.panelContent.author.title = this._translate.instant(this.TRANSLATION_AUTHOR);\n            this.panelContent.uploaded.title = this._translate.instant(this.TRANSLATION_UPLOAD);\n        });\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this.panelContent = this.createPanelContent();\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._subscription.unsubscribe();\n    }\n\n    public show(event: MouseEvent): boolean {\n        event.stopPropagation();\n        return false;\n    }\n\n    public collapse() {\n    }\n\n    public setPanelRef(panelRef: MatExpansionPanel) {\n        this.panelRef = panelRef;\n    }\n\n    /**\n     * Handles the logic that should be executed when the \"delete workflow\" button is clicked.\n     *\n     * Calls the appropriate method in the {@link WorkflowViewService}.\n     */\n    public deleteWorkflow(): void {\n        this._workflowService.deleteWorkflow(this.workflow);\n    }\n\n    /**\n     * Populate data fields group for every petri net model\n     */\n    protected createPanelContent(): WorkflowPanelContent {\n        return {\n            netIdentifier: new TextField('', this._translate.instant(this.TRANSLATION_NET),\n                this.workflow.identifier, this.dataFieldsBehaviour),\n            title: new TextField('', this._translate.instant(this.TRANSLATION_TITLE),\n                this.workflow.title, this.dataFieldsBehaviour),\n            version: new TextField('', this._translate.instant(this.TRANSLATION_VERSION),\n                this.workflow.version, this.dataFieldsBehaviour),\n            author: new TextField('', this._translate.instant(this.TRANSLATION_AUTHOR),\n                this.workflow.author.fullName, this.dataFieldsBehaviour),\n            uploaded: new DateTimeField('', this._translate.instant(this.TRANSLATION_UPLOAD),\n                toMoment(this.workflow.createdDate), this.dataFieldsBehaviour)\n        };\n    }\n\n    protected resolveFeaturedFieldsValues(): void {\n        if (!this._lastSelectedHeaders) {\n            return;\n        }\n\n        this.featuredFieldsValues.splice(0, this.featuredFieldsValues.length);\n        this._lastSelectedHeaders.forEach(header => {\n            this.featuredFieldsValues.push(this.getFeaturedValue(header));\n        });\n    }\n\n    protected getFeaturedMetaValue(selectedHeader: HeaderColumn): FeaturedValue {\n        switch (selectedHeader.fieldIdentifier) {\n            case WorkflowMetaField.INITIALS:\n                return {value: this.workflow.initials, icon: '', type: 'meta'};\n            case WorkflowMetaField.TITLE:\n                return {value: this.workflow.title, icon: '', type: 'meta'};\n            case WorkflowMetaField.NET_ID:\n                return {value: this.workflow.stringId, icon: '', type: 'meta'};\n            case WorkflowMetaField.VERSION:\n                return {value: this.workflow.version, icon: '', type: 'meta'};\n            case WorkflowMetaField.AUTHOR:\n                return {value: this.workflow.author.fullName, icon: 'account_circle', type: 'meta'};\n            case WorkflowMetaField.CREATION_DATE:\n                return {value: toMoment(this.workflow.createdDate).format(DATE_TIME_FORMAT_STRING), icon: 'event', type: 'meta'};\n        }\n    }\n\n    protected getFeaturedImmediateValue(selectedHeader: HeaderColumn): FeaturedValue {\n        this._log.warn('Immediate data in workflow panel headers are currently not supported');\n        return {value: '', icon: '', type: ''};\n    }\n\n}\n"]}

package/esm2015/lib/process/net.js

@@ -0,0 +1,101 @@
+/**
+ * @ignore
+ */
+export class Net {
+    /**
+     * @ignore
+     */
+    constructor(net) {
+        this._stringId = net.stringId;
+        this._title = net.title;
+        this._identifier = net.identifier;
+        this._version = net.version;
+        this._initials = net.initials;
+        this._defaultCaseName = net.defaultCaseName;
+        this._createdDate = net.createdDate;
+        this._author = net.author;
+        this._immediateData = net.immediateData;
+        this._transitions = [];
+        this._transactions = [];
+        this._roles = [];
+    }
+    get stringId() {
+        return this._stringId;
+    }
+    set stringId(value) {
+        this._stringId = value;
+    }
+    get title() {
+        return this._title;
+    }
+    set title(value) {
+        this._title = value;
+    }
+    get identifier() {
+        return this._identifier;
+    }
+    set identifier(value) {
+        this._identifier = value;
+    }
+    get version() {
+        return this._version;
+    }
+    set version(value) {
+        this._version = value;
+    }
+    get initials() {
+        return this._initials;
+    }
+    set initials(value) {
+        this._initials = value;
+    }
+    get defaultCaseName() {
+        return this._defaultCaseName;
+    }
+    set defaultCaseName(value) {
+        this._defaultCaseName = value;
+    }
+    get createdDate() {
+        return this._createdDate;
+    }
+    set createdDate(value) {
+        this._createdDate = value;
+    }
+    get author() {
+        return this._author;
+    }
+    set author(value) {
+        this._author = value;
+    }
+    get immediateData() {
+        return this._immediateData;
+    }
+    set immediateData(value) {
+        this._immediateData = value;
+    }
+    get transitions() {
+        return this._transitions;
+    }
+    set transitions(value) {
+        this._transitions = value;
+    }
+    get transactions() {
+        return this._transactions;
+    }
+    set transactions(value) {
+        this._transactions = value;
+    }
+    get roles() {
+        return this._roles;
+    }
+    set roles(value) {
+        this._roles = value;
+    }
+    get permissions() {
+        return this._permissions;
+    }
+    set permissions(value) {
+        this._permissions = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"net.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/process/net.ts"],"names":[],"mappings":"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","sourcesContent":["import {PetriNetReference} from '../resources/interface/petri-net-reference';\nimport {Author} from '../resources/interface/author';\nimport {ImmediateData} from '../resources/interface/immediate-data';\nimport Transition from './transition';\nimport Transaction from './transaction';\nimport NetRole from './netRole';\nimport {Permissions} from './permissions';\nimport {PetriNetReferenceWithPermissions} from './petri-net-reference-with-permissions';\n\n/**\n * @ignore\n */\nexport class Net implements PetriNetReferenceWithPermissions {\n    /**\n     * @ignore\n     */\n    private _stringId: string;\n    /**\n     * @ignore\n     */\n    private _title: string;\n    /**\n     * @ignore\n     */\n    private _identifier: string;\n    /**\n     * @ignore\n     */\n    private _version: string;\n    /**\n     * @ignore\n     */\n    private _initials: string;\n    /**\n     * @ignore\n     */\n    private _defaultCaseName: string;\n    /**\n     * @ignore\n     */\n    private _createdDate: Array<number>;\n    /**\n     * @ignore\n     */\n    private _author: Author;\n    /**\n     * @ignore\n     */\n    private _immediateData: Array<ImmediateData>;\n    /**\n     * @ignore\n     */\n    private _transitions: Array<Transition>;\n    /**\n     * @ignore\n     */\n    private _transactions: Array<Transaction>;\n    /**\n     * @ignore\n     */\n    private _roles: Array<NetRole>;\n    /**\n     * @ignore\n     */\n    private _permissions: Permissions;\n    /**\n     * @ignore\n     */\n    constructor(net: PetriNetReference) {\n        this._stringId = net.stringId;\n        this._title = net.title;\n        this._identifier = net.identifier;\n        this._version = net.version;\n        this._initials = net.initials;\n        this._defaultCaseName = net.defaultCaseName;\n        this._createdDate = net.createdDate;\n        this._author = net.author;\n        this._immediateData = net.immediateData;\n        this._transitions = [];\n        this._transactions = [];\n        this._roles = [];\n    }\n\n    get stringId(): string {\n        return this._stringId;\n    }\n\n    set stringId(value: string) {\n        this._stringId = value;\n    }\n\n    get title(): string {\n        return this._title;\n    }\n\n    set title(value: string) {\n        this._title = value;\n    }\n\n    get identifier(): string {\n        return this._identifier;\n    }\n\n    set identifier(value: string) {\n        this._identifier = value;\n    }\n\n    get version(): string {\n        return this._version;\n    }\n\n    set version(value: string) {\n        this._version = value;\n    }\n\n    get initials(): string {\n        return this._initials;\n    }\n\n    set initials(value: string) {\n        this._initials = value;\n    }\n\n    get defaultCaseName(): string {\n        return this._defaultCaseName;\n    }\n\n    set defaultCaseName(value: string) {\n        this._defaultCaseName = value;\n    }\n\n    get createdDate(): Array<number> {\n        return this._createdDate;\n    }\n\n    set createdDate(value: Array<number>) {\n        this._createdDate = value;\n    }\n\n    get author(): Author {\n        return this._author;\n    }\n\n    set author(value: Author) {\n        this._author = value;\n    }\n\n    get immediateData(): Array<ImmediateData> {\n        return this._immediateData;\n    }\n\n    set immediateData(value: Array<ImmediateData>) {\n        this._immediateData = value;\n    }\n\n    get transitions(): Array<Transition> {\n        return this._transitions;\n    }\n\n    set transitions(value: Array<Transition>) {\n        this._transitions = value;\n    }\n\n    get transactions(): Array<Transaction> {\n        return this._transactions;\n    }\n\n    set transactions(value: Array<Transaction>) {\n        this._transactions = value;\n    }\n\n    get roles(): Array<NetRole> {\n        return this._roles;\n    }\n\n    set roles(value: Array<NetRole>) {\n        this._roles = value;\n    }\n\n    get permissions(): Permissions {\n        return this._permissions;\n    }\n\n    set permissions(value: Permissions) {\n        this._permissions = value;\n    }\n}\n"]}

package/esm2015/lib/process/netRole.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0Um9sZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9wcm9jZXNzL25ldFJvbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGludGVyZmFjZSBOZXRSb2xlIHtcbiAgICBzdHJpbmdJZDogc3RyaW5nO1xuICAgIG5hbWU6IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/process/permissions.js

@@ -0,0 +1,12 @@
+export var PermissionType;
+(function (PermissionType) {
+    PermissionType["CREATE"] = "create";
+    PermissionType["DELETE"] = "delete";
+    PermissionType["VIEW"] = "view";
+    PermissionType["ASSIGN"] = "assign";
+    PermissionType["CANCEL"] = "cancel";
+    PermissionType["FINISH"] = "finish";
+    PermissionType["DELEGATE"] = "delegate";
+    PermissionType["SET"] = "set";
+})(PermissionType || (PermissionType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvcHJvY2Vzcy9wZXJtaXNzaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF3QkEsTUFBTSxDQUFOLElBQVksY0FTWDtBQVRELFdBQVksY0FBYztJQUN0QixtQ0FBaUIsQ0FBQTtJQUNqQixtQ0FBaUIsQ0FBQTtJQUNqQiwrQkFBYSxDQUFBO0lBQ2IsbUNBQWlCLENBQUE7SUFDakIsbUNBQWlCLENBQUE7SUFDakIsbUNBQWlCLENBQUE7SUFDakIsdUNBQXFCLENBQUE7SUFDckIsNkJBQVcsQ0FBQTtBQUNmLENBQUMsRUFUVyxjQUFjLEtBQWQsY0FBYyxRQVN6QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUGVybWlzc2lvbnMge1xuICAgIFtrOiBzdHJpbmddOiBQZXJtaXNzaW9uO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVzZXJQZXJtaXNzaW9ucyB7XG4gICAgW2s6IHN0cmluZ106IFBlcm1pc3Npb247XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVXNlclJlZnMge1xuICAgIFtrOiBzdHJpbmddOiBQZXJtaXNzaW9uO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFBlcm1pc3Npb24ge1xuICAgIGNyZWF0ZT86IGJvb2xlYW47XG4gICAgZGVsZXRlPzogYm9vbGVhbjtcbiAgICB2aWV3PzogYm9vbGVhbjtcbiAgICBhc3NpZ24/OiBib29sZWFuO1xuICAgIGFzc2lnbmVkPzogYm9vbGVhbjtcbiAgICBjYW5jZWw/OiBib29sZWFuO1xuICAgIGZpbmlzaD86IGJvb2xlYW47XG4gICAgZGVsZWdhdGU/OiBib29sZWFuO1xuICAgIHNldD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBlbnVtIFBlcm1pc3Npb25UeXBlIHtcbiAgICBDUkVBVEUgPSAnY3JlYXRlJyxcbiAgICBERUxFVEUgPSAnZGVsZXRlJyxcbiAgICBWSUVXID0gJ3ZpZXcnLFxuICAgIEFTU0lHTiA9ICdhc3NpZ24nLFxuICAgIENBTkNFTCA9ICdjYW5jZWwnLFxuICAgIEZJTklTSCA9ICdmaW5pc2gnLFxuICAgIERFTEVHQVRFID0gJ2RlbGVnYXRlJyxcbiAgICBTRVQgPSAnc2V0J1xufVxuIl19

package/esm2015/lib/process/petri-net-reference-with-permissions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGV0cmktbmV0LXJlZmVyZW5jZS13aXRoLXBlcm1pc3Npb25zLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3Byb2Nlc3MvcGV0cmktbmV0LXJlZmVyZW5jZS13aXRoLXBlcm1pc3Npb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BldHJpTmV0UmVmZXJlbmNlfSBmcm9tICcuLi9yZXNvdXJjZXMvaW50ZXJmYWNlL3BldHJpLW5ldC1yZWZlcmVuY2UnO1xuaW1wb3J0IHtQZXJtaXNzaW9uc30gZnJvbSAnLi9wZXJtaXNzaW9ucyc7XG5pbXBvcnQgTmV0Um9sZSBmcm9tICcuL25ldFJvbGUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBldHJpTmV0UmVmZXJlbmNlV2l0aFBlcm1pc3Npb25zIGV4dGVuZHMgUGV0cmlOZXRSZWZlcmVuY2Uge1xuICAgIHJvbGVzOiBBcnJheTxOZXRSb2xlPjtcbiAgICBwZXJtaXNzaW9uczogUGVybWlzc2lvbnM7XG59XG5cbiJdfQ==

package/esm2015/lib/process/process.service.js

@@ -0,0 +1,301 @@
+import { Injectable } from '@angular/core';
+import { forkJoin, of, ReplaySubject, Subject } from 'rxjs';
+import { Net } from './net';
+import { PetriNetResourceService } from '../resources/engine-endpoint/petri-net-resource.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { catchError, map, switchMap, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../resources/engine-endpoint/petri-net-resource.service";
+import * as i2 from "../logger/services/logger.service";
+/**
+ * Process service is responsible for loading and caching processes needed for any functionality of an app.
+ */
+export class ProcessService {
+    constructor(_petriNetResource, _log) {
+        this._petriNetResource = _petriNetResource;
+        this._log = _log;
+        this._nets = {};
+        this._netsSubject = new Subject();
+        this._netUpdate = new Subject();
+        this._requestCache = new Map();
+        this._referenceRequestCache = new Map();
+    }
+    ngOnDestroy() {
+        this._netsSubject.complete();
+        this._netUpdate.complete();
+        Array.from(this._requestCache.values()).forEach(net => net.complete());
+        Array.from(this._referenceRequestCache.values()).forEach(net => net.complete());
+    }
+    /**
+     * Get process nets according to provided identifiers.
+     * If any of the requested processes is not cached it will be loaded from the server and saved for later.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    getNets(identifiers, forceLoad = false) {
+        if (identifiers.length === 0) {
+            return of([]);
+        }
+        return forkJoin(identifiers.map(i => {
+            return this.getNet(i, forceLoad);
+        })).pipe(map(nets => nets.filter(n => !!n)), tap(nets => {
+            if (nets.length === 0) {
+                return;
+            }
+            this._netsSubject.next(this._nets);
+            nets.forEach(n => this._netUpdate.next(n));
+        }));
+    }
+    /**
+     * Get process net by identifier.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    getNet(identifier, forceLoad = false) {
+        if (!forceLoad && this._nets[identifier]) {
+            this._log.debug(`returning net '${identifier}' from cache`);
+            return of(this._nets[identifier]);
+        }
+        if (this._requestCache.has(identifier)) {
+            this._log.debug(`returning net '${identifier}' from pending requests`);
+            return this._requestCache.get(identifier).asObservable();
+        }
+        this._log.debug(`retrieving net '${identifier}' from backend`);
+        this._requestCache.set(identifier, new ReplaySubject(1));
+        return this.loadNet(identifier).pipe(tap(net => {
+            const s = this._requestCache.get(identifier);
+            if (s) {
+                s.next(net);
+                s.complete();
+                this._requestCache.delete(identifier);
+            }
+            if (net) {
+                this.publishUpdate(net);
+            }
+        }));
+    }
+    /**
+     * Get process net referencess according to provided identifiers.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    getNetReferences(identifiers) {
+        if (identifiers.length === 0) {
+            return of([]);
+        }
+        return forkJoin(identifiers.map(i => {
+            return this.getNetReference(i);
+        })).pipe(map(references => references.filter(r => !!r)));
+    }
+    /**
+     * Get process net reference by identifier.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    getNetReference(identifier) {
+        if (this._referenceRequestCache.has(identifier)) {
+            return this._referenceRequestCache.get(identifier).asObservable();
+        }
+        this._referenceRequestCache.set(identifier, new ReplaySubject(1));
+        return this.loadNetReference(identifier).pipe(switchMap(ref => {
+            if (ref !== null) {
+                return forkJoin({ net: of(ref), roles: this.loadRoles(ref.stringId) });
+            }
+            else {
+                return of({ net: ref, roles: undefined });
+            }
+        }), map(result => {
+            if (result.net === null) {
+                return null;
+            }
+            return Object.assign(Object.assign({}, result.net), { roles: result.roles.processRoles, permissions: result.roles.permissions });
+        }), tap(reference => {
+            const s = this._referenceRequestCache.get(identifier);
+            if (s) {
+                s.next(reference);
+                s.complete();
+                this._referenceRequestCache.delete(identifier);
+            }
+        }));
+    }
+    /**
+     * Remove cached process by identifier. If the process is not found nothing happens.
+     * @param identifier Process identifier
+     */
+    removeNet(identifier) {
+        if (!this._nets[identifier]) {
+            return;
+        }
+        delete this._nets[identifier];
+        this.publishUpdate();
+    }
+    /**
+     * Update cached process object. If the process is not found nothing happens. Process object is replaced.
+     * @param net Updated process object.
+     */
+    updateNet(net) {
+        if (!this._nets[net.identifier]) {
+            return;
+        }
+        if (!net.transitions.length || !net.transactions.length || !net.roles.length) {
+            forkJoin({
+                transitions: this.loadTransitions(net.stringId),
+                transactions: this.loadTransactions(net.stringId),
+                roles: this.loadRoles(net.stringId)
+            }).subscribe(values => {
+                net.transitions = values.transitions;
+                net.transactions = values.transactions;
+                net.roles = values.roles.processRoles;
+                net.permissions = values.roles.permissions;
+                this._nets[net.identifier] = net;
+                this.publishUpdate(net);
+            }, error => {
+                this._log.error('Failed to load part of Petri net ' + net.title, error);
+                // throw error;
+            });
+        }
+        else {
+            this._nets[net.identifier] = net;
+            this.publishUpdate(net);
+        }
+    }
+    /**
+     * Stream of change of the process cache.
+     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+     * @returns Observable of whole updated cache.
+     */
+    get nets$() {
+        return this._netsSubject.asObservable();
+    }
+    /**
+     * Stream of change in the process cache.
+     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+     * @returns Observable of updated or newly loaded process net.
+     */
+    get netUpdate$() {
+        return this._netUpdate.asObservable();
+    }
+    areNetsLoaded(identifiers) {
+        return identifiers.every(identifier => this.isNetLoaded(identifier));
+    }
+    isNetLoaded(identifier) {
+        return !!this._nets[identifier];
+    }
+    loadNet(id) {
+        const returnNet = new ReplaySubject(1);
+        this.loadNetReference(id).subscribe(net => {
+            if (net === null) {
+                this._log.debug(`loadNetReference for net '${id}' returned null`);
+                returnNet.next(null);
+                returnNet.complete();
+                return;
+            }
+            this._log.debug(`loading net '${id}' transitions, transactions and roles`);
+            forkJoin({
+                transitions: this.loadTransitions(net.stringId),
+                transactions: this.loadTransactions(net.stringId),
+                roles: this.loadRoles(net.stringId)
+            }).subscribe(values => {
+                this._nets[net.identifier] = new Net(net);
+                this._nets[net.identifier].transitions = values.transitions;
+                this._nets[net.identifier].transactions = values.transactions;
+                this._nets[net.identifier].roles = values.roles.processRoles;
+                this._nets[net.identifier].permissions = values.roles.permissions;
+                returnNet.next(this._nets[net.identifier]);
+                returnNet.complete();
+            }, error => {
+                this._log.error('Failed to load part of Petri net ' + net.title, error);
+                returnNet.next(this._nets[net.identifier]);
+                returnNet.complete();
+                // throw error;
+            });
+        });
+        return returnNet.asObservable();
+    }
+    loadNetReference(id) {
+        const returnReference = new ReplaySubject(1);
+        this._petriNetResource.getOne(id, '^').subscribe(reference => {
+            returnReference.next(!reference.stringId ? null : reference);
+            returnReference.complete();
+            return;
+        }, error => {
+            this._log.error('Failed to load Petri net', error);
+            returnReference.next(null);
+            returnReference.complete();
+        });
+        return returnReference.asObservable();
+    }
+    loadTransitions(id) {
+        return this._petriNetResource.getPetriNetTransitions(id).pipe(map(trans => {
+            if (trans instanceof Array) {
+                return trans;
+            }
+            return [];
+        }), tap(trans => {
+            if (trans.length === 0) {
+                this._log.info('References for transitions of net ' + id + ' were not found!');
+            }
+        }), catchError(err => {
+            this._log.error('References for transitions of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    }
+    loadTransactions(id) {
+        return this._petriNetResource.getPetriNetTransactions(id).pipe(map(trans => {
+            if (trans instanceof Array) {
+                return trans;
+            }
+            return [];
+        }), tap(trans => {
+            if (trans.length === 0) {
+                this._log.info('References for transactions of net ' + id + ' were not found!');
+            }
+        }), catchError(err => {
+            this._log.error('References for transactions of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    }
+    loadRoles(id) {
+        return this._petriNetResource.getPetriNetRoles(id).pipe(tap(rolesAndPerm => {
+            if (rolesAndPerm.processRoles.length === 0) {
+                this._log.info('Roles reference of net ' + id + ' were not found!');
+            }
+        }), catchError(err => {
+            this._log.error('Roles reference of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    }
+    publishUpdate(net) {
+        this._netsSubject.next(this._nets);
+        if (net) {
+            this._netUpdate.next(net);
+        }
+    }
+}
+ProcessService.ctorParameters = () => [
+    { type: PetriNetResourceService },
+    { type: LoggerService }
+];
+ProcessService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProcessService_Factory() { return new ProcessService(i0.ɵɵinject(i1.PetriNetResourceService), i0.ɵɵinject(i2.LoggerService)); }, token: ProcessService, providedIn: "root" });
+ProcessService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ProcessService.ctorParameters = () => [
+    { type: PetriNetResourceService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/process/process.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {forkJoin, Observable, of, ReplaySubject, Subject} from 'rxjs';\nimport {Net} from './net';\nimport {PetriNetResourceService} from '../resources/engine-endpoint/petri-net-resource.service';\nimport {LoggerService} from '../logger/services/logger.service';\nimport Transition from './transition';\nimport Transaction from './transaction';\nimport {catchError, map, switchMap, tap} from 'rxjs/operators';\nimport RolesAndPermissions from './rolesAndPermissions';\nimport {PetriNetReference} from '../resources/interface/petri-net-reference';\nimport {PetriNetReferenceWithPermissions} from './petri-net-reference-with-permissions';\n\nexport interface NetCache {\n    [k: string]: Net;\n}\n\n/**\n * Process service is responsible for loading and caching processes needed for any functionality of an app.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class ProcessService implements OnDestroy {\n\n    protected readonly _nets: NetCache;\n    protected _netsSubject: Subject<NetCache>;\n    protected _netUpdate: Subject<Net>;\n    protected _requestCache: Map<string, ReplaySubject<Net>>;\n    protected _referenceRequestCache: Map<string, ReplaySubject<PetriNetReferenceWithPermissions>>;\n\n    constructor(private _petriNetResource: PetriNetResourceService, private _log: LoggerService) {\n        this._nets = {};\n        this._netsSubject = new Subject<NetCache>();\n        this._netUpdate = new Subject<Net>();\n        this._requestCache = new Map<string, ReplaySubject<Net>>();\n        this._referenceRequestCache = new Map<string, ReplaySubject<PetriNetReferenceWithPermissions>>();\n    }\n\n    ngOnDestroy(): void {\n        this._netsSubject.complete();\n        this._netUpdate.complete();\n        Array.from(this._requestCache.values()).forEach(net => net.complete());\n        Array.from(this._referenceRequestCache.values()).forEach(net => net.complete());\n    }\n\n    /**\n     * Get process nets according to provided identifiers.\n     * If any of the requested processes is not cached it will be loaded from the server and saved for later.\n     * @param identifiers Array of identifiers of requested processes. See {@link Net}\n     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made\n     * (unless another is already pending)\n     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.\n     * If any of the processes failed to load it is skipped from the result.\n     */\n    public getNets(identifiers: Array<string>, forceLoad = false): Observable<Array<Net>> {\n        if (identifiers.length === 0) {\n            return of([]);\n        }\n        return forkJoin(identifiers.map(i => {\n            return this.getNet(i, forceLoad);\n        })).pipe(\n            map(nets => nets.filter(n => !!n)),\n            tap(nets => {\n                if (nets.length === 0) {\n                    return;\n                }\n                this._netsSubject.next(this._nets);\n                nets.forEach(n => this._netUpdate.next(n));\n            })\n        );\n    }\n\n    /**\n     * Get process net by identifier.\n     * @param identifier Identifier of the requested process. See {@link Net}\n     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made\n     * (unless another is already pending)\n     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.\n     */\n    public getNet(identifier: string, forceLoad = false): Observable<Net> {\n        if (!forceLoad && this._nets[identifier]) {\n            this._log.debug(`returning net '${identifier}' from cache`);\n            return of(this._nets[identifier]);\n        }\n        if (this._requestCache.has(identifier)) {\n            this._log.debug(`returning net '${identifier}' from pending requests`);\n            return this._requestCache.get(identifier).asObservable();\n        }\n        this._log.debug(`retrieving net '${identifier}' from backend`);\n        this._requestCache.set(identifier, new ReplaySubject<Net>(1));\n        return this.loadNet(identifier).pipe(\n            tap(net => {\n                const s = this._requestCache.get(identifier);\n                if (s) {\n                    s.next(net);\n                    s.complete();\n                    this._requestCache.delete(identifier);\n                }\n                if (net) {\n                    this.publishUpdate(net);\n                }\n            })\n        );\n    }\n\n    /**\n     * Get process net referencess according to provided identifiers.\n     *\n     * `PetriNetReferences` are not cached.\n     * Each call will result in a new backend request unless a request for the same net is already pending.\n     * @param identifiers Array of identifiers of requested processes. See {@link Net}\n     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.\n     * If any of the processes failed to load it is skipped from the result.\n     */\n    public getNetReferences(identifiers: Array<string>): Observable<Array<PetriNetReferenceWithPermissions>> {\n        if (identifiers.length === 0) {\n            return of([]);\n        }\n        return forkJoin(identifiers.map(i => {\n            return this.getNetReference(i);\n        })).pipe(\n            map(references => references.filter(r => !!r))\n        );\n    }\n\n    /**\n     * Get process net reference by identifier.\n     *\n     * `PetriNetReferences` are not cached.\n     * Each call will result in a new backend request unless a request for the same net is already pending.\n     * @param identifier Identifier of the requested process. See {@link Net}\n     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.\n     */\n    public getNetReference(identifier: string): Observable<PetriNetReferenceWithPermissions> {\n        if (this._referenceRequestCache.has(identifier)) {\n            return this._referenceRequestCache.get(identifier).asObservable();\n        }\n        this._referenceRequestCache.set(identifier, new ReplaySubject<PetriNetReferenceWithPermissions>(1));\n        return this.loadNetReference(identifier).pipe(\n            switchMap(ref => {\n                if (ref !== null) {\n                    return forkJoin({net: of(ref), roles: this.loadRoles(ref.stringId)});\n                } else {\n                    return of({net: ref, roles: undefined});\n                }\n            }),\n            map(result => {\n                if (result.net === null) {\n                    return null;\n                }\n                return {\n                    ...result.net,\n                    roles: result.roles.processRoles,\n                    permissions: result.roles.permissions\n                };\n            }),\n            tap(reference => {\n                const s = this._referenceRequestCache.get(identifier);\n                if (s) {\n                    s.next(reference);\n                    s.complete();\n                    this._referenceRequestCache.delete(identifier);\n                }\n            })\n        );\n    }\n\n    /**\n     * Remove cached process by identifier. If the process is not found nothing happens.\n     * @param identifier Process identifier\n     */\n    public removeNet(identifier: string): void {\n        if (!this._nets[identifier]) {\n            return;\n        }\n        delete this._nets[identifier];\n        this.publishUpdate();\n    }\n\n    /**\n     * Update cached process object. If the process is not found nothing happens. Process object is replaced.\n     * @param net Updated process object.\n     */\n    public updateNet(net: Net): void {\n        if (!this._nets[net.identifier]) {\n            return;\n        }\n        if (!net.transitions.length || !net.transactions.length || !net.roles.length) {\n            forkJoin({\n                transitions: this.loadTransitions(net.stringId),\n                transactions: this.loadTransactions(net.stringId),\n                roles: this.loadRoles(net.stringId)\n            }).subscribe(values => {\n                net.transitions = values.transitions;\n                net.transactions = values.transactions;\n                net.roles = values.roles.processRoles;\n                net.permissions = values.roles.permissions;\n                this._nets[net.identifier] = net;\n                this.publishUpdate(net);\n            }, error => {\n                this._log.error('Failed to load part of Petri net ' + net.title, error);\n                // throw error;\n            });\n        } else {\n            this._nets[net.identifier] = net;\n            this.publishUpdate(net);\n        }\n    }\n\n    /**\n     * Stream of change of the process cache.\n     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.\n     * @returns Observable of whole updated cache.\n     */\n    public get nets$(): Observable<NetCache> {\n        return this._netsSubject.asObservable();\n    }\n\n    /**\n     * Stream of change in the process cache.\n     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.\n     * @returns Observable of updated or newly loaded process net.\n     */\n    public get netUpdate$(): Observable<Net> {\n        return this._netUpdate.asObservable();\n    }\n\n    public areNetsLoaded(identifiers: Array<string>): boolean {\n        return identifiers.every(identifier => this.isNetLoaded(identifier));\n    }\n\n    public isNetLoaded(identifier: string): boolean {\n        return !!this._nets[identifier];\n    }\n\n    protected loadNet(id: string): Observable<Net> {\n        const returnNet = new ReplaySubject<Net>(1);\n        this.loadNetReference(id).subscribe(net => {\n            if (net === null) {\n                this._log.debug(`loadNetReference for net '${id}' returned null`);\n                returnNet.next(null);\n                returnNet.complete();\n                return;\n            }\n            this._log.debug(`loading net '${id}' transitions, transactions and roles`);\n            forkJoin({\n                transitions: this.loadTransitions(net.stringId),\n                transactions: this.loadTransactions(net.stringId),\n                roles: this.loadRoles(net.stringId)\n            }).subscribe(values => {\n                this._nets[net.identifier] = new Net(net);\n                this._nets[net.identifier].transitions = values.transitions;\n                this._nets[net.identifier].transactions = values.transactions;\n                this._nets[net.identifier].roles = values.roles.processRoles;\n                this._nets[net.identifier].permissions = values.roles.permissions;\n                returnNet.next(this._nets[net.identifier]);\n                returnNet.complete();\n            }, error => {\n                this._log.error('Failed to load part of Petri net ' + net.title, error);\n                returnNet.next(this._nets[net.identifier]);\n                returnNet.complete();\n                // throw error;\n            });\n        });\n        return returnNet.asObservable();\n    }\n\n    protected loadNetReference(id: string): Observable<PetriNetReference> {\n        const returnReference = new ReplaySubject<PetriNetReference>(1);\n        this._petriNetResource.getOne(id, '^').subscribe(reference => {\n            returnReference.next(!reference.stringId ? null : reference);\n            returnReference.complete();\n            return;\n        }, error => {\n            this._log.error('Failed to load Petri net', error);\n            returnReference.next(null);\n            returnReference.complete();\n        });\n        return returnReference.asObservable();\n    }\n\n    protected loadTransitions(id: string): Observable<Array<Transition>> {\n        return this._petriNetResource.getPetriNetTransitions(id).pipe(\n            map(trans => {\n                if (trans instanceof Array) {\n                    return trans;\n                }\n                return [];\n            }),\n            tap(trans => {\n                if (trans.length === 0) {\n                    this._log.info('References for transitions of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('References for transitions of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected loadTransactions(id: string): Observable<Array<Transaction>> {\n        return this._petriNetResource.getPetriNetTransactions(id).pipe(\n            map(trans => {\n                if (trans instanceof Array) {\n                    return trans;\n                }\n                return [];\n            }),\n            tap(trans => {\n                if (trans.length === 0) {\n                    this._log.info('References for transactions of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('References for transactions of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected loadRoles(id: string): Observable<RolesAndPermissions> {\n        return this._petriNetResource.getPetriNetRoles(id).pipe(\n            tap(rolesAndPerm => {\n                if (rolesAndPerm.processRoles.length === 0) {\n                    this._log.info('Roles reference of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('Roles reference of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected publishUpdate(net?: Net): void {\n        this._netsSubject.next(this._nets);\n        if (net) {\n            this._netUpdate.next(net);\n        }\n    }\n}\n"]}

package/esm2015/lib/process/public-api.js

@@ -0,0 +1,8 @@
+export * from './process.service';
+export * from './net';
+export * from './transition';
+export * from './transaction';
+export * from './netRole';
+export * from './public-process.service';
+export * from './petri-net-reference-with-permissions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9wcm9jZXNzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3Byb2Nlc3Muc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL25ldCc7XG5leHBvcnQgKiBmcm9tICcuL3RyYW5zaXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc2FjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL25ldFJvbGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtcHJvY2Vzcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGV0cmktbmV0LXJlZmVyZW5jZS13aXRoLXBlcm1pc3Npb25zJztcbiJdfQ==