@smartbit4all/ng-client 1.0.0

package/esm2020/lib/view-context/smart-ui-action/ui-action.descriptor.service.mjs

@@ -0,0 +1,113 @@
+import { Injectable } from "@angular/core";
+import { UiActionButtonIconPos, UiActionButtonType, UiActionFeedbackType, } from "../api";
+import { Subject, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../smart-view-context.service";
+export class UiActionDescriptorService {
+    constructor(viewContext) {
+        this.viewContext = viewContext;
+        this._destroy$ = new Subject();
+        this.languageChanged = new Subject();
+        this.keysToTranslate = ["title", "text", "placeholder", "caption", "feedbackText"];
+        this.basicActionDescriptors = new Map([
+            [
+                "UNKOWN",
+                {
+                    title: "",
+                    type: UiActionButtonType.Normal,
+                    color: "accent",
+                    icon: "Question",
+                    iconColor: `text-primary`,
+                    iconPosition: UiActionButtonIconPos.Post,
+                    dialog: {
+                        title: "",
+                        placeholder: "placeholder",
+                        actionButton: {
+                            caption: "",
+                            color: "accent",
+                        },
+                        cancelButton: {
+                            caption: "Mégse",
+                            color: "",
+                        },
+                    },
+                },
+            ],
+        ]);
+        if (this.viewContext.translateService) {
+            this.subscribeToTranslateService();
+        }
+        else {
+            this.viewContext.translateServiceChanged
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(() => {
+                this.subscribeToTranslateService();
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    subscribeToTranslateService() {
+        this.viewContext
+            .translateService.onLangChange.pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.languageChanged.next();
+        });
+    }
+    async getActionDescriptor(uiAction) {
+        let code = uiAction.code;
+        let actionDescriptorFromDescriptors = this.viewContext.getActionDescriptors()?.get(code);
+        let actionDescriptor = JSON.parse(JSON.stringify(actionDescriptorFromDescriptors));
+        if (!actionDescriptor) {
+            actionDescriptor = this.basicActionDescriptors.get("UNKOWN");
+            actionDescriptor.title = code;
+        }
+        if (!actionDescriptor.dialog) {
+            actionDescriptor = this.setUpUnkownDialogDescriptor(code, actionDescriptor, "dialog");
+        }
+        if (!actionDescriptor.feedbackType && uiAction.submit) {
+            actionDescriptor.feedbackType = UiActionFeedbackType.Snackbar;
+        }
+        if (this.viewContext.translateService && actionDescriptor) {
+            actionDescriptor = await this.translateUiActionDescriptor(actionDescriptor);
+        }
+        return actionDescriptor;
+    }
+    async translateUiActionDescriptor(uiActionDescriptor) {
+        uiActionDescriptor = await this.deepTranslate(uiActionDescriptor);
+        return uiActionDescriptor;
+    }
+    async deepTranslate(model) {
+        Object.keys(model).map(async (key) => {
+            if (model[key] !== undefined &&
+                typeof model[key] === "string" &&
+                model[key].length &&
+                this.keysToTranslate.includes(key)) {
+                model[key] = await this.viewContext.translateService.get(model[key]).toPromise();
+            }
+            else if (model[key] !== undefined && typeof model[key] === "object") {
+                model[key] = await this.deepTranslate(model[key]);
+            }
+            return model;
+        });
+        return model;
+    }
+    setUpUnkownDialogDescriptor(code, uiActionDescriptor, dialogType) {
+        let unkownDescriptor = this.basicActionDescriptors.get("UNKOWN");
+        uiActionDescriptor[dialogType] = unkownDescriptor.dialog;
+        uiActionDescriptor[dialogType].title = code;
+        uiActionDescriptor[dialogType].actionButton.caption = code;
+        return uiActionDescriptor;
+    }
+}
+UiActionDescriptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, deps: [{ token: i1.SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionDescriptorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SmartViewContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-action.descriptor.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/view-context/smart-ui-action/ui-action.descriptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from \"@angular/core\";\nimport {\n    UiAction,\n    UiActionButtonIconPos,\n    UiActionButtonType,\n    UiActionDescriptor,\n    UiActionFeedbackType,\n} from \"../api\";\nimport { SmartViewContextService } from \"../smart-view-context.service\";\nimport { Subject, takeUntil } from \"rxjs\";\n\n@Injectable({\n    providedIn: \"root\",\n})\nexport class UiActionDescriptorService implements OnDestroy {\n    private _destroy$: Subject<void> = new Subject();\n\n    languageChanged: Subject<void> = new Subject();\n    keysToTranslate: string[] = [\"title\", \"text\", \"placeholder\", \"caption\", \"feedbackText\"];\n\n    constructor(private viewContext: SmartViewContextService) {\n        if (this.viewContext.translateService) {\n            this.subscribeToTranslateService();\n        } else {\n            this.viewContext.translateServiceChanged\n                .pipe(takeUntil(this._destroy$))\n                .subscribe(() => {\n                    this.subscribeToTranslateService();\n                });\n        }\n    }\n    ngOnDestroy(): void {\n        this._destroy$.next();\n        this._destroy$.complete();\n    }\n\n    private subscribeToTranslateService(): void {\n        this.viewContext\n            .translateService!.onLangChange.pipe(takeUntil(this._destroy$))\n            .subscribe(() => {\n                this.languageChanged.next();\n            });\n    }\n\n    public async getActionDescriptor(uiAction: UiAction): Promise<UiActionDescriptor> {\n        let code = uiAction.code!;\n        let actionDescriptorFromDescriptors = this.viewContext.getActionDescriptors()?.get(code);\n\n        let actionDescriptor = JSON.parse(JSON.stringify(actionDescriptorFromDescriptors));\n\n        if (!actionDescriptor) {\n            actionDescriptor = this.basicActionDescriptors.get(\"UNKOWN\");\n            actionDescriptor!.title = code;\n        }\n\n        if (!actionDescriptor!.dialog) {\n            actionDescriptor = this.setUpUnkownDialogDescriptor(code, actionDescriptor!, \"dialog\");\n        }\n\n        if (!actionDescriptor!.feedbackType && uiAction.submit) {\n            actionDescriptor!.feedbackType = UiActionFeedbackType.Snackbar;\n        }\n\n        if (this.viewContext.translateService && actionDescriptor) {\n            actionDescriptor = await this.translateUiActionDescriptor(actionDescriptor);\n        }\n\n        return actionDescriptor!;\n    }\n\n    private async translateUiActionDescriptor(\n        uiActionDescriptor: UiActionDescriptor\n    ): Promise<UiActionDescriptor> {\n        uiActionDescriptor = await this.deepTranslate(uiActionDescriptor);\n\n        return uiActionDescriptor;\n    }\n\n    private async deepTranslate(model: any): Promise<any> {\n        Object.keys(model).map(async (key: string) => {\n            if (\n                model[key] !== undefined &&\n                typeof model[key] === \"string\" &&\n                model[key].length &&\n                this.keysToTranslate.includes(key)\n            ) {\n                model[key] = await this.viewContext.translateService!.get(model[key]).toPromise();\n            } else if (model[key] !== undefined && typeof model[key] === \"object\") {\n                model[key] = await this.deepTranslate(model[key]);\n            }\n            return model;\n        });\n\n        return model;\n    }\n\n    private setUpUnkownDialogDescriptor(\n        code: string,\n        uiActionDescriptor: UiActionDescriptor,\n        dialogType: \"dialog\" | \"confirmDialog\" | \"inputDialog\" | \"input2Dialog\"\n    ): UiActionDescriptor {\n        let unkownDescriptor = this.basicActionDescriptors.get(\"UNKOWN\");\n\n        uiActionDescriptor[dialogType] = unkownDescriptor!.dialog;\n        uiActionDescriptor[dialogType]!.title = code;\n        uiActionDescriptor[dialogType]!.actionButton.caption = code;\n\n        return uiActionDescriptor;\n    }\n\n    private basicActionDescriptors: Map<string, UiActionDescriptor> = new Map([\n        [\n            \"UNKOWN\",\n            {\n                title: \"\",\n                type: UiActionButtonType.Normal,\n                color: \"accent\",\n                icon: \"Question\",\n                iconColor: `text-primary`,\n                iconPosition: UiActionButtonIconPos.Post,\n                dialog: {\n                    title: \"\",\n                    placeholder: \"placeholder\",\n                    actionButton: {\n                        caption: \"\",\n                        color: \"accent\",\n                    },\n                    cancelButton: {\n                        caption: \"Mégse\",\n                        color: \"\",\n                    },\n                },\n            },\n        ],\n    ]);\n}\n"]}

package/esm2020/lib/view-context/smart-ui-action/ui-action.model.mjs

@@ -0,0 +1,7 @@
+export var UiActionDialogType;
+(function (UiActionDialogType) {
+    UiActionDialogType["inputDialog"] = "inputDialog";
+    UiActionDialogType["confirmDialog"] = "confirmDialog";
+    UiActionDialogType["dialog"] = "dialog";
+})(UiActionDialogType || (UiActionDialogType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidWktYWN0aW9uLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvdmlldy1jb250ZXh0L3NtYXJ0LXVpLWFjdGlvbi91aS1hY3Rpb24ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBaUNBLE1BQU0sQ0FBTixJQUFZLGtCQUlYO0FBSkQsV0FBWSxrQkFBa0I7SUFDMUIsaURBQTJCLENBQUE7SUFDM0IscURBQStCLENBQUE7SUFDL0IsdUNBQWlCLENBQUE7QUFDckIsQ0FBQyxFQUpXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFJN0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSBcInJ4anNcIjtcbmltcG9ydCB7IFVpQWN0aW9uLCBVaUFjdGlvbkRlc2NyaXB0b3IsIFVpQWN0aW9uUmVxdWVzdCB9IGZyb20gXCIuLi9hcGlcIjtcblxuZXhwb3J0IGludGVyZmFjZSBVaUFjdGlvbk1vZGVsIHtcbiAgICB1aUFjdGlvbjogVWlBY3Rpb247XG4gICAgc2VydmljZVRvVXNlOiBVc2VVaUFjdGlvbjtcbiAgICBleGNlcHRpb24/OiBib29sZWFuO1xuICAgIGRlc2NyaXB0b3I/OiBVaUFjdGlvbkRlc2NyaXB0b3I7XG4gICAgY3NzQ2xhc3M/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVXNlVWlBY3Rpb24ge1xuICAgIHN1Ym1pdDogU3ViamVjdDx2b2lkPjtcbiAgICByZVN1YnNjcmliZVRvQ2hhbmdlOiBTdWJqZWN0PHZvaWQ+O1xuICAgIGdldEFkZGl0aW9uYWxQYXJhbXModWlBY3Rpb246IFVpQWN0aW9uKTogVWlBY3Rpb25BZGRpdGlvbmFsUGFyYW1zO1xuICAgIGdldE1vZGVsKCk6IGFueTtcbiAgICBwZXJmb3JtVWlBY3Rpb25SZXF1ZXN0KHVpQWN0aW9uUmVxdWVzdDogVWlBY3Rpb25SZXF1ZXN0KTogUHJvbWlzZTxhbnk+O1xuICAgIGhhbmRsZVNwZWNpZmljRGVtYW5kc0FzeW5jaHJvbm91c2x5KFxuICAgICAgICB1aUFjdGlvbjogVWlBY3Rpb24sXG4gICAgICAgIHVpQWN0aW9uUmVxdWVzdDogVWlBY3Rpb25SZXF1ZXN0XG4gICAgKTogUHJvbWlzZTxVaUFjdGlvblNwZWNpZmljRGVtYW5kUmVzcG9uc2U+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVpQWN0aW9uU3BlY2lmaWNEZW1hbmRSZXNwb25zZSB7XG4gICAgc2hvdWxkUGVyZm9ybUFjdGlvbjogYm9vbGVhbjtcbiAgICB1aUFjdGlvblJlcXVlc3Q/OiBVaUFjdGlvblJlcXVlc3Q7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVWlBY3Rpb25BZGRpdGlvbmFsUGFyYW1zIHtcbiAgICBmb3JUZXh0RmllbGQ/OiBzdHJpbmc7XG4gICAgZm9yVGV4dEFyZWE/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBlbnVtIFVpQWN0aW9uRGlhbG9nVHlwZSB7XG4gICAgaW5wdXREaWFsb2cgPSBcImlucHV0RGlhbG9nXCIsXG4gICAgY29uZmlybURpYWxvZyA9IFwiY29uZmlybURpYWxvZ1wiLFxuICAgIGRpYWxvZyA9IFwiZGlhbG9nXCIsXG59XG4iXX0=

package/esm2020/lib/view-context/smart-ui-action/ui-action.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { UiActionFeedbackType, UiActionInputType } from "../api";
+import { SuccessSnackBarComponent } from "./components/success-snack-bar/success-snack-bar.component";
+import * as i0 from "@angular/core";
+import * as i1 from "./dialogs/ui-action-confirm-dialog/ui-action-confirm-dialog.service";
+import * as i2 from "./dialogs/ui-action-input-dialog/ui-action-input-dialog.service";
+import * as i3 from "@angular/material/snack-bar";
+export class UiActionService {
+    constructor(confirmDialogService, textFieldDialogService, _snackBar) {
+        this.confirmDialogService = confirmDialogService;
+        this.textFieldDialogService = textFieldDialogService;
+        this._snackBar = _snackBar;
+    }
+    async execute(uiAction) {
+        let uiActionRequest;
+        uiActionRequest = {
+            code: uiAction.code,
+            identifier: uiAction.identifier,
+            params: uiAction.params ?? {},
+        };
+        if (uiAction.submit) {
+            this.uiActionModel.serviceToUse.submit.next();
+            try {
+                await this.uiActionModel.serviceToUse.submit.toPromise();
+                this.uiActionModel.serviceToUse.submit = new Subject();
+                this.uiActionModel.serviceToUse.reSubscribeToChange.next();
+            }
+            catch (error) {
+                console.error(error);
+                this.uiActionModel.serviceToUse.submit = new Subject();
+                this.uiActionModel.serviceToUse.reSubscribeToChange.next();
+                return;
+            }
+        }
+        if (uiAction.confirm) {
+            this.confirmDialogService.action = uiAction;
+            this.confirmDialogService.openDialog();
+            await this.confirmDialogService.onAction.toPromise();
+            if (!this.confirmDialogService.shouldDoAction) {
+                return;
+            }
+        }
+        // InputType
+        if (uiAction.inputType) {
+            uiActionRequest = await this.handleInputType(uiAction.inputType, uiAction, uiActionRequest, "inputDialog");
+            if (!uiActionRequest) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        // Input2Type
+        if (uiAction.input2Type) {
+            uiActionRequest = await this.handleInputType(uiAction.input2Type, uiAction, uiActionRequest, "input2Dialog");
+            if (!uiActionRequest) {
+                return;
+            }
+        }
+        if (this.uiActionModel.exception) {
+            let response = await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(uiAction, uiActionRequest);
+            if (!response.shouldPerformAction || !response.uiActionRequest) {
+                return;
+            }
+            uiActionRequest = response.uiActionRequest;
+        }
+        this.performAction(uiAction, uiActionRequest);
+    }
+    async handleInputType(inputType, uiAction, uiActionRequest, inputTypeName) {
+        switch (inputType) {
+            case UiActionInputType.None:
+                return uiActionRequest;
+            case UiActionInputType.Textarea:
+            case UiActionInputType.Textfield:
+                return await this.handleInputTypeTextField(inputTypeName, uiAction, uiActionRequest);
+            case UiActionInputType.UserSelect:
+                return await this.handleInputTypeUserSelect(inputTypeName, uiAction, uiActionRequest);
+            default:
+                return uiActionRequest;
+        }
+    }
+    async handleInputTypeTextField(inputTypeName, uiAction, uiActionRequest) {
+        let additionalParams = this.uiActionModel.serviceToUse.getAdditionalParams(uiAction);
+        let inputType = inputTypeName === "inputDialog" ? "inputType" : "input2Type";
+        if (uiAction[inputType] === UiActionInputType.Textfield) {
+            this.textFieldDialogService.nodeName = additionalParams.forTextField;
+        }
+        else if (uiAction[inputType] === UiActionInputType.Textarea) {
+            this.textFieldDialogService.nodeName = additionalParams.forTextArea;
+        }
+        this.textFieldDialogService.inputTypeName = inputTypeName;
+        this.textFieldDialogService.action = uiAction;
+        this.textFieldDialogService.openDialog();
+        await this.textFieldDialogService.onAction.toPromise();
+        let params = this.textFieldDialogService.params;
+        if (!params) {
+            console.error("There was no response from InputDialog");
+            return;
+        }
+        uiActionRequest.params = {
+            ...uiActionRequest.params,
+            ...params,
+        };
+        return uiActionRequest;
+    }
+    async handleInputTypeUserSelect(inputTypeName, uiAction, uiActionRequest) {
+        let response = await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(uiAction, uiActionRequest);
+        if (!response.shouldPerformAction || !response.uiActionRequest) {
+            return;
+        }
+        uiActionRequest = response.uiActionRequest;
+        return uiActionRequest;
+    }
+    async performAction(uiAction, uiActionRequest) {
+        if (!uiActionRequest.params ||
+            (uiActionRequest.params && !Object.keys(uiActionRequest.params).length)) {
+            uiActionRequest.params = {
+                model: this.uiActionModel.serviceToUse.getModel(),
+            };
+        }
+        else if (uiAction.submit) {
+            uiActionRequest.params["model"] = this.uiActionModel.serviceToUse.getModel();
+        }
+        try {
+            await this.uiActionModel.serviceToUse.performUiActionRequest(uiActionRequest);
+            if (this.uiActionModel.descriptor?.feedbackType === UiActionFeedbackType.Snackbar) {
+                this.showSavedSnackbar(uiAction);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    showSavedSnackbar(uiAction) {
+        this._snackBar.openFromComponent(SuccessSnackBarComponent, {
+            duration: 5 * 1000,
+            panelClass: ["backgroundColor-accent"],
+            data: uiAction,
+        });
+    }
+}
+UiActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, deps: [{ token: i1.UiActionConfirmDialogService }, { token: i2.UiActionInputDialogService }, { token: i3.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UiActionConfirmDialogService }, { type: i2.UiActionInputDialogService }, { type: i3.MatSnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-action.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/view-context/smart-ui-action/ui-action.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { MatSnackBar } from \"@angular/material/snack-bar\";\n\nimport { Subject } from \"rxjs\";\nimport { UiAction, UiActionFeedbackType, UiActionInputType, UiActionRequest } from \"../api\";\nimport { SuccessSnackBarComponent } from \"./components/success-snack-bar/success-snack-bar.component\";\n\nimport { UiActionInputDialogService } from \"./dialogs/ui-action-input-dialog/ui-action-input-dialog.service\";\nimport { UiActionConfirmDialogService } from \"./dialogs/ui-action-confirm-dialog/ui-action-confirm-dialog.service\";\nimport { UiActionModel } from \"./ui-action.model\";\nimport { L } from \"@angular/cdk/keycodes\";\n\n@Injectable({\n    providedIn: \"root\",\n})\nexport class UiActionService {\n    uiActionModel!: UiActionModel;\n\n    constructor(\n        private confirmDialogService: UiActionConfirmDialogService,\n        private textFieldDialogService: UiActionInputDialogService,\n        private _snackBar: MatSnackBar\n    ) {}\n\n    async execute(uiAction: UiAction): Promise<void> {\n        let uiActionRequest: UiActionRequest | undefined;\n\n        uiActionRequest = {\n            code: uiAction.code!,\n            identifier: uiAction.identifier,\n            params: uiAction.params ?? {},\n        };\n\n        if (uiAction.submit) {\n            this.uiActionModel.serviceToUse.submit.next();\n            try {\n                await this.uiActionModel.serviceToUse.submit.toPromise();\n                this.uiActionModel.serviceToUse.submit = new Subject();\n                this.uiActionModel.serviceToUse.reSubscribeToChange.next();\n            } catch (error: any) {\n                console.error(error);\n                this.uiActionModel.serviceToUse.submit = new Subject();\n                this.uiActionModel.serviceToUse.reSubscribeToChange.next();\n                return;\n            }\n        }\n\n        if (uiAction.confirm) {\n            this.confirmDialogService.action = uiAction;\n            this.confirmDialogService.openDialog();\n            await this.confirmDialogService.onAction.toPromise();\n            if (!this.confirmDialogService.shouldDoAction) {\n                return;\n            }\n        }\n\n        // InputType\n        if (uiAction.inputType) {\n            uiActionRequest = await this.handleInputType(\n                uiAction.inputType,\n                uiAction,\n                uiActionRequest,\n                \"inputDialog\"\n            );\n            if (!uiActionRequest) {\n                return;\n            }\n            await new Promise((resolve) => setTimeout(resolve, 250));\n        }\n        // Input2Type\n        if (uiAction.input2Type) {\n            uiActionRequest = await this.handleInputType(\n                uiAction.input2Type,\n                uiAction,\n                uiActionRequest,\n                \"input2Dialog\"\n            );\n            if (!uiActionRequest) {\n                return;\n            }\n        }\n\n        if (this.uiActionModel.exception) {\n            let response =\n                await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(\n                    uiAction,\n                    uiActionRequest\n                );\n\n            if (!response.shouldPerformAction || !response.uiActionRequest) {\n                return;\n            }\n            uiActionRequest = response.uiActionRequest;\n        }\n\n        this.performAction(uiAction, uiActionRequest);\n    }\n\n    private async handleInputType(\n        inputType: UiActionInputType,\n        uiAction: UiAction,\n        uiActionRequest: UiActionRequest,\n        inputTypeName: \"inputDialog\" | \"input2Dialog\"\n    ): Promise<UiActionRequest | undefined> {\n        switch (inputType) {\n            case UiActionInputType.None:\n                return uiActionRequest;\n            case UiActionInputType.Textarea:\n            case UiActionInputType.Textfield:\n                return await this.handleInputTypeTextField(\n                    inputTypeName,\n                    uiAction,\n                    uiActionRequest\n                );\n            case UiActionInputType.UserSelect:\n                return await this.handleInputTypeUserSelect(\n                    inputTypeName,\n                    uiAction,\n                    uiActionRequest\n                );\n            default:\n                return uiActionRequest;\n        }\n    }\n\n    private async handleInputTypeTextField(\n        inputTypeName: \"inputDialog\" | \"input2Dialog\",\n        uiAction: UiAction,\n        uiActionRequest: UiActionRequest\n    ): Promise<UiActionRequest | undefined> {\n        let additionalParams = this.uiActionModel.serviceToUse.getAdditionalParams(uiAction);\n        let inputType: \"inputType\" | \"input2Type\" =\n            inputTypeName === \"inputDialog\" ? \"inputType\" : \"input2Type\";\n\n        if (uiAction[inputType] === UiActionInputType.Textfield) {\n            this.textFieldDialogService.nodeName = additionalParams.forTextField;\n        } else if (uiAction[inputType] === UiActionInputType.Textarea) {\n            this.textFieldDialogService.nodeName = additionalParams.forTextArea;\n        }\n\n        this.textFieldDialogService.inputTypeName = inputTypeName;\n        this.textFieldDialogService.action = uiAction;\n\n        this.textFieldDialogService.openDialog();\n\n        await this.textFieldDialogService.onAction.toPromise();\n        let params = this.textFieldDialogService.params;\n\n        if (!params) {\n            console.error(\"There was no response from InputDialog\");\n            return;\n        }\n        uiActionRequest.params = {\n            ...uiActionRequest.params,\n            ...params,\n        };\n        return uiActionRequest;\n    }\n\n    private async handleInputTypeUserSelect(\n        inputTypeName: \"inputDialog\" | \"input2Dialog\",\n        uiAction: UiAction,\n        uiActionRequest: UiActionRequest\n    ): Promise<UiActionRequest | undefined> {\n        let response = await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(\n            uiAction,\n            uiActionRequest\n        );\n\n        if (!response.shouldPerformAction || !response.uiActionRequest) {\n            return;\n        }\n        uiActionRequest = response.uiActionRequest;\n        return uiActionRequest;\n    }\n\n    private async performAction(\n        uiAction: UiAction,\n        uiActionRequest: UiActionRequest\n    ): Promise<void> {\n        if (\n            !uiActionRequest.params ||\n            (uiActionRequest.params && !Object.keys(uiActionRequest.params).length)\n        ) {\n            uiActionRequest.params = {\n                model: this.uiActionModel.serviceToUse.getModel(),\n            };\n        } else if (uiAction.submit) {\n            uiActionRequest.params[\"model\"] = this.uiActionModel.serviceToUse.getModel();\n        }\n\n        try {\n            await this.uiActionModel.serviceToUse.performUiActionRequest(uiActionRequest);\n\n            if (this.uiActionModel.descriptor?.feedbackType === UiActionFeedbackType.Snackbar) {\n                this.showSavedSnackbar(uiAction);\n            }\n        } catch (error: any) {\n            console.error(error);\n        }\n    }\n\n    showSavedSnackbar(uiAction: UiAction): void {\n        this._snackBar.openFromComponent(SuccessSnackBarComponent, {\n            duration: 5 * 1000,\n            panelClass: [\"backgroundColor-accent\"],\n            data: uiAction,\n        });\n    }\n}\n"]}

package/esm2020/lib/view-context/smart-view-context-error-dialog/smart-view-context-error-dialog.component.mjs

@@ -0,0 +1,24 @@
+import { Component } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-view-context-error-dialog.service";
+import * as i2 from "@angular/material/button";
+export class SmartViewContextErrorDialogComponent {
+    constructor(service) {
+        this.service = service;
+        this.smartViewContextApiError = this.service.getSmartViewContextApiError();
+    }
+    ngOnInit() { }
+    onActionClick() {
+        if (this.smartViewContextApiError.customAction) {
+            this.smartViewContextApiError.customAction();
+        }
+        this.service.closeDialog();
+    }
+}
+SmartViewContextErrorDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogComponent, deps: [{ token: i1.SmartViewContextErrorDialogService }], target: i0.ɵɵFactoryTarget.Component });
+SmartViewContextErrorDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartViewContextErrorDialogComponent, selector: "lib-smart-view-context-error-dialog", ngImport: i0, template: "<div class=\"container\">\n    <h3 class=\"color-accent-700\">\n        {{ smartViewContextApiError.dialogTitle }}\n    </h3>\n    <div class=\"content\">\n        <p>\n            {{ smartViewContextApiError.message }}\n        </p>\n    </div>\n    <div class=\"buttonContainer\">\n        <button mat-raised-button color=\"primary\" (click)=\"onActionClick()\">\n            {{ smartViewContextApiError.buttonLabel }}\n        </button>\n    </div>\n</div>\n", styles: [".container{display:flex;flex-direction:column;gap:1em;min-width:25rem;max-width:50vw;height:auto;max-height:75vh}.content{flex:1;overflow:auto}.buttonContainer{display:flex;flex-direction:row;justify-content:flex-end}\n"], components: [{ type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "lib-smart-view-context-error-dialog", template: "<div class=\"container\">\n    <h3 class=\"color-accent-700\">\n        {{ smartViewContextApiError.dialogTitle }}\n    </h3>\n    <div class=\"content\">\n        <p>\n            {{ smartViewContextApiError.message }}\n        </p>\n    </div>\n    <div class=\"buttonContainer\">\n        <button mat-raised-button color=\"primary\" (click)=\"onActionClick()\">\n            {{ smartViewContextApiError.buttonLabel }}\n        </button>\n    </div>\n</div>\n", styles: [".container{display:flex;flex-direction:column;gap:1em;min-width:25rem;max-width:50vw;height:auto;max-height:75vh}.content{flex:1;overflow:auto}.buttonContainer{display:flex;flex-direction:row;justify-content:flex-end}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.SmartViewContextErrorDialogService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/view-context/smart-view-context-error-dialog/smart-view-context-error-dialog.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from "@angular/core";
+import { SmartdialogService } from "@smartbit4all/dialog";
+import { SmartViewContextErrorDialogComponent } from "./smart-view-context-error-dialog.component";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/router";
+import * as i3 from "../smart-view-context.service";
+export class SmartViewContextErrorDialogService extends SmartdialogService {
+    constructor(dialog, router, viewContext) {
+        super(dialog, router);
+        this.viewContext = viewContext;
+    }
+    handleAfterClosed(result) { }
+    openDialog() {
+        const dialogData = {
+            content: {
+                title: "",
+            },
+            size: {},
+            customComponent: SmartViewContextErrorDialogComponent,
+        };
+        this.createDialog(dialogData, SmartViewContextErrorDialogComponent);
+    }
+    getSmartViewContextApiError() {
+        if (this.viewApiError?.code) {
+            return this.viewContext.getSmartViewContextApiErrorByCode(this.viewApiError.code);
+        }
+        return {
+            code: this.viewApiError?.code ?? "",
+            message: this.viewApiError?.message ?? "An error has occured",
+            buttonLabel: "Ok",
+            dialogTitle: "Hiba",
+        };
+    }
+}
+SmartViewContextErrorDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, deps: [{ token: i1.MatDialog }, { token: i2.Router }, { token: i3.SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartViewContextErrorDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.Router }, { type: i3.SmartViewContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/view-context/smart-view-context.interceptor.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from "@angular/core";
+import { catchError, throwError } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-view-context-error-dialog/smart-view-context-error-dialog.service";
+export class SmartViewContextInterceptor {
+    constructor(viewContextErrorDialog) {
+        this.viewContextErrorDialog = viewContextErrorDialog;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status === 409 &&
+                (error.error.code || error.error.message)) {
+                this.openErrorDialog(error.error);
+            }
+            return throwError(error);
+        }));
+    }
+    openErrorDialog(viewApiError) {
+        this.viewContextErrorDialog.viewApiError = viewApiError;
+        this.viewContextErrorDialog.openDialog();
+    }
+}
+SmartViewContextInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor, deps: [{ token: i1.SmartViewContextErrorDialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartViewContextInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SmartViewContextErrorDialogService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/view-context/smart-view-context.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtdmlldy1jb250ZXh0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvdmlldy1jb250ZXh0L3NtYXJ0LXZpZXctY29udGV4dC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50VHlwZSB9IGZyb20gXCJAYW5ndWxhci9jZGsvcG9ydGFsXCI7XG5pbXBvcnQgeyBFdmVudEVtaXR0ZXIgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgTWF0RGlhbG9nUmVmIH0gZnJvbSBcIkBhbmd1bGFyL21hdGVyaWFsL2RpYWxvZ1wiO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU21hcnRWaWV3SGFuZGxlck1vZGVsIHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgcm91dGU/OiBzdHJpbmc7XG4gICAgY29tcG9uZW50PzogQ29tcG9uZW50VHlwZTxhbnk+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNtYXJ0Vmlld0NvbnRleHRBcGlFcnJvciB7XG4gICAgY29kZTogc3RyaW5nO1xuICAgIGRpYWxvZ1RpdGxlPzogc3RyaW5nO1xuICAgIG1lc3NhZ2U6IHN0cmluZztcbiAgICBidXR0b25MYWJlbD86IHN0cmluZztcbiAgICBjdXN0b21BY3Rpb24/OiAoKSA9PiB2b2lkO1xufVxuZXhwb3J0IGludGVyZmFjZSBTbWFydFZpZXdDb250ZXh0QXBpRXJyb3JzIHtcbiAgICB2aWV3Q29udGV4dEFwaUVycm9yczogQXJyYXk8U21hcnRWaWV3Q29udGV4dEFwaUVycm9yPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTbWFydFZpZXdEaWFsb2dSZWYge1xuICAgIHV1aWQ6IHN0cmluZztcbiAgICBkaWFsb2dSZWY6IE1hdERpYWxvZ1JlZjxhbnksIGFueT47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU21hcnRUcmFuc2xhdGVTZXJ2aWNlIHtcbiAgICBnZXQoa2V5OiBzdHJpbmcgfCBBcnJheTxzdHJpbmc+LCBpbnRlcnBvbGF0ZVBhcmFtcz86IE9iamVjdCk6IE9ic2VydmFibGU8c3RyaW5nIHwgYW55PjtcbiAgICBnZXQgb25MYW5nQ2hhbmdlKCk6IEV2ZW50RW1pdHRlcjxhbnk+O1xuICAgIGdldCBjdXJyZW50TGFuZygpOiBzdHJpbmc7XG4gICAgc2V0IGN1cnJlbnRMYW5nKGN1cnJlbnRMYW5nOiBzdHJpbmcpO1xuICAgIGluc3RhbnQoa2V5OiBzdHJpbmcgfCBBcnJheTxzdHJpbmc+LCBpbnRlcnBvbGF0ZVBhcmFtcz86IE9iamVjdCk6IHN0cmluZyB8IGFueTtcbn1cbiJdfQ==

package/esm2020/lib/view-context/smart-view-context.module.mjs

@@ -0,0 +1,84 @@
+import { CommonModule } from "@angular/common";
+import { HttpClientModule, HTTP_INTERCEPTORS } from "@angular/common/http";
+import { NgModule } from "@angular/core";
+import { MatButtonModule } from "@angular/material/button";
+import { MatCommonModule } from "@angular/material/core";
+import { MatIconModule } from "@angular/material/icon";
+import { MessageDialogComponent } from "./message-dialog/message-dialog.component";
+import { SmartViewContextService } from "./smart-view-context.service";
+import { SmartViewContextErrorDialogComponent } from "./smart-view-context-error-dialog/smart-view-context-error-dialog.component";
+import { SmartViewContextInterceptor } from "./smart-view-context.interceptor";
+import { SmartViewRedirect } from "./smart-view-redirect/smart-view-redirect";
+import { SmartIconModule } from "@smartbit4all/icon";
+import { UiActionToolbarComponent } from "./smart-ui-action/ui-action-toolbar.component";
+import { UiActionInputDialogComponent } from "./smart-ui-action/dialogs/ui-action-input-dialog/ui-action-input-dialog.component";
+import { UiActionConfirmDialogComponent } from "./smart-ui-action/dialogs/ui-action-confirm-dialog/ui-action-confirm-dialog.component";
+import { SmartformModule } from "@smartbit4all/form";
+import { MatSnackBarModule } from "@angular/material/snack-bar";
+import * as i0 from "@angular/core";
+export class SmartViewContextModule {
+}
+SmartViewContextModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartViewContextModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, declarations: [MessageDialogComponent,
+        SmartViewContextErrorDialogComponent,
+        SmartViewRedirect,
+        UiActionToolbarComponent,
+        UiActionInputDialogComponent,
+        UiActionConfirmDialogComponent], imports: [CommonModule,
+        HttpClientModule,
+        MatCommonModule,
+        MatButtonModule,
+        MatIconModule,
+        MatSnackBarModule,
+        SmartIconModule,
+        SmartformModule], exports: [UiActionToolbarComponent, UiActionInputDialogComponent] });
+SmartViewContextModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, providers: [
+        SmartViewContextService,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartViewContextInterceptor,
+            multi: true,
+        },
+    ], imports: [[
+            CommonModule,
+            HttpClientModule,
+            MatCommonModule,
+            MatButtonModule,
+            MatIconModule,
+            MatSnackBarModule,
+            SmartIconModule,
+            SmartformModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MessageDialogComponent,
+                        SmartViewContextErrorDialogComponent,
+                        SmartViewRedirect,
+                        UiActionToolbarComponent,
+                        UiActionInputDialogComponent,
+                        UiActionConfirmDialogComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        MatCommonModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatSnackBarModule,
+                        SmartIconModule,
+                        SmartformModule,
+                    ],
+                    exports: [UiActionToolbarComponent, UiActionInputDialogComponent],
+                    providers: [
+                        SmartViewContextService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartViewContextInterceptor,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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