@eqproject/eqp-dynamic-module 2.8.7 → 3.0.0

package/esm2022/lib/components/private/field-templates/image-with-markers-field-template/image-with-markers-field-template.component.mjs

@@ -0,0 +1,261 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { ImageFolderEnum } from '../../../../models/fields/imageField.model';
+import { UtilityHelperService } from '../../../../services/utilityHelper.services';
+import { ParamTypeEnum } from '../../../../models/endPointConfiguration.model';
+import { DataGetterTypeEnum } from '../../../../models/baseField.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../../../services/utilityHelper.services";
+import * as i3 from "@angular/common";
+import * as i4 from "../../tmw-image-marker/tmw-image-marker.component";
+/**
+ * Metodo per recuperare, a partire da un Blob, la stringa contenente il base64 del file.
+ * Usato per prendere il base64 dell'immagine dopo che l'utente ci ha disegnato sopra.
+ * @param file Blob che rappresenta l'immagine.
+ */
+const toBase64 = file => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result.toString());
+    reader.onerror = error => reject(error);
+});
+export class ImageWithMarkersFieldTemplateComponent {
+    dialog;
+    utilityHelperService;
+    endPointConfiguration;
+    record;
+    field;
+    inConfig = false;
+    recordChange = new EventEmitter();
+    imageMark = new EventEmitter();
+    imageWidth = 0;
+    MarkingLoaded = false;
+    FileBase64 = "";
+    MarkFileBase64 = "";
+    FileDataBase64 = "";
+    AttachmentID;
+    imageMarkAttachment;
+    extraJSON = null;
+    //preLoadedImageMetadataFormGroup: UntypedFormGroup;
+    //#region Proprietà per configurare il componente ngx-image-Marking e aprire il relativo dialog.
+    width = null;
+    height = null;
+    dialogImageMarkingRef;
+    dialogImageMarking;
+    //#endregion
+    constructor(dialog, utilityHelperService) {
+        this.dialog = dialog;
+        this.utilityHelperService = utilityHelperService;
+    }
+    ngOnInit() {
+        if (this.record[this.field.Name] == null || this.record[this.field.Name] == 0) {
+            this.FileDataBase64 = this.field.DynAttachment.FileDataBase64;
+            this.imageWidth = (this.field.DynAttachment.ResizedImageHeightPx / this.field.DynAttachment.ImageHeightPx * this.field.DynAttachment.ImageWidthPx) + 50;
+            this.record[this.field.Name] = this.field.DynAttachment;
+            this.imageMarkAttachment = JSON.parse(JSON.stringify(this.field.DynAttachment));
+            this.imageMarkAttachment.ID = 0;
+            this.AttachmentID = this.field.DynAttachment.ID;
+        }
+        else {
+            if (typeof this.record[this.field.Name] === 'string') {
+                this.record[this.field.Name] = JSON.parse(this.record[this.field.Name]);
+            }
+            this.imageWidth = (this.field.DynAttachment.ResizedImageHeightPx / this.field.DynAttachment.ImageHeightPx * this.field.DynAttachment.ImageWidthPx) + 50;
+            if (this.record[this.field.Name].FileBases64 != null) {
+                this.FileDataBase64 = this.record[this.field.Name].FileBases64[ImageFolderEnum.Regular];
+            }
+            else {
+                this.FileDataBase64 = this.record[this.field.Name].FileDataBase64;
+            }
+            this.record[this.field.Name].FileDataBase64 = this.FileDataBase64;
+            this.extraJSON = this.record[this.field.Name].ExtraJSON;
+            this.imageMarkAttachment = this.record[this.field.Name];
+            this.imageMarkAttachment.FileDataBase64 = this.FileDataBase64;
+            this.AttachmentID = this.field.DynAttachment.ID;
+        }
+        this.recordChange.emit(this.record);
+        // Clono l'attachment originale, gli cambio il FileBase e gli azzero l'ID
+        // this.imageMarkAttachment.FileName = "";
+        // this.imageMarkAttachment.FilePath = "";
+        this.imageMark.emit(this.imageMarkAttachment);
+        this.updateField();
+    }
+    ngOnChanges(changes) {
+        // Se viene modificato il valore di "ngModelInput" allora aggiorna l'input
+        if (changes['record'] != undefined && changes['record'].firstChange == false && JSON.stringify(changes['record'].currentValue) != JSON.stringify(changes['record'].previousValue)) {
+            this.record = changes['record'].currentValue;
+            this.updateField();
+        }
+    }
+    // updateMetadataValidity() {
+    //   if (this.preLoadedImageMetadataFormGroup.invalid) {
+    //     this.field.FormFormGroup.controls[this.field.Name].setErrors({ 'incorrect': true });
+    //   } else {
+    //     this.field.FormFormGroup.controls[this.field.Name].setErrors(null);
+    //   }
+    //   this.onRecordValueChange();
+    // }
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField() {
+        if ((this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale || this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Formula) && this.field.Formula) {
+            this.record[this.field.Name] = UtilityHelperService.EvaluateFieldFormula(this.field.Formula, this.record, null);
+        }
+        if (this.field.VisibleIf) {
+            this.field.InListView = UtilityHelperService.EvaluateFieldFormula(this.field.VisibleIf, this.record, null);
+        }
+    }
+    resetPreLoadedImage() {
+        this.width = null;
+        this.height = null;
+        /*this.record[this.field.Name] = [JSON.parse(JSON.stringify(this.field.ContextualAttachment))];*/
+        this.getImageDimensions();
+    }
+    /**
+     * Metodo invocato quando vengono aggiunti o eliminati gli allegati nel componente AttachmentFieldTemplate.
+     * Se l'ImageField è abilitato al disegno (EnableMarking == true), non permette allegati multipli (IsMulitAttach == false)
+     * e nel Record corrente è presente l'immagine caricata dall'utente allora recupera le dimensioni dell'immagine e
+     * apre il dialog con il componente image-Marking per permettere il disegno sull'immagine appena caricata.
+     */
+    onAttachmentsChange() {
+        /*
+        if (!this.field.AttachDefinition.IsMultiAttach && this.field.EnableMarking && this.record[this.field.Name] && this.record[this.field.Name][0]) {
+          this.getImageDimensions();
+          this.dialogImageDrowingRef = this.dialog.open(this.dialogImageDrowing, {
+            disableClose: true,
+            hasBackdrop: true,
+            width: '75%'
+          });
+        }
+        */
+    }
+    /**
+     * Metodo invocato al salvataggio dell'immagine dal componente image-Marking.
+     * Trasforma il Blob ricevuto in un base64, aggiorna il FileContetType e il FileDataBase64
+     * dell'allegato caricato e chiude il dialog in cui disegnare.
+     * @param MarknPicture Blob dell'immagine disegnata.
+     */
+    async saveMark(markedImage) {
+        let base64File = await toBase64(markedImage.image);
+        if (base64File) {
+            this.MarkFileBase64 = base64File.split(",")[1];
+            this.FileDataBase64 = this.MarkFileBase64;
+            // Clono l'attachment originale, gli cambio il FileBase e gli azzero l'ID
+            this.imageMarkAttachment.FileDataBase64 = this.MarkFileBase64;
+            this.imageMarkAttachment.ExtraJSON = JSON.stringify(markedImage.outmarkers);
+            this.extraJSON = this.imageMarkAttachment.ExtraJSON;
+            this.imageMark.emit(this.imageMarkAttachment);
+        }
+        if (this.dialogImageMarkingRef) {
+            this.closeDialog();
+        }
+    }
+    /**
+     * Metodo per chiudere il dialog in cui disegnare sull'immagine cariata e svuotare le dimensioni.
+     */
+    closeDialog() {
+        this.dialogImageMarkingRef.close();
+        this.width = null;
+        this.height = null;
+    }
+    /**
+     * Metodo per recuperare le dimensioni dell'immagine caricata per mostrare correttamente
+     * il componente image-Marking. Se non viene eseguito questo passaggio l'area in cui disegnare
+     * è più grande dell'immagine stessa e al salvataggio i tratti disegnati vengono spostati.
+     */
+    getImageDimensions() {
+        var blob = this.getBlobFromBase64();
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            const image = new Image();
+            image.src = e.target.result;
+            image.onload = rs => {
+                this.height = rs.currentTarget['height'];
+                this.width = rs.currentTarget['width'];
+            };
+        };
+        reader.readAsDataURL(blob);
+    }
+    /**
+     * Metodo per convertire il base64 di un'immagine in un Blob.
+     * Necessario per il recupero delle dimensioni dell'immagine caricata a partire dal suo base64.
+     * Viene eseguito solo nel caso in cui l'ImageField non ammette allegati multipli.
+     * @returns Restituisce il Blob dell'immagine caricata.
+     */
+    getBlobFromBase64() {
+        const byteCharacters = atob(this.record[this.field.Name][0].FileDataBase64);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        return new Blob([byteArray], { type: this.record[this.field.Name][0].FileContentType });
+    }
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange() {
+        if (!this.field.Formula) {
+            this.recordChange.emit(this.record);
+        }
+    }
+    openMark() {
+        this.dialogImageMarkingRef = this.dialog.open(this.dialogImageMarking, {
+            disableClose: true,
+            hasBackdrop: true,
+            panelClass: 'image-modal',
+            width: '75%'
+        });
+        if (this.AttachmentID != null && Number(this.AttachmentID) > 0) {
+            this.load(this.AttachmentID, [ImageFolderEnum.Regular]);
+        }
+        else {
+            this.FileBase64 = this.FileDataBase64;
+            this.MarkingLoaded = true;
+        }
+    }
+    load(ID, Types) {
+        this.MarkingLoaded = false;
+        // preparo la versione corretta del form
+        var dynamicModuleParams = [
+            {
+                ParamName: "AttachmentID",
+                ParamValue: ID,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+            {
+                ParamName: "Types",
+                ParamValue: Types,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+        ];
+        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Forms.GetAttachmentWithBases64, dynamicModuleParams, (res) => {
+            this.FileBase64 = res.FileBases64[ImageFolderEnum.Regular];
+            this.MarkingLoaded = true;
+        }, (err) => {
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageWithMarkersFieldTemplateComponent, deps: [{ token: i1.MatDialog }, { token: i2.UtilityHelperService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ImageWithMarkersFieldTemplateComponent, selector: "image-with-markers-field-template", inputs: { endPointConfiguration: "endPointConfiguration", record: "record", field: "field", inConfig: "inConfig" }, outputs: { recordChange: "recordChange", imageMark: "imageMark" }, viewQueries: [{ propertyName: "dialogImageMarking", first: true, predicate: ["dialogImageMarking"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"row imageContainer\" style=\"width: {{imageWidth}}px;\">\r\n    <div class=\"row\">\r\n         <div class=\"col-12\">{{field.Description}}</div>\r\n         <div class=\"col-12\"><img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{FileDataBase64}}\"\r\n              [height]=\"field.DynAttachment.ResizedImageHeightPx != null ? field.DynAttachment.ResizedImageHeightPx : 128\"\r\n              class=\"singleImage\"></div>\r\n              <div class=\"col-12 drawButton\">\r\n                   <button class=\"btn btn-primary btn-w100\" (click)=\"openMark()\">Marca</button>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonkey\" *ngIf=\"field.DynAttachment.ButtonKey != null && field.DynAttachment.ButtonKey != ''\">\r\n                   <div>Etichetta</div><div>{{field.DynAttachment.ButtonKey}}</div>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonvalue\" *ngIf=\"field.DynAttachment.ButtonValue != null && field.DynAttachment.ButtonValue != ''\"> \r\n                   <div>Valore</div><div>{{field.DynAttachment.ButtonValue}}</div>\r\n              </div>\r\n    </div>   \r\n</div>\r\n\r\n<!-- DIALOG PER DISEGNARE SUL NUOVO ALLEGATO CARICATO -->\r\n<ng-template #dialogImageMarking>\r\n    <div class=\"padder\">\r\n         <div\r\n              class=\"row\">\r\n              <div class=\"col-sm-12 col-md-12\">\r\n                   <tmw-image-marker\r\n                   *ngIf=\"MarkingLoaded\"\r\n                   [src]=\"'data:'+ field.DynAttachment.FileContentType + ';base64,'+ FileBase64\" [inConfig]=\"inConfig\" [savedMarkers]=\"extraJSON\"\r\n                   [width]=\"field.DynAttachment.ImageWidthPx\" [height]=\"field.DynAttachment.ImageHeightPx\" \r\n                   (save)=\"saveMark($event)\" (closeDialog)=\"closeDialog()\">\r\n                   </tmw-image-marker>\r\n              </div>\r\n         </div>\r\n    </div>\r\n</ng-template>", styles: ["::ng-deep image-drawing>button{background-color:var(--primary)!important;color:#fff!important}.imageContainer .singleImage{margin-top:5px;display:block}.drawButton{margin:5px 0}.buttonkey{border-top:1px solid black;padding-top:10px}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.TmwImageMarkerComponent, selector: "tmw-image-marker", inputs: ["src", "width", "height", "inConfig", "savedMarkers", "outputMimeType", "outputQuality", "forceSizeCanvas"], outputs: ["closeDialog", "save"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageWithMarkersFieldTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'image-with-markers-field-template', template: "<div class=\"row imageContainer\" style=\"width: {{imageWidth}}px;\">\r\n    <div class=\"row\">\r\n         <div class=\"col-12\">{{field.Description}}</div>\r\n         <div class=\"col-12\"><img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{FileDataBase64}}\"\r\n              [height]=\"field.DynAttachment.ResizedImageHeightPx != null ? field.DynAttachment.ResizedImageHeightPx : 128\"\r\n              class=\"singleImage\"></div>\r\n              <div class=\"col-12 drawButton\">\r\n                   <button class=\"btn btn-primary btn-w100\" (click)=\"openMark()\">Marca</button>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonkey\" *ngIf=\"field.DynAttachment.ButtonKey != null && field.DynAttachment.ButtonKey != ''\">\r\n                   <div>Etichetta</div><div>{{field.DynAttachment.ButtonKey}}</div>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonvalue\" *ngIf=\"field.DynAttachment.ButtonValue != null && field.DynAttachment.ButtonValue != ''\"> \r\n                   <div>Valore</div><div>{{field.DynAttachment.ButtonValue}}</div>\r\n              </div>\r\n    </div>   \r\n</div>\r\n\r\n<!-- DIALOG PER DISEGNARE SUL NUOVO ALLEGATO CARICATO -->\r\n<ng-template #dialogImageMarking>\r\n    <div class=\"padder\">\r\n         <div\r\n              class=\"row\">\r\n              <div class=\"col-sm-12 col-md-12\">\r\n                   <tmw-image-marker\r\n                   *ngIf=\"MarkingLoaded\"\r\n                   [src]=\"'data:'+ field.DynAttachment.FileContentType + ';base64,'+ FileBase64\" [inConfig]=\"inConfig\" [savedMarkers]=\"extraJSON\"\r\n                   [width]=\"field.DynAttachment.ImageWidthPx\" [height]=\"field.DynAttachment.ImageHeightPx\" \r\n                   (save)=\"saveMark($event)\" (closeDialog)=\"closeDialog()\">\r\n                   </tmw-image-marker>\r\n              </div>\r\n         </div>\r\n    </div>\r\n</ng-template>", styles: ["::ng-deep image-drawing>button{background-color:var(--primary)!important;color:#fff!important}.imageContainer .singleImage{margin-top:5px;display:block}.drawButton{margin:5px 0}.buttonkey{border-top:1px solid black;padding-top:10px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }, { type: i2.UtilityHelperService }], propDecorators: { endPointConfiguration: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], inConfig: [{
+                type: Input
+            }], recordChange: [{
+                type: Output
+            }], imageMark: [{
+                type: Output
+            }], dialogImageMarking: [{
+                type: ViewChild,
+                args: ["dialogImageMarking", { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-with-markers-field-template.component.js","sourceRoot":"","sources":["../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/field-templates/image-with-markers-field-template/image-with-markers-field-template.component.ts","../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/field-templates/image-with-markers-field-template/image-with-markers-field-template.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges, TemplateRef, ViewChild } from '@angular/core';\r\nimport { ImageField, ImageFolderEnum } from '../../../../models/fields/imageField.model';\r\nimport { Record } from '../../../../models/record.model';\r\nimport { UtilityHelperService } from '../../../../services/utilityHelper.services';\r\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\r\nimport { EndPointConfiguration, ParamTypeEnum } from '../../../../models/endPointConfiguration.model';\r\nimport { DynAttachment } from '../../../../models/dynAttachment';\r\nimport { MarkedImage } from '../../tmw-image-marker/tmw-image-marker.component';\r\nimport { ImageWithMarkersField } from '../../../../models/fields/imageWithMarkersField.model';\r\nimport { DataGetterTypeEnum } from '../../../../models/baseField.model';\r\n\r\n/**\r\n * Metodo per recuperare, a partire da un Blob, la stringa contenente il base64 del file.\r\n * Usato per prendere il base64 dell'immagine dopo che l'utente ci ha disegnato sopra.\r\n * @param file Blob che rappresenta l'immagine.\r\n */\r\nconst toBase64 = file => new Promise<string>((resolve, reject) => {\r\n  const reader = new FileReader();\r\n  reader.readAsDataURL(file);\r\n  reader.onload = () => resolve(reader.result.toString());\r\n  reader.onerror = error => reject(error);\r\n});\r\n\r\n@Component({\r\n  selector: 'image-with-markers-field-template',\r\n  templateUrl: './image-with-markers-field-template.component.html',\r\n  styleUrls: ['./image-with-markers-field-template.component.scss']\r\n})\r\n\r\nexport class ImageWithMarkersFieldTemplateComponent {\r\n\r\n  @Input() endPointConfiguration: EndPointConfiguration;\r\n  @Input() record: Record;\r\n  @Input() field: ImageWithMarkersField;\r\n  @Input() inConfig: boolean = false;\r\n  @Output() recordChange: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() imageMark: EventEmitter<DynAttachment> = new EventEmitter<DynAttachment>();\r\n\r\n  imageWidth: number = 0;\r\n  MarkingLoaded: boolean = false;\r\n  FileBase64: string = \"\";\r\n  MarkFileBase64: string = \"\";\r\n  FileDataBase64: string = \"\";\r\n\r\n  AttachmentID: string | number;\r\n\r\n  imageMarkAttachment: DynAttachment;\r\n  extraJSON: string = null;\r\n  \r\n\r\n  //preLoadedImageMetadataFormGroup: UntypedFormGroup;\r\n\r\n  //#region Proprietà per configurare il componente ngx-image-Marking e aprire il relativo dialog.\r\n  public width = null;\r\n  public height = null;\r\n\r\n  dialogImageMarkingRef: MatDialogRef<TemplateRef<any>>;\r\n  @ViewChild(\"dialogImageMarking\", { static: true }) dialogImageMarking: TemplateRef<any>;\r\n  //#endregion\r\n\r\n  constructor(\r\n    private dialog: MatDialog,\r\n    private utilityHelperService: UtilityHelperService\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n\r\n    if (this.record[this.field.Name] == null || this.record[this.field.Name] == 0){\r\n      this.FileDataBase64 = this.field.DynAttachment.FileDataBase64;\r\n      this.imageWidth =  (this.field.DynAttachment.ResizedImageHeightPx / this.field.DynAttachment.ImageHeightPx * this.field.DynAttachment.ImageWidthPx) + 50;\r\n      this.record[this.field.Name] = this.field.DynAttachment;\r\n\r\n      this.imageMarkAttachment = JSON.parse(JSON.stringify(this.field.DynAttachment));\r\n      this.imageMarkAttachment.ID = 0;\r\n\r\n      this.AttachmentID = this.field.DynAttachment.ID; \r\n\r\n    } else {\r\n      if (typeof this.record[this.field.Name] === 'string'){\r\n        this.record[this.field.Name] = JSON.parse(this.record[this.field.Name]);\r\n      }\r\n      this.imageWidth =  (this.field.DynAttachment.ResizedImageHeightPx / this.field.DynAttachment.ImageHeightPx * this.field.DynAttachment.ImageWidthPx) + 50;\r\n\r\n      if ((this.record[this.field.Name] as DynAttachment).FileBases64 != null){\r\n        this.FileDataBase64 = (this.record[this.field.Name] as DynAttachment).FileBases64[ImageFolderEnum.Regular];\r\n      } else {\r\n        this.FileDataBase64 = (this.record[this.field.Name] as DynAttachment).FileDataBase64;\r\n      }      \r\n\r\n      (this.record[this.field.Name] as DynAttachment).FileDataBase64 = this.FileDataBase64;\r\n      this.extraJSON = (this.record[this.field.Name] as DynAttachment).ExtraJSON;\r\n\r\n      this.imageMarkAttachment = this.record[this.field.Name];\r\n      this.imageMarkAttachment.FileDataBase64 = this.FileDataBase64;\r\n\r\n      this.AttachmentID = this.field.DynAttachment.ID;\r\n    }\r\n\r\n    this.recordChange.emit(this.record);\r\n\r\n\r\n    // Clono l'attachment originale, gli cambio il FileBase e gli azzero l'ID\r\n\r\n    // this.imageMarkAttachment.FileName = \"\";\r\n    // this.imageMarkAttachment.FilePath = \"\";\r\n\r\n    this.imageMark.emit(this.imageMarkAttachment);\r\n\r\n\r\n\r\n\r\n\r\n    this.updateField();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    // Se viene modificato il valore di \"ngModelInput\" allora aggiorna l'input\r\n    if (changes['record'] != undefined && changes['record'].firstChange == false && JSON.stringify(changes['record'].currentValue) != JSON.stringify(changes['record'].previousValue)) {\r\n      this.record = changes['record'].currentValue;\r\n      this.updateField();\r\n    }\r\n  }\r\n\r\n\r\n  // updateMetadataValidity() {\r\n  //   if (this.preLoadedImageMetadataFormGroup.invalid) {\r\n  //     this.field.FormFormGroup.controls[this.field.Name].setErrors({ 'incorrect': true });\r\n  //   } else {\r\n  //     this.field.FormFormGroup.controls[this.field.Name].setErrors(null);\r\n  //   }\r\n  //   this.onRecordValueChange();\r\n  // }\r\n\r\n\r\n  /**\r\n   * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.\r\n   */\r\n  updateField() {\r\n    if ((this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale || this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Formula) && this.field.Formula) {\r\n      this.record[this.field.Name] = UtilityHelperService.EvaluateFieldFormula(this.field.Formula, this.record, null);\r\n    }\r\n    if (this.field.VisibleIf) {\r\n      this.field.InListView = UtilityHelperService.EvaluateFieldFormula(this.field.VisibleIf, this.record, null);\r\n    }\r\n  }\r\n\r\n\r\n  resetPreLoadedImage() {\r\n    this.width = null;\r\n    this.height = null;\r\n    /*this.record[this.field.Name] = [JSON.parse(JSON.stringify(this.field.ContextualAttachment))];*/\r\n    this.getImageDimensions();\r\n  }\r\n\r\n  /**\r\n   * Metodo invocato quando vengono aggiunti o eliminati gli allegati nel componente AttachmentFieldTemplate.\r\n   * Se l'ImageField è abilitato al disegno (EnableMarking == true), non permette allegati multipli (IsMulitAttach == false)\r\n   * e nel Record corrente è presente l'immagine caricata dall'utente allora recupera le dimensioni dell'immagine e\r\n   * apre il dialog con il componente image-Marking per permettere il disegno sull'immagine appena caricata.\r\n   */\r\n  onAttachmentsChange() {\r\n    /*\r\n    if (!this.field.AttachDefinition.IsMultiAttach && this.field.EnableMarking && this.record[this.field.Name] && this.record[this.field.Name][0]) {\r\n      this.getImageDimensions();\r\n      this.dialogImageDrowingRef = this.dialog.open(this.dialogImageDrowing, {\r\n        disableClose: true,\r\n        hasBackdrop: true,\r\n        width: '75%'\r\n      });\r\n    }\r\n    */\r\n  }\r\n\r\n  /**\r\n   * Metodo invocato al salvataggio dell'immagine dal componente image-Marking.\r\n   * Trasforma il Blob ricevuto in un base64, aggiorna il FileContetType e il FileDataBase64\r\n   * dell'allegato caricato e chiude il dialog in cui disegnare.\r\n   * @param MarknPicture Blob dell'immagine disegnata.\r\n   */\r\n  async saveMark(markedImage: MarkedImage) {\r\n    let base64File = await toBase64(markedImage.image);\r\n    if (base64File) {\r\n      this.MarkFileBase64 = base64File.split(\",\")[1];\r\n      this.FileDataBase64 = this.MarkFileBase64;\r\n\r\n      // Clono l'attachment originale, gli cambio il FileBase e gli azzero l'ID\r\n      this.imageMarkAttachment.FileDataBase64 = this.MarkFileBase64;\r\n      this.imageMarkAttachment.ExtraJSON = JSON.stringify(markedImage.outmarkers);\r\n      this.extraJSON = this.imageMarkAttachment.ExtraJSON;\r\n\r\n      this.imageMark.emit(this.imageMarkAttachment);\r\n\r\n    }\r\n\r\n    if (this.dialogImageMarkingRef) {\r\n      this.closeDialog();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per chiudere il dialog in cui disegnare sull'immagine cariata e svuotare le dimensioni.\r\n   */\r\n  closeDialog() {\r\n    this.dialogImageMarkingRef.close();\r\n    this.width = null;\r\n    this.height = null;\r\n  }\r\n\r\n  /**\r\n   * Metodo per recuperare le dimensioni dell'immagine caricata per mostrare correttamente\r\n   * il componente image-Marking. Se non viene eseguito questo passaggio l'area in cui disegnare \r\n   * è più grande dell'immagine stessa e al salvataggio i tratti disegnati vengono spostati. \r\n   */\r\n  private getImageDimensions() {\r\n    var blob: Blob = this.getBlobFromBase64();\r\n    const reader = new FileReader();\r\n    reader.onload = (e: any) => {\r\n      const image = new Image();\r\n      image.src = e.target.result;\r\n      image.onload = rs => {\r\n        this.height = rs.currentTarget['height'];\r\n        this.width = rs.currentTarget['width'];\r\n      };\r\n    };\r\n    reader.readAsDataURL(blob);\r\n  }\r\n\r\n  /**\r\n   * Metodo per convertire il base64 di un'immagine in un Blob.\r\n   * Necessario per il recupero delle dimensioni dell'immagine caricata a partire dal suo base64.\r\n   * Viene eseguito solo nel caso in cui l'ImageField non ammette allegati multipli.\r\n   * @returns Restituisce il Blob dell'immagine caricata.\r\n   */\r\n  private getBlobFromBase64() {\r\n    const byteCharacters = atob(this.record[this.field.Name][0].FileDataBase64);\r\n    const byteNumbers = new Array(byteCharacters.length);\r\n    for (let i = 0; i < byteCharacters.length; i++) {\r\n      byteNumbers[i] = byteCharacters.charCodeAt(i);\r\n    }\r\n    const byteArray = new Uint8Array(byteNumbers);\r\n    return new Blob([byteArray], { type: this.record[this.field.Name][0].FileContentType });\r\n  }\r\n\r\n  /**\r\n   * Metodo per emettere l'evento che il valore del record è cambiato.\r\n   */\r\n  private onRecordValueChange() {\r\n    if (!this.field.Formula) {\r\n      this.recordChange.emit(this.record);\r\n    }\r\n  }\r\n\r\n  public openMark(){\r\n    this.dialogImageMarkingRef = this.dialog.open(this.dialogImageMarking, {\r\n      disableClose: true,\r\n      hasBackdrop: true,\r\n      panelClass: 'image-modal',\r\n      width: '75%'\r\n    });\r\n\r\n    if (this.AttachmentID != null && Number(this.AttachmentID) > 0){\r\n      this.load(this.AttachmentID,[ImageFolderEnum.Regular]);\r\n    } else {\r\n      this.FileBase64 = this.FileDataBase64;\r\n      this.MarkingLoaded = true;\r\n    }\r\n\r\n  }\r\n\r\n  load(ID,Types){\r\n\r\n    this.MarkingLoaded = false;\r\n\r\n      // preparo la versione corretta del form\r\n      var dynamicModuleParams = [\r\n        {\r\n          ParamName: \"AttachmentID\",\r\n          ParamValue: ID,\r\n          ParamType: ParamTypeEnum[\"Query param\"],\r\n        },\r\n        {\r\n          ParamName: \"Types\",\r\n          ParamValue: Types,\r\n          ParamType: ParamTypeEnum[\"Query param\"],\r\n        },\r\n      ];    \r\n      \r\n    this.utilityHelperService.RunEndPointCall(\r\n      this.endPointConfiguration.Forms.GetAttachmentWithBases64,\r\n      dynamicModuleParams,\r\n      (res: DynAttachment) => {\r\n\r\n        this.FileBase64 = res.FileBases64[ImageFolderEnum.Regular];\r\n        this.MarkingLoaded = true;\r\n\r\n      },\r\n      (err) => {\r\n\r\n      }\r\n    );    \r\n  }\r\n\r\n}\r\n","<div class=\"row imageContainer\" style=\"width: {{imageWidth}}px;\">\r\n    <div class=\"row\">\r\n         <div class=\"col-12\">{{field.Description}}</div>\r\n         <div class=\"col-12\"><img *ngIf=\"field.DynAttachment\"\r\n              src=\"data:{{field.DynAttachment.FileContentType}};base64,{{FileDataBase64}}\"\r\n              [height]=\"field.DynAttachment.ResizedImageHeightPx != null ? field.DynAttachment.ResizedImageHeightPx : 128\"\r\n              class=\"singleImage\"></div>\r\n              <div class=\"col-12 drawButton\">\r\n                   <button class=\"btn btn-primary btn-w100\" (click)=\"openMark()\">Marca</button>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonkey\" *ngIf=\"field.DynAttachment.ButtonKey != null && field.DynAttachment.ButtonKey != ''\">\r\n                   <div>Etichetta</div><div>{{field.DynAttachment.ButtonKey}}</div>\r\n              </div>\r\n              <div class=\"col-12 flex justify-content-around buttonvalue\" *ngIf=\"field.DynAttachment.ButtonValue != null && field.DynAttachment.ButtonValue != ''\"> \r\n                   <div>Valore</div><div>{{field.DynAttachment.ButtonValue}}</div>\r\n              </div>\r\n    </div>   \r\n</div>\r\n\r\n<!-- DIALOG PER DISEGNARE SUL NUOVO ALLEGATO CARICATO -->\r\n<ng-template #dialogImageMarking>\r\n    <div class=\"padder\">\r\n         <div\r\n              class=\"row\">\r\n              <div class=\"col-sm-12 col-md-12\">\r\n                   <tmw-image-marker\r\n                   *ngIf=\"MarkingLoaded\"\r\n                   [src]=\"'data:'+ field.DynAttachment.FileContentType + ';base64,'+ FileBase64\" [inConfig]=\"inConfig\" [savedMarkers]=\"extraJSON\"\r\n                   [width]=\"field.DynAttachment.ImageWidthPx\" [height]=\"field.DynAttachment.ImageHeightPx\" \r\n                   (save)=\"saveMark($event)\" (closeDialog)=\"closeDialog()\">\r\n                   </tmw-image-marker>\r\n              </div>\r\n         </div>\r\n    </div>\r\n</ng-template>"]}

package/esm2022/lib/components/private/field-templates/label-field-template/label-field-template.component.mjs

@@ -0,0 +1,82 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { UtilityHelperService } from '../../../../services/utilityHelper.services';
+import { interval } from 'rxjs';
+import { DataGetterTypeEnum } from '../../../../models/baseField.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class LabelFieldTemplateComponent {
+    //Variabili per l'input vocale
+    isStillRecoginze = false;
+    source = interval(200);
+    newtext;
+    subscription;
+    //variabili esterne per l'input dei campi
+    field;
+    record;
+    inConfig = false;
+    STT = true;
+    //variabili per gestire il css della label e del field
+    FieldstyleObj;
+    LabelstyleObj;
+    recordChange = new EventEmitter();
+    constructor() {
+    }
+    ngOnInit() {
+        this.updateField();
+        this.initStyles();
+    }
+    initStyles() {
+        //Funzione per parsare il campo stylecss dell'oggetto field ed applicarlo all'html
+        if (this.field.FieldstyleCSS != null || this.field.FieldstyleCSS != undefined)
+            this.FieldstyleObj = UtilityHelperService.initStyles(this.field.FieldstyleCSS);
+        if (this.field.LabelstyleCSS != null || this.field.LabelstyleCSS != undefined)
+            this.LabelstyleObj = UtilityHelperService.initStyles(this.field.LabelstyleCSS);
+    }
+    ngOnChanges(changes) {
+        // Se viene modificato il valore di "ngModelInput" allora aggiorna l'input
+        if (changes['record'] != undefined && changes['record'].firstChange == false && JSON.stringify(changes['record'].currentValue) != JSON.stringify(changes['record'].previousValue)) {
+            this.record = changes['record'].currentValue;
+            this.updateField();
+        }
+    }
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField() {
+        if ((this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale || this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Formula) && this.field.Formula) {
+            this.record[this.field.Name] = UtilityHelperService.EvaluateFieldFormula(this.field.Formula, this.record, null);
+        }
+        if (this.field.VisibleIf) {
+            this.field.InListView = UtilityHelperService.EvaluateFieldFormula(this.field.VisibleIf, this.record, null);
+        }
+        if (this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale && this.record[this.field.Name] == null) {
+            this.record[this.field.Name] = this.field.DataGetter.DataGetterValue;
+        }
+    }
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange() {
+        if (!this.field.Formula) {
+            this.recordChange.emit(this.record);
+        }
+        if (!this.field.VisibleIf) {
+            this.recordChange.emit(this.record);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LabelFieldTemplateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LabelFieldTemplateComponent, selector: "label-field-template", inputs: { field: "field", record: "record", inConfig: "inConfig" }, outputs: { recordChange: "recordChange" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"dm-etichetta\" [ngStyle]=\"LabelstyleObj\" [innerHTML]=\"field.Etichetta\"></div>", styles: ["::ng-deep .mat-form-field-label{font-size:x-large}.dm-etichetta{margin-top:18px}\n"], dependencies: [{ kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LabelFieldTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'label-field-template', template: "<div class=\"dm-etichetta\" [ngStyle]=\"LabelstyleObj\" [innerHTML]=\"field.Etichetta\"></div>", styles: ["::ng-deep .mat-form-field-label{font-size:x-large}.dm-etichetta{margin-top:18px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], inConfig: [{
+                type: Input
+            }], recordChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"label-field-template.component.js","sourceRoot":"","sources":["../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/field-templates/label-field-template/label-field-template.component.ts","../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/field-templates/label-field-template/label-field-template.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\r\nimport { Record } from '../../../../models/record.model';\r\nimport { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';\r\nimport { UtilityHelperService } from '../../../../services/utilityHelper.services';\r\nimport { interval, Subscription } from 'rxjs';\r\nimport { LabelField } from '../../../../models/fields/labelField.model';\r\nimport { DataGetterTypeEnum } from '../../../../models/baseField.model';\r\n\r\n@Component({\r\n  selector: 'label-field-template',\r\n  templateUrl: './label-field-template.component.html',\r\n  styleUrls: ['./label-field-template.component.scss']\r\n})\r\nexport class LabelFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {\r\n  //Variabili per l'input vocale\r\n  isStillRecoginze = false;\r\n  source = interval(200);\r\n  newtext: string;\r\n  subscription: Subscription;\r\n  //variabili esterne per l'input dei campi\r\n  @Input() field: LabelField;\r\n  @Input() record: Record;\r\n  @Input() inConfig: boolean = false;\r\n  STT:boolean =true;\r\n  //variabili per gestire il css della label e del field\r\n  FieldstyleObj: any;\r\n  LabelstyleObj: any;\r\n\r\n  @Output() recordChange: EventEmitter<Record> = new EventEmitter<Record>();\r\n\r\n\r\n  constructor() {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.updateField();\r\n    this.initStyles();\r\n  }\r\n  initStyles() {\r\n      //Funzione per parsare il campo stylecss dell'oggetto field ed applicarlo all'html\r\n    if(this.field.FieldstyleCSS != null || this.field.FieldstyleCSS != undefined)   \r\n      this.FieldstyleObj= UtilityHelperService.initStyles(this.field.FieldstyleCSS);\r\n    if(this.field.LabelstyleCSS != null || this.field.LabelstyleCSS != undefined)   \r\n      this.LabelstyleObj = UtilityHelperService.initStyles(this.field.LabelstyleCSS);\r\n }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    // Se viene modificato il valore di \"ngModelInput\" allora aggiorna l'input\r\n    if (changes['record'] != undefined && changes['record'].firstChange == false && JSON.stringify(changes['record'].currentValue) != JSON.stringify(changes['record'].previousValue)) {\r\n      this.record = changes['record'].currentValue;\r\n      this.updateField();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.\r\n   */\r\n  updateField() {\r\n    if ((this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale || this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Formula) && this.field.Formula) {\r\n      this.record[this.field.Name] = UtilityHelperService.EvaluateFieldFormula(this.field.Formula, this.record, null);\r\n    }\r\n    if (this.field.VisibleIf) {\r\n      this.field.InListView = UtilityHelperService.EvaluateFieldFormula(this.field.VisibleIf, this.record, null);\r\n    }\r\n    if (this.field.DataGetter.DataGetterType == DataGetterTypeEnum.Manuale && this.record[this.field.Name] == null) {\r\n      this.record[this.field.Name] = this.field.DataGetter.DataGetterValue;\r\n    }   \r\n  }\r\n\r\n  /**\r\n   * Metodo per emettere l'evento che il valore del record è cambiato.\r\n   */\r\n  onRecordValueChange() {\r\n    if (!this.field.Formula) {\r\n      this.recordChange.emit(this.record);\r\n    }\r\n    if (!this.field.VisibleIf) {\r\n      this.recordChange.emit(this.record);\r\n    }\r\n  }\r\n}\r\n","<div class=\"dm-etichetta\" [ngStyle]=\"LabelstyleObj\" [innerHTML]=\"field.Etichetta\"></div>"]}