@pepperi-addons/ngx-composite-lib 0.4.2-beta.8 → 0.4.2-beta.81

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

@@ -0,0 +1,153 @@
+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 {
+    constructor(translate, dataViewService, dialogService) {
+        this.translate = translate;
+        this.dataViewService = dataViewService;
+        this.dialogService = dialogService;
+        this.showType = false;
+        this.showAccessibility = false;
+        // If columns are not defined, the default columns will be used (default is with no Internal - Accessibility).
+        this.parametersColumns = [];
+        this.parameters = [];
+        this.parametersTitle = '';
+        this.parametersChange = new EventEmitter();
+        this.listMessages = {};
+        this.actions = {
+            get: async (data) => {
+                const actions = [];
+                if (data && data.rows.length == 1) {
+                    actions.push({
+                        title: this.translate.instant('Edit'),
+                        handler: async (objs) => {
+                            this.openCreateParamForm('edit', objs.rows[0]);
+                        }
+                    });
+                    actions.push({
+                        title: this.translate.instant('Delete'),
+                        handler: async (objs) => {
+                            this.showDeleteDialog(objs.rows[0]);
+                        }
+                    });
+                }
+                return actions;
+            }
+        };
+    }
+    notifyParametersChange() {
+        this.parametersChange.emit(this.parameters);
+        this.dataSource = this.getDataSource();
+    }
+    getDataSource() {
+        return {
+            init: async (params) => {
+                const listDataView = this.dataViewService.getParametersListDataView(this.parametersColumns, this.showType, this.showAccessibility);
+                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;
+        }
+        const parameter = { ...defaultParam, ...paramItem };
+        const formData = {
+            Parameter: parameter,
+            Mode: formMode,
+            ShowType: this.showType,
+            ShowAccessibility: this.showAccessibility
+        };
+        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();
+                }
+            }
+        });
+    }
+}
+ManageParametersComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ManageParametersComponent, deps: [{ token: i1.TranslateService }, { token: i2.ManageParametersService }, { token: i3.PepDialogService }], target: i0.ɵɵFactoryTarget.Component });
+ManageParametersComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.2", type: ManageParametersComponent, selector: "pep-manage-parameters", inputs: { showType: "showType", showAccessibility: "showAccessibility", parametersColumns: "parametersColumns", parameters: "parameters", parametersTitle: "parametersTitle" }, 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]=\"true\"\n    [actions]=\"actions\"\n    [addPadding]=\"false\"\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", "description", "inline", "showSearch", "noDataFoundMsg", "emptyState", "selectionType", "supportSorting", "supportSortingFields", "separator", "sorting", "cacheSize", "hideSelectAll", "pager", "tableViewType", "zebraStripes", "smartFilter", "showTopBar", "breadCrumbsItems", "selectAll", "scrollPosition"], outputs: ["fieldClick", "valueChange", "breadCrumbItemClick", "startIndexChange", "listLoad"] }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", 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]=\"true\"\n    [actions]=\"actions\"\n    [addPadding]=\"false\"\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
+            }], parametersColumns: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }], parametersTitle: [{
+                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()\n    showType = false;\n\n    @Input()\n    showAccessibility = false;\n\n    // If columns are not defined, the default columns will be used (default is with no Internal - Accessibility).\n    @Input()\n    parametersColumns: IParametersColumn[] = [];\n\n    @Input()\n    parameters: IParamemeter[] = [];\n\n    @Input()\n    parametersTitle = '';\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                actions.push({\n                    title: this.translate.instant('Edit'),\n                    handler: async (objs: any) => {\n                        this.openCreateParamForm('edit', objs.rows[0]);\n                    }\n                });\n                actions.push({\n                    title: this.translate.instant('Delete'),\n                    handler: async (objs: any) => {\n                        this.showDeleteDialog(objs.rows[0]);\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() {\n        this.parametersChange.emit(this.parameters);\n        this.dataSource = this.getDataSource();\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);\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        const parameter = { ...defaultParam, ...paramItem };\n    \n        const formData: IParameterFormData = {\n            Parameter: parameter,\n            Mode: formMode,\n            ShowType: this.showType,\n            ShowAccessibility: this.showAccessibility\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]=\"true\"\n    [actions]=\"actions\"\n    [addPadding]=\"false\"\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/manage-parameters/manage-parameters.model.mjs

@@ -0,0 +1,24 @@
+// import { AddonDataScheme, FlowParam, FormDataView, NgComponentRelation } from "@pepperi-addons/papi-sdk";
+// import { IAddonBlockLoaderDialogOptions } from "@pepperi-addons/ngx-lib/remote-loader";
+export {};
+// export interface FlowDraggableItem extends IPepDraggableItem {
+//     data: {
+//         key: string;
+//         addonUUID: string;
+//         blockExecutionRelativeURL: string;
+//         moduleName: string;
+//         componentName: string;
+//     }
+// }
+// export interface FlowPickerData {
+//     runFlowData?: FlowObject
+//     fields?: AddonDataScheme['Fields']
+// }
+// export interface PageTitleButton {
+//     Key: string;
+//     Title: string;
+//     StyleType: PepStyleType;
+//     Disabled: boolean
+// }
+// export type PollResultCallback = (status: DebugFlowResult)=> void;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/manage-parameters/manage-parameters.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PepNgxLibModule } from '@pepperi-addons/ngx-lib';
+import { ManageParametersComponent } from './manage-parameters.component';
+import { ManageParameterComponent } from './manage-parameter/manage-parameter.component';
+import { PepDialogModule } from '@pepperi-addons/ngx-lib/dialog';
+import { PepGenericListModule } from '@pepperi-addons/ngx-composite-lib/generic-list';
+import { PepGenericFormModule } from '@pepperi-addons/ngx-composite-lib/generic-form';
+import { PepButtonModule } from '@pepperi-addons/ngx-lib/button';
+import { ManageParametersService } from './manage-parameters.service';
+import * as i0 from "@angular/core";
+export class PepManageParametersModule {
+}
+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: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ManageParametersComponent, ManageParameterComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        PepNgxLibModule,
+                        PepDialogModule,
+                        PepButtonModule,
+                        PepGenericListModule,
+                        PepGenericFormModule
+                    ],
+                    providers: [ManageParametersService],
+                    exports: [ManageParametersComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,142 @@
+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) {
+        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', 'TextBox', 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));
+            }
+            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) {
+        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));
+        }
+        return {
+            Type: 'Form',
+            Fields: fields,
+            Context: {
+                Name: '',
+                Profile: {},
+                ScreenSize: 'Tablet'
+            }
+        };
+    }
+}
+ManageParametersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ManageParametersService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+ManageParametersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ManageParametersService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", 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): 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', 'TextBox', 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            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): 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        return {\n            Type: 'Form',\n            Fields: fields,\n            Context: {\n                Name: '',\n                Profile: { },\n                ScreenSize: 'Tablet'\n            }\n        };\n    }\n}"]}

