@eqproject/eqp-dynamic-module 2.8.7 → 3.0.0

package/esm2022/lib/components/private/add-form-field/add-form-field.component.mjs

@@ -0,0 +1,1263 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from "@angular/core";
+import { UntypedFormControl, Validators, } from "@angular/forms";
+import { AttachmentType, } from "@eqproject/eqp-attachments";
+import { TypeColumn } from "@eqproject/eqp-table";
+import { BaseField, ColSpanSizesEnum, DataGetterCardinalityEnum, FieldInvisibilityEnum, FieldTypeEnum } from "../../../models/baseField.model";
+import { AvailableFileExtensions, AvailableImageExtensions, } from "../../../models/fields/attachmentField.model";
+import { BoolPresentantioEnum, } from "../../../models/fields/booleanField.model";
+import { DateTimeTypeEnum, } from "../../../models/fields/dateField.model";
+import { ListPresentationEnum, } from "../../../models/fields/listValueField.model";
+import { TextMaskEnum, } from "../../../models/fields/textField.model";
+import { UtilityHelperService } from "../../../services/utilityHelper.services";
+import { GlobalService } from "../../../services/global.service";
+import { EqpDynamicModuleDialogService } from "../../../services/eqp-dynamic-module-dialog.service";
+import { AttachmentFieldTypeEnum } from "../../../models/dynAttachment";
+import { DataGetterTypeEnum, DataGetter } from '../../../models/baseField.model';
+import { QueryEditorModeEnum } from "../dbgetter/dbgetter.component";
+import { ModeEnum, TimeTypeEnum } from "tmw-picker";
+import { ParamTypeEnum } from "../../../models/endPointConfiguration.model";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@eqproject/eqp-select";
+import * as i3 from "@angular/material/dialog";
+import * as i4 from "@angular/common/http";
+import * as i5 from "../../../services/utilityHelper.services";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/material/form-field";
+import * as i9 from "@angular/material/slide-toggle";
+import * as i10 from "@angular/material/card";
+import * as i11 from "@angular/material/tabs";
+import * as i12 from "@angular/material/icon";
+import * as i13 from "@angular/material/tooltip";
+import * as i14 from "@angular/common";
+import * as i15 from "@eqproject/eqp-attachments";
+import * as i16 from "tmw-picker";
+import * as i17 from "../add-formula-field/add-formula-field.component";
+import * as i18 from "../../../directives/dynamic-loader/dynamic-loader.directive";
+export class AddFormFieldComponent {
+    formBuilder;
+    enumHelper;
+    dialog;
+    cdr;
+    httpClient;
+    utilityHelperService;
+    form;
+    endPointConfiguration;
+    field;
+    indexField;
+    formFieldsGroups;
+    /** Elenco dei Field creati nella form, usati per popolare l'autocomplete della proprietà Formula. */
+    availableFields;
+    fieldTypesToExclude = [FieldTypeEnum["Form di dettaglio"]];
+    QueryEditorComponent; // L'intero componente query Editor
+    contestualization = null;
+    out = new EventEmitter();
+    saveFieldEvent = new EventEmitter();
+    resizedImagesHeightPx;
+    fieldFormGroup;
+    keyValueObject = { key: "", value: "" };
+    availableColSpanSizesCompilazione = [];
+    availableColSpanSizesRisposta = [];
+    formulaAutocompleteOptions;
+    VisibleIfAutocompleteOptions;
+    AvailableFileExtensions = AvailableFileExtensions;
+    AvailableImageExtensions = AvailableImageExtensions;
+    fieldInvisibilityEnum = FieldInvisibilityEnum;
+    columnKeys = new Array();
+    //#region Template dei vari pezzi di form per la creazione di un campo(in base al tipo scelto).
+    fieldTypeFormTemplate;
+    textFieldFormTemplate;
+    labelFieldFormTemplate;
+    textareaFieldFormTemplate;
+    booleadFieldFormTemplate;
+    dateFieldFormTemplate;
+    numericFieldFormTemplate;
+    attachmentFieldFormTemplate;
+    imageFieldFormTemplate;
+    imageWithMarkersFieldFormTemplate;
+    imageFieldSelectorFormTemplate;
+    listValueFieldFormTemplate;
+    lookupFieldFormTemplate;
+    dataGetterTemplate;
+    //#endregion
+    //#region Proprietà per gestire i metadata nei campi ti dipo Allegato o Immagine
+    metadataColumns;
+    //@ViewChild('metadataFieldsTable', { static: false }) metadataFieldsTable: EqpTableComponent;
+    selectedMetadata;
+    //indexSelectedMetadata: number;
+    //dialogMetadataRef: MatDialogRef<TemplateRef<any>>;
+    dialogFormulaRef;
+    dialogVisibleIfRef;
+    //@ViewChild('dialogMetadata', { static: true }) dialogMetadata: TemplateRef<any>;
+    dialogFormula;
+    //#endregion
+    //#region Proprietà per gestire le immagini nei capi di tipo elenco generico
+    buttonImagesKeyValueInputColumn;
+    //#endregion
+    //#region Enumeratori usati nell'html
+    FieldTypeEnum = FieldTypeEnum;
+    BoolPresentantioEnum = BoolPresentantioEnum;
+    DateTimeTypeEnum = DateTimeTypeEnum;
+    ListPresentationEnum = ListPresentationEnum;
+    TextMaskEnum = TextMaskEnum;
+    AttachmentType = AttachmentType;
+    attachmentFieldTypeEnum = AttachmentFieldTypeEnum;
+    dataGetterTypeEnum = DataGetterTypeEnum;
+    subscription;
+    //#endregion
+    //#region Gestione delle liste di immagini
+    configColumnListImages = new Array();
+    configColumnImage = new Array();
+    GenericListImagesImageTemplate;
+    GenericListImagesKeyTemplate;
+    GenericListImagesValueTemplate;
+    imageSelectorAttachments;
+    imageAttachment;
+    //#endregion
+    // DB Getter
+    dialogQERef;
+    //@ViewChild('dialogMetadata', { static: true }) dialogMetadata: TemplateRef<any>;
+    dialogQE;
+    // TMW-PICKER
+    mode = ModeEnum;
+    timeType = TimeTypeEnum;
+    // DM Getter
+    forms = new Array();
+    DMModule;
+    DMField;
+    DMFields;
+    DMGetterCardinalities = DataGetterCardinalityEnum;
+    constructor(formBuilder, enumHelper, dialog, cdr, httpClient, utilityHelperService) {
+        this.formBuilder = formBuilder;
+        this.enumHelper = enumHelper;
+        this.dialog = dialog;
+        this.cdr = cdr;
+        this.httpClient = httpClient;
+        this.utilityHelperService = utilityHelperService;
+    }
+    async ngOnInit() {
+        this.configureColumns();
+        if (this.field.DataGetter == null) {
+            this.field.DataGetter = new DataGetter();
+        }
+        if (this.field.DataGetter.DataGetterType != null && this.field.DataGetter.DataGetterType == DataGetterTypeEnum["Da modulo dinamico"]) {
+            await this.getAllModules();
+        }
+        if (typeof this.field.DataGetter.DataGetterValue != "undefined" && this.field.DataGetter.DataGetterValue != null) {
+            this.createColumnKeys(this.field.DataGetter.DataGetterValue.Params);
+        }
+        if (!this.fieldTypesToExclude.includes(FieldTypeEnum["Form di dettaglio"])) {
+            this.fieldTypesToExclude.push(FieldTypeEnum["Form di dettaglio"]);
+        }
+        this.onFieldTypeChange(false);
+        this.availableFields = this.availableFields
+            ? this.availableFields.filter((f) => f != this.field)
+            : [];
+    }
+    /**
+     * Metodo per impostare i valori da suggerire nell'autocomplete del campo Formula.
+     * Viene scatenato al focus (in questo caso viene passato il parametro a null per differenziarlo
+     * dall'evento di click sulla tastiera) e al keyup sull'input (il parametro è diverso da null).
+     * @param keyboardEvent Evento scatenato al keyup sulla tastiera. Se null allora il metodo è stato invocato dal focus sull'input.
+     * @summary Aggiorna l'elenco dei suggerimenti per l'autocomplete se l'utente esegue il focus sull'input
+     * oppure al keyup sulla tastiera di un tasto diverso dalle frecce.
+     */
+    // setFormulaAutocompleteOptions(keyboardEvent: KeyboardEvent) {
+    //   // Creo l'array per l'autocomplete solo se sto facendo il focus sull'input o se sto premendo un tasto
+    //   // sulla tastiera diverso dalle frecce (in quest'ultimo caso, se non viene eseguito il filtro sull'evento,
+    //   // non si può selezionare un suggerimento dell'autocomplete perchè al click verrebbe ricaricato l'array e
+    //   // si prederebbe la selezione appena fatta).
+    //   if (!keyboardEvent || !keyboardEvent.code.includes("Arrow")) {
+    //     this.formulaAutocompleteOptions = UtilityHelperService.GetAutocompleteOptions(this.availableFields, this.field.Formula);
+    //   }
+    // }
+    setVisibleIfAutocompleteOptions(keyboardEvent) {
+        // Creo l'array per l'autocomplete solo se sto facendo il focus sull'input o se sto premendo un tasto
+        // sulla tastiera diverso dalle frecce (in quest'ultimo caso, se non viene eseguito il filtro sull'evento,
+        // non si può selezionare un suggerimento dell'autocomplete perchè al click verrebbe ricaricato l'array e
+        // si prederebbe la selezione appena fatta).
+        if (!keyboardEvent || !keyboardEvent.code.includes("Arrow")) {
+            this.VisibleIfAutocompleteOptions =
+                UtilityHelperService.GetAutocompleteOptions(this.availableFields, this.field.VisibleIf);
+        }
+    }
+    omit_special_char(event) {
+        var k;
+        k = event.keyCode; //         k = event.keyCode;  (Both can be used)
+        if (k == 34) {
+            event.keyCode = 0;
+            return false;
+        }
+    }
+    /**
+     * Crea il FormGroup per l'aggiunta di un nuovo campo all'interno della form.
+     * Metodo richiamato ogni volta che cambia il tipo del campo scelto o viene aggiunto/modificato un Field
+     */
+    createFieldForm() {
+        this.fieldFormGroup = this.formBuilder.group({
+            Label: [
+                this.field.Label,
+                [
+                    Validators.required,
+                    this.questionPoll,
+                    Validators.pattern("^[a-zA-Z ]*$"),
+                ],
+            ],
+            Description: [
+                this.field.Description,
+                [Validators.required, this.questionPoll],
+            ],
+            Readonly: [this.field.Readonly],
+            Required: [this.field.Required],
+            FieldType: [
+                this.field.FieldType,
+                [Validators.required, this.questionPoll],
+            ],
+            DMModule: [null],
+            DMField: [null],
+            DataGetterType: [
+                this.field.DataGetter.DataGetterType,
+                [Validators.required],
+            ],
+            ColSpanSizes: [this.field.ColSpanSizes],
+            InListView: [this.field.InListView],
+            Invisibility: [this.field.Invisibility],
+            VisibleIf: [this.field.VisibleIf, this.questionPoll],
+            Tooltip: [this.field.Tooltip, this.questionPoll],
+            LabelstyleCSS: [this.field.LabelstyleCSS, this.questionPoll],
+            FieldstyleCSS: [this.field.FieldstyleCSS, this.questionPoll],
+            Formula: [this.field.Formula, this.questionPoll],
+            DataGetterValue: [this.field.DataGetter.DataGetterValue, this.questionPoll],
+            AnswerStyleLabelstyleCSS: [this.field.AnswerStyle.LabelstyleCSS, this.questionPoll],
+            AnswerStyleFieldstyleCSS: [this.field.AnswerStyle.FieldstyleCSS, this.questionPoll],
+            AnswerStyleVisibleIf: [this.field.AnswerStyle.VisibleIf, this.questionPoll],
+            AnswerStyleColSpanSizes: [this.field.AnswerStyle.ColSpanSizes],
+            AnswerStyleInListView: [this.field.AnswerStyle.InListView],
+            AnswerStyleInvisibility: [this.field.AnswerStyle.Invisibility],
+        });
+        if (this.formFieldsGroups) {
+            this.fieldFormGroup.addControl("FieldGroup", new UntypedFormControl(this.field.FieldGroup, Validators.required));
+        }
+    }
+    questionPoll(control) {
+        // c'è un FormControl che è vuoto che da problemi (probabilmente type Data, campo Formato)
+        if (control.value != undefined) {
+            if (UtilityHelperService.stringCheckParentesis(control.value, control.hasValidator(Validators.required))) {
+                return null;
+            }
+            else {
+                return { "Missing Parenthesis": true };
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    stringSanitaizedValidator(control) {
+        // c'è un FormControl che è vuoto che da problemi (probabilmente type Data, campo Formato)
+        if (control.value != undefined) {
+            if (UtilityHelperService.stringCheckParentesis(control.value, control.hasValidator(Validators.required))) {
+                return null;
+            }
+            else {
+                return { "La formula non è valida": true };
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    // getAllFormValidationErrors() {
+    //   Object.keys(this.fieldFormGroup.controls).forEach((key) => {
+    //     const controlErrors: ValidationErrors =
+    //       this.fieldFormGroup.get(key).errors;
+    //     if (controlErrors != null) {
+    //       Object.keys(controlErrors).forEach((keyError) => {
+    //         console.log(
+    //           "Key control: " + key + ", keyError: " + keyError + ", err value: ",
+    //           controlErrors[keyError]
+    //         );
+    //       });
+    //     }
+    //   });
+    // }
+    /**
+     * Metodo chiamato dai mat-error per prendere gli errori generati relativi al campo.
+     * @param control è il nome del GroupControl di cui leggere se ci sono errori
+     */
+    getFormValidationErrors(control) {
+        if (control == "Label")
+            GlobalService.debugLog('getFormValidationErrors', this.fieldFormGroup.controls["Label"]);
+        const controlErrors = this.fieldFormGroup.controls[control].errors;
+        let errors = [];
+        let values = [];
+        if (controlErrors != null) {
+            Object.keys(controlErrors).forEach((keyError) => {
+                errors.push(keyError);
+            });
+            GlobalService.debugLog('control: ', control);
+            GlobalService.debugLog('errors: ', errors);
+            GlobalService.debugLog('values: ', values);
+        }
+        return errors.join(", ");
+    }
+    //#region onFieldTypeChange
+    /**
+     * Metodo chiamato quando cambia il FieldType del BaseField che si sta aggiungendo/modificando.
+     * Ricrea l'oggetto field popolando solo le proprietà del BaseField inserite dall'utente
+     * (quelle comuni a tutte le tipologie di campo), ricrea la form e, in base al FieldType scelto,
+     * aggiunge alla form i FormControl necessari e seleziona il template corretto da usare.
+     * @param restoreField Se TRUE ripristina i valori base (ereditati dal modello BaseField) del campo aggiunto/modificato
+     */
+    onFieldTypeChange(restoreField = true) {
+        if (restoreField) {
+            this.restoreBaseFieldProperties();
+        }
+        this.createFieldForm();
+        this.onColSpanSizeSelect();
+        if (this.field.InListView == null) {
+            this.field.InListView = true;
+        }
+        if (this.field.Invisibility == null) {
+            this.field.Invisibility = FieldInvisibilityEnum.NASCOSTO;
+        }
+        this.fieldTypeFormTemplate = null;
+        switch (this.field.FieldType) {
+            //#region CAMPO DI TESTO
+            case FieldTypeEnum["Campo di testo"]:
+                if (this.field.Microphone == null) {
+                    this.field.Microphone = false;
+                }
+                this.fieldFormGroup.addControl("TextMask", new UntypedFormControl(this.field.TextMask));
+                this.fieldFormGroup.addControl("MaxLenght", new UntypedFormControl(this.field.MaxLenght, [
+                    this.questionPoll,
+                    Validators.pattern("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("MinLenght", new UntypedFormControl(this.field.MinLenght, [
+                    this.questionPoll,
+                    Validators.pattern("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("Microphone", new UntypedFormControl(this.field.Microphone));
+                this.fieldTypeFormTemplate = this.textFieldFormTemplate;
+                break;
+            //#endregion CAMPO DI TESTO
+            //#region LABEL
+            case FieldTypeEnum['Etichetta']:
+                if (this.field.Etichetta == null) {
+                    this.field.Etichetta = "";
+                }
+                this.fieldFormGroup.addControl("Etichetta", new UntypedFormControl(this.field.Etichetta));
+                this.fieldTypeFormTemplate = this.labelFieldFormTemplate;
+                break;
+            //#endregion LABEL
+            //#region AREA DI TESTO 
+            case FieldTypeEnum["Area di testo"]:
+                if (this.field.Microphone == null) {
+                    this.field.Microphone = false;
+                }
+                this.fieldFormGroup.addControl("Rows", new UntypedFormControl(this.field.Rows, [
+                    this.questionPoll,
+                    Validators.pattern("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("MaxLenght", new UntypedFormControl(this.field.MaxLenght, [
+                    this.questionPoll,
+                    Validators.pattern("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("MinLenght", new UntypedFormControl(this.field.MinLenght, [
+                    this.questionPoll,
+                    Validators.pattern("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("Microphone", new UntypedFormControl(this.field.Microphone));
+                this.fieldTypeFormTemplate = this.textareaFieldFormTemplate;
+                break;
+            //#endregion AREA DI TESTO 
+            //#region BOOLEANO
+            case FieldTypeEnum.Booleano:
+                this.fieldFormGroup.addControl("IsTristate", new UntypedFormControl(this.field.IsTristate));
+                this.fieldFormGroup.addControl("PresetationType", new UntypedFormControl(this.field.PresetationType, Validators.required));
+                this.fieldTypeFormTemplate = this.booleadFieldFormTemplate;
+                break;
+            //#endregion BOOLEANO
+            //#region DATA E/I ORA
+            case FieldTypeEnum["Data e/o ora"]:
+                if (this.field.IsOnlyDate == null) {
+                    this.field.IsOnlyDate = DateTimeTypeEnum["Solo data"];
+                }
+                this.fieldFormGroup.addControl("IsOnlyDate", new UntypedFormControl(this.field.IsOnlyDate, [
+                    Validators.required,
+                    this.questionPoll,
+                ]));
+                this.fieldFormGroup.addControl("MinDate", new UntypedFormControl(this.field.MinDate, this.questionPoll));
+                this.fieldFormGroup.addControl("MaxDate", new UntypedFormControl(this.field.MaxDate, this.questionPoll));
+                this.fieldFormGroup.addControl("DateFormat", new UntypedFormControl(this.field.DateFormat));
+                this.fieldTypeFormTemplate = this.dateFieldFormTemplate;
+                break;
+            //#endregion DATA E/I ORA
+            //#region CAMPO NUMERICO
+            case FieldTypeEnum["Campo numerico"]:
+                if (this.field.IsInteger == null) {
+                    this.field.IsInteger = true;
+                }
+                this.fieldFormGroup.addControl("IsInteger", new UntypedFormControl(this.field.IsInteger));
+                this.fieldFormGroup.addControl("MinValue", new UntypedFormControl(this.field.MinValue, [
+                    this.questionPoll,
+                    Validators.pattern("^-?[0-9]+(,[0-9]+|\.[0-9]+)?$"), //("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("MaxValue", new UntypedFormControl(this.field.MaxValue, [
+                    this.questionPoll,
+                    Validators.pattern("^-?[0-9]+(,[0-9]+|\.[0-9]+)?$"), //("^[0-9]*$"),
+                ]));
+                this.fieldFormGroup.addControl("DecimalSeparator", new UntypedFormControl(this.field.DecimalSeparator, [this.questionPoll, Validators.pattern("^[a-zA-Z -/',._/\\^<>]+")]));
+                this.fieldFormGroup.addControl("DecimalPrecision", new UntypedFormControl(this.field.DecimalPrecision, [this.questionPoll, Validators.pattern("^[0-9]+$")]));
+                this.fieldFormGroup.addControl("ThousandsSeparator", new UntypedFormControl(this.field.ThousandsSeparator, [this.questionPoll, Validators.pattern("^[a-zA-Z -/',._/\\^<>]+")]));
+                this.fieldFormGroup.addControl("CurrencySymbol", new UntypedFormControl(this.field.CurrencySymbol, this.questionPoll));
+                this.fieldFormGroup.addControl("MeasureUnit", new UntypedFormControl(this.field.MeasureUnit, this.questionPoll));
+                this.fieldTypeFormTemplate = this.numericFieldFormTemplate;
+                break;
+            //#endregion CAMPO NUMERICO
+            //#region ALLEGATO
+            case FieldTypeEnum.Allegato:
+                this.fieldFormGroup.addControl("AllowedExtensions", new UntypedFormControl(this.field.AllowedExtensions));
+                this.fieldFormGroup.addControl("IsMultiAttach", new UntypedFormControl(this.field.IsMultiAttach));
+                this.fieldTypeFormTemplate = this.attachmentFieldFormTemplate;
+                break;
+            //#endregion ALLEGATO
+            //#region IMMAGINE
+            case FieldTypeEnum.Immagine:
+                if (typeof this.field.DynAttachment == "undefined") {
+                    this.field.DynAttachment = null;
+                }
+                if (typeof this.field.EnableDrawing == "undefined") {
+                    this.field.EnableDrawing = false;
+                }
+                this.fieldFormGroup.addControl("ResizedImagesHeightPx", new UntypedFormControl(this.field.ResizedImagesHeightPx, [Validators.required, Validators.max(4320)]));
+                this.field.ResizedImagesHeightPx = this.field.ResizedImagesHeightPx != null ? this.field.ResizedImagesHeightPx : 128;
+                this.fieldFormGroup.addControl("EnableDrawing", new UntypedFormControl(this.field.EnableDrawing));
+                this.fieldTypeFormTemplate = this.imageFieldFormTemplate;
+                break;
+            /*
+            (this.field as ImageField).AttachDefinition = new AttachmentField();
+            this.fieldFormGroup.addControl(
+              "EnableDrawing",
+              new UntypedFormControl((this.field as ImageField).EnableDrawing)
+            );
+            this.fieldFormGroup.addControl(
+              "ImageIsContextualAttachment",
+              new UntypedFormControl(
+                (this.field as ImageField).ImageIsContextualAttachment
+              )
+            );
+            // Imposto i FormControl variabili.
+            this.onImageIsContextualAttachmentChange();
+            this.fieldTypeFormTemplate = this.imageFieldFormTemplate;
+            break;
+            */
+            //#endregion IMMAGINE
+            //#region ELENCO GENERICO
+            case FieldTypeEnum["Elenco generico"]:
+                if (this.field.InListView == null) {
+                    this.field.InListView = true;
+                }
+                if (this.field.Invisibility == null) {
+                    this.field.Invisibility = FieldInvisibilityEnum.NASCOSTO;
+                }
+                this.fieldFormGroup.addControl("IsMultiChoiche", new UntypedFormControl(this.field.IsMultiChoiche));
+                this.fieldFormGroup.addControl("PresentationMode", new UntypedFormControl(this.field.PresentationMode, Validators.required));
+                this.fieldTypeFormTemplate = this.listValueFieldFormTemplate;
+                break;
+            //#endregion ELENCO GENERICO
+            //#region ELENCO IMMAGINI
+            case FieldTypeEnum["Elenco immagini"]:
+                this.fieldFormGroup.addControl("IsMultiChoiche", new UntypedFormControl(this.field.IsMultiChoiche));
+                this.fieldFormGroup.addControl("ResizedImagesHeightPx", new UntypedFormControl(this.field.ResizedImagesHeightPx, [Validators.required, Validators.max(4320)]));
+                this.fieldTypeFormTemplate = this.imageFieldSelectorFormTemplate;
+                break;
+            //#endregion ELENCO IMMAGINI     
+            //#region IMMAGINE CON MARKER
+            case FieldTypeEnum["Immagine con markers"]:
+                this.fieldFormGroup.addControl("ResizedImagesHeightPx", new UntypedFormControl(this.field.ResizedImagesHeightPx, [Validators.required, Validators.max(4320)]));
+                this.fieldTypeFormTemplate = this.imageWithMarkersFieldFormTemplate;
+                break;
+            //#endregion IMMAGINE CON MARKER        
+            //#region LOOKUP
+            case FieldTypeEnum.Lookup:
+                this.fieldFormGroup.addControl("EntitySourceName", new UntypedFormControl(this.field.EntitySourceName, Validators.required));
+                this.fieldFormGroup.addControl("UseAsGetOrDiscard", new UntypedFormControl(this.field.UseAsGetOrDiscard));
+                this.fieldTypeFormTemplate = this.lookupFieldFormTemplate;
+                break;
+            //#endregion LOOKUP
+        }
+        if ([
+            FieldTypeEnum.Allegato,
+            FieldTypeEnum.Immagine,
+            FieldTypeEnum["Form di dettaglio"],
+        ].includes(this.field.FieldType)) {
+            this.field.Formula = null;
+            this.fieldFormGroup.controls["Formula"].disable();
+            this.fieldFormGroup.controls["InListView"].disable();
+            this.fieldFormGroup.controls["Invisibility"].disable();
+        }
+        else {
+            this.fieldFormGroup.controls["Formula"].enable();
+            this.fieldFormGroup.controls["InListView"].enable();
+            this.fieldFormGroup.controls["Invisibility"].enable();
+        }
+        if ([
+            FieldTypeEnum.Allegato,
+            FieldTypeEnum.Immagine,
+            FieldTypeEnum["Form di dettaglio"],
+            FieldTypeEnum["Data e/o ora"],
+        ].includes(this.field.FieldType)) {
+            this.fieldFormGroup.controls["LabelstyleCSS"].disable();
+            this.fieldFormGroup.controls["FieldstyleCSS"].disable();
+        }
+        else {
+            this.fieldFormGroup.controls["LabelstyleCSS"].enable();
+            this.fieldFormGroup.controls["FieldstyleCSS"].enable();
+        }
+        if ([FieldTypeEnum.Booleano].includes(this.field.FieldType)) {
+            this.fieldFormGroup.controls["LabelstyleCSS"].disable();
+        }
+        else {
+            this.fieldFormGroup.controls["LabelstyleCSS"].enable();
+        }
+    }
+    //#endregion onFieldTypeChange
+    //#region onDataGetterTypeChange
+    async onDataGetterTypeChange() {
+        if (this.field.DataGetter.DataGetterType == DataGetterTypeEnum['Da modulo dinamico'] && this.forms.length == 0) {
+            this.getAllModules();
+        }
+        if (this.field.DataGetter.DataGetterType != DataGetterTypeEnum.Formula) {
+            this.field.Formula = null;
+        }
+        this.field.DataGetter.DataGetterValue = null;
+        this.DMModule = null;
+        this.DMField = null;
+    }
+    //#endregion onDataGetterTypeChange
+    /**
+     * Metodo invocato al cambio del valore della proprietà ImageIsContextualAttachment nel caso
+     * di campi di tipo Immagine. Se TRUE allora rimuove i FormControl per le proprietà IsMultiAttach
+     * e AllowedExtensions e aggiunge i FormControl per le proprietà ImgName e ContextualAttachment,
+     * altrimenti il contrario.
+     */
+    onImageIsContextualAttachmentChange() {
+        /*
+        (this.field as ImageField).ImgName = null;
+        (this.field as ImageField).AttachDefinition.AllowedExtensions = [];
+        (this.field as ImageField).AttachDefinition.IsMultiAttach = false;
+        (this.field as ImageField).ContextualAttachment = null;
+    
+        if ((this.field as ImageField).ImageIsContextualAttachment) {
+          this.fieldFormGroup.removeControl("IsMultiAttach");
+          this.fieldFormGroup.removeControl("AllowedExtensions");
+          this.fieldFormGroup.addControl(
+            "ImgName",
+            new UntypedFormControl(
+              (this.field as ImageField).ImgName,
+              Validators.required
+            )
+          );
+          this.fieldFormGroup.addControl(
+            "ContextualAttachment",
+            new UntypedFormControl(
+              (this.field as ImageField).ContextualAttachment,
+              Validators.required
+            )
+          );
+        } else {
+          this.fieldFormGroup.removeControl("ImgName");
+          this.fieldFormGroup.removeControl("ContextualAttachment");
+          this.fieldFormGroup.addControl(
+            "IsMultiAttach",
+            new UntypedFormControl(
+              (this.field as ImageField).AttachDefinition.IsMultiAttach
+            )
+          );
+          this.fieldFormGroup.addControl(
+            "AllowedExtensions",
+            new UntypedFormControl(
+              (this.field as ImageField).AttachDefinition.AllowedExtensions
+            )
+          );
+        }
+        */
+    }
+    /**
+     * Metodo per intercettare l'aggiunta di un allegato nei campi di tipo Immagine per aggiornare
+     * il valore della proprietà ContextualAttachment e la validazione del relativo FormControl.
+     * @param event Array contenente l'elenco aggiornato degli allegati caricati (nel nostro caso ne contiene al più 1).
+     */
+    catchContextualAttachmentChange(event) {
+        /*
+        if (event && event.length > 0) {
+          (this.field as ImageField).ContextualAttachment = event[0];
+        } else {
+          (this.field as ImageField).ContextualAttachment = null;
+        }
+        this.fieldFormGroup.controls["ContextualAttachment"].setValue(
+          (this.field as ImageField).ContextualAttachment
+        );
+        */
+    }
+    /**
+     * Metodo invocato alla selezione di una classe nella select per le colonne di bootstrap
+     * da usare nella visualizzazione del campo. Questa funzione manipola la sorgente dati per
+     * la eqp-select in modo da escludere i valori dell'enumeratore che fanno riferimento ad
+     * una larghezza di schermo già selezionata. Esempio: per gli schermi piccoli (sm) l'utente
+     * seleziona la classe "col-sm-6", al change del valore questo metodo rimuove dalla select
+     * tutti gli altri valori per la grandezza di schermo selezionata.
+     */
+    onColSpanSizeSelect() {
+        // Recupero l'array degli oggetti chiave-valore che rappreseta l'enumeratore
+        let colSizeClassEnumArray = this.enumHelper.getEnumArray(ColSpanSizesEnum, false, null);
+        // Costruisco l'array delle classi selezionate dall'utente in formato stringa
+        let selectedDimensionsCompilazione = this.field.ColSpanSizes
+            ? this.field.ColSpanSizes.map((col) => ColSpanSizesEnum[col])
+            : [];
+        let selectedDimensionsRisposta = this.field.AnswerStyle.ColSpanSizes
+            ? this.field.AnswerStyle.ColSpanSizes.map((col) => ColSpanSizesEnum[col])
+            : [];
+        // Filtro i valori ottenuti dall'enumeratore per escludere tutti i valori per le
+        // grandezze di schermo già selezionatead esclusione dei valori selezionati.
+        this.availableColSpanSizesCompilazione = colSizeClassEnumArray.filter((value) => !selectedDimensionsCompilazione.find((col) => value.value.includes(col.substring(4, 6)) && value.value != col));
+        this.availableColSpanSizesRisposta = colSizeClassEnumArray.filter((value) => !selectedDimensionsRisposta.find((col) => value.value.includes(col.substring(4, 6)) && value.value != col));
+    }
+    /**
+     * Metodo invocato al cambio del tipo di visualizzazione scelta per i campi di tipo elenco generico.
+     * Se viene scelta la visualizzazione ad immagini svuota la lista delle coppie chiave-valore inserite
+     * in precedenza, altrimenti svuota la lista delle immagini caricate.
+     */
+    onPresentationModeChange() {
+    }
+    /**
+     * Metodo invocato al salvataggio degli allegati quando viene configurato un campo di tipo "Elenco generico"
+     * con il tipo di visualizzazione ad immagini. Intercetta l'elenco aggiornato delle immagini caricate e lo
+     * memorizza nell'oggetto field corrente.
+     * @param attachments Array aggiornato degli allegati caricati.
+     */
+    catchButtonImagesChange(attachments) {
+        this.field.AttachmentList = attachments;
+        this.field.AttachmentList.forEach((attachment) => {
+            if (typeof attachment.ImageHeightPx == "undefined") {
+                var myBase64 = "data:image/" + attachment.FileExtension.toLowerCase() + ";base64," + attachment.FileDataBase64;
+                var img = new Image();
+                img.src = myBase64;
+                var self = this;
+                img.addEventListener('load', function () {
+                    attachment.ImageWidthPx = img.width;
+                    attachment.ImageHeightPx = img.height;
+                    attachment.AttachmentFieldType = AttachmentFieldTypeEnum.ELENCO_IMMAGINI;
+                    if (self.imageSelectorAttachments) {
+                        self.imageSelectorAttachments.reloadData();
+                    }
+                });
+            }
+        });
+    }
+    catchButtonImageChange(attachments) {
+        this.field.DynAttachment = attachments[1];
+        if (this.field.DynAttachment != null && typeof this.field.DynAttachment.ImageHeightPx == "undefined") {
+            var myBase64 = "data:image/" + this.field.DynAttachment.FileExtension.toLowerCase() + ";base64," + this.field.DynAttachment.FileDataBase64;
+            var img = new Image();
+            img.src = myBase64;
+            var self = this;
+            img.addEventListener('load', function () {
+                self.field.DynAttachment.ImageWidthPx = img.width;
+                self.field.DynAttachment.ImageHeightPx = img.height;
+                self.field.DynAttachment.AttachmentFieldType = AttachmentFieldTypeEnum.IMMAGINE;
+            });
+        }
+    }
+    catchButtonImageWithMarkersChange(attachments) {
+        this.field.DynAttachment = attachments[1];
+        if (this.field.DynAttachment != null && typeof this.field.DynAttachment.ImageHeightPx == "undefined") {
+            var myBase64 = "data:image/" + this.field.DynAttachment.FileExtension.toLowerCase() + ";base64," + this.field.DynAttachment.FileDataBase64;
+            var img = new Image();
+            img.src = myBase64;
+            var self = this;
+            img.addEventListener('load', function () {
+                self.field.DynAttachment.ImageWidthPx = img.width;
+                self.field.DynAttachment.ImageHeightPx = img.height;
+                self.field.DynAttachment.AttachmentFieldType = AttachmentFieldTypeEnum.IMMAGINE_CON_MARKERS;
+            });
+        }
+    }
+    /**
+     * Metodo chiamato al keyup degli input testuali che prevedono l'aggiunta del valore inserito in un array.
+     * Se l'utente preme il tasto invio, in base al tipo di campo che sta inserendo/modificando, questo metodo
+     * aggiunge il valore inserito dall'utente nella lista di stringhe corretta (in input viene passato il nome
+     * della proprietà in cui inserire la stringa).
+     * @param event Evento che rappresenta il keyup dell'utente
+     * @param propertyName Nome della proprietà del field in cui inserire la stringa digitata.
+     */
+    onMultiSelectInputKeyup(event, propertyName) {
+        if (event.code === "Enter" || event.code === "NumpadEnter") {
+            switch (this.field.FieldType) {
+                case FieldTypeEnum.Lookup:
+                case FieldTypeEnum.Allegato:
+                    if (!this.field[propertyName]) {
+                        this.field[propertyName] = new Array();
+                    }
+                    this.field[propertyName].push(event.currentTarget.value);
+                    break;
+                case FieldTypeEnum["Immagine con markers"]:
+                    break;
+                case FieldTypeEnum.Immagine:
+                    break;
+                case FieldTypeEnum["Elenco generico"]:
+                    if (!this.keyValueObject.key || !this.keyValueObject.value) {
+                        return;
+                    }
+                    if (!this.field.ValuePairs) {
+                        this.field.ValuePairs = {};
+                    }
+                    this.field.ValuePairs[this.keyValueObject.key] =
+                        this.keyValueObject.value;
+                    this.keyValueObject = { key: "", value: "" };
+                    break;
+            }
+            event.currentTarget.value = null;
+        }
+    }
+    /**
+     * Metodo chiamato per mostrare come elenco le opzioni aggiunte in un campo di tipo "Elenco generico".
+     * @returns Restituisce un array di oggetti del tipo { key: string, value: string } con i valori inseriti dall'utente.
+     */
+    getDictionaryKeyValue() {
+        if (this.field.ValuePairs) {
+            return Object.keys(this.field.ValuePairs).map((k) => {
+                return {
+                    key: k,
+                    value: this.field.ValuePairs[k],
+                };
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * Metodo per rimuovere una opzione aggiunta al campo di tipo "Elenco generico"
+     * @param key Nome della chiave da rimuovere
+     */
+    deleteKeyFromDictionary(key) {
+        delete this.field.ValuePairs[key];
+    }
+    /**
+     * Metodo per aprire il dialog per aggiungere/modificare un metadata in un campo di tipo Allegato o Immagine.
+     * @param metadata Metadata da modificare, se null allora ne sto creando uno nuovo.
+     */
+    // openMetadataDialog(field: BaseField = null) {
+    //   if (field) {
+    //     if (this.field.FieldType === FieldTypeEnum.Allegato) {
+    //       this.indexSelectedMetadata = (this.field as AttachmentField).MetadataFields.indexOf(field);
+    //       this.selectedMetadata = JSON.parse(JSON.stringify(field));
+    //     } else if (this.field.FieldType === FieldTypeEnum.Immagine) {
+    //       this.indexSelectedMetadata = (this.field as ImageField).AttachDefinition.MetadataFields.indexOf(field);
+    //       this.selectedMetadata = JSON.parse(JSON.stringify(field));
+    //     }
+    //   } else {
+    //     this.selectedMetadata = new BaseField();
+    //     this.indexSelectedMetadata = null;
+    //   }
+    //   this.dialogMetadataRef = this.dialog.open(this.dialogMetadata, {
+    //     disableClose: true,
+    //     hasBackdrop: true,
+    //     width: '75%'
+    //   });
+    // }
+    //#region openFormulaDialog
+    openFormulaDialog() {
+        this.dialogFormulaRef = this.dialog.open(this.dialogFormula, {
+            disableClose: true,
+            hasBackdrop: true,
+            width: "75%",
+            data: {
+                fields: this.availableFields,
+                formula: this.field.Formula,
+            },
+        });
+        this.dialogFormulaRef.afterClosed().subscribe((result) => {
+            this.field.Formula = result.formula.toString() == "" ? null : result.formula.toString();
+        });
+    }
+    //#endregion openFormulaDialog
+    //#region openVisibleIfDialog
+    openVisibleIfDialog() {
+        this.dialogVisibleIfRef = this.dialog.open(this.dialogFormula, {
+            disableClose: true,
+            hasBackdrop: true,
+            width: "75%",
+            data: {
+                fields: this.availableFields,
+                formula: this.field.VisibleIf,
+            },
+        });
+        this.dialogVisibleIfRef.afterClosed().subscribe((result) => {
+            this.field.VisibleIf = result.formula.toString() == "" ? null : result.formula.toString();
+        });
+    }
+    //#endregion openVisibleIfDialog
+    //#region openAnswerStyleVisibleIfDialog
+    openAnswerStyleVisibleIfDialog() {
+        this.dialogVisibleIfRef = this.dialog.open(this.dialogFormula, {
+            disableClose: true,
+            hasBackdrop: true,
+            width: "75%",
+            data: {
+                fields: this.availableFields,
+                formula: this.field.AnswerStyle.VisibleIf,
+            },
+        });
+        this.dialogVisibleIfRef.afterClosed().subscribe((result) => {
+            this.field.AnswerStyle.VisibleIf = result.formula.toString() == "" ? null : result.formula.toString();
+        });
+    }
+    //#endregion openAnswerStyleVisibleIfDialog
+    stringSanitizer(value) {
+        if (!UtilityHelperService.stringCheckParentesis(value)) {
+            // alert("errore!");
+        }
+    }
+    /**
+     * Metodo invocato dall'output dal dialog per aggiungere/modificare un metadata
+     * nei campi di tipo Allegato o Immagine. Prima di aggiungere il metadata nell'elenco
+     * contolla se esiste un altro metadata con lo stesso nome e nel caso genera un errore
+     * (i metadata, come per i campi della form, devono avere un nome univoco).
+     * @param metadata Metadata aggiunto o modificato, se null allora il dialog è stato chiuso senza fare modifiche.
+     */
+    // onSaveMetadata(metadata: BaseField) {
+    //   if (metadata) {
+    //     if (
+    //       (this.field.FieldType === FieldTypeEnum.Allegato
+    //         && (this.field as AttachmentField).MetadataFields
+    //         && (this.field as AttachmentField).MetadataFields.find(
+    //           (m, i) => m.Label === metadata.Label
+    //             && (this.indexSelectedMetadata == null ? true : this.indexSelectedMetadata !== i)
+    //         )
+    //       ) ||
+    //       (this.field.FieldType === FieldTypeEnum.Immagine
+    //         && (this.field as ImageField).AttachDefinition.MetadataFields
+    //         && (this.field as ImageField).AttachDefinition.MetadataFields.find(
+    //           (m, i) => m.Label === metadata.Label
+    //             && (this.indexSelectedMetadata == null ? true : this.indexSelectedMetadata !== i)
+    //         )
+    //       )
+    //     ) {
+    //       EqpDynamicModuleDialogService.Warning('Impossibile inserire due metadata con la stessa label.');
+    //       throw new Error('Impossibile inserire due metadata con la stessa label.');
+    //     }
+    //     if (this.indexSelectedMetadata != null && this.indexSelectedMetadata >= 0) {
+    //       if (this.field.FieldType === FieldTypeEnum.Allegato) {
+    //         (this.field as AttachmentField).MetadataFields[this.indexSelectedMetadata] = metadata;
+    //       } else if (this.field.FieldType === FieldTypeEnum.Immagine) {
+    //         (this.field as ImageField).AttachDefinition.MetadataFields[this.indexSelectedMetadata] = metadata;
+    //       }
+    //     } else {
+    //       if (this.field.FieldType === FieldTypeEnum.Allegato) {
+    //         if (!(this.field as AttachmentField).MetadataFields) {
+    //           (this.field as AttachmentField).MetadataFields = new Array<BaseField>();
+    //         }
+    //         (this.field as AttachmentField).MetadataFields.push(metadata);
+    //       } else if (this.field.FieldType === FieldTypeEnum.Immagine) {
+    //         if (!(this.field as ImageField).AttachDefinition.MetadataFields) {
+    //           (this.field as ImageField).AttachDefinition.MetadataFields = new Array<BaseField>();
+    //         }
+    //         (this.field as ImageField).AttachDefinition.MetadataFields.push(metadata);
+    //       }
+    //     }
+    //   }
+    //   this.dialogMetadataRef.close();
+    //   this.setMetadataOrdinalPosition();
+    //   this.reloadMetadataTable();
+    // }
+    //#region disableSaveField
+    /**
+     * Metodo per disabilitare il pulsante per salvare il campo inserito/modificato.
+     * @returns Restituisce un booleano, se true il salvataggio viene disabilitato.
+     */
+    disableSaveField() {
+        if (this.fieldFormGroup.invalid) {
+            return true;
+        }
+        switch (this.field.FieldType) {
+            case FieldTypeEnum["Elenco generico"]:
+                if (this.field.Formula != undefined &&
+                    this.field.Formula != "") {
+                    if (!this.field.ValuePairs) {
+                        this.field.ValuePairs = {};
+                    }
+                    return false;
+                }
+                if (this.field.ValueString != undefined &&
+                    this.field.ValueString != null &&
+                    this.field.ValueString != "") {
+                    return false;
+                }
+                return (!this.field.ValuePairs ||
+                    this.field.ValuePairs.length === 0);
+            case FieldTypeEnum["Elenco immagini"]:
+                return (!this.field.AttachmentList ||
+                    this.field.AttachmentList.length === 0 ||
+                    this.field.AttachmentList.find((i) => (i.ButtonKey == null || i.ButtonKey === "undefined" || i.ButtonKey == '') || (i.ButtonValue == null || i.ButtonValue === "undefined" || i.ButtonValue == '')) != null);
+            case FieldTypeEnum.Lookup:
+                return (!this.field.FieldNames ||
+                    this.field.FieldNames.length === 0);
+            default:
+                return false;
+        }
+    }
+    //#endregion disableSaveField
+    //#region saveAndExitAddField
+    /**
+     * Metodo per salvare il campo inserito/modificato.
+     * Se è stato inserito un field con la stessa label viene generato un errore (le label devono essere univoche).
+     * Una volta aggiunto/aggiornato il campo nell'elenco dei Field della Form chiude il dialog e ricarica la tabella
+     * che mostra l'elenco dei campi aggiunti alla form.
+     */
+    saveAndExitAddField(save) {
+        this.setResizedImagesHeightPx();
+        this.setFieldOrdinalPosition();
+        if (this.imageSelectorAttachments) {
+            this.imageSelectorAttachments.reloadData();
+        }
+        if (save) {
+            // retrocompatibilità con valuepairs per Elenco Generico
+            if (this.field.FieldType == FieldTypeEnum["Elenco generico"]) {
+                if ((this.field.Formula && this.field.Formula != "") || (this.field.ValueString && this.field.ValueString != "")) {
+                    this.field.ValuePairs = null;
+                }
+            }
+            if (this.field.FieldType == FieldTypeEnum["Elenco immagini"]) {
+                if ((this.field.AttachmentList.length > 0)) {
+                    this.field.AttachmentList.forEach((attachment) => {
+                        attachment.ResizedImageHeightPx = this.field.ResizedImagesHeightPx;
+                    });
+                }
+            }
+            if (this.field.FieldType == FieldTypeEnum.Immagine) {
+                if ((this.field.DynAttachment != null)) {
+                    this.field.DynAttachment.ResizedImageHeightPx = this.field.ResizedImagesHeightPx;
+                }
+            }
+            if (this.field.FieldType == FieldTypeEnum["Immagine con markers"]) {
+                if ((this.field.DynAttachment != null)) {
+                    this.field.DynAttachment.ResizedImageHeightPx = this.field.ResizedImagesHeightPx;
+                }
+            }
+            GlobalService.debugLog('add-form-field save', this.field);
+            this.saveFieldEvent.emit(this.field);
+        }
+        else {
+            this.saveFieldEvent.emit(null);
+        }
+    }
+    //#endregion saveAndExitAddField
+    //#region restoreBaseFieldProperties
+    /**
+     * Metodo per ripristinare l'oggetto field al cambio del tipo selezionato.
+     * Lascia valorizzate solo le proprietà dell'oggetto BaseField comune a tutti i tipi di campo.
+     */
+    restoreBaseFieldProperties() {
+        if (this.field) {
+            const tmpBaseField = JSON.parse(JSON.stringify(this.field));
+            this.field = new BaseField();
+            this.field.Label = tmpBaseField.Label;
+            this.field.Description = tmpBaseField.Description;
+            this.field.Required = tmpBaseField.Required;
+            this.field.FieldType = tmpBaseField.FieldType;
+            this.field.Formula = tmpBaseField.Formula;
+            this.field.ColSpanSizes = tmpBaseField.ColSpanSizes;
+            this.field.InListView = tmpBaseField.InListView;
+            this.field.Invisibility = tmpBaseField.Invisibility;
+            this.field.Tooltip = tmpBaseField.Tooltip;
+            this.field.Readonly = tmpBaseField.Readonly;
+            this.field.FieldGroup = tmpBaseField.FieldGroup;
+            this.field.VisibleIf = tmpBaseField.VisibleIf;
+        }
+    }
+    //#region restoreBaseFieldProperties
+    countValuePairs(valuePairs) {
+        if (valuePairs) {
+            return Object.keys(valuePairs).length;
+        }
+        else {
+            return 0;
+        }
+    }
+    configureColumns() {
+        // Lista Generica di immagini
+        this.configColumnListImages = [];
+        this.configColumnListImages.push({
+            key: 'action', display: '', type: TypeColumn.MenuAction, buttonMenuIcon: 'more_vert', styles: { flex: '0 0 6%' },
+            actions: [
+                { name: 'Elimina', icon: 'delete', fn: (element, index, col) => this.deleteListImage(element, index, col) },
+                {
+                    name: "Sposta su",
+                    icon: "arrow_upward",
+                    fn: (element, index, col) => this.moveElement(element, true),
+                    disabled: (element) => this.field.AttachmentList.indexOf(element) === 0,
+                },
+                {
+                    name: "Sposta giù",
+                    icon: "arrow_downward",
+                    fn: (element, index, col) => this.moveElement(element, false),
+                    disabled: (element) => this.field.AttachmentList.indexOf(element) >= this.field.AttachmentList.length - 1,
+                },
+            ]
+        });
+        this.configColumnListImages.push({
+            key: "FileDataBase64",
+            display: "Immagine",
+            type: TypeColumn.ExternalTemplate,
+            externalTemplate: this.GenericListImagesImageTemplate,
+        });
+        this.configColumnListImages.push({
+            key: "ButtonKey",
+            display: "Chiave",
+            type: TypeColumn.ExternalTemplate,
+            externalTemplate: this.GenericListImagesKeyTemplate,
+        });
+        this.configColumnListImages.push({
+            key: "ButtonValue",
+            display: "Valore",
+            type: TypeColumn.ExternalTemplate,
+            externalTemplate: this.GenericListImagesValueTemplate,
+        });
+        this.configColumnListImages.push({
+            key: "ImageWidthPx",
+            display: "Larghezza"
+        });
+        this.configColumnListImages.push({
+            key: "ImageHeightPx",
+            display: "Altezza"
+        });
+    }
+    moveElement(element, moveUp) {
+        const startingIndex = this.field.AttachmentList.indexOf(element);
+        const endingIndex = startingIndex + (moveUp ? -1 : 1);
+        this.field.AttachmentList.splice(startingIndex, 1);
+        this.field.AttachmentList.splice(endingIndex, 0, element);
+        this.setFieldOrdinalPosition();
+        if (this.imageSelectorAttachments) {
+            this.imageSelectorAttachments.reloadData();
+        }
+    }
+    setFieldOrdinalPosition() {
+        if (this.field.AttachmentList) {
+            this.field.AttachmentList.forEach((field) => {
+                field.OrdinalPosition = this.field.AttachmentList.indexOf(field);
+            });
+        }
+    }
+    setResizedImagesHeightPx() {
+        this.resizedImagesHeightPx = this.field.ResizedImagesHeightPx;
+    }
+    deleteListImage(el, i, col) {
+        EqpDynamicModuleDialogService.Confirm('Eliminare questa immagine?', () => {
+            this.field.AttachmentList.splice(el.originalIndex, 1);
+            if (this.imageSelectorAttachments) {
+                this.imageSelectorAttachments.reloadData();
+            }
+        }, false, 'Richiesta conferma');
+    }
+    deleteImage(el) {
+        this.field.DynAttachment = null;
+    }
+    // DB GETTER
+    openDBGetter() {
+        if (this.QueryEditorComponent != null && !this.QueryEditorComponent.inputParams.useDynamicModuleMock) {
+            this.QueryEditorComponent.inputParams.config.mode = QueryEditorModeEnum.COMPOSER;
+            this.QueryEditorComponent.inputParams.config.loadQueryStatuses = this.field.DataGetter.DataGetterValue;
+            this.dialogQERef = this.dialog.open(this.dialogQE, {
+                disableClose: true,
+                hasBackdrop: true,
+                panelClass: 'query-editor-modal',
+                width: '90%'
+            });
+        }
+        else {
+            this.httpClient.get('./assets/mockups/mockedFromQueryEditor_QUERY_WITH_QUESTION.txt', { responseType: 'text' })
+                .subscribe(mockedFromQueryEditor => {
+                this.treatDataFromQueryEditor(JSON.parse(mockedFromQueryEditor).Params);
+            });
+        }
+    }
+    closeQEModal() {
+        this.dialogQERef.close();
+    }
+    onExternalComponentOut(ev) {
+        if (ev.Behaviours.indexOf("send-out") != -1) {
+            this.out.emit(ev);
+        }
+        if (ev.Behaviours.indexOf("close-modal") != -1) {
+            this.closeQEModal();
+        }
+        if (ev.Behaviours.indexOf("save-query") != -1) {
+            this.treatDataFromQueryEditor(ev.Params);
+        }
+    }
+    treatDataFromQueryEditor(data) {
+        this.field.DataGetter.DataGetterValue = data;
+        this.createColumnKeys(data);
+    }
+    createColumnKeys(data) {
+        if (data == null && this.field.DataGetter.DataGetterValue != null) {
+            data = this.field.DataGetter.DataGetterValue;
+        }
+        if (data != null && typeof data != "undefined" && typeof data.selectedFields != "undefined") {
+            this.columnKeys = new Array();
+            data.selectedFields.forEach((key) => {
+                this.columnKeys.push({ key: key.DatabaseTableName + "_" + key.PropertyName + "__" + key.CurrentTranslate.replace(" ", "_"), value: key.CurrentTranslate });
+            });
+        }
+    }
+    getAllModules() {
+        const dynamicModuleParams = new Array();
+        dynamicModuleParams.push({
+            ParamName: "orgaid",
+            ParamValue: this.form.OrgaID,
+            ParamType: ParamTypeEnum["Query param"],
+        });
+        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Forms.GetAllFormEndPoint, dynamicModuleParams, (res) => {
+            this.forms = res;
+            this.forms = this.forms.sort((uno, due) => uno.Name.localeCompare(due.Name));
+            this.DMField = null;
+            if (this.DMModule == null && this.field.DataGetter.DataGetterValue != null) {
+                this.DMModule = this.forms.find(x => x.Code == this.field.DataGetter.DataGetterValue);
+                this.DMModule.Fields = JSON.parse(this.DMModule.JsonFields);
+                this.DMFields = new Array();
+                this.DMModule.Fields.forEach(element => {
+                    this.DMFields.push({ key: element.Value.Name });
+                });
+                this.DMFields = this.DMFields.sort((uno, due) => uno.key.localeCompare(due.key));
+                if (this.field.DataGetter.DataGetterColumnForce != null) {
+                    this.DMField = this.DMFields.find(x => x.key == this.field.DataGetter.DataGetterColumnForce);
+                }
+            }
+        }, (err) => { });
+    }
+    onChangeDMModule() {
+        console.log("this.DMModule", this.DMModule, this.field.DataGetter.DataGetterValue);
+        if (this.DMModule != null) {
+            this.DMModule.Fields = JSON.parse(this.DMModule.JsonFields);
+            this.DMFields = new Array();
+            this.DMModule.Fields.forEach(element => {
+                this.DMFields.push({ key: element.Value.Name });
+            });
+            this.field.DataGetter.DataGetterValue = this.DMModule.Code;
+        }
+        else {
+            this.DMModule = null;
+            this.field.DataGetter.DataGetterValue = null;
+            this.DMField = null;
+            this.field.DataGetter.DataGetterColumnForce = null;
+        }
+    }
+    onChangeDMField() {
+        if (this.DMField != null) {
+            this.field.DataGetter.DataGetterColumnForce = this.DMField.key;
+        }
+        else {
+            this.field.DataGetter.DataGetterColumnForce = null;
+        }
+    }
+    onChangeDMContestualization() {
+        console.log("onChangeDMContestualization()", this.field.DataGetter.DataGetterContestualization);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AddFormFieldComponent, deps: [{ token: i1.UntypedFormBuilder }, { token: i2.EnumHelper }, { token: i3.MatDialog }, { token: i0.ChangeDetectorRef }, { token: i4.HttpClient }, { token: i5.UtilityHelperService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AddFormFieldComponent, selector: "eqp-dynamic-module-add-form-field", inputs: { form: "form", endPointConfiguration: "endPointConfiguration", field: "field", indexField: "indexField", formFieldsGroups: "formFieldsGroups", availableFields: "availableFields", fieldTypesToExclude: "fieldTypesToExclude", QueryEditorComponent: "QueryEditorComponent", contestualization: "contestualization" }, outputs: { out: "out", saveFieldEvent: "saveFieldEvent" }, viewQueries: [{ propertyName: "textFieldFormTemplate", first: true, predicate: ["textFieldFormTemplate"], descendants: true, static: true }, { propertyName: "labelFieldFormTemplate", first: true, predicate: ["labelFieldFormTemplate"], descendants: true, static: true }, { propertyName: "textareaFieldFormTemplate", first: true, predicate: ["textareaFieldFormTemplate"], descendants: true, static: true }, { propertyName: "booleadFieldFormTemplate", first: true, predicate: ["booleadFieldFormTemplate"], descendants: true, static: true }, { propertyName: "dateFieldFormTemplate", first: true, predicate: ["dateFieldFormTemplate"], descendants: true, static: true }, { propertyName: "numericFieldFormTemplate", first: true, predicate: ["numericFieldFormTemplate"], descendants: true, static: true }, { propertyName: "attachmentFieldFormTemplate", first: true, predicate: ["attachmentFieldFormTemplate"], descendants: true, static: true }, { propertyName: "imageFieldFormTemplate", first: true, predicate: ["imageFieldFormTemplate"], descendants: true, static: true }, { propertyName: "imageWithMarkersFieldFormTemplate", first: true, predicate: ["imageWithMarkersFieldFormTemplate"], descendants: true, static: true }, { propertyName: "imageFieldSelectorFormTemplate", first: true, predicate: ["imageFieldSelectorFormTemplate"], descendants: true, static: true }, { propertyName: "listValueFieldFormTemplate", first: true, predicate: ["listValueFieldFormTemplate"], descendants: true, static: true }, { propertyName: "lookupFieldFormTemplate", first: true, predicate: ["lookupFieldFormTemplate"], descendants: true, static: true }, { propertyName: "dataGetterTemplate", first: true, predicate: ["dataGetterTemplate"], descendants: true, static: true }, { propertyName: "dialogFormula", first: true, predicate: ["dialogFormula"], descendants: true, static: true }, { propertyName: "buttonImagesKeyValueInputColumn", first: true, predicate: ["buttonImagesKeyValueInputColumn"], descendants: true, static: true }, { propertyName: "GenericListImagesImageTemplate", first: true, predicate: ["GenericListImagesImageTemplate"], descendants: true, static: true }, { propertyName: "GenericListImagesKeyTemplate", first: true, predicate: ["GenericListImagesKeyTemplate"], descendants: true, static: true }, { propertyName: "GenericListImagesValueTemplate", first: true, predicate: ["GenericListImagesValueTemplate"], descendants: true, static: true }, { propertyName: "imageSelectorAttachments", first: true, predicate: ["imageSelectorAttachments"], descendants: true }, { propertyName: "imageAttachment", first: true, predicate: ["imageAttachment"], descendants: true }, { propertyName: "dialogQE", first: true, predicate: ["dialogQE"], descendants: true, static: true }], ngImport: i0, template: "<!-- <div class=\"add-form-field bigwrapper\" style=\"max-height: 100vh !important; overflow-x: hidden; overflow-y: auto;\"> -->\r\n\r\n<mat-card class=\"add-form-field\">\r\n    <mat-card-header>\r\n        <mat-card-title>\r\n            {{indexField != null && indexField >= 0 ? \"Modifica\" : \"Aggiungi\"}} campo\r\n        </mat-card-title>\r\n    </mat-card-header>\r\n\r\n    <mat-card-content>\r\n\r\n        <div class=\"container-fluid containerContent \">\r\n            <form [formGroup]=\"fieldFormGroup\" style=\"height: 100%;\">\r\n                <!--#region AREA PRINCIPALE -->\r\n                <div class=\"row eqp-dform-add-form-field-main\">\r\n                    <!--#region TIPO CAMPO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2 tipoCampo\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldType'].status != 'VALID' && fieldFormGroup.controls['FieldType'].touched }\">\r\n                            Tipo campo *\r\n                        </mat-label>\r\n                        <eqp-select [enumData]=\"FieldTypeEnum\" [(ngModelInput)]=\"field.FieldType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onFieldTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'FieldType'\"\r\n                            [enumDataToExclude]=\"fieldTypesToExclude\">\r\n                        </eqp-select>\r\n                    </div>\r\n                    <!--#endregion TIPO CAMPO -->\r\n\r\n                    <!--#region CODICE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Label'].status != 'VALID' && fieldFormGroup.controls['Label'].touched }\">\r\n                            Codice *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input formControlName=\"Label\" required matInput [(ngModel)]=\"field.Label\"\r\n                                (keypress)=\"omit_special_char($event)\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (focusout)=\"stringSanitizer(field.Label)\">\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Label') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['pattern']\">\r\n                                        Si possono inserire solo lettere a-z\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion CODICE -->\r\n\r\n                    <!--#region DESCRIZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Description'].status != 'VALID' && fieldFormGroup.controls['Description'].touched }\">\r\n                            Descrizione *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input name=\"Description\" formControlName=\"Description\" required matInput\r\n                                [(ngModel)]=\"field.Description\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Description)\">\r\n                            <!-- <mat-error *ngIf=\"!field.Description.valid && field.FormFormGroup.controls[field.Description].touched\"> -->\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Description') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion DESCRIZIONE -->\r\n\r\n                    <!--#region SEZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\" *ngIf=\"formFieldsGroups\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldGroup'].status != 'VALID' && fieldFormGroup.controls['FieldGroup'].touched }\">Sezione\r\n                            *</mat-label>\r\n                        <eqp-select [arrayData]=\"formFieldsGroups\" [(ngModelInput)]=\"field.FieldGroup\"\r\n                            [arrayKeyProperty]=\"'Name'\" [arrayValueProperty]=\"'Name'\" [formGroupInput]=\"fieldFormGroup\"\r\n                            [formControlNameInput]=\"'FieldGroup'\" required>\r\n                        </eqp-select>\r\n                        <mat-error>\r\n                            <!-- {{ getFormValidationErrors('FieldGroup') }} -->\r\n                            <ul>\r\n                                <li *ngIf=\"fieldFormGroup.controls['FieldGroup'].errors?.['required']\">\r\n                                    Obbligatorio\r\n                                </li>\r\n                            </ul>\r\n                        </mat-error>\r\n                    </div>\r\n                    <!--#endregion SEZIONE -->\r\n\r\n                    <!--#region OBBLIGATORIO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Required\" formControlName=\"Required\"\r\n                            color=\"primary\">\r\n                            Obbligatorio\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion OBBLIGATORIO -->\r\n\r\n                    <!--#region READONLY -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Readonly\" formControlName=\"Readonly\"\r\n                            color=\"primary\">\r\n                            ReadOnly\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion READONLY -->\r\n\r\n                </div>\r\n                <!--#endregion AREA PRINCIPALE -->\r\n\r\n                <!--#region AREA TABS -->\r\n                <mat-tab-group class=\"eqp-dform-add-form-field-tabs\" mat-stretch-tabs=\"false\" mat-align-tabs=\"start\">\r\n                    <!--#region STILE COMPILAZIONE -->\r\n                    <mat-tab label=\"Stile Compilazione\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesCompilazione\" [(ngModelInput)]=\"field.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'ColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"LabelstyleCSS\" formControlName=\"LabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['LabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"FieldstyleCSS\" formControlName=\"FieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['FieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n                        \r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.VisibleIf != null || field.VisibleIf != undefined) && field.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.InListView\" formControlName=\"InListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['InListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n\r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilit\u00E0 del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'Invisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.VisibleIf\" (click)=\"openVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['VisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                            <!--#region TOOLTIP -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Tooltip </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"Tooltip\" formControlName=\"Tooltip\" matInput [(ngModel)]=\"field.Tooltip\"\r\n                                        spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.Tooltip)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Tooltip') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion TOOLTIP -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE COMPILAZIONE -->\r\n\r\n                    <!--#region STILE DELLA RISPSOTA -->\r\n                    <mat-tab label=\"Stile Risposta\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesRisposta\" [(ngModelInput)]=\"field.AnswerStyle.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleLabelstyleCSS\" formControlName=\"AnswerStyleLabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleLabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleFieldstyleCSS\" formControlName=\"AnswerStyleFieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleFieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n\r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.AnswerStyle.VisibleIf != null || field.AnswerStyle.VisibleIf != undefined) && field.AnswerStyle.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.AnswerStyle.InListView\" formControlName=\"AnswerStyleInListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['AnswerStyleInListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n                            \r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.AnswerStyle.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilit\u00E0 del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.AnswerStyle.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleInvisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleVisibleIf\" formControlName=\"AnswerStyleVisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.VisibleIf\" (click)=\"openAnswerStyleVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleVisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE DELLA RISPSOTA -->\r\n\r\n                    <!--#region SPECIFICHE -->\r\n                    <mat-tab label=\"Specifiche\">\r\n                        <div class=\"row\">\r\n                            <ng-container *ngTemplateOutlet=\"fieldTypeFormTemplate\">\r\n                            </ng-container>\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion SPECIFICHE -->\r\n\r\n                    <!--#region MODALITA' RECUPERO DATI -->\r\n                    <mat-tab label=\"Modalit\u00E0 recupero dati\">\r\n                        <div class=\"row\">\r\n\r\n\r\n\r\n                            <eqp-select [enumData]=\"dataGetterTypeEnum\" [(ngModelInput)]=\"field.DataGetter.DataGetterType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onDataGetterTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DataGetterType'\">\r\n                            </eqp-select>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Manuale\">\r\n                                <mat-label> Valore di Default </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"DataGetterValue\" matInput [(ngModel)]=\"field.DataGetter.DataGetterValue\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\">\r\n                                </mat-form-field>  \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Formula\">\r\n                                <mat-label> Formula (Javascript) </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"Formula\" matInput [(ngModel)]=\"field.Formula\"\r\n                                        (click)=\"openFormulaDialog()\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formula)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Formula') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field> \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da database']\">\r\n                                \r\n                                <div class=\"col-12 mt-4 configuraQueryEditor\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-10\">Configura in Query Editor</div>\r\n                                        <div class=\"col-2\">\r\n                                            <button class=\"btn btn-primary\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue == null\">Procedi</button>\r\n                                            <button class=\"btn btn-success\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue != null\">Modifica</button>\r\n                                        </div>\r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Seleziona colonna</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"columnKeys\" [(ngModelInput)]=\"field.DataGetter.DataGetterColumnForce\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                            [showCancelButton]=\"true\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                \r\n                                </div>\r\n                                \r\n                        \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da modulo dinamico']\">\r\n                                \r\n                                <div class=\"col-12 mt-4\" *ngIf=\"forms.length > 0\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-6\">Modulo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona modulo'\" [arrayData]=\"forms\" [(ngModelInput)]=\"DMModule\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'Code'\" [arrayValueProperty]=\"'Name'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMModule'\"\r\n                                            (ngModelInputChange)=\"onChangeDMModule()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null && DMModule != null\">\r\n                                        <div class=\"col-6\">Campo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona campo'\" [arrayData]=\"DMFields\" [(ngModelInput)]=\"DMField\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'key'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMField'\"\r\n                                            (ngModelInputChange)=\"onChangeDMField()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Cardinalit\u00E0</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [enumData]=\"DMGetterCardinalities\" [(ngModelInput)]=\"field.DataGetter.DataGetterCardinality\"\r\n                                            [showCancelButton]=\"false\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>         \r\n                                    \r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Contestualizzazione</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"contestualization\" [arrayKeyProperty]=\"'entityTableName'\" [arrayValueProperty]=\"'entityTableName'\" [(ngModelInput)]=\"field.DataGetter.DataGetterContestualization\"\r\n                                            [showCancelButton]=\"true\" (ngModelInputChange)=\"onChangeDMContestualization()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>                                      \r\n                                \r\n                                </div>\r\n\r\n                            </div>\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion MODALITA' RECUPERO DATI -->\r\n\r\n                </mat-tab-group>\r\n                <!--#region AREA TABS -->\r\n\r\n                <!--#region listValueFieldFormTemplate vallues -->\r\n                \r\n                <!--#endregion listValueFieldFormTemplate vallues -->\r\n\r\n            </form>\r\n        </div>\r\n    </mat-card-content>\r\n\r\n    <mat-card-footer>\r\n\r\n        <div class=\"d-flex justify-content-end mt-2 mb-1 me-3\"> \r\n            <!-- <div class=\"buttonsForma\"> -->\r\n            <button class=\"btn mat-raised-button cancel\" (click)=\"saveAndExitAddField(false)\" type=\"button\">\r\n                Annulla\r\n            </button>\r\n            <span class=\"me-2\"></span>\r\n            <button class=\"mr-2 save\" mat-raised-button color=\"primary\" (click)=\"saveAndExitAddField(true)\"\r\n                [disabled]=\"disableSaveField()\" type=\"button\">\r\n                Salva\r\n            </button>\r\n            <!-- </div> -->\r\n        </div>\r\n    </mat-card-footer>\r\n</mat-card>\r\n\r\n<!-- </div> -->\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI DI TESTO -->\r\n<ng-template #textFieldFormTemplate>\r\n    <!--#region MASCHERA -->\r\n    <div class=\"col-sm-12 col-md-6\">\r\n        <mat-label>Maschera</mat-label>\r\n        <eqp-select [enumData]=\"TextMaskEnum\" [(ngModelInput)]=\"field.TextMask\" [formGroupInput]=\"fieldFormGroup\"\r\n            [formControlNameInput]=\"'TextMask'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion MASCHERA -->\r\n\r\n    <!--#region SPEECH TO TEXT -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SPEECH TO TEXT -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MinLenght'].status != 'VALID' && fieldFormGroup.controls['MinLenght'].touched }\">\r\n            Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MaxLenght'].status != 'VALID' && fieldFormGroup.controls['MaxLenght'].touched }\">\r\n            Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI DI TESTO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 ETICHETTA -->\r\n<ng-template #labelFieldFormTemplate>\r\n\r\n    <!--#region ETICHETTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-form-field>\r\n\r\n            <textarea name=\"Etichetta\" placeholder=\"Etichetta\" matInput formControlName=\"Etichetta\" [(ngModel)]=\"field.Etichetta\"></textarea>\r\n\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion ETICHETTA -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 ETICHETTA -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI AREA DI TESTO -->\r\n<ng-template #textareaFieldFormTemplate>\r\n    <!--#region RIGHE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Righe </mat-label>\r\n        <mat-form-field class=\"righe\">\r\n            <input id=\"rows\" formControlName=\"Rows\" type=\"number\" [min]=\"0\" matInput [(ngModel)]=\"field.Rows\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.Rows)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Rows') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion RIGHE -->\r\n\r\n    <!--#region SpeechToText -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SpeechToText -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI AREA DI TESTO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI BOOLEANI -->\r\n<ng-template #booleadFieldFormTemplate>\r\n    <!--#region A TRE STATI -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsTristate\" formControlName=\"IsTristate\" color=\"primary\">\r\n            A tre stati\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion A TRE STATI -->\r\n\r\n    <!--#region TIPO PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di presentazione *</mat-label>\r\n        <eqp-select [enumData]=\"BoolPresentantioEnum\" [(ngModelInput)]=\"field.PresetationType\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresetationType'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO PRESENTAZIONE -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI BOOLEANI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI DATA -->\r\n<ng-template #dateFieldFormTemplate>\r\n    <!--#region TIPO DI DATA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di data</mat-label>\r\n        <eqp-select [enumData]=\"DateTimeTypeEnum\" [(ngModelInput)]=\"field.IsOnlyDate\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'IsOnlyDate'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI DATA -->\r\n\r\n    <!--#region FORMATO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Formato </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DateFormat\" matInput [(ngModel)]=\"field.DateFormat\"\r\n                [matTooltip]=\"'Indicare il formato seguendo la guida del pacchetto momentjs.'\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formato)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Formato') }} -->\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion FORMATO -->\r\n\r\n    <!--#region DATA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data minima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MINIMA -->\r\n\r\n    <!--#region DATA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data massima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI DATA -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI NUMERICI -->\r\n<ng-template #numericFieldFormTemplate>\r\n    <!--#region VALORE INTERO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsInteger\" formControlName=\"IsInteger\" color=\"primary\">\r\n            Valore intero\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion VALORE INTERO -->\r\n\r\n    <!--#region SEPARATORE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalSeparator\" matInput [(ngModel)]=\"field.DecimalSeparator\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.DecimalSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['pattern']\">\r\n                        Non \u00E8 possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE DECIMALI -->\r\n\r\n    <!--#region PRECISIONE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Precisione decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalPrecision\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.DecimalPrecision\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.DecimalPrecision)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalPrecision') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion PRECISIONE DECIMALI -->\r\n\r\n    <!--#region SEPARATORE MIGLIAIA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore migliaia </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"ThousandsSeparator\" matInput [(ngModel)]=\"field.ThousandsSeparator\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.ThousandsSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('ThousandsSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['pattern']\">\r\n                        Non \u00E8 possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE MIGLIAIA -->\r\n\r\n    <!--#region SIMBOLO VALUTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo prima del valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Simbolo valuta </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"CurrencySymbol\" matInput [(ngModel)]=\"field.CurrencySymbol\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.CurrencySymbol)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('CurrencySymbol') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['CurrencySymbol'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SIMBOLO VALUTA -->\r\n\r\n    <!--#region UNITA DI MISURA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo dopo il valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Unit\u00E0 di misura </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MeasureUnit\" matInput [(ngModel)]=\"field.MeasureUnit\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.MeasureUnit)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MeasureUnit') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MeasureUnit'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion UNITA DI MISURA -->\r\n\r\n    <!--#region VALORE MINIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore minimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MinValue\" type=\"number\" matInput [(ngModel)]=\"field.MinValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinValue') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MINIMO -->\r\n\r\n    <!--#region VALORE MASSIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore massimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MaxValue\" type=\"number\" matInput [(ngModel)]=\"field.MaxValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxValue') }}  -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MASSIMO -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI NUMERICI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI ALLEGATO -->\r\n<ng-template #attachmentFieldFormTemplate>\r\n    <!--#region ALLEGATI MULTIPLI -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiAttach\" formControlName=\"IsMultiAttach\" color=\"primary\">\r\n            Allegati multipli\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion ALLEGATI MULTIPLI -->\r\n\r\n    <!--#region ESTENSIONI ACCETTATE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Estensioni accettate</mat-label>\r\n        <eqp-select [arrayData]=\"AvailableFileExtensions.concat(AvailableImageExtensions)\"\r\n            [(ngModelInput)]=\"field.AllowedExtensions\" [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n            [isMultiSelect]=\"true\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AllowedExtensions'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion ESTENSIONI ACCETTATE -->\r\n\r\n    <!-- <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row mt-2\">\r\n            <div class=\"col-sm-12 col-md-6\">\r\n                <div class=\"header-title-standard\">\r\n                    Elenco metadata\r\n                </div>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-6 text-right buttonsForm\">\r\n                <button class=\"btn btn-primary save\" mat-raised-button color=\"primary\" type=\"button\"\r\n                    (click)=\"openMetadataDialog()\">\r\n                    <mat-icon>add</mat-icon>\r\n                    <span style=\"margin-left: 10px;\">Aggiungi allegato</span>\r\n                </button>\r\n            </div>\r\n        </div>\r\n        <eqp-table #metadataFieldsTable [createMatCard]=\"false\" [columns]=\"metadataColumns\"\r\n            [data]=\"field.MetadataFields\" [emptyTableMessage]=\"'Nessun metadata inserito'\" [searchText]=\"'Cerca'\">\r\n        </eqp-table>\r\n    </div> -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI ALLEGATO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI LISTA DI VALORI -->\r\n<ng-template #listValueFieldFormTemplate>\r\n    <!--#region SCELTA MULTIPLA -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n            Scelta multipla\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SCELTA MULTIPLA -->\r\n\r\n    <!--#region TIPO DI PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Tipo di presentazione*</mat-label>\r\n        <eqp-select [enumData]=\"ListPresentationEnum\" [(ngModelInput)]=\"field.PresentationMode\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresentationMode'\"\r\n            (ngModelInputChange)=\"onPresentationModeChange()\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI PRESENTAZIONE -->\r\n\r\n\r\n    <!--#region GESTIONE OPZIONI -->\r\n    <div class=\"col-sm-12 mt-2\">\r\n\r\n        <mat-label> area dei valori da inserire </mat-label>\r\n        <mat-form-field>\r\n            <textarea matInput \r\n                placeholder=\"key1|value1;key2|value2\" \r\n                [(ngModel)]=\"field.ValueString\"\r\n                spellcheck=\"false\" \r\n                autocomplete=\"off\"\r\n                >\r\n            </textarea>\r\n        </mat-form-field>\r\n\r\n        <div class=\"row\" *ngIf=\"countValuePairs(field.ValuePairs) > 0\">\r\n            <h4 class=\"key-value-list-section-title\"> </h4>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Label opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.key\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Valore opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.value\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4  align-self-center\">\r\n                <span class=\"mr-3\">Opzioni inserite:</span>\r\n                <ul class=\"value-pairs-list\">\r\n                    <li *ngFor=\"let keyValuePair of getDictionaryKeyValue()\">\r\n                        <mat-icon class=\"mr-1\" (click)=\"deleteKeyFromDictionary(keyValuePair.key)\">close\r\n                        </mat-icon>\r\n                        <span><b>Label: </b> {{keyValuePair.key}} - <b>Valore: </b> {{keyValuePair.value}}</span>\r\n                    </li>\r\n                </ul>\r\n            </div>\r\n        </div> \r\n\r\n    </div>    \r\n    <!--#endregion GESTIONE OPZIONI -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI LISTA DI VALORI -->\r\n\r\n\r\n\r\n\r\n<!--#region FORM LISTA IMMAGINI -->\r\n<ng-template #imageFieldSelectorFormTemplate>\r\n\r\n    <div class=\"row\">\r\n        <div class=\"col-3 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-3 col-xs-12 col-middle\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n                Scelta multipla\r\n            </mat-slide-toggle>\r\n        </div>        \r\n    </div>\r\n\r\n    <eqp-attachments #imageSelectorAttachments [attachmentsList]=\"field.AttachmentList\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n    [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"true\" [showHeader]=\"false\"\r\n    [allowedTypes]=\"[AttachmentType.FILE]\" (localEditedAttachments)=\"catchButtonImagesChange($event)\"\r\n    [attachmentsColumns]=\"configColumnListImages\">\r\n    </eqp-attachments>\r\n\r\n  \r\n</ng-template>\r\n<!--#endregion FORM LISTA IMMAGINI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI IMMAGINE -->\r\n<ng-template #imageFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.EnableDrawing\" formControlName=\"EnableDrawing\" color=\"primary\">\r\n                Immagine disegnabile?\r\n            </mat-slide-toggle>\r\n        </div>   \r\n    </div>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI IMMAGINE -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI IMMAGINE CON MARKERS -->\r\n<ng-template #imageWithMarkersFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageWithMarkersChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI IMMAGINE CON MARKERS -->\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI LOOKUP -->\r\n<ng-template #lookupFieldFormTemplate>\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.UseAsGetOrDiscard\" formControlName=\"UseAsGetOrDiscard\" color=\"primary\"\r\n            matTooltip=\"Se true la lookup viene visualizzata in una modale per lo scegli scarta\">\r\n            Usa per scegli o scarta\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <div class=\"col-sm-12 col-md-4 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Nome entit\u00E0 </mat-label>\r\n        <mat-form-field matTooltip=\"Nome dell'entit\u00E0 relazionata\">\r\n            <input formControlName=\"EntitySourceName\" required matInput [(ngModel)]=\"field.EntitySourceName\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.EntitySourceName)\">\r\n            <mat-error>\r\n                {{ getFormValidationErrors('EntitySourceName') }}\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row\">\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Nomi dei campi (invio per confermare) </mat-label>\r\n                <mat-form-field\r\n                    matTooltip=\"Elenco di campi ordinato che verr\u00E0 visualizzato nella lookup (premere invio per confermare)\">\r\n                    <input matInput (keyup)=\"onMultiSelectInputKeyup($event, 'FieldNames')\" spellcheck=\"false\"\r\n                        autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-8  align-self-center\">\r\n                <span class=\"mr-3\">Nomi selezionati:</span>\r\n                <div class=\"extension-container\" *ngFor=\"let extension of field.FieldNames; let i = index\">\r\n                    <span>{{extension}}</span>\r\n                    <mat-icon class=\"ml-1\" (click)=\"field.FieldNames.splice(i,1)\">close\r\n                    </mat-icon>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI LOOKUP -->\r\n\r\n<!-- DIALOG PER AGGIUNGERE UN METADATA NEI CAMPI DI TIPO ALLEGATO O IMMAGINE -->\r\n<!-- <ng-template #dialogMetadata>\r\n    <eqp-dynamic-module-add-form-field [field]=\"selectedMetadata\" [availableFields]=\"availableFields\"\r\n        [indexField]=\"indexSelectedMetadata\" (saveFieldEvent)=\"onSaveMetadata($event)\" [fieldTypesToExclude]=\"[6,7,10]\">\r\n    </eqp-dynamic-module-add-form-field>\r\n</ng-template> -->\r\n\r\n<ng-template #buttonImagesKeyValueInputColumn let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> {{col.display}} </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\" required spellcheck=\"false\" autocomplete=\"off\">\r\n    </mat-form-field>\r\n</ng-template>\r\n<!--DIALOG PER SEMPLIFICARE LA SCRITTURA DEL CAMPO FORMULA-->\r\n<ng-template #dialogFormula>\r\n    <eqp-dynamic-module-add-formula-component>\r\n    </eqp-dynamic-module-add-formula-component>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesImageTemplate let-row=\"row\" let-col=\"col\">\r\n    <img src=\"data:image/jpeg;base64, {{row[col.key]}}\" class=\"GenericListImagesImageTemplate\">\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesKeyTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Chiave </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesValueTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Valore </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER QUERY EDITOR -->\r\n<ng-template #dialogQE>\r\n    <ng-template [appDynamicLoader] [data]=\"QueryEditorComponent\" (out)=\"onExternalComponentOut($event);\">\r\n    </ng-template>\r\n</ng-template>\r\n  ", styles: [".mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0,0,.2,1);transform:scale3d(0,0,0);background-color:var(--mat-ripple-color, rgba(0, 0, 0, .1))}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;inset:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity .4s cubic-bezier(.25,.8,.25,1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:#00000052}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0!important;box-sizing:content-box!important;height:auto!important;overflow:hidden!important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0!important;box-sizing:content-box!important;height:0!important}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator:before{inset:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus:before{content:\"\"}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator:before{inset:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus:before{content:\"\"}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-app-background{background-color:var(--mat-app-background-color, transparent);color:var(--mat-app-text-color, inherit)}.add-form-field{max-height:100%;height:100%;overflow:hidden}.add-form-field mat-card-header{min-height:3rem}.add-form-field mat-card-content{height:calc(100% - 6rem);max-height:calc(100% - 6rem);overflow:auto;margin:0;padding:0 2rem 2rem}.add-form-field mat-card-content .eqp-dform-add-form-field-main{height:60%}.add-form-field mat-card-content .eqp-dform-add-form-field-tabs{height:40%}.add-form-field mat-card-footer{min-height:3rem}.extension-container{display:inline-block;font-size:15px;border:1px solid var(--primary);border-radius:15px;margin-right:10px}.extension-container mat-icon{vertical-align:middle;font-size:15px;height:15px;width:15px;color:var(--danger);margin-right:10px;cursor:pointer}.extension-container span{margin-left:10px}.key-value-list-section-title{background:linear-gradient(to right,var(--gray) 0%,rgb(255,255,255) 100%) left bottom #fff no-repeat;background-size:100% 1px}.value-pairs-list{list-style:none;padding:0}.value-pairs-list mat-icon{vertical-align:middle;font-size:15px;height:15px;width:15px;color:var(--danger);margin-right:10px;cursor:pointer}::ng-deep .mat-dialog-container{border-radius:10px}.row.title{background-color:#ebebeb;padding:20px 0 20px 50px}.row.title mat-icon.add{background:#fff;color:#7b7b7b;height:40px;width:40px;border-radius:10px;font-size:27px;padding:7px 6px 6px 7px;margin:0 7px 0 0}.row.title .header-title-standard{display:flex;align-items:center;font-size:19px;font-weight:700;color:gray}.row:not(.title){margin:15px 0 0}form{margin:25px 0 0}.col-middle{display:flex;align-items:center}::ng-deep .mat-select-arrow{color:transparent!important}input[type=number]{-webkit-appearance:textfield;-moz-appearance:textfield;appearance:textfield}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{-webkit-appearance:none}.increasableValues{display:flex}.increasableValues .col-sm-12{display:flex;flex-direction:column;margin:0 3em 0 0}.increasableValues .col-sm-12 .mat-form-field{height:79px;line-height:34px;width:50%}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex{width:230px;border:1px solid #e7e7e9;border-radius:10px;padding:7px 0 0 20px!important;margin-top:10px;background-color:#fff}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex .mat-form-field-infix{display:flex;margin:-10px 0 0}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex .mat-form-field-infix input{margin:0;border:none;height:100%}.increasableValues .col-sm-12 .mat-form-field div.buttons{display:flex;flex-direction:column;margin:-10px 0 0;border-right:1px solid #F4F4F4;padding:10px 14px 0 0}.increasableValues .col-sm-12 .mat-form-field div.buttons button.up{height:17px;width:21px;background:url(/assets/images/arrow.png) no-repeat;background-size:20px;background-position-y:1px;background-position-x:1px;-webkit-transform:rotate(180deg);border:none;opacity:.3;cursor:pointer}.increasableValues .col-sm-12 .mat-form-field div.buttons button.down{height:50px;width:23px;background:url(/assets/images/arrow.png) no-repeat no-repeat;background-size:20px;border:none;opacity:.3;background-position-y:21px;background-position-x:0px;cursor:pointer}.increasableValues .col-sm-12 .mat-form-field input{margin:-14px 0 0 63px;font-size:18px}.second .col-sm-12{margin:0 1em 0 0}.date ::ng-deep mat-form-field .mat-form-field-wrapper .mat-form-field-label-wrapper label{display:none}.date ::ng-deep mat-form-field .mat-form-field-wrapper .mat-form-field-suffix{display:inline}.GenericListImagesImageTemplate{height:100%}.configuraQueryEditor{display:flex;justify-content:center;flex-flow:column}eqp-attachments ::ng-deep div button{padding:5px 35px;background:linear-gradient(to right,#1e31eb,#693dda);border-radius:10px}eqp-attachments ::ng-deep div button span mat-icon{margin-right:5px}eqp-attachments ::ng-deep div button.eqp-attachments-delete-btn{color:#fff}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .row:first-child{padding:20px 40px;background-color:#ebebeb;color:gray;font-size:19px;font-weight:700}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .mat-form-field-label-wrapper label{margin-top:21px;margin-left:25px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .btn-primary[disabled]{padding:7px 35px;border-radius:10px;font-size:14px;background-color:#dbdbdc!important;color:#000;background:none}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .btn-primary:not(disabled){padding:7px 35px;border-radius:10px;font-size:14px;background:linear-gradient(to right,#1e31eb,#693dda);color:#fff}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form button{margin:0 10px 0 0!important;border:1px solid #1E31EB;padding:7px 35px;border-radius:10px;font-size:14px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form button[disabled]{border:none}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .ng-star-inserted .justify-content-center button{padding:4px;margin:0;border:none;left:8px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .row:last-child{padding:50px 20px 20px 0}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper input{background-color:#ebebeb!important;background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA/MAAAPzCAYAAAD7/FyjAABXfklEQVR42uzdd7hddZno8XWSkARCCCSU0AQCAygooJRBEFBEFKQoygPYKBYQNFZEURABhZHRINWhDaAIUgZFECIiDE2qVJGqIB0SOiSk3Psu9hkPkOTk7LPW2nuVz+d5vv/cZ+78cS/v+/vtnL3XShIAAAAAABqtJxoWjYxGRQtFI3r/z3r8Pw8AAAC0J/1gvUy0RrRRtHX0yWif6HvR4dHR0cnRr6LfRH+Iro5ujv4WPRQ9GU2NnoteiqZFM6LZ0f+bT7N7/2dfiV7s/d8xtfd/54PRXdFN0VXR5Oj86IzopOio6LBo/+iL0S7RVtGG0Vuj8b3/cAAAAACltWC0YrRBtG30uei7vR96z4ou7/1w/EQ0fQAftOtS+o8Lj0V3RJf1/sPEpOjb0e69/4ixbrS8D/8AAADkKf2a+qrR5tGu0QHRCdHF0V+T1l+0/59y6Zno9ujC6PjoO9Gnos2iCdFw/zkCAACQSn8/vlzvB8bPJq2vj5+TtL5i/pQP2KUq/WnA49F10ZnRIb3/wLJx0vpqPwAAADWzRO8H9s9HP05avwFPv/79sg/JtemF6C/R2dGPktZX+dNnEizqP38AAIByWzzaNGk9mO2Y6E9J66FuPuw2u0eS1oP80t/sp880eHc0xrgAAAB0VvqKtbWS1tesj/ShXRk/5B+RtJ7Knz6Nf4jxAgAAyC59Wvy/R3tF/xXdmLSelO7DqIoofVXfNUnrmx17RO9MPHwPAACgX0OjdXo/uP93dGc00wdMdblXk9bv8U/o/YC/RtJ6eCIAAEAjpU8h/0h0eHRF0vqrqA+PqkLPJq2v6P8g2ioaa5wBAIA6Sv+S+Y7oS0nr1WIP+kComnVPdGrSesjeqkYeAACoovRBYunvjb+atF4FN8WHPTWsx6KzktbbFXw1HwAAKKX09+7rR/tGFyatryH7QCf19VR0bjQxab2NwYd7AACgKyZEe0bnRc/4sCa11RPRGUnrFYvLWCcAAEBRxkQfjY6L7vdhTMq19O0NP01aD9RbyLoBAAAGK/0a8LrRgUnr3dteEyd1punRZdG3ktbv7QEAAPqV/kVw26T1Tu1HfKiSSlH6TZifRVtEw60pAAAgtVzS+u17+uC6V3xwkkrd89E50WeiJawvAABoljWT1tfn/+LDkVTZZkVXJ623SEyw1gAAoJ7S974fGv3NhyCplqX/OLd/tJp1BwAA1ZU+wG6D6MfRAz7oSI3qjuig6O1WIQAAVMP6SesVVw/5QCMpuidpfSvHk/EBAKBkVk1af4W71wcXSf10a9L6jf3y1iYAAHTH0tFXoxt9QJHUZrOjK6LPR4tZpwAAUKzR0a7RH5LWk6x9KJGUtenRb6Ido5HWLAAA5GfT6NToJR88JBXY1OiYaF1rFwAABme56LvRfT5gSOpC6e/rvxItbh0DAED/RiStr7penPgavaTyfA3/3GjraKg1DQAAfVaPJkVTfHCQVOIeSVqvuVvB2gYAoKkWSFp/hf+TDwiSKlb6zaELoq2iIdY5AABNkL7f+eDoMR8IJNWgB6JvRUtY7wAA1E1P9MGk9fqnmS7/kmpY+tv6X0YbW/kAAFRd+l74iYkn0ktq3pPw90i8tx4AgIpZMfpJ9JxLvaQG92T0g2i8YwEAgDLbJDov8VV6SXrzV/BPjdZxTAAAUBbDo09HN7mwS9J8uyLaPvEUfAAAumSRaN/oUZdzSWq79Fkie0YjHCcAAHTCUtGPomddxiUpc+lrOvfr/QdSAADI3YTouOgVl29Jyr30H0gPSzwsDwCAnKwV/SrxUDtJ6kTpP5geH63s+AEAYDD+PbrIxVqSutLM3n9IfZvjCACAgX6Iv8RFWpJK0azorGgNxxMAAHOzoQ/xklTaZke/9qEeAID/8+5osouyJFXmQ/3Z0ZqOLwCAZkr/Ev8HF2NJ8qEeAIDye3t0gYuwJNXmN/WnRys53gAA6im96P2i9+LnAixJ9Wp6dFS0lOMOAKAexkdHR6+67EpS7XsxOiQa4/gDAKim9CJ3aO/FzgVXkprVlOib0YKOQwCAahgefb33IudCK0nN7uFo92iI4xEAoLw+Ft3v8ipJelO3RJs7JgEAymX96CqXVUnSfErfZrK6YxMAoLtWiM5IWu8bdkmVJA2kGdEx0eKOUQCAzlok+lH0ikupJGmQPZu0HpI3wrEKAFCsnqT1IKMnXEIlSTmVPmtlO0csAEAx1o3+7NIpSSqo30erOm4BAPKR/qbxhGiWi6YkqeCmR4dHCzt+AQAGZ2i0TzTV5VKS1OHS99Pv7CgGAGjPxknrncAulJKkbnZ59HbHMgBA/9Kv1J/q8ihJKlEzo58kvnoPADBX6VPqn3ZplCSVtIeibR3XAAAtqyetrzG6KEqSqtB50bKObwCgqUZEP0haTw52OZQkVannoy9HQxznAECTvC+622VQklTxbojWcawDAHW3WHSKy58kqUalD8g7IlrQMQ8A1NF20aMufZKkmnZP9B7HPQBQF+OiM1zyJEkNaHb0s2iU4x8AqLKPRU+43EmSGtb90XtdAwCAqlkyOttlTpKUNPuv9MdFo10LAIAq2Cl6yiVOkqTXejD6gOsBAFBWY6OzXNokSZprx0QLuS4AAGWyZfSIi5okSf12d7S+awMA0G3pXxiOcTmTJGnAzYgOioa5RgAA3ZD+ZeFulzJJkgbV9dFqrhMAQKekf0n4ftL6y4LLmCRJg+/laB9XCwCgaKtE17l8SZKUaxdHS7lmAABF+ET0vAuXJEmF9ETSeqAsAEAuFo5OdcmSJKnwZkf/ES3g+gEAZLFO4iF3kiR1uvQnbRNcQwCAwfhKNN2FSpKkrvRctLPrCAAwUItHv3OJkiSpFJ0cjXI9AQD6s3H0sIuTJEml6q5oDdcUAGBuvp54d7wkSWXtxaT1ZhkAgNeMic5zSZIkqRIdF41wfQGAZlsrutfFSJKkSnVDtKJrDAA0027Ryy5EkiRVsinRVq4zANAcI6OTXIIkSap8s6NDo6GuNwBQbytEN7v8SJJUqy6NxrnmAEA9bRY95cIjSVIteyB6h+sOANTLlxKvnZMkqQmvr/u4aw8AVF/66pqTXW4kSWpUP4yGuAYBQDUtE/3ZhUaSpEZ2YTTGdQgAqmXD6FEXGUmSGt3d0equRQBQDen746e7wEiSpOi5aGvXIwAor57oMJcWSZL0pmZGE12VAKB8ForOc1mRJEn9dGw0zLUJAMohfdDdTS4okiRpAF2SeDAeAHTdOtHDLiaSJKmN7oxWco0CgO7YLnrRhUSSJA2iJ6ONXKcAoLO+Ec1yEZEkSRmaFn3CtQoAijckOtrlQ5Ik5dTs6NuuWABQnJGJJ9ZLkqRiOqb3jwYAQI7GRle5aEiSpAL7n2hB1y4AyMcK0V0uGJIkqQNdE41z/QKAbNaOHnWxkCRJHexv0YquYQAwOFtEz7tQSJKkLvRY9E7XMQBoz87Rqy4SkiSpi70Qbe5aBgADs1fiHfKSJKkcpe+i/4jrGQD0b3+XBkmSVLJmRru6pgHA3B3hsiBJkkra7OgrrmsA0GdodKJLgiRJqkAHu7oBQJIMj85xMZAkSRXqqKjHNQ6AphoVTXYhkCRJFewX0TDXOQCaZnR0pYuAJEmqcOdFC7jWAdAUY6JrXQAkSVINuiAa4XoHQN0tFt3g4JckSTXq4mikax4AdTUu+osDX5Ik1bBLo4Vc9wComyWj2xz0kiSpxl0RLezaB0BdjI/+6oCXJEkN6OpoEdc/AKpumehuB7skSWpQ10WLugYCUFXjfZCXJEkN/kDvL/QAVE76G3lfrZckSU3uqsRv6AGokPSp9R52J0mSlCSXJ55yD0AFpO+R9/o5SZKkN762znvoASitMdENDmxJkqQ5+n00wnURgLIZHV3roJYkSZpnv40WcG0EoCxGRVc6oCVJkubbudEw10cAum14NNnBLEmSNOBOi3pcIwHolqHROQ5kSZKktvuZqyQA3XKSg1iSJGnQHeQ6CUCnHeEAliRJytxE10oAOuU7Dl5JkqRcmh19xvUSgKLt5dCVJEnKtZnRdq6ZABRl52iWA1eSJCn3pkXvc90EIG9bRK86aCVJkgrr+Wht104A8rJO7+HikJUkSSq2R6MVXD8ByGqF3kPF4SpJktSZ7orGuoYCMFhjew8Th6okSVJnuyoa6ToKQLvSw+NqB6kkSVLXOi8a4loKwEAN6T08HKKSJEnd7ShXUwAG6mgHpyRJUmn6luspAPPzDQemJElSqZod7eyaCsC8bBfNcmBKkiSVrleiDV1XAXiz9F3yLzooJdXgr1czei+96U57KZrW+3822//7SKp4T0QrurYC8H+WiR52QErqQtOjf0Y3Rr+PzoiOjX4Y7Rt9Ptox+mC0SbRutEa0UjQ+WiQaEQ2Legaw73p6/2fT/ztjev93TIjWjNaLNo0+FO0U7RntFx0WHR+dGV0S/SV6tPcfCPz/oaROd0fv7gOg4RaKbnIwSsq52b0feK+Lzo0mRV/v/WCefihfLVq04vsz/YeBcdFbo82S1u9Z03+ASJ88fX7vbn3CfwuSCij9x8+hrrEAzZVeRL2CTlKW32/eGf02+mm0d9L6C/oq0QJW7L+MjFaPPhxNjH4WXRTdHb3qvyNJg8wr6wAa7DAHoaQBlP72/Ibo1KT1eqRtopWjIdZoZsN6P+h/NPpu0vqZwS29/1Divz1J82tvaxSgeXZzAEqaS49Ev4sOjnZIWr8n77EyOy79h5L0pwjpb/cPT1q/1X/Sf5+S3tTMaEsrE6A50teaTHcASo3vqd4P7t/rvQwuaT2W3rJJ6+v66T+2TI6e9d+x1Pieif7NegSov/TJ9Y86+KRG/vUm/ap8+iC69EFtE6zDWki/NZF+Tf8zSestALclXsEnNbG/RqOtRID6Sl/F9GcHntSI0nerXxkdmrT+6u6S1xyLRdtGR0TXJ16hJzWl8xM/iwKorZMddFJtm5W0XgN3SNJ6TdpIK49eCyettwykH+5vTfzlXqpz37fyAOrnSw44qXbdHx2XtB5Ut5g1xwAtFe0SnRI9bI6kWpX+Y9321hxAfWyW+JqlVIfSd5JfFn09aT3pHPKwVrR/dG3S+oaHWZOq3fPR26w2gOpbIWk9sdrhJlWzKUnr/e47RmOsNAq2RPSp6KzeDwRmUKpm90SLWmkA1ZX+ZvZmB5pUudI3TqRPJt88GmaV0SXpQ1PT1+Cd3PuPSmZTqlYXJR6IB1BZJzrIpMr0YPSf0btdviihYb3/uJT+I9Pj5lWqTN+zvgCqZzcHmFT6nur9cLSxD/BUyNDoA0nrAXrPmWOp9G862cLaAqiO9GFGLzvApFL2QnR69KHEV+ipvvTnXOnbFM6JpplvqbT/cLycdQVQfukDsu51cEmle1XQ5dFnolHWFDWVvh7xi9H1Zl4qXddEC1hTAOV2ngNLKk3/iA6KJlhNNMwa0RGJ39dLZWqS1QRQXl93UEldb0Z0btL6jaLfwdN06U9Jto8uTlrfULEjpO72cWsJoHw27v0Q4aCSutNDSeupwUtbRzBX6TdUDouetC+krvV8tJp1BFAei0cPO6CkrvwWPv2L47ZJ6wnfwPwNj3aKrrRDpK50W9J6eCUAJXCBg0nqaC8mrVfKrW79QCbvjE6NptsrUkc71voB6L6JDiSpow+0+0a0qNUDuVoq+n7igXlSJ/uo1QPQPesk/pohdaKboh0TX6WHoqVfwd89usvekQpvavQWaweg8xaO7nYQSYU2OdrcuoGOS98EkT4F/1p7SCq0K/1DNUDn/bcDSCqkWdGZSeu3vED3bRJdaDdJhfUDawagcz7h4JFyb2Z0WrSqFQOllP4D2/l2lVTIP2JvZsUAFG+VpPWOUIePlE8zolN6Zwsov7Wjc5PWqyHtMCmf0lccj7NeAIozLLrOgSPl9iH+xGiC1QKV9PbobB/qpdw631oBKM73HTRS5tKLf/qbeF+nh3pIv37/e7tNyqXdrRSA/K2XtP6S6KCRBl/6EK21rROopfRBeVfZc1Km0p9yrmSdAORnocRr6KQspRf8ja0SaISto1vtPSnT6+qGWCUA+TjGwSINqnujHawQaJz0g0j6deFH7UFpUO1njQBkt6UDRWq7KdHEaAErBBptVHRg9KK9KLXV9MTP0gAyGRs94kCR2rp8HBEtan0Ar7N00np7xSx7Uhpwd0QjrA+AwTnLQSINuIsST6gH+rdudK19KQ24/7Q2ANq3kwNEGlD3RdtYGcAA9USfiR6zP6UBvc51E2sDYOCWjJ5ygEj99lK0f+IrgMDgLJK0fpbzqn0qzfdhsgtaGQADc7aDQ+q330ZvsSqAHKyRtF7FZbdK8+4nVgXA/H3MgSHNs39GH7EmgJylX73/bNJ6E4ZdK81Z+vDIDa0KgHlbPHrCgSHN0cxoUjTamgAKtER0mp0rzbW7opHWBMDcneGgkOboluhd1gPQQZtH99u/0hwdZj0AzGk7B4Q0xzvjD4gWsB6ALhgVHZl4N7305m/KrWc9APRZLPGKHOn1XR+taTUAJbBR9Dd7WfpXt0fDrQaAllMcDNJrvRLtGw21FoASSX8nnH69eKY9Lb3WQdYCQJK814EgvdZN0dusBKDE0qd532tfS6/9FG51KwFoshHR3Q4ENbz0L10HJ34bD1RD+lv64+xuKbkiab3WEaCRDnIQqOHdE21gFQAV9KHoUXtcDW93qwBoovSrSdMdAmpwx0cLWQVAhY2LzrXP1eCmREtYBUCTpF9JusIBoIY2NdrBGgBqZM/oZftdDe10KwBokt0tfjW0/42WtwKAGlojab2yy65XE9vcCgCaIP0q0hRLXw0rfcjd9xOvnAPqLX2F3bF2vhrYPb3//QPU2qkWvhrWY9FmRh9okPSnRM/Z/2pYBxt9oM7eY9GrYf0pGm/0gQb6t+gW54Aa1LRoFaMP1NFQh7oa1OzoR4mv1QPNtmB0sjNBDepCYw/U0d4WvBpS+rT6Dxt5gH/ZLfG0ezUndwCgVhbv/YBjwavu3RZNMPIAc1gn+odzQg3ovmiEkQfq4gSLXQ3o7GiUcQeYp/Qf9y9zXqgBfde4A3WwXjTLUleNS//7/o5RBxiQYdEkZ4dq3kvRW4w7UGU90XUWumrcs9FWRh2gbZ+OXnGOKKn3N/YAKmt3i1w1Lv1N3GrGHGDQNoged56oxm1uzIEqGh09YYmrpl0RjTPmAJmlX0W+zbmimnZH4jW1QAX9yAJXTTslGm7EAXKT/gHgQueLatqeRhyokhUSv4NT/Zodfct4AxQi/eulB+OpjqXfVF3EiANVcYbFrZo1Lfq40QYo3JcSb8FR/fqR0QaqYP2k9RdMi1t1aWq0idEG6JiPJr7hp3qV/ve8gtEGyu4qC1s16qHobcYaoOM2iqY4h1SjzjDWQJl9zKJWjbo1WsZYA3TN6tHfnUeqSek3Vzcw1kAZpU/3vt+iVk1KXz3nYTUA3bd04tV1qk9XG2mgjL5mQasmXRCNNNIApbFYdI3zSTXJA3WBUhmT+F2b6tEvomFGGqB0RkWXOKdUg+511wDK5FCLWTXo6KjHOAOUVvqTvrOdV6pBXzDOQBmMj160lFXxDjXKAJUwJDrJuaWK90i0oHEGuu1oC1kV73vGGKBS0m9RHev8UsXb1ygD3bRS9KplrAq3nzEGqKxJzjFVuPR5U2OMMdAtp1vEqnBfM8IAlfdj55kqnJ/5AV3x9miWJayK9iUjDFAbhzjXVNHS504tZYSBTrvAApYP8gCUhDfrqMpv0wHomA0tXlU0X60HqC9fuVcVS58/tZLxBTplssWrCvYtowtQe0c671TBTjS6QCe828JVBTvA6AI0xnHOPSXV++v8ikYXKJq/ysuTYgEos/Q99Cc7/1SxTjC6QJH8Vl4eKgNAFQyNznUOKvHXeYDXXGLRqkL9Mmn9dQaAZhoR/cF5qAr1X8YWKMK/W7CqUOmrE4cZW4DGGxVd61xUUp2/zq9gbIG8XWzBqiJdHo00sgD0Ghvd7nxU4q/zQAP5q7yq0q3RIkYWgDdZJnrQOanEX+eBhrnIYlUFerD3sgYAc/O2aKrzUhXoeOMK5GEtC1UVaGrvJQ0A+rNJNM25qZKX/jc63rgCWf3KQlUFDrxNjCoAA/TxaLbzUyXvcKMKZDEhmmmZqsTN7r2UAUA7vuIMVcl7LhpjVIHBOs4iVcnbz5gCMEhHO0dV8r5tTIHBWCp6xRJViTvFmAKQwdDEq3dV7h5PvG4XGIQfWqAqcVdEw40pABmlX2O+07mqErenMQXakb6n+1nLUyXtvmicMQUgJytFTzpfVeJ7z1BjCgzUvhanSlr6j0yrG1EAcrZRNN05q5K2kxEFBiL96vKjlqZK2KxoKyMKQEE+66xVSbvZeAID8WkLUyXtO8YTgIJ5k4/K2mbGE5ifmyxLlbBfG00AOmCB6ErnrkrY+cYT6M8mFqVK2G3RKOMJQIekr+f9p/NXJSv9ueHKxhOYl/MsSpWsqdEEowlAh60XTXMOq2QdaTSBuVmp91/8LEqVpdnRh40mAF2yl7NYJeuFaIzRBN7sJxakStaPjCUAXfYL57FK1teMJfB6o6PnLEeVqMujoUYTgC5Ln9lyp3NZJerv7kjA6020GFWiHovGG0sASmL1pPX1Zme0ytIOxhJI9UT3WYoqSTMT71EFoHx2dkarRF1pJIHUBy1ElaiDjCQAJXWyc1olak0jCfzGMlRSnn9l9hswAMoq/f38Xc5rlaRjjCQ02/JJ62vNFqLK8D75txhJAEpu7cT751WOno8WNpLQXAdbhCpJHzWOAFSEBwerLH3BOEIzLZC0nhpuEarbHW8cAaiYC5zfKkG3GEVopo9bgCpB90QLGUcAKmbJ6EnnuErQhsYRmudPlp+6XPq8hg2MIgAVtb2zXCXoNKMIzfJWi08l6GCjCEDFneI8V5dLH8g4zihCc0yy+NTlbkpaz20AgCpbJPqHc11d7htGEZphRDTF0lMXeyV6m1EEoCY2jWY539XF7jKG0Aw7WnjqcvsaQwBq5kjnu7qcB+FBA1xs2amLXR8NNYYA1Ez6Zpb7nfPqYicYQ6i35RJfA1P3mh6taQwBqKn3RbOd9+pSzyde9wu1tr9Fpy52gBEEoOZ+7rxXF/u0EYR66onus+TUpW5JPL0egPpLn27/kHNfXepyIwj1tKkFpy41M3qXEQSgIbZ29qtLpT/zWNkIQv2casGpS00yfgA0zDnOf3WpQ4wf1Mvo6CXLTV3on73//QFAkyybtB5I5i6gbty9hhhBqI9dLTZ1qY8YPwAa6svuAepS7zd+UB9/sNTUhX5r9ABosPSvoze6D6gLnWz8oB6WTrxbXp0v/VnHW4wfAA33LvcwdaHnopHGD6rvqxaautD+Rg8AXnO8e4G60A5GD6rvBstMHe6+aITRA4DXjIumuB+ow51n9KDaVrXI1IW2MXoA8AZfdD9Qh5sWLWr0oLoOssjU4S4ydgAwh6HRLe4J6nB7GD2ornstMXWw6Unr2yAAwJze466gDneZsYNqWt8CU4c7wtgBQL/Ocl9QB0vfpLCMsYPq+akFpg6WPtjH77IAoH8rJa3fMrs7qFN9zdhBtfRED1le6mATjR0ADMgR7g3qYNcYOaiWDSwudbD02QwLGDsAGJD0m2xeVadONTta1thBdfzY4lIH28HIAUBbJro/qIN9ychBdTxgaalDXWXcAKBt6TfavHVIneoKIwfVsI6FpQ62sZEDgEHZ2T1CHSp9qv1SRg7K71ALSx3qQuMGAIOWPrD4FvcJdag9jRyU398sK3Wg9GEqaxs3AMjkw+4U6lCXGjcotzUtKnWoM40bAOTiavcKdaAZ0TjjBuV1oEWlDh0G/2bcACAXm7pbqEPtYdygvP5iSakDnWTUACBXk90v1IEuMGpQTstZUEo681f5CcYNAHK1kTuGOtDL0YLGDcpnTwtKHegUowYAhfije4Y60NZGDcrnd5aTCm5mtIpRA4BCbOKuoQ50vFGDclkoesVyUsGdZtQAoFB/ct9Qwf3TmEG5bGsxqeBmRasaNQAo1HvdOdSB1jFqUB7/ZSmp4LxXHgA6w3vnVXTfM2ZQDj3Ro5aSEv+CCwB14BuXKrrrjRmUw7oWkgpusjEDgI5J/1Bzp/uHCmx2tJRRg+470EJSwb3fmAFAR+3q/qGC292YQfddYxmpwG4yYgDQcQskraeOu4uoqM4yZtBdY5LWu78tJBXVjsYMALria+4hKrCnoyHGDLrnoxaRCuwf0VBjBgBdsUj0vPuICmxdYwbdc5wlpAL7hhEDgK6a5D6iAvuOEYPuud8SUkG9GC1qxACgq1aOZrmXqKD+ZMSgOyZYQCqwY40YAJTCb9xLVFDTo1FGDDpvTwtIBZW+e3R1IwYApfA+dxMV2NZGDDrvPMtHBXWx8QKAUrnV/UQFdaTxgs5KnzD+rOWjgtrWiAFAqfhGporqr8YLOmt9i0cF9VDidXQAUDajoxfcU1RQyxgx6Jx9LR0V1AHGCwBK6efuKSqonY0XdM6Flo4KaEbiX2YBoKzWdldRQR1vvKAzhkTPWToqoHONFwCU2nXuKyqgu4wWdMY7LRwV1BbGCwBKbTf3FRXUksYLivdVy0YF9I+ox3gBQKmNSjwIT8X0MeMFxTvfslEBHWS0AKASTnZvUQEdZbSgWOlfTqdYNsq52dEE4wUAlfAedxcV0G1GC4r1DotGBXS50QKASrnP/UVJ/n/cGWe0oDhfsmhUQJ8xWgBQKd91f1EBbW+0oDhnWjLKufQhOqOMFgBUyvLRLPcY5dwRRguK86Alo5w73VgBQCVd7h6jnLvKWEExlrZgVEAfMloAUEmfd49Rzr0cLWC0IH8fsWCUc09Fw4wWAFTS2OhV9xnl3LpGC/J3uOWinDvWWAFApV3gPqOc28dYQf6usFyUcxsbKwCotF3cZ5RzvzRWkK+h0UuWi3IsfZhij9ECgEpL30jzonuNcux+YwX5WsdiUc79p7ECgFo4271GObeEsYL87GmpKOfebawAoBZ2cq9Rzm1jrCA/p1gqyrFHE1+xB4C6GB1Nc79Rjh1qrCA/d1oqyjFPsQeAevFUe+XZZCMF+VgwmmmpKMc2N1YAUCu7ud8ox54yUpCPDSwU5djT0TBjBQC1Mjaa4Z6jHFvOWEF2e1kmyrFTjRQA1NJl7jnKMQ/Bgxz8l2WiHNvRSAFALX3dPUc5dqCRguxutEyUU69GY4wUANTSau46yrHzjRRkk/622atGlFeXGSkAqLV73XeUUw8aJ8hmLYtEOfZ1IwUAtTbJfUc5Ns5IweDtaokox1YzUgBQa1u47yjH3m+kYPCOtESUU/cbJwCoveHRi+49yqlvGikYvD9ZIsqp440TADTCRe49yqnTjRMM3pOWiHJqB+MEAI3wVfce5dTNxgkGZ3ELRDk1K1rMSAFAI6zp7qOcejkaYqSgfZtaIMqp64wTADTKo+4/yqmVjRO074uWh3LqEOMEAI1ymvuPcmpb4wTtO8byUE5tZpwAoFE+7f6jnNrPOEH7PMleeTQtGmmcAKBRVnAHUk55oj0MgifZK4+uNEoA0EgPugcph24yStCeJSwO5dShxgkAGul09yDlkCfaQ5s2sziUU1saJwBopM+5BymnPNEe2vB5S0M5NDNa2DgBQCOt5i6knNrKOMHA/djSUA7dYJQAoNEedx9SDn3ZKMHAnW9pKIcmGSUAaLRz3YeUQ0cZJRi4OywN5dDORgkAGm1f9yHl0O+NEgxMT9J6aqTFoaxNME4A0Gibug8ph+41SjAwy1kYyqGnjBIANN6opPVAXHcjZenVaJhxgvnbzMJQDv3OKAEA4Rb3IuWQ19PBAHzWslAOfc8oAQDh5+5FyqEtjRLM32GWhSxcACAnu7sXKYf2Nkowf+dYFsqhJYwSABDWcS9SDv3UKMH83WRZKGOPGCMAoNfwpPUAM3ckZek3Rgnm7ynLQhnz8DsA4PU8BE9Zu9kYQf8WtCiUQwcbJQDgdf7b/UgZe9oYQf9WtSiUQzsYJQDgdSa6HymHFjRKMG+bWxLKoQlGCQB4nU3cj5RDqxklmLddLQll7IWoxygBAK8z1h1JOfR+owTzdoAloYzdYIwAgLl43D1JGdvdGMG8nWBJKGOnGiMAYC4uc09Sxg40RjBvF1sSyti3jBEAMBdHuycpYycZI5i3v1oSytg2xggAmIsvuicpY38wRjBvz1kSytjKxggAmIvN3JOUsbuMEczdghaEMvZKNMQoAQBzsaS7kjI21RjB3K1oQShjdxojAKAfz7svKWPDjRHMaQPLQRn7rTECAPrxF/clZWw5YwRz2tZyUMZ+aowAgH6c476kjL3LGMGcPmc5KGN7GyMAoB+HuS8pY1sZI5jTdy0HZeyDxggA6Ic/HilruxkjmNPPLAdlbBVjBAD0473uS8rYt4wRzOksy0EZmhUtYIwAgH6s6M6kjP3EGMGcLrcclKFHjRAAMB/pP/zPcm9Shn5pjGBOd1kOytB1RggAGIBH3ZuUoUuNEMzpCctBGTrXCAEAA3Cde5MydLMRgjlNtxyUoUlGCAAYgLPdm5ShB4wQvNFCFoMy9nVjBAAMwE/cm5ShZ4wQvNEyFoMytqMxAgAG4KvuTcpQ+gDFHmMEfdawGJSxTYwRADAAO7s3KWOLGiPos5GloIytZowAgAF4n3uTMraiMYI+W1sKSvwLKQBQvDXdm5SxtY0R9PmkpaAMTTdCAMAALeHupIy91xhBn30sBWXon0YIABigIdFM9ydl6CPGCPp8z1JQhm40QgBAGx53f1KGdjdC0OdwS0EZ+r0RAgDacJv7kzI00QhBn6MtBWXoDCMEALThf92flKFvGyHoc7KloAwda4QAgDb81v1JGTrYCEGfX1kKytAPjRAA0IbT3J+UoSOMEPT5jaWgDO1rhACANhzp/qTEt0IhF3+wFJShzxshAKANB7k/KUP/bYSgz9WWgjK0oxECANrwVfcnZejXRgj63GwpKEMfNEIAQBt2d39Shi4wQtDnb5aCMrSJEQIA2rCz+5My9EcjBH0eshSUoXWNEADQhu3cn5Sha40Q9HnSUlCG1jBCAEAbPuD+pAzdYoSgz1RLQRlayQgBAG3Y2P1JGbrDCEGf5ywFZWi8EQIA2vAu9ydl6C4jBH1eshSUoUWMEADQhre6PylD9xgh6DPNUlCGRhghAKANK7k/KUMPGCHoM8NSUIaGGSEAoA1vcX9Shh40QtBntqWgDPUYIQCgDcu6PylDDxshaOmxEJSh2UYIAGjTeHcoZehxIwQtwywEZWiGEQIA2rS4O5Qy9JQRgpaRFoIy9IoRAgDatJg7lDI01QhByygLQRl60QgBAG0a7Q6lDD1vhKBlIQtBGXrJCAEAbVrEHUo+zEN2IywEZWiaEQIA2uRr9srSM0YIWjwATx6ABwB00hLuUMrQFCMELV5NJ6+mAwA6yavplKUnjRD0mW0pKEM9RggAaMOy7k/K0GNGCPrMsBSUoWFGCABowwruT8rQI0YI+rxiKShDI4wQANCGCe5PytBDRgj6vGgpKENjjBAA0Ia3uT8pQ/8wQtDnOUtBGRpvhACANrzL/UkZutcIQZ+ploIyNMEIAQBteI/7kzJ0uxGCPk9aCsrQmkYIAGjDlu5PytCNRgj6PGgpKEPrGSEAoA3buz8pQ1cZIehzl6WgDG1qhACANuzi/qQMXWqEoM9NloIy9CEjBAC0YQ/3J2XoQiMEfa6yFJShnYwQANCGr7s/KUPnGiHoM9lSUIb2NEIAQBsOdn9Shs4wQtDnfEtBGdrPCAEAbTjK/UkZOtEIQZ8zLAVl6DAjBAC04XT3J2Xop0YI+pxkKShDxxshAKANF7g/KUMHGyHo46tOytKZRggAaMOV7k/K0L5GCPocZikoQ5cYIQCgDXe4PylDexkh6LO/paAM/cUIAQBteMr9SRn6lBGCPl+0FJShR4wQADBAQ6NZ7k/K0PbGCPrsYikoQzOiHmMEAAzAeHcnZez9xgj6bGUpKGPjjBEAMADvcG9SxtYzRtBnQ0tBGXurMQIABmAL9yZlbBVjBH3eaikoY5sZIwBgAD7h3qSMjTVG0Mdvl5S1nY0RADAA33BvUoZmR0OMEfQZaTEoY/saIwBgAI50b1KGnjFCMKdploMydJQRAgAG4H/cm5Sh+40QzOkxy0EZOt8IAQADcKN7kzJ0oxGCOd1hOShDNxkhAGAAnnBvUoYmGyGY02WWgzL0hBECAOZjRNJ6gJm7kwbbGcYI5vQry0EZSg/mkcYIAOjHyu5MythPjRHMaZLloIytbowAgH5s4b6kjH3bGMGcvm05KGMfNkYAQD/2cl9SxnY3RjCn3S0HZWyiMQIA+nGE+5IytrUxgjltbTkoYz8zRgBAP7xjXllbzxjBnNa1HJSxi4wRANCP292XlLG3GCOY0/KWgzJ2tzECAPrxkvuSMubtSTAXIywHZezVaJhRAgDmYll3JWVsqjGCeXvGklDGvJ4OAJgbr6VT1m4zRjBvfsekrH3UGAEAczHRPUkZ+70xgnm70JJQxr5rjACAufi5e5IydoIxgnk73pJQxs4wRgDAXFzpnqSMHWiMYN6+Y0koY7cYIwBgLqa4JyljexgjmLdPWRLK2CvREKMEALzOku5IyqEtjRLM22aWhHJoNaMEALzO+92PlENrGiWYtwmWhHJoJ6MEALzON92PlEMLGyWYt+HRbItCGTvcKAEAr/NL9yNl7CljBPP3uGWhjF1ijACA17nT/UgZu8EYwfxdZ1koY08aIwCg14LRTPcjZezXRgnm70zLQjm0rFECAML67kVK/IwTOuIQy0I59GGjBACEL7gXKYf2NEowf7taFsqhg40SABBOdi9SDnnHPAzAxpaFcmiyUQIAwl/di5RDqxolmL/xloVy6NmoxzgBQKONSbz2WNlLH6C4gHGCgXnB0lAOrW6UAKDRtnAfUg7dZ5Rg4G6xNJRDnzFKANBo33UfUg5dZJRg4M62NJRDxxolAGi0C9yHlEOTjBIM3I8sDeXQbUYJABorfXbOVPch5dDexgkGbndLQzmUPvBmMeMEAI30Dnch5dQWxgkGbiNLQzm1rXECgEbaxz1IObWCcYKBW9TSUE4dYZwAoJF+7R6kHHolGmKcoD2PWB7KoeuNEgA00mPuQcqhm40StO8PlodyaEa0sHECgEZZ1R1IOXW6cYL2TbI8lFMfNE4A0Cifc/9RTu1nnMASlt/NAwCd4ffyyqttjBO0792Wh3LqVuMEAI2RPqxsivuPcmolIwXt80R75fm++aWMFAA0wrruPsqpF6MeIwWD44n2yqtdjBMANMJ+7j3KqRuMEwzeZEtEOXWKcQKARvije4/cH6H7jrBElFMPGycAqL2FomnuPcqpiUYKBm8XS0Q5tpaRAoBa28Z9Rzm2qZGCwXurJaIc299IAUCtHe++o5xKH6A8xkjB4KWvFnnJMlFOXWOkAKDW/um+o5x6wDhBdtdYJsqpWdHiRgoAamktdx3l2HlGCrI7xjJRjn3KSAFALe3vnqMcO8BIQXaftUyUY2cZKQCoJd/mVJ5tY6Qgu3daJsqx56MRxgoAamXppPXAMncd5dUyxgqyGx69aqEoxz5srACgVvZyv1GOPWKkID9/sVSUYycbKQColUvdb5Rj/2OkID8nWCrKsaejYcYKAGphbDTD/UY59h1jBfnZw1JRzm1urACgFnZzr1HObWGsID9rWCrKuWONFQDUwgXuNcqx9EGKixoryE9P9Kzlohx7PBpqtACg0tIPXdPda5Rj9xgryN9ky0U59wFjBQCV5qeYyrtfGCvI3w8sF+XcKcYKACrtj+4zyrm9jRXkbyvLRTn3XDTSaAFAJS0dzXKfUc6tbbQgf2MtFxXQDkYLACrpK+4xyrnnE89UgsLcY8ko584xVgBQSde5xyjnLjVWUJxTLRnl3LRoMaMFAJWyqjuMCuggowXF+ZwlowLay2gBQKX80P1FBbSl0YLirGbJqICuN1oAUBlDoofdX5Rz6cMUxxgvKNZjlo0KaA2jBQCVsKV7iwroVqMFxTvLslEB/dhoAUAlnOneogI60mhB8b5o2aiAHo+GGS8AKLVFo1fcW1RAHzFeULw1LBsV1PbGCwBKbW/3FRXQ7Gis8YLi9URPWToqoIuNFwCU2u3uKyogv5eHDjrP0lFSzL/KrmS8AKCUNnJXUUH9zHhB50y0dFRQhxkvACil091TVFAfNV7QOWtZOiqoJ6LhRgwASmVc4sF3Ku6bmeOMGHROT++HLgtIRbSTEQOAUvma+4kK6mbjBZ13huWjgrrSeAFAaQyJ7nU/UUEdbsSg83a1fFRg7zRiAFAK27iXqMDeb8Sg85a1fFRgpxoxACiFS91LVFDpcxhGGjHojjstIRXU9GgpIwYAXbWmO4kKbLIRg+75qSWkAvu+EQOArjrBfUQF9k0jBt2zlSWkAns88Zo6AOiW9HVhL7uPqMDWNmbQPQslra9DW0Yqqt2NGQB0xQHuIUqK/aNNjzGD7rrMMlKB3WXRA0DHpX+weco9RAV2ijGD7vuWZaSC296YAUBH7eP+oYL7uDGD7lvDMlLBXWvMAKBjhkV/d/9Qgc2Ixhg1KIcHLCUV3CbGDAA6Yhf3DhXcFcYMyuNnlpIK7kJjBgAdcYt7hwpuX2MG5bGFpaQO9E6jBgCF2tZ9Qx1oTaMG5ZG+C/x5i0kFd75RA4BC3eS+oYJ70JhB+ZxjOangZkdrGTUAKMSH3TXUgY4yalA+n7Gc1IHONWoAUIjr3TPUgTY3alA+S0SzLCglxf91/u3GDQBy9SF3DHWgZ5LWqw+BErrGklIHOtuoAUCu/ux+oQ70S6MG5bWvJaWkM3+dX8e4AUAuPMFenerjxg3Ka4IlpQ71e+MGAJn1RLe5V6gDTY9GGzkot79YVupQ7zFuAJDJLu4TSvwhBui1v2WlDnWlcQOAQUsfRHaf+4Q61GeNHJTfapaVOthWRg4ABuUL7hHqUDOicUYOquEOS0sd6tZoiJEDgLYsFD3iHqEONdnIQXUcZGmpg+1u5ACgLQe4P6iDfc7IQXW83dJSB0v/sjDK2AHAgCwdvej+oKRzX7Ff3NhBtdxjeamDHWjkAGBATnRvUOIr9kA/DrW81MHSvzAsbewAoF/ptydnuTco8RV7oB9rWF7qcCcaOwDo1yXuC0p8xR4YgFstMXWw9C8N7zJ2ADBX27orqMNdaOyguva1xNThrol6jB4AvMGI6D73BHW4XYweVNfy0WyLTB3u00YPAN5gf/cDdbj0eUbeNgQVd4Vlpg73WDTa6AHAa5aLXnI/UIf7pdGD6vu8ZaYu9GOjBwCvOdO9QF1oa6MH1Tc2mm6hqcO9mrTeqAAATfY+dwJ1oaeiYcYP6uE3lpq60JWJh+EB0FzpQ+/udh9QFzrG+EF97GipqUvtYfwAaKjvuweoS61v/KA+RkbPWGzqQlOiJYwgAA2zajTNPUBd6E7jB/VzrOWmLnWa8QOgYS5z/qtL7Wv8oH7WtdzUxTY3ggA0xKec++pSM6OljSDU062WnLrU/dFCRhCAmlsqaf3EzNmvbnSREYT6+oolpy42yQgCUHPnOO/VxXY0glBfiyet939bdupGs6J3G0MAaupjznp1salJ63WIQI2da9mpi/0tab1dAQDqZGz0uHNeXexIYwj1t7Vlpy53mDEEoGZOc76ry61pDKH+hkaPWHjqYumTVjc0igDUxPbOdnW5a4whNMehlp663L3RKKMIQMWlT69/0rmuLrebUYTmWCFpPYzM8lM3O84oAlBxv3Weq8s9m3j9LzTOBZafStCHjCIAFbWHc1wl6FijCM2zleWnEvRoNM44AlAxE6IXnOMqQWsbR2ieIdHfLUCVoHONIwAVMiy62vmtEnStcYTm2s8SVEn6gnEEoCIOcW6rJH3SOEJzLRFNtwhVgl6O1jCSAJTcZomHCKscPRENN5LQbGdYhipJt0cjjSQAJZU+4+Vh57VK0qFGEtjYMlSJ8kRWAMrKa+hUlmZGyxtJIHWrpagStYORBKBkJjqfVaLOM5LA//GeVJWp56JVjCUAJfHv0avOZ5Wo9xlL4P+kv1N+0mJUibolWtBoAtBli0cPOZdVom43lsCb/cByVMk6yVgC0EVDooudxypZexhN4M3GJ15Tp/K1m9EEoEsOdA6rZKXfpPXmH2CuTrUkVbLS98+vYzQB6LAtE++TV/k6yGgC87KOJakS9o+k9ZtFAOiElaOpzl+VrGnRUsYT6M8VlqVK2GXRMOMJQMEWTloPGHP2qmydYjyB+dneslRJm2Q8ASjYOc5blbS1jCcwP+mTW++zMFXSPm1EASjId5yzKmmTjScwUHtamippr0QbGFEAcrZN4oF3Km+bG1FgoEZEj1mcKmmPR28xpgDkJP368gvOV5W0G40o0K79LE+VuNui0cYUgIzGRw85V1XidjSmQLvGRM9ZoCpxv4uGGlUABmnB6HrnqUrcfe46wGAdbomq5HnCPQCD0ROd7RxVydvTqAKDlX71bJpFqpK3j1EFoE3+YKGy90Q00qgCWfzcMlXJS58+/FGjCsAA7ePsVAX6llEFslo5mmmhquSlr6zbyLgCMB8fSbyCTuVvSuJBv0BOfmWpqiIH3+rGFYB5eHfS+sdfZ6bK3gHGFcjLGol/xVY1+nu0tJEF4E1Wi552TqoCpW+TWtTIAnk6y3JVRUrfQb+YkQWg1/LRg85HVaRDjSyQt/Sv87MtWFWka6KFjC1A4y0R/c25qIr0YrS4sQWK8GtLVhXqkmi4sQVorEWim5yHqlBHGFugKGsm/jqvanV2NMToAjRO+n7uy52DSqr1V/kljS5QpLMtW1Wsk6IeowvQGAtEFzj/VLEOM7pA0fx1XlXsWKML0AjDonOde6pYz0fjjC/QCf46ryo2yegC1NrQ6FfOO1Wwg40v0CnpX+e9d15V7D+ML0Atpc9HOdU5pwr2TOK98kCHnW75qqIdYnwBaiV9LsqJzjdVtO8ZYaDTVopetYDlAz0AXTTEB3lVuKej0cYY6IajLWFVuB8bYYBKS38jf5rzTBXua8YY6JalktY7MS1jVbUjjTFAJaVPrfewO1W5B6MRRhnopkMtY1W89LV13kMPUB3pe+S9fk5Vb1ejDHTbmGiKhayKd3LS+romAOU2MrrAuaWKd0fSet4DQNd901JWDTonGm6cAUprkehy55Vq0HbGGSiLBaOHLWbVoD9Eo4w0QOksHt3onFINuto4A2Wzu+WsmnRttJiRBiiN5aO7nE+qSRsbaaBs0t/93GJBqybdHi1jrAG6brWk9dRvZ5Pq0LlGGiirzS1p1aj08vhWYw3QNe+OnnYeqSa9Gq1irIEy+51lrRo1NXqPsQbouI9ErziHVKN+aqyBsls9mmFhq0ZNiz5mtAE6Zp9olvNHSb3+ODDWaANVcIylrZqVXiq/YrQBCtUTHe7MUQ37qvEGqiJ9fcyzFrdq2NHRUCMOkLv0NbdnO2dUw+6LhhtxoEr2tbxV0y6OFjHiALkZH13vfFFN286IA1UzInrAAldNuyNayZgDZLZW9JBzRTVtshEHqmp7S1w17sloI2MOMGjbRC84T1TT0gdCv82YA1X2e8tcNW56tIcxB2jbdxJPrFe9m2TMgapbtfcDj6WuOndstIBxB5ivhaNznBuqeU9Fixp3oA68ZkZN6MpoKeMOME8rJ61njjgzVPc+b9yBukj/Ff5hi10N6J/RekYeYA5bRlOdE2pAN0VDjDxQJztb7mpI06I9jTzAa9IPNQcmfh+vZpT+d76+sQfq6ApLXg3q9GiUsQcabPHoYueBGtTPjT1QV2+PZlr0alB3RqsbfaCBNkxaPz1yFqhJr6wda/SBOvuJZa+Glb5DeWejDzTIxOhV+18NazejD9Rd+jC8hyx8NbCTooWsAKDGxkW/te/VwK6KeqwAoAm2tfTV0O6K1rICgBraLPHmGjWzGdE7rACgSf7H8ldDS592/2UrAKiJYdEhiafVq7n9hzUANM1y0fMOADW4C6IlrQKgwlaKrrbP1eDuT/yEDmioiQ4BNbz0ybfbWQVABX02aT3g0y5Xk/uAVQA01ZDoBgeBlJwSjbYSgApIv1HkIXdSkvzCOgCabp3Eu+eltL9Hm1oJQIltn7S+UWRnq+k9HS1hJQAkyREOBem10gdIHZn4/R1QLmOj0+1oyTvlAd5swegeB4P0hgfqvNdqAEpgh+hxe1n6V5daCwBv9J5otgNC+lfpPPw8WsR6ALpgqegcu1h6Q+lDH1e0HgDmdJRDQpqjh6KtrQeggz6VtH4TbAdLb2xv6wFg7kZFDzgopLmW/oVsGWsCKNCq0R/tW2muXR71WBMA8/a+xNftpXn1fPTlpPVaR4C8jIi+H02zZ6W59lK0slUBMH/HOzSkfrsxepdVAeQg/Uf0u+1Vqd++alUADMzo6EEHhzTf19gdF42zMoBBWC460y6V5tvViW/EAbTlAw4PaUBNib4YDbU2gAFIv1K/f9L62rAdKvXfi9Eq1gZA+451iEgD7pak9YpHgHnZNrrfvpQG3BetDYDBWSjxOz6p3dKvza5kfQCv8/boEvtRaqt0Zjy9HiCD9aMZDhSprdInUh8RLWqFQKMtHZ2YtJ6xYTdKA++ZaFkrBCC7gxwq0qB6OpoYLWCNQKOk32w7MGn93tculNrvk9YIQD6GRdc7WKRBd2+0U+LrgtCE8/IL0SP2njToLrBKAPK1WvSyA0bK/JC8D1snUDvpa7M+Ed1nz0mZmxq901oByNc+Dhgpt3fmbmqlQC2kT6i/zV6TfKAHKLP0K8IXO2Ck3JocbWS1QCV9KPqzPSb5QA9QFeOjJxwwUq79MdrEeoFKSH8q4zkykg/0AJW0ZTTbASPl3p+izawYKKX06/Q32lNSVz7Qv8sKAsjPjx0uUqG/qU8/OHj6PXRX+nT69MF2t9pLkg/0AHWRvjfb1wylYrsz2jXxnnrotPQ98V+K/m4PST7QA9TRytFzDhep8P4ZfS0abe1AocZFB0RP2TuSD/QAdbezg0XqWOk/nk2KJlg9kKs1oxOjV+wZqfQ94wM9QH5OdrBIHW1W9JvofdYPDFr6TIptokvtFKmSH+jXtcYAshsV3eVgkbpS+mCuPaOFrSIYkLFJ62cr99ofkg/0ACTJGtFLDhapaz0fHR+tbR3BXG0UnZ74Kr3kAz0Ac/ikQ0UqRddFuyWtb81Aky0a7R3dbi9Itf5Av551B5Dd8Q4VqTS9kLSeafEeq4kGGRJtGZ2Z+Cu85AM9AAM2IrrRoSKVrvT3wd+NlremqKlVox9GD5t3yQd6AAZnxWiKQ0Uq7ZPwL48+n7QeBAZVtnT0laT10xLzLelZH+gBsts6mu1QkUrdq9EF0c6J39dTHenv4D8b/bH3H6fMsiQf6AFydqgDRapML0a/jnaKRltflEz6LZLdev/xabp5lTSAD/TrW50Agzc0utSBIlWuab0fmnZLfBWf7hkf7dV7jswwl5J8oAforHHRAw4UqbL9//buBOiusjDj+ElYEqJAAAEFCqQwIg5WBDcUkS2ALLIKsigQjBBW2UHZUrTVyqAsKlYrFMROW0EtA4hGB2VzpZRFRhEGSqMgSFglgSTT53iutiDL/dZ73nt/v5n/jDPtdGpyz3nvk+9+59Yj6vvp2LSeWxpj7I3pY+nGykfoJRn0AD33N+kpB4rUN0/F/2yanpZ2e2OEpqSd0hfT/a4vSWM06N/mdgswfHs6TKS+/D37K9PRaQO3ObpQfwf8m9NJVfMAu/muI0kGPUD7/Z3DROrrfpMuTh9Ma7rl0VF///vMqnnA4sOuE0k96jGDHmBkP5G50mEiDUz3pUs6Q87v2w+GCVXzq1WHd8b7b10Hkgx6gP6wfPqlw0QayB5Il6UT0rsr323fL/f0+vkJp1TNNyA84nUuyaAH6F+v69xIHSjSYLcw3VI1Dz+bkd5Ueahemy1TNU+FPjh9Jf0iLfY6llTooH+72zrA8OzQeSPvQJH0/3umM/AvSkelzdIKbpnjbpW0dTo+XZrucM+WZNAD8CcfcZBI6rL6I/r1992fnw5Nm3cGJyOzetV8TL7+h5P6ExLXVR5SJ2mwBv0mjgKA4fmCg0TSCHo8/Wf6evpk1Txsb4u0dlrKLbaalNbpDPZZ6az0jXRbesrrR5IMeoDhWjJd4yCRNAYtqpqvy/tx+vd0djo67Z22TBuklavmmzZKs0R6ddU8Ob4e6vum49I5nbH+s/Rg5XfaJcmgBxhD9dOQ73CQSOpR9e+C1x/jvzX9MP1HurgzjGd3/gFgRucfAXZO26RN08Zp/TQtrVk1H1mvB/arqub3/JdNy3X+88qd/1n9v7NW+uv0+s7/jXelbdMuaZ90UDo2nZnOq5qv96ufFF9/BP729FDnHyr83UnS6H7Sy6AHGIZpnTeoDhNJkiQZ9AAFeWea7yCRJElSDwf9O7wtBxi6fR0ikiRJMugBynOyQ0SSJEkGPUB5Pu8QkSRJUo8H/Tu9LQcYmvqror7hEJEkSZJBD1CWZdKNDhFJkiT1sCcMeoChWyn90iEiSZIkgx6gLPV30D/gEJEkSZJBD1CWjTo3UAeJJEmSejnoN/XWHGBotkrzHSKSJEky6AHKsmta6BCRJEmSQQ9QlgPTYoeIJEmSejzo3+WtOcDQHO0AkSRJkkEPUJ4zHSCSJEky6AHKc74DRJIkST3uSYMeYGgmpEsdIJIkSTLoAcqyZLrcASJJkqQWDPrNvD0H6N7S6QoHiCRJkgx6gLJMSt92gEiSJKkFg/7d3p4DdG9ymuMAkSRJkkEPUJYp6QcOEEmSJBn0AGV5ZbrBASJJkiSDHqAsy6WfOEAkSZLU454y6AGGZmr6sQNEkiRJLRj0m3t7DjC0n9D7yL0kSZIMeoDC1L9Df60DRJIkSQY9QFnqp9z72jpJkiS1YdBv4e05QPfq76H/tgNEkiRJBj1AWSalKxwgkiRJasGg39Lbc4DuLZUud4BIkiTJoAcoy5LpYgeIJEmSDHqAskxI5zpAJEmS1OP+YNADDN1sB4gkSZIMeoDyHJUWO0QkSZLU40G/lbfmAENzQFroEJEkSZJBD1CWXdJ8h4gkSZIMeoCy1L+r9LhDRJIkST0e9Ft7aw4wNBum3zhEJEmSZNADlGWtdKdDRJIkSQY9QFlWTDc4RCRJktTjQT/dW3OAoZmcLneISJIkyaAHKMvEdL5DRJIkST3saYMeYHhOTIsdJJIkSTLoAcqyd+W76CVJkmTQAxRnk/Sgg0SSJEk9HPTbeFsOMHRrp9sdJJIkSTLoAcqyXLraQSJJkqQeDvptvS0HGLol0nkOEkmSJBn0AOU5PC10mEiSJMmgByjLdmmew0SSJEk9GvTbeUsOMDyvTb9wmEiSJKkHzTfoAYZv2fQth4kkSZIMeoCyTEiz02IHiiRJkgx6gLLskh53oEiSJMmgByjL69NdDhRJkiT1YNC/x9txgOGbmq5yoEiSJMmgByjLxHRaWuRQkSRJ0jgP+u29HQcYmenpIYeKJEmSDHqAsqyRbnSoSJIkyaAHKMtS6bMOFUmSJI3zoN/BW3GAkduz8vV1kiRJMugBirNeutXBIkmSpHFqgUEPMDompy84WCRJkmTQA5Rnt/SIw0WSJEkGPUBZ1kzXO1wkSZI0ToN+R2/BAUbHEunMtMgBI0mSJIMeoCxbpLkOGEmSJBn0AGVZKX3TASNJkqRxGPQ7efsNMLoOqnwnvSRJkgx6gOJMS9c5ZCRJGlZXVL41Rup20L/XW2+A0TUxndS5yTpsJEl6+eal/Trn6EYGvWTQA/TShul2B40kSS/ZNWmN552hBr1k0AP01KR0dlrssJEk6Tk9lQ59iTPUoJcMeoCe2yzd5bCRJOmP3ZDW7eL83Nigl7rqGYMeYOxMqZqf0i9y4EiSBrT6p/FHV83zZbpl0EvdD/qdveUGGDubpDsdOJKkAevaqrufxr/YoJ/nz1Ay6AF6bXL6ZFro0JEk9XlPpMPShBGenQa9ZNADtMZb0m0OHUlSnzYnrT2K56ZBL3U/6HfxVhtgbC2dZle+l16S1D89nA4Yo3PzzQa9ZNADtMn66YcOHklS4X01rTzGZ6ZBL3U/6Hf1Nhtg7NW/T3hQ+r3DR5JUWPekbcbxzHyLQS8Z9ABtU/9E4xKHjySpgJ5N/1A1X8E63gx6yaAHaKWt0l0OIElSS7s+vaHHZ2U96B/1dyF1Neh38/YaYPzUX2N3ZprvEJIktaSH0oHVyL9uzqCXDHqAvrduutIhJEnqYYvSF9OKLTwnDXqp+1+NMegBemDH9GsHkSRpnPt5emvLz8i3GvSSQQ/QZpPSKekph5EkaYz7XZqZJhZyRhr0kkEP0Hprpq87jCRJY/RG/zNpaoHno0EvdX+d7+4tNUDv1E+9v8OBJEkapb6T1i/8bHybQS8Z9AAlWCIdkh50KEmShln9TJad++hsrAf9Y/5epa4G/R7eTgP01nLp79PTDiZJUpc9ko5OS/fhuWjQSwY9QFHWSv/iYJIkvUQL0tlphT4/Ew16yaAHKPINzA0OJ0nS86ofoLrOgJ2HBr3U3aB/n7fQAO1R35TvckBJ0sB3Y9p0QM/Ctxv0kkEPUKIl08FprkNKkgau+ltPdnYUGvTSEAb9nm4ZAO2yTDqhah545LCSpP7uvnRAmuj4+7NNDHrJoAco2dT0ifSkw0qS+q6Hq+YJ9ZMcdwa9ZNAD9KdV0/npGQeWJBXfvHRqWtbx1tWgf9xrRjLoAUo3LX25c8N2cElSWdWj9G+r5lNXGPTSaLfQoAcoY9R/qfKTekkqofpXpT6ZVnJ8GfSSQQ9AbW2jXpJaPeLPSqs4rgx6aZwH/V5uGQBlWCv9o1EvSa2ofmhb/fDSVzmeRt07DHrJoAfo11F/QZrvEJOkce/36bTK78Qb9FJ7Bv373TIAyvLq9KnKV/pI0nj0YDqx8nT68fROg14y6AH62fLp5PSAw0ySRr1fp0PSZMeNQS8Z9ACMhfqN5qx0twNNkkbcz6vmadFLOF5aMeif8JqUuhr0e7tlAJRric6/zN7sUJOkIfedtJWjxKCXDHoAemnz9M20yOEmSS9a/UDRC9MbHRsGvdQng34ftwyA/rBuOtebIEn6i4fazU6rOiaKsamzTDLoAQZR/bC8Y9K9DjlJA9xtaUaa5Fgw6CWDHoCS1L9Xv0e6zkEnaYDe1F6WtnQEGPTSgN379nXLAOhPb0ifr3z1j6T+/Sj9x9Nfud33nXcZ9JJBD0BVvbJqvkv5FoeepD7ops6b16Xd3g16SQY9wKDYJF1cNU94dgBKKqVH0+fShm7jAzfon/T6l162RQY9wOBYKR2X7nQASmpxN6YD0xS3bYNekkEPwHPVP63/UuV36yW1o0fSOWkDt2cMemnIg34/twyAwVP/5Gv/dG1a7ECUNI7Vv/N5VXpf5WvleGGbGfSSQQ/Ay1unap4Sfb9DUdIYdkc6Ib3GbReDXhrVQf8BtwyAwTYxbZ2+kh5zOEoahR6qmofZvdUtlmF4t0EvGfQADM3ktHu6vPI0fElDqx5fl6bt05Jupxj0kkEPQG9MTQel73cOCgempOf3bLoy7ZNe4baJQS/1bNB/0C0DgBeyejqmar5CyoPzJAP+O2lmepXbI+Mw6J9y3UkGPQCjM+yPTD+o/MReGrQB/yEDHoNeavWg398tA4BurJoOSXOq5munHKRS/1Q/N+OqzoBfye2OHtvcoJcMegDGRv3Tuvp37K9If3CYSkU2L321ar4Lflm3NQx6yaAHYLAsk3ZMF1S+x15qe/el89JWlafQY9BL/TToD3DLAGCk3pROTT+pPEBPasPvv1+bTkgbuD1RoC0MesmgB2D8vTrNSP+aHnbQSuPSA+nCqvn4/PJuQxj0kkEPACMxMb05fbRqflK4wKErjUpPV83T549PG6YJbjcY9NJAD/oD3TIAGEuvSDukc9KdDl+p6+pfX7k5fSptnSa7nTAgtjToJYMegPZZLe1dNQ/SM+6l5473/+r8w9dula+Ow6D3LSpSd4N+hlsGAL2wStqjap68fWvlYXoarDdgfxrvuxrvYNBLI/jHYIMegJ6rB80u6ax0fdX8nrCDWv3QE2lOmp22rTy0Dgx6yaAHoI8tVTUP1DsiXZrudmCrkDdVv0pfTYdVzQPrlnA5g0EvGfQADLKV007pE1XzdO+HHODqcXPTN6rmWxymp6kuUxhVWxn0kkEPQH9aI703nZ6+me5zoGuMuiddnk7r/KPSai4/MOillg36g9wyAChZ/fv39Vd61d/LfUnVfM2XN4LqtvqrsX6aLkxHpc0qv+cOvba1+7hk0AMwmCamdarmp/gnGfmqmocs3tx5LdSvifqn7dPSBJcLGPSSQQ8AZYz87dORVfNVeVenu9Kz3hAU38L063RV+mzVPJSu/t32tTp/94BBL/XroP+QWwYAg2rJztDftjMCP5O+VTU/zX3YG4XWVD8I8Sfp39Kn0iGdv7PXVs23IgD9ZbpBLxn0ADASU9J6VfOTovoJsvVD+P4pfTfdmR7xRmLE1X+Gt1bNpyW+1PkzPqgz1jdIy3oZwsAO+qfdI6WuBv1MtwwAGLqlq+aJ+xtXzUf5D0wnprPTpWlO1fykv35S+ry0qM/fUNT/He9OP6uarxf8WtV84uHkzj+I7JDektZMk718AINeMugBoAT1w9fq7ypfO22Ytki7dobuUZ3Re2Y6K30+XVQ1Hy+/In0v3ZRuSbdXzacDftX5h4L6K/v+Jz1QNR9Lr3/i/XinemD/Pv0u/bZqvjv9v9O9VfPsgNs64/v6zj8+XJku6wzxL3fGeP3/0wlpVvpA2qVqPrFQD/N104qV31EHDHrJoAcAADDopSEN+g+7ZQAAAG2xjUEvGfQAAIBBL/XzoD/YLQMAAGiLbQ16yaAHAAAMesmgBwAAMOilVg36Q9wyAACAttguzTfWJIMeAAAw6KV+HfSz3DIAAACDXjLoAQAADHrJoAcAAAx6SS806A91ywAAANriPQa9ZNADAAAGvWTQAwAAGPRSqzLoAQCA1tjeoJcMegAAwKCX+rnD3DIAAIC22MGglwx6AADAoJcMegAAgHEa9AsMNamrDnfLAAAADHrJoAcAADDopXHoCLcMAACgLXY06CWDHgAAMOglgx4AAMCgl1rVkW4ZAABAW+xk0EsGPQAAYNBL/dxRbhkAAEBbvNeglwx6AADAoJcMegAAAINealUfccsAAADaNOifMdQkgx4AADDopX7taLcMAACgLXY26CWDHgAAMOglgx4AAMCgl1rVMW4ZAABAW+xi0EsGPQAAYNBL/dyxbhkAAEBb7GrQSwY9AABg0EsGPQAAgEEvtarj3DIAAIC22M2glwx6AADAoJf6uePdMgAAgDYN+mcNNcmgBwAADHrJoAcAADDopdZ0glsGAADQFrsb9JJBDwAAGPSSQQ8AAGDQS63qRLcMAACgLfYw6CWDHgAAMOilfu4ktwwAAKAt3mfQSwY9AABg0EsGPQAAgEEvtaqT3TIAAIC22NOglwx6AADAoJf6uY+6ZQAAAG0a9AsNNcmgBwAADHrJoAcAADDopdb0MbcMAACgLfYy6CWDHgAAMOilfu4UtwwAAKAt3m/QSwY9AABg0EsGPQAAgEEvtapT3TIAAIC22Nuglwx6AADAoJf6udPcMgAAgLbYx6CXDHoAAMCglwx6AAAAg15qVae7ZQAAAG2xr0EvGfQAAIBBLxn0AAAABr3Uqk5yywAAANo06BcZalJXHe6WAQAAGPRSWS1O+7tlAAAAbbGfQS911TNpS7cMAADAoJfKal5a3y0DAAAw6KWyuiet6JYBAAC0xQcMeqmrrk4T3TIAAACDXvId9AAAAMP2QYNeetnqa8QD8QAAAINeKqz701S3CwAAwKCXyuprbhUAAEDb7G/QSy/b7m4VAACAQS+V1dy0nFsFAADQNgcY9NJLdp7bBAAAYNBL5T3dfkO3CQAAwKCXyup7bhEAAEBbHWjQSy/aDm4RAACAQS+V1R1polsEAADQVjPSYuNN+ov2cnsAAAAMeqmsbksT3B4AAACDXiqr3dwaAAAAg14qq+vcFgAAAINeKq+N3BYAAACDXiqrf3ZLAAAASnGQQS/9sT+k5d0SAAAAg14qq4PdDgAAgJJ8yKCXqpvcCgAAAINeKq9pbgUAAIBBL5XVsW4DAABAiWYa9BrgbnQLAAAADHqprOrX/apuAQAAQKk+bNBrQNvX5Q8AABj0Ulld5NIHAAAMeqms5rrsAQCAfnCwQa8By1fUAQAABr1UWHu75AEAgH5xiEGvAekclzsAAGDQS2V1g0sdAAAw6KWyetRlDgAA9KNZBr36vNVd5gAAgEEvldXWLnEAAKBfHWrQq0+b6fIGAAAMeqmsPu7SBgAABmHQG4Dqpy52WQMAAAa9VFbfdUkDAAAGvVRWN7ucAQCAQXKYIag+6F6XMgAAYNBLZfWYyxgAADDopbJa4BIGAAAG1eFGoQptscsXAAAw6KXyWsrlCwAAGPSSMQ8AAFCUI4xDVT5mDwAAYNBLY9R8lysAAMD/OdJQVAHNc6kCAAAY9Cqre1ymAAAABr3K6qcuUQAAgBd2lNGolnaNyxMAAMCgV1ld6NIEAAB4aR8xHtWyznBZAgAAGPQqqxkuSQAAAINeZbW5yxEAAKB7RxuSakGruBQBAAAMepXTQy5BAACA4TnGqFSPutblBwAAYNCrrD7t0gMAADDoVVa7u+wAAABG7lgDU+PYai45AAAAg17ldLdLDQAAYHQdZ2xqjLvAZQYAAGDQy+/LAwAAYNBrjHo2reDyAgAAGDvHG58a5ea4rAAAAAx6ldUslxQAAMD4OMEI1Si0KL3G5QQAAGDQy0fsAQAAMOg1Ru3nEgIAAOiNE41SDaPH0hSXDwAAgEGvcvqcywYAAMCgVzktTuu5ZAAAANrhJENVXXS1SwUAAMCgV1lNd5kAAAC0z8kGq16km1weAAAABr3K6j0uDQAAAINe5fQjlwQAAEAZPmrEqtOmLgcAAACDXuV0mcsAAACgPB8zaAe2BWldlwAAAIBBr3Ka7aUPAABg0KucfpkmedkDAACU7xQjdyBanLb0cgcAADDoVU7nepkDAAD0n1MN3r7tF2kZL3EAAACDXuU8vX4jL20AAACDXuV0qJc0AADAYDjNCO6LLvFSBgAAMOhVTrekKV7GAAAAg+d0o7jI5qY1vHwBAAAMepXRk5UH3gEAAGDQF9MzaXsvVwAAAP7kDGO51S1Me3qZAgAAYNCX0eI0w8sTAACAF3Oy8dyqFhnyAAAAdOOIqvlpsDHd+9+R99F6AAAAurZ/Z0wa1b17ar2H3QEAADBkW6V5hnVPvkfe188BAAAwbOunewzsceuWtIaXHQAAACO1Yrra0B7zLklTvNwAAAAYLRPT6VXzdHXDe3RbkGZ5iQEAADBWtkz3G+Cj1p2V348HAABgHExNXzPER1T91X/npmW8nAAAABhPu1fNk9eN86H1q6r5hAMAAAD0xHLpvMrv0nfT/HRGmuRlAwAAQBtsmL5nsL9ol6V1vUwAAABoox3THcb7n/tR2tTLAgAAgLarv8Zur3TbAI/4m9J2XgoAAACUZkLaLV1fDc4T6q9O0/3VAwAA0A82Thenp/twxD+WPpde568ZAACAfrR8OrhqPoZe8oCvn94/J+2XpvhrBQAAYFBMS8emG6vmI+ptH/DPpu+mWek1/voAAAAYdKumfdNFaW6LBvzd6YK0e1rBXxMAAAC8uPqn9nunc9IN6dFxGO4PpWvTp6vmwX2r+WsAAACAkVk9bZ1mpo9XzQP16o+935zurZoH0S2onvuR/fo/z0/z0j3pp+madGE6I81Im6dV/PECAABAby2dlvLH8NL+FxIFhKMMk5f+AAAAAElFTkSuQmCC) no-repeat;background-size:19px;background-position:19px;padding:15px 0 15px 53px!important}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper input:focus{background-color:#fff!important;border:1px solid #e7e7e9}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper .mat-form-field-label-wrapper label{margin-top:21px;margin-left:55px}eqp-table ::ng-deep mat-header-row{background-color:#ebebeb;border-bottom-width:0px}eqp-table ::ng-deep mat-header-row .mat-column-Required{flex:none!important}eqp-table ::ng-deep .mat-sort-header-button{color:#3b3a3b;font-size:15px}eqp-table ::ng-deep .mat-row{background-color:#fff;margin:10px 0;box-shadow:0 3px 7px -3px #0003;padding:5px 0}eqp-table ::ng-deep .mat-row .mat-column-Required{flex:0 0 8%!important}eqp-table ::ng-deep .mat-row mat-cell eqp-select{margin-top:16px}eqp-table ::ng-deep .mat-row mat-cell eqp-select .mat-form-field-wrapper{padding-bottom:0}eqp-table ::ng-deep .mat-row .mat-cell:last-child span i.success-color{background-color:#383fec;color:#fff!important;padding:6px;border-radius:3px}@media screen and (max-width: 1100px){.row:not(.title){margin:0!important}.second{display:flex;flex-direction:column}.second .col-sm-12{margin:0}.buttonsForm{padding:0 30px 20px 0;margin:50px 0 0}}@media screen and (max-width: 766px){.increasableValues{display:flex;flex-direction:column}.increasableValues .col-sm-12{margin:0 0 -1.5em}.second{display:flex;flex-direction:column}.second .col-sm-12{margin:0 0 -3.4em}.buttonsForm{margin:55px 0 0!important;padding:0 13px 20px 0;transform:translateY(110px)}}@media screen and (max-width: 577px){.increasableValues .col-sm-12{margin:0 0 1.5em}}:host ::ng-deep .mat-input-element{width:100%;width:-moz-available;width:-webkit-fill-available;width:fill-available}\n"], dependencies: [{ kind: "component", type: i6.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i8.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i8.MatLabel, selector: "mat-label" }, { kind: "directive", type: i8.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "component", type: i9.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "component", type: i10.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i10.MatCardContent, selector: "mat-card-content" }, { kind: "directive", type: i10.MatCardFooter, selector: "mat-card-footer" }, { kind: "component", type: i10.MatCardHeader, selector: "mat-card-header" }, { kind: "directive", type: i10.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { kind: "component", type: i11.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass"], exportAs: ["matTab"] }, { kind: "component", type: i11.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "fitInkBarToContent", "mat-stretch-tabs", "dynamicHeight", "selectedIndex", "headerPosition", "animationDuration", "contentTabIndex", "disablePagination", "disableRipple", "preserveContent", "backgroundColor"], outputs: ["selectedIndexChange", "focusChange", "animationDone", "selectedTabChange"], exportAs: ["matTabGroup"] }, { kind: "component", type: i12.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i13.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { kind: "directive", type: i1.MinValidator, selector: "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]", inputs: ["min"] }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i14.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i14.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i14.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i14.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i15.EqpAttachmentsComponent, selector: "eqp-attachments", inputs: ["disableAction", "showHeader", "headerTitle", "attachmentsList", "showMatCard", "multipleAttachment", "loadMultipleFiles", "attachmentsColumns", "emptyTableMessage", "allowOnlyImages", "acceptedFileTypes", "isDisabled", "showInlinePreview", "getAttachmentEndpoint", "productionBaseUrl", "compressionOptions", "allowedTypes", "isEqpTableMultiLanguage", "tablePaginatorVisible", "isTableSearcheable", "tablePaginatorSize", "separatedUploadButtons", "showPreview", "singleAttachmentDragAndDrop", "cropOptions", "cropDialogClass", "downloadTooltipPosition", "openLinkLabel", "addButtonLabel", "downloadLabel", "deleteLabel", "fileNameLabel", "previewLabel", "uploadFileLabel", "confirmLabel", "abortLabel", "saveLabel", "exitLabel", "uploadWithDropboxLabel", "cropLabel", "eqpTableSearchText", "deleteDialogTitle", "deleteDialogMessage", "noImageSelectedErrorMessage", "wrongTypeSelectedErrorMessage", "videoPreviewErrorMessage", "flipHorinzontalLabel", "flipVerticalLabel", "rotateRightLabel", "rotateLeftLabel"], outputs: ["localEditedAttachments", "abortAddAttachment", "downloadAttachment", "onDeleteAttachment"] }, { kind: "component", type: i2.EqpSelectComponent, selector: "eqp-select", inputs: ["placeholder", "enumData", "enumDataToExclude", "arrayData", "arrayKeyProperty", "arrayValueProperty", "ngModelOptions", "ngModelInput", "formGroupInput", "formControlNameInput", "isRequired", "isDisabled", "isMultiLanguage", "multilanguagePrefixKey", "isAlphabeticalOrderable", "suffixIcon", "prefixIcon", "isMultiSelect", "showCancelButton", "isSearchable", "noResultSearchText", "isReadonly", "isSearchWhileComposing", "appendToInput", "dropdownPosition", "selectOnTab", "selectAll", "selectAllText", "selectableGroupAsModel", "clearAllText", "customOption", "customLabel", "class", "data"], outputs: ["ngModelInputChange", "formControlChange"] }, { kind: "component", type: i16.TmwDateTimePickerComponent, selector: "tmw-datetimepicker", inputs: ["debugMode", "ngModelInput", "formGroupInput", "formControlNameInput", "pickerMode", "timeType", "label", "placeholder", "hint", "minDate", "maxDate", "locale", "inputFormat", "outputFormat", "forSaveLocalOnDB", "disabled", "readonly", "currentDateAsDefault", "showSpinners", "touchUi", "enableMeridian", "hideTime", "stepHour", "showHours", "hourLabel", "stepMinute", "showMinutes", "minuteLabel", "stepSecond", "showSeconds", "secondLabel", "disableMinute", "dayLabel", "monthLabel", "yearLabel", "highLightedDates", "highLightedAriaFormat"], outputs: ["ngModelInputChange"] }, { kind: "component", type: i17.AddFormulaComponent, selector: "eqp-dynamic-module-add-formula-component" }, { kind: "directive", type: i18.DynamicLoaderDirective, selector: "[appDynamicLoader]", inputs: ["data"], outputs: ["out"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AddFormFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "eqp-dynamic-module-add-form-field", template: "<!-- <div class=\"add-form-field bigwrapper\" style=\"max-height: 100vh !important; overflow-x: hidden; overflow-y: auto;\"> -->\r\n\r\n<mat-card class=\"add-form-field\">\r\n    <mat-card-header>\r\n        <mat-card-title>\r\n            {{indexField != null && indexField >= 0 ? \"Modifica\" : \"Aggiungi\"}} campo\r\n        </mat-card-title>\r\n    </mat-card-header>\r\n\r\n    <mat-card-content>\r\n\r\n        <div class=\"container-fluid containerContent \">\r\n            <form [formGroup]=\"fieldFormGroup\" style=\"height: 100%;\">\r\n                <!--#region AREA PRINCIPALE -->\r\n                <div class=\"row eqp-dform-add-form-field-main\">\r\n                    <!--#region TIPO CAMPO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2 tipoCampo\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldType'].status != 'VALID' && fieldFormGroup.controls['FieldType'].touched }\">\r\n                            Tipo campo *\r\n                        </mat-label>\r\n                        <eqp-select [enumData]=\"FieldTypeEnum\" [(ngModelInput)]=\"field.FieldType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onFieldTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'FieldType'\"\r\n                            [enumDataToExclude]=\"fieldTypesToExclude\">\r\n                        </eqp-select>\r\n                    </div>\r\n                    <!--#endregion TIPO CAMPO -->\r\n\r\n                    <!--#region CODICE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Label'].status != 'VALID' && fieldFormGroup.controls['Label'].touched }\">\r\n                            Codice *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input formControlName=\"Label\" required matInput [(ngModel)]=\"field.Label\"\r\n                                (keypress)=\"omit_special_char($event)\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (focusout)=\"stringSanitizer(field.Label)\">\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Label') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['pattern']\">\r\n                                        Si possono inserire solo lettere a-z\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion CODICE -->\r\n\r\n                    <!--#region DESCRIZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Description'].status != 'VALID' && fieldFormGroup.controls['Description'].touched }\">\r\n                            Descrizione *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input name=\"Description\" formControlName=\"Description\" required matInput\r\n                                [(ngModel)]=\"field.Description\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Description)\">\r\n                            <!-- <mat-error *ngIf=\"!field.Description.valid && field.FormFormGroup.controls[field.Description].touched\"> -->\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Description') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion DESCRIZIONE -->\r\n\r\n                    <!--#region SEZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\" *ngIf=\"formFieldsGroups\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldGroup'].status != 'VALID' && fieldFormGroup.controls['FieldGroup'].touched }\">Sezione\r\n                            *</mat-label>\r\n                        <eqp-select [arrayData]=\"formFieldsGroups\" [(ngModelInput)]=\"field.FieldGroup\"\r\n                            [arrayKeyProperty]=\"'Name'\" [arrayValueProperty]=\"'Name'\" [formGroupInput]=\"fieldFormGroup\"\r\n                            [formControlNameInput]=\"'FieldGroup'\" required>\r\n                        </eqp-select>\r\n                        <mat-error>\r\n                            <!-- {{ getFormValidationErrors('FieldGroup') }} -->\r\n                            <ul>\r\n                                <li *ngIf=\"fieldFormGroup.controls['FieldGroup'].errors?.['required']\">\r\n                                    Obbligatorio\r\n                                </li>\r\n                            </ul>\r\n                        </mat-error>\r\n                    </div>\r\n                    <!--#endregion SEZIONE -->\r\n\r\n                    <!--#region OBBLIGATORIO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Required\" formControlName=\"Required\"\r\n                            color=\"primary\">\r\n                            Obbligatorio\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion OBBLIGATORIO -->\r\n\r\n                    <!--#region READONLY -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Readonly\" formControlName=\"Readonly\"\r\n                            color=\"primary\">\r\n                            ReadOnly\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion READONLY -->\r\n\r\n                </div>\r\n                <!--#endregion AREA PRINCIPALE -->\r\n\r\n                <!--#region AREA TABS -->\r\n                <mat-tab-group class=\"eqp-dform-add-form-field-tabs\" mat-stretch-tabs=\"false\" mat-align-tabs=\"start\">\r\n                    <!--#region STILE COMPILAZIONE -->\r\n                    <mat-tab label=\"Stile Compilazione\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesCompilazione\" [(ngModelInput)]=\"field.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'ColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"LabelstyleCSS\" formControlName=\"LabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['LabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"FieldstyleCSS\" formControlName=\"FieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['FieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n                        \r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.VisibleIf != null || field.VisibleIf != undefined) && field.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.InListView\" formControlName=\"InListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['InListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n\r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilit\u00E0 del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'Invisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.VisibleIf\" (click)=\"openVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['VisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                            <!--#region TOOLTIP -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Tooltip </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"Tooltip\" formControlName=\"Tooltip\" matInput [(ngModel)]=\"field.Tooltip\"\r\n                                        spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.Tooltip)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Tooltip') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion TOOLTIP -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE COMPILAZIONE -->\r\n\r\n                    <!--#region STILE DELLA RISPSOTA -->\r\n                    <mat-tab label=\"Stile Risposta\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesRisposta\" [(ngModelInput)]=\"field.AnswerStyle.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleLabelstyleCSS\" formControlName=\"AnswerStyleLabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleLabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleFieldstyleCSS\" formControlName=\"AnswerStyleFieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleFieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n\r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.AnswerStyle.VisibleIf != null || field.AnswerStyle.VisibleIf != undefined) && field.AnswerStyle.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.AnswerStyle.InListView\" formControlName=\"AnswerStyleInListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['AnswerStyleInListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n                            \r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.AnswerStyle.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilit\u00E0 del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.AnswerStyle.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleInvisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleVisibleIf\" formControlName=\"AnswerStyleVisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.VisibleIf\" (click)=\"openAnswerStyleVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleVisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE DELLA RISPSOTA -->\r\n\r\n                    <!--#region SPECIFICHE -->\r\n                    <mat-tab label=\"Specifiche\">\r\n                        <div class=\"row\">\r\n                            <ng-container *ngTemplateOutlet=\"fieldTypeFormTemplate\">\r\n                            </ng-container>\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion SPECIFICHE -->\r\n\r\n                    <!--#region MODALITA' RECUPERO DATI -->\r\n                    <mat-tab label=\"Modalit\u00E0 recupero dati\">\r\n                        <div class=\"row\">\r\n\r\n\r\n\r\n                            <eqp-select [enumData]=\"dataGetterTypeEnum\" [(ngModelInput)]=\"field.DataGetter.DataGetterType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onDataGetterTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DataGetterType'\">\r\n                            </eqp-select>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Manuale\">\r\n                                <mat-label> Valore di Default </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"DataGetterValue\" matInput [(ngModel)]=\"field.DataGetter.DataGetterValue\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\">\r\n                                </mat-form-field>  \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Formula\">\r\n                                <mat-label> Formula (Javascript) </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"Formula\" matInput [(ngModel)]=\"field.Formula\"\r\n                                        (click)=\"openFormulaDialog()\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formula)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Formula') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field> \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da database']\">\r\n                                \r\n                                <div class=\"col-12 mt-4 configuraQueryEditor\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-10\">Configura in Query Editor</div>\r\n                                        <div class=\"col-2\">\r\n                                            <button class=\"btn btn-primary\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue == null\">Procedi</button>\r\n                                            <button class=\"btn btn-success\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue != null\">Modifica</button>\r\n                                        </div>\r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Seleziona colonna</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"columnKeys\" [(ngModelInput)]=\"field.DataGetter.DataGetterColumnForce\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                            [showCancelButton]=\"true\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                \r\n                                </div>\r\n                                \r\n                        \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da modulo dinamico']\">\r\n                                \r\n                                <div class=\"col-12 mt-4\" *ngIf=\"forms.length > 0\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-6\">Modulo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona modulo'\" [arrayData]=\"forms\" [(ngModelInput)]=\"DMModule\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'Code'\" [arrayValueProperty]=\"'Name'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMModule'\"\r\n                                            (ngModelInputChange)=\"onChangeDMModule()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null && DMModule != null\">\r\n                                        <div class=\"col-6\">Campo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona campo'\" [arrayData]=\"DMFields\" [(ngModelInput)]=\"DMField\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'key'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMField'\"\r\n                                            (ngModelInputChange)=\"onChangeDMField()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Cardinalit\u00E0</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [enumData]=\"DMGetterCardinalities\" [(ngModelInput)]=\"field.DataGetter.DataGetterCardinality\"\r\n                                            [showCancelButton]=\"false\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>         \r\n                                    \r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Contestualizzazione</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"contestualization\" [arrayKeyProperty]=\"'entityTableName'\" [arrayValueProperty]=\"'entityTableName'\" [(ngModelInput)]=\"field.DataGetter.DataGetterContestualization\"\r\n                                            [showCancelButton]=\"true\" (ngModelInputChange)=\"onChangeDMContestualization()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>                                      \r\n                                \r\n                                </div>\r\n\r\n                            </div>\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion MODALITA' RECUPERO DATI -->\r\n\r\n                </mat-tab-group>\r\n                <!--#region AREA TABS -->\r\n\r\n                <!--#region listValueFieldFormTemplate vallues -->\r\n                \r\n                <!--#endregion listValueFieldFormTemplate vallues -->\r\n\r\n            </form>\r\n        </div>\r\n    </mat-card-content>\r\n\r\n    <mat-card-footer>\r\n\r\n        <div class=\"d-flex justify-content-end mt-2 mb-1 me-3\"> \r\n            <!-- <div class=\"buttonsForma\"> -->\r\n            <button class=\"btn mat-raised-button cancel\" (click)=\"saveAndExitAddField(false)\" type=\"button\">\r\n                Annulla\r\n            </button>\r\n            <span class=\"me-2\"></span>\r\n            <button class=\"mr-2 save\" mat-raised-button color=\"primary\" (click)=\"saveAndExitAddField(true)\"\r\n                [disabled]=\"disableSaveField()\" type=\"button\">\r\n                Salva\r\n            </button>\r\n            <!-- </div> -->\r\n        </div>\r\n    </mat-card-footer>\r\n</mat-card>\r\n\r\n<!-- </div> -->\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI DI TESTO -->\r\n<ng-template #textFieldFormTemplate>\r\n    <!--#region MASCHERA -->\r\n    <div class=\"col-sm-12 col-md-6\">\r\n        <mat-label>Maschera</mat-label>\r\n        <eqp-select [enumData]=\"TextMaskEnum\" [(ngModelInput)]=\"field.TextMask\" [formGroupInput]=\"fieldFormGroup\"\r\n            [formControlNameInput]=\"'TextMask'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion MASCHERA -->\r\n\r\n    <!--#region SPEECH TO TEXT -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SPEECH TO TEXT -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MinLenght'].status != 'VALID' && fieldFormGroup.controls['MinLenght'].touched }\">\r\n            Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MaxLenght'].status != 'VALID' && fieldFormGroup.controls['MaxLenght'].touched }\">\r\n            Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI DI TESTO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 ETICHETTA -->\r\n<ng-template #labelFieldFormTemplate>\r\n\r\n    <!--#region ETICHETTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-form-field>\r\n\r\n            <textarea name=\"Etichetta\" placeholder=\"Etichetta\" matInput formControlName=\"Etichetta\" [(ngModel)]=\"field.Etichetta\"></textarea>\r\n\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion ETICHETTA -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 ETICHETTA -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI AREA DI TESTO -->\r\n<ng-template #textareaFieldFormTemplate>\r\n    <!--#region RIGHE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Righe </mat-label>\r\n        <mat-form-field class=\"righe\">\r\n            <input id=\"rows\" formControlName=\"Rows\" type=\"number\" [min]=\"0\" matInput [(ngModel)]=\"field.Rows\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.Rows)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Rows') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion RIGHE -->\r\n\r\n    <!--#region SpeechToText -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SpeechToText -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI AREA DI TESTO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI BOOLEANI -->\r\n<ng-template #booleadFieldFormTemplate>\r\n    <!--#region A TRE STATI -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsTristate\" formControlName=\"IsTristate\" color=\"primary\">\r\n            A tre stati\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion A TRE STATI -->\r\n\r\n    <!--#region TIPO PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di presentazione *</mat-label>\r\n        <eqp-select [enumData]=\"BoolPresentantioEnum\" [(ngModelInput)]=\"field.PresetationType\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresetationType'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO PRESENTAZIONE -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI BOOLEANI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI DATA -->\r\n<ng-template #dateFieldFormTemplate>\r\n    <!--#region TIPO DI DATA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di data</mat-label>\r\n        <eqp-select [enumData]=\"DateTimeTypeEnum\" [(ngModelInput)]=\"field.IsOnlyDate\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'IsOnlyDate'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI DATA -->\r\n\r\n    <!--#region FORMATO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Formato </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DateFormat\" matInput [(ngModel)]=\"field.DateFormat\"\r\n                [matTooltip]=\"'Indicare il formato seguendo la guida del pacchetto momentjs.'\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formato)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Formato') }} -->\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion FORMATO -->\r\n\r\n    <!--#region DATA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data minima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MINIMA -->\r\n\r\n    <!--#region DATA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data massima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI DATA -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI NUMERICI -->\r\n<ng-template #numericFieldFormTemplate>\r\n    <!--#region VALORE INTERO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsInteger\" formControlName=\"IsInteger\" color=\"primary\">\r\n            Valore intero\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion VALORE INTERO -->\r\n\r\n    <!--#region SEPARATORE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalSeparator\" matInput [(ngModel)]=\"field.DecimalSeparator\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.DecimalSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['pattern']\">\r\n                        Non \u00E8 possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE DECIMALI -->\r\n\r\n    <!--#region PRECISIONE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Precisione decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalPrecision\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.DecimalPrecision\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.DecimalPrecision)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalPrecision') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion PRECISIONE DECIMALI -->\r\n\r\n    <!--#region SEPARATORE MIGLIAIA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore migliaia </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"ThousandsSeparator\" matInput [(ngModel)]=\"field.ThousandsSeparator\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.ThousandsSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('ThousandsSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['pattern']\">\r\n                        Non \u00E8 possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE MIGLIAIA -->\r\n\r\n    <!--#region SIMBOLO VALUTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo prima del valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Simbolo valuta </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"CurrencySymbol\" matInput [(ngModel)]=\"field.CurrencySymbol\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.CurrencySymbol)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('CurrencySymbol') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['CurrencySymbol'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SIMBOLO VALUTA -->\r\n\r\n    <!--#region UNITA DI MISURA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo dopo il valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Unit\u00E0 di misura </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MeasureUnit\" matInput [(ngModel)]=\"field.MeasureUnit\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.MeasureUnit)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MeasureUnit') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MeasureUnit'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion UNITA DI MISURA -->\r\n\r\n    <!--#region VALORE MINIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore minimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MinValue\" type=\"number\" matInput [(ngModel)]=\"field.MinValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinValue') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MINIMO -->\r\n\r\n    <!--#region VALORE MASSIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore massimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MaxValue\" type=\"number\" matInput [(ngModel)]=\"field.MaxValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxValue') }}  -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MASSIMO -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI NUMERICI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI ALLEGATO -->\r\n<ng-template #attachmentFieldFormTemplate>\r\n    <!--#region ALLEGATI MULTIPLI -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiAttach\" formControlName=\"IsMultiAttach\" color=\"primary\">\r\n            Allegati multipli\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion ALLEGATI MULTIPLI -->\r\n\r\n    <!--#region ESTENSIONI ACCETTATE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Estensioni accettate</mat-label>\r\n        <eqp-select [arrayData]=\"AvailableFileExtensions.concat(AvailableImageExtensions)\"\r\n            [(ngModelInput)]=\"field.AllowedExtensions\" [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n            [isMultiSelect]=\"true\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AllowedExtensions'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion ESTENSIONI ACCETTATE -->\r\n\r\n    <!-- <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row mt-2\">\r\n            <div class=\"col-sm-12 col-md-6\">\r\n                <div class=\"header-title-standard\">\r\n                    Elenco metadata\r\n                </div>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-6 text-right buttonsForm\">\r\n                <button class=\"btn btn-primary save\" mat-raised-button color=\"primary\" type=\"button\"\r\n                    (click)=\"openMetadataDialog()\">\r\n                    <mat-icon>add</mat-icon>\r\n                    <span style=\"margin-left: 10px;\">Aggiungi allegato</span>\r\n                </button>\r\n            </div>\r\n        </div>\r\n        <eqp-table #metadataFieldsTable [createMatCard]=\"false\" [columns]=\"metadataColumns\"\r\n            [data]=\"field.MetadataFields\" [emptyTableMessage]=\"'Nessun metadata inserito'\" [searchText]=\"'Cerca'\">\r\n        </eqp-table>\r\n    </div> -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI ALLEGATO -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI LISTA DI VALORI -->\r\n<ng-template #listValueFieldFormTemplate>\r\n    <!--#region SCELTA MULTIPLA -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n            Scelta multipla\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SCELTA MULTIPLA -->\r\n\r\n    <!--#region TIPO DI PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Tipo di presentazione*</mat-label>\r\n        <eqp-select [enumData]=\"ListPresentationEnum\" [(ngModelInput)]=\"field.PresentationMode\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresentationMode'\"\r\n            (ngModelInputChange)=\"onPresentationModeChange()\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI PRESENTAZIONE -->\r\n\r\n\r\n    <!--#region GESTIONE OPZIONI -->\r\n    <div class=\"col-sm-12 mt-2\">\r\n\r\n        <mat-label> area dei valori da inserire </mat-label>\r\n        <mat-form-field>\r\n            <textarea matInput \r\n                placeholder=\"key1|value1;key2|value2\" \r\n                [(ngModel)]=\"field.ValueString\"\r\n                spellcheck=\"false\" \r\n                autocomplete=\"off\"\r\n                >\r\n            </textarea>\r\n        </mat-form-field>\r\n\r\n        <div class=\"row\" *ngIf=\"countValuePairs(field.ValuePairs) > 0\">\r\n            <h4 class=\"key-value-list-section-title\"> </h4>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Label opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.key\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Valore opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.value\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4  align-self-center\">\r\n                <span class=\"mr-3\">Opzioni inserite:</span>\r\n                <ul class=\"value-pairs-list\">\r\n                    <li *ngFor=\"let keyValuePair of getDictionaryKeyValue()\">\r\n                        <mat-icon class=\"mr-1\" (click)=\"deleteKeyFromDictionary(keyValuePair.key)\">close\r\n                        </mat-icon>\r\n                        <span><b>Label: </b> {{keyValuePair.key}} - <b>Valore: </b> {{keyValuePair.value}}</span>\r\n                    </li>\r\n                </ul>\r\n            </div>\r\n        </div> \r\n\r\n    </div>    \r\n    <!--#endregion GESTIONE OPZIONI -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI LISTA DI VALORI -->\r\n\r\n\r\n\r\n\r\n<!--#region FORM LISTA IMMAGINI -->\r\n<ng-template #imageFieldSelectorFormTemplate>\r\n\r\n    <div class=\"row\">\r\n        <div class=\"col-3 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-3 col-xs-12 col-middle\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n                Scelta multipla\r\n            </mat-slide-toggle>\r\n        </div>        \r\n    </div>\r\n\r\n    <eqp-attachments #imageSelectorAttachments [attachmentsList]=\"field.AttachmentList\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n    [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"true\" [showHeader]=\"false\"\r\n    [allowedTypes]=\"[AttachmentType.FILE]\" (localEditedAttachments)=\"catchButtonImagesChange($event)\"\r\n    [attachmentsColumns]=\"configColumnListImages\">\r\n    </eqp-attachments>\r\n\r\n  \r\n</ng-template>\r\n<!--#endregion FORM LISTA IMMAGINI -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI IMMAGINE -->\r\n<ng-template #imageFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.EnableDrawing\" formControlName=\"EnableDrawing\" color=\"primary\">\r\n                Immagine disegnabile?\r\n            </mat-slide-toggle>\r\n        </div>   \r\n    </div>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI IMMAGINE -->\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI IMMAGINE CON MARKERS -->\r\n<ng-template #imageWithMarkersFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageWithMarkersChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI IMMAGINE CON MARKERS -->\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIET\u00C0 CAMPI LOOKUP -->\r\n<ng-template #lookupFieldFormTemplate>\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.UseAsGetOrDiscard\" formControlName=\"UseAsGetOrDiscard\" color=\"primary\"\r\n            matTooltip=\"Se true la lookup viene visualizzata in una modale per lo scegli scarta\">\r\n            Usa per scegli o scarta\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <div class=\"col-sm-12 col-md-4 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Nome entit\u00E0 </mat-label>\r\n        <mat-form-field matTooltip=\"Nome dell'entit\u00E0 relazionata\">\r\n            <input formControlName=\"EntitySourceName\" required matInput [(ngModel)]=\"field.EntitySourceName\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.EntitySourceName)\">\r\n            <mat-error>\r\n                {{ getFormValidationErrors('EntitySourceName') }}\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row\">\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Nomi dei campi (invio per confermare) </mat-label>\r\n                <mat-form-field\r\n                    matTooltip=\"Elenco di campi ordinato che verr\u00E0 visualizzato nella lookup (premere invio per confermare)\">\r\n                    <input matInput (keyup)=\"onMultiSelectInputKeyup($event, 'FieldNames')\" spellcheck=\"false\"\r\n                        autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-8  align-self-center\">\r\n                <span class=\"mr-3\">Nomi selezionati:</span>\r\n                <div class=\"extension-container\" *ngFor=\"let extension of field.FieldNames; let i = index\">\r\n                    <span>{{extension}}</span>\r\n                    <mat-icon class=\"ml-1\" (click)=\"field.FieldNames.splice(i,1)\">close\r\n                    </mat-icon>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIET\u00C0 CAMPI LOOKUP -->\r\n\r\n<!-- DIALOG PER AGGIUNGERE UN METADATA NEI CAMPI DI TIPO ALLEGATO O IMMAGINE -->\r\n<!-- <ng-template #dialogMetadata>\r\n    <eqp-dynamic-module-add-form-field [field]=\"selectedMetadata\" [availableFields]=\"availableFields\"\r\n        [indexField]=\"indexSelectedMetadata\" (saveFieldEvent)=\"onSaveMetadata($event)\" [fieldTypesToExclude]=\"[6,7,10]\">\r\n    </eqp-dynamic-module-add-form-field>\r\n</ng-template> -->\r\n\r\n<ng-template #buttonImagesKeyValueInputColumn let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> {{col.display}} </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\" required spellcheck=\"false\" autocomplete=\"off\">\r\n    </mat-form-field>\r\n</ng-template>\r\n<!--DIALOG PER SEMPLIFICARE LA SCRITTURA DEL CAMPO FORMULA-->\r\n<ng-template #dialogFormula>\r\n    <eqp-dynamic-module-add-formula-component>\r\n    </eqp-dynamic-module-add-formula-component>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesImageTemplate let-row=\"row\" let-col=\"col\">\r\n    <img src=\"data:image/jpeg;base64, {{row[col.key]}}\" class=\"GenericListImagesImageTemplate\">\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesKeyTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Chiave </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesValueTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Valore </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER QUERY EDITOR -->\r\n<ng-template #dialogQE>\r\n    <ng-template [appDynamicLoader] [data]=\"QueryEditorComponent\" (out)=\"onExternalComponentOut($event);\">\r\n    </ng-template>\r\n</ng-template>\r\n  ", styles: [".mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0,0,.2,1);transform:scale3d(0,0,0);background-color:var(--mat-ripple-color, rgba(0, 0, 0, .1))}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;inset:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity .4s cubic-bezier(.25,.8,.25,1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:#00000052}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0!important;box-sizing:content-box!important;height:auto!important;overflow:hidden!important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0!important;box-sizing:content-box!important;height:0!important}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator:before{inset:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus:before{content:\"\"}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator:before{inset:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus:before{content:\"\"}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-app-background{background-color:var(--mat-app-background-color, transparent);color:var(--mat-app-text-color, inherit)}.add-form-field{max-height:100%;height:100%;overflow:hidden}.add-form-field mat-card-header{min-height:3rem}.add-form-field mat-card-content{height:calc(100% - 6rem);max-height:calc(100% - 6rem);overflow:auto;margin:0;padding:0 2rem 2rem}.add-form-field mat-card-content .eqp-dform-add-form-field-main{height:60%}.add-form-field mat-card-content .eqp-dform-add-form-field-tabs{height:40%}.add-form-field mat-card-footer{min-height:3rem}.extension-container{display:inline-block;font-size:15px;border:1px solid var(--primary);border-radius:15px;margin-right:10px}.extension-container mat-icon{vertical-align:middle;font-size:15px;height:15px;width:15px;color:var(--danger);margin-right:10px;cursor:pointer}.extension-container span{margin-left:10px}.key-value-list-section-title{background:linear-gradient(to right,var(--gray) 0%,rgb(255,255,255) 100%) left bottom #fff no-repeat;background-size:100% 1px}.value-pairs-list{list-style:none;padding:0}.value-pairs-list mat-icon{vertical-align:middle;font-size:15px;height:15px;width:15px;color:var(--danger);margin-right:10px;cursor:pointer}::ng-deep .mat-dialog-container{border-radius:10px}.row.title{background-color:#ebebeb;padding:20px 0 20px 50px}.row.title mat-icon.add{background:#fff;color:#7b7b7b;height:40px;width:40px;border-radius:10px;font-size:27px;padding:7px 6px 6px 7px;margin:0 7px 0 0}.row.title .header-title-standard{display:flex;align-items:center;font-size:19px;font-weight:700;color:gray}.row:not(.title){margin:15px 0 0}form{margin:25px 0 0}.col-middle{display:flex;align-items:center}::ng-deep .mat-select-arrow{color:transparent!important}input[type=number]{-webkit-appearance:textfield;-moz-appearance:textfield;appearance:textfield}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{-webkit-appearance:none}.increasableValues{display:flex}.increasableValues .col-sm-12{display:flex;flex-direction:column;margin:0 3em 0 0}.increasableValues .col-sm-12 .mat-form-field{height:79px;line-height:34px;width:50%}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex{width:230px;border:1px solid #e7e7e9;border-radius:10px;padding:7px 0 0 20px!important;margin-top:10px;background-color:#fff}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex .mat-form-field-infix{display:flex;margin:-10px 0 0}.increasableValues .col-sm-12 .mat-form-field ::ng-deep .mat-form-field-flex .mat-form-field-infix input{margin:0;border:none;height:100%}.increasableValues .col-sm-12 .mat-form-field div.buttons{display:flex;flex-direction:column;margin:-10px 0 0;border-right:1px solid #F4F4F4;padding:10px 14px 0 0}.increasableValues .col-sm-12 .mat-form-field div.buttons button.up{height:17px;width:21px;background:url(/assets/images/arrow.png) no-repeat;background-size:20px;background-position-y:1px;background-position-x:1px;-webkit-transform:rotate(180deg);border:none;opacity:.3;cursor:pointer}.increasableValues .col-sm-12 .mat-form-field div.buttons button.down{height:50px;width:23px;background:url(/assets/images/arrow.png) no-repeat no-repeat;background-size:20px;border:none;opacity:.3;background-position-y:21px;background-position-x:0px;cursor:pointer}.increasableValues .col-sm-12 .mat-form-field input{margin:-14px 0 0 63px;font-size:18px}.second .col-sm-12{margin:0 1em 0 0}.date ::ng-deep mat-form-field .mat-form-field-wrapper .mat-form-field-label-wrapper label{display:none}.date ::ng-deep mat-form-field .mat-form-field-wrapper .mat-form-field-suffix{display:inline}.GenericListImagesImageTemplate{height:100%}.configuraQueryEditor{display:flex;justify-content:center;flex-flow:column}eqp-attachments ::ng-deep div button{padding:5px 35px;background:linear-gradient(to right,#1e31eb,#693dda);border-radius:10px}eqp-attachments ::ng-deep div button span mat-icon{margin-right:5px}eqp-attachments ::ng-deep div button.eqp-attachments-delete-btn{color:#fff}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .row:first-child{padding:20px 40px;background-color:#ebebeb;color:gray;font-size:19px;font-weight:700}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .mat-form-field-label-wrapper label{margin-top:21px;margin-left:25px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .btn-primary[disabled]{padding:7px 35px;border-radius:10px;font-size:14px;background-color:#dbdbdc!important;color:#000;background:none}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .btn-primary:not(disabled){padding:7px 35px;border-radius:10px;font-size:14px;background:linear-gradient(to right,#1e31eb,#693dda);color:#fff}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form button{margin:0 10px 0 0!important;border:1px solid #1E31EB;padding:7px 35px;border-radius:10px;font-size:14px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form button[disabled]{border:none}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .ng-star-inserted .justify-content-center button{padding:4px;margin:0;border:none;left:8px}::ng-deep mat-dialog-container .container-fluid.eqp-attachments-dialog-add-container form .row:last-child{padding:50px 20px 20px 0}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper input{background-color:#ebebeb!important;background:url(data:image/png;base64,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) no-repeat;background-size:19px;background-position:19px;padding:15px 0 15px 53px!important}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper input:focus{background-color:#fff!important;border:1px solid #e7e7e9}eqp-table ::ng-deep mat-form-field:not(.mat-paginator-page-size-select) .mat-form-field-wrapper .mat-form-field-label-wrapper label{margin-top:21px;margin-left:55px}eqp-table ::ng-deep mat-header-row{background-color:#ebebeb;border-bottom-width:0px}eqp-table ::ng-deep mat-header-row .mat-column-Required{flex:none!important}eqp-table ::ng-deep .mat-sort-header-button{color:#3b3a3b;font-size:15px}eqp-table ::ng-deep .mat-row{background-color:#fff;margin:10px 0;box-shadow:0 3px 7px -3px #0003;padding:5px 0}eqp-table ::ng-deep .mat-row .mat-column-Required{flex:0 0 8%!important}eqp-table ::ng-deep .mat-row mat-cell eqp-select{margin-top:16px}eqp-table ::ng-deep .mat-row mat-cell eqp-select .mat-form-field-wrapper{padding-bottom:0}eqp-table ::ng-deep .mat-row .mat-cell:last-child span i.success-color{background-color:#383fec;color:#fff!important;padding:6px;border-radius:3px}@media screen and (max-width: 1100px){.row:not(.title){margin:0!important}.second{display:flex;flex-direction:column}.second .col-sm-12{margin:0}.buttonsForm{padding:0 30px 20px 0;margin:50px 0 0}}@media screen and (max-width: 766px){.increasableValues{display:flex;flex-direction:column}.increasableValues .col-sm-12{margin:0 0 -1.5em}.second{display:flex;flex-direction:column}.second .col-sm-12{margin:0 0 -3.4em}.buttonsForm{margin:55px 0 0!important;padding:0 13px 20px 0;transform:translateY(110px)}}@media screen and (max-width: 577px){.increasableValues .col-sm-12{margin:0 0 1.5em}}:host ::ng-deep .mat-input-element{width:100%;width:-moz-available;width:-webkit-fill-available;width:fill-available}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UntypedFormBuilder }, { type: i2.EnumHelper }, { type: i3.MatDialog }, { type: i0.ChangeDetectorRef }, { type: i4.HttpClient }, { type: i5.UtilityHelperService }], propDecorators: { form: [{
+                type: Input
+            }], endPointConfiguration: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], indexField: [{
+                type: Input
+            }], formFieldsGroups: [{
+                type: Input
+            }], availableFields: [{
+                type: Input
+            }], fieldTypesToExclude: [{
+                type: Input
+            }], QueryEditorComponent: [{
+                type: Input
+            }], contestualization: [{
+                type: Input
+            }], out: [{
+                type: Output
+            }], saveFieldEvent: [{
+                type: Output
+            }], textFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["textFieldFormTemplate", { static: true }]
+            }], labelFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["labelFieldFormTemplate", { static: true }]
+            }], textareaFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["textareaFieldFormTemplate", { static: true }]
+            }], booleadFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["booleadFieldFormTemplate", { static: true }]
+            }], dateFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["dateFieldFormTemplate", { static: true }]
+            }], numericFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["numericFieldFormTemplate", { static: true }]
+            }], attachmentFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["attachmentFieldFormTemplate", { static: true }]
+            }], imageFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["imageFieldFormTemplate", { static: true }]
+            }], imageWithMarkersFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["imageWithMarkersFieldFormTemplate", { static: true }]
+            }], imageFieldSelectorFormTemplate: [{
+                type: ViewChild,
+                args: ["imageFieldSelectorFormTemplate", { static: true }]
+            }], listValueFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["listValueFieldFormTemplate", { static: true }]
+            }], lookupFieldFormTemplate: [{
+                type: ViewChild,
+                args: ["lookupFieldFormTemplate", { static: true }]
+            }], dataGetterTemplate: [{
+                type: ViewChild,
+                args: ["dataGetterTemplate", { static: true }]
+            }], dialogFormula: [{
+                type: ViewChild,
+                args: ["dialogFormula", { static: true }]
+            }], buttonImagesKeyValueInputColumn: [{
+                type: ViewChild,
+                args: ["buttonImagesKeyValueInputColumn", { static: true }]
+            }], GenericListImagesImageTemplate: [{
+                type: ViewChild,
+                args: ['GenericListImagesImageTemplate', { static: true }]
+            }], GenericListImagesKeyTemplate: [{
+                type: ViewChild,
+                args: ['GenericListImagesKeyTemplate', { static: true }]
+            }], GenericListImagesValueTemplate: [{
+                type: ViewChild,
+                args: ['GenericListImagesValueTemplate', { static: true }]
+            }], imageSelectorAttachments: [{
+                type: ViewChild,
+                args: ['imageSelectorAttachments', { static: false }]
+            }], imageAttachment: [{
+                type: ViewChild,
+                args: ['imageAttachment', { static: false }]
+            }], dialogQE: [{
+                type: ViewChild,
+                args: ["dialogQE", { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-form-field.component.js","sourceRoot":"","sources":["../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/add-form-field/add-form-field.component.ts","../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/add-form-field/add-form-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  TemplateRef,\r\n  ViewChild,\r\n} from \"@angular/core\";\r\nimport {\r\n  AbstractControl,\r\n  FormControl,\r\n  UntypedFormBuilder,\r\n  UntypedFormControl,\r\n  UntypedFormGroup,\r\n  ValidationErrors,\r\n  ValidatorFn,\r\n  Validators,\r\n} from \"@angular/forms\";\r\nimport { MatDialog, MatDialogRef } from \"@angular/material/dialog\";\r\nimport {\r\n  AttachmentType,\r\n  EqpAttachmentDialogService,\r\n  EqpAttachmentsComponent,\r\n  IAttachmentDTO,\r\n} from \"@eqproject/eqp-attachments\";\r\nimport { EnumHelper } from \"@eqproject/eqp-select\";\r\nimport { ConfigColumn, TypeColumn } from \"@eqproject/eqp-table\";\r\nimport {\r\n  BaseField,\r\n  ColSpanSizesEnum,\r\n  DataGetterCardinalityEnum,\r\n  FieldInvisibilityEnum,\r\n  FieldTypeEnum\r\n} from \"../../../models/baseField.model\";\r\nimport {\r\n  AttachmentField,\r\n  AvailableFileExtensions,\r\n  AvailableImageExtensions,\r\n} from \"../../../models/fields/attachmentField.model\";\r\nimport {\r\n  BooleanField,\r\n  BoolPresentantioEnum,\r\n} from \"../../../models/fields/booleanField.model\";\r\nimport {\r\n  DateField,\r\n  DateTimeTypeEnum,\r\n} from \"../../../models/fields/dateField.model\";\r\nimport { ImageField } from \"../../../models/fields/imageField.model\";\r\nimport {\r\n  ListPresentationEnum,\r\n  ListValueField,\r\n} from \"../../../models/fields/listValueField.model\";\r\nimport { LookupField } from \"../../../models/fields/lookupField.model\";\r\nimport { NumericField } from \"../../../models/fields/numericField.model\";\r\nimport { TextareaField } from \"../../../models/fields/textareaField.model\";\r\nimport {\r\n  TextMaskEnum,\r\n  TextField,\r\n} from \"../../../models/fields/textField.model\";\r\nimport { FormFieldGroup, Form } from '../../../models/form.model';\r\nimport { UtilityHelperService } from \"../../../services/utilityHelper.services\";\r\nimport { GlobalService } from \"../../../services/global.service\";\r\nimport { ImageSelectorField } from \"../../../models/fields/imageSelectorField.model\";\r\nimport { EqpDynamicModuleDialogService } from \"../../../services/eqp-dynamic-module-dialog.service\";\r\nimport { LabelField } from \"../../../models/fields/labelField.model\";\r\nimport { ImageWithMarkersField } from \"../../../models/fields/imageWithMarkersField.model\";\r\nimport { AttachmentFieldTypeEnum, DynAttachment } from \"../../../models/dynAttachment\";\r\nimport { DynamicLoaderDirectiveData, eventOut } from \"../../../directives/dynamic-loader/dynamic-loader.directive\";\r\nimport { HttpClient } from \"@angular/common/http\";\r\nimport { DataGetterTypeEnum, DataGetter } from '../../../models/baseField.model';\r\nimport { QueryEditorModeEnum } from \"../dbgetter/dbgetter.component\";\r\nimport { ModeEnum, TimeTypeEnum } from \"tmw-picker\";\r\nimport { EndPointConfiguration, EndPointDataParams, ParamTypeEnum } from \"../../../models/endPointConfiguration.model\";\r\nimport { Contestualization } from \"../../../models/getter.model\";\r\n\r\n@Component({\r\n  selector: \"eqp-dynamic-module-add-form-field\",\r\n  templateUrl: \"./add-form-field.component.html\",\r\n  styleUrls: [\"./add-form-field.component.scss\"],\r\n})\r\nexport class AddFormFieldComponent implements OnInit {\r\n  \r\n  @Input() form: Form;\r\n  @Input() endPointConfiguration: EndPointConfiguration;\r\n  @Input() field: BaseField | any;\r\n  @Input() indexField: number;\r\n  @Input() formFieldsGroups: Array<FormFieldGroup>;\r\n  /** Elenco dei Field creati nella form, usati per popolare l'autocomplete della proprietà Formula. */\r\n  @Input() availableFields: Array<BaseField>;\r\n  @Input() fieldTypesToExclude: Array<FieldTypeEnum> = [FieldTypeEnum[\"Form di dettaglio\"]];\r\n  @Input() QueryEditorComponent: DynamicLoaderDirectiveData; // L'intero componente query Editor\r\n  @Input() contestualization: Array<Contestualization> = null;\r\n\r\n  @Output() out: EventEmitter<eventOut> = new EventEmitter<eventOut>();\r\n  @Output() saveFieldEvent: EventEmitter<BaseField | any> = new EventEmitter<BaseField | any>();\r\n\r\n  resizedImagesHeightPx: number;\r\n  fieldFormGroup: UntypedFormGroup;\r\n  keyValueObject: { key: string; value: string } = { key: \"\", value: \"\" };\r\n  availableColSpanSizesCompilazione: Array<ColSpanSizesEnum> = [];\r\n  availableColSpanSizesRisposta: Array<ColSpanSizesEnum> = [];\r\n  formulaAutocompleteOptions: Array<{ label: string; value: string }>;\r\n  VisibleIfAutocompleteOptions: Array<{ label: string; value: string }>;\r\n  AvailableFileExtensions = AvailableFileExtensions;\r\n  AvailableImageExtensions = AvailableImageExtensions;\r\n  fieldInvisibilityEnum = FieldInvisibilityEnum;\r\n  columnKeys: Array<{ key: string; value: string }> = new Array<{ key: string; value: string }>();\r\n\r\n  //#region Template dei vari pezzi di form per la creazione di un campo(in base al tipo scelto).\r\n  fieldTypeFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"textFieldFormTemplate\", { static: true })\r\n  textFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"labelFieldFormTemplate\", { static: true })\r\n  labelFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"textareaFieldFormTemplate\", { static: true })\r\n  textareaFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"booleadFieldFormTemplate\", { static: true })\r\n  booleadFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"dateFieldFormTemplate\", { static: true })\r\n  dateFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"numericFieldFormTemplate\", { static: true })\r\n  numericFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"attachmentFieldFormTemplate\", { static: true })\r\n  attachmentFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"imageFieldFormTemplate\", { static: true })\r\n  imageFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"imageWithMarkersFieldFormTemplate\", { static: true })\r\n  imageWithMarkersFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"imageFieldSelectorFormTemplate\", { static: true })\r\n  imageFieldSelectorFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"listValueFieldFormTemplate\", { static: true })\r\n  listValueFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"lookupFieldFormTemplate\", { static: true })\r\n  lookupFieldFormTemplate: TemplateRef<any>;\r\n  @ViewChild(\"dataGetterTemplate\", { static: true })\r\n  dataGetterTemplate: TemplateRef<any>;  \r\n  \r\n  //#endregion\r\n\r\n  //#region Proprietà per gestire i metadata nei campi ti dipo Allegato o Immagine\r\n  metadataColumns: Array<ConfigColumn>;\r\n  //@ViewChild('metadataFieldsTable', { static: false }) metadataFieldsTable: EqpTableComponent;\r\n  selectedMetadata: BaseField;\r\n  //indexSelectedMetadata: number;\r\n  //dialogMetadataRef: MatDialogRef<TemplateRef<any>>;\r\n  dialogFormulaRef: MatDialogRef<TemplateRef<any>>;\r\n  dialogVisibleIfRef: MatDialogRef<TemplateRef<any>>;\r\n  //@ViewChild('dialogMetadata', { static: true }) dialogMetadata: TemplateRef<any>;\r\n  @ViewChild(\"dialogFormula\", { static: true }) dialogFormula: TemplateRef<any>;\r\n  //#endregion\r\n\r\n  //#region Proprietà per gestire le immagini nei capi di tipo elenco generico\r\n  @ViewChild(\"buttonImagesKeyValueInputColumn\", { static: true })\r\n  buttonImagesKeyValueInputColumn: TemplateRef<any>;\r\n  //#endregion\r\n\r\n  //#region Enumeratori usati nell'html\r\n  FieldTypeEnum = FieldTypeEnum;\r\n  BoolPresentantioEnum = BoolPresentantioEnum;\r\n  DateTimeTypeEnum = DateTimeTypeEnum;\r\n  ListPresentationEnum = ListPresentationEnum;\r\n  TextMaskEnum = TextMaskEnum;\r\n  AttachmentType = AttachmentType;\r\n  attachmentFieldTypeEnum = AttachmentFieldTypeEnum;\r\n  dataGetterTypeEnum = DataGetterTypeEnum;\r\n  subscription: any;\r\n\r\n  //#endregion\r\n\r\n  //#region Gestione delle liste di immagini\r\n  configColumnListImages: Array<ConfigColumn> = new Array<ConfigColumn>();\r\n  configColumnImage: Array<ConfigColumn> = new Array<ConfigColumn>();\r\n  @ViewChild('GenericListImagesImageTemplate', { static: true }) GenericListImagesImageTemplate: TemplateRef<any>;\r\n  @ViewChild('GenericListImagesKeyTemplate', { static: true }) GenericListImagesKeyTemplate: TemplateRef<any>;\r\n  @ViewChild('GenericListImagesValueTemplate', { static: true }) GenericListImagesValueTemplate: TemplateRef<any>;\r\n  @ViewChild('imageSelectorAttachments', { static: false }) imageSelectorAttachments: EqpAttachmentsComponent;\r\n  @ViewChild('imageAttachment', { static: false }) imageAttachment: EqpAttachmentsComponent;\r\n  //#endregion\r\n\r\n  // DB Getter\r\n  dialogQERef: MatDialogRef<TemplateRef<any>>;\r\n  //@ViewChild('dialogMetadata', { static: true }) dialogMetadata: TemplateRef<any>;\r\n  @ViewChild(\"dialogQE\", { static: true }) dialogQE: TemplateRef<any>;\r\n\r\n  // TMW-PICKER\r\n  mode = ModeEnum\r\n  timeType = TimeTypeEnum\r\n\r\n  // DM Getter\r\n  forms: Array<Form> = new Array<Form>();\r\n  DMModule: any;\r\n  DMField: any;\r\n  DMFields: Array<{ key: string }>;\r\n  DMGetterCardinalities = DataGetterCardinalityEnum;\r\n\r\n  constructor(\r\n    private formBuilder: UntypedFormBuilder,\r\n    private enumHelper: EnumHelper,\r\n    private dialog: MatDialog,\r\n    private cdr: ChangeDetectorRef,\r\n    private httpClient: HttpClient,\r\n    private utilityHelperService: UtilityHelperService\r\n  ) {}\r\n\r\n  async ngOnInit() {\r\n    this.configureColumns();\r\n    if (this.field.DataGetter == null){ this.field.DataGetter = new DataGetter(); }\r\n    if (this.field.DataGetter.DataGetterType != null && this.field.DataGetter.DataGetterType == DataGetterTypeEnum[\"Da modulo dinamico\"]){\r\n      await this.getAllModules();\r\n    }\r\n\r\n    if (typeof this.field.DataGetter.DataGetterValue != \"undefined\" && this.field.DataGetter.DataGetterValue != null){\r\n      this.createColumnKeys(this.field.DataGetter.DataGetterValue.Params);\r\n    }\r\n\r\n    if (\r\n      !this.fieldTypesToExclude.includes(FieldTypeEnum[\"Form di dettaglio\"])\r\n    ) {\r\n      this.fieldTypesToExclude.push(FieldTypeEnum[\"Form di dettaglio\"]);\r\n    }\r\n\r\n    this.onFieldTypeChange(false);\r\n    this.availableFields = this.availableFields\r\n      ? this.availableFields.filter((f) => f != this.field)\r\n      : [];\r\n\r\n  }\r\n\r\n  /**\r\n   * Metodo per impostare i valori da suggerire nell'autocomplete del campo Formula.\r\n   * Viene scatenato al focus (in questo caso viene passato il parametro a null per differenziarlo\r\n   * dall'evento di click sulla tastiera) e al keyup sull'input (il parametro è diverso da null).\r\n   * @param keyboardEvent Evento scatenato al keyup sulla tastiera. Se null allora il metodo è stato invocato dal focus sull'input.\r\n   * @summary Aggiorna l'elenco dei suggerimenti per l'autocomplete se l'utente esegue il focus sull'input\r\n   * oppure al keyup sulla tastiera di un tasto diverso dalle frecce.\r\n   */\r\n  // setFormulaAutocompleteOptions(keyboardEvent: KeyboardEvent) {\r\n  //   // Creo l'array per l'autocomplete solo se sto facendo il focus sull'input o se sto premendo un tasto\r\n  //   // sulla tastiera diverso dalle frecce (in quest'ultimo caso, se non viene eseguito il filtro sull'evento,\r\n  //   // non si può selezionare un suggerimento dell'autocomplete perchè al click verrebbe ricaricato l'array e\r\n  //   // si prederebbe la selezione appena fatta).\r\n  //   if (!keyboardEvent || !keyboardEvent.code.includes(\"Arrow\")) {\r\n  //     this.formulaAutocompleteOptions = UtilityHelperService.GetAutocompleteOptions(this.availableFields, this.field.Formula);\r\n  //   }\r\n  // }\r\n  setVisibleIfAutocompleteOptions(keyboardEvent: KeyboardEvent) {\r\n    // Creo l'array per l'autocomplete solo se sto facendo il focus sull'input o se sto premendo un tasto\r\n    // sulla tastiera diverso dalle frecce (in quest'ultimo caso, se non viene eseguito il filtro sull'evento,\r\n    // non si può selezionare un suggerimento dell'autocomplete perchè al click verrebbe ricaricato l'array e\r\n    // si prederebbe la selezione appena fatta).\r\n    if (!keyboardEvent || !keyboardEvent.code.includes(\"Arrow\")) {\r\n      this.VisibleIfAutocompleteOptions =\r\n        UtilityHelperService.GetAutocompleteOptions(\r\n          this.availableFields,\r\n          this.field.VisibleIf\r\n        );\r\n    }\r\n  }\r\n  omit_special_char(event) {\r\n    var k;\r\n    k = event.keyCode; //         k = event.keyCode;  (Both can be used)\r\n    if (k == 34) {\r\n      event.keyCode = 0;\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Crea il FormGroup per l'aggiunta di un nuovo campo all'interno della form.\r\n   * Metodo richiamato ogni volta che cambia il tipo del campo scelto o viene aggiunto/modificato un Field\r\n   */\r\n  createFieldForm() {\r\n    this.fieldFormGroup = this.formBuilder.group({\r\n      Label: [\r\n        this.field.Label,\r\n        [\r\n          Validators.required,\r\n          this.questionPoll,\r\n          Validators.pattern(\"^[a-zA-Z ]*$\"),\r\n        ],\r\n      ],\r\n      Description: [\r\n        this.field.Description,\r\n        [Validators.required, this.questionPoll],\r\n      ],\r\n      Readonly: [this.field.Readonly],\r\n      Required: [this.field.Required],\r\n      FieldType: [\r\n        this.field.FieldType,\r\n        [Validators.required, this.questionPoll],\r\n      ],\r\n      DMModule: [null],      \r\n      DMField: [null],      \r\n      DataGetterType: [\r\n        this.field.DataGetter.DataGetterType,\r\n        [Validators.required],\r\n      ],      \r\n      ColSpanSizes: [this.field.ColSpanSizes],\r\n      InListView: [this.field.InListView],\r\n      Invisibility: [this.field.Invisibility],\r\n      VisibleIf: [this.field.VisibleIf, this.questionPoll],\r\n      Tooltip: [this.field.Tooltip, this.questionPoll],\r\n      LabelstyleCSS: [this.field.LabelstyleCSS, this.questionPoll],\r\n      FieldstyleCSS: [this.field.FieldstyleCSS, this.questionPoll],\r\n      Formula: [this.field.Formula, this.questionPoll],\r\n      DataGetterValue: [this.field.DataGetter.DataGetterValue, this.questionPoll],\r\n\r\n      AnswerStyleLabelstyleCSS: [this.field.AnswerStyle.LabelstyleCSS, this.questionPoll],\r\n      AnswerStyleFieldstyleCSS: [this.field.AnswerStyle.FieldstyleCSS, this.questionPoll],\r\n      AnswerStyleVisibleIf: [this.field.AnswerStyle.VisibleIf, this.questionPoll],\r\n      AnswerStyleColSpanSizes: [this.field.AnswerStyle.ColSpanSizes],\r\n      AnswerStyleInListView: [this.field.AnswerStyle.InListView],\r\n      AnswerStyleInvisibility: [this.field.AnswerStyle.Invisibility],\r\n    });\r\n\r\n    if (this.formFieldsGroups) {\r\n      this.fieldFormGroup.addControl(\r\n        \"FieldGroup\",\r\n        new UntypedFormControl(this.field.FieldGroup, Validators.required)\r\n      );\r\n    }\r\n  }\r\n  questionPoll(control: FormControl): { [s: string]: boolean } {\r\n    // c'è un FormControl che è vuoto che da problemi (probabilmente type Data, campo Formato)\r\n    if (control.value != undefined) {\r\n      if (\r\n        UtilityHelperService.stringCheckParentesis(\r\n          control.value,\r\n          control.hasValidator(Validators.required)\r\n        )\r\n      ) {\r\n        return null;\r\n      } else {\r\n        return { \"Missing Parenthesis\": true };\r\n      }\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n  stringSanitaizedValidator(control: FormControl): { [s: string]: boolean } {\r\n    // c'è un FormControl che è vuoto che da problemi (probabilmente type Data, campo Formato)\r\n    if (control.value != undefined) {\r\n      if (\r\n        UtilityHelperService.stringCheckParentesis(\r\n          control.value,\r\n          control.hasValidator(Validators.required)\r\n        )\r\n      ) {\r\n        return null;\r\n      } else {\r\n        return { \"La formula non è valida\": true };\r\n      }\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n  // getAllFormValidationErrors() {\r\n  //   Object.keys(this.fieldFormGroup.controls).forEach((key) => {\r\n  //     const controlErrors: ValidationErrors =\r\n  //       this.fieldFormGroup.get(key).errors;\r\n  //     if (controlErrors != null) {\r\n  //       Object.keys(controlErrors).forEach((keyError) => {\r\n  //         console.log(\r\n  //           \"Key control: \" + key + \", keyError: \" + keyError + \", err value: \",\r\n  //           controlErrors[keyError]\r\n  //         );\r\n  //       });\r\n  //     }\r\n  //   });\r\n  // }\r\n\r\n  /**\r\n   * Metodo chiamato dai mat-error per prendere gli errori generati relativi al campo.\r\n   * @param control è il nome del GroupControl di cui leggere se ci sono errori\r\n   */\r\n  getFormValidationErrors(control: string) {\r\n    if (control == \"Label\") GlobalService.debugLog('getFormValidationErrors', this.fieldFormGroup.controls[\"Label\"]);\r\n\r\n    const controlErrors: ValidationErrors =\r\n      this.fieldFormGroup.controls[control].errors;\r\n    let errors = [];\r\n    let values = [];\r\n    if (controlErrors != null) {\r\n      Object.keys(controlErrors).forEach((keyError) => {\r\n        errors.push(keyError);\r\n      });\r\n      GlobalService.debugLog('control: ', control);\r\n      GlobalService.debugLog('errors: ', errors);\r\n      GlobalService.debugLog('values: ', values);\r\n    }\r\n    return errors.join(\", \");\r\n  }\r\n\r\n  //#region onFieldTypeChange\r\n  /**\r\n   * Metodo chiamato quando cambia il FieldType del BaseField che si sta aggiungendo/modificando.\r\n   * Ricrea l'oggetto field popolando solo le proprietà del BaseField inserite dall'utente\r\n   * (quelle comuni a tutte le tipologie di campo), ricrea la form e, in base al FieldType scelto,\r\n   * aggiunge alla form i FormControl necessari e seleziona il template corretto da usare.\r\n   * @param restoreField Se TRUE ripristina i valori base (ereditati dal modello BaseField) del campo aggiunto/modificato\r\n   */\r\n  onFieldTypeChange(restoreField: boolean = true) {\r\n    if (restoreField) {\r\n      this.restoreBaseFieldProperties();\r\n    }\r\n\r\n    this.createFieldForm();\r\n    this.onColSpanSizeSelect();\r\n    if ((this.field as BaseField).InListView == null) {\r\n      this.field.InListView = true;\r\n    }\r\n    if ((this.field as BaseField).Invisibility == null) {\r\n      this.field.Invisibility = FieldInvisibilityEnum.NASCOSTO;\r\n    }    \r\n    this.fieldTypeFormTemplate = null;\r\n\r\n    switch (this.field.FieldType) {\r\n\r\n      //#region CAMPO DI TESTO\r\n      case FieldTypeEnum[\"Campo di testo\"]:\r\n        if ((this.field as TextField).Microphone == null) {\r\n          this.field.Microphone = false;\r\n        }\r\n        this.fieldFormGroup.addControl(\r\n          \"TextMask\",\r\n          new UntypedFormControl((this.field as TextField).TextMask)\r\n        );\r\n        this.fieldFormGroup.addControl(\r\n          \"MaxLenght\",\r\n          new UntypedFormControl((this.field as TextField).MaxLenght, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n        this.fieldFormGroup.addControl(\r\n          \"MinLenght\",\r\n          new UntypedFormControl((this.field as TextField).MinLenght, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n        this.fieldFormGroup.addControl(\r\n          \"Microphone\",\r\n          new UntypedFormControl((this.field as TextField).Microphone)\r\n        );\r\n        this.fieldTypeFormTemplate = this.textFieldFormTemplate;\r\n        break;\r\n      //#endregion CAMPO DI TESTO\r\n\r\n      //#region LABEL\r\n      case FieldTypeEnum['Etichetta']:\r\n        if ((this.field as LabelField).Etichetta == null) {\r\n          this.field.Etichetta = \"\";\r\n        }\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"Etichetta\",\r\n          new UntypedFormControl((this.field as LabelField).Etichetta)\r\n        );\r\n        this.fieldTypeFormTemplate = this.labelFieldFormTemplate;   \r\n        break;     \r\n      //#endregion LABEL\r\n\r\n      //#region AREA DI TESTO \r\n      case FieldTypeEnum[\"Area di testo\"]:\r\n        if ((this.field as TextareaField).Microphone == null) {\r\n          this.field.Microphone = false;\r\n        }\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"Rows\",\r\n          new UntypedFormControl((this.field as TextareaField).Rows, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MaxLenght\",\r\n          new UntypedFormControl((this.field as TextareaField).MaxLenght, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MinLenght\",\r\n          new UntypedFormControl((this.field as TextareaField).MinLenght, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"Microphone\",\r\n          new UntypedFormControl((this.field as TextareaField).Microphone)\r\n        );\r\n        this.fieldTypeFormTemplate = this.textareaFieldFormTemplate;\r\n        break;\r\n      //#endregion AREA DI TESTO \r\n\r\n      //#region BOOLEANO\r\n      case FieldTypeEnum.Booleano:\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"IsTristate\",\r\n          new UntypedFormControl((this.field as BooleanField).IsTristate)\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"PresetationType\",\r\n          new UntypedFormControl(\r\n            (this.field as BooleanField).PresetationType,\r\n            Validators.required\r\n          )\r\n        );\r\n        this.fieldTypeFormTemplate = this.booleadFieldFormTemplate;\r\n        break;\r\n      //#endregion BOOLEANO\r\n\r\n      //#region DATA E/I ORA\r\n      case FieldTypeEnum[\"Data e/o ora\"]:\r\n        if (this.field.IsOnlyDate == null) {\r\n          this.field.IsOnlyDate = DateTimeTypeEnum[\"Solo data\"];\r\n        }\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"IsOnlyDate\",\r\n          new UntypedFormControl((this.field as DateField).IsOnlyDate, [\r\n            Validators.required,\r\n            this.questionPoll,\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MinDate\",\r\n          new UntypedFormControl(\r\n            (this.field as DateField).MinDate,\r\n            this.questionPoll\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MaxDate\",\r\n          new UntypedFormControl(\r\n            (this.field as DateField).MaxDate,\r\n            this.questionPoll\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"DateFormat\",\r\n          new UntypedFormControl((this.field as DateField).DateFormat)\r\n        );\r\n        this.fieldTypeFormTemplate = this.dateFieldFormTemplate;\r\n        break;\r\n      //#endregion DATA E/I ORA\r\n\r\n      //#region CAMPO NUMERICO\r\n      case FieldTypeEnum[\"Campo numerico\"]:\r\n        if ((this.field as NumericField).IsInteger == null) {\r\n          this.field.IsInteger = true;\r\n        }\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"IsInteger\",\r\n          new UntypedFormControl((this.field as NumericField).IsInteger)\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MinValue\",\r\n          new UntypedFormControl((this.field as NumericField).MinValue, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\"), //(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MaxValue\",\r\n          new UntypedFormControl((this.field as NumericField).MaxValue, [\r\n            this.questionPoll,\r\n            Validators.pattern(\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\"), //(\"^[0-9]*$\"),\r\n          ])\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"DecimalSeparator\",\r\n          new UntypedFormControl(\r\n            (this.field as NumericField).DecimalSeparator,\r\n            [this.questionPoll, Validators.pattern(\"^[a-zA-Z -/',._/\\\\^<>]+\")]\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"DecimalPrecision\",\r\n          new UntypedFormControl(\r\n            (this.field as NumericField).DecimalPrecision,\r\n            [this.questionPoll, Validators.pattern(\"^[0-9]+$\")]\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"ThousandsSeparator\",\r\n          new UntypedFormControl(\r\n            (this.field as NumericField).ThousandsSeparator,\r\n            [this.questionPoll, Validators.pattern(\"^[a-zA-Z -/',._/\\\\^<>]+\")]\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"CurrencySymbol\",\r\n          new UntypedFormControl(\r\n            (this.field as NumericField).CurrencySymbol,\r\n            this.questionPoll\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"MeasureUnit\",\r\n          new UntypedFormControl(\r\n            (this.field as NumericField).MeasureUnit,\r\n            this.questionPoll\r\n          )\r\n        );\r\n        this.fieldTypeFormTemplate = this.numericFieldFormTemplate;\r\n        break;\r\n      //#endregion CAMPO NUMERICO\r\n\r\n      //#region ALLEGATO\r\n      case FieldTypeEnum.Allegato:\r\n        this.fieldFormGroup.addControl(\r\n          \"AllowedExtensions\",\r\n          new UntypedFormControl(\r\n            (this.field as AttachmentField).AllowedExtensions\r\n          )\r\n        );\r\n        this.fieldFormGroup.addControl(\r\n          \"IsMultiAttach\",\r\n          new UntypedFormControl((this.field as AttachmentField).IsMultiAttach)\r\n        );\r\n        this.fieldTypeFormTemplate = this.attachmentFieldFormTemplate;\r\n        break;\r\n      //#endregion ALLEGATO\r\n\r\n      //#region IMMAGINE\r\n      case FieldTypeEnum.Immagine:\r\n      if (typeof (this.field as ImageField).DynAttachment == \"undefined\"){\r\n        (this.field as ImageField).DynAttachment = null;\r\n      }\r\n\r\n      if (typeof (this.field as ImageField).EnableDrawing == \"undefined\"){\r\n        (this.field as ImageField).EnableDrawing = false;\r\n      }\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"ResizedImagesHeightPx\",\r\n          new UntypedFormControl(\r\n            (this.field as ImageField).ResizedImagesHeightPx,\r\n            [Validators.required,Validators.max(4320)]\r\n          )\r\n        );\r\n        (this.field as ImageField).ResizedImagesHeightPx = (this.field as ImageField).ResizedImagesHeightPx != null ? (this.field as ImageField).ResizedImagesHeightPx : 128;\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"EnableDrawing\",\r\n          new UntypedFormControl((this.field as ImageField).EnableDrawing)\r\n        );\r\n\r\n        this.fieldTypeFormTemplate = this.imageFieldFormTemplate;\r\n        break;\r\n\r\n        /*\r\n        (this.field as ImageField).AttachDefinition = new AttachmentField();\r\n        this.fieldFormGroup.addControl(\r\n          \"EnableDrawing\",\r\n          new UntypedFormControl((this.field as ImageField).EnableDrawing)\r\n        );\r\n        this.fieldFormGroup.addControl(\r\n          \"ImageIsContextualAttachment\",\r\n          new UntypedFormControl(\r\n            (this.field as ImageField).ImageIsContextualAttachment\r\n          )\r\n        );\r\n        // Imposto i FormControl variabili.\r\n        this.onImageIsContextualAttachmentChange();\r\n        this.fieldTypeFormTemplate = this.imageFieldFormTemplate;\r\n        break;\r\n        */\r\n      //#endregion IMMAGINE\r\n\r\n      //#region ELENCO GENERICO\r\n      case FieldTypeEnum[\"Elenco generico\"]:\r\n        if ((this.field as ListValueField).InListView == null) {\r\n          this.field.InListView = true;\r\n        }\r\n        if ((this.field as ListValueField).Invisibility == null) {\r\n          this.field.Invisibility = FieldInvisibilityEnum.NASCOSTO;\r\n        }        \r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"IsMultiChoiche\",\r\n          new UntypedFormControl((this.field as ListValueField).IsMultiChoiche)\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"PresentationMode\",\r\n          new UntypedFormControl(\r\n            (this.field as ListValueField).PresentationMode,\r\n            Validators.required\r\n          )\r\n        );\r\n        this.fieldTypeFormTemplate = this.listValueFieldFormTemplate;\r\n\r\n        break;\r\n      //#endregion ELENCO GENERICO\r\n\r\n      //#region ELENCO IMMAGINI\r\n      case FieldTypeEnum[\"Elenco immagini\"]:\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"IsMultiChoiche\",\r\n          new UntypedFormControl((this.field as ImageSelectorField).IsMultiChoiche)\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"ResizedImagesHeightPx\",\r\n          new UntypedFormControl(\r\n            (this.field as ImageSelectorField).ResizedImagesHeightPx,\r\n            [Validators.required,Validators.max(4320)]\r\n          )\r\n        );        \r\n        this.fieldTypeFormTemplate = this.imageFieldSelectorFormTemplate;\r\n\r\n        break;\r\n      //#endregion ELENCO IMMAGINI     \r\n\r\n      //#region IMMAGINE CON MARKER\r\n      case FieldTypeEnum[\"Immagine con markers\"]:\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"ResizedImagesHeightPx\",\r\n          new UntypedFormControl(\r\n            (this.field as ImageWithMarkersField).ResizedImagesHeightPx,\r\n            [Validators.required,Validators.max(4320)]\r\n          )\r\n        );        \r\n        this.fieldTypeFormTemplate = this.imageWithMarkersFieldFormTemplate;\r\n\r\n        break;\r\n      //#endregion IMMAGINE CON MARKER        \r\n\r\n      //#region LOOKUP\r\n      case FieldTypeEnum.Lookup:\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"EntitySourceName\",\r\n          new UntypedFormControl(\r\n            (this.field as LookupField).EntitySourceName,\r\n            Validators.required\r\n          )\r\n        );\r\n\r\n        this.fieldFormGroup.addControl(\r\n          \"UseAsGetOrDiscard\",\r\n          new UntypedFormControl((this.field as LookupField).UseAsGetOrDiscard)\r\n        );\r\n        this.fieldTypeFormTemplate = this.lookupFieldFormTemplate;\r\n        break;\r\n      //#endregion LOOKUP\r\n    }\r\n    if (\r\n      [\r\n        FieldTypeEnum.Allegato,\r\n        FieldTypeEnum.Immagine,\r\n        FieldTypeEnum[\"Form di dettaglio\"],\r\n      ].includes(this.field.FieldType)\r\n    ) {\r\n      this.field.Formula = null;\r\n      this.fieldFormGroup.controls[\"Formula\"].disable();\r\n      this.fieldFormGroup.controls[\"InListView\"].disable();\r\n      this.fieldFormGroup.controls[\"Invisibility\"].disable();\r\n    } else {\r\n      this.fieldFormGroup.controls[\"Formula\"].enable();\r\n      this.fieldFormGroup.controls[\"InListView\"].enable();\r\n      this.fieldFormGroup.controls[\"Invisibility\"].enable();\r\n    }\r\n    if (\r\n      [\r\n        FieldTypeEnum.Allegato,\r\n        FieldTypeEnum.Immagine,\r\n        FieldTypeEnum[\"Form di dettaglio\"],\r\n        FieldTypeEnum[\"Data e/o ora\"],\r\n      ].includes(this.field.FieldType)\r\n    ) {\r\n      this.fieldFormGroup.controls[\"LabelstyleCSS\"].disable();\r\n      this.fieldFormGroup.controls[\"FieldstyleCSS\"].disable();\r\n    } else {\r\n      this.fieldFormGroup.controls[\"LabelstyleCSS\"].enable();\r\n      this.fieldFormGroup.controls[\"FieldstyleCSS\"].enable();\r\n    }\r\n    if ([FieldTypeEnum.Booleano].includes(this.field.FieldType)) {\r\n      this.fieldFormGroup.controls[\"LabelstyleCSS\"].disable();\r\n    } else {\r\n      this.fieldFormGroup.controls[\"LabelstyleCSS\"].enable();\r\n    }\r\n  }\r\n  //#endregion onFieldTypeChange\r\n\r\n  //#region onDataGetterTypeChange\r\n  async onDataGetterTypeChange(){\r\n    if (this.field.DataGetter.DataGetterType == DataGetterTypeEnum['Da modulo dinamico'] && this.forms.length == 0){\r\n      this.getAllModules();\r\n    }\r\n\r\n    if (this.field.DataGetter.DataGetterType != DataGetterTypeEnum.Formula){\r\n      this.field.Formula = null;\r\n    }\r\n\r\n    this.field.DataGetter.DataGetterValue = null;\r\n    this.DMModule = null;\r\n    this.DMField = null;\r\n  }\r\n  //#endregion onDataGetterTypeChange\r\n\r\n  /**\r\n   * Metodo invocato al cambio del valore della proprietà ImageIsContextualAttachment nel caso\r\n   * di campi di tipo Immagine. Se TRUE allora rimuove i FormControl per le proprietà IsMultiAttach\r\n   * e AllowedExtensions e aggiunge i FormControl per le proprietà ImgName e ContextualAttachment,\r\n   * altrimenti il contrario.\r\n   */\r\n  onImageIsContextualAttachmentChange() {\r\n    \r\n    /*\r\n    (this.field as ImageField).ImgName = null;\r\n    (this.field as ImageField).AttachDefinition.AllowedExtensions = [];\r\n    (this.field as ImageField).AttachDefinition.IsMultiAttach = false;\r\n    (this.field as ImageField).ContextualAttachment = null;\r\n\r\n    if ((this.field as ImageField).ImageIsContextualAttachment) {\r\n      this.fieldFormGroup.removeControl(\"IsMultiAttach\");\r\n      this.fieldFormGroup.removeControl(\"AllowedExtensions\");\r\n      this.fieldFormGroup.addControl(\r\n        \"ImgName\",\r\n        new UntypedFormControl(\r\n          (this.field as ImageField).ImgName,\r\n          Validators.required\r\n        )\r\n      );      \r\n      this.fieldFormGroup.addControl(\r\n        \"ContextualAttachment\",\r\n        new UntypedFormControl(\r\n          (this.field as ImageField).ContextualAttachment,\r\n          Validators.required\r\n        )\r\n      );\r\n    } else {\r\n      this.fieldFormGroup.removeControl(\"ImgName\");\r\n      this.fieldFormGroup.removeControl(\"ContextualAttachment\");\r\n      this.fieldFormGroup.addControl(\r\n        \"IsMultiAttach\",\r\n        new UntypedFormControl(\r\n          (this.field as ImageField).AttachDefinition.IsMultiAttach\r\n        )\r\n      );\r\n      this.fieldFormGroup.addControl(\r\n        \"AllowedExtensions\",\r\n        new UntypedFormControl(\r\n          (this.field as ImageField).AttachDefinition.AllowedExtensions\r\n        )\r\n      );\r\n    }\r\n    */\r\n\r\n  }\r\n\r\n  /**\r\n   * Metodo per intercettare l'aggiunta di un allegato nei campi di tipo Immagine per aggiornare\r\n   * il valore della proprietà ContextualAttachment e la validazione del relativo FormControl.\r\n   * @param event Array contenente l'elenco aggiornato degli allegati caricati (nel nostro caso ne contiene al più 1).\r\n   */\r\n  catchContextualAttachmentChange(event: Array<IAttachmentDTO>) {\r\n    /*\r\n    if (event && event.length > 0) {\r\n      (this.field as ImageField).ContextualAttachment = event[0];\r\n    } else {\r\n      (this.field as ImageField).ContextualAttachment = null;\r\n    }\r\n    this.fieldFormGroup.controls[\"ContextualAttachment\"].setValue(\r\n      (this.field as ImageField).ContextualAttachment\r\n    );\r\n    */\r\n  }\r\n\r\n  /**\r\n   * Metodo invocato alla selezione di una classe nella select per le colonne di bootstrap\r\n   * da usare nella visualizzazione del campo. Questa funzione manipola la sorgente dati per\r\n   * la eqp-select in modo da escludere i valori dell'enumeratore che fanno riferimento ad\r\n   * una larghezza di schermo già selezionata. Esempio: per gli schermi piccoli (sm) l'utente\r\n   * seleziona la classe \"col-sm-6\", al change del valore questo metodo rimuove dalla select\r\n   * tutti gli altri valori per la grandezza di schermo selezionata.\r\n   */\r\n  onColSpanSizeSelect() {\r\n    // Recupero l'array degli oggetti chiave-valore che rappreseta l'enumeratore\r\n    let colSizeClassEnumArray = this.enumHelper.getEnumArray(\r\n      ColSpanSizesEnum,\r\n      false,\r\n      null\r\n    );\r\n    // Costruisco l'array delle classi selezionate dall'utente in formato stringa\r\n    let selectedDimensionsCompilazione: Array<string> = this.field.ColSpanSizes\r\n      ? this.field.ColSpanSizes.map((col) => ColSpanSizesEnum[col])\r\n      : [];\r\n      let selectedDimensionsRisposta: Array<string> = this.field.AnswerStyle.ColSpanSizes\r\n      ? this.field.AnswerStyle.ColSpanSizes.map((col) => ColSpanSizesEnum[col])\r\n      : [];      \r\n    // Filtro i valori ottenuti dall'enumeratore per escludere tutti i valori per le\r\n    // grandezze di schermo già selezionatead esclusione dei valori selezionati.\r\n    this.availableColSpanSizesCompilazione = colSizeClassEnumArray.filter(\r\n      (value: { key: number; value: string }) =>\r\n        !selectedDimensionsCompilazione.find(\r\n          (col) =>\r\n            value.value.includes(col.substring(4, 6)) && value.value != col\r\n        )\r\n    );\r\n    this.availableColSpanSizesRisposta = colSizeClassEnumArray.filter(\r\n      (value: { key: number; value: string }) =>\r\n        !selectedDimensionsRisposta.find(\r\n          (col) =>\r\n            value.value.includes(col.substring(4, 6)) && value.value != col\r\n        )\r\n    );    \r\n  }\r\n\r\n  /**\r\n   * Metodo invocato al cambio del tipo di visualizzazione scelta per i campi di tipo elenco generico.\r\n   * Se viene scelta la visualizzazione ad immagini svuota la lista delle coppie chiave-valore inserite\r\n   * in precedenza, altrimenti svuota la lista delle immagini caricate.\r\n   */\r\n  onPresentationModeChange() {\r\n\r\n  }\r\n\r\n  /**\r\n   * Metodo invocato al salvataggio degli allegati quando viene configurato un campo di tipo \"Elenco generico\"\r\n   * con il tipo di visualizzazione ad immagini. Intercetta l'elenco aggiornato delle immagini caricate e lo\r\n   * memorizza nell'oggetto field corrente.\r\n   * @param attachments Array aggiornato degli allegati caricati.\r\n   */\r\n  catchButtonImagesChange(attachments: Array<IAttachmentDTO>) {\r\n\r\n    (this.field as ImageSelectorField).AttachmentList = attachments as Array<DynAttachment>;\r\n\r\n      (this.field as ImageSelectorField).AttachmentList.forEach((attachment: DynAttachment) => {\r\n        if (typeof attachment.ImageHeightPx == \"undefined\"){\r\n\r\n          var myBase64 = \"data:image/\"+attachment.FileExtension.toLowerCase()+\";base64,\" + attachment.FileDataBase64;\r\n          var img = new Image();\r\n\r\n          img.src = myBase64;\r\n          var self = this;\r\n          img.addEventListener('load',function(){\r\n              attachment.ImageWidthPx = img.width;\r\n              attachment.ImageHeightPx = img.height;\r\n              attachment.AttachmentFieldType = AttachmentFieldTypeEnum.ELENCO_IMMAGINI;\r\n              if (self.imageSelectorAttachments){ self.imageSelectorAttachments.reloadData(); }\r\n          });\r\n\r\n        }\r\n      });\r\n      \r\n  }\r\n\r\n  catchButtonImageChange(attachments: Array<IAttachmentDTO>) {\r\n\r\n    (this.field as ImageField).DynAttachment = attachments[1] as DynAttachment;\r\n\r\n      if (this.field.DynAttachment != null && typeof this.field.DynAttachment.ImageHeightPx == \"undefined\"){\r\n\r\n        var myBase64 = \"data:image/\"+this.field.DynAttachment.FileExtension.toLowerCase()+\";base64,\" + this.field.DynAttachment.FileDataBase64;\r\n        var img = new Image();\r\n\r\n        img.src = myBase64;\r\n        var self = this;\r\n        img.addEventListener('load',function(){\r\n          self.field.DynAttachment.ImageWidthPx = img.width;\r\n          self.field.DynAttachment.ImageHeightPx = img.height;\r\n          self.field.DynAttachment.AttachmentFieldType = AttachmentFieldTypeEnum.IMMAGINE;\r\n        });\r\n\r\n      }      \r\n      \r\n  }  \r\n\r\n  catchButtonImageWithMarkersChange(attachments: Array<IAttachmentDTO>) {\r\n\r\n    (this.field as ImageWithMarkersField).DynAttachment = attachments[1] as DynAttachment;\r\n\r\n      if (this.field.DynAttachment != null && typeof this.field.DynAttachment.ImageHeightPx == \"undefined\"){\r\n\r\n        var myBase64 = \"data:image/\"+this.field.DynAttachment.FileExtension.toLowerCase()+\";base64,\" + this.field.DynAttachment.FileDataBase64;\r\n        var img = new Image();\r\n\r\n        img.src = myBase64;\r\n        var self = this;\r\n        img.addEventListener('load',function(){\r\n          self.field.DynAttachment.ImageWidthPx = img.width;\r\n          self.field.DynAttachment.ImageHeightPx = img.height;\r\n          self.field.DynAttachment.AttachmentFieldType = AttachmentFieldTypeEnum.IMMAGINE_CON_MARKERS;\r\n        });\r\n\r\n      }      \r\n      \r\n  }    \r\n\r\n  /**\r\n   * Metodo chiamato al keyup degli input testuali che prevedono l'aggiunta del valore inserito in un array.\r\n   * Se l'utente preme il tasto invio, in base al tipo di campo che sta inserendo/modificando, questo metodo\r\n   * aggiunge il valore inserito dall'utente nella lista di stringhe corretta (in input viene passato il nome\r\n   * della proprietà in cui inserire la stringa).\r\n   * @param event Evento che rappresenta il keyup dell'utente\r\n   * @param propertyName Nome della proprietà del field in cui inserire la stringa digitata.\r\n   */\r\n  onMultiSelectInputKeyup(event, propertyName: string) {\r\n    if (event.code === \"Enter\" || event.code === \"NumpadEnter\") {\r\n      switch (this.field.FieldType) {\r\n        case FieldTypeEnum.Lookup:\r\n        case FieldTypeEnum.Allegato:\r\n          if (!this.field[propertyName]) {\r\n            this.field[propertyName] = new Array<string>();\r\n          }\r\n          this.field[propertyName].push(event.currentTarget.value);\r\n          break;\r\n          case FieldTypeEnum[\"Immagine con markers\"]:\r\n            break;          \r\n        case FieldTypeEnum.Immagine:\r\n          break;\r\n        case FieldTypeEnum[\"Elenco generico\"]:\r\n          if (!this.keyValueObject.key || !this.keyValueObject.value) {\r\n            return;\r\n          }\r\n          if (!(this.field as ListValueField).ValuePairs) {\r\n            (this.field as ListValueField).ValuePairs = {};\r\n          }\r\n          (this.field as ListValueField).ValuePairs[this.keyValueObject.key] =\r\n            this.keyValueObject.value;\r\n          this.keyValueObject = { key: \"\", value: \"\" };\r\n          break;\r\n      }\r\n      event.currentTarget.value = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo chiamato per mostrare come elenco le opzioni aggiunte in un campo di tipo \"Elenco generico\".\r\n   * @returns Restituisce un array di oggetti del tipo { key: string, value: string } con i valori inseriti dall'utente.\r\n   */\r\n  getDictionaryKeyValue() {\r\n    if ((this.field as ListValueField).ValuePairs) {\r\n      return Object.keys((this.field as ListValueField).ValuePairs).map((k) => {\r\n        return {\r\n          key: k,\r\n          value: (this.field as ListValueField).ValuePairs[k],\r\n        };\r\n      });\r\n    } else {\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per rimuovere una opzione aggiunta al campo di tipo \"Elenco generico\"\r\n   * @param key Nome della chiave da rimuovere\r\n   */\r\n  deleteKeyFromDictionary(key: string) {\r\n    delete (this.field as ListValueField).ValuePairs[key];\r\n  }\r\n\r\n  /**\r\n   * Metodo per aprire il dialog per aggiungere/modificare un metadata in un campo di tipo Allegato o Immagine.\r\n   * @param metadata Metadata da modificare, se null allora ne sto creando uno nuovo.\r\n   */\r\n  // openMetadataDialog(field: BaseField = null) {\r\n  //   if (field) {\r\n  //     if (this.field.FieldType === FieldTypeEnum.Allegato) {\r\n  //       this.indexSelectedMetadata = (this.field as AttachmentField).MetadataFields.indexOf(field);\r\n  //       this.selectedMetadata = JSON.parse(JSON.stringify(field));\r\n  //     } else if (this.field.FieldType === FieldTypeEnum.Immagine) {\r\n  //       this.indexSelectedMetadata = (this.field as ImageField).AttachDefinition.MetadataFields.indexOf(field);\r\n  //       this.selectedMetadata = JSON.parse(JSON.stringify(field));\r\n  //     }\r\n  //   } else {\r\n  //     this.selectedMetadata = new BaseField();\r\n  //     this.indexSelectedMetadata = null;\r\n  //   }\r\n  //   this.dialogMetadataRef = this.dialog.open(this.dialogMetadata, {\r\n  //     disableClose: true,\r\n  //     hasBackdrop: true,\r\n  //     width: '75%'\r\n  //   });\r\n  // }\r\n\r\n  //#region openFormulaDialog\r\n  openFormulaDialog() {\r\n    this.dialogFormulaRef = this.dialog.open(this.dialogFormula, {\r\n      disableClose: true,\r\n      hasBackdrop: true,\r\n      width: \"75%\",\r\n      data: {\r\n        fields: this.availableFields,\r\n        formula: this.field.Formula,\r\n      },\r\n    });\r\n    this.dialogFormulaRef.afterClosed().subscribe((result) => {\r\n      this.field.Formula = result.formula.toString() == \"\" ? null : result.formula.toString();\r\n    });\r\n  }\r\n  //#endregion openFormulaDialog\r\n\r\n  //#region openVisibleIfDialog\r\n  openVisibleIfDialog() {\r\n    this.dialogVisibleIfRef = this.dialog.open(this.dialogFormula, {\r\n      disableClose: true,\r\n      hasBackdrop: true,\r\n      width: \"75%\",\r\n      data: {\r\n        fields: this.availableFields,\r\n        formula: this.field.VisibleIf,\r\n      },\r\n    });\r\n    this.dialogVisibleIfRef.afterClosed().subscribe((result) => {\r\n      this.field.VisibleIf = result.formula.toString() == \"\" ? null : result.formula.toString();\r\n    });\r\n  }\r\n  //#endregion openVisibleIfDialog\r\n\r\n  //#region openAnswerStyleVisibleIfDialog\r\n  openAnswerStyleVisibleIfDialog() {\r\n    this.dialogVisibleIfRef = this.dialog.open(this.dialogFormula, {\r\n      disableClose: true,\r\n      hasBackdrop: true,\r\n      width: \"75%\",\r\n      data: {\r\n        fields: this.availableFields,\r\n        formula: this.field.AnswerStyle.VisibleIf,\r\n      },\r\n    });\r\n    this.dialogVisibleIfRef.afterClosed().subscribe((result) => {\r\n      this.field.AnswerStyle.VisibleIf = result.formula.toString() == \"\" ? null : result.formula.toString();\r\n    });\r\n  }\r\n  //#endregion openAnswerStyleVisibleIfDialog\r\n\r\n  stringSanitizer(value) {\r\n    if (!UtilityHelperService.stringCheckParentesis(value)) {\r\n      // alert(\"errore!\");\r\n    }\r\n  }\r\n  /**\r\n   * Metodo invocato dall'output dal dialog per aggiungere/modificare un metadata\r\n   * nei campi di tipo Allegato o Immagine. Prima di aggiungere il metadata nell'elenco\r\n   * contolla se esiste un altro metadata con lo stesso nome e nel caso genera un errore\r\n   * (i metadata, come per i campi della form, devono avere un nome univoco).\r\n   * @param metadata Metadata aggiunto o modificato, se null allora il dialog è stato chiuso senza fare modifiche.\r\n   */\r\n  // onSaveMetadata(metadata: BaseField) {\r\n  //   if (metadata) {\r\n  //     if (\r\n  //       (this.field.FieldType === FieldTypeEnum.Allegato\r\n  //         && (this.field as AttachmentField).MetadataFields\r\n  //         && (this.field as AttachmentField).MetadataFields.find(\r\n  //           (m, i) => m.Label === metadata.Label\r\n  //             && (this.indexSelectedMetadata == null ? true : this.indexSelectedMetadata !== i)\r\n  //         )\r\n  //       ) ||\r\n  //       (this.field.FieldType === FieldTypeEnum.Immagine\r\n  //         && (this.field as ImageField).AttachDefinition.MetadataFields\r\n  //         && (this.field as ImageField).AttachDefinition.MetadataFields.find(\r\n  //           (m, i) => m.Label === metadata.Label\r\n  //             && (this.indexSelectedMetadata == null ? true : this.indexSelectedMetadata !== i)\r\n  //         )\r\n  //       )\r\n  //     ) {\r\n  //       EqpDynamicModuleDialogService.Warning('Impossibile inserire due metadata con la stessa label.');\r\n  //       throw new Error('Impossibile inserire due metadata con la stessa label.');\r\n  //     }\r\n\r\n  //     if (this.indexSelectedMetadata != null && this.indexSelectedMetadata >= 0) {\r\n  //       if (this.field.FieldType === FieldTypeEnum.Allegato) {\r\n  //         (this.field as AttachmentField).MetadataFields[this.indexSelectedMetadata] = metadata;\r\n  //       } else if (this.field.FieldType === FieldTypeEnum.Immagine) {\r\n  //         (this.field as ImageField).AttachDefinition.MetadataFields[this.indexSelectedMetadata] = metadata;\r\n  //       }\r\n  //     } else {\r\n  //       if (this.field.FieldType === FieldTypeEnum.Allegato) {\r\n  //         if (!(this.field as AttachmentField).MetadataFields) {\r\n  //           (this.field as AttachmentField).MetadataFields = new Array<BaseField>();\r\n  //         }\r\n  //         (this.field as AttachmentField).MetadataFields.push(metadata);\r\n  //       } else if (this.field.FieldType === FieldTypeEnum.Immagine) {\r\n  //         if (!(this.field as ImageField).AttachDefinition.MetadataFields) {\r\n  //           (this.field as ImageField).AttachDefinition.MetadataFields = new Array<BaseField>();\r\n  //         }\r\n  //         (this.field as ImageField).AttachDefinition.MetadataFields.push(metadata);\r\n  //       }\r\n  //     }\r\n  //   }\r\n  //   this.dialogMetadataRef.close();\r\n  //   this.setMetadataOrdinalPosition();\r\n  //   this.reloadMetadataTable();\r\n  // }\r\n\r\n  //#region disableSaveField\r\n  /**\r\n   * Metodo per disabilitare il pulsante per salvare il campo inserito/modificato.\r\n   * @returns Restituisce un booleano, se true il salvataggio viene disabilitato.\r\n   */\r\n  disableSaveField(): boolean {\r\n\r\n    if (this.fieldFormGroup.invalid) {\r\n      return true;\r\n    }\r\n\r\n    switch (this.field.FieldType) {\r\n      case FieldTypeEnum[\"Elenco generico\"]:\r\n\r\n        if (\r\n          (this.field as ListValueField).Formula != undefined &&\r\n          (this.field as ListValueField).Formula != \"\"\r\n        ) {\r\n          if (!(this.field as ListValueField).ValuePairs) {\r\n            (this.field as ListValueField).ValuePairs = {};\r\n          }\r\n          return false;\r\n        }\r\n\r\n        if(\r\n          (this.field as ListValueField).ValueString != undefined &&\r\n          (this.field as ListValueField).ValueString != null &&\r\n          (this.field as ListValueField).ValueString != \"\"){\r\n          return false\r\n        }\r\n\r\n        return (\r\n          !(this.field as ListValueField).ValuePairs ||\r\n          (this.field as ListValueField).ValuePairs.length === 0\r\n        );\r\n        \r\n      case FieldTypeEnum[\"Elenco immagini\"]: \r\n\r\n      return (\r\n        !(this.field as ImageSelectorField).AttachmentList ||\r\n        (this.field as ImageSelectorField).AttachmentList.length === 0 ||\r\n        (this.field as ImageSelectorField).AttachmentList.find(\r\n          (i) => (i.ButtonKey == null || i.ButtonKey === \"undefined\" || i.ButtonKey == '') || (i.ButtonValue == null || i.ButtonValue === \"undefined\" || i.ButtonValue == '')\r\n        ) != null\r\n      );\r\n\r\n      case FieldTypeEnum.Lookup:\r\n        return (\r\n          !(this.field as LookupField).FieldNames ||\r\n          (this.field as LookupField).FieldNames.length === 0\r\n        );\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n  //#endregion disableSaveField\r\n\r\n  //#region saveAndExitAddField\r\n  /**\r\n   * Metodo per salvare il campo inserito/modificato.\r\n   * Se è stato inserito un field con la stessa label viene generato un errore (le label devono essere univoche).\r\n   * Una volta aggiunto/aggiornato il campo nell'elenco dei Field della Form chiude il dialog e ricarica la tabella\r\n   * che mostra l'elenco dei campi aggiunti alla form.\r\n   */\r\n  saveAndExitAddField(save: boolean) {\r\n    this.setResizedImagesHeightPx();\r\n    this.setFieldOrdinalPosition();\r\n    if (this.imageSelectorAttachments){ this.imageSelectorAttachments.reloadData(); }\r\n    if (save) {\r\n      // retrocompatibilità con valuepairs per Elenco Generico\r\n      if(this.field.FieldType == FieldTypeEnum[\"Elenco generico\"]) {\r\n        if(((this.field as ListValueField).Formula && (this.field as ListValueField).Formula != \"\") || ((this.field as ListValueField).ValueString && (this.field as ListValueField).ValueString != \"\")){\r\n          (this.field as ListValueField).ValuePairs = null;\r\n        }\r\n      }\r\n      if(this.field.FieldType == FieldTypeEnum[\"Elenco immagini\"]) {\r\n        if(((this.field as ImageSelectorField).AttachmentList.length > 0)){\r\n          (this.field as ImageSelectorField).AttachmentList.forEach((attachment) => {\r\n            attachment.ResizedImageHeightPx = (this.field as ImageSelectorField).ResizedImagesHeightPx;\r\n          });\r\n        }\r\n      }\r\n      if(this.field.FieldType == FieldTypeEnum.Immagine) {\r\n        if(((this.field as ImageField).DynAttachment != null)){\r\n          (this.field as ImageField).DynAttachment.ResizedImageHeightPx = (this.field as ImageField).ResizedImagesHeightPx;\r\n        }\r\n      }      \r\n      if(this.field.FieldType == FieldTypeEnum[\"Immagine con markers\"]) {\r\n        if(((this.field as ImageWithMarkersField).DynAttachment != null)){\r\n          (this.field as ImageWithMarkersField).DynAttachment.ResizedImageHeightPx = (this.field as ImageWithMarkersField).ResizedImagesHeightPx;\r\n        }\r\n      }         \r\n      GlobalService.debugLog('add-form-field save', this.field)\r\n      this.saveFieldEvent.emit(this.field);\r\n    } else {\r\n      this.saveFieldEvent.emit(null);\r\n    }\r\n  }\r\n  //#endregion saveAndExitAddField\r\n\r\n  //#region restoreBaseFieldProperties\r\n  /**\r\n   * Metodo per ripristinare l'oggetto field al cambio del tipo selezionato.\r\n   * Lascia valorizzate solo le proprietà dell'oggetto BaseField comune a tutti i tipi di campo.\r\n   */\r\n  private restoreBaseFieldProperties() {\r\n    if (this.field) {\r\n      const tmpBaseField = JSON.parse(JSON.stringify(this.field));\r\n      this.field = new BaseField();\r\n      this.field.Label = tmpBaseField.Label;\r\n      this.field.Description = tmpBaseField.Description;\r\n      this.field.Required = tmpBaseField.Required;\r\n      this.field.FieldType = tmpBaseField.FieldType;\r\n      this.field.Formula = tmpBaseField.Formula;\r\n      this.field.ColSpanSizes = tmpBaseField.ColSpanSizes;\r\n      this.field.InListView = tmpBaseField.InListView;\r\n      this.field.Invisibility = tmpBaseField.Invisibility;\r\n      this.field.Tooltip = tmpBaseField.Tooltip;\r\n      this.field.Readonly = tmpBaseField.Readonly;\r\n      this.field.FieldGroup = tmpBaseField.FieldGroup;\r\n      this.field.VisibleIf = tmpBaseField.VisibleIf;\r\n    }\r\n  }\r\n  //#region restoreBaseFieldProperties\r\n\r\n  countValuePairs(valuePairs): number{\r\n    if(valuePairs){\r\n      return Object.keys(valuePairs).length;\r\n    } else {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  configureColumns(){\r\n\r\n    // Lista Generica di immagini\r\n    this.configColumnListImages = [];\r\n\r\n      this.configColumnListImages.push({\r\n        key: 'action', display: '', type: TypeColumn.MenuAction, buttonMenuIcon: 'more_vert', styles: { flex: '0 0 6%' },\r\n        actions: [\r\n          { name: 'Elimina', icon: 'delete', fn: (element, index, col) => this.deleteListImage(element, index, col) },\r\n          {\r\n            name: \"Sposta su\",\r\n            icon: \"arrow_upward\",\r\n            fn: (element, index, col) =>\r\n              this.moveElement(element, true),\r\n            disabled: (element) => this.field.AttachmentList.indexOf(element) === 0,\r\n          },\r\n          {\r\n            name: \"Sposta giù\",\r\n            icon: \"arrow_downward\",\r\n            fn: (element, index, col) =>\r\n              this.moveElement(element, false),\r\n            disabled: (element) =>\r\n              this.field.AttachmentList.indexOf(element) >= this.field.AttachmentList.length - 1,\r\n          },\r\n        ]\r\n      }); \r\n\r\n    this.configColumnListImages.push({\r\n      key:\"FileDataBase64\",\r\n      display: \"Immagine\",\r\n      type: TypeColumn.ExternalTemplate,\r\n      externalTemplate: this.GenericListImagesImageTemplate,\r\n    });    \r\n    this.configColumnListImages.push({\r\n      key:\"ButtonKey\",\r\n      display: \"Chiave\",\r\n      type: TypeColumn.ExternalTemplate,\r\n      externalTemplate: this.GenericListImagesKeyTemplate,\r\n    });\r\n    this.configColumnListImages.push({\r\n      key:\"ButtonValue\",\r\n      display: \"Valore\",\r\n      type: TypeColumn.ExternalTemplate,\r\n      externalTemplate: this.GenericListImagesValueTemplate,\r\n    });   \r\n    this.configColumnListImages.push({\r\n      key:\"ImageWidthPx\",\r\n      display: \"Larghezza\"\r\n    });     \r\n    this.configColumnListImages.push({\r\n      key:\"ImageHeightPx\",\r\n      display: \"Altezza\"\r\n    });            \r\n\r\n  }\r\n\r\n  private moveElement(\r\n    element: DynAttachment,\r\n    moveUp: boolean\r\n  ) {\r\n    const startingIndex = this.field.AttachmentList.indexOf(element);\r\n    const endingIndex = startingIndex + (moveUp ? -1 : 1);\r\n\r\n    this.field.AttachmentList.splice(startingIndex, 1);\r\n    this.field.AttachmentList.splice(endingIndex, 0, element);\r\n\r\n    this.setFieldOrdinalPosition();\r\n    if (this.imageSelectorAttachments){ this.imageSelectorAttachments.reloadData(); }\r\n  }\r\n\r\n  private setFieldOrdinalPosition() {\r\n    if (this.field.AttachmentList) {\r\n      this.field.AttachmentList.forEach((field) => {\r\n        field.OrdinalPosition = this.field.AttachmentList.indexOf(field);\r\n      });\r\n    }\r\n  }\r\n\r\n  setResizedImagesHeightPx(){\r\n    this.resizedImagesHeightPx = this.field.ResizedImagesHeightPx;\r\n  }\r\n\r\n  deleteListImage(el: DynAttachment, i: number, col: number){\r\n        EqpDynamicModuleDialogService.Confirm('Eliminare questa immagine?', () => {\r\n        this.field.AttachmentList.splice(el.originalIndex, 1);\r\n        if (this.imageSelectorAttachments){ this.imageSelectorAttachments.reloadData(); }\r\n\r\n     }, false, 'Richiesta conferma');\r\n  }\r\n\r\n  deleteImage(el: DynAttachment){\r\n    this.field.DynAttachment = null;\r\n  }\r\n\r\n  // DB GETTER\r\n  openDBGetter(){\r\n    if (this.QueryEditorComponent != null && !this.QueryEditorComponent.inputParams.useDynamicModuleMock){\r\n\r\n      this.QueryEditorComponent.inputParams.config.mode = QueryEditorModeEnum.COMPOSER;\r\n      this.QueryEditorComponent.inputParams.config.loadQueryStatuses = this.field.DataGetter.DataGetterValue;\r\n\r\n      this.dialogQERef = this.dialog.open(this.dialogQE, {\r\n        disableClose: true,\r\n        hasBackdrop: true,\r\n        panelClass: 'query-editor-modal',\r\n        width: '90%'\r\n      });\r\n\r\n    } else {\r\n\r\n      this.httpClient.get('./assets/mockups/mockedFromQueryEditor_QUERY_WITH_QUESTION.txt', {responseType: 'text'})\r\n      .subscribe(mockedFromQueryEditor => {\r\n        this.treatDataFromQueryEditor(JSON.parse(mockedFromQueryEditor).Params);\r\n       });\r\n\r\n    }\r\n  }\r\n\r\n  closeQEModal(){\r\n    this.dialogQERef.close();\r\n  }\r\n\r\n  onExternalComponentOut(ev: eventOut){\r\n    if (ev.Behaviours.indexOf(\"send-out\") != -1){ this.out.emit(ev); }\r\n    if (ev.Behaviours.indexOf(\"close-modal\") != -1){ this.closeQEModal(); }   \r\n    if (ev.Behaviours.indexOf(\"save-query\") != -1){ \r\n      \r\n      this.treatDataFromQueryEditor(ev.Params);\r\n\r\n     }\r\n  }\r\n\r\n  treatDataFromQueryEditor(data: any){\r\n    this.field.DataGetter.DataGetterValue = data;\r\n    this.createColumnKeys(data);\r\n  }\r\n\r\n  createColumnKeys(data){\r\n    if (data == null && this.field.DataGetter.DataGetterValue != null){ data = this.field.DataGetter.DataGetterValue; }\r\n    if (data != null && typeof data != \"undefined\" && typeof data.selectedFields != \"undefined\"){\r\n      this.columnKeys = new Array<{ key: string; value: string }>();\r\n      data.selectedFields.forEach((key) => {\r\n        this.columnKeys.push({key: key.DatabaseTableName+\"_\"+key.PropertyName+\"__\"+key.CurrentTranslate.replace(\" \",\"_\"), value: key.CurrentTranslate});\r\n      });\r\n    }\r\n  }\r\n\r\n  getAllModules(){\r\n    const dynamicModuleParams: Array<EndPointDataParams> =\r\n      new Array<EndPointDataParams>();\r\n    dynamicModuleParams.push({\r\n      ParamName: \"orgaid\",\r\n      ParamValue: this.form.OrgaID,\r\n      ParamType: ParamTypeEnum[\"Query param\"],\r\n    });\r\n    this.utilityHelperService.RunEndPointCall(\r\n      this.endPointConfiguration.Forms.GetAllFormEndPoint,\r\n      dynamicModuleParams,\r\n      (res: Array<Form>) => {\r\n        this.forms = res;\r\n        this.forms = this.forms.sort((uno, due) => uno.Name.localeCompare(due.Name));\r\n\r\n        this.DMField = null;\r\n        if (this.DMModule == null && this.field.DataGetter.DataGetterValue != null){\r\n          this.DMModule = this.forms.find(x => x.Code == this.field.DataGetter.DataGetterValue);\r\n          this.DMModule.Fields = JSON.parse(this.DMModule.JsonFields);\r\n          this.DMFields = new Array<{ key: string }>();\r\n          this.DMModule.Fields.forEach(element => {\r\n              this.DMFields.push({ key: element.Value.Name });\r\n          });\r\n\r\n          this.DMFields = this.DMFields.sort((uno, due) => uno.key.localeCompare(due.key));\r\n  \r\n          if (this.field.DataGetter.DataGetterColumnForce != null){\r\n            this.DMField = this.DMFields.find(x => x.key == this.field.DataGetter.DataGetterColumnForce);\r\n          }          \r\n        }\r\n\r\n      },\r\n      (err) => { }\r\n    );    \r\n  }\r\n\r\n  onChangeDMModule(){\r\n    console.log(\"this.DMModule\",this.DMModule,this.field.DataGetter.DataGetterValue);\r\n    if (this.DMModule != null){\r\n      this.DMModule.Fields = JSON.parse(this.DMModule.JsonFields);\r\n      this.DMFields = new Array<{ key: string }>();\r\n      this.DMModule.Fields.forEach(element => {\r\n        this.DMFields.push({ key: element.Value.Name });\r\n      });\r\n  \r\n      this.field.DataGetter.DataGetterValue = this.DMModule.Code;\r\n    } else {\r\n      this.DMModule = null;\r\n      this.field.DataGetter.DataGetterValue = null;\r\n      this.DMField = null;\r\n      this.field.DataGetter.DataGetterColumnForce = null;\r\n    }\r\n  }\r\n\r\n  onChangeDMField(){\r\n    if (this.DMField != null){\r\n      this.field.DataGetter.DataGetterColumnForce = this.DMField.key;\r\n    } else {\r\n      this.field.DataGetter.DataGetterColumnForce = null;\r\n    }\r\n  }\r\n\r\n  onChangeDMContestualization(){\r\n    console.log(\"onChangeDMContestualization()\", this.field.DataGetter.DataGetterContestualization);\r\n  }\r\n\r\n}\r\n","<!-- <div class=\"add-form-field bigwrapper\" style=\"max-height: 100vh !important; overflow-x: hidden; overflow-y: auto;\"> -->\r\n\r\n<mat-card class=\"add-form-field\">\r\n    <mat-card-header>\r\n        <mat-card-title>\r\n            {{indexField != null && indexField >= 0 ? \"Modifica\" : \"Aggiungi\"}} campo\r\n        </mat-card-title>\r\n    </mat-card-header>\r\n\r\n    <mat-card-content>\r\n\r\n        <div class=\"container-fluid containerContent \">\r\n            <form [formGroup]=\"fieldFormGroup\" style=\"height: 100%;\">\r\n                <!--#region AREA PRINCIPALE -->\r\n                <div class=\"row eqp-dform-add-form-field-main\">\r\n                    <!--#region TIPO CAMPO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2 tipoCampo\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldType'].status != 'VALID' && fieldFormGroup.controls['FieldType'].touched }\">\r\n                            Tipo campo *\r\n                        </mat-label>\r\n                        <eqp-select [enumData]=\"FieldTypeEnum\" [(ngModelInput)]=\"field.FieldType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onFieldTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'FieldType'\"\r\n                            [enumDataToExclude]=\"fieldTypesToExclude\">\r\n                        </eqp-select>\r\n                    </div>\r\n                    <!--#endregion TIPO CAMPO -->\r\n\r\n                    <!--#region CODICE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Label'].status != 'VALID' && fieldFormGroup.controls['Label'].touched }\">\r\n                            Codice *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input formControlName=\"Label\" required matInput [(ngModel)]=\"field.Label\"\r\n                                (keypress)=\"omit_special_char($event)\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (focusout)=\"stringSanitizer(field.Label)\">\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Label') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['pattern']\">\r\n                                        Si possono inserire solo lettere a-z\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Label'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion CODICE -->\r\n\r\n                    <!--#region DESCRIZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['Description'].status != 'VALID' && fieldFormGroup.controls['Description'].touched }\">\r\n                            Descrizione *\r\n                        </mat-label>\r\n                        <mat-form-field>\r\n                            <input name=\"Description\" formControlName=\"Description\" required matInput\r\n                                [(ngModel)]=\"field.Description\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Description)\">\r\n                            <!-- <mat-error *ngIf=\"!field.Description.valid && field.FormFormGroup.controls[field.Description].touched\"> -->\r\n                            <mat-error>\r\n                                <!-- {{ getFormValidationErrors('Description') }} -->\r\n                                <ul>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['required']\">\r\n                                        Obbligatorio\r\n                                    </li>\r\n                                    <li *ngIf=\"fieldFormGroup.controls['Description'].errors?.['Missing Parenthesis']\">\r\n                                        Attenzione, ci sono parentesi non chiuse\r\n                                    </li>\r\n                                </ul>\r\n                            </mat-error>\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <!--#endregion DESCRIZIONE -->\r\n\r\n                    <!--#region SEZIONE -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2\" *ngIf=\"formFieldsGroups\">\r\n                        <mat-label\r\n                            [ngClass]=\"{'text-danger': fieldFormGroup.controls['FieldGroup'].status != 'VALID' && fieldFormGroup.controls['FieldGroup'].touched }\">Sezione\r\n                            *</mat-label>\r\n                        <eqp-select [arrayData]=\"formFieldsGroups\" [(ngModelInput)]=\"field.FieldGroup\"\r\n                            [arrayKeyProperty]=\"'Name'\" [arrayValueProperty]=\"'Name'\" [formGroupInput]=\"fieldFormGroup\"\r\n                            [formControlNameInput]=\"'FieldGroup'\" required>\r\n                        </eqp-select>\r\n                        <mat-error>\r\n                            <!-- {{ getFormValidationErrors('FieldGroup') }} -->\r\n                            <ul>\r\n                                <li *ngIf=\"fieldFormGroup.controls['FieldGroup'].errors?.['required']\">\r\n                                    Obbligatorio\r\n                                </li>\r\n                            </ul>\r\n                        </mat-error>\r\n                    </div>\r\n                    <!--#endregion SEZIONE -->\r\n\r\n                    <!--#region OBBLIGATORIO -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Required\" formControlName=\"Required\"\r\n                            color=\"primary\">\r\n                            Obbligatorio\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion OBBLIGATORIO -->\r\n\r\n                    <!--#region READONLY -->\r\n                    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\">\r\n                        <mat-slide-toggle [(ngModel)]=\"field.Readonly\" formControlName=\"Readonly\"\r\n                            color=\"primary\">\r\n                            ReadOnly\r\n                        </mat-slide-toggle>\r\n                    </div>\r\n                    <!--#endregion READONLY -->\r\n\r\n                </div>\r\n                <!--#endregion AREA PRINCIPALE -->\r\n\r\n                <!--#region AREA TABS -->\r\n                <mat-tab-group class=\"eqp-dform-add-form-field-tabs\" mat-stretch-tabs=\"false\" mat-align-tabs=\"start\">\r\n                    <!--#region STILE COMPILAZIONE -->\r\n                    <mat-tab label=\"Stile Compilazione\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesCompilazione\" [(ngModelInput)]=\"field.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'ColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"LabelstyleCSS\" formControlName=\"LabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['LabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"FieldstyleCSS\" formControlName=\"FieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['FieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n                        \r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.VisibleIf != null || field.VisibleIf != undefined) && field.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.InListView\" formControlName=\"InListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['InListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n\r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilità del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'Invisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.VisibleIf\" (click)=\"openVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['VisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                            <!--#region TOOLTIP -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Tooltip </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"Tooltip\" formControlName=\"Tooltip\" matInput [(ngModel)]=\"field.Tooltip\"\r\n                                        spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.Tooltip)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Tooltip') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['Tooltip'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion TOOLTIP -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE COMPILAZIONE -->\r\n\r\n                    <!--#region STILE DELLA RISPSOTA -->\r\n                    <mat-tab label=\"Stile Risposta\">\r\n                        <div class=\"row\">\r\n\r\n                            <!--#region LARGHEZZA CAMPO -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label>Larghezza campo</mat-label>\r\n                                <eqp-select [arrayData]=\"availableColSpanSizesRisposta\" [(ngModelInput)]=\"field.AnswerStyle.ColSpanSizes\"\r\n                                    [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                    (ngModelInputChange)=\"onColSpanSizeSelect()\" [isMultiSelect]=\"true\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleColSpanSizes'\">\r\n                                </eqp-select>\r\n                            </div>\r\n                            <!--#endregion LARGHEZZA CAMPO -->\r\n\r\n                            <!--#region LABEL CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Label css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleLabelstyleCSS\" formControlName=\"AnswerStyleLabelstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.LabelstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.LabelstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('LabelstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleLabelstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion LABEL CSS -->\r\n\r\n                            <!--#region FIELD CSS -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> Field css </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleFieldstyleCSS\" formControlName=\"AnswerStyleFieldstyleCSS\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.FieldstyleCSS\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.FieldstyleCSS)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('FieldstyleCSS') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleFieldstyleCSS'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                            </div>\r\n                            <!--#endregion FIELD CSS -->\r\n\r\n                            <!--#region VISIBLE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"(field.AnswerStyle.VisibleIf != null || field.AnswerStyle.VisibleIf != undefined) && field.AnswerStyle.VisibleIf != ''\">\r\n                                <div class=\" align-self-center\">\r\n                                    <mat-slide-toggle [(ngModel)]=\"field.AnswerStyle.InListView\" formControlName=\"AnswerStyleInListView\"\r\n                                        color=\"primary\" [disabled]=\"fieldFormGroup.controls['AnswerStyleInListView'].disabled\">\r\n                                        Visibile\r\n                                    </mat-slide-toggle>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion VISIBLE -->\r\n                            \r\n                            <!--#region INVISIBILE -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2 align-self-center\"\r\n                                [hidden]=\"field.AnswerStyle.InListView\">\r\n                                <div class=\" align-self-center\">\r\n                                    Tipo di invisibilità del campo\r\n                                    <eqp-select [enumData]=\"fieldInvisibilityEnum\" [(ngModelInput)]=\"field.AnswerStyle.Invisibility\"\r\n                                    [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AnswerStyleInvisibility'\">\r\n                                </eqp-select>\r\n                                </div>\r\n                            </div>\r\n                            <!--#endregion INVISIBLE -->\r\n\r\n                            <!--#region VISIBLE IF -->\r\n                            <div class=\"col-sm-12 col-md-4 mt-2\">\r\n                                <mat-label> VisibleIf </mat-label>\r\n                                <mat-form-field>\r\n                                    <input name=\"AnswerStyleVisibleIf\" formControlName=\"AnswerStyleVisibleIf\" matInput\r\n                                        [(ngModel)]=\"field.AnswerStyle.VisibleIf\" (click)=\"openAnswerStyleVisibleIfDialog()\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                                        (focusout)=\"stringSanitizer(field.AnswerStyle.VisibleIf)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('VisibleIf') }} -->\r\n                                        <ul>\r\n                                            <li\r\n                                                *ngIf=\"fieldFormGroup.controls['AnswerStyleVisibleIf'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field>\r\n                                <!-- <mat-form-field>\r\n                                <input name=\"VisibleIf\" formControlName=\"VisibleIf\" matInput [(ngModel)]=\"field.VisibleIf\"\r\n                                    [matAutocomplete]=\"VisibleIfAutocomplete\" (keyup)=\"setVisibleIfAutocompleteOptions($event)\"\r\n                                    (focus)=\"setVisibleIfAutocompleteOptions(null)\" (focusout)=\"stringSanitizer(field.VisibleIf)\">\r\n                                <mat-autocomplete #VisibleIfAutocomplete=\"matAutocomplete\">\r\n                                    <mat-option *ngFor=\"let option of VisibleIfAutocompleteOptions\" [value]=\"option.value\">\r\n                                        {{option.label}}\r\n                                    </mat-option>\r\n                                </mat-autocomplete>\r\n                            </mat-form-field> -->\r\n                            </div>\r\n                            <!--#endregion VISIBLE IF -->\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion STILE DELLA RISPSOTA -->\r\n\r\n                    <!--#region SPECIFICHE -->\r\n                    <mat-tab label=\"Specifiche\">\r\n                        <div class=\"row\">\r\n                            <ng-container *ngTemplateOutlet=\"fieldTypeFormTemplate\">\r\n                            </ng-container>\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion SPECIFICHE -->\r\n\r\n                    <!--#region MODALITA' RECUPERO DATI -->\r\n                    <mat-tab label=\"Modalità recupero dati\">\r\n                        <div class=\"row\">\r\n\r\n\r\n\r\n                            <eqp-select [enumData]=\"dataGetterTypeEnum\" [(ngModelInput)]=\"field.DataGetter.DataGetterType\"\r\n                            [showCancelButton]=\"false\" (ngModelInputChange)=\"onDataGetterTypeChange()\"\r\n                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DataGetterType'\">\r\n                            </eqp-select>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Manuale\">\r\n                                <mat-label> Valore di Default </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"DataGetterValue\" matInput [(ngModel)]=\"field.DataGetter.DataGetterValue\" spellcheck=\"false\"\r\n                                        autocomplete=\"off\">\r\n                                </mat-form-field>  \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" [hidden]=\"field.DataGetter.DataGetterType != dataGetterTypeEnum.Formula\">\r\n                                <mat-label> Formula (Javascript) </mat-label>\r\n                                <mat-form-field>\r\n                                    <input formControlName=\"Formula\" matInput [(ngModel)]=\"field.Formula\"\r\n                                        (click)=\"openFormulaDialog()\" spellcheck=\"false\" autocomplete=\"off\"\r\n                                        (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formula)\">\r\n                                    <mat-error>\r\n                                        <!-- {{ getFormValidationErrors('Formula') }} -->\r\n                                        <ul>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['required']\">\r\n                                                Obbligatorio\r\n                                            </li>\r\n                                            <li *ngIf=\"fieldFormGroup.controls['Formula'].errors?.['Missing Parenthesis']\">\r\n                                                Attenzione, ci sono parentesi non chiuse\r\n                                            </li>\r\n                                        </ul>\r\n                                    </mat-error>\r\n                                </mat-form-field> \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da database']\">\r\n                                \r\n                                <div class=\"col-12 mt-4 configuraQueryEditor\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-10\">Configura in Query Editor</div>\r\n                                        <div class=\"col-2\">\r\n                                            <button class=\"btn btn-primary\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue == null\">Procedi</button>\r\n                                            <button class=\"btn btn-success\" (click)=\"openDBGetter()\" *ngIf=\"field.DataGetter.DataGetterValue != null\">Modifica</button>\r\n                                        </div>\r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Seleziona colonna</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"columnKeys\" [(ngModelInput)]=\"field.DataGetter.DataGetterColumnForce\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n                                            [showCancelButton]=\"true\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                \r\n                                </div>\r\n                                \r\n                        \r\n                            </div>\r\n                        \r\n                            <div class=\"col-md-4\" *ngIf=\"field.DataGetter.DataGetterType == dataGetterTypeEnum['Da modulo dinamico']\">\r\n                                \r\n                                <div class=\"col-12 mt-4\" *ngIf=\"forms.length > 0\">\r\n                                    <div class=\"row\">\r\n                                        <div class=\"col-6\">Modulo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona modulo'\" [arrayData]=\"forms\" [(ngModelInput)]=\"DMModule\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'Code'\" [arrayValueProperty]=\"'Name'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMModule'\"\r\n                                            (ngModelInputChange)=\"onChangeDMModule()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null && DMModule != null\">\r\n                                        <div class=\"col-6\">Campo</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [placeholder]=\"'Seleziona campo'\" [arrayData]=\"DMFields\" [(ngModelInput)]=\"DMField\" [isSearchable]=\"true\"\r\n                                            [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'key'\"\r\n                                            [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'DMField'\"\r\n                                            (ngModelInputChange)=\"onChangeDMField()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>\r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Cardinalità</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [enumData]=\"DMGetterCardinalities\" [(ngModelInput)]=\"field.DataGetter.DataGetterCardinality\"\r\n                                            [showCancelButton]=\"false\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>         \r\n                                    \r\n                                    <div class=\"row\" *ngIf=\"field.DataGetter.DataGetterValue != null\">\r\n                                        <div class=\"col-6\">Contestualizzazione</div>\r\n                                        <div class=\"col-6\">\r\n                                            <eqp-select [arrayData]=\"contestualization\" [arrayKeyProperty]=\"'entityTableName'\" [arrayValueProperty]=\"'entityTableName'\" [(ngModelInput)]=\"field.DataGetter.DataGetterContestualization\"\r\n                                            [showCancelButton]=\"true\" (ngModelInputChange)=\"onChangeDMContestualization()\">\r\n                                            </eqp-select>\r\n                                        </div>    \r\n                                    </div>                                      \r\n                                \r\n                                </div>\r\n\r\n                            </div>\r\n\r\n                        </div>\r\n                    </mat-tab>\r\n                    <!--#endregion MODALITA' RECUPERO DATI -->\r\n\r\n                </mat-tab-group>\r\n                <!--#region AREA TABS -->\r\n\r\n                <!--#region listValueFieldFormTemplate vallues -->\r\n                \r\n                <!--#endregion listValueFieldFormTemplate vallues -->\r\n\r\n            </form>\r\n        </div>\r\n    </mat-card-content>\r\n\r\n    <mat-card-footer>\r\n\r\n        <div class=\"d-flex justify-content-end mt-2 mb-1 me-3\"> \r\n            <!-- <div class=\"buttonsForma\"> -->\r\n            <button class=\"btn mat-raised-button cancel\" (click)=\"saveAndExitAddField(false)\" type=\"button\">\r\n                Annulla\r\n            </button>\r\n            <span class=\"me-2\"></span>\r\n            <button class=\"mr-2 save\" mat-raised-button color=\"primary\" (click)=\"saveAndExitAddField(true)\"\r\n                [disabled]=\"disableSaveField()\" type=\"button\">\r\n                Salva\r\n            </button>\r\n            <!-- </div> -->\r\n        </div>\r\n    </mat-card-footer>\r\n</mat-card>\r\n\r\n<!-- </div> -->\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI DI TESTO -->\r\n<ng-template #textFieldFormTemplate>\r\n    <!--#region MASCHERA -->\r\n    <div class=\"col-sm-12 col-md-6\">\r\n        <mat-label>Maschera</mat-label>\r\n        <eqp-select [enumData]=\"TextMaskEnum\" [(ngModelInput)]=\"field.TextMask\" [formGroupInput]=\"fieldFormGroup\"\r\n            [formControlNameInput]=\"'TextMask'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion MASCHERA -->\r\n\r\n    <!--#region SPEECH TO TEXT -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SPEECH TO TEXT -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MinLenght'].status != 'VALID' && fieldFormGroup.controls['MinLenght'].touched }\">\r\n            Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n            [ngClass]=\"{'text-danger': fieldFormGroup.controls['MaxLenght'].status != 'VALID' && fieldFormGroup.controls['MaxLenght'].touched }\">\r\n            Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI DI TESTO -->\r\n\r\n<!--#region FORM PROPRIETÀ ETICHETTA -->\r\n<ng-template #labelFieldFormTemplate>\r\n\r\n    <!--#region ETICHETTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-form-field>\r\n\r\n            <textarea name=\"Etichetta\" placeholder=\"Etichetta\" matInput formControlName=\"Etichetta\" [(ngModel)]=\"field.Etichetta\"></textarea>\r\n\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion ETICHETTA -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ ETICHETTA -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI AREA DI TESTO -->\r\n<ng-template #textareaFieldFormTemplate>\r\n    <!--#region RIGHE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Righe </mat-label>\r\n        <mat-form-field class=\"righe\">\r\n            <input id=\"rows\" formControlName=\"Rows\" type=\"number\" [min]=\"0\" matInput [(ngModel)]=\"field.Rows\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.Rows)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Rows') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['Rows'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion RIGHE -->\r\n\r\n    <!--#region SpeechToText -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\" [hidden]=\"field.Readonly\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.Microphone\" formControlName=\"Microphone\" color=\"primary\">\r\n            Speech-To-Text\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SpeechToText -->\r\n\r\n    <!--#region LUNGHEZZA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza minima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMin\" formControlName=\"MinLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MinLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MINIMA -->\r\n\r\n    <!--#region LUNGHEZZA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Lunghezza massima </mat-label>\r\n        <mat-form-field>\r\n            <input id=\"lengthMax\" formControlName=\"MaxLenght\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.MaxLenght\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxLenght)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxLenght') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxLenght'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion LUNGHEZZA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI AREA DI TESTO -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI BOOLEANI -->\r\n<ng-template #booleadFieldFormTemplate>\r\n    <!--#region A TRE STATI -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsTristate\" formControlName=\"IsTristate\" color=\"primary\">\r\n            A tre stati\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion A TRE STATI -->\r\n\r\n    <!--#region TIPO PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di presentazione *</mat-label>\r\n        <eqp-select [enumData]=\"BoolPresentantioEnum\" [(ngModelInput)]=\"field.PresetationType\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresetationType'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO PRESENTAZIONE -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI BOOLEANI -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI DATA -->\r\n<ng-template #dateFieldFormTemplate>\r\n    <!--#region TIPO DI DATA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label>Tipo di data</mat-label>\r\n        <eqp-select [enumData]=\"DateTimeTypeEnum\" [(ngModelInput)]=\"field.IsOnlyDate\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'IsOnlyDate'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI DATA -->\r\n\r\n    <!--#region FORMATO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Formato </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DateFormat\" matInput [(ngModel)]=\"field.DateFormat\"\r\n                [matTooltip]=\"'Indicare il formato seguendo la guida del pacchetto momentjs.'\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.Formato)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('Formato') }} -->\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion FORMATO -->\r\n\r\n    <!--#region DATA MINIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data minima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MinDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MinDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MINIMA -->\r\n\r\n    <!--#region DATA MASSIMA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\">\r\n        <mat-label> Data massima </mat-label>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo data']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Data e ora']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.DATETIMEPICKER\" [outputFormat]=\"'DD/MM/YYYY HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n        <tmw-datetimepicker *ngIf=\"field.IsOnlyDate == DateTimeTypeEnum['Solo orario']\" class=\"date\"\r\n            [(ngModelInput)]=\"field.MaxDate\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'MaxDate'\"\r\n            [pickerMode]=\"mode.TIMEPICKER\" [outputFormat]=\"'HH:mm'\" [showSeconds]=\"false\">\r\n        </tmw-datetimepicker>\r\n    </div>\r\n    <!--#endregion DATA MASSIMA -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI DATA -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI NUMERICI -->\r\n<ng-template #numericFieldFormTemplate>\r\n    <!--#region VALORE INTERO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsInteger\" formControlName=\"IsInteger\" color=\"primary\">\r\n            Valore intero\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion VALORE INTERO -->\r\n\r\n    <!--#region SEPARATORE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalSeparator\" matInput [(ngModel)]=\"field.DecimalSeparator\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.DecimalSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['pattern']\">\r\n                        Non è possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE DECIMALI -->\r\n\r\n    <!--#region PRECISIONE DECIMALI -->\r\n    <div *ngIf=\"!field.IsInteger\" class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Precisione decimali </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"DecimalPrecision\" type=\"number\" [min]=\"0\" matInput\r\n                [(ngModel)]=\"field.DecimalPrecision\" spellcheck=\"false\" autocomplete=\"off\"\r\n                (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.DecimalPrecision)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('DecimalPrecision') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['DecimalPrecision'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion PRECISIONE DECIMALI -->\r\n\r\n    <!--#region SEPARATORE MIGLIAIA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Separatore migliaia </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"ThousandsSeparator\" matInput [(ngModel)]=\"field.ThousandsSeparator\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.ThousandsSeparator)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('ThousandsSeparator') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['pattern']\">\r\n                        Non è possibile inserire dei numeri.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['ThousandsSeparator'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SEPARATORE MIGLIAIA -->\r\n\r\n    <!--#region SIMBOLO VALUTA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo prima del valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Simbolo valuta </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"CurrencySymbol\" matInput [(ngModel)]=\"field.CurrencySymbol\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.CurrencySymbol)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('CurrencySymbol') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['CurrencySymbol'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion SIMBOLO VALUTA -->\r\n\r\n    <!--#region UNITA DI MISURA -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label\r\n        matTooltip=\"Simbolo dopo il valore\"\r\n        matTooltipClass=\"example-tooltip-uppercase\"\r\n        > Unità di misura </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MeasureUnit\" matInput [(ngModel)]=\"field.MeasureUnit\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.MeasureUnit)\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MeasureUnit') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MeasureUnit'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion UNITA DI MISURA -->\r\n\r\n    <!--#region VALORE MINIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore minimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MinValue\" type=\"number\" matInput [(ngModel)]=\"field.MinValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MinValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MinValue') }} -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MinValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MINIMO -->\r\n\r\n    <!--#region VALORE MASSIMO -->\r\n    <div class=\"col-sm-12 col-md-6 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Valore massimo </mat-label>\r\n        <mat-form-field>\r\n            <input formControlName=\"MaxValue\" type=\"number\" matInput [(ngModel)]=\"field.MaxValue\" spellcheck=\"false\"\r\n                autocomplete=\"off\" (keypress)=\"omit_special_char($event)\" (focusout)=\"stringSanitizer(field.MaxValue)\"\r\n                pattern=\"^-?[0-9]+(,[0-9]+|\\.[0-9]+)?$\">\r\n            <mat-error>\r\n                <!-- {{ getFormValidationErrors('MaxValue') }}  -->\r\n                <ul>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['pattern']\">\r\n                        Inserire un valore numerico.\r\n                    </li>\r\n                    <li *ngIf=\"fieldFormGroup.controls['MaxValue'].errors?.['Missing Parenthesis']\">\r\n                        Attenzione, ci sono parentesi non chiuse.\r\n                    </li>\r\n                </ul>\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <!--#endregion VALORE MASSIMO -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI NUMERICI -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI ALLEGATO -->\r\n<ng-template #attachmentFieldFormTemplate>\r\n    <!--#region ALLEGATI MULTIPLI -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiAttach\" formControlName=\"IsMultiAttach\" color=\"primary\">\r\n            Allegati multipli\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion ALLEGATI MULTIPLI -->\r\n\r\n    <!--#region ESTENSIONI ACCETTATE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Estensioni accettate</mat-label>\r\n        <eqp-select [arrayData]=\"AvailableFileExtensions.concat(AvailableImageExtensions)\"\r\n            [(ngModelInput)]=\"field.AllowedExtensions\" [arrayKeyProperty]=\"'key'\" [arrayValueProperty]=\"'value'\"\r\n            [isMultiSelect]=\"true\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'AllowedExtensions'\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion ESTENSIONI ACCETTATE -->\r\n\r\n    <!-- <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row mt-2\">\r\n            <div class=\"col-sm-12 col-md-6\">\r\n                <div class=\"header-title-standard\">\r\n                    Elenco metadata\r\n                </div>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-6 text-right buttonsForm\">\r\n                <button class=\"btn btn-primary save\" mat-raised-button color=\"primary\" type=\"button\"\r\n                    (click)=\"openMetadataDialog()\">\r\n                    <mat-icon>add</mat-icon>\r\n                    <span style=\"margin-left: 10px;\">Aggiungi allegato</span>\r\n                </button>\r\n            </div>\r\n        </div>\r\n        <eqp-table #metadataFieldsTable [createMatCard]=\"false\" [columns]=\"metadataColumns\"\r\n            [data]=\"field.MetadataFields\" [emptyTableMessage]=\"'Nessun metadata inserito'\" [searchText]=\"'Cerca'\">\r\n        </eqp-table>\r\n    </div> -->\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI ALLEGATO -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI LISTA DI VALORI -->\r\n<ng-template #listValueFieldFormTemplate>\r\n    <!--#region SCELTA MULTIPLA -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n            Scelta multipla\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <!--#endregion SCELTA MULTIPLA -->\r\n\r\n    <!--#region TIPO DI PRESENTAZIONE -->\r\n    <div class=\"col-sm-12 col-md-4 mt-2\">\r\n        <mat-label>Tipo di presentazione*</mat-label>\r\n        <eqp-select [enumData]=\"ListPresentationEnum\" [(ngModelInput)]=\"field.PresentationMode\" required\r\n            [showCancelButton]=\"false\" [formGroupInput]=\"fieldFormGroup\" [formControlNameInput]=\"'PresentationMode'\"\r\n            (ngModelInputChange)=\"onPresentationModeChange()\">\r\n        </eqp-select>\r\n    </div>\r\n    <!--#endregion TIPO DI PRESENTAZIONE -->\r\n\r\n\r\n    <!--#region GESTIONE OPZIONI -->\r\n    <div class=\"col-sm-12 mt-2\">\r\n\r\n        <mat-label> area dei valori da inserire </mat-label>\r\n        <mat-form-field>\r\n            <textarea matInput \r\n                placeholder=\"key1|value1;key2|value2\" \r\n                [(ngModel)]=\"field.ValueString\"\r\n                spellcheck=\"false\" \r\n                autocomplete=\"off\"\r\n                >\r\n            </textarea>\r\n        </mat-form-field>\r\n\r\n        <div class=\"row\" *ngIf=\"countValuePairs(field.ValuePairs) > 0\">\r\n            <h4 class=\"key-value-list-section-title\"> </h4>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Label opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.key\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Valore opzione (invio per confermare)</mat-label>\r\n                <mat-form-field>\r\n                    <input matInput [(ngModel)]=\"keyValueObject.value\" (keyup)=\"onMultiSelectInputKeyup($event, null)\"\r\n                        spellcheck=\"false\" autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-4  align-self-center\">\r\n                <span class=\"mr-3\">Opzioni inserite:</span>\r\n                <ul class=\"value-pairs-list\">\r\n                    <li *ngFor=\"let keyValuePair of getDictionaryKeyValue()\">\r\n                        <mat-icon class=\"mr-1\" (click)=\"deleteKeyFromDictionary(keyValuePair.key)\">close\r\n                        </mat-icon>\r\n                        <span><b>Label: </b> {{keyValuePair.key}} - <b>Valore: </b> {{keyValuePair.value}}</span>\r\n                    </li>\r\n                </ul>\r\n            </div>\r\n        </div> \r\n\r\n    </div>    \r\n    <!--#endregion GESTIONE OPZIONI -->\r\n\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI LISTA DI VALORI -->\r\n\r\n\r\n\r\n\r\n<!--#region FORM LISTA IMMAGINI -->\r\n<ng-template #imageFieldSelectorFormTemplate>\r\n\r\n    <div class=\"row\">\r\n        <div class=\"col-3 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-3 col-xs-12 col-middle\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.IsMultiChoiche\" formControlName=\"IsMultiChoiche\" color=\"primary\">\r\n                Scelta multipla\r\n            </mat-slide-toggle>\r\n        </div>        \r\n    </div>\r\n\r\n    <eqp-attachments #imageSelectorAttachments [attachmentsList]=\"field.AttachmentList\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n    [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"true\" [showHeader]=\"false\"\r\n    [allowedTypes]=\"[AttachmentType.FILE]\" (localEditedAttachments)=\"catchButtonImagesChange($event)\"\r\n    [attachmentsColumns]=\"configColumnListImages\">\r\n    </eqp-attachments>\r\n\r\n  \r\n</ng-template>\r\n<!--#endregion FORM LISTA IMMAGINI -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI IMMAGINE -->\r\n<ng-template #imageFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-slide-toggle [(ngModel)]=\"field.EnableDrawing\" formControlName=\"EnableDrawing\" color=\"primary\">\r\n                Immagine disegnabile?\r\n            </mat-slide-toggle>\r\n        </div>   \r\n    </div>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI IMMAGINE -->\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI IMMAGINE CON MARKERS -->\r\n<ng-template #imageWithMarkersFieldFormTemplate>\r\n    <div class=\"row\">\r\n        <div class=\"col-4 col-xs-12\" [formGroup]=\"fieldFormGroup\">\r\n            <mat-label> Altezza in Pixel delle immagini scalate </mat-label>\r\n            <mat-form-field>\r\n                <input formControlName=\"ResizedImagesHeightPx\" matInput [(ngModel)]=\"field.ResizedImagesHeightPx\" required spellcheck=\"false\"\r\n                    autocomplete=\"off\" (change)=\"setResizedImagesHeightPx()\">\r\n                <mat-error>\r\n                    {{ getFormValidationErrors('ResizedImagesHeightPx') }}\r\n                </mat-error>\r\n            </mat-form-field>  \r\n        </div>\r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Etichetta </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonKey\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>        \r\n        <div class=\"col-4 col-xs-12\" *ngIf=\"field.DynAttachment != null\">\r\n            <mat-label> Valore </mat-label>\r\n            <mat-form-field>\r\n                <input matInput [(ngModel)]=\"field.DynAttachment.ButtonValue\" spellcheck=\"false\"\r\n                    autocomplete=\"off\">\r\n            </mat-form-field>  \r\n        </div>                  \r\n    </div>    \r\n\r\n    <div class=\"col-sm-12 col-md-8 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <eqp-attachments [attachmentsList]=\"[field.DynAttachment]\" [showMatCard]=\"false\" [allowOnlyImages]=\"true\"\r\n            [isDisabled]=\"false\" [showInlinePreview]=\"true\" [multipleAttachment]=\"false\" [showHeader]=\"false\"\r\n            [allowedTypes]=\"[AttachmentType.FILE]\"\r\n            (localEditedAttachments)=\"catchButtonImageWithMarkersChange($event)\" (onDeleteAttachment)=\"deleteImage($event)\" #imageAttachment>\r\n        </eqp-attachments>\r\n        <ng-template #readonlyProfileImage>\r\n            <img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{field.DynAttachment.FileDataBase64}}\"\r\n              alt=\"\">\r\n          </ng-template>        \r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI IMMAGINE CON MARKERS -->\r\n\r\n\r\n\r\n\r\n\r\n<!--#region FORM PROPRIETÀ CAMPI LOOKUP -->\r\n<ng-template #lookupFieldFormTemplate>\r\n    <div class=\"col-sm-12 col-md-4 mt-2  align-self-center\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-slide-toggle [(ngModel)]=\"field.UseAsGetOrDiscard\" formControlName=\"UseAsGetOrDiscard\" color=\"primary\"\r\n            matTooltip=\"Se true la lookup viene visualizzata in una modale per lo scegli scarta\">\r\n            Usa per scegli o scarta\r\n        </mat-slide-toggle>\r\n    </div>\r\n    <div class=\"col-sm-12 col-md-4 mt-2\" [formGroup]=\"fieldFormGroup\">\r\n        <mat-label> Nome entità </mat-label>\r\n        <mat-form-field matTooltip=\"Nome dell'entità relazionata\">\r\n            <input formControlName=\"EntitySourceName\" required matInput [(ngModel)]=\"field.EntitySourceName\"\r\n                spellcheck=\"false\" autocomplete=\"off\" (keypress)=\"omit_special_char($event)\"\r\n                (focusout)=\"stringSanitizer(field.EntitySourceName)\">\r\n            <mat-error>\r\n                {{ getFormValidationErrors('EntitySourceName') }}\r\n            </mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n    <div class=\"col-sm-12 mt-2\">\r\n        <div class=\"row\">\r\n            <div class=\"col-md-4\">\r\n                <mat-label> Nomi dei campi (invio per confermare) </mat-label>\r\n                <mat-form-field\r\n                    matTooltip=\"Elenco di campi ordinato che verrà visualizzato nella lookup (premere invio per confermare)\">\r\n                    <input matInput (keyup)=\"onMultiSelectInputKeyup($event, 'FieldNames')\" spellcheck=\"false\"\r\n                        autocomplete=\"off\">\r\n                </mat-form-field>\r\n            </div>\r\n            <div class=\"col-md-8  align-self-center\">\r\n                <span class=\"mr-3\">Nomi selezionati:</span>\r\n                <div class=\"extension-container\" *ngFor=\"let extension of field.FieldNames; let i = index\">\r\n                    <span>{{extension}}</span>\r\n                    <mat-icon class=\"ml-1\" (click)=\"field.FieldNames.splice(i,1)\">close\r\n                    </mat-icon>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</ng-template>\r\n<!--#endregion FORM PROPRIETÀ CAMPI LOOKUP -->\r\n\r\n<!-- DIALOG PER AGGIUNGERE UN METADATA NEI CAMPI DI TIPO ALLEGATO O IMMAGINE -->\r\n<!-- <ng-template #dialogMetadata>\r\n    <eqp-dynamic-module-add-form-field [field]=\"selectedMetadata\" [availableFields]=\"availableFields\"\r\n        [indexField]=\"indexSelectedMetadata\" (saveFieldEvent)=\"onSaveMetadata($event)\" [fieldTypesToExclude]=\"[6,7,10]\">\r\n    </eqp-dynamic-module-add-form-field>\r\n</ng-template> -->\r\n\r\n<ng-template #buttonImagesKeyValueInputColumn let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> {{col.display}} </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\" required spellcheck=\"false\" autocomplete=\"off\">\r\n    </mat-form-field>\r\n</ng-template>\r\n<!--DIALOG PER SEMPLIFICARE LA SCRITTURA DEL CAMPO FORMULA-->\r\n<ng-template #dialogFormula>\r\n    <eqp-dynamic-module-add-formula-component>\r\n    </eqp-dynamic-module-add-formula-component>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesImageTemplate let-row=\"row\" let-col=\"col\">\r\n    <img src=\"data:image/jpeg;base64, {{row[col.key]}}\" class=\"GenericListImagesImageTemplate\">\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesKeyTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Chiave </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<ng-template #GenericListImagesValueTemplate let-row=\"row\" let-col=\"col\">\r\n    <mat-form-field>\r\n        <mat-label> Valore </mat-label>\r\n        <input matInput [(ngModel)]=\"row[col.key]\">\r\n    </mat-form-field>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER QUERY EDITOR -->\r\n<ng-template #dialogQE>\r\n    <ng-template [appDynamicLoader] [data]=\"QueryEditorComponent\" (out)=\"onExternalComponentOut($event);\">\r\n    </ng-template>\r\n</ng-template>\r\n  "]}