@pepperi-addons/ngx-composite-lib 0.4.2-beta.99 → 0.5.0-ng16.2

package/esm2022/manage-parameters/manage-parameter/manage-parameter.component.mjs

@@ -0,0 +1,86 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../manage-parameters.service";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@pepperi-addons/ngx-lib/dialog";
+import * as i5 from "@pepperi-addons/ngx-lib/button";
+import * as i6 from "@pepperi-addons/ngx-composite-lib/generic-form";
+export class ManageParameterComponent {
+    constructor(dialogRef, manageParametersService, translate, incoming) {
+        this.dialogRef = dialogRef;
+        this.manageParametersService = manageParametersService;
+        this.translate = translate;
+        this.incoming = incoming;
+        this.parameter = undefined;
+        this.showType = false;
+        this.showAccessibility = false;
+        this.showPersistency = false;
+        this.readonly = false;
+        this.isValid = true;
+    }
+    loadDataView(paramType) {
+        this.dataView = this.manageParametersService.getParameterFormDataView(this.incoming.Mode, paramType || 'String', this.showType, this.showAccessibility, this.showPersistency);
+    }
+    ngOnInit() {
+        this.parameter = this.getParameter(this.incoming.Parameter);
+        this.showType = this.incoming.ShowType ?? false;
+        this.showAccessibility = this.incoming.ShowAccessibility ?? false;
+        this.showPersistency = this.incoming.ShowPersistency ?? false;
+        this.readonly = this.incoming.Readonly ?? false;
+        this.loadDataView(this.parameter?.Type);
+    }
+    saveParameter() {
+        // before updating the parameter, remove redundant properties
+        if (this.parameter && this.showAccessibility) {
+            delete this.parameter['Accessibility'];
+            delete this.parameter['Accessibility_Description'];
+        }
+        this.close(this.parameter);
+    }
+    close(parameter = undefined) {
+        this.dialogRef.close(parameter || null);
+    }
+    getParameter(parameter) {
+        const ret = JSON.parse(JSON.stringify(parameter));
+        Object.keys(parameter || {}).forEach(prop => {
+            if (typeof (parameter[prop]) != 'boolean') {
+                // if the value is null/undefined, don't copy it
+                if (parameter[prop]) {
+                    ret[prop] = parameter[prop].toString();
+                }
+            }
+            else if (prop === 'Internal' && this.showAccessibility) {
+                ret['Accessibility'] = parameter[prop] ? 'Internal' : 'External';
+            }
+            else {
+                ret[prop] = parameter[prop];
+            }
+        });
+        if (this.showAccessibility) {
+            ret['Accessibility_Description'] = this.translate.instant('MANAGE_PARAMETERS.INTERNAL_DESCRIPTION');
+        }
+        return ret;
+    }
+    onValueChanged(event) {
+        if (event.ApiName === 'Type' && this.showType) {
+            this.loadDataView(event.Value);
+        }
+        else if (event.ApiName === 'Accessibility' && this.showAccessibility) {
+            if (this.parameter) {
+                this.parameter['Internal'] = event.Value === 'Internal';
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParameterComponent, deps: [{ token: i1.MatDialogRef }, { token: i2.ManageParametersService }, { token: i3.TranslateService }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ManageParameterComponent, selector: "manage-parameter", ngImport: i0, template: "<pep-dialog [title]=\"(incoming.Mode === 'edit' ? 'MANAGE_PARAMETERS.EDIT_FORM_TITLE' : 'MANAGE_PARAMETERS.ADD_FORM_TITLE') | translate\">\n    <ng-container pep-dialog-content>\n        <pep-generic-form #addForm [dataSource]=\"parameter\" [dataView]=\"dataView\" [isLocked]=\"readonly\" (formValidationChange)=\"isValid = $event\" (valueChange)=\"onValueChanged($event)\">\n\n        </pep-generic-form>\n    </ng-container>\n    <ng-container pep-dialog-actions>\n        <div class=\"pep-spacing-element-negative\" style=\"display: flex;\">         \n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"'Cancel' | translate\" \n                [styleType]=\"'weak'\" \n                (buttonClick)=\"close()\"\n        ></pep-button>\n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"(incoming.Mode === 'edit' ? 'Update' : 'Save') | translate\"\n                [styleType]=\"'strong'\" \n                (buttonClick)=\"saveParameter()\"\n                [disabled]=\"!isValid\"\n            ></pep-button>\n        </div>\n    </ng-container>\n</pep-dialog>", styles: [":host ::ng-deep .pep-textarea-container textarea{margin-bottom:calc(var(--pep-spacing-lg, 1rem) * -1)!important}\n"], dependencies: [{ kind: "component", type: i4.PepDialogComponent, selector: "pep-dialog", inputs: ["title", "showClose", "showHeader", "showFooter"], outputs: ["close"] }, { kind: "component", type: i5.PepButtonComponent, selector: "pep-button", inputs: ["key", "value", "styleType", "styleStateType", "sizeType", "classNames", "disabled", "iconName", "iconPosition", "visible"], outputs: ["buttonClick"] }, { kind: "component", type: i6.GenericFormComponent, selector: "pep-generic-form", inputs: ["dataSource", "dataView", "isLocked", "inline", "showTopBar", "addPadding"], outputs: ["valueChange", "fieldClick", "formValidationChange"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParameterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'manage-parameter', template: "<pep-dialog [title]=\"(incoming.Mode === 'edit' ? 'MANAGE_PARAMETERS.EDIT_FORM_TITLE' : 'MANAGE_PARAMETERS.ADD_FORM_TITLE') | translate\">\n    <ng-container pep-dialog-content>\n        <pep-generic-form #addForm [dataSource]=\"parameter\" [dataView]=\"dataView\" [isLocked]=\"readonly\" (formValidationChange)=\"isValid = $event\" (valueChange)=\"onValueChanged($event)\">\n\n        </pep-generic-form>\n    </ng-container>\n    <ng-container pep-dialog-actions>\n        <div class=\"pep-spacing-element-negative\" style=\"display: flex;\">         \n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"'Cancel' | translate\" \n                [styleType]=\"'weak'\" \n                (buttonClick)=\"close()\"\n        ></pep-button>\n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"(incoming.Mode === 'edit' ? 'Update' : 'Save') | translate\"\n                [styleType]=\"'strong'\" \n                (buttonClick)=\"saveParameter()\"\n                [disabled]=\"!isValid\"\n            ></pep-button>\n        </div>\n    </ng-container>\n</pep-dialog>", styles: [":host ::ng-deep .pep-textarea-container textarea{margin-bottom:calc(var(--pep-spacing-lg, 1rem) * -1)!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: i2.ManageParametersService }, { type: i3.TranslateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-parameter.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-composite-lib/manage-parameters/manage-parameter/manage-parameter.component.ts","../../../../../projects/ngx-composite-lib/manage-parameters/manage-parameter/manage-parameter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, OnInit, ViewChild } from '@angular/core';\nimport { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';\n\nimport { GenericFormComponent, IPepGenericFormDataView, IPepGenericFormValueChange } from '@pepperi-addons/ngx-composite-lib/generic-form';\nimport { IParamemeter, IParameterFormData } from '../manage-parameters.model';\n\nimport { TranslateService } from '@ngx-translate/core';\nimport { ManageParametersService } from '../manage-parameters.service';\nimport { SchemeFieldType } from '@pepperi-addons/papi-sdk';\n\n@Component({\n    selector: 'manage-parameter',\n    templateUrl: './manage-parameter.component.html',\n    styleUrls: ['./manage-parameter.component.scss']\n})\nexport class ManageParameterComponent implements OnInit {\n\n    // @ViewChild('flowsList', {read: GenericFormComponent}) set genericFormSetter(inForm: GenericFormComponent) {\n    //     if (inForm) {\n    //         this.form = inForm;\n    //     }\n    // };\n    \n    form!: GenericFormComponent;\n    parameter: IParamemeter | undefined = undefined;\n    showType = false;\n    showAccessibility = false;\n    showPersistency = false;\n    dataView!: IPepGenericFormDataView;\n    readonly = false;\n    isValid = true;\n\n    constructor ( private dialogRef: MatDialogRef<ManageParameterComponent>,\n        private manageParametersService: ManageParametersService,\n        private translate: TranslateService,\n        @Inject(MAT_DIALOG_DATA) public incoming: IParameterFormData) {\n\n    }\n\n    private loadDataView(paramType: SchemeFieldType) {\n        this.dataView = this.manageParametersService.getParameterFormDataView(this.incoming.Mode, paramType || 'String', this.showType, this.showAccessibility, this.showPersistency);\n    }\n\n    ngOnInit(): void {\n        this.parameter = this.getParameter(this.incoming.Parameter);\n        this.showType = this.incoming.ShowType ?? false;\n        this.showAccessibility = this.incoming.ShowAccessibility ?? false;\n        this.showPersistency = this.incoming.ShowPersistency ?? false;\n        this.readonly = this.incoming.Readonly ?? false;\n        this.loadDataView(this.parameter?.Type);\n    }\n\n    saveParameter() {\n        // before updating the parameter, remove redundant properties\n        if (this.parameter && this.showAccessibility) {\n            delete this.parameter['Accessibility'];\n            delete this.parameter['Accessibility_Description'];\n        }\n\n        this.close(this.parameter);\n    }\n\n    close(parameter: IParamemeter | undefined = undefined) {\n        this.dialogRef.close(parameter || null);\n    }\n\n    getParameter(parameter: IParamemeter): IParamemeter {\n        const ret: IParamemeter = JSON.parse(JSON.stringify(parameter));\n        Object.keys(parameter || {}).forEach(prop => {\n            if (typeof(parameter[prop]) != 'boolean') {\n                // if the value is null/undefined, don't copy it\n                if (parameter[prop]) {\n                    ret[prop] = parameter[prop].toString();\n                }\n            } else if (prop === 'Internal' && this.showAccessibility) {\n                ret['Accessibility'] = parameter[prop] ? 'Internal' : 'External'\n            } else {\n                ret[prop] = parameter[prop];\n            }\n        });\n        \n        if (this.showAccessibility) {\n            ret['Accessibility_Description'] = this.translate.instant('MANAGE_PARAMETERS.INTERNAL_DESCRIPTION');\n        }\n\n        return ret;\n    }\n\n    onValueChanged(event: IPepGenericFormValueChange) {\n        if (event.ApiName === 'Type' && this.showType) {\n            this.loadDataView(event.Value);\n        } else if (event.ApiName === 'Accessibility' && this.showAccessibility) {\n            if (this.parameter) {\n                this.parameter['Internal'] = event.Value === 'Internal';\n            }\n        }\n    }\n\n}","<pep-dialog [title]=\"(incoming.Mode === 'edit' ? 'MANAGE_PARAMETERS.EDIT_FORM_TITLE' : 'MANAGE_PARAMETERS.ADD_FORM_TITLE') | translate\">\n    <ng-container pep-dialog-content>\n        <pep-generic-form #addForm [dataSource]=\"parameter\" [dataView]=\"dataView\" [isLocked]=\"readonly\" (formValidationChange)=\"isValid = $event\" (valueChange)=\"onValueChanged($event)\">\n\n        </pep-generic-form>\n    </ng-container>\n    <ng-container pep-dialog-actions>\n        <div class=\"pep-spacing-element-negative\" style=\"display: flex;\">         \n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"'Cancel' | translate\" \n                [styleType]=\"'weak'\" \n                (buttonClick)=\"close()\"\n        ></pep-button>\n            <pep-button \n                class=\"pep-spacing-element\"\n                [sizeType]=\"'md'\" \n                [value]=\"(incoming.Mode === 'edit' ? 'Update' : 'Save') | translate\"\n                [styleType]=\"'strong'\" \n                (buttonClick)=\"saveParameter()\"\n                [disabled]=\"!isValid\"\n            ></pep-button>\n        </div>\n    </ng-container>\n</pep-dialog>"]}

package/esm2022/manage-parameters/manage-parameters.component.mjs

@@ -0,0 +1,189 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { PepDialogData } from '@pepperi-addons/ngx-lib/dialog';
+import { ManageParameterComponent } from './manage-parameter/manage-parameter.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "./manage-parameters.service";
+import * as i3 from "@pepperi-addons/ngx-lib/dialog";
+import * as i4 from "@pepperi-addons/ngx-lib/button";
+import * as i5 from "@pepperi-addons/ngx-composite-lib/generic-list";
+export class ManageParametersComponent {
+    set showPersistency(value) {
+        this._showPersistency = value;
+    }
+    get showPersistency() {
+        return this._showPersistency;
+    }
+    set parameters(value) {
+        this._parameters = value || [];
+        this.notifyParametersChange(false);
+    }
+    get parameters() {
+        return this._parameters;
+    }
+    constructor(translate, dataViewService, dialogService) {
+        this.translate = translate;
+        this.dataViewService = dataViewService;
+        this.dialogService = dialogService;
+        this.showType = false;
+        this.showAccessibility = false;
+        this._showPersistency = false;
+        this.inline = true;
+        this.addPadding = false;
+        this.parametersTitle = '';
+        // If columns are not defined, the default columns will be used (default is with no Internal - Accessibility).
+        this.parametersColumns = [];
+        this._parameters = [];
+        this.parametersChange = new EventEmitter();
+        this.listMessages = {};
+        this.actions = {
+            get: async (data) => {
+                const actions = [];
+                if (data && data.rows.length == 1) {
+                    const paramName = data.rows[0];
+                    const readOnly = this.parameters.find(x => x.Key === paramName)?.Readonly ?? false;
+                    actions.push({
+                        title: this.translate.instant('Edit'),
+                        handler: async (objs) => {
+                            this.openCreateParamForm('edit', objs.rows[0]);
+                        }
+                    });
+                    if (!readOnly) {
+                        actions.push({
+                            title: this.translate.instant('Delete'),
+                            handler: async (objs) => {
+                                this.showDeleteDialog(objs.rows[0]);
+                            }
+                        });
+                    }
+                }
+                return actions;
+            }
+        };
+    }
+    notifyParametersChange(raiseEvent = true) {
+        // Sort the parameters by name
+        this._parameters = this.parameters.sort((a, b) => a.Key.localeCompare(b.Key));
+        this.dataSource = this.getDataSource();
+        if (raiseEvent) {
+            this.parametersChange.emit(this.parameters);
+        }
+    }
+    getDataSource() {
+        return {
+            init: async (params) => {
+                const listDataView = this.dataViewService.getParametersListDataView(this.parametersColumns, this.showType, this.showAccessibility, this.showPersistency);
+                console.log('data view:', listDataView);
+                return {
+                    dataView: listDataView,
+                    totalCount: this.parameters.length,
+                    items: this.parameters
+                };
+            },
+            inputs: {
+                pager: {
+                    type: 'scroll'
+                },
+                selectionType: 'single',
+                emptyState: {
+                    show: true,
+                    title: this.listMessages['MANAGE_PARAMETERS.EMPTY_STATE_TITLE'],
+                    description: this.listMessages['MANAGE_PARAMETERS.EMPTY_STATE_DESCRIPTION'],
+                }
+            },
+        };
+    }
+    ngOnInit() {
+        this.translate.get(['MANAGE_PARAMETERS.EMPTY_STATE_TITLE', 'MANAGE_PARAMETERS.EMPTY_STATE_DESCRIPTION']).subscribe(translations => {
+            this.listMessages = translations;
+            this.dataSource = this.getDataSource();
+        });
+    }
+    onFieldClick(event) {
+        this.openCreateParamForm('edit', event.value);
+    }
+    openCreateParamForm(formMode, paramName = '') {
+        const paramItem = this.parameters.find(x => x.Key === paramName);
+        const defaultParam = {
+            DefaultValue: '',
+            Key: '',
+            Type: 'String',
+            Description: ''
+        };
+        // Add Accessibility field only if showAccessibility is true.
+        if (this.showAccessibility) {
+            defaultParam['Internal'] = false;
+        }
+        // Add Persistency field only if showPersistency is true.
+        if (this.showPersistency) {
+            defaultParam['Persistency'] = false;
+        }
+        const parameter = { ...defaultParam, ...paramItem };
+        const formData = {
+            Parameter: parameter,
+            Mode: formMode,
+            ShowType: this.showType,
+            ShowAccessibility: this.showAccessibility,
+            ShowPersistency: this.showPersistency,
+            Readonly: paramItem?.Readonly
+        };
+        const config = this.dialogService.getDialogConfig({}, 'large');
+        config.data = new PepDialogData({
+            content: ManageParameterComponent
+        });
+        this.dialogService.openDialog(ManageParameterComponent, formData, config).afterClosed().subscribe((value) => {
+            if (value) {
+                const index = this.parameters.findIndex(param => param.Key === value.Key);
+                // if the param doesn't exist, push to the end of the array, otherwise edit existing
+                if (index < 0) {
+                    this.parameters.push(value);
+                }
+                else {
+                    this.parameters.splice(index, 1, value);
+                }
+                this.notifyParametersChange();
+            }
+        });
+    }
+    showDeleteDialog(paramName) {
+        const dataMsg = new PepDialogData({
+            title: this.translate.instant('MANAGE_PARAMETERS.DELETE_DIALOG_TITLE', { param_name: paramName }),
+            actionsType: 'cancel-delete',
+            content: this.translate.instant('MANAGE_PARAMETERS.DELETE_DIALOG_CONTENT')
+        });
+        this.dialogService.openDefaultDialog(dataMsg).afterClosed().subscribe(async (isDeletePressed) => {
+            if (isDeletePressed) {
+                const index = this.parameters.findIndex(x => x.Key === paramName);
+                if (index > -1) {
+                    this.parameters.splice(index, 1);
+                    this.notifyParametersChange();
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParametersComponent, deps: [{ token: i1.TranslateService }, { token: i2.ManageParametersService }, { token: i3.PepDialogService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ManageParametersComponent, selector: "pep-manage-parameters", inputs: { showType: "showType", showAccessibility: "showAccessibility", showPersistency: "showPersistency", inline: "inline", addPadding: "addPadding", parametersTitle: "parametersTitle", parametersColumns: "parametersColumns", parameters: "parameters" }, outputs: { parametersChange: "parametersChange" }, ngImport: i0, template: "<pep-generic-list class=\"generic-list\"\n    [title]=\"parametersTitle || ('MANAGE_PARAMETERS.TITLE' | translate)\"\n    [showTopBar]=\"true\" \n    [dataSource]=\"dataSource\" \n    [inline]=\"inline\"\n    [actions]=\"actions\"\n    [addPadding]=\"addPadding\"\n    [uuidMapping]=\"'Key'\"\n    (fieldClick)=\"onFieldClick($event)\"\n    >\n    <ng-container right-buttons>\n        <pep-button \n            class=\"pep-spacing-element\"\n            [sizeType]=\"'sm'\" \n            [value]=\"'MANAGE_PARAMETERS.ADD_BUTTON_TITLE' | translate\"\n            [styleType]=\"'strong'\" \n            (buttonClick)=\"openCreateParamForm('add', '')\"\n        ></pep-button>\n    </ng-container>\n</pep-generic-list>", styles: [":host .generic-list{height:100%}\n"], dependencies: [{ kind: "component", type: i4.PepButtonComponent, selector: "pep-button", inputs: ["key", "value", "styleType", "styleStateType", "sizeType", "classNames", "disabled", "iconName", "iconPosition", "visible"], outputs: ["buttonClick"] }, { kind: "component", type: i5.GenericListComponent, selector: "pep-generic-list", inputs: ["dataSource", "actions", "uuidMapping", "disabled", "addPadding", "title", "sideBarTitle", "description", "inline", "showSearch", "noDataFoundMsg", "emptyState", "selectionType", "supportSorting", "supportSortingFields", "separator", "sorting", "cacheSize", "hideSelectAll", "pager", "tableViewType", "zebraStripes", "smartFilter", "showTopBar", "breadCrumbsItems", "selectAll", "scrollPosition", "unknownCount"], outputs: ["itemClick", "fieldClick", "valueChange", "breadCrumbItemClick", "startIndexChange", "listLoad"] }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParametersComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pep-manage-parameters', template: "<pep-generic-list class=\"generic-list\"\n    [title]=\"parametersTitle || ('MANAGE_PARAMETERS.TITLE' | translate)\"\n    [showTopBar]=\"true\" \n    [dataSource]=\"dataSource\" \n    [inline]=\"inline\"\n    [actions]=\"actions\"\n    [addPadding]=\"addPadding\"\n    [uuidMapping]=\"'Key'\"\n    (fieldClick)=\"onFieldClick($event)\"\n    >\n    <ng-container right-buttons>\n        <pep-button \n            class=\"pep-spacing-element\"\n            [sizeType]=\"'sm'\" \n            [value]=\"'MANAGE_PARAMETERS.ADD_BUTTON_TITLE' | translate\"\n            [styleType]=\"'strong'\" \n            (buttonClick)=\"openCreateParamForm('add', '')\"\n        ></pep-button>\n    </ng-container>\n</pep-generic-list>", styles: [":host .generic-list{height:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.ManageParametersService }, { type: i3.PepDialogService }]; }, propDecorators: { showType: [{
+                type: Input
+            }], showAccessibility: [{
+                type: Input
+            }], showPersistency: [{
+                type: Input
+            }], inline: [{
+                type: Input
+            }], addPadding: [{
+                type: Input
+            }], parametersTitle: [{
+                type: Input
+            }], parametersColumns: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], parametersChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-parameters.component.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/manage-parameters/manage-parameters.component.ts","../../../../projects/ngx-composite-lib/manage-parameters/manage-parameters.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { IPepGenericListActions, IPepGenericListDataSource, IPepGenericListParams } from '@pepperi-addons/ngx-composite-lib/generic-list';\nimport { PepDialogData, PepDialogService } from '@pepperi-addons/ngx-lib/dialog';\nimport { PepSelectionData } from '@pepperi-addons/ngx-lib/list';\nimport { ParameterFormType, IParameterFormData, IParamemeter, IParametersColumn } from './manage-parameters.model';\nimport { ManageParameterComponent } from './manage-parameter/manage-parameter.component';\nimport { IPepFieldClickEvent } from '@pepperi-addons/ngx-lib';\nimport { ManageParametersService } from './manage-parameters.service';\n\n@Component({\n    selector: 'pep-manage-parameters',\n    templateUrl: './manage-parameters.component.html',\n    styleUrls: ['./manage-parameters.component.scss']\n})\nexport class ManageParametersComponent implements OnInit {\n\n    @Input() showType = false;\n    @Input() showAccessibility = false;\n    \n    private _showPersistency = false;\n    @Input()\n    set showPersistency(value: boolean) {\n        this._showPersistency = value;\n    }\n    get showPersistency(): boolean {\n        return this._showPersistency;\n    }\n\n    @Input() inline = true;\n    @Input() addPadding = false;\n    @Input() parametersTitle = '';\n\n    // If columns are not defined, the default columns will be used (default is with no Internal - Accessibility).\n    @Input() parametersColumns: IParametersColumn[] = [];\n\n    private _parameters: IParamemeter[] = [];\n    @Input()\n    set parameters(value: IParamemeter[]) {\n        this._parameters = value || [];\n\n        this.notifyParametersChange(false);\n    }\n    get parameters(): IParamemeter[] {\n        return this._parameters;\n    }\n\n    @Output()\n    parametersChange = new EventEmitter<IParamemeter[]>();\n    \n    dataSource!: IPepGenericListDataSource;\n    listMessages: { [key: string]: string } = {};\n\n    actions: IPepGenericListActions = {\n        get: async (data: PepSelectionData) => {\n            const actions = [];\n            if (data && data.rows.length == 1) {\n                const paramName = data.rows[0];\n                const readOnly = this.parameters.find(x => x.Key === paramName)?.Readonly ?? false;\n                actions.push({\n                    title: this.translate.instant('Edit'),\n                    handler: async (objs: any) => {\n                        this.openCreateParamForm('edit', objs.rows[0]);\n                    }\n                });\n                if (!readOnly) {\n                    actions.push({\n                        title: this.translate.instant('Delete'),\n                        handler: async (objs: any) => {\n                            this.showDeleteDialog(objs.rows[0]);\n                        }\n                    })\n                }\n            }\n            return actions;\n        }\n    }\n\n    constructor (private translate: TranslateService,\n        private dataViewService: ManageParametersService,\n        private dialogService: PepDialogService\n    ) { }\n\n    private notifyParametersChange(raiseEvent = true) {\n        // Sort the parameters by name\n        this._parameters = this.parameters.sort((a, b) => a.Key.localeCompare(b.Key));\n\n        this.dataSource = this.getDataSource();\n        \n        if (raiseEvent) {\n            this.parametersChange.emit(this.parameters);\n        }\n    }\n\n    private getDataSource(): IPepGenericListDataSource {\n        return {\n            init: async (params: IPepGenericListParams) => {\n                const listDataView = this.dataViewService.getParametersListDataView(this.parametersColumns, this.showType, this.showAccessibility, this.showPersistency);\n                console.log('data view:', listDataView);\n                return {\n                    dataView: listDataView,\n                    totalCount: this.parameters.length,\n                    items: this.parameters\n                };\n            },\n            inputs: {\n                pager: {\n                    type: 'scroll'\n                },\n                selectionType: 'single',\n                emptyState: {\n                    show: true,\n                    title: this.listMessages['MANAGE_PARAMETERS.EMPTY_STATE_TITLE'],\n                    description: this.listMessages['MANAGE_PARAMETERS.EMPTY_STATE_DESCRIPTION'],\n                }\n            },\n        } as IPepGenericListDataSource\n    }\n\n    ngOnInit(): void {\n        this.translate.get(['MANAGE_PARAMETERS.EMPTY_STATE_TITLE', 'MANAGE_PARAMETERS.EMPTY_STATE_DESCRIPTION']).subscribe(translations => {\n            this.listMessages = translations;\n            this.dataSource = this.getDataSource();\n        })\n    }\n\n    onFieldClick(event: IPepFieldClickEvent) {\n        this.openCreateParamForm('edit', event.value);\n    }\n\n    openCreateParamForm(formMode: ParameterFormType, paramName = '') {\n        const paramItem = this.parameters.find(x => x.Key === paramName);\n        const defaultParam: IParamemeter = {\n            DefaultValue: '',\n            Key: '',\n            Type: 'String',\n            Description: ''\n        };\n\n        // Add Accessibility field only if showAccessibility is true.\n        if (this.showAccessibility) {\n            defaultParam['Internal'] = false;\n        }\n\n        // Add Persistency field only if showPersistency is true.\n        if (this.showPersistency) {\n            defaultParam['Persistency'] = false;\n        }\n\n        const parameter = { ...defaultParam, ...paramItem };\n\n        const formData: IParameterFormData = {\n            Parameter: parameter,\n            Mode: formMode,\n            ShowType: this.showType,\n            ShowAccessibility: this.showAccessibility,\n            ShowPersistency: this.showPersistency,\n            Readonly: paramItem?.Readonly\n        };\n\n        const config = this.dialogService.getDialogConfig({}, 'large');\n        config.data = new PepDialogData({\n            content: ManageParameterComponent\n        })\n        \n        this.dialogService.openDialog(ManageParameterComponent, formData, config).afterClosed().subscribe((value: IParamemeter) => {\n            if (value) {\n                const index = this.parameters.findIndex(param => param.Key === value.Key);\n                // if the param doesn't exist, push to the end of the array, otherwise edit existing\n                if (index < 0) {\n                    this.parameters.push(value);\n                }\n                else {\n                    this.parameters.splice(index, 1, value);\n                }\n\n                this.notifyParametersChange();\n            }\n        });\n    }\n\n    showDeleteDialog(paramName: string) {\n        const dataMsg = new PepDialogData({\n            title: this.translate.instant('MANAGE_PARAMETERS.DELETE_DIALOG_TITLE', { param_name: paramName }),\n            actionsType: 'cancel-delete',\n            content: this.translate.instant('MANAGE_PARAMETERS.DELETE_DIALOG_CONTENT')\n        });\n\n        this.dialogService.openDefaultDialog(dataMsg).afterClosed().subscribe(async (isDeletePressed) => {\n            if (isDeletePressed) {\n                const index = this.parameters.findIndex(x => x.Key === paramName);\n                if (index > -1) {\n                    this.parameters.splice(index, 1);\n                    this.notifyParametersChange();\n                }\n            }\n        });\n    }\n}\n","<pep-generic-list class=\"generic-list\"\n    [title]=\"parametersTitle || ('MANAGE_PARAMETERS.TITLE' | translate)\"\n    [showTopBar]=\"true\" \n    [dataSource]=\"dataSource\" \n    [inline]=\"inline\"\n    [actions]=\"actions\"\n    [addPadding]=\"addPadding\"\n    [uuidMapping]=\"'Key'\"\n    (fieldClick)=\"onFieldClick($event)\"\n    >\n    <ng-container right-buttons>\n        <pep-button \n            class=\"pep-spacing-element\"\n            [sizeType]=\"'sm'\" \n            [value]=\"'MANAGE_PARAMETERS.ADD_BUTTON_TITLE' | translate\"\n            [styleType]=\"'strong'\" \n            (buttonClick)=\"openCreateParamForm('add', '')\"\n        ></pep-button>\n    </ng-container>\n</pep-generic-list>"]}

package/{esm2020 → esm2022}/manage-parameters/manage-parameters.model.mjs

@@ -21,4 +21,4 @@ export {};
 //     Disabled: boolean
 // }
 // export type PollResultCallback = (status: DebugFlowResult)=> void;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/manage-parameters/manage-parameters.module.mjs

@@ -10,21 +10,21 @@ import { PepButtonModule } from '@pepperi-addons/ngx-lib/button';
 import { ManageParametersService } from './manage-parameters.service';
 import * as i0 from "@angular/core";
 export class PepManageParametersModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepManageParametersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepManageParametersModule, declarations: [ManageParametersComponent, ManageParameterComponent], imports: [CommonModule,
+            PepNgxLibModule,
+            PepDialogModule,
+            PepButtonModule,
+            PepGenericListModule,
+            PepGenericFormModule], exports: [ManageParametersComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepManageParametersModule, providers: [ManageParametersService], imports: [CommonModule,
+            PepNgxLibModule,
+            PepDialogModule,
+            PepButtonModule,
+            PepGenericListModule,
+            PepGenericFormModule] }); }
 }
-PepManageParametersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepManageParametersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-PepManageParametersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.2", ngImport: i0, type: PepManageParametersModule, declarations: [ManageParametersComponent, ManageParameterComponent], imports: [CommonModule,
-        PepNgxLibModule,
-        PepDialogModule,
-        PepButtonModule,
-        PepGenericListModule,
-        PepGenericFormModule], exports: [ManageParametersComponent] });
-PepManageParametersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepManageParametersModule, providers: [ManageParametersService], imports: [CommonModule,
-        PepNgxLibModule,
-        PepDialogModule,
-        PepButtonModule,
-        PepGenericListModule,
-        PepGenericFormModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepManageParametersModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepManageParametersModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -42,4 +42,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImpor
                     exports: [ManageParametersComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/manage-parameters/manage-parameters.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable } from "@angular/core";
+import { SchemeFieldTypes } from "@pepperi-addons/papi-sdk";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class ManageParametersService {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    getAvailableTypes() {
+        const types = SchemeFieldTypes.filter(type => ['Array', 'DateTime', 'Resource', 'ContainedResource', 'DynamicResource', 'ContainedDynamicResource', 'MultipleStringValues'].includes(type) === false);
+        return types.map(type => {
+            return {
+                Key: type,
+                Value: type
+            };
+        });
+    }
+    convertParamsTypeToDVType(paramType) {
+        let res = 'TextBox';
+        switch (paramType) {
+            case 'Bool': {
+                res = 'Boolean';
+                break;
+            }
+            case 'Integer': {
+                res = 'NumberInteger';
+                break;
+            }
+            case 'Double': {
+                res = 'NumberReal';
+                break;
+            }
+        }
+        return res;
+    }
+    getDataViewField(fieldId, type, title, mandatory, readOnly, optionalValues = undefined, additionalProps = undefined, layout = undefined) {
+        const res = {
+            FieldID: fieldId,
+            Type: type,
+            Title: title,
+            Mandatory: mandatory,
+            ReadOnly: readOnly
+        };
+        if (optionalValues) {
+            res['OptionalValues'] = optionalValues;
+        }
+        if (additionalProps) {
+            res['AdditionalProps'] = additionalProps;
+        }
+        if (layout) {
+            res['Layout'] = layout;
+        }
+        return res;
+    }
+    getParametersListDataView(parametersColumns, showType, showAccessibility, showPersistency) {
+        let fields;
+        let columns;
+        // If columns are defined, use them. Otherwise, use the default columns.
+        if (parametersColumns.length > 0) {
+            fields = parametersColumns.map(column => {
+                return this.getDataViewField(column.Key, column.Type, column.Title, false, true, [], {});
+            });
+            columns = parametersColumns.map(column => {
+                return { Width: column.Width };
+            });
+        }
+        else {
+            // Add Key and Description fields.
+            fields = [
+                this.getDataViewField('Key', 'Link', this.translate.instant('MANAGE_PARAMETERS.KEY_TITLE'), false, true),
+                this.getDataViewField('Description', 'TextArea', this.translate.instant('MANAGE_PARAMETERS.DESCRIPTION_TITLE'), false, true),
+            ];
+            // Add Type field only if showType is true.
+            if (showType) {
+                fields.push(this.getDataViewField('Type', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.TYPE_TITLE'), false, true));
+            }
+            // Add DefaultValue field.
+            fields.push(this.getDataViewField('DefaultValue', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.DEFAULT_VALUE_TITLE'), false, true));
+            // Add Internal field.
+            if (showAccessibility) {
+                fields.push(this.getDataViewField('Internal', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.INTERNAL_TITLE'), false, true));
+            }
+            // Add Internal field.
+            if (showPersistency) {
+                fields.push(this.getDataViewField('Persistency', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.PERSISTENCY_TITLE'), false, true));
+            }
+            columns = fields.map(field => {
+                return { Width: 100 / fields.length };
+            });
+        }
+        return {
+            Context: {
+                Name: '',
+                Profile: { InternalID: 0 },
+                ScreenSize: 'Landscape'
+            },
+            Type: 'Grid',
+            Title: '',
+            Fields: fields,
+            Columns: columns,
+            FrozenColumnsCount: 0,
+            MinimumColumnWidth: 0
+        };
+    }
+    getParameterFormDataView(formMode, paramType, showType, showAccessibility, showPersistency) {
+        const fieldTypes = this.getAvailableTypes();
+        const noEmptyOption = { emptyOption: false };
+        // Add Key and Description fields.
+        const fields = [
+            this.getDataViewField('Key', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.KEY_TITLE'), formMode === 'add', formMode != 'add', [], { regex: '^([a-zA-Z0-9-_])*$', regexError: this.translate.instant('MANAGE_PARAMETERS.KEY_REGEX_ERROR') }),
+            this.getDataViewField('Description', 'TextArea', this.translate.instant('MANAGE_PARAMETERS.DESCRIPTION_TITLE'), false, false, [], {}, { Size: { Width: 1, Height: 2 } })
+        ];
+        // Add Type field only if showType is true.
+        if (showType) {
+            this.getDataViewField('Type', 'ComboBox', this.translate.instant('MANAGE_PARAMETERS.TYPE_TITLE'), false, formMode != 'add', fieldTypes, noEmptyOption);
+        }
+        // Add DefaultValue field.
+        fields.push(this.getDataViewField('DefaultValue', this.convertParamsTypeToDVType(paramType), this.translate.instant('MANAGE_PARAMETERS.DEFAULT_VALUE_TITLE'), false, false, [], {}));
+        // Add Internal and Accessibility_Description fields.
+        if (showAccessibility) {
+            const accessibilityDescAdditionalProps = { renderTitle: false, renderEnlargeButton: false };
+            const accessibilityDescLayout = { Size: { Height: 0, Width: 1 } };
+            fields.push(this.getDataViewField('Accessibility_Description', 'RichTextHTML', this.translate.instant('MANAGE_PARAMETERS.INTERNAL_DESCRIPTION'), false, true, [], accessibilityDescAdditionalProps, accessibilityDescLayout));
+            const accessibilityOptionalValues = [{ Key: 'Internal', Value: 'Internal' }, { Key: 'External', Value: 'External' }];
+            fields.push(this.getDataViewField('Accessibility', 'ComboBox', this.translate.instant('MANAGE_PARAMETERS.ACCESSIBILITY_TITLE'), false, false, accessibilityOptionalValues, noEmptyOption));
+        }
+        if (showPersistency) {
+            fields.push(this.getDataViewField('Persistency', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.PERSISTENCY_TITLE'), false, false));
+        }
+        return {
+            Type: 'Form',
+            Fields: fields,
+            Context: {
+                Name: '',
+                Profile: {},
+                ScreenSize: 'Tablet'
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParametersService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParametersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ManageParametersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-parameters.service.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/manage-parameters/manage-parameters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { TranslateService } from \"@ngx-translate/core\";\nimport { IPepGenericFormDataView } from \"@pepperi-addons/ngx-composite-lib/generic-form\";\nimport { KeyValuePair } from \"@pepperi-addons/ngx-lib\";\nimport { DataViewFieldType, GridDataView, SchemeFieldType, SchemeFieldTypes } from \"@pepperi-addons/papi-sdk\";\nimport { IParametersColumn, ParameterFormType } from \"./manage-parameters.model\";\n\n@Injectable({\n    providedIn:'root'\n})\nexport class ManageParametersService {\n    \n    constructor (private translate: TranslateService) {\n\n    }\n\n    private getAvailableTypes(): KeyValuePair<string>[] {\n        const types = SchemeFieldTypes.filter(type => ['Array', 'DateTime', 'Resource', 'ContainedResource', 'DynamicResource', 'ContainedDynamicResource', 'MultipleStringValues'].includes(type) === false);\n        return types.map(type => {\n            return {\n                Key: type,\n                Value: type\n            }\n        })\n    }\n\n    private convertParamsTypeToDVType(paramType: SchemeFieldType): DataViewFieldType {\n        let res: DataViewFieldType = 'TextBox';\n        switch (paramType) {\n            case 'Bool': {\n                res = 'Boolean';\n                break;\n            }\n            case 'Integer': {\n                res = 'NumberInteger';\n                break;\n            }\n            case 'Double': {\n                res = 'NumberReal';\n                break;\n            }\n        }\n        return res;\n    }\n\n    private getDataViewField(fieldId: string, type: DataViewFieldType, title: string, mandatory: boolean, readOnly: boolean, \n        optionalValues: any[] | undefined = undefined, additionalProps: any = undefined, layout: any = undefined): any {\n\n        const res: any = {\n            FieldID: fieldId,\n            Type: type,\n            Title: title,\n            Mandatory: mandatory,\n            ReadOnly: readOnly\n        }\n\n        if (optionalValues) {\n            res['OptionalValues'] = optionalValues;\n        }\n\n        if (additionalProps) {\n            res['AdditionalProps'] = additionalProps;\n        }\n\n        if (layout) {\n            res['Layout'] = layout;\n        }\n\n        return res;\n    }\n\n    getParametersListDataView(parametersColumns: IParametersColumn[], showType: boolean, showAccessibility: boolean, showPersistency: boolean): GridDataView {\n        let fields;\n        let columns;\n\n        // If columns are defined, use them. Otherwise, use the default columns.\n        if (parametersColumns.length > 0) {\n            fields = parametersColumns.map(column => {\n                return this.getDataViewField(column.Key, column.Type, column.Title, false, true, [], {});\n            });\n\n            columns = parametersColumns.map(column => {\n                return { Width: column.Width }\n            });\n        } else {\n            // Add Key and Description fields.\n            fields = [\n                this.getDataViewField('Key', 'Link', this.translate.instant('MANAGE_PARAMETERS.KEY_TITLE'), false, true),\n                this.getDataViewField('Description', 'TextArea', this.translate.instant('MANAGE_PARAMETERS.DESCRIPTION_TITLE'), false, true),\n            ];\n\n            // Add Type field only if showType is true.\n            if (showType) {\n                fields.push(this.getDataViewField('Type', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.TYPE_TITLE'), false, true));\n            }\n\n            // Add DefaultValue field.\n            fields.push(this.getDataViewField('DefaultValue', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.DEFAULT_VALUE_TITLE'), false, true));\n\n            // Add Internal field.\n            if (showAccessibility) {\n                fields.push(this.getDataViewField('Internal', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.INTERNAL_TITLE'), false, true));\n            }\n\n            // Add Internal field.\n            if (showPersistency) {\n                fields.push(this.getDataViewField('Persistency', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.PERSISTENCY_TITLE'), false, true));\n            }\n\n            columns = fields.map(field => {\n                return { Width: 100 / fields.length }\n            });\n        }\n\n        return {\n            Context: {\n                Name: '',\n                Profile: { InternalID: 0 },\n                ScreenSize: 'Landscape'\n            },\n            Type: 'Grid',\n            Title: '',\n            Fields: fields,\n            Columns: columns,\n            FrozenColumnsCount: 0,\n            MinimumColumnWidth: 0\n        }\n    }\n\n    getParameterFormDataView(formMode: ParameterFormType, paramType: SchemeFieldType, showType: boolean, showAccessibility: boolean, showPersistency: boolean): IPepGenericFormDataView {\n        const fieldTypes = this.getAvailableTypes();\n        const noEmptyOption = { emptyOption: false };\n\n        // Add Key and Description fields.\n        const fields = [\n            this.getDataViewField('Key', 'TextBox', this.translate.instant('MANAGE_PARAMETERS.KEY_TITLE'), formMode === 'add', formMode != 'add', [], \n                { regex: '^([a-zA-Z0-9-_])*$', regexError: this.translate.instant('MANAGE_PARAMETERS.KEY_REGEX_ERROR')}\n            ),\n            this.getDataViewField('Description', 'TextArea', this.translate.instant('MANAGE_PARAMETERS.DESCRIPTION_TITLE'), false, false, [], {}, \n                { Size: { Width:1, Height:2 } }\n            )\n        ];\n\n        // Add Type field only if showType is true.\n        if (showType) {\n            this.getDataViewField('Type', 'ComboBox', this.translate.instant('MANAGE_PARAMETERS.TYPE_TITLE'), false, formMode != 'add', fieldTypes, noEmptyOption);\n        }\n        \n        // Add DefaultValue field.\n        fields.push(this.getDataViewField('DefaultValue', this.convertParamsTypeToDVType(paramType), this.translate.instant('MANAGE_PARAMETERS.DEFAULT_VALUE_TITLE'), \n            false, false, [], {}))\n            \n        // Add Internal and Accessibility_Description fields.\n        if (showAccessibility) {\n            const accessibilityDescAdditionalProps = { renderTitle: false, renderEnlargeButton: false };\n            const accessibilityDescLayout = { Size: { Height: 0, Width: 1 } };\n\n            fields.push(this.getDataViewField('Accessibility_Description', 'RichTextHTML', this.translate.instant('MANAGE_PARAMETERS.INTERNAL_DESCRIPTION'), \n            false, true, [], accessibilityDescAdditionalProps, accessibilityDescLayout)\n            );\n                \n            const accessibilityOptionalValues = [{ Key: 'Internal', Value: 'Internal' }, { Key: 'External', Value: 'External' }];\n            fields.push(this.getDataViewField('Accessibility', 'ComboBox', this.translate.instant('MANAGE_PARAMETERS.ACCESSIBILITY_TITLE'), \n                false, false, accessibilityOptionalValues, noEmptyOption)\n            );\n        }\n\n        if (showPersistency) {\n            fields.push(this.getDataViewField('Persistency', 'Boolean', this.translate.instant('MANAGE_PARAMETERS.PERSISTENCY_TITLE'), \n                false, false)\n            );\n        }\n\n        return {\n            Type: 'Form',\n            Fields: fields,\n            Context: {\n                Name: '',\n                Profile: { },\n                ScreenSize: 'Tablet'\n            }\n        };\n    }\n}"]}