package/esm2020/manage-parameters/pepperi-addons-ngx-composite-lib-manage-parameters.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVwcGVyaS1hZGRvbnMtbmd4LWNvbXBvc2l0ZS1saWItbWFuYWdlLXBhcmFtZXRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9tYW5hZ2UtcGFyYW1ldGVycy9wZXBwZXJpLWFkZG9ucy1uZ3gtY29tcG9zaXRlLWxpYi1tYW5hZ2UtcGFyYW1ldGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/manage-parameters/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of ngx-composite-lib/manage-parameters
+ */
+export * from './manage-parameters.module';
+export * from './manage-parameters.component';
+// export * from './manage-parameter/manage-parameter.component';
+export * from './manage-parameters.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL21hbmFnZS1wYXJhbWV0ZXJzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsaUVBQWlFO0FBQ2pFLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1jb21wb3NpdGUtbGliL21hbmFnZS1wYXJhbWV0ZXJzXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vbWFuYWdlLXBhcmFtZXRlcnMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbWFuYWdlLXBhcmFtZXRlcnMuY29tcG9uZW50Jztcbi8vIGV4cG9ydCAqIGZyb20gJy4vbWFuYWdlLXBhcmFtZXRlci9tYW5hZ2UtcGFyYW1ldGVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21hbmFnZS1wYXJhbWV0ZXJzLm1vZGVsJztcbiJdfQ==

package/esm2020/rich-text/pepperi-addons-ngx-composite-lib-rich-text.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVwcGVyaS1hZGRvbnMtbmd4LWNvbXBvc2l0ZS1saWItcmljaC10ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWNvbXBvc2l0ZS1saWIvcmljaC10ZXh0L3BlcHBlcmktYWRkb25zLW5neC1jb21wb3NpdGUtbGliLXJpY2gtdGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/rich-text/public-api.mjs

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of ngx-composite-lib/flow-picker-button
+ */
+export * from './rich-text.module';
+export * from './rich-text.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3JpY2gtdGV4dC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY29tcG9zaXRlLWxpYi9mbG93LXBpY2tlci1idXR0b25cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9yaWNoLXRleHQubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vcmljaC10ZXh0LmNvbXBvbmVudCc7XG4iXX0=