@eqproject/eqp-dynamic-module 0.0.1

package/esm5/lib/models/fields/textField.model.js

@@ -0,0 +1,12 @@
+import { __extends } from "tslib";
+import { BaseField } from "../baseField.model";
+/**Campo di testo */
+var TextField = /** @class */ (function (_super) {
+    __extends(TextField, _super);
+    function TextField() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return TextField;
+}(BaseField));
+export { TextField };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dEZpZWxkLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGVxcHJvamVjdC9lcXAtZHluYW1pYy1tb2R1bGUvIiwic291cmNlcyI6WyJsaWIvbW9kZWxzL2ZpZWxkcy90ZXh0RmllbGQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUvQyxvQkFBb0I7QUFDcEI7SUFBK0IsNkJBQVM7SUFBeEM7O0lBSUEsQ0FBQztJQUFELGdCQUFDO0FBQUQsQ0FBQyxBQUpELENBQStCLFNBQVMsR0FJdkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlRmllbGQgfSBmcm9tIFwiLi4vYmFzZUZpZWxkLm1vZGVsXCI7XHJcblxyXG4vKipDYW1wbyBkaSB0ZXN0byAqL1xyXG5leHBvcnQgY2xhc3MgVGV4dEZpZWxkIGV4dGVuZHMgQmFzZUZpZWxkIHtcclxuICAgIFRleHRNYXNrOiBzdHJpbmc7XHJcbiAgICBNYXhMZW5naHQ6IG51bWJlcjtcclxuICAgIE1pbkxlbmdodDogbnVtYmVyO1xyXG59Il19

