@eqproject/eqp-dynamic-module 2.8.7 → 3.0.0

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

@@ -0,0 +1,837 @@
+import { Component, EventEmitter, Input, Output, ViewChildren } from '@angular/core';
+import { AnswerStyle, DataGetter, DataGetterTypeEnum, FieldInvisibilityEnum, FieldTypeEnum } from '../../../../models/baseField.model';
+import { FormScalarTypeEnum } from '../../../../models/form.model';
+import { DynRecord, Record } from '../../../../models/record.model';
+import { UtilityHelperService } from '../../../../services/utilityHelper.services';
+import { ParamTypeEnum } from './../../../../models/endPointConfiguration.model';
+import { GlobalService } from '../../../../services/global.service';
+import { LogicOperator } from '../../../../models/logicOperator.model';
+import { FireTrigger, TriggerPropertyTypeEnum } from '../../../../models/trigger.model';
+import { DateTimeTypeEnum } from '../../../../models/fields/dateField.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../services/utilityHelper.services";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/stepper";
+import * as i5 from "@angular/material/tabs";
+import * as i6 from "@angular/material/expansion";
+import * as i7 from "@angular/forms";
+import * as i8 from "../../dynamic-module-field-fix/dynamic-module-field.component";
+export class AddFormRecordComponent {
+    cdr;
+    utilityService;
+    datepipe;
+    configurations;
+    endPointConfiguration;
+    userID;
+    orgaID = null; // preview
+    formID = null; // preview
+    form = null; // preview config
+    record = null; // edit
+    onlyView = false;
+    isDuplicate = false;
+    inConfig = false;
+    showAllFields = false;
+    QueryEditorComponent; // L'intero componente query Editor
+    saveRecordEvent = new EventEmitter();
+    afterSaveRecordEvent = new EventEmitter();
+    out = new EventEmitter();
+    fireTrigger = new EventEmitter();
+    showTitle = true;
+    showSaveButton = true;
+    showBackButton = true;
+    loader = false;
+    isSaving = false;
+    formloaded = false;
+    formForm;
+    fieldGroups = {};
+    FormScalarTypeEnum = FormScalarTypeEnum;
+    FieldTypeEnum = FieldTypeEnum;
+    fieldTemplate;
+    constructor(cdr, utilityService, datepipe) {
+        this.cdr = cdr;
+        this.utilityService = utilityService;
+        this.datepipe = datepipe;
+    }
+    ngOnInit() {
+        if (this.form != null && this.orgaID != null) {
+            this.form.OrgaID = this.orgaID;
+        }
+        // add può funzionare anche come modifica e come preview
+        // in add abbiamo in input l'ID del Form
+        // in modifica abbiamo in input l'ID del Record
+        // in preview abbiamo in input il Form(caso configurator) o l'ID del modulo on onlyView impostato a true
+        this.showTitle = this.configurations.showTitle;
+        this.showSaveButton = this.configurations.showSaveButton;
+        this.showBackButton = this.configurations.showBackButton;
+        GlobalService.debugLog("AddFormRecord");
+        if (this.record == null) {
+            this.showTitle = true;
+            GlobalService.debugLog("AddFormRecord - new");
+            this.previewOrNewResponseRecord();
+        }
+        else {
+            this.showTitle = false;
+            GlobalService.debugLog("AddFormRecord - edit", this.record);
+            this.editResponseRecord();
+        }
+        // l'inizializzazione termina con il recupero del record o con l'inizializzazione del form vuoto
+        this.cdr.detectChanges();
+        GlobalService.debugLog('oninit - DynaForm', this.form);
+    }
+    onStepChange(event) {
+        //console.log("IGOR_event.selectedIndex", event.selectedIndex);
+        if (GlobalService.isSpeechToTextStarted) {
+            GlobalService.speechDirective.SpeechToTextToggler();
+        }
+    }
+    //#region onRecordChange
+    /**
+     * Metodo invocato al cambio del valore di ogni proprietà dell'oggetto record.
+     * Serve ad aggiornare il valore di tutti i campi che hanno una formula.
+     */
+    onRecordChange() {
+        console.log("FOrmForm", this.formForm);
+        if (this.fieldTemplate && this.fieldTemplate.length > 0) {
+            this.fieldTemplate.forEach((f) => f.updateField());
+        }
+    }
+    //#endregion onRecordChange
+    //#region previewOrNewResponseRecord
+    previewOrNewResponseRecord() {
+        this.record = new Record();
+        // aggiugni nuovo
+        if (this.form != null) {
+            // preview per il configurator
+            this.fieldsConfig();
+        }
+        else if (this.formID != null) {
+            // preview per admin
+            this.getFormByID(); // dentro chiama fieldsConfig
+        }
+    }
+    //#endregion previewOrNewResponseRecord
+    //#region editResponseRecord
+    editResponseRecord() {
+        // modiiltà modifica
+        if (typeof this.record === "string") {
+            // allora è un ID
+            this.getRecordByID();
+        }
+        else {
+            // il record viene passato come tale
+            // (<Record>this.record).EntID = "3";
+            // (<Record>this.record).Version;
+            this.getFormByIDandVersion(true);
+        }
+    }
+    //#endregion editResponseRecord
+    //#region saveOrExitForm
+    /**
+     * Metodo per salvare i dati inseriti dall'utente una volta conclusa la compilazione della form.
+     */
+    saveOrExitForm(exit) {
+        GlobalService.debugLog('add-form-record saveRecordEvent');
+        if (exit) {
+            // this.saveRecordEvent.emit(null);
+            this.onSaveRecord(null);
+        }
+        else {
+            // this.saveRecordEvent.emit(this.record);
+            this.isSaving = true;
+            this.onSaveRecord(this.record);
+        }
+    }
+    //#endregion saveOrExitForm
+    //#region onSaveRecord
+    /**
+     * Metodo per salvare il record aggiunto o modificato.
+     * Se è stato configurato un endPoint per il salvataggio viene effettuata una chiamata al server passando l'oggeto da salvare
+     * nel body della chiamata, altrimenti scatena l'evento "saveRecord".
+     * @param event Oggetto di tipo Record da salvare.
+     */
+    async onSaveRecord(event) {
+        GlobalService.debugLog('onSaveRecord - event', event);
+        GlobalService.debugLog('onSaveRecord - form', this.form);
+        if (event != null &&
+            this.endPointConfiguration != null &&
+            this.endPointConfiguration.Records.SaveEndPoint) {
+            var dynRec = new DynRecord();
+            dynRec.ID = event.ID ?? null;
+            dynRec.EntID = this.form.ID;
+            dynRec.Version = this.form.Version;
+            dynRec.userID = this.userID;
+            dynRec.Values = event ?? null;
+            dynRec.HTMLreadableValues = await this.createHTMLreadableValues(event);
+            if (event.FK_InsertUser == null) {
+                // Nuovo Record
+                dynRec.FK_InsertUser = this.userID;
+                dynRec.InsertDate = new Date();
+                dynRec.FK_UpdateUser = this.userID;
+                dynRec.UpdateDate = new Date();
+            }
+            else {
+                // Modifica del Record
+                dynRec.FK_InsertUser = event.FK_InsertUser;
+                dynRec.InsertDate = event.InsertDate;
+                dynRec.FK_UpdateUser = this.userID;
+                dynRec.UpdateDate = new Date();
+            }
+            var additionalParams = this.configurations.additionalParams == null ? event.AdditionalParams : this.configurations.additionalParams;
+            dynRec.AdditionalParams = JSON.stringify(additionalParams);
+            // var additionalInfo = this.additionalInfo == null ? event.AdditionalInfo : this.additionalInfo;
+            var additionalInfo = event.AdditionalInfo == null ? this.configurations.additionalInfo : event.AdditionalInfo;
+            dynRec.AdditionalInfo = JSON.stringify(additionalInfo);
+            var dynamicModuleParams = [
+                {
+                    ParamName: "Record",
+                    ParamValue: dynRec,
+                    ParamType: ParamTypeEnum["In Body"],
+                },
+            ];
+            GlobalService.debugLog('onSaveRecord - dynamicModuleParams', dynamicModuleParams);
+            this.utilityService.RunEndPointCall(this.endPointConfiguration.Records.SaveEndPoint, dynamicModuleParams, (res) => {
+                dynRec.ID = res.toString();
+                event.ID = res.toString();
+                this.checkTriggers(event);
+                this.afterSaveRecordEvent.emit(dynRec);
+                this.isSaving = false;
+            });
+        }
+        else {
+            this.saveRecordEvent.emit(dynRec);
+        }
+    }
+    //#endregion onSaveRecord
+    //#region getFormByID
+    getFormByID(id = this.formID) {
+        const dynamicModuleParams = new Array();
+        dynamicModuleParams.push({
+            ParamName: "id",
+            ParamValue: id,
+            ParamType: ParamTypeEnum["Query param"],
+        });
+        this.utilityService.RunEndPointCall(this.endPointConfiguration.Forms.GetByIDEndPoint, dynamicModuleParams, (res) => {
+            this.form = res;
+            this.form.OrgaID = this.orgaID;
+            if (this.form.ObjectTriggers != null && this.form.ObjectTriggers != "") {
+                this.form.Triggers = JSON.parse(this.form.ObjectTriggers);
+            }
+            else {
+                this.form.Triggers = new Array();
+            }
+            this.setDataGetter(this.form);
+            GlobalService.debugLog('getFormByID - DynaForm', this.form);
+            this.fieldsConfig();
+        }, (err) => { });
+    }
+    //#endregion getFormByID
+    //#region getRecordByID
+    // ci entro solo se è stato passato il parametro "record" come stringa
+    getRecordByID() {
+        // preparo i dati del record
+        var dynamicRecordParams = [
+            {
+                ParamName: "id",
+                ParamValue: this.record,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+        ];
+        this.utilityService.RunEndPointCall(this.endPointConfiguration.Records.GetByIDEndPoint, dynamicRecordParams, (res) => {
+            this.record = new Record();
+            this.record = JSON.parse(res.SerializedValues);
+            this.record.ID = this.isDuplicate ? "" : res.ID;
+            this.record.EntID = res.EntID;
+            this.record.userID = res.userID;
+            this.record.Version = res.Version;
+            this.record.Values = JSON.parse(res.SerializedValues);
+            this.record.FK_InsertUser = res.FK_InsertUser;
+            this.record.FK_UpdateUser = res.FK_UpdateUser;
+            this.record.InsertDate = res.InsertDate;
+            this.record.UpdateDate = res.UpdateDate;
+            // this.viewMode = DynamicModuleViewModeEnum.COMPILE;
+            // this.loader = true;
+            this.getFormByIDandVersion();
+        });
+    }
+    //#endregion getRecordByID
+    //#region getFormByIDandVersion
+    getFormByIDandVersion(getAttachments = false) {
+        // preparo la versione corretta del form
+        var dynamicModuleParams = [
+            {
+                ParamName: "EntID",
+                ParamValue: this.record.EntID,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+            {
+                ParamName: "Version",
+                ParamValue: this.record.Version,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+        ];
+        GlobalService.debugLog("getFormByIDandVersion - this record", this.record);
+        this.utilityService.RunEndPointCall(this.endPointConfiguration.Forms.GetByIDAndVersionEndPoint, dynamicModuleParams, (res) => {
+            GlobalService.debugLog("AFTER getFormByIDandVersion - this.form", res);
+            this.form = res;
+            this.form.OrgaID = this.orgaID;
+            if (this.form.ObjectTriggers != null && this.form.ObjectTriggers != "") {
+                this.form.Triggers = JSON.parse(this.form.ObjectTriggers);
+            }
+            else {
+                this.form.Triggers = new Array();
+            }
+            this.setDataGetter(this.form);
+            this.createRecordProperties();
+            this.reorderFormFields();
+            this.createFormGroup();
+            if (this.form.FormScalarType != FormScalarTypeEnum.Semplice) {
+                this.createFieldGroups();
+            }
+            if (!getAttachments) {
+                this.loader = true;
+                this.formloaded = true;
+            }
+            else {
+                this.getAllRecordAttachments(this.record.ID);
+            }
+        });
+    }
+    //#endregion getFormByIDandVersion
+    //#region getAllRecordAttachments
+    getAllRecordAttachments(recordID) {
+        var dynamicModuleParams = [
+            {
+                ParamName: "answerId",
+                ParamValue: recordID,
+                ParamType: ParamTypeEnum["Query param"],
+            }
+        ];
+        this.utilityService.RunEndPointCall(this.endPointConfiguration.Records.GetAllAttachmentsEndPoint, dynamicModuleParams, (res) => {
+            GlobalService.debugLog("GetAllAttachmentsEndPoint()", res);
+            this.form.Fields.forEach((field) => {
+                if (field.FieldType == FieldTypeEnum.Immagine || field.FieldType == FieldTypeEnum['Immagine con markers']) {
+                    var attachId = this.record[field.Name];
+                    this.record[field.Name] = res.find(x => x.ID == attachId);
+                }
+            });
+            this.loader = true;
+            this.formloaded = true;
+        });
+    }
+    //#endregion getAllRecordAttachments
+    //#region fieldsConfig
+    fieldsConfig() {
+        this.createRecordProperties();
+        this.reorderFormFields();
+        this.createFormGroup();
+        if (this.form.FormScalarType != FormScalarTypeEnum.Semplice) {
+            this.createFieldGroups();
+        }
+        GlobalService.debugLog("fieldsConfig - form", this.form);
+        this.loader = true;
+        this.formloaded = true;
+    }
+    //#endregion fieldsConfig
+    //#region createRecordProperties
+    /**
+     * Metodo per creare nell'oggetto Record le proprietà mancanti rispetto ai campi che compongono la form.
+     */
+    createRecordProperties() {
+        const recordProperties = Object.keys(this.record);
+        this.form.Fields.forEach((field) => {
+            if (!recordProperties.find((p) => p === field.Name)) {
+                this.record[field.Name] = null;
+            }
+        });
+        if (this.form.InnerForms && this.form.InnerForms.length > 0) {
+            this.form.InnerForms.forEach((form) => {
+                const arrayName = form.Name.split(" ").join("_");
+                if (!recordProperties.find((p) => p === arrayName)) {
+                    this.record[arrayName] = [];
+                }
+            });
+        }
+        GlobalService.debugLog("createRecordProperties - form", this.form);
+        GlobalService.debugLog("createRecordProperties - record", this.record);
+    }
+    //#endregion createRecordProperties
+    /**
+     * Metodo per riordinare i campi che compongono la form.
+     */
+    reorderFormFields() {
+        if (this.form.Fields && this.form.Fields.length > 0) {
+            this.form.Fields.sort((a, b) => a.OrdinalPosition > b.OrdinalPosition ? 1 : b.OrdinalPosition > a.OrdinalPosition ? -1 : 0);
+        }
+        GlobalService.debugLog("reorderFormFields - form", this.form);
+    }
+    /**
+     * Metodo per creare il FormGroup che rappresenta la form.
+     */
+    createFormGroup() {
+        this.formForm = this.utilityService.CreateFormFormGroup(this.form.Fields, this.record, this.onlyView);
+        GlobalService.debugLog("createFormGroup - form", this.form);
+    }
+    /**
+     * Metodo per creare i gruppi in cui raggruppare i campi della form in base
+     * a come è stata configurata dall'utente.
+     */
+    createFieldGroups() {
+        this.form.FormFieldsGroups.sort((a, b) => a.OrdinalPosition > b.OrdinalPosition ? 1 : b.OrdinalPosition > a.OrdinalPosition ? -1 : 0)
+            .map((g) => g.Name)
+            .forEach((groupName) => {
+            this.fieldGroups[groupName] = this.form.Fields.filter((f) => f.FieldGroup == groupName);
+        });
+        GlobalService.debugLog("createFieldGroups - form", this.form);
+    }
+    //#region createHTMLreadableValues
+    /**
+     * Metodo per creare il FormGroup che rappresenta la form.
+     */
+    async createHTMLreadableValues(record) {
+        GlobalService.debugLog("createHTMLreadableValues - record", record);
+        GlobalService.debugLog("createHTMLreadableValues - form", this.form);
+        var formnames = new Array();
+        this.form.Fields.forEach((field) => { formnames.push(field.Name); });
+        GlobalService.debugLog("createHTMLreadableValues - form fields names", formnames);
+        // alert("continue for values?")
+        let outputValuesArray = await this.getResponseValues(record, this.form);
+        GlobalService.debugLog("createHTMLreadableValues - outputValuesArray", outputValuesArray);
+        // alert("continue for templates?")
+        let template = this.getResponseTemplate(record, this.form); // oggetto nel quale viene costruito il template o che prende il valore da un template esterno
+        GlobalService.debugLog("createHTMLreadableValues - template", template);
+        // alert("continue for output?")
+        const regex = /##([\w]+)##/g;
+        const output = this.replaceTemplatePlaceholdersWithValues(template, outputValuesArray, regex);
+        GlobalService.debugLog("createHTMLreadableValues - output", output);
+        // alert("continue for ending?")
+        return output; // oggetto che conterrà l'output elaborato    
+    }
+    //#endregion createHTMLreadableValues
+    //#region getResponseValues
+    async getResponseValues(record, form) {
+        let outputValuesArray = []; // array con i valori delle risposte
+        //(<DynRecord>this.record).Values è la lista di oggetti {fieldName: valore}
+        // GlobalService.debugLog("(record).Values", record);
+        form.Fields.forEach(async (field) => {
+            try {
+                //GlobalService.debugLog("getResponseValues field", field);
+                // let foundObject = record.find(
+                //   (obj) => obj === field.Name
+                // );
+                let foundObject = record[field.Name];
+                // fare un eval per popolare i valuePairs se è presente una formula
+                // prendere la label corretta
+                ////////////////////////////////////////////////////////////////////////////////
+                // PREPARO IL VALUEPAIRS
+                switch (field.FieldType) {
+                    case FieldTypeEnum["Elenco generico"]:
+                        {
+                            if (field.Formula != null && field.Formula) {
+                                // aggiungo a valuepairs i valori calcolati
+                                // (<ListValueField>foundObject).ValuePairs = (<ListValueField>foundObject).ValuePairs ? (<ListValueField>foundObject).ValuePairs : {};
+                                var temp = UtilityHelperService.EvaluateFieldFormula(field.Formula, record, null);
+                                for (let key2 in temp) {
+                                    if (UtilityHelperService.isNumeric(temp[key2])) {
+                                        field.ValuePairs[Number(key2)] = temp[key2];
+                                    }
+                                    else {
+                                        field.ValuePairs[key2] = temp[key2];
+                                    }
+                                }
+                                outputValuesArray[field.Name] = field.ValuePairs[record[field.Name]];
+                            }
+                            else if (field.ValuePairs != null && field.ValuePairs.length > 0) {
+                                // va bene così
+                            }
+                            else if (field.ValueString != null && field.ValueString != "") {
+                                // va presa la strigna e rimappata nel diario
+                                field.ValuePairs = GlobalService.stringToValuePairs(field.ValueString);
+                            }
+                            let inverted = {};
+                            //GlobalService.debugLog("(<ListValueField>foundObject).ValuePairs", (<ListValueField>field).ValuePairs);
+                            // ValuePairs: {Si: 'Si', No: 'No'}
+                            for (let key in field.ValuePairs) {
+                                inverted[field.ValuePairs[key]] = key;
+                            }
+                            field.ValuePairs = inverted;
+                            if (record[field.Name] != null && field.IsMultiChoiche) {
+                                // caso MULTISCELTA
+                                let value = "";
+                                record[field.Name].forEach((element, i) => {
+                                    value += field.ValuePairs[element];
+                                    value += i == record[field.Name].length - 1 ? "" : ", ";
+                                });
+                                outputValuesArray[field.Name] = value;
+                            }
+                            else {
+                                outputValuesArray[field.Name] = field.ValuePairs[record[field.Name]];
+                            }
+                            //console.log("outputValuesArray", outputValuesArray)
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum["Campo numerico"]:
+                        {
+                            if (field.IsInteger) {
+                                if (field.DecimalSeparator == null) {
+                                    outputValuesArray[field.Name] = record[field.Name];
+                                }
+                                else {
+                                    outputValuesArray[field.Name] = record[field.Name];
+                                }
+                            }
+                            else {
+                                outputValuesArray[field.Name] = record[field.Name];
+                            }
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum['Immagine']:
+                        {
+                            console.log("immagine ", field.Name, record[field.Name]);
+                            // Recupero il BASE64 dell'immagine Resized via promise client
+                            var resizedBase64 = await this.resizeBase64Image("data:image/" + record[field.Name].FileExtension + ";base64," + record[field.Name].FileDataBase64);
+                            // Aggiungo l'HTML con il nuovo BASE64
+                            outputValuesArray[field.Name] = "<img src='" + resizedBase64 + "' style='height: " + record[field.Name].ResizedImageHeightPx + "px'>";
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum['Allegato']:
+                        {
+                            console.log("Allegato ", field.Name, record[field.Name], record);
+                            if (record[field.Name] != null) {
+                                let resizedBase64;
+                                if (record[field.Name][0].IsImage) {
+                                    // Recupero il BASE64 dell'immagine Resized via promise client
+                                    resizedBase64 = await this.resizeBase64Image("data:image/" + record[field.Name][0].FileExtension + ";base64," + record[field.Name][0].FileDataBase64);
+                                    console.log("Allegato resizedBase64", resizedBase64);
+                                    // Aggiungo l'HTML con il nuovo BASE64
+                                    outputValuesArray[field.Name] = '<img class="image-preview" src="' + resizedBase64 + '" style="height: ' + record[field.Name][0].ResizedImageHeightPx + 'px">';
+                                }
+                                else if (record[field.Name][0].FileContentType == "application/pdf") {
+                                    outputValuesArray[field.Name] = '<iframe src="data:application/pdf;base64,' + record[field.Name][0].FileDataBase64 + '"style="min-height: 300px; height: 100%;"></iframe>';
+                                }
+                                else {
+                                    outputValuesArray[field.Name] = '<iframe src="data:"' + record[field.Name][0].FileExtension + '";base64,' + record[field.Name][0].FileDataBase64 + '"style="min-height: 300px; height: 100%;"></iframe>';
+                                }
+                                // Aggiungo l'HTML con il nuovo BASE64
+                                // outputValuesArray[field.Name] = "<img src='" + resizedBase64 + "' style='height: " + record[field.Name][0].ResizedImageHeightPx + "px'>";
+                                console.log("Allegato outputValuesArray", outputValuesArray[field.Name]);
+                            }
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum['Immagine con markers']:
+                        {
+                            // Recupero il BASE64 dell'immagine Resized via promise client
+                            var resizedBase64 = await this.resizeBase64Image("data:image/" + record[field.Name].FileExtension + ";base64," + record[field.Name].FileDataBase64);
+                            // Aggiungo l'HTML con il nuovo BASE64
+                            outputValuesArray[field.Name] = "<img src='" + resizedBase64 + "' style='height: " + record[field.Name].ResizedImageHeightPx + "px'>";
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum['Elenco immagini']:
+                        {
+                            outputValuesArray[field.Name] = "";
+                            if (record[field.Name] != null && field.IsMultiChoiche) {
+                                record[field.Name].forEach((imageobj) => {
+                                    var attachmentInForm = field.AttachmentList.find(x => x.ID == imageobj);
+                                    if (attachmentInForm != null) {
+                                        outputValuesArray[field.Name] += attachmentInForm.ButtonKey + ", ";
+                                    }
+                                });
+                                var parts = outputValuesArray[field.Name].split(", ");
+                                outputValuesArray[field.Name] = parts.slice(0, parts.length - 1).join(", ");
+                            }
+                            else {
+                                var attachmentInForm = field.AttachmentList.find(x => x.ID == record[field.Name]);
+                                if (attachmentInForm != null) {
+                                    outputValuesArray[field.Name] = attachmentInForm.ButtonKey;
+                                }
+                            }
+                            break;
+                        }
+                        ;
+                    case FieldTypeEnum['Data e/o ora']: {
+                        console.log("Data e/o ora", field);
+                        if (field.DateFormat != null) {
+                            let fixDateFormat = field.DateFormat.replace("DD", "dd");
+                            outputValuesArray[field.Name] = this.datepipe.transform(record[field.Name], fixDateFormat);
+                        }
+                        else {
+                            if (field.IsOnlyDate == DateTimeTypeEnum['Solo data']) {
+                                outputValuesArray[field.Name] = this.datepipe.transform(record[field.Name], "dd/MM/yyyy");
+                            }
+                            else if (field.IsOnlyDate == DateTimeTypeEnum['Data e ora']) {
+                                outputValuesArray[field.Name] = this.datepipe.transform(record[field.Name], "dd/MM/yyyy HH:mm");
+                            }
+                            else if (field.IsOnlyDate == DateTimeTypeEnum['Solo orario']) {
+                                outputValuesArray[field.Name] = this.datepipe.transform(record[field.Name], "HH:mm");
+                            }
+                        }
+                        break;
+                    }
+                    default: {
+                        outputValuesArray[field.Name] = record[field.Name];
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+        // Funziona, ma non è affidabile al 100%
+        await this.delay(3000);
+        GlobalService.debugLog("outputValuesArray 1", outputValuesArray);
+        // cancello i valori indefiniti o nulli
+        for (const chiave in outputValuesArray) {
+            if (outputValuesArray[chiave] == undefined || outputValuesArray[chiave] == null)
+                outputValuesArray[chiave] = '';
+        }
+        return outputValuesArray;
+    }
+    //#endregion getResponseValues
+    //#region getResponseTemplate
+    getResponseTemplate(record, form) {
+        let template = '<div class="row">';
+        // PREPARO O PRENDO LA STRUTTURA DA STAMPARE
+        form.Fields.forEach((baseField) => {
+            GlobalService.debugLog('getResposneTemplate - pre - field', baseField);
+            if (baseField.AnswerStyle == null || baseField.AnswerStyle == undefined) {
+                baseField.AnswerStyle = new AnswerStyle();
+                baseField.AnswerStyle.ColSpanSizes = baseField.ColSpanSizes;
+                baseField.AnswerStyle.FieldstyleCSS = baseField.FieldstyleCSS;
+                baseField.AnswerStyle.LabelstyleCSS = baseField.LabelstyleCSS;
+                if (baseField.VisibleIf) {
+                    baseField.AnswerStyle.InListView = UtilityHelperService.EvaluateFieldFormula(baseField.VisibleIf, record, null);
+                }
+                else {
+                    baseField.AnswerStyle.InListView = baseField.InListView;
+                    baseField.AnswerStyle.VisibleIf = baseField.VisibleIf;
+                }
+            }
+            if (baseField.AnswerStyle.VisibleIf) {
+                const visibility = UtilityHelperService.EvaluateFieldFormula(baseField.AnswerStyle.VisibleIf, record, null);
+                GlobalService.debugLog("EvaluateFieldFormula - visibility", visibility);
+                baseField.AnswerStyle.InListView = (visibility == true) ? true : false;
+            }
+            if (baseField.AnswerStyle.InListView) {
+                template += '<div class="' + this.utilityService.getFieldAnswerStyleClass(baseField) + ' d-flex flex-column dynaform-answer-field"> ' +
+                    ' <span class="dynaform-question" style="' + baseField.AnswerStyle.LabelstyleCSS + '">' + baseField.Description + ':</span>' +
+                    ' <span class="dynaform-response" style="' + baseField.AnswerStyle.FieldstyleCSS + '"> ##' + baseField.Name + '##</span>' +
+                    '</div> \n ';
+            }
+            else if (!baseField.AnswerStyle.InListView && baseField.AnswerStyle.Invisibility == FieldInvisibilityEnum['NASCOSTO CON AREA VISIBILE']) {
+                template += '<div class="' + this.utilityService.getFieldAnswerStyleClass(baseField) + ' d-flex flex-column dynaform-answer-field"> ' +
+                    '</div> \n ';
+            }
+            GlobalService.debugLog('getResposneTemplate - post - field', baseField);
+        });
+        // (attualmente non esiste il concetto di tempate di output)
+        template += '</div>';
+        return template;
+    }
+    //#endregion getResponseTemplate
+    replaceTemplatePlaceholdersWithValues(template, outputValuesArray, regex) {
+        return template.replace(regex, (match, group) => {
+            return outputValuesArray[group];
+        });
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async resizeBase64Image(base64Image) {
+        return new Promise((resolve, reject) => {
+            const imagetype = /data:image\/([\w]+);/;
+            const match = base64Image.match(imagetype);
+            const img = new Image();
+            img.src = base64Image;
+            img.onload = function () {
+                const canvas = document.createElement("canvas");
+                const ctx = canvas.getContext('2d');
+                const width = img.width;
+                const height = img.height;
+                const aspectRatio = width / height;
+                const newHeight = 128;
+                const newWidth = newHeight * aspectRatio;
+                canvas.width = newWidth;
+                canvas.height = newHeight;
+                ctx.drawImage(img, 0, 0, newWidth, newHeight);
+                let quality = 0.8;
+                let dataURL = canvas.toDataURL('image/' + match[1], quality);
+                resolve(dataURL);
+            };
+        });
+    }
+    setDataGetter(form) {
+        form.Fields.forEach((field) => {
+            // Trasformo il Base64String del Datagetter nel Datagetter vero e proprio
+            if (field.DataGetterValueBase64String != null) {
+                field.DataGetter = JSON.parse(atob(field.DataGetterValueBase64String));
+                field.DataGetter.DataGetterType = field.DataGetter.DataGetterType == null ? DataGetterTypeEnum.Manuale : field.DataGetter.DataGetterType;
+            }
+            else {
+                field.DataGetter = new DataGetter();
+            }
+            field.DataGetterValueBase64String = null;
+        });
+    }
+    //#region checkTriggers
+    // Controlla e spara il trigger se necessario
+    checkTriggers(record) {
+        var fireTrigger = true;
+        GlobalService.debugLog("checkTriggers - inside checkTriggers()", this.form.Triggers);
+        if (this.form.Triggers != null) {
+            GlobalService.debugLog("checkTriggers - have triggers in form");
+            this.form.Triggers.forEach((trigger) => {
+                fireTrigger = true;
+                trigger.conditions.forEach((condition) => {
+                    if (!fireTrigger) {
+                        return;
+                    }
+                    var logicOperator = condition.logicoperator;
+                    var conditionKey = Object.keys(condition.record)[0];
+                    var conditionValue = condition.record[conditionKey];
+                    var recordValue = record[conditionKey];
+                    if (logicOperator == LogicOperator['='] && conditionValue != recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['!='] && conditionValue == recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['<'] && conditionValue <= recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['<='] && conditionValue < recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['>'] && conditionValue >= recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['>='] && conditionValue > recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['LIKE'] && recordValue.indexOf(conditionValue) == -1) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['NOT LIKE'] && recordValue.indexOf(conditionValue) != -1) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator.Si && !recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator.No && recordValue) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['CONTIENE ALMENO UNO'] && !conditionValue.some(c => recordValue.includes(c))) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                    if (logicOperator == LogicOperator['CONTIENE TUTTI'] && !conditionValue.every(c => recordValue.includes(c))) {
+                        fireTrigger = false;
+                        this.logTrigger(trigger, condition, record);
+                        return;
+                    }
+                });
+                GlobalService.debugLog("checkTriggers - fireTrigger? ", fireTrigger);
+                if (fireTrigger) {
+                    // Il trigger va sparato. Valuto le funzioni interne
+                    var formulas = JSON.parse(JSON.stringify(trigger.formulas));
+                    GlobalService.debugLog("checkTriggers - evaluate formulas ", formulas);
+                    if (formulas != null && Object.keys(formulas).length > 0) {
+                        Object.keys(formulas).forEach((key) => {
+                            var formula = formulas[key].value;
+                            GlobalService.debugLog("checkTriggers - formulas[key] ", formulas[key]);
+                            var temp;
+                            if (formulas[key].type == TriggerPropertyTypeEnum.DMMODULE) {
+                                temp = formula;
+                            }
+                            else {
+                                temp = UtilityHelperService.EvaluateFieldFormula(formula, record, null);
+                            }
+                            formulas[key] = temp;
+                        });
+                    }
+                    // Sparo il trigger all'esterno
+                    var triggerToFire = new FireTrigger();
+                    triggerToFire.form = this.form; // Il form che ha provocato il trigger
+                    triggerToFire.record = record; // Il record che ha provocato il trigger
+                    triggerToFire.trigger = trigger; // Il trigger
+                    triggerToFire.formulas = formulas; // Le formule inviate in input al modulo dinamico, valutate nel contesto del trigger e del record
+                    triggerToFire.userPatient = this.userID; // UserID
+                    console.log("checkTriggers - Trigger Fired ", triggerToFire.trigger.description, triggerToFire);
+                    this.fireTrigger.emit(triggerToFire);
+                }
+            });
+        }
+    }
+    logTrigger(trigger, condition, record) {
+        GlobalService.debugLog("checkTriggers - Condition that invalidated the trigger TRIGGER", trigger);
+        GlobalService.debugLog("checkTriggers - Condition that invalidated the trigger CONDITION", condition);
+        GlobalService.debugLog("checkTriggers - Condition that invalidated the trigger RECORD", record);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AddFormRecordComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.UtilityHelperService }, { token: i2.DatePipe }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AddFormRecordComponent, selector: "add-form-record", inputs: { configurations: "configurations", endPointConfiguration: "endPointConfiguration", userID: "userID", orgaID: "orgaID", formID: "formID", form: "form", record: "record", onlyView: "onlyView", isDuplicate: "isDuplicate", inConfig: "inConfig", showAllFields: "showAllFields", QueryEditorComponent: "QueryEditorComponent" }, outputs: { saveRecordEvent: "saveRecordEvent", afterSaveRecordEvent: "afterSaveRecordEvent", out: "out", fireTrigger: "fireTrigger" }, viewQueries: [{ propertyName: "fieldTemplate", predicate: ["fieldTemplate"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"loader\">\r\n\r\n    <div class=\"row eqp-dynamic-module-title add-form-record-header\" *ngIf=\"showTitle\">\r\n        <div class=\"col-md-12\">\r\n            <span>{{form.Name}}</span>\r\n        </div>\r\n    </div>\r\n\r\n    <form [formGroup]=\"formForm\" class=\"add-form-record-form\">\r\n\r\n        <!-- VISUALIZZAZIONE SEMPLICE -->\r\n        <ng-container *ngIf=\"form.FormScalarType == FormScalarTypeEnum.Semplice\" [ngTemplateOutlet]=\"fieldTemplates\"\r\n            [ngTemplateOutletContext]=\"{ fields: form.Fields }\" class=\"add-form-record-semplice\">\r\n        </ng-container>\r\n\r\n        <!-- VISUALIZZAZIONE A STEPPER -->\r\n        <mat-horizontal-stepper linear *ngIf=\"form.FormScalarType == FormScalarTypeEnum['A step']\"\r\n            class=\"add-form-record-stepper\" (selectionChange)=\"onStepChange($event)\">\r\n            <mat-step *ngFor=\"let group of form.FormFieldsGroups; let i = index; let first = first; let last = last\">\r\n              \r\n                <ng-template matStepLabel>\r\n                    {{group.Name}}\r\n                </ng-template>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n\r\n                <div class=\"mt-2 d-flex justify-content-end add-form-record-buttons\">\r\n                    <button *ngIf=\"!first\" class=\"mr-2 previous\" mat-raised-button matStepperPrevious>\r\n                        Precedente\r\n                    </button>\r\n                    <button *ngIf=\"!last\" class=\"button-next\" color=\"primary\" mat-raised-button matStepperNext>\r\n                        Successivo\r\n                    </button>\r\n                    <button *ngIf=\"last && showSaveButton\" (click)=\"saveOrExitForm(false)\" class=\"button-next\" [disabled]=\"formForm.invalid || formForm.disabled\"\r\n                        color=\"primary\" mat-raised-button>\r\n                        Salva\r\n                    </button>\r\n                </div>\r\n\r\n            </mat-step>\r\n        </mat-horizontal-stepper>\r\n\r\n        <!-- VISUALIZZAZIONE A TAB -->\r\n        <mat-tab-group *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In tab']\" class=\"add-form-record-tab\">\r\n            <mat-tab *ngFor=\"let group of form.FormFieldsGroups\" [label]=\"group.Name\">                \r\n                <div class=\"mt-3\">                    \r\n                    <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                        [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                    </ng-container>\r\n                </div>\r\n            </mat-tab>\r\n        </mat-tab-group>\r\n\r\n        <!-- VISUALIZZAZIONE AD ACCORDION -->\r\n        <mat-accordion multi *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In accordion']\"\r\n            class=\"add-form-record-accordion\">\r\n            <mat-expansion-panel *ngFor=\"let group of form.FormFieldsGroups\">\r\n                <mat-expansion-panel-header>\r\n                    <mat-panel-title>\r\n                        {{group.Name}}\r\n                    </mat-panel-title>\r\n                </mat-expansion-panel-header>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n            </mat-expansion-panel>\r\n        </mat-accordion>\r\n    </form>\r\n\r\n    <div class=\"row mt-2 add-form-record-buttons\"\r\n        *ngIf=\"(showBackButton || showSaveButton) && form.FormScalarType != FormScalarTypeEnum['A step']\">\r\n        <div class=\"col-sm-12 text-right\">\r\n            <button class=\"mr-2\" mat-raised-button type=\"button\" *ngIf=\"showBackButton\" (click)=\"saveOrExitForm(true)\">\r\n                Annulla\r\n            </button>\r\n            <button class=\"mr-2\" mat-raised-button color=\"primary\" type=\"button\" *ngIf=\"showSaveButton\"\r\n                (click)=\"saveOrExitForm(false)\" [disabled]=\"formForm.invalid || formForm.disabled || isSaving\">\r\n                <span *ngIf=\"!isSaving\">Salva</span>\r\n                <span *ngIf=\"isSaving\">Salvataggio in Corso...</span>\r\n            </button>\r\n        </div>\r\n    </div>\r\n\r\n</ng-container>\r\n\r\n\r\n\r\n<!-- TEMPLATE PER LA VISUALIZZAZIONE DEI CAMPI DELLA FORM -->\r\n<ng-template #fieldTemplates let-fields='fields'>\r\n    <div class=\"row\" *ngIf=\"formloaded\">\r\n        <div class=\"mt-2\" *ngFor=\"let field of fields\"\r\n            [ngClass]=\"utilityService.getFieldSyleClass(field, showAllFields)\">\r\n            <dynamic-module-field-fix #fieldTemplate [field]=\"field\" [QueryEditorComponent]=\"QueryEditorComponent\" [form]=\"form\" [record]=\"record\" [configurations]=\"configurations\" [endPointConfiguration]=\"endPointConfiguration\" [userID]=\"userID\" [inConfig]=\"inConfig\"\r\n                (recordChange)=\"onRecordChange()\">\r\n            </dynamic-module-field-fix>\r\n        </div>\r\n    </div>\r\n</ng-template>", styles: [".visibility_hidden{display:none}.visibility_transparent{visibility:hidden}\n"], dependencies: [{ kind: "component", type: i3.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i4.MatStep, selector: "mat-step", inputs: ["color"], exportAs: ["matStep"] }, { kind: "directive", type: i4.MatStepLabel, selector: "[matStepLabel]" }, { kind: "component", type: i4.MatStepper, selector: "mat-stepper, mat-vertical-stepper, mat-horizontal-stepper, [matStepper]", inputs: ["disableRipple", "color", "labelPosition", "headerPosition", "animationDuration"], outputs: ["animationDone"], exportAs: ["matStepper", "matVerticalStepper", "matHorizontalStepper"] }, { kind: "directive", type: i4.MatStepperNext, selector: "button[matStepperNext]" }, { kind: "directive", type: i4.MatStepperPrevious, selector: "button[matStepperPrevious]" }, { kind: "component", type: i5.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass"], exportAs: ["matTab"] }, { kind: "component", type: i5.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: "directive", type: i6.MatAccordion, selector: "mat-accordion", inputs: ["hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { kind: "component", type: i6.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["hideToggle", "togglePosition"], outputs: ["afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i6.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["expandedHeight", "collapsedHeight", "tabIndex"] }, { kind: "directive", type: i6.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "directive", type: i7.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i7.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i7.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i8.DynamicModuleFieldFixComponent, selector: "dynamic-module-field-fix", inputs: ["configurations", "endPointConfiguration", "field", "form", "record", "inConfig", "userID", "QueryEditorComponent"], outputs: ["recordChange", "out"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AddFormRecordComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "add-form-record", template: "<ng-container *ngIf=\"loader\">\r\n\r\n    <div class=\"row eqp-dynamic-module-title add-form-record-header\" *ngIf=\"showTitle\">\r\n        <div class=\"col-md-12\">\r\n            <span>{{form.Name}}</span>\r\n        </div>\r\n    </div>\r\n\r\n    <form [formGroup]=\"formForm\" class=\"add-form-record-form\">\r\n\r\n        <!-- VISUALIZZAZIONE SEMPLICE -->\r\n        <ng-container *ngIf=\"form.FormScalarType == FormScalarTypeEnum.Semplice\" [ngTemplateOutlet]=\"fieldTemplates\"\r\n            [ngTemplateOutletContext]=\"{ fields: form.Fields }\" class=\"add-form-record-semplice\">\r\n        </ng-container>\r\n\r\n        <!-- VISUALIZZAZIONE A STEPPER -->\r\n        <mat-horizontal-stepper linear *ngIf=\"form.FormScalarType == FormScalarTypeEnum['A step']\"\r\n            class=\"add-form-record-stepper\" (selectionChange)=\"onStepChange($event)\">\r\n            <mat-step *ngFor=\"let group of form.FormFieldsGroups; let i = index; let first = first; let last = last\">\r\n              \r\n                <ng-template matStepLabel>\r\n                    {{group.Name}}\r\n                </ng-template>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n\r\n                <div class=\"mt-2 d-flex justify-content-end add-form-record-buttons\">\r\n                    <button *ngIf=\"!first\" class=\"mr-2 previous\" mat-raised-button matStepperPrevious>\r\n                        Precedente\r\n                    </button>\r\n                    <button *ngIf=\"!last\" class=\"button-next\" color=\"primary\" mat-raised-button matStepperNext>\r\n                        Successivo\r\n                    </button>\r\n                    <button *ngIf=\"last && showSaveButton\" (click)=\"saveOrExitForm(false)\" class=\"button-next\" [disabled]=\"formForm.invalid || formForm.disabled\"\r\n                        color=\"primary\" mat-raised-button>\r\n                        Salva\r\n                    </button>\r\n                </div>\r\n\r\n            </mat-step>\r\n        </mat-horizontal-stepper>\r\n\r\n        <!-- VISUALIZZAZIONE A TAB -->\r\n        <mat-tab-group *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In tab']\" class=\"add-form-record-tab\">\r\n            <mat-tab *ngFor=\"let group of form.FormFieldsGroups\" [label]=\"group.Name\">                \r\n                <div class=\"mt-3\">                    \r\n                    <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                        [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                    </ng-container>\r\n                </div>\r\n            </mat-tab>\r\n        </mat-tab-group>\r\n\r\n        <!-- VISUALIZZAZIONE AD ACCORDION -->\r\n        <mat-accordion multi *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In accordion']\"\r\n            class=\"add-form-record-accordion\">\r\n            <mat-expansion-panel *ngFor=\"let group of form.FormFieldsGroups\">\r\n                <mat-expansion-panel-header>\r\n                    <mat-panel-title>\r\n                        {{group.Name}}\r\n                    </mat-panel-title>\r\n                </mat-expansion-panel-header>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n            </mat-expansion-panel>\r\n        </mat-accordion>\r\n    </form>\r\n\r\n    <div class=\"row mt-2 add-form-record-buttons\"\r\n        *ngIf=\"(showBackButton || showSaveButton) && form.FormScalarType != FormScalarTypeEnum['A step']\">\r\n        <div class=\"col-sm-12 text-right\">\r\n            <button class=\"mr-2\" mat-raised-button type=\"button\" *ngIf=\"showBackButton\" (click)=\"saveOrExitForm(true)\">\r\n                Annulla\r\n            </button>\r\n            <button class=\"mr-2\" mat-raised-button color=\"primary\" type=\"button\" *ngIf=\"showSaveButton\"\r\n                (click)=\"saveOrExitForm(false)\" [disabled]=\"formForm.invalid || formForm.disabled || isSaving\">\r\n                <span *ngIf=\"!isSaving\">Salva</span>\r\n                <span *ngIf=\"isSaving\">Salvataggio in Corso...</span>\r\n            </button>\r\n        </div>\r\n    </div>\r\n\r\n</ng-container>\r\n\r\n\r\n\r\n<!-- TEMPLATE PER LA VISUALIZZAZIONE DEI CAMPI DELLA FORM -->\r\n<ng-template #fieldTemplates let-fields='fields'>\r\n    <div class=\"row\" *ngIf=\"formloaded\">\r\n        <div class=\"mt-2\" *ngFor=\"let field of fields\"\r\n            [ngClass]=\"utilityService.getFieldSyleClass(field, showAllFields)\">\r\n            <dynamic-module-field-fix #fieldTemplate [field]=\"field\" [QueryEditorComponent]=\"QueryEditorComponent\" [form]=\"form\" [record]=\"record\" [configurations]=\"configurations\" [endPointConfiguration]=\"endPointConfiguration\" [userID]=\"userID\" [inConfig]=\"inConfig\"\r\n                (recordChange)=\"onRecordChange()\">\r\n            </dynamic-module-field-fix>\r\n        </div>\r\n    </div>\r\n</ng-template>", styles: [".visibility_hidden{display:none}.visibility_transparent{visibility:hidden}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.UtilityHelperService }, { type: i2.DatePipe }], propDecorators: { configurations: [{
+                type: Input
+            }], endPointConfiguration: [{
+                type: Input
+            }], userID: [{
+                type: Input
+            }], orgaID: [{
+                type: Input
+            }], formID: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], onlyView: [{
+                type: Input
+            }], isDuplicate: [{
+                type: Input
+            }], inConfig: [{
+                type: Input
+            }], showAllFields: [{
+                type: Input
+            }], QueryEditorComponent: [{
+                type: Input
+            }], saveRecordEvent: [{
+                type: Output
+            }], afterSaveRecordEvent: [{
+                type: Output
+            }], out: [{
+                type: Output
+            }], fireTrigger: [{
+                type: Output
+            }], fieldTemplate: [{
+                type: ViewChildren,
+                args: ["fieldTemplate"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-form-record.component.js","sourceRoot":"","sources":["../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/form-records/add-form-record/add-form-record.component.ts","../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/form-records/add-form-record/add-form-record.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, QueryList, ViewChildren } from '@angular/core';\r\nimport { UntypedFormGroup } from '@angular/forms';\r\nimport { DynamicModuleCompileConfig } from '../../../../models/dynamicModuleCompileConfig.model';\r\nimport { AnswerStyle, BaseField, DataGetter, DataGetterTypeEnum, FieldInvisibilityEnum, FieldTypeEnum } from '../../../../models/baseField.model';\r\nimport { Form, FormScalarTypeEnum } from '../../../../models/form.model';\r\nimport { DynRecord, Record } from '../../../../models/record.model';\r\nimport { UtilityHelperService } from '../../../../services/utilityHelper.services';\r\nimport { DynamicModuleFieldFixComponent } from '../../dynamic-module-field-fix/dynamic-module-field.component';\r\nimport { EndPointConfiguration, EndPointDataParams, ParamTypeEnum } from './../../../../models/endPointConfiguration.model';\r\nimport { ListValueField } from '../../../../models/fields/listValueField.model';\r\nimport { GlobalService } from '../../../../services/global.service';\r\nimport { NumericField } from '../../../../models/fields/numericField.model';\r\nimport { ImageSelectorField } from '../../../../models/fields/imageSelectorField.model';\r\nimport { DynAttachment } from '../../../../models/dynAttachment';\r\nimport { DynamicLoaderDirectiveData, eventOut } from \"../../../../directives/dynamic-loader/dynamic-loader.directive\";\r\nimport { LogicOperator } from '../../../../models/logicOperator.model';\r\nimport { FireTrigger, Trigger, TriggerPropertyTypeEnum } from '../../../../models/trigger.model';\r\nimport { DatePipe } from '@angular/common';\r\nimport { DateField, DateTimeTypeEnum } from '../../../../models/fields/dateField.model';\r\n\r\n\r\n@Component({\r\n  selector: \"add-form-record\",\r\n  templateUrl: \"./add-form-record.component.html\",\r\n  styleUrls: [\"./add-form-record.component.scss\"],\r\n})\r\nexport class AddFormRecordComponent implements OnInit {\r\n\r\n  @Input() configurations: DynamicModuleCompileConfig;\r\n  @Input() endPointConfiguration: EndPointConfiguration;\r\n  @Input() userID: string;\r\n  @Input() orgaID: string = null; // preview\r\n  \r\n  @Input() formID: string = null; // preview\r\n  @Input() form: Form = null; // preview config\r\n  @Input() record: Record | string = null; // edit\r\n  @Input() onlyView: boolean = false;\r\n  @Input() isDuplicate: boolean = false;\r\n  @Input() inConfig: boolean = false;\r\n  @Input() showAllFields: boolean = false;\r\n\r\n  @Input() QueryEditorComponent: DynamicLoaderDirectiveData; // L'intero componente query Editor\r\n\r\n  @Output() saveRecordEvent: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() afterSaveRecordEvent: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() out: EventEmitter<eventOut> = new EventEmitter<eventOut>();\r\n  @Output() fireTrigger: EventEmitter<FireTrigger> = new EventEmitter<FireTrigger>();\r\n\r\n  showTitle = true;\r\n  showSaveButton = true;\r\n  showBackButton = true;\r\n  loader: boolean = false;\r\n  isSaving: boolean = false;\r\n  formloaded: boolean = false;\r\n\r\n  formForm: UntypedFormGroup;\r\n  fieldGroups: { [key: string]: Array<BaseField> } = {};\r\n  FormScalarTypeEnum = FormScalarTypeEnum;\r\n  FieldTypeEnum = FieldTypeEnum;\r\n\r\n  @ViewChildren(\"fieldTemplate\")\r\n  fieldTemplate: QueryList<DynamicModuleFieldFixComponent>;\r\n\r\n  constructor(\r\n    private cdr: ChangeDetectorRef,\r\n    public utilityService: UtilityHelperService,\r\n    private datepipe:DatePipe\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n\r\n\r\n    if (this.form != null && this.orgaID != null) {\r\n      this.form.OrgaID = this.orgaID;\r\n    }\r\n\r\n    // add può funzionare anche come modifica e come preview\r\n    // in add abbiamo in input l'ID del Form\r\n    // in modifica abbiamo in input l'ID del Record\r\n    // in preview abbiamo in input il Form(caso configurator) o l'ID del modulo on onlyView impostato a true\r\n    this.showTitle = this.configurations.showTitle;\r\n    this.showSaveButton = this.configurations.showSaveButton;\r\n    this.showBackButton = this.configurations.showBackButton;\r\n\r\n    GlobalService.debugLog(\"AddFormRecord\")\r\n\r\n    if (this.record == null) {\r\n      this.showTitle = true;\r\n      GlobalService.debugLog(\"AddFormRecord - new\")\r\n      this.previewOrNewResponseRecord();\r\n    } else {\r\n      this.showTitle = false;\r\n      GlobalService.debugLog(\"AddFormRecord - edit\", this.record)\r\n      this.editResponseRecord();\r\n    }\r\n\r\n    // l'inizializzazione termina con il recupero del record o con l'inizializzazione del form vuoto\r\n\r\n    this.cdr.detectChanges();\r\n    GlobalService.debugLog('oninit - DynaForm', this.form)\r\n  }\r\n\r\n  onStepChange(event: any): void {\r\n    //console.log(\"IGOR_event.selectedIndex\", event.selectedIndex);\r\n    if(GlobalService.isSpeechToTextStarted)\r\n    {\r\n      GlobalService.speechDirective.SpeechToTextToggler();\r\n    }\r\n  }\r\n\r\n  //#region onRecordChange\r\n  /**\r\n   * Metodo invocato al cambio del valore di ogni proprietà dell'oggetto record.\r\n   * Serve ad aggiornare il valore di tutti i campi che hanno una formula.\r\n   */\r\n  onRecordChange() {\r\n    console.log(\"FOrmForm\",this.formForm);\r\n    if (this.fieldTemplate && this.fieldTemplate.length > 0) {\r\n      this.fieldTemplate.forEach((f) => f.updateField());\r\n    }\r\n  }\r\n  //#endregion onRecordChange\r\n\r\n  //#region previewOrNewResponseRecord\r\n  previewOrNewResponseRecord() {\r\n    this.record = new Record();\r\n    // aggiugni nuovo\r\n    if (this.form != null) {\r\n      // preview per il configurator\r\n      this.fieldsConfig();\r\n    } else if (this.formID != null) {\r\n      // preview per admin\r\n      this.getFormByID(); // dentro chiama fieldsConfig\r\n    }\r\n  }\r\n  //#endregion previewOrNewResponseRecord\r\n\r\n  //#region editResponseRecord\r\n  editResponseRecord() {\r\n\r\n    // modiiltà modifica\r\n    if (typeof this.record === \"string\") {\r\n      // allora è un ID\r\n      this.getRecordByID();\r\n    } else {\r\n      // il record viene passato come tale\r\n      // (<Record>this.record).EntID = \"3\";\r\n      // (<Record>this.record).Version;\r\n      this.getFormByIDandVersion(true);\r\n    }\r\n  }\r\n  //#endregion editResponseRecord\r\n\r\n  //#region saveOrExitForm\r\n  /**\r\n   * Metodo per salvare i dati inseriti dall'utente una volta conclusa la compilazione della form.\r\n   */\r\n  saveOrExitForm(exit: boolean) {\r\n    GlobalService.debugLog('add-form-record saveRecordEvent')\r\n    if (exit) {\r\n      // this.saveRecordEvent.emit(null);\r\n      this.onSaveRecord(null);\r\n    } else {\r\n      // this.saveRecordEvent.emit(this.record);\r\n      this.isSaving = true;\r\n      this.onSaveRecord((<Record>this.record));\r\n    }\r\n  }\r\n  //#endregion saveOrExitForm\r\n\r\n  //#region onSaveRecord\r\n  /**\r\n   * Metodo per salvare il record aggiunto o modificato.\r\n   * Se è stato configurato un endPoint per il salvataggio viene effettuata una chiamata al server passando l'oggeto da salvare\r\n   * nel body della chiamata, altrimenti scatena l'evento \"saveRecord\".\r\n   * @param event Oggetto di tipo Record da salvare.\r\n   */\r\n  async onSaveRecord(event: Record) {\r\n    GlobalService.debugLog('onSaveRecord - event', event)\r\n    GlobalService.debugLog('onSaveRecord - form', this.form)\r\n    if (\r\n      event != null &&\r\n      this.endPointConfiguration != null &&\r\n      this.endPointConfiguration.Records.SaveEndPoint\r\n    ) {\r\n      var dynRec: DynRecord = new DynRecord();\r\n      dynRec.ID = event.ID ?? null;\r\n      dynRec.EntID = this.form.ID;\r\n      dynRec.Version = this.form.Version;\r\n      dynRec.userID = this.userID;\r\n      dynRec.Values = event ?? null;\r\n      dynRec.HTMLreadableValues = await this.createHTMLreadableValues(event);\r\n\r\n      if (event.FK_InsertUser == null) {\r\n        // Nuovo Record\r\n        dynRec.FK_InsertUser = this.userID;\r\n        dynRec.InsertDate = new Date();\r\n        dynRec.FK_UpdateUser = this.userID;\r\n        dynRec.UpdateDate = new Date();\r\n      } else {\r\n        // Modifica del Record\r\n        dynRec.FK_InsertUser = event.FK_InsertUser\r\n        dynRec.InsertDate = event.InsertDate;\r\n        dynRec.FK_UpdateUser = this.userID;\r\n        dynRec.UpdateDate = new Date();\r\n      }\r\n\r\n      var additionalParams = this.configurations.additionalParams == null ? event.AdditionalParams : this.configurations.additionalParams;\r\n      dynRec.AdditionalParams = JSON.stringify(additionalParams);\r\n\r\n      // var additionalInfo = this.additionalInfo == null ? event.AdditionalInfo : this.additionalInfo;\r\n      var additionalInfo = event.AdditionalInfo == null ? this.configurations.additionalInfo : event.AdditionalInfo;\r\n      dynRec.AdditionalInfo = JSON.stringify(additionalInfo);\r\n\r\n      var dynamicModuleParams = [\r\n        {\r\n          ParamName: \"Record\",\r\n          ParamValue: dynRec,\r\n          ParamType: ParamTypeEnum[\"In Body\"],\r\n        },\r\n      ];\r\n\r\n      GlobalService.debugLog('onSaveRecord - dynamicModuleParams', dynamicModuleParams)\r\n      this.utilityService.RunEndPointCall(\r\n        this.endPointConfiguration.Records.SaveEndPoint,\r\n        dynamicModuleParams,\r\n        (res) => {\r\n          dynRec.ID = res.toString();\r\n          event.ID = res.toString();\r\n          this.checkTriggers(event);\r\n          this.afterSaveRecordEvent.emit(dynRec);\r\n          this.isSaving = false;\r\n        }\r\n      );\r\n    } else {\r\n      this.saveRecordEvent.emit(dynRec);\r\n    }\r\n  }\r\n  //#endregion onSaveRecord\r\n\r\n  //#region getFormByID\r\n  getFormByID(id: string = this.formID) {\r\n    const dynamicModuleParams: Array<EndPointDataParams> =\r\n      new Array<EndPointDataParams>();\r\n    dynamicModuleParams.push({\r\n      ParamName: \"id\",\r\n      ParamValue: id,\r\n      ParamType: ParamTypeEnum[\"Query param\"],\r\n    });\r\n    this.utilityService.RunEndPointCall(\r\n      this.endPointConfiguration.Forms.GetByIDEndPoint,\r\n      dynamicModuleParams,\r\n      (res: Form) => {\r\n        this.form = res;\r\n        this.form.OrgaID = this.orgaID;\r\n\r\n        if (this.form.ObjectTriggers != null && this.form.ObjectTriggers != \"\") {\r\n          this.form.Triggers = JSON.parse(this.form.ObjectTriggers);\r\n        } else {\r\n          this.form.Triggers = new Array<Trigger>();\r\n        }\r\n\r\n        this.setDataGetter(this.form);\r\n        GlobalService.debugLog('getFormByID - DynaForm', this.form)\r\n        this.fieldsConfig();\r\n      },\r\n      (err) => { }\r\n    );\r\n  }\r\n  //#endregion getFormByID\r\n\r\n  //#region getRecordByID\r\n  // ci entro solo se è stato passato il parametro \"record\" come stringa\r\n  getRecordByID() {\r\n\r\n    // preparo i dati del record\r\n    var dynamicRecordParams = [\r\n      {\r\n        ParamName: \"id\",\r\n        ParamValue: this.record,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      },\r\n    ];\r\n    this.utilityService.RunEndPointCall(\r\n      this.endPointConfiguration.Records.GetByIDEndPoint,\r\n      dynamicRecordParams,\r\n      (res: DynRecord) => {\r\n        this.record = new Record();\r\n\r\n        (<Record>this.record) = JSON.parse(res.SerializedValues);\r\n        this.record.ID = this.isDuplicate ? \"\" : res.ID;\r\n        this.record.EntID = res.EntID;\r\n        this.record.userID = res.userID;\r\n        this.record.Version = res.Version;\r\n        this.record.Values = JSON.parse(res.SerializedValues);\r\n        this.record.FK_InsertUser = res.FK_InsertUser;\r\n        this.record.FK_UpdateUser = res.FK_UpdateUser;\r\n        this.record.InsertDate = res.InsertDate;\r\n        this.record.UpdateDate = res.UpdateDate;\r\n\r\n        // this.viewMode = DynamicModuleViewModeEnum.COMPILE;\r\n        // this.loader = true;\r\n        this.getFormByIDandVersion();\r\n      }\r\n    );\r\n  }\r\n  //#endregion getRecordByID\r\n\r\n  //#region getFormByIDandVersion\r\n  getFormByIDandVersion(getAttachments: boolean = false) {\r\n    // preparo la versione corretta del form\r\n    var dynamicModuleParams = [\r\n      {\r\n        ParamName: \"EntID\",\r\n        ParamValue: (<Record>this.record).EntID,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      },\r\n      {\r\n        ParamName: \"Version\",\r\n        ParamValue: (<Record>this.record).Version,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      },\r\n    ];\r\n    GlobalService.debugLog(\"getFormByIDandVersion - this record\", <Record>this.record)\r\n    this.utilityService.RunEndPointCall(\r\n      this.endPointConfiguration.Forms.GetByIDAndVersionEndPoint,\r\n      dynamicModuleParams,\r\n      (res: Form) => {\r\n        GlobalService.debugLog(\"AFTER getFormByIDandVersion - this.form\", res)\r\n        this.form = res;\r\n        this.form.OrgaID = this.orgaID;\r\n\r\n        if (this.form.ObjectTriggers != null && this.form.ObjectTriggers != \"\") {\r\n          this.form.Triggers = JSON.parse(this.form.ObjectTriggers);\r\n        } else {\r\n          this.form.Triggers = new Array<Trigger>();\r\n        }\r\n\r\n        this.setDataGetter(this.form);\r\n\r\n        this.createRecordProperties();\r\n        this.reorderFormFields();\r\n        this.createFormGroup();\r\n        if (this.form.FormScalarType != FormScalarTypeEnum.Semplice) {\r\n          this.createFieldGroups();\r\n        }\r\n\r\n        if (!getAttachments) {\r\n          this.loader = true;\r\n          this.formloaded = true;\r\n        } else {\r\n          this.getAllRecordAttachments((<Record>this.record).ID);\r\n        }\r\n      }\r\n    );\r\n  }\r\n  //#endregion getFormByIDandVersion\r\n\r\n  //#region getAllRecordAttachments\r\n  getAllRecordAttachments(recordID: string) {\r\n\r\n    var dynamicModuleParams = [\r\n      {\r\n        ParamName: \"answerId\",\r\n        ParamValue: recordID,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      }\r\n    ];\r\n\r\n    this.utilityService.RunEndPointCall(\r\n      this.endPointConfiguration.Records.GetAllAttachmentsEndPoint,\r\n      dynamicModuleParams,\r\n      (res: Array<DynAttachment>) => {\r\n        GlobalService.debugLog(\"GetAllAttachmentsEndPoint()\", res);\r\n\r\n        this.form.Fields.forEach((field) => {\r\n          if (field.FieldType == FieldTypeEnum.Immagine || field.FieldType == FieldTypeEnum['Immagine con markers']) {\r\n            var attachId = this.record[field.Name];\r\n            this.record[field.Name] = res.find(x => x.ID == attachId);\r\n          }\r\n        });\r\n\r\n        this.loader = true;\r\n        this.formloaded = true;\r\n      }\r\n    );\r\n\r\n  }\r\n  //#endregion getAllRecordAttachments\r\n\r\n  //#region fieldsConfig\r\n  fieldsConfig() {\r\n    this.createRecordProperties();\r\n    this.reorderFormFields();\r\n    this.createFormGroup();\r\n    if (this.form.FormScalarType != FormScalarTypeEnum.Semplice) {\r\n      this.createFieldGroups();\r\n    }\r\n    GlobalService.debugLog(\"fieldsConfig - form\", this.form);\r\n    this.loader = true;\r\n    this.formloaded = true;\r\n  }\r\n  //#endregion fieldsConfig\r\n\r\n  //#region createRecordProperties\r\n  /**\r\n   * Metodo per creare nell'oggetto Record le proprietà mancanti rispetto ai campi che compongono la form.\r\n   */\r\n  private createRecordProperties() {\r\n    const recordProperties: Array<string> = Object.keys(this.record);\r\n    this.form.Fields.forEach((field) => {\r\n      if (!recordProperties.find((p) => p === field.Name)) {\r\n        this.record[field.Name] = null;\r\n      }\r\n    });\r\n    if (this.form.InnerForms && this.form.InnerForms.length > 0) {\r\n      this.form.InnerForms.forEach((form) => {\r\n        const arrayName: string = form.Name.split(\" \").join(\"_\");\r\n        if (!recordProperties.find((p) => p === arrayName)) {\r\n          this.record[arrayName] = [];\r\n        }\r\n      });\r\n    }\r\n    GlobalService.debugLog(\"createRecordProperties - form\", this.form);\r\n    GlobalService.debugLog(\"createRecordProperties - record\", this.record);\r\n  }\r\n  //#endregion createRecordProperties\r\n\r\n  /**\r\n   * Metodo per riordinare i campi che compongono la form.\r\n   */\r\n  private reorderFormFields() {\r\n    if (this.form.Fields && this.form.Fields.length > 0) {\r\n      this.form.Fields.sort((a, b) =>\r\n        a.OrdinalPosition > b.OrdinalPosition ? 1 : b.OrdinalPosition > a.OrdinalPosition ? -1 : 0);\r\n    }\r\n    GlobalService.debugLog(\"reorderFormFields - form\", this.form);\r\n  }\r\n\r\n  /**\r\n   * Metodo per creare il FormGroup che rappresenta la form.\r\n   */\r\n  private createFormGroup() {\r\n    this.formForm = this.utilityService.CreateFormFormGroup(\r\n      this.form.Fields,\r\n      (<Record>this.record),\r\n      this.onlyView\r\n    );\r\n    GlobalService.debugLog(\"createFormGroup - form\", this.form);\r\n  }\r\n\r\n  /**\r\n   * Metodo per creare i gruppi in cui raggruppare i campi della form in base\r\n   * a come è stata configurata dall'utente.\r\n   */\r\n  private createFieldGroups() {\r\n    this.form.FormFieldsGroups.sort((a, b) => a.OrdinalPosition > b.OrdinalPosition ? 1 : b.OrdinalPosition > a.OrdinalPosition ? -1 : 0)\r\n      .map((g) => g.Name)\r\n      .forEach((groupName) => {\r\n        this.fieldGroups[groupName] = this.form.Fields.filter(\r\n          (f) => f.FieldGroup == groupName\r\n        );\r\n      });\r\n    GlobalService.debugLog(\"createFieldGroups - form\", this.form);\r\n  }\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n  //#region createHTMLreadableValues\r\n  /**\r\n   * Metodo per creare il FormGroup che rappresenta la form.\r\n   */\r\n  private async createHTMLreadableValues(record: Record) {\r\n\r\n    GlobalService.debugLog(\"createHTMLreadableValues - record\", record);\r\n    GlobalService.debugLog(\"createHTMLreadableValues - form\", this.form);\r\n\r\n    var formnames = new Array<string>();\r\n    this.form.Fields.forEach((field) => { formnames.push(field.Name); });\r\n    GlobalService.debugLog(\"createHTMLreadableValues - form fields names\", formnames);\r\n\r\n    // alert(\"continue for values?\")\r\n\r\n    let outputValuesArray = await this.getResponseValues(record, this.form);\r\n\r\n    GlobalService.debugLog(\"createHTMLreadableValues - outputValuesArray\", outputValuesArray);\r\n\r\n    // alert(\"continue for templates?\")\r\n    let template: string = this.getResponseTemplate(record, this.form); // oggetto nel quale viene costruito il template o che prende il valore da un template esterno\r\n\r\n    GlobalService.debugLog(\"createHTMLreadableValues - template\", template);\r\n    // alert(\"continue for output?\")\r\n    const regex = /##([\\w]+)##/g;\r\n    const output = this.replaceTemplatePlaceholdersWithValues(template, outputValuesArray, regex)\r\n\r\n    GlobalService.debugLog(\"createHTMLreadableValues - output\", output);\r\n    // alert(\"continue for ending?\")\r\n    return output; // oggetto che conterrà l'output elaborato    \r\n\r\n  }\r\n  //#endregion createHTMLreadableValues\r\n\r\n  //#region getResponseValues\r\n  private async getResponseValues(record: Record, form: Form) {\r\n    let outputValuesArray: Array<any> = []; // array con i valori delle risposte\r\n    //(<DynRecord>this.record).Values è la lista di oggetti {fieldName: valore}\r\n    // GlobalService.debugLog(\"(record).Values\", record);\r\n\r\n    form.Fields.forEach(\r\n      async (field) => {\r\n        try {\r\n          //GlobalService.debugLog(\"getResponseValues field\", field);\r\n          // let foundObject = record.find(\r\n          //   (obj) => obj === field.Name\r\n          // );\r\n          let foundObject = record[field.Name];\r\n\r\n          // fare un eval per popolare i valuePairs se è presente una formula\r\n          // prendere la label corretta\r\n          ////////////////////////////////////////////////////////////////////////////////\r\n          // PREPARO IL VALUEPAIRS\r\n          switch (field.FieldType) {\r\n            case FieldTypeEnum[\"Elenco generico\"]: {\r\n              if (field.Formula != null && field.Formula) {\r\n                // aggiungo a valuepairs i valori calcolati\r\n                // (<ListValueField>foundObject).ValuePairs = (<ListValueField>foundObject).ValuePairs ? (<ListValueField>foundObject).ValuePairs : {};\r\n                var temp = UtilityHelperService.EvaluateFieldFormula(\r\n                  field.Formula,\r\n                  record,\r\n                  null\r\n                );\r\n                for (let key2 in temp) {\r\n                  if (UtilityHelperService.isNumeric(temp[key2])) {\r\n                    (<ListValueField>field).ValuePairs[Number(key2)] = temp[key2];\r\n                  } else {\r\n                    (<ListValueField>field).ValuePairs[key2] = temp[key2];\r\n                  }\r\n                }\r\n                outputValuesArray[field.Name] = (<ListValueField>field).ValuePairs[record[field.Name]];\r\n              } else if ((<ListValueField>field).ValuePairs != null && (<ListValueField>field).ValuePairs.length > 0) {\r\n                // va bene così\r\n              } else if ((<ListValueField>field).ValueString != null && (<ListValueField>field).ValueString != \"\") {\r\n                // va presa la strigna e rimappata nel diario\r\n                (<ListValueField>field).ValuePairs = GlobalService.stringToValuePairs((<ListValueField>field).ValueString);\r\n              }\r\n\r\n              let inverted = {};\r\n              //GlobalService.debugLog(\"(<ListValueField>foundObject).ValuePairs\", (<ListValueField>field).ValuePairs);\r\n              // ValuePairs: {Si: 'Si', No: 'No'}\r\n              for (let key in (<ListValueField>field).ValuePairs) {\r\n                inverted[(<ListValueField>field).ValuePairs[key]] = key;\r\n              }\r\n              (<ListValueField>field).ValuePairs = inverted;\r\n              if (record[field.Name] != null && (<ListValueField>field).IsMultiChoiche) {\r\n                // caso MULTISCELTA\r\n                let value = \"\";\r\n                record[field.Name].forEach((element, i) => {\r\n                  value += (<ListValueField>field).ValuePairs[element];\r\n                  value += i == record[field.Name].length - 1 ? \"\" : \", \"\r\n                });\r\n                outputValuesArray[field.Name] = value;\r\n              } else {\r\n                outputValuesArray[field.Name] = (<ListValueField>field).ValuePairs[record[field.Name]];\r\n              }\r\n              //console.log(\"outputValuesArray\", outputValuesArray)\r\n\r\n              break;\r\n            };\r\n            case FieldTypeEnum[\"Campo numerico\"]: {\r\n              if ((<NumericField>field).IsInteger) {\r\n                if ((<NumericField>field).DecimalSeparator == null) {\r\n                  outputValuesArray[field.Name] = record[field.Name];\r\n                } else {\r\n                  outputValuesArray[field.Name] = record[field.Name];\r\n                }\r\n              } else {\r\n                outputValuesArray[field.Name] = record[field.Name];\r\n              }\r\n              break;\r\n            };\r\n\r\n            case FieldTypeEnum['Immagine']: {\r\n              console.log(\"immagine \", field.Name, record[field.Name])\r\n              // Recupero il BASE64 dell'immagine Resized via promise client\r\n              var resizedBase64 = await this.resizeBase64Image(\"data:image/\" + record[field.Name].FileExtension + \";base64,\" + record[field.Name].FileDataBase64);\r\n\r\n              // Aggiungo l'HTML con il nuovo BASE64\r\n              outputValuesArray[field.Name] = \"<img src='\" + resizedBase64 + \"' style='height: \" + record[field.Name].ResizedImageHeightPx + \"px'>\";\r\n\r\n              break;\r\n            };\r\n\r\n\r\n            case FieldTypeEnum['Allegato']: {\r\n              console.log(\"Allegato \", field.Name, record[field.Name], record)\r\n\r\n              if (record[field.Name] != null) {\r\n                let resizedBase64;\r\n                if (record[field.Name][0].IsImage) {\r\n                  // Recupero il BASE64 dell'immagine Resized via promise client\r\n                  resizedBase64 = await this.resizeBase64Image(\"data:image/\" + record[field.Name][0].FileExtension + \";base64,\" + record[field.Name][0].FileDataBase64);\r\n                  console.log(\"Allegato resizedBase64\", resizedBase64)\r\n                  // Aggiungo l'HTML con il nuovo BASE64\r\n                  outputValuesArray[field.Name] = '<img class=\"image-preview\" src=\"' + resizedBase64 + '\" style=\"height: ' + record[field.Name][0].ResizedImageHeightPx + 'px\">';\r\n                } else if (record[field.Name][0].FileContentType == \"application/pdf\") {\r\n                  outputValuesArray[field.Name] = '<iframe src=\"data:application/pdf;base64,' + record[field.Name][0].FileDataBase64 + '\"style=\"min-height: 300px; height: 100%;\"></iframe>';\r\n                } else {\r\n                  outputValuesArray[field.Name] = '<iframe src=\"data:\"' + record[field.Name][0].FileExtension + '\";base64,' + record[field.Name][0].FileDataBase64 + '\"style=\"min-height: 300px; height: 100%;\"></iframe>';\r\n                }\r\n\r\n                // Aggiungo l'HTML con il nuovo BASE64\r\n                // outputValuesArray[field.Name] = \"<img src='\" + resizedBase64 + \"' style='height: \" + record[field.Name][0].ResizedImageHeightPx + \"px'>\";\r\n                console.log(\"Allegato outputValuesArray\", outputValuesArray[field.Name])\r\n              }\r\n\r\n              break;\r\n            };\r\n\r\n            case FieldTypeEnum['Immagine con markers']: {\r\n\r\n              // Recupero il BASE64 dell'immagine Resized via promise client\r\n              var resizedBase64 = await this.resizeBase64Image(\"data:image/\" + record[field.Name].FileExtension + \";base64,\" + record[field.Name].FileDataBase64);\r\n\r\n              // Aggiungo l'HTML con il nuovo BASE64\r\n              outputValuesArray[field.Name] = \"<img src='\" + resizedBase64 + \"' style='height: \" + record[field.Name].ResizedImageHeightPx + \"px'>\";\r\n\r\n              break;\r\n            };\r\n\r\n            case FieldTypeEnum['Elenco immagini']: {\r\n              outputValuesArray[field.Name] = \"\";\r\n              if (record[field.Name] != null && (<ImageSelectorField>field).IsMultiChoiche) {\r\n                record[field.Name].forEach((imageobj: number) => {\r\n                  var attachmentInForm: DynAttachment = (<ImageSelectorField>field).AttachmentList.find(x => x.ID == imageobj);\r\n                  if (attachmentInForm != null) {\r\n                    outputValuesArray[field.Name] += attachmentInForm.ButtonKey + \", \";\r\n                  }\r\n                });\r\n                var parts = outputValuesArray[field.Name].split(\", \");\r\n                outputValuesArray[field.Name] = parts.slice(0, parts.length - 1).join(\", \");\r\n              }\r\n              else {\r\n                var attachmentInForm: DynAttachment = (<ImageSelectorField>field).AttachmentList.find(x => x.ID == record[field.Name]);\r\n                if (attachmentInForm != null) {\r\n                  outputValuesArray[field.Name] = attachmentInForm.ButtonKey;\r\n                }\r\n              }\r\n              \r\n              break;\r\n            };\r\n            case  FieldTypeEnum['Data e/o ora']:{\r\n              console.log(\"Data e/o ora\",field);\r\n              if((<DateField>field).DateFormat!=null){\r\n                let fixDateFormat=(<DateField>field).DateFormat.replace(\"DD\",\"dd\");\r\n                outputValuesArray[field.Name] =this.datepipe.transform(record[field.Name],fixDateFormat);\r\n              }\r\n              else{\r\n                if ((<DateField>field).IsOnlyDate== DateTimeTypeEnum['Solo data']) {\r\n                  outputValuesArray[field.Name] =this.datepipe.transform(record[field.Name],\"dd/MM/yyyy\");\r\n                } else if ((<DateField>field).IsOnlyDate== DateTimeTypeEnum['Data e ora']) {\r\n                  outputValuesArray[field.Name] =this.datepipe.transform(record[field.Name],\"dd/MM/yyyy HH:mm\");\r\n                } else if ((<DateField>field).IsOnlyDate== DateTimeTypeEnum['Solo orario']) {\r\n                  outputValuesArray[field.Name] =this.datepipe.transform(record[field.Name],\"HH:mm\");\r\n                }\r\n              }\r\n              break;\r\n            }\r\n\r\n            default: {\r\n              outputValuesArray[field.Name] = record[field.Name];\r\n            }\r\n          }\r\n        }\r\n        catch (e) {\r\n          console.error(e);\r\n        }\r\n      }\r\n    )\r\n\r\n    // Funziona, ma non è affidabile al 100%\r\n    await this.delay(3000);\r\n\r\n    GlobalService.debugLog(\"outputValuesArray 1\", outputValuesArray);\r\n    // cancello i valori indefiniti o nulli\r\n    for (const chiave in outputValuesArray) {\r\n      if (outputValuesArray[chiave] == undefined || outputValuesArray[chiave] == null)\r\n        outputValuesArray[chiave] = ''\r\n    }\r\n    return outputValuesArray;\r\n  }\r\n  //#endregion getResponseValues\r\n\r\n  //#region getResponseTemplate\r\n  private getResponseTemplate(record: Record, form: Form): string {\r\n    let template: string = '<div class=\"row\">';\r\n    // PREPARO O PRENDO LA STRUTTURA DA STAMPARE\r\n    form.Fields.forEach((baseField: BaseField) => {\r\n      GlobalService.debugLog('getResposneTemplate - pre - field', baseField)\r\n      if (baseField.AnswerStyle == null || baseField.AnswerStyle == undefined) {\r\n        baseField.AnswerStyle = new AnswerStyle();\r\n        baseField.AnswerStyle.ColSpanSizes = baseField.ColSpanSizes;\r\n        baseField.AnswerStyle.FieldstyleCSS = baseField.FieldstyleCSS;\r\n        baseField.AnswerStyle.LabelstyleCSS = baseField.LabelstyleCSS;\r\n        if (baseField.VisibleIf) {\r\n          baseField.AnswerStyle.InListView = UtilityHelperService.EvaluateFieldFormula(baseField.VisibleIf, record, null);\r\n        } else {\r\n          baseField.AnswerStyle.InListView = baseField.InListView;\r\n          baseField.AnswerStyle.VisibleIf = baseField.VisibleIf;\r\n        }\r\n      }\r\n      if (baseField.AnswerStyle.VisibleIf) {\r\n        const visibility = UtilityHelperService.EvaluateFieldFormula(baseField.AnswerStyle.VisibleIf, record, null)\r\n        GlobalService.debugLog(\"EvaluateFieldFormula - visibility\", visibility);\r\n        baseField.AnswerStyle.InListView = (visibility == true) ? true : false;\r\n      }\r\n      if (baseField.AnswerStyle.InListView) {\r\n        template += '<div class=\"' + this.utilityService.getFieldAnswerStyleClass(baseField) + ' d-flex flex-column dynaform-answer-field\"> ' +\r\n          ' <span class=\"dynaform-question\" style=\"' + baseField.AnswerStyle.LabelstyleCSS + '\">' + baseField.Description + ':</span>' +\r\n          ' <span class=\"dynaform-response\" style=\"' + baseField.AnswerStyle.FieldstyleCSS + '\"> ##' + baseField.Name + '##</span>' +\r\n          '</div> \\n ';\r\n      } else if (!baseField.AnswerStyle.InListView && baseField.AnswerStyle.Invisibility == FieldInvisibilityEnum['NASCOSTO CON AREA VISIBILE']) {\r\n        template += '<div class=\"' + this.utilityService.getFieldAnswerStyleClass(baseField) + ' d-flex flex-column dynaform-answer-field\"> ' +\r\n          '</div> \\n ';\r\n      }\r\n\r\n      GlobalService.debugLog('getResposneTemplate - post - field', baseField)\r\n    });\r\n    // (attualmente non esiste il concetto di tempate di output)\r\n    template += '</div>';\r\n    return template;\r\n  }\r\n  //#endregion getResponseTemplate\r\n\r\n  private replaceTemplatePlaceholdersWithValues(template: string, outputValuesArray: Array<any>, regex): string {\r\n    return template.replace(regex, (match, group) => {\r\n      return <string>outputValuesArray[group];\r\n    });\r\n  }\r\n\r\n  delay(ms: number) {\r\n    return new Promise(resolve => setTimeout(resolve, ms));\r\n  }\r\n\r\n  private async resizeBase64Image(base64Image: string) {\r\n    return new Promise((resolve, reject) => {\r\n      const imagetype = /data:image\\/([\\w]+);/;\r\n      const match = base64Image.match(imagetype);\r\n      const img = new Image();\r\n      img.src = base64Image;\r\n      img.onload = function () {\r\n        const canvas = document.createElement(\"canvas\");\r\n        const ctx = canvas.getContext('2d');\r\n        const width = img.width;\r\n        const height = img.height;\r\n        const aspectRatio = width / height;\r\n\r\n        const newHeight = 128;\r\n        const newWidth = newHeight * aspectRatio;\r\n\r\n        canvas.width = newWidth;\r\n        canvas.height = newHeight;\r\n        ctx.drawImage(img, 0, 0, newWidth, newHeight);\r\n        let quality = 0.8;\r\n        let dataURL = canvas.toDataURL('image/'+match[1], quality);\r\n        resolve(dataURL);\r\n      };\r\n    });\r\n  }\r\n\r\n  setDataGetter(form) {\r\n    form.Fields.forEach((field) => {\r\n\r\n      // Trasformo il Base64String del Datagetter nel Datagetter vero e proprio\r\n      if (field.DataGetterValueBase64String != null) {\r\n        field.DataGetter = JSON.parse(atob(field.DataGetterValueBase64String));\r\n        field.DataGetter.DataGetterType = field.DataGetter.DataGetterType == null ? DataGetterTypeEnum.Manuale : field.DataGetter.DataGetterType;\r\n      } else {\r\n        field.DataGetter = new DataGetter();\r\n      }\r\n\r\n      field.DataGetterValueBase64String = null;\r\n\r\n    });\r\n  }\r\n\r\n  //#region checkTriggers\r\n  // Controlla e spara il trigger se necessario\r\n  checkTriggers(record: Record) {\r\n    var fireTrigger = true;\r\n\r\n    GlobalService.debugLog(\"checkTriggers - inside checkTriggers()\", this.form.Triggers);\r\n\r\n    if (this.form.Triggers != null) {\r\n      GlobalService.debugLog(\"checkTriggers - have triggers in form\");\r\n      this.form.Triggers.forEach((trigger) => {\r\n        fireTrigger = true;\r\n        trigger.conditions.forEach((condition) => {\r\n          if (!fireTrigger) { return; }\r\n          var logicOperator: LogicOperator = condition.logicoperator as LogicOperator;\r\n          var conditionKey = Object.keys(condition.record)[0];\r\n          var conditionValue = condition.record[conditionKey];\r\n          var recordValue = record[conditionKey];\r\n\r\n          if (logicOperator == LogicOperator['='] && conditionValue != recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['!='] && conditionValue == recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['<'] && conditionValue <= recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['<='] && conditionValue < recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['>'] && conditionValue >= recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['>='] && conditionValue > recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['LIKE'] && recordValue.indexOf(conditionValue) == -1) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['NOT LIKE'] && recordValue.indexOf(conditionValue) != -1) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator.Si && !recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator.No && recordValue) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }\r\n\r\n          if (logicOperator == LogicOperator['CONTIENE ALMENO UNO'] && !conditionValue.some(c => recordValue.includes(c))) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }         \r\n          \r\n          if (logicOperator == LogicOperator['CONTIENE TUTTI'] && !conditionValue.every(c => recordValue.includes(c))) {\r\n            fireTrigger = false;\r\n            this.logTrigger(trigger, condition, record);\r\n            return;\r\n          }               \r\n\r\n        });\r\n\r\n        GlobalService.debugLog(\"checkTriggers - fireTrigger? \", fireTrigger);\r\n\r\n        if (fireTrigger) {\r\n\r\n          // Il trigger va sparato. Valuto le funzioni interne\r\n          var formulas = JSON.parse(JSON.stringify(trigger.formulas));\r\n          GlobalService.debugLog(\"checkTriggers - evaluate formulas \", formulas);\r\n\r\n          if (formulas != null && Object.keys(formulas).length > 0){\r\n            Object.keys(formulas).forEach((key) => {\r\n              var formula = formulas[key].value;\r\n              GlobalService.debugLog(\"checkTriggers - formulas[key] \", formulas[key]);\r\n              var temp;\r\n              if (formulas[key].type == TriggerPropertyTypeEnum.DMMODULE) {\r\n                temp = formula\r\n              } else {\r\n                temp = UtilityHelperService.EvaluateFieldFormula(\r\n                  formula,\r\n                  record,\r\n                  null\r\n                );\r\n              }\r\n\r\n              formulas[key] = temp;\r\n\r\n            });\r\n          }\r\n\r\n          // Sparo il trigger all'esterno\r\n          var triggerToFire: FireTrigger = new FireTrigger();\r\n          triggerToFire.form = this.form; // Il form che ha provocato il trigger\r\n          triggerToFire.record = record; // Il record che ha provocato il trigger\r\n          triggerToFire.trigger = trigger; // Il trigger\r\n          triggerToFire.formulas = formulas; // Le formule inviate in input al modulo dinamico, valutate nel contesto del trigger e del record\r\n          triggerToFire.userPatient = this.userID; // UserID\r\n\r\n          console.log(\"checkTriggers - Trigger Fired \", triggerToFire.trigger.description, triggerToFire);\r\n          this.fireTrigger.emit(triggerToFire);\r\n        }\r\n\r\n      });\r\n    }\r\n  }\r\n\r\n  logTrigger(trigger, condition, record) {\r\n    GlobalService.debugLog(\"checkTriggers - Condition that invalidated the trigger TRIGGER\", trigger);\r\n    GlobalService.debugLog(\"checkTriggers - Condition that invalidated the trigger CONDITION\", condition);\r\n    GlobalService.debugLog(\"checkTriggers - Condition that invalidated the trigger RECORD\", record);\r\n  }\r\n  //#endregion checkTriggers\r\n\r\n}\r\n","<ng-container *ngIf=\"loader\">\r\n\r\n    <div class=\"row eqp-dynamic-module-title add-form-record-header\" *ngIf=\"showTitle\">\r\n        <div class=\"col-md-12\">\r\n            <span>{{form.Name}}</span>\r\n        </div>\r\n    </div>\r\n\r\n    <form [formGroup]=\"formForm\" class=\"add-form-record-form\">\r\n\r\n        <!-- VISUALIZZAZIONE SEMPLICE -->\r\n        <ng-container *ngIf=\"form.FormScalarType == FormScalarTypeEnum.Semplice\" [ngTemplateOutlet]=\"fieldTemplates\"\r\n            [ngTemplateOutletContext]=\"{ fields: form.Fields }\" class=\"add-form-record-semplice\">\r\n        </ng-container>\r\n\r\n        <!-- VISUALIZZAZIONE A STEPPER -->\r\n        <mat-horizontal-stepper linear *ngIf=\"form.FormScalarType == FormScalarTypeEnum['A step']\"\r\n            class=\"add-form-record-stepper\" (selectionChange)=\"onStepChange($event)\">\r\n            <mat-step *ngFor=\"let group of form.FormFieldsGroups; let i = index; let first = first; let last = last\">\r\n              \r\n                <ng-template matStepLabel>\r\n                    {{group.Name}}\r\n                </ng-template>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n\r\n                <div class=\"mt-2 d-flex justify-content-end add-form-record-buttons\">\r\n                    <button *ngIf=\"!first\" class=\"mr-2 previous\" mat-raised-button matStepperPrevious>\r\n                        Precedente\r\n                    </button>\r\n                    <button *ngIf=\"!last\" class=\"button-next\" color=\"primary\" mat-raised-button matStepperNext>\r\n                        Successivo\r\n                    </button>\r\n                    <button *ngIf=\"last && showSaveButton\" (click)=\"saveOrExitForm(false)\" class=\"button-next\" [disabled]=\"formForm.invalid || formForm.disabled\"\r\n                        color=\"primary\" mat-raised-button>\r\n                        Salva\r\n                    </button>\r\n                </div>\r\n\r\n            </mat-step>\r\n        </mat-horizontal-stepper>\r\n\r\n        <!-- VISUALIZZAZIONE A TAB -->\r\n        <mat-tab-group *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In tab']\" class=\"add-form-record-tab\">\r\n            <mat-tab *ngFor=\"let group of form.FormFieldsGroups\" [label]=\"group.Name\">                \r\n                <div class=\"mt-3\">                    \r\n                    <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                        [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                    </ng-container>\r\n                </div>\r\n            </mat-tab>\r\n        </mat-tab-group>\r\n\r\n        <!-- VISUALIZZAZIONE AD ACCORDION -->\r\n        <mat-accordion multi *ngIf=\"form.FormScalarType == FormScalarTypeEnum['In accordion']\"\r\n            class=\"add-form-record-accordion\">\r\n            <mat-expansion-panel *ngFor=\"let group of form.FormFieldsGroups\">\r\n                <mat-expansion-panel-header>\r\n                    <mat-panel-title>\r\n                        {{group.Name}}\r\n                    </mat-panel-title>\r\n                </mat-expansion-panel-header>\r\n\r\n                <ng-container [ngTemplateOutlet]=\"fieldTemplates\"\r\n                    [ngTemplateOutletContext]=\"{ fields: fieldGroups[group.Name] }\">\r\n                </ng-container>\r\n            </mat-expansion-panel>\r\n        </mat-accordion>\r\n    </form>\r\n\r\n    <div class=\"row mt-2 add-form-record-buttons\"\r\n        *ngIf=\"(showBackButton || showSaveButton) && form.FormScalarType != FormScalarTypeEnum['A step']\">\r\n        <div class=\"col-sm-12 text-right\">\r\n            <button class=\"mr-2\" mat-raised-button type=\"button\" *ngIf=\"showBackButton\" (click)=\"saveOrExitForm(true)\">\r\n                Annulla\r\n            </button>\r\n            <button class=\"mr-2\" mat-raised-button color=\"primary\" type=\"button\" *ngIf=\"showSaveButton\"\r\n                (click)=\"saveOrExitForm(false)\" [disabled]=\"formForm.invalid || formForm.disabled || isSaving\">\r\n                <span *ngIf=\"!isSaving\">Salva</span>\r\n                <span *ngIf=\"isSaving\">Salvataggio in Corso...</span>\r\n            </button>\r\n        </div>\r\n    </div>\r\n\r\n</ng-container>\r\n\r\n\r\n\r\n<!-- TEMPLATE PER LA VISUALIZZAZIONE DEI CAMPI DELLA FORM -->\r\n<ng-template #fieldTemplates let-fields='fields'>\r\n    <div class=\"row\" *ngIf=\"formloaded\">\r\n        <div class=\"mt-2\" *ngFor=\"let field of fields\"\r\n            [ngClass]=\"utilityService.getFieldSyleClass(field, showAllFields)\">\r\n            <dynamic-module-field-fix #fieldTemplate [field]=\"field\" [QueryEditorComponent]=\"QueryEditorComponent\" [form]=\"form\" [record]=\"record\" [configurations]=\"configurations\" [endPointConfiguration]=\"endPointConfiguration\" [userID]=\"userID\" [inConfig]=\"inConfig\"\r\n                (recordChange)=\"onRecordChange()\">\r\n            </dynamic-module-field-fix>\r\n        </div>\r\n    </div>\r\n</ng-template>"]}