package/esm5/lib/models/form.model.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { BaseObj } from "./baseObj.model";
+/**
+ * Classe che rappresenta una Form completa.
+ * Si tratta dell'oggetto che viene rappresentato a video e con cui l'utente interagisce.
+ */
+var Form = /** @class */ (function (_super) {
+    __extends(Form, _super);
+    function Form() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Form;
+}(BaseObj));
+export { Form };
+var FormFieldGroup = /** @class */ (function () {
+    function FormFieldGroup() {
+    }
+    return FormFieldGroup;
+}());
+export { FormFieldGroup };
+var ActionOnRecord = /** @class */ (function () {
+    function ActionOnRecord() {
+    }
+    return ActionOnRecord;
+}());
+export { ActionOnRecord };
+export var FormTypeEnum;
+(function (FormTypeEnum) {
+    FormTypeEnum[FormTypeEnum["SCALAR"] = 1] = "SCALAR";
+    FormTypeEnum[FormTypeEnum["LIST"] = 2] = "LIST"; /* form di tipo lista che viene rappresentata con molti record */
+})(FormTypeEnum || (FormTypeEnum = {}));
+export var FormScalarTypeEnum;
+(function (FormScalarTypeEnum) {
+    FormScalarTypeEnum[FormScalarTypeEnum["Semplice"] = 1] = "Semplice";
+    FormScalarTypeEnum[FormScalarTypeEnum["A step"] = 2] = "A step";
+    FormScalarTypeEnum[FormScalarTypeEnum["In tab"] = 3] = "In tab";
+    FormScalarTypeEnum[FormScalarTypeEnum["In accordion"] = 4] = "In accordion"; //GROUPED_BY_ACCORDION
+})(FormScalarTypeEnum || (FormScalarTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/models/record.model.js

@@ -0,0 +1,7 @@
+var Record = /** @class */ (function () {
+    function Record() {
+    }
+    return Record;
+}());
+export { Record };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb3JkLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGVxcHJvamVjdC9lcXAtZHluYW1pYy1tb2R1bGUvIiwic291cmNlcyI6WyJsaWIvbW9kZWxzL3JlY29yZC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtJQUFBO0lBSUEsQ0FBQztJQUFELGFBQUM7QUFBRCxDQUFDLEFBSkQsSUFJQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBSZWNvcmQge1xyXG4gICAgSUQ6IHN0cmluZztcclxuICAgIEVudElEOiBzdHJpbmc7XHJcbiAgICBba2V5OiBzdHJpbmddOiBhbnk7XHJcbn1cclxuIl19

package/esm5/lib/modules/material.module.js

@@ -0,0 +1,111 @@
+import { __decorate } from "tslib";
+import { NgModule } from '@angular/core';
+//Angular Material Components
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatButtonModule } from '@angular/material/button';
+import { MatInputModule } from '@angular/material/input';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatListModule } from '@angular/material/list';
+import { MatGridListModule } from '@angular/material/grid-list';
+import { MatCardModule } from '@angular/material/card';
+import { MatStepperModule } from '@angular/material/stepper';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatIconModule } from '@angular/material/icon';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTableModule } from '@angular/material/table';
+import { MatSortModule } from '@angular/material/sort';
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatNativeDateModule } from '@angular/material/core';
+var MaterialModule = /** @class */ (function () {
+    function MaterialModule() {
+    }
+    MaterialModule = __decorate([
+        NgModule({
+            imports: [
+                MatCheckboxModule,
+                MatButtonModule,
+                MatInputModule,
+                MatAutocompleteModule,
+                MatDatepickerModule,
+                MatFormFieldModule,
+                MatRadioModule,
+                MatSelectModule,
+                MatSliderModule,
+                MatSlideToggleModule,
+                MatMenuModule,
+                MatSidenavModule,
+                MatToolbarModule,
+                MatListModule,
+                MatGridListModule,
+                MatCardModule,
+                MatStepperModule,
+                MatTabsModule,
+                MatExpansionModule,
+                MatButtonToggleModule,
+                MatChipsModule,
+                MatIconModule,
+                MatProgressSpinnerModule,
+                MatProgressBarModule,
+                MatDialogModule,
+                MatTooltipModule,
+                MatSnackBarModule,
+                MatTableModule,
+                MatSortModule,
+                MatPaginatorModule,
+                MatDatepickerModule,
+                MatNativeDateModule
+            ],
+            exports: [
+                MatCheckboxModule,
+                MatButtonModule,
+                MatInputModule,
+                MatAutocompleteModule,
+                MatDatepickerModule,
+                MatFormFieldModule,
+                MatRadioModule,
+                MatSelectModule,
+                MatSliderModule,
+                MatSlideToggleModule,
+                MatMenuModule,
+                MatSidenavModule,
+                MatToolbarModule,
+                MatListModule,
+                MatGridListModule,
+                MatCardModule,
+                MatStepperModule,
+                MatTabsModule,
+                MatExpansionModule,
+                MatButtonToggleModule,
+                MatChipsModule,
+                MatIconModule,
+                MatProgressSpinnerModule,
+                MatProgressBarModule,
+                MatDialogModule,
+                MatTooltipModule,
+                MatSnackBarModule,
+                MatTableModule,
+                MatSortModule,
+                MatPaginatorModule
+            ],
+        })
+    ], MaterialModule);
+    return MaterialModule;
+}());
+export { MaterialModule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.module.js","sourceRoot":"ng://@eqproject/eqp-dynamic-module/","sources":["lib/modules/material.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\r\n\r\n//Angular Material Components\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatSliderModule } from '@angular/material/slider';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatMenuModule } from '@angular/material/menu';\r\nimport { MatSidenavModule } from '@angular/material/sidenav';\r\nimport { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatListModule } from '@angular/material/list';\r\nimport { MatGridListModule } from '@angular/material/grid-list';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { MatStepperModule } from '@angular/material/stepper';\r\nimport { MatTabsModule } from '@angular/material/tabs';\r\nimport { MatExpansionModule } from '@angular/material/expansion';\r\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { MatDialogModule } from '@angular/material/dialog';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\r\nimport { MatTableModule } from '@angular/material/table';\r\nimport { MatSortModule } from '@angular/material/sort';\r\nimport { MatPaginatorModule } from '@angular/material/paginator';\r\nimport { MatNativeDateModule } from '@angular/material/core';\r\n\r\n\r\n@NgModule({\r\n  imports: [\r\n    MatCheckboxModule,\r\n    MatButtonModule,\r\n    MatInputModule,\r\n    MatAutocompleteModule,\r\n    MatDatepickerModule,\r\n    MatFormFieldModule,\r\n    MatRadioModule,\r\n    MatSelectModule,\r\n    MatSliderModule,\r\n    MatSlideToggleModule,\r\n    MatMenuModule,\r\n    MatSidenavModule,\r\n    MatToolbarModule,\r\n    MatListModule,\r\n    MatGridListModule,\r\n    MatCardModule,\r\n    MatStepperModule,\r\n    MatTabsModule,\r\n    MatExpansionModule,\r\n    MatButtonToggleModule,\r\n    MatChipsModule,\r\n    MatIconModule,\r\n    MatProgressSpinnerModule,\r\n    MatProgressBarModule,\r\n    MatDialogModule,\r\n    MatTooltipModule,\r\n    MatSnackBarModule,\r\n    MatTableModule,\r\n    MatSortModule,\r\n    MatPaginatorModule,\r\n    MatDatepickerModule,\r\n    MatNativeDateModule\r\n  ],\r\n  exports: [\r\n    MatCheckboxModule,\r\n    MatButtonModule,\r\n    MatInputModule,\r\n    MatAutocompleteModule,\r\n    MatDatepickerModule,\r\n    MatFormFieldModule,\r\n    MatRadioModule,\r\n    MatSelectModule,\r\n    MatSliderModule,\r\n    MatSlideToggleModule,\r\n    MatMenuModule,\r\n    MatSidenavModule,\r\n    MatToolbarModule,\r\n    MatListModule,\r\n    MatGridListModule,\r\n    MatCardModule,\r\n    MatStepperModule,\r\n    MatTabsModule,\r\n    MatExpansionModule,\r\n    MatButtonToggleModule,\r\n    MatChipsModule,\r\n    MatIconModule,\r\n    MatProgressSpinnerModule,\r\n    MatProgressBarModule,\r\n    MatDialogModule,\r\n    MatTooltipModule,\r\n    MatSnackBarModule,\r\n    MatTableModule,\r\n    MatSortModule,\r\n    MatPaginatorModule],\r\n})\r\nexport class MaterialModule { }"]}

package/esm5/lib/services/custom-form-validators.service.js

@@ -0,0 +1,23 @@
+var ArrayValidators = /** @class */ (function () {
+    function ArrayValidators() {
+    }
+    ArrayValidators.minLenght = function (minLenght) {
+        var validationFunction = function (control) {
+            return !!control && !!control.value && Array.isArray(control.value) && control.value.length >= minLenght
+                ? null
+                : { hasMinLenght: false };
+        };
+        return validationFunction;
+    };
+    ArrayValidators.maxLenght = function (maxLenght) {
+        var validationFunction = function (control) {
+            return !!control && !!control.value && Array.isArray(control.value) && control.value.length <= maxLenght
+                ? null
+                : { hasMinLenght: false };
+        };
+        return validationFunction;
+    };
+    return ArrayValidators;
+}());
+export { ArrayValidators };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/services/eqp-dynamic-module-dialog.service.js

@@ -0,0 +1,113 @@
+import { __decorate } from "tslib";
+import { Injectable } from "@angular/core";
+import Swal from 'sweetalert2';
+import * as i0 from "@angular/core";
+var EqpDynamicModuleDialogService = /** @class */ (function () {
+    function EqpDynamicModuleDialogService() {
+    }
+    /**
+     * Mostra uno sweet alert di tipo ERROR con il messaggio passato come parametro.
+     * @param message Messaggio d'errore da mostrare nello sweetalert
+     * @param title Titolo dello sweetalert (di default mostra 'Errore')
+     */
+    EqpDynamicModuleDialogService.Error = function (message, title) {
+        if (title === void 0) { title = null; }
+        var currentTitle = title != null ? title : 'Errore';
+        if (Array.isArray(message)) {
+            currentTitle = title != null ? title : 'Errore';
+            var htmlErrors = message.join("<br>");
+            Swal.fire({
+                title: currentTitle,
+                html: htmlErrors,
+                icon: 'error'
+            });
+        }
+        else {
+            Swal.fire(currentTitle, message, 'error');
+        }
+    };
+    /**
+     * Mostra uno sweetalert di tipo CONFIRM con il messaggio passato come parametro e se viene premuto
+     * CONFERMA lancia la funzione di callback passata come parametro
+     * @param message Messaggio da mostrare nello sweetalert
+     * @param title Titolo dello sweetalert (di default mostra 'Info')
+     */
+    EqpDynamicModuleDialogService.Confirm = function (message, confirmCallback, isWarning, title, customWidth) {
+        if (isWarning === void 0) { isWarning = false; }
+        if (title === void 0) { title = null; }
+        if (customWidth === void 0) { customWidth = null; }
+        var currentTitle = title != null ? title : 'Sei sicuro di voler procedere?';
+        if (Array.isArray(message)) {
+            var htmlErrors = message.join("<br>");
+            Swal.fire({
+                title: currentTitle,
+                html: htmlErrors,
+                width: customWidth ? customWidth : '32rem',
+                icon: !isWarning ? 'question' : 'warning',
+                showCancelButton: true,
+                allowOutsideClick: false,
+                allowEscapeKey: false
+            }).then(function (result) {
+                if (result.value && confirmCallback) {
+                    confirmCallback();
+                }
+            });
+        }
+        else {
+            Swal.fire({
+                title: currentTitle,
+                text: message,
+                width: customWidth ? customWidth : '32rem',
+                icon: !isWarning ? 'question' : 'warning',
+                showCancelButton: true,
+                allowOutsideClick: false,
+                allowEscapeKey: false
+            }).then(function (result) {
+                if (result.value && confirmCallback) {
+                    confirmCallback();
+                }
+            });
+        }
+    };
+    /**
+     * Mostra uno sweetalert di tipo INFO con il messaggio passato come parametro
+     * @param message Messaggio da mostrare nello sweetalert
+     * @param title Titolo dello sweetalert (di default mostra 'Info')
+     */
+    EqpDynamicModuleDialogService.Info = function (message, title, isToast) {
+        if (title === void 0) { title = null; }
+        if (isToast === void 0) { isToast = null; }
+        var currentTitle = title != null ? title : "Informazione:";
+        Swal.fire(currentTitle, message, 'info');
+    };
+    /**
+     * Mostra uno sweetalert di tipo WARNING con il messaggio passato come parametro
+     * @param message Messaggio da mostrare nello sweetalert
+     * @param title Titolo dello sweetalert (di default mostra 'Attenzione!')
+     */
+    EqpDynamicModuleDialogService.Warning = function (message, title, isToast) {
+        if (title === void 0) { title = null; }
+        if (isToast === void 0) { isToast = null; }
+        var currentTitle = title != null ? title : "Attenzione!";
+        if (Array.isArray(message)) {
+            var htmlWarnings = message.join("<br>");
+            Swal.fire({
+                title: currentTitle,
+                html: htmlWarnings,
+                icon: 'warning'
+            });
+        }
+        else {
+            Swal.fire(currentTitle, message, 'warning');
+        }
+    };
+    EqpDynamicModuleDialogService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EqpDynamicModuleDialogService_Factory() { return new EqpDynamicModuleDialogService(); }, token: EqpDynamicModuleDialogService, providedIn: "root" });
+    EqpDynamicModuleDialogService = __decorate([
+        Injectable({
+            providedIn: 'root'
+        })
+    ], EqpDynamicModuleDialogService);
+    return EqpDynamicModuleDialogService;
+}());
+export { EqpDynamicModuleDialogService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eqp-dynamic-module-dialog.service.js","sourceRoot":"ng://@eqproject/eqp-dynamic-module/","sources":["lib/services/eqp-dynamic-module-dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport Swal from 'sweetalert2';\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class EqpDynamicModuleDialogService {\r\n\r\n    constructor() { }\r\n\r\n    /**\r\n     * Mostra uno sweet alert di tipo ERROR con il messaggio passato come parametro.\r\n     * @param message Messaggio d'errore da mostrare nello sweetalert\r\n     * @param title Titolo dello sweetalert (di default mostra 'Errore')\r\n     */\r\n    static Error(message: string | string[], title: string = null) {\r\n        let currentTitle = title != null ? title : 'Errore';\r\n        if (Array.isArray(message)) {\r\n            currentTitle = title != null ? title : 'Errore';\r\n            let htmlErrors: string = message.join(\"<br>\");\r\n            Swal.fire({\r\n                title: currentTitle,\r\n                html: htmlErrors,\r\n                icon: 'error'\r\n            });\r\n        }\r\n        else {\r\n            Swal.fire(currentTitle, message, 'error');\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Mostra uno sweetalert di tipo CONFIRM con il messaggio passato come parametro e se viene premuto\r\n     * CONFERMA lancia la funzione di callback passata come parametro\r\n     * @param message Messaggio da mostrare nello sweetalert\r\n     * @param title Titolo dello sweetalert (di default mostra 'Info')\r\n     */\r\n    static Confirm(message: string | string[], confirmCallback: any, isWarning: boolean = false, title: string = null, customWidth: string = null) {\r\n\r\n        let currentTitle = title != null ? title : 'Sei sicuro di voler procedere?';\r\n        if (Array.isArray(message)) {\r\n            let htmlErrors: string = message.join(\"<br>\");\r\n            Swal.fire({\r\n                title: currentTitle,\r\n                html: htmlErrors,\r\n                width: customWidth ? customWidth : '32rem',\r\n                icon: !isWarning ? 'question' : 'warning',\r\n                showCancelButton: true,\r\n                allowOutsideClick: false,\r\n                allowEscapeKey: false\r\n            }).then((result) => {\r\n                if (result.value && confirmCallback) {\r\n                    confirmCallback();\r\n                }\r\n            });\r\n        }\r\n        else {\r\n            Swal.fire({\r\n                title: currentTitle,\r\n                text: message,\r\n                width: customWidth ? customWidth : '32rem',\r\n                icon: !isWarning ? 'question' : 'warning',\r\n                showCancelButton: true,\r\n                allowOutsideClick: false,\r\n                allowEscapeKey: false\r\n            }).then((result) => {\r\n                if (result.value && confirmCallback) {\r\n                    confirmCallback();\r\n                }\r\n            })\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Mostra uno sweetalert di tipo INFO con il messaggio passato come parametro\r\n     * @param message Messaggio da mostrare nello sweetalert\r\n     * @param title Titolo dello sweetalert (di default mostra 'Info')\r\n     */\r\n    static Info(message: string, title: string = null, isToast: boolean = null) {\r\n        let currentTitle = title != null ? title : \"Informazione:\";\r\n        Swal.fire(currentTitle, message, 'info');\r\n    }\r\n\r\n    /**\r\n     * Mostra uno sweetalert di tipo WARNING con il messaggio passato come parametro\r\n     * @param message Messaggio da mostrare nello sweetalert\r\n     * @param title Titolo dello sweetalert (di default mostra 'Attenzione!')\r\n     */\r\n    static Warning(message: string | string[], title: string = null, isToast: boolean = null) {\r\n        let currentTitle = title != null ? title : \"Attenzione!\";\r\n\r\n        if (Array.isArray(message)) {\r\n            let htmlWarnings: string = message.join(\"<br>\");\r\n            Swal.fire({\r\n                title: currentTitle,\r\n                html: htmlWarnings,\r\n                icon: 'warning'\r\n            });\r\n        } else {\r\n            Swal.fire(currentTitle, message, 'warning');\r\n        }\r\n    }\r\n}\r\n"]}

package/esm5/lib/services/utilityHelper.services.js

@@ -0,0 +1,225 @@
+import { __decorate } from "tslib";
+import { Injectable } from "@angular/core";
+import { AbstractControl, FormBuilder, FormControl, FormGroup, ValidatorFn, Validators } from "@angular/forms";
+import { ColSpanSizesEnum, FieldTypeEnum } from "../models/baseField.model";
+import { Context } from "../models/context.model";
+import { ArrayValidators } from "./custom-form-validators.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+var UtilityHelperService = /** @class */ (function () {
+    function UtilityHelperService(formBuilder) {
+        this.formBuilder = formBuilder;
+    }
+    UtilityHelperService_1 = UtilityHelperService;
+    UtilityHelperService.EvaluateFieldFormula = function (formula, rec, ctx) {
+        var evaluatedValue = eval(formula.replace('"', '\"'));
+        return (evaluatedValue ? evaluatedValue : null);
+    };
+    UtilityHelperService.SetContext = function (ctx) {
+        this.context = ctx;
+    };
+    /**
+     * Metodo per impostare i valori da suggerire nell'autocomplete per i campi in cui l'utente deve scrivere comandi javascript.
+     * In base all'ultimo carattere digitato viene impostato un elenco di oggetti o proprietà che l'utente ha a disposizione in quel momento.
+     * @param fields Array di BaseField aggiunti alla Form
+     * @param typedFormula Stringa digitata dall'utente
+     * @summary Il metodo imposta i suggerimenti basandosi su 3 casi:
+     *  1) l'utente non ha digitato nulla o la stringa digitata dall'utente finisce con uno spazio vuoto
+     *  2) la stringa digitata dall'utente finisce con un "."
+     *  3) la stringa digitata dall'utente non coincide con nessun altro caso sopra (finisce con un carattere qualunque)
+     */
+    UtilityHelperService.GetAutocompleteOptions = function (fields, typedFormula) {
+        var autocompleteOptions = [];
+        // Recupero i nomi di tutti i campi creati fino ad ora nella form.
+        var availableRecProperties = fields.map(function (f) { return f.Label.split(' ').join('_'); });
+        // Nel casi in cui l'utente non ha inserito nulla oppure la stringa finisce con uno spazio vuoto o un simbolo diverso da "."
+        // (un carattere non alfanumerico) imposto come suggerimenti solo "rec" e "ctx", ovvero gli unici due oggetti a cui l'utente ha accesso.
+        if (!typedFormula ||
+            (!typedFormula.endsWith(".")
+                && new RegExp("[^0-9a-zA-Z_]").test(typedFormula.substring(typedFormula.length - 1, typedFormula.length)))) {
+            autocompleteOptions = [
+                { label: "rec", value: (typedFormula ? typedFormula : '') + "rec" },
+                { label: "ctx", value: (typedFormula ? typedFormula : '') + "ctx" }
+            ];
+        }
+        // Se la stringa finisce con un "." vuol dire che l'utente sta cercando di accedere ad una proprietà di un oggetto
+        // a sua disposizione. Recupero il nome dell'ultimo oggetto digitato dall'utente e se l'oggetto scelto è "rec" o "ctx"
+        // allora suggerisco le proprietà che esistono all'interno di questi oggetti altrimenti non mostro nulla.
+        else if (typedFormula.endsWith(".")) {
+            var formulaPieces = typedFormula.split(" ")[typedFormula.split(" ").length - 1].split('.');
+            if (formulaPieces[formulaPieces.length - 2] === "rec") {
+                autocompleteOptions = availableRecProperties.map(function (f) { return { label: f, value: typedFormula + f }; });
+            }
+            else if (formulaPieces[formulaPieces.length - 2] === "ctx") {
+                autocompleteOptions = Object.keys(UtilityHelperService_1.context).map(function (f) { return { label: f, value: typedFormula + f }; });
+            }
+            else if (formulaPieces.length > 2 && formulaPieces[formulaPieces.length - 3] === "ctx" && formulaPieces[formulaPieces.length - 2] === "User") {
+                autocompleteOptions = Object.keys(UtilityHelperService_1.context.User).map(function (f) { return { label: f, value: typedFormula + f }; });
+            }
+            else {
+                autocompleteOptions = [];
+            }
+        }
+        // In tutti gli altri casi, ovvero quando la stringa digitata finisce con un carattere diverso da quelli
+        // controllati finora, vuol dire che l'utente sta digitanto il nome di un oggetto, una proprietà o una
+        // funzione javascript. Controllo la parola che l'utente sta digitando e se fa parte di uno degli oggetti a disposizione
+        // o una proprietà di essi allora suggerisco i possibili match.
+        else {
+            var availableOptions = [];
+            // Prendo tutti i blocchi di caratteri digitati dall'utente
+            var allFormulaWords = typedFormula.split(" ");
+            // Prendo l'ultimo blocco di caratteri digitato dall'utente
+            var lastTypedString = allFormulaWords[allFormulaWords.length - 1];
+            // Se la l'ultima stringa digitata non contiene caratteri speciali allora splitto la stringa
+            // sui "." e imposto i suggerimenti in base al path della prorpietà che si sta digitando.
+            if (!new RegExp("[^0-9a-zA-Z_.]").test(lastTypedString)) {
+                var propertyPath = lastTypedString.split(".");
+                var lastTypedWork = propertyPath[propertyPath.length - 1];
+                var propertiesToCheck = [];
+                if (propertyPath.length == 1) {
+                    propertiesToCheck = ["rec", "ctx"];
+                }
+                else if (propertyPath.length > 1 && propertyPath[propertyPath.length - 2] === "ctx") {
+                    propertiesToCheck = Object.keys(UtilityHelperService_1.context);
+                }
+                else if (propertyPath.length > 2 && propertyPath[propertyPath.length - 3] === "ctx" && propertyPath[propertyPath.length - 2] === "User") {
+                    propertiesToCheck = Object.keys(UtilityHelperService_1.context.User);
+                }
+                else if (propertyPath.length > 1 && propertyPath[propertyPath.length - 2] === "rec") {
+                    propertiesToCheck = availableRecProperties;
+                }
+                // Eseguo il controllo sulle proprietà recuperate, aggiungo ai suggerimenti tutti i nomi che iniziano con 
+                // quello che sta digitando l'utente.
+                propertiesToCheck.forEach(function (prop) {
+                    if (prop.startsWith(lastTypedWork)) {
+                        availableOptions.push({ label: prop, value: typedFormula + prop.substring(lastTypedWork.length, prop.length) });
+                    }
+                });
+            }
+            autocompleteOptions = availableOptions;
+        }
+        return autocompleteOptions;
+    };
+    /**
+     * Metodo invocato dall'html per impostare le classi css per visualizzare il campo all'interno della form.
+     * Se per il field sono state specificate delle classi allora vengono applcate quelle, altrimenti vengono usate
+     * delle classi di default.
+     * @param field BaseField da visualizzare.
+     * @returns Restituisce una stringa contenente le classi css da applicare.
+     */
+    UtilityHelperService.prototype.getFieldSyleClass = function (field) {
+        if (field.ColSpanSizes && field.ColSpanSizes.length > 0)
+            return field.ColSpanSizes.map(function (size) { return ColSpanSizesEnum[size].toString(); }).join(" ");
+        switch (field.FieldType) {
+            case FieldTypeEnum["Campo di testo"]:
+                return "col-sm-12 col-md-4 col-lg-4";
+            case FieldTypeEnum["Area di testo"]:
+                return "col-sm-12 col-md-12 col-lg-12";
+            case FieldTypeEnum["Booleano"]:
+                return "col-sm-12 col-md-4 col-lg-4 d-flex align-items-center";
+            case FieldTypeEnum["Data e/o ora"]:
+                return "col-sm-12 col-md-4 col-lg-4";
+            case FieldTypeEnum["Campo numerico"]:
+                return "col-sm-12 col-md-4 col-lg-4";
+            case FieldTypeEnum["Allegato"]:
+                if (field.IsMultiAttach ||
+                    (field.MetadataFields && field.MetadataFields.length > 0)) {
+                    return "col-sm-12 col-md-12 col-lg-12";
+                }
+                else {
+                    return "col-sm-12 col-md-4 col-lg-4";
+                }
+            case FieldTypeEnum["Immagine"]:
+                if (field.AttachDefinition.IsMultiAttach ||
+                    (field.AttachDefinition.MetadataFields && field.AttachDefinition.MetadataFields.length > 0)) {
+                    return "col-sm-12 col-md-12 col-lg-12";
+                }
+                else {
+                    return "col-sm-12 col-md-4 col-lg-4";
+                }
+            case FieldTypeEnum["Elenco generico"]:
+                return "col-sm-12 col-md-4 col-lg-4";
+            case FieldTypeEnum["Lookup"]:
+                return "col-sm-12 col-md-4 col-lg-4";
+            case FieldTypeEnum['Form di dettaglio']:
+                return "col-sm-12 col-md-12 col-lg-12";
+        }
+    };
+    /**
+     * Metodo per creare il FormGroup che rappresenta una Form a partire dai suoi BaseField.
+     * @param formFields Lista dei BaseField che compongono la form.
+     * @param record Oggetto di tipo Record che contiene i valori dei campi.
+     * @param onlyView Se TRUE disabilita la form per renderla in sola lettura.
+     * @param includeCurrentFormInField Se TRUE popola la proprietà FormFormGroup all'interno di ogni BaseField con il FormGroup corrente.
+     * @returns Restituisce un FormGroup rappresentate la Form a cui appartengono i BaseField ricevuti in input.
+     */
+    UtilityHelperService.prototype.CreateFormFormGroup = function (formFields, record, onlyView, includeCurrentFormInField) {
+        var _this = this;
+        if (onlyView === void 0) { onlyView = false; }
+        if (includeCurrentFormInField === void 0) { includeCurrentFormInField = true; }
+        var formForm = this.formBuilder.group([]);
+        formFields.forEach(function (field) {
+            formForm.addControl(field.Name, _this.createFieldFormControl(field, record));
+            if (includeCurrentFormInField) {
+                field.FormFormGroup = formForm;
+            }
+        });
+        if (onlyView) {
+            formForm.disable();
+        }
+        return formForm;
+    };
+    /**
+     * Funzione per creare e aggiungere al FormGroup rappresentante la form un nuovo FormControl a partire da un Field.
+     * In nuovo FormControl avrà il nome del campo passato e verranno impostati i Validators in base al tipo del campo stesso.
+     * @param field BaseField per cui creare il FormControl da inserire nel FormGroup dela form.
+     */
+    UtilityHelperService.prototype.createFieldFormControl = function (field, record) {
+        var validators = [];
+        if (field.Required)
+            validators.push(Validators.required);
+        switch (field.FieldType) {
+            case FieldTypeEnum["Campo di testo"]:
+                if (field.MaxLenght) {
+                    validators.push(Validators.maxLength(field.MaxLenght));
+                }
+                if (field.MinLenght) {
+                    validators.push(Validators.minLength(field.MinLenght));
+                }
+                break;
+            case FieldTypeEnum["Area di testo"]:
+                if (field.MaxLenght) {
+                    validators.push(Validators.maxLength(field.MaxLenght));
+                }
+                if (field.MinLenght) {
+                    validators.push(Validators.minLength(field.MinLenght));
+                }
+                break;
+            case FieldTypeEnum.Allegato:
+            case FieldTypeEnum.Immagine:
+                if (field.Required)
+                    validators.push(ArrayValidators.minLenght(1));
+                break;
+            case FieldTypeEnum['Elenco generico']:
+                if (field.IsMultiChoiche)
+                    if (field.Required)
+                        validators.push(ArrayValidators.minLenght(1));
+                break;
+        }
+        return new FormControl(record[field.Name], validators);
+    };
+    var UtilityHelperService_1;
+    UtilityHelperService.context = new Context();
+    UtilityHelperService.ctorParameters = function () { return [
+        { type: FormBuilder }
+    ]; };
+    UtilityHelperService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UtilityHelperService_Factory() { return new UtilityHelperService(i0.ɵɵinject(i1.FormBuilder)); }, token: UtilityHelperService, providedIn: "root" });
+    UtilityHelperService = UtilityHelperService_1 = __decorate([
+        Injectable({
+            providedIn: 'root'
+        })
+    ], UtilityHelperService);
+    return UtilityHelperService;
+}());
+export { UtilityHelperService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utilityHelper.services.js","sourceRoot":"ng://@eqproject/eqp-dynamic-module/","sources":["lib/services/utilityHelper.services.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC/G,OAAO,EAAa,gBAAgB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAOlD,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;;;AAKnE;IAII,8BACY,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IAEpC,CAAC;6BAPQ,oBAAoB;IASf,yCAAoB,GAAlC,UAAmC,OAAe,EAAE,GAAW,EAAE,GAAQ;QACrE,IAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;QACxD,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;IAEa,+BAAU,GAAxB,UAAyB,GAAY;QACjC,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;IACvB,CAAC;IAED;;;;;;;;;OASG;IACW,2CAAsB,GAApC,UAAqC,MAAwB,EAAE,YAAoB;QAE/E,IAAI,mBAAmB,GAA4C,EAAE,CAAC;QAEtE,kEAAkE;QAClE,IAAM,sBAAsB,GAAkB,MAAM,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAA5B,CAA4B,CAAC,CAAC;QAE5F,4HAA4H;QAC5H,wIAAwI;QACxI,IACI,CAAC,YAAY;YACb,CACI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC;mBACxB,IAAI,MAAM,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAC5G,EACH;YACE,mBAAmB,GAAG;gBAClB,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE;gBACnE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE;aACtE,CAAC;SACL;QACD,kHAAkH;QAClH,sHAAsH;QACtH,yGAAyG;aACpG,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACjC,IAAM,aAAa,GAAkB,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5G,IAAI,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE;gBACnD,mBAAmB,GAAG,sBAAsB,CAAC,GAAG,CAAC,UAAA,CAAC,IAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC5G;iBAAM,IAAI,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE;gBAC1D,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,sBAAoB,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,UAAA,CAAC,IAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/H;iBAAM,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,MAAM,EAAE;gBAC5I,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,sBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,UAAA,CAAC,IAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aACpI;iBAAM;gBACH,mBAAmB,GAAG,EAAE,CAAC;aAC5B;SACJ;QACD,wGAAwG;QACxG,sGAAsG;QACtG,wHAAwH;QACxH,+DAA+D;aAC1D;YACD,IAAI,gBAAgB,GAA4C,EAAE,CAAC;YAEnE,2DAA2D;YAC3D,IAAM,eAAe,GAAkB,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC/D,2DAA2D;YAC3D,IAAI,eAAe,GAAW,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAE1E,4FAA4F;YAC5F,yFAAyF;YACzF,IAAI,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE;gBACrD,IAAI,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9C,IAAI,aAAa,GAAG,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBAE1D,IAAI,iBAAiB,GAAkB,EAAE,CAAC;gBAE1C,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE;oBAC1B,iBAAiB,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;iBACtC;qBAAM,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE;oBACnF,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,sBAAoB,CAAC,OAAO,CAAC,CAAC;iBACjE;qBAAM,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,MAAM,EAAE;oBACvI,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,sBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;iBACtE;qBAAM,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE;oBACnF,iBAAiB,GAAG,sBAAsB,CAAC;iBAC9C;gBAED,0GAA0G;gBAC1G,qCAAqC;gBACrC,iBAAiB,CAAC,OAAO,CAAC,UAAA,IAAI;oBAC1B,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;wBAChC,gBAAgB,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;qBAClH;gBACL,CAAC,CAAC,CAAC;aACN;YAED,mBAAmB,GAAG,gBAAgB,CAAC;SAC1C;QAED,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACH,gDAAiB,GAAjB,UAAkB,KAAgB;QAC9B,IAAI,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC;YACnD,OAAO,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAjC,CAAiC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEvF,QAAQ,KAAK,CAAC,SAAS,EAAE;YACrB,KAAK,aAAa,CAAC,gBAAgB,CAAC;gBAChC,OAAO,6BAA6B,CAAC;YACzC,KAAK,aAAa,CAAC,eAAe,CAAC;gBAC/B,OAAO,+BAA+B,CAAC;YAC3C,KAAK,aAAa,CAAC,UAAU,CAAC;gBAC1B,OAAO,uDAAuD,CAAC;YACnE,KAAK,aAAa,CAAC,cAAc,CAAC;gBAC9B,OAAO,6BAA6B,CAAC;YACzC,KAAK,aAAa,CAAC,gBAAgB,CAAC;gBAChC,OAAO,6BAA6B,CAAC;YACzC,KAAK,aAAa,CAAC,UAAU,CAAC;gBAC1B,IACK,KAAyB,CAAC,aAAa;oBACxC,CAAE,KAAyB,CAAC,cAAc,IAAK,KAAyB,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,EACrG;oBACE,OAAO,+BAA+B,CAAC;iBAC1C;qBAAM;oBACH,OAAO,6BAA6B,CAAC;iBACxC;YACL,KAAK,aAAa,CAAC,UAAU,CAAC;gBAC1B,IACK,KAAoB,CAAC,gBAAgB,CAAC,aAAa;oBACpD,CAAE,KAAoB,CAAC,gBAAgB,CAAC,cAAc,IAAK,KAAoB,CAAC,gBAAgB,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,EAC7H;oBACE,OAAO,+BAA+B,CAAC;iBAC1C;qBAAM;oBACH,OAAO,6BAA6B,CAAC;iBACxC;YACL,KAAK,aAAa,CAAC,iBAAiB,CAAC;gBACjC,OAAO,6BAA6B,CAAC;YACzC,KAAK,aAAa,CAAC,QAAQ,CAAC;gBACxB,OAAO,6BAA6B,CAAC;YACzC,KAAK,aAAa,CAAC,mBAAmB,CAAC;gBACnC,OAAO,+BAA+B,CAAC;SAC9C;IACL,CAAC;IAED;;;;;;;OAOG;IACI,kDAAmB,GAA1B,UAA2B,UAA4B,EAAE,MAAc,EAAE,QAAyB,EAAE,yBAAyC;QAA7I,iBAaC;QAbwE,yBAAA,EAAA,gBAAyB;QAAE,0CAAA,EAAA,gCAAyC;QACzI,IAAI,QAAQ,GAAc,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrD,UAAU,CAAC,OAAO,CAAC,UAAA,KAAK;YACpB,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,KAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;YAC5E,IAAI,yBAAyB,EAAE;gBAC3B,KAAK,CAAC,aAAa,GAAG,QAAQ,CAAC;aAClC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,QAAQ,EAAE;YACV,QAAQ,CAAC,OAAO,EAAE,CAAC;SACtB;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACK,qDAAsB,GAA9B,UAA+B,KAAgB,EAAE,MAAc;QAC3D,IAAM,UAAU,GAAuB,EAAE,CAAC;QAE1C,IAAI,KAAK,CAAC,QAAQ;YACd,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAEzC,QAAQ,KAAK,CAAC,SAAS,EAAE;YACrB,KAAK,aAAa,CAAC,gBAAgB,CAAC;gBAChC,IAAK,KAAmB,CAAC,SAAS,EAAE;oBAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAE,KAAmB,CAAC,SAAS,CAAC,CAAC,CAAC;iBAAE;gBAC9G,IAAK,KAAmB,CAAC,SAAS,EAAE;oBAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAE,KAAmB,CAAC,SAAS,CAAC,CAAC,CAAC;iBAAE;gBAC9G,MAAM;YACV,KAAK,aAAa,CAAC,eAAe,CAAC;gBAC/B,IAAK,KAAuB,CAAC,SAAS,EAAE;oBAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAE,KAAuB,CAAC,SAAS,CAAC,CAAC,CAAC;iBAAE;gBACtH,IAAK,KAAuB,CAAC,SAAS,EAAE;oBAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAE,KAAuB,CAAC,SAAS,CAAC,CAAC,CAAC;iBAAE;gBACtH,MAAM;YACV,KAAK,aAAa,CAAC,QAAQ,CAAC;YAC5B,KAAK,aAAa,CAAC,QAAQ;gBACvB,IAAI,KAAK,CAAC,QAAQ;oBACd,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClD,MAAM;YACV,KAAK,aAAa,CAAC,iBAAiB,CAAC;gBACjC,IAAK,KAAwB,CAAC,cAAc;oBACxC,IAAI,KAAK,CAAC,QAAQ;wBACd,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtD,MAAM;SACb;QAED,OAAO,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC;IAC3D,CAAC;;IApNa,4BAAO,GAAY,IAAI,OAAO,EAAE,CAAC;;gBAGtB,WAAW;;;IAL3B,oBAAoB;QAHhC,UAAU,CAAC;YACR,UAAU,EAAE,MAAM;SACrB,CAAC;OACW,oBAAoB,CAuNhC;+BAtOD;CAsOC,AAvND,IAuNC;SAvNY,oBAAoB","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { AbstractControl, FormBuilder, FormControl, FormGroup, ValidatorFn, Validators } from \"@angular/forms\";\r\nimport { BaseField, ColSpanSizesEnum, FieldTypeEnum } from \"../models/baseField.model\";\r\nimport { Context } from \"../models/context.model\";\r\nimport { AttachmentField } from \"../models/fields/attachmentField.model\";\r\nimport { ImageField } from \"../models/fields/imageField.model\";\r\nimport { ListValueField } from \"../models/fields/listValueField.model\";\r\nimport { TextareaField } from \"../models/fields/testareaField.model\";\r\nimport { TextField } from \"../models/fields/textField.model\";\r\nimport { Record } from \"../models/record.model\";\r\nimport { ArrayValidators } from \"./custom-form-validators.service\";\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class UtilityHelperService {\r\n\r\n    public static context: Context = new Context();\r\n\r\n    constructor(\r\n        private formBuilder: FormBuilder\r\n    ) {\r\n    }\r\n\r\n    public static EvaluateFieldFormula(formula: string, rec: Record, ctx: any): any {\r\n        const evaluatedValue = eval(formula.replace('\"', '\\\"'));\r\n        return (evaluatedValue ? evaluatedValue : null);\r\n    }\r\n\r\n    public static SetContext(ctx: Context) {\r\n        this.context = ctx;\r\n    }\r\n\r\n    /**\r\n     * Metodo per impostare i valori da suggerire nell'autocomplete per i campi in cui l'utente deve scrivere comandi javascript.\r\n     * In base all'ultimo carattere digitato viene impostato un elenco di oggetti o proprietà che l'utente ha a disposizione in quel momento.\r\n     * @param fields Array di BaseField aggiunti alla Form\r\n     * @param typedFormula Stringa digitata dall'utente\r\n     * @summary Il metodo imposta i suggerimenti basandosi su 3 casi:\r\n     *  1) l'utente non ha digitato nulla o la stringa digitata dall'utente finisce con uno spazio vuoto\r\n     *  2) la stringa digitata dall'utente finisce con un \".\"\r\n     *  3) la stringa digitata dall'utente non coincide con nessun altro caso sopra (finisce con un carattere qualunque)\r\n     */\r\n    public static GetAutocompleteOptions(fields: Array<BaseField>, typedFormula: string): Array<{ label: string, value: string }> {\r\n\r\n        var autocompleteOptions: Array<{ label: string, value: string }> = [];\r\n\r\n        // Recupero i nomi di tutti i campi creati fino ad ora nella form.\r\n        const availableRecProperties: Array<string> = fields.map(f => f.Label.split(' ').join('_'));\r\n\r\n        // Nel casi in cui l'utente non ha inserito nulla oppure la stringa finisce con uno spazio vuoto o un simbolo diverso da \".\"\r\n        // (un carattere non alfanumerico) imposto come suggerimenti solo \"rec\" e \"ctx\", ovvero gli unici due oggetti a cui l'utente ha accesso.\r\n        if (\r\n            !typedFormula ||\r\n            (\r\n                !typedFormula.endsWith(\".\")\r\n                && new RegExp(\"[^0-9a-zA-Z_]\").test(typedFormula.substring(typedFormula.length - 1, typedFormula.length))\r\n            )\r\n        ) {\r\n            autocompleteOptions = [\r\n                { label: \"rec\", value: (typedFormula ? typedFormula : '') + \"rec\" },\r\n                { label: \"ctx\", value: (typedFormula ? typedFormula : '') + \"ctx\" }\r\n            ];\r\n        }\r\n        // Se la stringa finisce con un \".\" vuol dire che l'utente sta cercando di accedere ad una proprietà di un oggetto\r\n        // a sua disposizione. Recupero il nome dell'ultimo oggetto digitato dall'utente e se l'oggetto scelto è \"rec\" o \"ctx\"\r\n        // allora suggerisco le proprietà che esistono all'interno di questi oggetti altrimenti non mostro nulla.\r\n        else if (typedFormula.endsWith(\".\")) {\r\n            const formulaPieces: Array<string> = typedFormula.split(\" \")[typedFormula.split(\" \").length - 1].split('.');\r\n            if (formulaPieces[formulaPieces.length - 2] === \"rec\") {\r\n                autocompleteOptions = availableRecProperties.map(f => { return { label: f, value: typedFormula + f }; });\r\n            } else if (formulaPieces[formulaPieces.length - 2] === \"ctx\") {\r\n                autocompleteOptions = Object.keys(UtilityHelperService.context).map(f => { return { label: f, value: typedFormula + f }; });\r\n            } else if (formulaPieces.length > 2 && formulaPieces[formulaPieces.length - 3] === \"ctx\" && formulaPieces[formulaPieces.length - 2] === \"User\") {\r\n                autocompleteOptions = Object.keys(UtilityHelperService.context.User).map(f => { return { label: f, value: typedFormula + f }; });\r\n            } else {\r\n                autocompleteOptions = [];\r\n            }\r\n        }\r\n        // In tutti gli altri casi, ovvero quando la stringa digitata finisce con un carattere diverso da quelli\r\n        // controllati finora, vuol dire che l'utente sta digitanto il nome di un oggetto, una proprietà o una\r\n        // funzione javascript. Controllo la parola che l'utente sta digitando e se fa parte di uno degli oggetti a disposizione\r\n        // o una proprietà di essi allora suggerisco i possibili match.\r\n        else {\r\n            var availableOptions: Array<{ label: string, value: string }> = [];\r\n\r\n            // Prendo tutti i blocchi di caratteri digitati dall'utente\r\n            const allFormulaWords: Array<string> = typedFormula.split(\" \");\r\n            // Prendo l'ultimo blocco di caratteri digitato dall'utente\r\n            var lastTypedString: string = allFormulaWords[allFormulaWords.length - 1];\r\n\r\n            // Se la l'ultima stringa digitata non contiene caratteri speciali allora splitto la stringa\r\n            // sui \".\" e imposto i suggerimenti in base al path della prorpietà che si sta digitando.\r\n            if (!new RegExp(\"[^0-9a-zA-Z_.]\").test(lastTypedString)) {\r\n                var propertyPath = lastTypedString.split(\".\");\r\n                var lastTypedWork = propertyPath[propertyPath.length - 1];\r\n\r\n                var propertiesToCheck: Array<string> = [];\r\n\r\n                if (propertyPath.length == 1) {\r\n                    propertiesToCheck = [\"rec\", \"ctx\"];\r\n                } else if (propertyPath.length > 1 && propertyPath[propertyPath.length - 2] === \"ctx\") {\r\n                    propertiesToCheck = Object.keys(UtilityHelperService.context);\r\n                } else if (propertyPath.length > 2 && propertyPath[propertyPath.length - 3] === \"ctx\" && propertyPath[propertyPath.length - 2] === \"User\") {\r\n                    propertiesToCheck = Object.keys(UtilityHelperService.context.User);\r\n                } else if (propertyPath.length > 1 && propertyPath[propertyPath.length - 2] === \"rec\") {\r\n                    propertiesToCheck = availableRecProperties;\r\n                }\r\n\r\n                // Eseguo il controllo sulle proprietà recuperate, aggiungo ai suggerimenti tutti i nomi che iniziano con \r\n                // quello che sta digitando l'utente.\r\n                propertiesToCheck.forEach(prop => {\r\n                    if (prop.startsWith(lastTypedWork)) {\r\n                        availableOptions.push({ label: prop, value: typedFormula + prop.substring(lastTypedWork.length, prop.length) })\r\n                    }\r\n                });\r\n            }\r\n\r\n            autocompleteOptions = availableOptions;\r\n        }\r\n\r\n        return autocompleteOptions;\r\n    }\r\n\r\n    /**\r\n     * Metodo invocato dall'html per impostare le classi css per visualizzare il campo all'interno della form.\r\n     * Se per il field sono state specificate delle classi allora vengono applcate quelle, altrimenti vengono usate\r\n     * delle classi di default.\r\n     * @param field BaseField da visualizzare.\r\n     * @returns Restituisce una stringa contenente le classi css da applicare.\r\n     */\r\n    getFieldSyleClass(field: BaseField): string {\r\n        if (field.ColSpanSizes && field.ColSpanSizes.length > 0)\r\n            return field.ColSpanSizes.map(size => ColSpanSizesEnum[size].toString()).join(\" \");\r\n\r\n        switch (field.FieldType) {\r\n            case FieldTypeEnum[\"Campo di testo\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4\";\r\n            case FieldTypeEnum[\"Area di testo\"]:\r\n                return \"col-sm-12 col-md-12 col-lg-12\";\r\n            case FieldTypeEnum[\"Booleano\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4 d-flex align-items-center\";\r\n            case FieldTypeEnum[\"Data e/o ora\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4\";\r\n            case FieldTypeEnum[\"Campo numerico\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4\";\r\n            case FieldTypeEnum[\"Allegato\"]:\r\n                if (\r\n                    (field as AttachmentField).IsMultiAttach ||\r\n                    ((field as AttachmentField).MetadataFields && (field as AttachmentField).MetadataFields.length > 0)\r\n                ) {\r\n                    return \"col-sm-12 col-md-12 col-lg-12\";\r\n                } else {\r\n                    return \"col-sm-12 col-md-4 col-lg-4\";\r\n                }\r\n            case FieldTypeEnum[\"Immagine\"]:\r\n                if (\r\n                    (field as ImageField).AttachDefinition.IsMultiAttach ||\r\n                    ((field as ImageField).AttachDefinition.MetadataFields && (field as ImageField).AttachDefinition.MetadataFields.length > 0)\r\n                ) {\r\n                    return \"col-sm-12 col-md-12 col-lg-12\";\r\n                } else {\r\n                    return \"col-sm-12 col-md-4 col-lg-4\";\r\n                }\r\n            case FieldTypeEnum[\"Elenco generico\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4\";\r\n            case FieldTypeEnum[\"Lookup\"]:\r\n                return \"col-sm-12 col-md-4 col-lg-4\";\r\n            case FieldTypeEnum['Form di dettaglio']:\r\n                return \"col-sm-12 col-md-12 col-lg-12\";\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Metodo per creare il FormGroup che rappresenta una Form a partire dai suoi BaseField.\r\n     * @param formFields Lista dei BaseField che compongono la form.\r\n     * @param record Oggetto di tipo Record che contiene i valori dei campi.\r\n     * @param onlyView Se TRUE disabilita la form per renderla in sola lettura.\r\n     * @param includeCurrentFormInField Se TRUE popola la proprietà FormFormGroup all'interno di ogni BaseField con il FormGroup corrente.\r\n     * @returns Restituisce un FormGroup rappresentate la Form a cui appartengono i BaseField ricevuti in input. \r\n     */\r\n    public CreateFormFormGroup(formFields: Array<BaseField>, record: Record, onlyView: boolean = false, includeCurrentFormInField: boolean = true): FormGroup {\r\n        var formForm: FormGroup = this.formBuilder.group([]);\r\n        formFields.forEach(field => {\r\n            formForm.addControl(field.Name, this.createFieldFormControl(field, record));\r\n            if (includeCurrentFormInField) {\r\n                field.FormFormGroup = formForm;\r\n            }\r\n        });\r\n        if (onlyView) {\r\n            formForm.disable();\r\n        }\r\n\r\n        return formForm;\r\n    }\r\n\r\n    /**\r\n     * Funzione per creare e aggiungere al FormGroup rappresentante la form un nuovo FormControl a partire da un Field. \r\n     * In nuovo FormControl avrà il nome del campo passato e verranno impostati i Validators in base al tipo del campo stesso.\r\n     * @param field BaseField per cui creare il FormControl da inserire nel FormGroup dela form.\r\n     */\r\n    private createFieldFormControl(field: BaseField, record: Record): AbstractControl {\r\n        const validators: Array<ValidatorFn> = [];\r\n\r\n        if (field.Required)\r\n            validators.push(Validators.required);\r\n\r\n        switch (field.FieldType) {\r\n            case FieldTypeEnum[\"Campo di testo\"]:\r\n                if ((field as TextField).MaxLenght) { validators.push(Validators.maxLength((field as TextField).MaxLenght)); }\r\n                if ((field as TextField).MinLenght) { validators.push(Validators.minLength((field as TextField).MinLenght)); }\r\n                break;\r\n            case FieldTypeEnum[\"Area di testo\"]:\r\n                if ((field as TextareaField).MaxLenght) { validators.push(Validators.maxLength((field as TextareaField).MaxLenght)); }\r\n                if ((field as TextareaField).MinLenght) { validators.push(Validators.minLength((field as TextareaField).MinLenght)); }\r\n                break;\r\n            case FieldTypeEnum.Allegato:\r\n            case FieldTypeEnum.Immagine:\r\n                if (field.Required)\r\n                    validators.push(ArrayValidators.minLenght(1));\r\n                break;\r\n            case FieldTypeEnum['Elenco generico']:\r\n                if ((field as ListValueField).IsMultiChoiche)\r\n                    if (field.Required)\r\n                        validators.push(ArrayValidators.minLenght(1));\r\n                break;\r\n        }\r\n\r\n        return new FormControl(record[field.Name], validators);\r\n    }\r\n}"]}