@eqproject/eqp-attachments 2.5.0 → 2.5.1

package/esm2020/lib/eqp-attachments.component.mjs

@@ -0,0 +1,1064 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from "@angular/core";
+import { Validators } from "@angular/forms";
+import { TooltipPositionType, TypeColumn } from "@eqproject/eqp-table";
+import imageCompression from "browser-image-compression";
+import { base64ToFile, ImageCropperComponent } from "ngx-image-cropper";
+import { AttachmentHelperService } from "./helpers/attachment.helper";
+import { AttachmentType } from "./interfaces/IAttachment";
+import { EqpAttachmentDialogService } from "./services/eqp-attachment-dialog.service";
+import { concatMap, from, Observable } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/common/http";
+import * as i5 from "./services/eqp-attachment.service";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/material/form-field";
+import * as i9 from "@angular/material/menu";
+import * as i10 from "@angular/material/card";
+import * as i11 from "@angular/material/icon";
+import * as i12 from "@angular/material/tooltip";
+import * as i13 from "@angular/common";
+import * as i14 from "ngx-image-cropper";
+import * as i15 from "@eqproject/eqp-table";
+import * as i16 from "ngx-file-drop";
+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 EqpAttachmentsComponent {
+    constructor(dialog, formBuilder, sanitizer, http, cd, eqpAttachmentService) {
+        this.dialog = dialog;
+        this.formBuilder = formBuilder;
+        this.sanitizer = sanitizer;
+        this.http = http;
+        this.cd = cd;
+        this.eqpAttachmentService = eqpAttachmentService;
+        //#region @Input del componente
+        /**
+         * Se TRUE allora nasconde la colonna per le azioni sull'allegato (nel caso "multipleAttachment" è TRUE).
+         */
+        this.disableAction = false;
+        /**
+         * Se TRUE mostra il titolo nell'header nel caso in cui "multipleAttachment" è TRUE ("Elenco allegati" di default).
+         */
+        this.showHeader = true;
+        /**
+         * Titolo da visualizzare se il parametro "showHeader" è TRUE. Di devault viene visualizzato "Elenco allegati".
+         */
+        this.headerTitle = "Elenco allegati";
+        /**
+         * Sorgente dati da visualizzare. Nel caso si vuole gestire un singolo allegato va passato in ogni caso come Array.
+         */
+        this.attachmentsList = null;
+        /**
+         * Se TRUE non mostra la MatCard (nel caso in cui "multipleAttachment" è TRUE).
+         */
+        this.showMatCard = true;
+        /**
+         * Se FALSE allora il componente mostra solo il pulsante di caricamento di un singolo file, una volta caricato il file invoca l'evento di output "localEditedAttachments".
+         * Se TRUE allora il componente mostra l'elenco di tutti gli allegati ricevuto nel parametro "attachmentsList".
+         */
+        this.multipleAttachment = true;
+        /**
+         * Se assume il valore TRUE allora sarà possibile caricare più file per volta. Questa funzionalità è attiva
+         * SOLO se si gestiscono allegati multipli, quindi se l'input 'multipleAttachment' assume il valore TRUE, altrimenti è sempre disabilitata.
+         */
+        this.loadMultipleFiles = false;
+        /**
+         * Configurazione delle colonne della eqp-table per la visualizzazione degli allegati (caso "multipleAttachment" è TRUE).
+         */
+        this.attachmentsColumns = null;
+        /**
+         * Imposta il messaggio da visualizzare nel caso in cui la tabella degli allegati (nel caso in cui "multipleAttachment" è TRUE) è vuota.
+         */
+        this.emptyTableMessage = "Nessun dato trovato";
+        /**
+         * Se TRUE allora permette di selezionare soltanto file di tipo immagine, avente uno dei mimetype
+         * specificati dentro AttachmentHelperService.
+         * Se FALSE permette di selezionare qualsiasi tipo di file
+         */
+        this.allowOnlyImages = false;
+        /**
+         * Se TRUE disabilita il pulsante di Aggiunta allegato (a prescindere dal valore del parametro "multipleAttachment").
+         */
+        this.isDisabled = false;
+        /**
+         * Mostra/nasconde la colonna per visualizzare l'anteprima dei file nella tabella (caso multipleAtatchments = true).
+         */
+        this.showInlinePreview = false;
+        /**
+         * Endpoint da chiamare per recueprare l'IAttachmentDTO completo da vedere nell'anteprima. La chiamata sarà in POST e nel body
+         * conterrà l'IAttachmentDTO selezionato dall'utente.
+         * La chiamata viene eseguita solo per l'anteprima delle immagini essendo necessario il base64 completo dell'immagine a dimensione reale.
+         * Per documenti/link basta che sia popolata la proprietà FilePath di IAttachmentDTO.
+         */
+        this.getAttachmentEndpoint = null;
+        /**
+         * Hostname dell'ambiente di produzione dell'applicativo. Necessario per visualizzare l'anteprima dei documenti
+         * tramite il viewer di google.
+         * NOTA: Per visualizzare l'anteprima è necessario che la prorietà FilePath dell'IAttachmentDTO sia popolata e che
+         * sia abilitato l'accesso alla cartella sul server tramite hostname.
+         */
+        this.productionBaseUrl = null;
+        /**
+         * Opzioni per la compressione delle immagini caricate.
+         */
+        this.compressionOptions = {
+            maxSizeMB: 0.5,
+            maxWidthOrHeight: 1920,
+            useWebWorker: true
+        };
+        /**
+         * Array di AttachmentType che si possono aggiungere
+         */
+        this.allowedTypes = [AttachmentType.FILE, AttachmentType.LINK];
+        /**
+         * Permette di stabilire se la eqp-table contenente l'elenco degli allegati utilizza
+         * il multilingua oppure no
+         */
+        this.isEqpTableMultiLanguage = false;
+        /**
+         * Permette di stabilire, in caso di gestione allegati multipli, se la tabella contenente l'elenco
+         * degli allegati deve essere paginata oppure no
+         */
+        this.tablePaginatorVisible = true;
+        /**
+         * Permette di stabilire, in caso di gestione allegati multipli, se la tabella contenente l'elenco
+         * degli allegati deve contenere il campo di ricerca oppure no
+         */
+        this.isTableSearcheable = true;
+        /**
+         * In caso di gestione allegati multipli, permette di stabilire la dimensione pagina di default
+         * per la tabella contenente l'elenco degli allegati
+         */
+        this.tablePaginatorSize = null;
+        /**
+         * Permette di scegliere il modo in cui i file devono essere caricati
+         */
+        // @Input("uploadType") uploadType: UploadTypeEnum = UploadTypeEnum.FILE_AND_LINK;
+        /**
+         * Permette di stabilire se i pulsanti per il caricamento dei file sono separati o in un menù a tendina
+         */
+        this.separatedUploadButtons = false;
+        /**
+         * Permette di scegliere se dare la possibilità di vedere o no l'anteprima
+         */
+        this.showPreview = true;
+        /**
+         * In caso di allegato singolo, permette di scegliere se aggiungere file tramite drag and drop
+         */
+        this.singleAttachmentDragAndDrop = false;
+        /**
+         * Array di opzioni che si possono utilizzare per il crop
+         */
+        this.cropOptions = [];
+        /**
+         * Input per definire le label da usare nel componente
+         */
+        this.downloadTooltipPosition = TooltipPositionType.Below;
+        this.openLinkLabel = "Apri link";
+        this.addButtonLabel = "Aggiungi";
+        this.downloadLabel = "Download";
+        this.deleteLabel = "Elimina";
+        this.fileNameLabel = "Nome file";
+        this.previewLabel = "Anteprima";
+        this.uploadFileLabel = "Carica file";
+        this.confirmLabel = "Conferma";
+        this.abortLabel = "Annulla";
+        this.saveLabel = "Salva";
+        this.exitLabel = "Esci";
+        this.uploadWithDropboxLabel = "Carica con Dropbox";
+        this.cropLabel = "Scegli le dimensioni dell'immagine";
+        this.eqpTableSearchText = "Cerca";
+        this.deleteDialogTitle = null;
+        this.deleteDialogMessage = "Sei sicuro di voler cancellare quest'allegato?";
+        this.noImageSelectedErrorMessage = "Non è possibile selezionare un file che non sia un'immagine.";
+        this.wrongTypeSelectedErrorMessage = "Non è possibile caricare il file selezionato.";
+        this.videoPreviewErrorMessage = "Impossibile aprire l'anteprima di un file video.";
+        this.audioPreviewErrorMessage = "Impossibile aprire l'anteprima di un file audio.";
+        this.flipHorinzontalLabel = "Capovolgi orizzontalmente";
+        this.flipVerticalLabel = "Capovolgi verticalmente";
+        this.rotateRightLabel = "Ruota a destra";
+        this.rotateLeftLabel = "Ruota a sinistra";
+        //#endregion
+        //#region @Output del componente
+        /**
+         * Restituisce la lista aggiornata degli allegati.
+         */
+        this.localEditedAttachments = new EventEmitter();
+        /**
+         * Evento scatenato alla pressione del pulsante ESCI della modale di caricamento file.
+         */
+        this.abortAddAttachment = new EventEmitter();
+        /**
+         * Evento di output che restituisce l'IAttachmentDTO selezionato per il download nel caso FileDataBase64, FileContentType o FileName non fossero specificati.
+         */
+        this.downloadAttachment = new EventEmitter();
+        /**
+         * Evento di output che restituisce l'elemento eliminato prima che questo venga effettivamente rismosso dalla lista.
+         */
+        this.onDeleteAttachment = new EventEmitter();
+        //#endregion
+        //#region Proprietà per gestione caricamento nuovo allegato
+        this.newAttachment = {};
+        this.newMultipleAttachments = [];
+        this.attachmentType = AttachmentType;
+        this.selectedFile = null;
+        this.selectedFiles = null;
+        this.showCropImage = false;
+        //#endregion
+        //#region Proprietà per gestione ridimensionamento file di tipo image
+        this.imageChangedEvent = "";
+        this.croppedImage = "";
+        this.transform = {};
+        this.canvasRotation = 0;
+        //#endregion
+        this.AttachmentType = AttachmentType;
+        this.addingLinkMode = false;
+    }
+    async ngOnInit() {
+        //Se è stata richiesta la gestione delle sole immagini allora imposta il filtro per le estensioni possibili da caricare
+        if (!this.acceptedFileTypes)
+            if (this.allowOnlyImages == true)
+                this.acceptedFileTypes = "image/*";
+            else
+                this.acceptedFileTypes = "*";
+        // Se non sono stati specificati i tipi da gestire ma è stato passato null o un array vuoto imposto i tipi di default.
+        if (!this.allowedTypes || this.allowedTypes.length == 0)
+            this.allowedTypes = [AttachmentType.FILE, AttachmentType.LINK, AttachmentType.DROPBOX];
+        else if (this.allowedTypes.find((t) => t != AttachmentType.FILE && t != AttachmentType.LINK && t != AttachmentType.DROPBOX)) {
+            EqpAttachmentDialogService.Warning('Almeno uno degli AttachmentType selezionati nel parametro "allowedTypes" non esiste.');
+            this.allowedTypes = [AttachmentType.FILE, AttachmentType.LINK, AttachmentType.DROPBOX];
+        }
+        //Se è stata richiesta la gestione multipla degli allegati allora configura l'eqp-table
+        if (this.multipleAttachment == true && (!this.attachmentsColumns || this.attachmentsColumns.length == 0)) {
+            this.configureColumns();
+        }
+        if (this.attachmentsList == null)
+            this.attachmentsList = new Array();
+        this.checkAttachmentImage();
+        if (this.allowedTypes.includes(3)) {
+            this.eqpAttachmentService.loadDropboxScript();
+        }
+    }
+    reloadData() {
+        if (this.attachmentTable)
+            this.attachmentTable.reloadDatatable();
+    }
+    checkAttachmentImage() {
+        this.attachmentsList.forEach((a) => {
+            a.IsImage = AttachmentHelperService.checkImageFromMimeType(a.FileContentType);
+        });
+    }
+    //#region Gestione elenco allegati
+    /**
+     * Configura le colonne per l'eqp-table nel caso in cui il parametro "multipleAttachments" è TRUE.
+     */
+    configureColumns() {
+        this.attachmentsColumns = [];
+        if (this.disableAction != true) {
+            this.attachmentsColumns.push({
+                key: "action",
+                display: "",
+                type: TypeColumn.MenuAction,
+                buttonMenuIcon: "more_vert",
+                styles: { flex: "0 0 6%" },
+                actions: [
+                    { name: this.deleteLabel, icon: "delete", fn: (element, index, col) => this.deleteAttachment(element) }
+                ]
+            });
+        }
+        let downloadColumn = {
+            key: "attachment",
+            display: "",
+            type: TypeColumn.SimpleAction,
+            styles: { flex: "0 0 6%" },
+            actions: [
+                {
+                    name: "",
+                    fontawesome: true,
+                    icon: (element) => {
+                        return this.showInlinePreview
+                            ? element.AttachmentType == AttachmentType.FILE
+                                ? "fas fa-cloud-download-alt"
+                                : "fas fa-external-link-alt"
+                            : this.getAttachmentIcon(element);
+                    },
+                    fn: (element, col, elementIndex) => this.viewAttachment(element),
+                    tooltip: {
+                        tooltipText: (element) => {
+                            return element.AttachmentType == AttachmentType.FILE ? this.downloadLabel : this.openLinkLabel;
+                        },
+                        tooltipPosition: this.downloadTooltipPosition
+                    }
+                }
+            ]
+        };
+        let inlinePreviewColumn = {
+            key: "InlinePreview",
+            display: this.previewLabel,
+            type: TypeColumn.ExternalTemplate,
+            externalTemplate: this.inlinePreviewTemplate,
+            styles: { flex: "0 0 10%" }
+        };
+        let fileNameColumn = { key: "FileName", display: this.fileNameLabel };
+        if (this.showInlinePreview) {
+            this.attachmentsColumns.push(inlinePreviewColumn);
+            this.attachmentsColumns.push(fileNameColumn);
+            this.attachmentsColumns.push(downloadColumn);
+        }
+        else {
+            this.attachmentsColumns.push(downloadColumn);
+            this.attachmentsColumns.push(fileNameColumn);
+        }
+    }
+    /**
+     * Elimina un allegato eliminando anche il file presente nello storage di archiviazione utilizzato (AWS o cartella progetto)
+     * @param element IAttachmentDTO da cancellare
+     */
+    deleteAttachment(element) {
+        EqpAttachmentDialogService.Confirm(this.deleteDialogMessage, () => {
+            this.removeAttachmentFromList(this.attachmentsList.indexOf(element));
+        }, true, this.deleteDialogTitle);
+    }
+    /**
+     * Rimuove l'allegato selezionato dalla lista "attachmentsList" e invoca l'evento di output che restituisce la lista aggiornata.
+     * @param attachmentIndex Indice dell'attachment da rimuovere
+     */
+    removeAttachmentFromList(attachmentIndex) {
+        this.onDeleteAttachment.emit(this.attachmentsList[attachmentIndex]);
+        this.attachmentsList.splice(attachmentIndex, 1);
+        if (this.attachmentTable)
+            this.attachmentTable.reloadDatatable();
+        this.localEditedAttachments.emit(this.attachmentsList);
+    }
+    /**
+     * Scarica l'allegato o apre il link
+     * @param element Allegato da mostrare
+     */
+    viewAttachment(attachment) {
+        if (attachment.AttachmentType == AttachmentType.LINK) {
+            window.open(attachment.FilePath, "_blank");
+            return;
+        }
+        if (attachment.FileDataBase64 && attachment.FileContentType && attachment.FileName) {
+            let source = `data:${attachment.FileContentType};base64,${attachment.FileDataBase64}`;
+            const link = document.createElement("a");
+            link.href = source;
+            link.download = `${attachment.FileName}`;
+            link.click();
+        }
+        else {
+            this.downloadAttachment.emit(attachment);
+        }
+    }
+    /**
+     * Ridefinisce l'icona da mostrare nella colonna dell'eqp-table per ogni file.
+     * L'icona varia in base all'estensione del file
+     * @param attachment
+     */
+    getAttachmentIcon(attachment) {
+        if (attachment.AttachmentType == AttachmentType.LINK)
+            return "fas fa-link";
+        else
+            return AttachmentHelperService.getIconFromFileExtensione(attachment.FileExtension);
+    }
+    //#endregion
+    /**
+     * In caso di allegato singolo, sceglie quale metodo richiamare in base al tipo di allegato
+     */
+    addFile(attachmentType, imageInput = null) {
+        if (attachmentType == AttachmentType.LINK) {
+            this.switchToAddingLinkMode();
+        }
+        else if (attachmentType == AttachmentType.FILE) {
+            imageInput.click();
+        }
+        else {
+            this.chooseDropboxFile();
+        }
+    }
+    createAttachmentForm() {
+        //Crea la form per la validazione dei campi
+        this.newAttachmentForm = this.formBuilder.group({
+            type: [this.newAttachment.AttachmentType, Validators.required],
+            name: [this.newAttachment.FileName],
+            path: [this.newAttachment.FilePath],
+            customHeight: [this.customHeight],
+            customWidth: [this.customWidth]
+        });
+    }
+    close(emitCloseEvent = true) {
+        this.newAttachment = {};
+        this.newMultipleAttachments = new Array();
+        this.abortFile();
+        if (this.newAttachmentForm)
+            this.newAttachmentForm.reset();
+        this.dialogRefCropImage.close();
+        this.restoreOriginalDimensions();
+        if (emitCloseEvent == true && this.abortAddAttachment)
+            this.abortAddAttachment.emit();
+    }
+    /**
+     * In base al tipo di allegato controlla se disabilitare o meno il pulsante per salvare.
+     * Funzione usata nel [disable] del pulsante "Salva" del dialog per l'aggiunta di un allegato.
+     * @returns
+     */
+    disableSave() {
+        if (this.loadMultipleFiles != true) {
+            if (this.newAttachment.AttachmentType == AttachmentType.FILE) {
+                return !this.newAttachment.FileDataBase64;
+            }
+            else {
+                return !this.newAttachment.FilePath;
+            }
+        }
+        else {
+            return (this.newMultipleAttachments.filter((p) => (p.AttachmentType == AttachmentType.FILE && !p.FileDataBase64) ||
+                (p.AttachmentType == AttachmentType.LINK && !p.FilePath)).length > 0);
+        }
+    }
+    confirmAddAttachment() {
+        if (this.newAttachment.IsImage) {
+            this.newAttachment.FileDataBase64 = this.imageCropper.crop().base64.split(";base64,")[1];
+        }
+        if (this.loadMultipleFiles != true) {
+            if (this.newAttachment.AttachmentType == AttachmentType.LINK && !this.newAttachment.FileName)
+                this.newAttachment.FileName = this.newAttachment.FilePath;
+            if (this.attachmentsList == null)
+                this.attachmentsList = new Array();
+            this.attachmentsList.push(this.newAttachment);
+        }
+        else {
+            if (this.newMultipleAttachments == null || this.newMultipleAttachments.length == 0)
+                return;
+            if (this.attachmentsList == null)
+                this.attachmentsList = new Array();
+            this.attachmentsList = this.attachmentsList.concat(this.newMultipleAttachments);
+        }
+        if (this.attachmentTable)
+            this.attachmentTable.reloadDatatable();
+        this.localEditedAttachments.emit(this.attachmentsList);
+        if (this.newAttachment.IsImage) {
+            this.dialogRefCropImage.close();
+            this.restoreOriginalDimensions();
+        }
+    }
+    /**
+     * Apre il dialog per l'anteprima dell'allegato selezionato.
+     * @param row
+     * @returns
+     */
+    async openPreviewDialog(row) {
+        this.selectedAttachment = JSON.parse(JSON.stringify(row));
+        if (this.selectedAttachment.AttachmentType == AttachmentType.FILE) {
+            if (this.selectedAttachment.FileContentType.startsWith("video")) {
+                EqpAttachmentDialogService.Warning(this.videoPreviewErrorMessage);
+                return;
+            }
+            else if (this.selectedAttachment.FileContentType.startsWith("audio")) {
+                EqpAttachmentDialogService.Warning(this.audioPreviewErrorMessage);
+                return;
+            }
+        }
+        if (this.getAttachmentEndpoint && this.selectedAttachment.IsImage && !this.selectedAttachment.FileDataBase64) {
+            await this.getAttachmentByID()
+                .then((res) => {
+                this.selectedAttachment.FileDataBase64 = res.FileDataBase64;
+            })
+                .catch((err) => {
+                EqpAttachmentDialogService.Error(err);
+            });
+        }
+        if (this.selectedAttachment.AttachmentType == AttachmentType.LINK) {
+            this.selectedAttachment.TrustedUrl = this.sanitizer.bypassSecurityTrustResourceUrl(this.selectedAttachment.FilePath);
+        }
+        else if (this.selectedAttachment.IsImage &&
+            !this.selectedAttachment.FileDataBase64 &&
+            !this.selectedAttachment.FileThumbnailBase64) {
+            EqpAttachmentDialogService.Info("Impossibile aprire l'anteprima dell'allegato, file mancante.");
+            return;
+        }
+        else if (!this.selectedAttachment.IsImage) {
+            if (this.selectedAttachment.FilePath && this.productionBaseUrl) {
+                this.selectedAttachment.TrustedUrl = this.sanitizer.bypassSecurityTrustResourceUrl("https://docs.google.com/gview?url=" +
+                    this.productionBaseUrl +
+                    "/" +
+                    this.selectedAttachment.FilePath +
+                    "&embedded=true");
+            }
+            else {
+                EqpAttachmentDialogService.Info("Impossibile aprire l'anteprima del documento!");
+                return;
+            }
+        }
+        this.dialog.open(this.dialogPreview, {
+            disableClose: true,
+            hasBackdrop: true
+        });
+    }
+    async getAttachmentByID() {
+        return this.http.post(this.getAttachmentEndpoint, this.selectedAttachment).toPromise();
+    }
+    //#region Gestione caricamento file
+    /**
+     * Evento scatenato alla selezione del file (o dei file).
+     * Se il caricamento è SINGOLO o se comunque è stato selezionato un solo file allora si occupa di controllare se si tratta di un immagine in modo da
+     * mostrare le funzionalità del croppie (per ritagliare l'immagine) oppure no.
+     * Se il file caricato non è un immagine allora genera direttamente il base64 e lo associa all'allegato da salvare.
+     * Se invece il caricamento dei file è MULTIPLO e sono presenti più file allora esegue le stesse operazioni ignorando però il contrllo
+     * immagine per il croppie (in caso di caricamento multiplo le funzionalità del croppie sono disabilitate).
+     */
+    async onFileAdded(event, isFileDropped = false) {
+        this.showCropImage = false;
+        let filesOnInput = isFileDropped ? event : event.target.files;
+        //Se è stato richiesto il caricamento SINGOLO oppure se il caricamento è MULTIPLO ma è stato selezionato un solo file
+        //allora verifica se il file è un immagine (per mostrare il CROPPIE)
+        if ([...filesOnInput].length == 1 || this.loadMultipleFiles != true) {
+            this.selectedFile = filesOnInput[0];
+            this.selectedFiles = filesOnInput;
+            if (!this.selectedFile)
+                return;
+            //Memorizza i dati per l'allegato
+            this.newAttachment = await this.createAttachmentFromUploadedFile(this.selectedFile, false);
+            this.newMultipleAttachments = new Array();
+            this.newMultipleAttachments.push(this.newAttachment);
+            //Se è stata richiesta la gestione delle sole immagini ma per errore è stato selezionato un file che non è un immagine
+            let checkOnlyImage = this.checkAllowOnlyImageFile(this.newAttachment);
+            if (checkOnlyImage == false)
+                return;
+            this.createAttachmentForm();
+            //Verifica se il file caricato è un'immagine oppure no. Se è un immagine, prima di caricarla mostra il croppie per il resize.
+            //Se non è un immagine allora genera il Base64
+            if (this.newAttachment.IsImage == true) {
+                this.getImageDimensions(filesOnInput[0]);
+                //Mostra il croppie e disabilita la form finchè non termina la modifica dell'immagine
+                this.newAttachmentForm.disable();
+                this.newAttachmentForm.controls["customWidth"].enable();
+                this.newAttachmentForm.controls["customHeight"].enable();
+                this.showCropImage = true;
+                this.imageFile = event;
+                this.dialogRefCropImage = this.dialog.open(this.dialogCropImage, {
+                    disableClose: true,
+                    hasBackdrop: true,
+                    width: "60%",
+                    maxHeight: "80%",
+                    maxWidth: "70vh"
+                });
+            }
+            else {
+                this.showCropImage = false;
+                let base64Result = await this.getBase64FromFile(this.selectedFile);
+                this.newAttachment.FileDataBase64 = base64Result.Base64File;
+                this.newAttachment.FileContentType = base64Result.ContentType;
+                this.confirmAddAttachment();
+            }
+        }
+        else {
+            this.selectedFiles = filesOnInput;
+            if (!this.selectedFiles || this.selectedFiles.length == 0)
+                return;
+            this.newMultipleAttachments = new Array();
+            for (let i = 0; i < this.selectedFiles.length; i++) {
+                let newAttachment = await this.createAttachmentFromUploadedFile(this.selectedFiles[i], true, true);
+                //Se è stata richiesta la gestione delle sole immagini ma per errore è stato selezionato un file che non è un immagine
+                let checkOnlyImage = this.checkAllowOnlyImageFile(newAttachment);
+                if (checkOnlyImage == false)
+                    return;
+                this.newMultipleAttachments.push(newAttachment);
+            }
+            this.confirmAddAttachment();
+        }
+        //Resetto il valore del file input in modo da scatenare il change anche se si dovesse caricare lo stesso file
+        if (!isFileDropped)
+            event.target.value = "";
+    }
+    /**
+     * A partire dal FILE ricevuto in input ricostruisce l'oggetto IAttachmentDTO e lo restituisce.
+     * Se il parametro getBase64 viene passato a TRUE allora, sempre a partire dal file,genera il base64 e
+     * ricava il ContentType da associare all'oggetto IAttachmentDTO da restituire
+     * @param currentFile Oggetto FILE da processare
+     * @param getBase64 Se TRUE allora calcola base64 e ContentType del file passato in input
+     * @returns Restituisce un oggetto di tipo IAttachmentDTO
+     */
+    async createAttachmentFromUploadedFile(currentFile, getBase64 = true, cropFile = false) {
+        let newAttachment = {};
+        //Memorizza i dati per l'allegato
+        newAttachment.AttachmentType = AttachmentType.FILE;
+        newAttachment.FileContentType = currentFile.type;
+        newAttachment.FileName = currentFile.name;
+        newAttachment.FileExtension = currentFile.name.substr(currentFile.name.lastIndexOf(".") + 1);
+        newAttachment.IsImage = AttachmentHelperService.checkImageFromMimeType(currentFile.type);
+        if (getBase64 == true) {
+            let base64Result = await this.getBase64FromFile(currentFile);
+            newAttachment.FileDataBase64 = base64Result.Base64File;
+            newAttachment.FileContentType = base64Result.ContentType;
+            if (newAttachment.IsImage && newAttachment.FileDataBase64 && cropFile) {
+                this.getCroppedAndUpload(`data:${base64Result.ContentType};base64,${base64Result.Base64File}`, newAttachment);
+            }
+        }
+        return newAttachment;
+    }
+    /**
+     * A partire dal file passato in input restituisce un oggetto
+     * contenente il base64 del file e il suo contentType
+     * @param currentFile Oggetto File da cui estrapolare base64 e contentType
+     * @returns Restituisce un oggetto avente le proprietà Base64File e ContentType
+     */
+    async getBase64FromFile(currentFile) {
+        let base64File = await toBase64(currentFile);
+        let contentType = null;
+        if (base64File) {
+            // Loris 20/01/2022: PROBLEMA - Quando eseguo l'upload di un file .sql non viene salvato/scaricato correttamente.
+            //                   Questo succede perchè non viene popolato il FileContentType. Per risolvere il problema
+            //                   faccio un controllo e se non esiste il FileContentType allora lo recupero dal base64 ottenuto.
+            contentType = base64File.split(",")[0].split(":")[1].split(";")[0];
+            // Un altro metodo per leggere il ccontent type del file è tramite una regular expression:
+            base64File = base64File.split(",")[1];
+        }
+        let result = {
+            Base64File: base64File,
+            ContentType: contentType
+        };
+        return result;
+    }
+    /**
+     * Controlla se il file che si sta caricando è supportato dal sistema.
+     * @returns
+     */
+    checkAcceptedFiles() {
+        if ((this.loadMultipleFiles != true && this.selectedFile.type.startsWith("video")) ||
+            (this.loadMultipleFiles == true && [...this.selectedFiles].filter((p) => p.type.startsWith("video")).length > 0))
+            return false;
+        if (this.acceptedFileTypes == "*")
+            return true;
+        //Verifica che i tipi del file (o dei file) caricati siano coerenti con quelli accettati dalla direttiva
+        let accepted = true;
+        if (this.loadMultipleFiles != true)
+            accepted = this.acceptedFileTypes.includes(this.selectedFile.type);
+        else {
+            let uploadedFileTypes = [...this.selectedFiles].map((p) => p.type);
+            uploadedFileTypes.forEach((type) => {
+                if (!this.acceptedFileTypes.includes(type))
+                    accepted = false;
+            });
+        }
+        //Questo controllo permette di gestire le casistiche per cui vengono indicati come tipi validi, ad esempio, 'image/*'
+        if (!accepted && this.loadMultipleFiles != true) {
+            for (let t of this.acceptedFileTypes.split(",").filter((t) => t.includes("*"))) {
+                accepted = this.selectedFile.type.startsWith(t.split("*")[0]);
+                if (accepted)
+                    break;
+            }
+        }
+        return accepted;
+    }
+    /**
+     * Se eqp-attachments è stata configurata per il caricamento delle sole immagini allora verifica che il file passato in
+     * input sia effettivamente un immagine o no.
+     * Se il controllo va a buon fine restituisce TRUE altrimenti mostra un messaggio d'errore e restituisce FALSE
+     */
+    checkAllowOnlyImageFile(newAttachment) {
+        if (this.allowOnlyImages == true && newAttachment.IsImage != true) {
+            EqpAttachmentDialogService.Error(this.noImageSelectedErrorMessage);
+            this.abortFile();
+            return false;
+        }
+        else if (!this.checkAcceptedFiles()) {
+            EqpAttachmentDialogService.Error(this.wrongTypeSelectedErrorMessage);
+            this.abortFile();
+            return false;
+        }
+        return true;
+    }
+    //#region Gestione crop file
+    getImageDimensions(img) {
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            const image = new Image();
+            image.src = e.target.result;
+            image.onload = (rs) => {
+                this.originalHeight = rs.currentTarget["height"];
+                this.originalWidth = rs.currentTarget["width"];
+                if (this.originalWidth > 1280) {
+                    this.customWidth = 1280;
+                    this.customHeight = Math.round((1280 * this.originalHeight) / this.originalWidth);
+                }
+                else {
+                    this.customHeight = rs.currentTarget["height"];
+                    this.customWidth = rs.currentTarget["width"];
+                }
+            };
+        };
+        reader.readAsDataURL(img);
+    }
+    restoreOriginalDimensions() {
+        this.customWidth = this.originalWidth;
+        this.customHeight = this.originalHeight;
+        this.canvasRotation = 0;
+        this.transform = {};
+    }
+    onDimensionsChange(dimension) {
+        if (dimension == "H") {
+            this.customWidth = Math.round((this.customHeight * this.originalWidth) / this.originalHeight);
+        }
+        else if (dimension == "W") {
+            this.customHeight = Math.round((this.customWidth * this.originalHeight) / this.originalWidth);
+        }
+    }
+    imageCropped(event) {
+        this.croppedImage = event.base64;
+        this.getCroppedAndUpload(this.croppedImage, this.newAttachment);
+    }
+    getCroppedAndUpload(file, newAttachment) {
+        var self = this;
+        var file = base64ToFile(file);
+        const options = this.compressionOptions;
+        /**
+         * Comprime l'immagine passando come parametri le options create nell'oggetto sopra, e il file dal reader principale
+         */
+        imageCompression(file, options).then((fileCompressed) => {
+            let fileReader = new FileReader();
+            //Faccio la push di ogni file all'interno dell'array di file dell'item da mandare al server
+            fileReader.onload = function () {
+                let resultReader = fileReader.result;
+                var marker = ";base64,";
+                newAttachment.FileDataBase64 = resultReader.substring(resultReader.indexOf(marker) + marker.length);
+                self.showCropImage = false;
+                if (self.newAttachmentForm) {
+                    self.newAttachmentForm.enable();
+                }
+            };
+            fileReader.readAsDataURL(fileCompressed);
+        });
+    }
+    // confirmCrop() {
+    //   this.imageCropper.crop();
+    //   this.dialogRefCropImage.close();
+    //   this.restoreOriginalDimensions();
+    // }
+    rotateLeft() {
+        this.canvasRotation--;
+        this.flipAfterRotate();
+    }
+    rotateRight() {
+        this.canvasRotation++;
+        this.flipAfterRotate();
+    }
+    flipAfterRotate() {
+        const flippedH = this.transform.flipH;
+        const flippedV = this.transform.flipV;
+        this.transform = {
+            ...this.transform,
+            flipH: flippedV,
+            flipV: flippedH
+        };
+    }
+    flipHorizontal() {
+        this.transform = {
+            ...this.transform,
+            flipH: !this.transform.flipH
+        };
+    }
+    flipVertical() {
+        this.transform = {
+            ...this.transform,
+            flipV: !this.transform.flipV
+        };
+    }
+    //#endregion
+    /**
+     * Annulla la selezione del file, svuotando l'input e resettando tutte le proprietà dell'IAttachmentDTO
+     */
+    abortFile() {
+        if (this.imageInput)
+            this.imageInput.nativeElement.value = "";
+        this.selectedFile = null;
+        this.selectedFiles = null;
+        this.showCropImage = false;
+        this.newAttachment.IsImage = false;
+        this.newAttachment.FileDataBase64 = null;
+        this.newAttachment.FileName = null;
+        this.newAttachment.FileExtension = null;
+        this.newAttachment.FileContentType = null;
+        this.newMultipleAttachments = new Array();
+        this.customHeight = null;
+        this.customWidth = null;
+        this.originalHeight = null;
+        this.originalWidth = null;
+        this.dialogRefCropImage.close();
+        this.restoreOriginalDimensions();
+    }
+    //#endregion
+    // Viene creato un'array observables per memorizzare tutti gli observable creati dalle chiamate a fileEntry.file().
+    // Dopo che tutti gli observables sono stati completati, viene utilizzato il metodo subscribe() per eseguire la funzione onFileAdded().
+    fileDropped(files) {
+        let filesDropped = [];
+        const observables = [];
+        for (let i = 0; i < files.length; i++) {
+            if (files[i].fileEntry.isFile) {
+                const fileEntry = files[i].fileEntry;
+                const observable = new Observable((observer) => {
+                    fileEntry.file((file) => {
+                        filesDropped.push(file);
+                        observer.next();
+                        observer.complete();
+                    });
+                });
+                observables.push(observable);
+            }
+            else {
+                const fileEntry = files[i].fileEntry;
+                console.log(files[i].relativePath, fileEntry);
+            }
+        }
+        from(observables)
+            .pipe(concatMap((observable) => observable))
+            .subscribe({
+            complete: () => {
+                this.onFileAdded(filesDropped, true);
+            }
+        });
+    }
+    // Se il caricamento del file dropbox va a buon fine, la funzione di callback restituisce un array di oggetti.
+    // Viene poi fatta una XMLHttpRequest con responseType 'blob' per convertire il primo elemento della response in un Blob.
+    chooseDropboxFile() {
+        var options = {
+            success: (files) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open("GET", files[0].link);
+                xhr.setRequestHeader("Authorization", `Bearer ${AttachmentHelperService.dropboxCredentials.accessToken}`);
+                xhr.responseType = "blob";
+                xhr.onload = () => {
+                    const blob = xhr.response;
+                    const file = new File([blob], files[0].name, { type: blob.type });
+                    let filesAdded = [file];
+                    this.onFileAdded(filesAdded, true);
+                };
+                xhr.send();
+            },
+            linkType: "direct",
+            multiselect: false,
+            extensions: [".jpg", ".png", ".pdf", ".doc", ".docx", ".txt"]
+        };
+        Dropbox.choose(options);
+    }
+    // Workaround dropzone: disabilito il click degli elementi inclusi nella dropzone per evitare di cliccare due volte
+    onSelectFile(event, fileInput) {
+        if (event.target.tagName === "BUTTON" ||
+            event.target.tagName === "INPUT" ||
+            this.addingLinkMode == true) {
+            return;
+        }
+        fileInput.click();
+    }
+    // Metodo per visualizzare la form di aggiunta di un link
+    switchToAddingLinkMode() {
+        this.addingLinkMode = true;
+        this.newAttachment = {};
+        this.newAttachment.IsImage = false;
+        this.newAttachment.AttachmentType = this.attachmentType.LINK;
+        this.newMultipleAttachments = new Array();
+        this.newMultipleAttachments.push(this.newAttachment);
+        this.createAttachmentForm();
+    }
+}
+EqpAttachmentsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EqpAttachmentsComponent, deps: [{ token: i1.MatDialog }, { token: i2.FormBuilder }, { token: i3.DomSanitizer }, { token: i4.HttpClient }, { token: i0.ChangeDetectorRef }, { token: i5.EqpAttachmentService }], target: i0.ɵɵFactoryTarget.Component });
+EqpAttachmentsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: EqpAttachmentsComponent, selector: "eqp-attachments", inputs: { disableAction: "disableAction", showHeader: "showHeader", headerTitle: "headerTitle", attachmentsList: "attachmentsList", showMatCard: "showMatCard", multipleAttachment: "multipleAttachment", loadMultipleFiles: "loadMultipleFiles", attachmentsColumns: "attachmentsColumns", emptyTableMessage: "emptyTableMessage", allowOnlyImages: "allowOnlyImages", acceptedFileTypes: "acceptedFileTypes", isDisabled: "isDisabled", showInlinePreview: "showInlinePreview", getAttachmentEndpoint: "getAttachmentEndpoint", productionBaseUrl: "productionBaseUrl", compressionOptions: "compressionOptions", allowedTypes: "allowedTypes", isEqpTableMultiLanguage: "isEqpTableMultiLanguage", tablePaginatorVisible: "tablePaginatorVisible", isTableSearcheable: "isTableSearcheable", tablePaginatorSize: "tablePaginatorSize", separatedUploadButtons: "separatedUploadButtons", showPreview: "showPreview", singleAttachmentDragAndDrop: "singleAttachmentDragAndDrop", cropOptions: "cropOptions", cropDialogClass: "cropDialogClass", downloadTooltipPosition: "downloadTooltipPosition", openLinkLabel: "openLinkLabel", addButtonLabel: "addButtonLabel", downloadLabel: "downloadLabel", deleteLabel: "deleteLabel", fileNameLabel: "fileNameLabel", previewLabel: "previewLabel", uploadFileLabel: "uploadFileLabel", confirmLabel: "confirmLabel", abortLabel: "abortLabel", saveLabel: "saveLabel", exitLabel: "exitLabel", uploadWithDropboxLabel: "uploadWithDropboxLabel", cropLabel: "cropLabel", eqpTableSearchText: "eqpTableSearchText", deleteDialogTitle: "deleteDialogTitle", deleteDialogMessage: "deleteDialogMessage", noImageSelectedErrorMessage: "noImageSelectedErrorMessage", wrongTypeSelectedErrorMessage: "wrongTypeSelectedErrorMessage", videoPreviewErrorMessage: "videoPreviewErrorMessage", audioPreviewErrorMessage: ["videoPreviewErrorMessage", "audioPreviewErrorMessage"], flipHorinzontalLabel: "flipHorinzontalLabel", flipVerticalLabel: "flipVerticalLabel", rotateRightLabel: "rotateRightLabel", rotateLeftLabel: "rotateLeftLabel" }, outputs: { localEditedAttachments: "localEditedAttachments", abortAddAttachment: "abortAddAttachment", downloadAttachment: "downloadAttachment", onDeleteAttachment: "onDeleteAttachment" }, viewQueries: [{ propertyName: "dialogAddAttachment", first: true, predicate: ["dialogAddAttachment"], descendants: true, static: true }, { propertyName: "dialogAddMultipleAttachment", first: true, predicate: ["dialogAddMultipleAttachment"], descendants: true, static: true }, { propertyName: "dialogCropImage", first: true, predicate: ["dialogCropImage"], descendants: true, static: true }, { propertyName: "imageCropper", first: true, predicate: ImageCropperComponent, descendants: true }, { propertyName: "imageInput", first: true, predicate: ["imageInput"], descendants: true }, { propertyName: "attachmentTable", first: true, predicate: ["attachmentTable"], descendants: true }, { propertyName: "inlinePreviewTemplate", first: true, predicate: ["inlinePreviewTemplate"], descendants: true, static: true }, { propertyName: "dialogPreview", first: true, predicate: ["dialogPreview"], descendants: true, static: true }], ngImport: i0, template: "<!-- Se richiesta la gestione singola mostra il pulsante di caricamento di un singolo file -->\r\n<div *ngIf=\"multipleAttachment != true\">\r\n  <div *ngIf=\"!singleAttachmentDragAndDrop\">\r\n    <!-- Template del button per l'aggiunta di un allegato -->\r\n    <div *ngIf=\"!addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addAttachmentButton\"></ng-container>\r\n    </div>\r\n    <!-- Template della form per l'aggiunta di un link -->\r\n    <div *ngIf=\"addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </div>\r\n  </div>\r\n  <div *ngIf=\"singleAttachmentDragAndDrop\">\r\n    <input\r\n      #fileInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <ngx-file-drop\r\n      (onFileDrop)=\"fileDropped($event)\"\r\n      (click)=\"onSelectFile($event, fileInput)\"\r\n      *ngIf=\"\r\n        allowedTypes &&\r\n        allowedTypes.includes(1) &&\r\n        (!attachmentsList || attachmentsList.length == 0 || (attachmentsList.length > 0 && !attachmentsList[0]))\r\n      \">\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n        <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n        Trascina i file qui\r\n        <div class=\"btn-group mt-1\" role=\"group\">\r\n          <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n          <div class=\"btn-group\" role=\"group\">\r\n            <button\r\n              type=\"button\"\r\n              class=\"btn btn-light border-start dropdown-toggle\"\r\n              [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n            <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(1)\"\r\n                mat-menu-item\r\n                (click)=\"fileInput.click()\"\r\n                class=\"eqp-attachments-file-btn\">\r\n                <i class=\"fas fa-file\"></i>\r\n                <span style=\"margin-left: 10px\">File</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(2)\"\r\n                mat-menu-item\r\n                (click)=\"switchToAddingLinkMode()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fas fa-link\"></i>\r\n                <span style=\"margin-left: 10px\">Link</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(3)\"\r\n                mat-menu-item\r\n                (click)=\"chooseDropboxFile()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fa-brands fa-dropbox\"></i>\r\n                <span style=\"margin-left: 10px\">Dropbox</span>\r\n              </button>\r\n            </mat-menu>\r\n          </div>\r\n        </div>\r\n      </ng-template>\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n        <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n      </ng-template>\r\n    </ngx-file-drop>\r\n  </div>\r\n  <div class=\"text-center\">\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-download-btn\"\r\n      (click)=\"viewAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      color=\"primary\">\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType == AttachmentType.FILE\">download</mat-icon>\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType != AttachmentType.FILE\">open_in_new</mat-icon>\r\n      {{ attachmentsList[0].AttachmentType == AttachmentType.FILE ? downloadLabel : openLinkLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-preview-btn\"\r\n      (click)=\"openPreviewDialog(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      color=\"primary\"\r\n      *ngIf=\"\r\n        showPreview &&\r\n        attachmentsList &&\r\n        attachmentsList.length > 0 &&\r\n        attachmentsList[0] &&\r\n        (!attachmentsList[0].FileContentType ||\r\n          (!attachmentsList[0].FileContentType.startsWith('video') &&\r\n            !attachmentsList[0].FileContentType.startsWith('audio'))) &&\r\n        attachmentsList[0].IsImage == true\r\n      \">\r\n      <mat-icon>visibility</mat-icon> {{ previewLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 eqp-attachments-delete-btn\"\r\n      (click)=\"deleteAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      [disabled]=\"isDisabled\">\r\n      <mat-icon>delete</mat-icon> {{ deleteLabel }}\r\n    </button>\r\n  </div>\r\n  <div\r\n    class=\"row\"\r\n    style=\"margin-top: 10px\"\r\n    *ngIf=\"\r\n      attachmentsList.length > 0 &&\r\n      attachmentsList[0] &&\r\n      attachmentsList[0].FileDataBase64 &&\r\n      attachmentsList[0].IsImage == true\r\n    \">\r\n    <div class=\"col-sm-12 d-flex justify-content-center\">\r\n      <div class=\"single-attachment-inline-preview-container\">\r\n        <img src=\"data:image/png;base64,{{ attachmentsList[0].FileDataBase64 }}\" />\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row\" *ngIf=\"attachmentsList.length > 0 && attachmentsList[0] && attachmentsList[0].IsImage != true\">\r\n    <div class=\"col-sm-12\">\r\n      <mat-form-field>\r\n        <mat-label>{{ fileNameLabel }}</mat-label>\r\n        <input readonly matInput [(ngModel)]=\"attachmentsList[0].FileName\" />\r\n      </mat-form-field>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div *ngIf=\"multipleAttachment == true\">\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <ngx-file-drop (onFileDrop)=\"fileDropped($event)\" (click)=\"onSelectFile($event, fileInput)\">\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n      <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n      Trascina i file qui\r\n      <div class=\"btn-group mt-1\" role=\"group\">\r\n        <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n        <div class=\"btn-group\" role=\"group\">\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn btn-light border-start dropdown-toggle\"\r\n            [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n          <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(1)\"\r\n              mat-menu-item\r\n              (click)=\"fileInput.click()\"\r\n              class=\"eqp-attachments-file-btn\">\r\n              <i class=\"fas fa-file\"></i>\r\n              <span style=\"margin-left: 10px\">File</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(2)\"\r\n              mat-menu-item\r\n              (click)=\"switchToAddingLinkMode()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fas fa-link\"></i>\r\n              <span style=\"margin-left: 10px\">Link</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(3)\"\r\n              mat-menu-item\r\n              (click)=\"chooseDropboxFile()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fa-brands fa-dropbox\"></i>\r\n              <span style=\"margin-left: 10px\">Dropbox</span>\r\n            </button>\r\n          </mat-menu>\r\n        </div>\r\n      </div>\r\n    </ng-template>\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </ng-template>\r\n  </ngx-file-drop>\r\n  <div class=\"mt-2\">\r\n    <eqp-table\r\n      #attachmentTable\r\n      [createMatCard]=\"false\"\r\n      #table\r\n      [columns]=\"attachmentsColumns\"\r\n      [isMultiLanguage]=\"isEqpTableMultiLanguage\"\r\n      [data]=\"attachmentsList\"\r\n      [paginatorVisible]=\"tablePaginatorVisible\"\r\n      [matPaginatorSize]=\"tablePaginatorSize\"\r\n      [emptyTableMessage]=\"emptyTableMessage\"\r\n      [searchText]=\"eqpTableSearchText\"\r\n      [isTableSearcheable]=\"isTableSearcheable\">\r\n    </eqp-table>\r\n  </div>\r\n</div>\r\n\r\n<ng-template #dialogCropImage>\r\n  <!-- Richiama il template per le funzionalit\u00E0 del CROPPIE -->\r\n  <div style=\"overflow-x: hidden\" [ngClass]=\"cropDialogClass\">\r\n    <ng-container\r\n      [ngTemplateOutlet]=\"croppieTemplate\"\r\n      [ngTemplateOutletContext]=\"{ form: newAttachmentForm }\"\r\n      *ngIf=\"showCropImage == true\"></ng-container>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #inlinePreviewTemplate let-row=\"row\">\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <img src=\"data:image/png;base64,{{ row.FileThumbnailBase64 ? row.FileThumbnailBase64 : row.FileDataBase64 }}\" />\r\n  </div>\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && !row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <i [ngClass]=\"getAttachmentIcon(row)\"></i>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #dialogPreview>\r\n  <mat-card class=\"example-card\" *ngIf=\"selectedAttachment\">\r\n    <mat-card-content>\r\n      <div class=\"row\">\r\n        <div class=\"header-title-standard\">\r\n          {{ previewLabel }} {{ selectedAttachment?.AttachmentType == attachmentType.FILE ? \"File\" : \"Link\" }}\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn-close closeButton\"\r\n            mat-dialog-close\r\n            (click)=\"selectedAttachment = null\"></button>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-2\">\r\n        <!-- ANTEPRIMA IMMAGINE -->\r\n        <div class=\"col-12 text-center preview-container\" *ngIf=\"selectedAttachment.IsImage\">\r\n          <img\r\n            class=\"image-preview\"\r\n            src=\"data:image/png;base64,{{\r\n              selectedAttachment.FileDataBase64\r\n                ? selectedAttachment.FileDataBase64\r\n                : selectedAttachment.FileThumbnailBase64\r\n            }}\" />\r\n        </div>\r\n\r\n        <!-- ANTEPRIMA LINK -->\r\n        <div class=\"col-12 preview-container\" *ngIf=\"!selectedAttachment.IsImage\">\r\n          <iframe\r\n            class=\"link-preview\"\r\n            [src]=\"selectedAttachment.TrustedUrl\"\r\n            [title]=\"selectedAttachment.FileName\"></iframe>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-3\">\r\n        <div class=\"col-sm-12 text-center\">\r\n          <button\r\n            mat-mini-fab\r\n            color=\"primary\"\r\n            matTooltip=\"Download\"\r\n            (click)=\"viewAttachment(selectedAttachment)\"\r\n            *ngIf=\"selectedAttachment.AttachmentType != AttachmentType.LINK\">\r\n            <mat-icon>download</mat-icon>\r\n          </button>\r\n        </div>\r\n      </div>\r\n    </mat-card-content>\r\n  </mat-card>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER IL PULSANTE DI AGGIUNTA NUOVO ALLEGATO -->\r\n<ng-template #addAttachmentButton>\r\n  <!--\r\n        Pulsanti per l'aggiunta di un file o un link. Ne viene visualizzato uno se:\r\n        - gli allowedTypes sono stati specificati, nell'array ne \u00E8 presente uno solo, quello inserito \u00E8 AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di pi\u00F9 allegati (multipleAttachment == true)\r\n        OPPURE\r\n        - gli allowedTypes sono stati specificati, nell'array ne \u00E8 presente uno solo, quello inserito \u00E8 AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di un singolo allegato (multipleAttachment == true) e non ne \u00E8 ancora stato selezionato uno (ovvero attachmentsList non esiste o non ha elementi)\r\n    -->\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    *ngIf=\"\r\n      allowedTypes &&\r\n      allowedTypes.length == 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \"\r\n    (click)=\"addFile(allowedTypes[0], fileInput)\"\r\n    [disabled]=\"isDisabled\">\r\n    <!-- Per l'aggiunta dei file mostro un'icona diversa dall'aggiunta dei link -->\r\n    <mat-icon *ngIf=\"allowedTypes[0] == 1\">cloud_upload</mat-icon>\r\n    <i class=\"fas fa-link\" *ngIf=\"allowedTypes[0] == 2\"></i>\r\n    <i class=\"fa-brands fa-dropbox\" *ngIf=\"allowedTypes[0] == 3\"></i>\r\n    <span style=\"margin-left: 10px\">\r\n      {{\r\n        allowedTypes[0] == 1\r\n          ? addButtonLabel + \" file\"\r\n          : allowedTypes[0] == 2\r\n          ? addButtonLabel + \" link\"\r\n          : uploadWithDropboxLabel\r\n      }}</span\r\n    >\r\n  </button>\r\n\r\n  <!-- Pulsante per aprire il menu per la scelta del tipo di Attachment da creare -->\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    [matMenuTriggerFor]=\"attachmentTypeMenu\"\r\n    [disabled]=\"isDisabled\"\r\n    *ngIf=\"\r\n      !separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <mat-icon *ngIf=\"multipleAttachment != true\">cloud_upload</mat-icon>\r\n    <mat-icon *ngIf=\"multipleAttachment == true\">add</mat-icon>\r\n    <span style=\"margin-left: 0px\"> {{ addButtonLabel }} </span>\r\n  </button>\r\n  <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n    <input\r\n      #imageInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(1)\"\r\n      mat-menu-item\r\n      (click)=\"imageInput.click()\"\r\n      class=\"eqp-attachments-file-btn\">\r\n      <i class=\"fas fa-file\"></i>\r\n      <span style=\"margin-left: 10px\">File</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(2)\"\r\n      mat-menu-item\r\n      (click)=\"switchToAddingLinkMode()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fas fa-link\"></i>\r\n      <span style=\"margin-left: 10px\">Link</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(3)\"\r\n      mat-menu-item\r\n      (click)=\"chooseDropboxFile()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fa-brands fa-dropbox\"></i>\r\n      <span style=\"margin-left: 10px\">Dropbox</span>\r\n    </button>\r\n  </mat-menu>\r\n\r\n  <div\r\n    *ngIf=\"\r\n      separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <div class=\"btn-group\">\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(1)\"\r\n        (click)=\"imageInput.click()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-solid fa-cloud-upload\"></i>\r\n        <span style=\"margin-left: 10px\">File</span>\r\n      </button>\r\n      <input\r\n        #imageInput\r\n        style=\"display: none\"\r\n        id=\"file_attachment\"\r\n        name=\"file_attachment\"\r\n        type=\"file\"\r\n        (change)=\"onFileAdded($event)\"\r\n        [accept]=\"acceptedFileTypes\"\r\n        [multiple]=\"loadMultipleFiles\" />\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(2)\"\r\n        (click)=\"switchToAddingLinkMode()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fas fa-link\"></i>\r\n        <span style=\"margin-left: 10px\">Link</span>\r\n      </button>\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(3)\"\r\n        (click)=\"chooseDropboxFile()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-brands fa-dropbox\"></i>\r\n        <span style=\"margin-left: 10px\">Dropbox</span>\r\n      </button>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #croppieTemplate>\r\n  <div class=\"row m-3\">\r\n    <h4>{{ cropLabel }}</h4>\r\n  </div>\r\n  <div class=\"row m-2 crop-large\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        [matTooltip]=\"rotateLeftLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateLeft()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_left</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"rotateRightLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateRight()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_right</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipHorinzontalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipHorizontal()\">\r\n        <mat-icon style=\"vertical-align: middle\">flip_horizontal</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipVerticalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipVertical()\">\r\n        <div style=\"transform: rotate(90deg)\"><mat-icon style=\"vertical-align: middle\">flip_vertical</mat-icon></div>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"'Reset'\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"restoreOriginalDimensions()\">\r\n        <mat-icon style=\"vertical-align: middle\">replay</mat-icon>\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row m-2 crop-small\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <mat-icon *ngIf=\"cropOptions.includes(1)\" style=\"font-size: 27px; vertical-align: middle\" (click)=\"rotateLeft()\"\r\n        >rotate_left</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"rotateRight()\"\r\n        >rotate_right</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"flipHorizontal()\"\r\n        >flip_horizontal</mat-icon\r\n      >\r\n      <div class=\"ms-3\" style=\"transform: rotate(90deg)\">\r\n        <mat-icon\r\n          *ngIf=\"cropOptions.includes(2)\"\r\n          style=\"font-size: 27px; vertical-align: middle\"\r\n          (click)=\"flipVertical()\"\r\n          >flip_vertical</mat-icon\r\n        >\r\n      </div>\r\n      <mat-icon class=\"ms-3\" (click)=\"restoreOriginalDimensions()\" style=\"font-size: 27px; vertical-align: middle\"\r\n        >replay</mat-icon\r\n      >\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <div class=\"crop-container\">\r\n        <image-cropper\r\n          [imageFile]=\"selectedFile\"\r\n          [maintainAspectRatio]=\"false\"\r\n          [autoCrop]=\"false\"\r\n          [containWithinAspectRatio]=\"false\"\r\n          [aspectRatio]=\"4 / 3\"\r\n          [cropperMinWidth]=\"128\"\r\n          [onlyScaleDown]=\"true\"\r\n          [roundCropper]=\"false\"\r\n          [canvasRotation]=\"0\"\r\n          [transform]=\"transform\"\r\n          [alignImage]=\"'left'\"\r\n          format=\"png\"\r\n          (imageCropped)=\"imageCropped($event)\"\r\n          [resizeToWidth]=\"customWidth\"\r\n          [resizeToHeight]=\"customHeight\"\r\n          [canvasRotation]=\"canvasRotation\">\r\n        </image-cropper>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-large\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        class=\"btn btn-primary mat-raised-button eqp-attachments-confirm-btn me-2\"\r\n        type=\"button\"\r\n        (click)=\"confirmAddAttachment()\">\r\n        {{ confirmLabel }}\r\n      </button>\r\n      <button class=\"btn mat-raised-button eqp-attachments-abort-btn\" type=\"button\" (click)=\"abortFile()\">\r\n        {{ abortLabel }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-small\">\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-times\" (click)=\"abortFile()\"></i>\r\n    </div>\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-check\" (click)=\"confirmAddAttachment()\"></i>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER FORM DI AGGIUNTA DI UN LINK -->\r\n<ng-template #addingLinkTemplate>\r\n  <span class=\"mb-1\" style=\"font-size: 20px\"><i class=\"fa fa-link\"></i>Inserisci l'URL</span>\r\n  <form [formGroup]=\"newAttachmentForm\" *ngIf=\"newAttachmentForm\">\r\n    <div class=\"row mb-2\" style=\"height: 80px\">\r\n      <div class=\"col-6 d-grid gap-2 mx-auto\">\r\n        <div class=\"input-group mb-1\">\r\n          <input\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"{{ fileNameLabel }}\"\r\n            formControlName=\"name\"\r\n            [(ngModel)]=\"newAttachment.FileName\" />\r\n        </div>\r\n      </div>\r\n      <div class=\"col-12 d-grid gap-2\">\r\n        <div class=\"input-group\">\r\n          <input\r\n            required\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"Link\"\r\n            formControlName=\"path\"\r\n            [(ngModel)]=\"newAttachment.FilePath\" />\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <div class=\"row\">\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-secondary mat-raised-button\"\r\n          (click)=\"selectedAttachment = null; addingLinkMode = false\"\r\n          type=\"button\">\r\n          {{ exitLabel }}\r\n        </button>\r\n      </div>\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-primary mat-raised-button\"\r\n          type=\"submit\"\r\n          (click)=\"confirmAddAttachment(); selectedAttachment = null; addingLinkMode = false\">\r\n          {{ saveLabel }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </form>\r\n</ng-template>\r\n", styles: ["ngx-file-drop ::ng-deep .ngx-file-drop__drop-zone{min-height:30vh;border-radius:5px!important;background-color:#e4e6ea!important;cursor:pointer;font-size:17px!important;border:dotted!important;padding-top:7vh}ngx-file-drop ::ng-deep .ngx-file-drop__drop-zone .ngx-file-drop__content{display:flex;flex-direction:column;align-items:center;justify-content:center;color:#73777a!important;margin:auto}.custom-height .mat-form-field-wrapper{height:20px}.eqp-attachments-header-title{font-weight:700;font-size:19px;line-height:24px;margin-bottom:auto}.single-attachment-inline-preview-container{max-height:400px;max-width:400px;display:flex;align-items:center}.single-attachment-inline-preview-container img{max-width:100%;max-height:120px}.inline-preview-container{max-height:100px;max-width:100px;display:flex;align-items:center;justify-content:center;width:100%;cursor:pointer}.inline-preview-container img{max-width:100%;max-height:100px}.inline-preview-container i{font-size:25px;margin:auto}.preview-container{max-height:60vh;max-width:100%}.preview-container .image-preview{max-width:100%;max-height:100%}.preview-container .link-preview{width:70vw;height:55vh}.closeButton{float:right}@media (max-width: 768px){.crop-large{display:none}}@media (min-width: 768px){.crop-small{display:none}}@media (max-width: 768px){.crop-container{max-width:55%}}@media (min-width: 768px){.crop-container{max-width:35%}}\n"], dependencies: [{ kind: "component", type: i6.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i6.MatMiniFabButton, selector: "button[mat-mini-fab]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i8.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i8.MatLabel, selector: "mat-label" }, { kind: "component", type: i9.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "component", type: i9.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i9.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "component", type: i10.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i10.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i11.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i1.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i12.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "directive", type: i2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i13.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i13.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i13.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i14.ImageCropperComponent, selector: "image-cropper", inputs: ["imageChangedEvent", "imageURL", "imageBase64", "imageFile", "imageAltText", "cropperFrameAriaLabel", "output", "format", "transform", "maintainAspectRatio", "aspectRatio", "resetCropOnAspectRatioChange", "resizeToWidth", "resizeToHeight", "cropperMinWidth", "cropperMinHeight", "cropperMaxHeight", "cropperMaxWidth", "cropperStaticWidth", "cropperStaticHeight", "canvasRotation", "initialStepSize", "roundCropper", "onlyScaleDown", "imageQuality", "autoCrop", "backgroundColor", "containWithinAspectRatio", "hideResizeSquares", "allowMoveImage", "cropper", "alignImage", "disabled", "hidden"], outputs: ["imageCropped", "startCropImage", "imageLoaded", "cropperReady", "loadImageFailed", "transformChange"] }, { kind: "component", type: i15.EqpTableComponent, selector: "eqp-table" }, { kind: "component", type: i16.NgxFileDropComponent, selector: "ngx-file-drop", inputs: ["accept", "directory", "multiple", "dropZoneLabel", "dropZoneClassName", "useDragEnter", "contentClassName", "showBrowseBtn", "browseBtnClassName", "browseBtnLabel", "disabled"], outputs: ["onFileDrop", "onFileOver", "onFileLeave"] }, { kind: "directive", type: i16.NgxFileDropContentTemplateDirective, selector: "[ngx-file-drop-content-tmp]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EqpAttachmentsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "eqp-attachments", template: "<!-- Se richiesta la gestione singola mostra il pulsante di caricamento di un singolo file -->\r\n<div *ngIf=\"multipleAttachment != true\">\r\n  <div *ngIf=\"!singleAttachmentDragAndDrop\">\r\n    <!-- Template del button per l'aggiunta di un allegato -->\r\n    <div *ngIf=\"!addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addAttachmentButton\"></ng-container>\r\n    </div>\r\n    <!-- Template della form per l'aggiunta di un link -->\r\n    <div *ngIf=\"addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </div>\r\n  </div>\r\n  <div *ngIf=\"singleAttachmentDragAndDrop\">\r\n    <input\r\n      #fileInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <ngx-file-drop\r\n      (onFileDrop)=\"fileDropped($event)\"\r\n      (click)=\"onSelectFile($event, fileInput)\"\r\n      *ngIf=\"\r\n        allowedTypes &&\r\n        allowedTypes.includes(1) &&\r\n        (!attachmentsList || attachmentsList.length == 0 || (attachmentsList.length > 0 && !attachmentsList[0]))\r\n      \">\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n        <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n        Trascina i file qui\r\n        <div class=\"btn-group mt-1\" role=\"group\">\r\n          <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n          <div class=\"btn-group\" role=\"group\">\r\n            <button\r\n              type=\"button\"\r\n              class=\"btn btn-light border-start dropdown-toggle\"\r\n              [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n            <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(1)\"\r\n                mat-menu-item\r\n                (click)=\"fileInput.click()\"\r\n                class=\"eqp-attachments-file-btn\">\r\n                <i class=\"fas fa-file\"></i>\r\n                <span style=\"margin-left: 10px\">File</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(2)\"\r\n                mat-menu-item\r\n                (click)=\"switchToAddingLinkMode()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fas fa-link\"></i>\r\n                <span style=\"margin-left: 10px\">Link</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(3)\"\r\n                mat-menu-item\r\n                (click)=\"chooseDropboxFile()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fa-brands fa-dropbox\"></i>\r\n                <span style=\"margin-left: 10px\">Dropbox</span>\r\n              </button>\r\n            </mat-menu>\r\n          </div>\r\n        </div>\r\n      </ng-template>\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n        <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n      </ng-template>\r\n    </ngx-file-drop>\r\n  </div>\r\n  <div class=\"text-center\">\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-download-btn\"\r\n      (click)=\"viewAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      color=\"primary\">\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType == AttachmentType.FILE\">download</mat-icon>\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType != AttachmentType.FILE\">open_in_new</mat-icon>\r\n      {{ attachmentsList[0].AttachmentType == AttachmentType.FILE ? downloadLabel : openLinkLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-preview-btn\"\r\n      (click)=\"openPreviewDialog(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      color=\"primary\"\r\n      *ngIf=\"\r\n        showPreview &&\r\n        attachmentsList &&\r\n        attachmentsList.length > 0 &&\r\n        attachmentsList[0] &&\r\n        (!attachmentsList[0].FileContentType ||\r\n          (!attachmentsList[0].FileContentType.startsWith('video') &&\r\n            !attachmentsList[0].FileContentType.startsWith('audio'))) &&\r\n        attachmentsList[0].IsImage == true\r\n      \">\r\n      <mat-icon>visibility</mat-icon> {{ previewLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 eqp-attachments-delete-btn\"\r\n      (click)=\"deleteAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      [disabled]=\"isDisabled\">\r\n      <mat-icon>delete</mat-icon> {{ deleteLabel }}\r\n    </button>\r\n  </div>\r\n  <div\r\n    class=\"row\"\r\n    style=\"margin-top: 10px\"\r\n    *ngIf=\"\r\n      attachmentsList.length > 0 &&\r\n      attachmentsList[0] &&\r\n      attachmentsList[0].FileDataBase64 &&\r\n      attachmentsList[0].IsImage == true\r\n    \">\r\n    <div class=\"col-sm-12 d-flex justify-content-center\">\r\n      <div class=\"single-attachment-inline-preview-container\">\r\n        <img src=\"data:image/png;base64,{{ attachmentsList[0].FileDataBase64 }}\" />\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row\" *ngIf=\"attachmentsList.length > 0 && attachmentsList[0] && attachmentsList[0].IsImage != true\">\r\n    <div class=\"col-sm-12\">\r\n      <mat-form-field>\r\n        <mat-label>{{ fileNameLabel }}</mat-label>\r\n        <input readonly matInput [(ngModel)]=\"attachmentsList[0].FileName\" />\r\n      </mat-form-field>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div *ngIf=\"multipleAttachment == true\">\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <ngx-file-drop (onFileDrop)=\"fileDropped($event)\" (click)=\"onSelectFile($event, fileInput)\">\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n      <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n      Trascina i file qui\r\n      <div class=\"btn-group mt-1\" role=\"group\">\r\n        <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n        <div class=\"btn-group\" role=\"group\">\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn btn-light border-start dropdown-toggle\"\r\n            [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n          <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(1)\"\r\n              mat-menu-item\r\n              (click)=\"fileInput.click()\"\r\n              class=\"eqp-attachments-file-btn\">\r\n              <i class=\"fas fa-file\"></i>\r\n              <span style=\"margin-left: 10px\">File</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(2)\"\r\n              mat-menu-item\r\n              (click)=\"switchToAddingLinkMode()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fas fa-link\"></i>\r\n              <span style=\"margin-left: 10px\">Link</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(3)\"\r\n              mat-menu-item\r\n              (click)=\"chooseDropboxFile()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fa-brands fa-dropbox\"></i>\r\n              <span style=\"margin-left: 10px\">Dropbox</span>\r\n            </button>\r\n          </mat-menu>\r\n        </div>\r\n      </div>\r\n    </ng-template>\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </ng-template>\r\n  </ngx-file-drop>\r\n  <div class=\"mt-2\">\r\n    <eqp-table\r\n      #attachmentTable\r\n      [createMatCard]=\"false\"\r\n      #table\r\n      [columns]=\"attachmentsColumns\"\r\n      [isMultiLanguage]=\"isEqpTableMultiLanguage\"\r\n      [data]=\"attachmentsList\"\r\n      [paginatorVisible]=\"tablePaginatorVisible\"\r\n      [matPaginatorSize]=\"tablePaginatorSize\"\r\n      [emptyTableMessage]=\"emptyTableMessage\"\r\n      [searchText]=\"eqpTableSearchText\"\r\n      [isTableSearcheable]=\"isTableSearcheable\">\r\n    </eqp-table>\r\n  </div>\r\n</div>\r\n\r\n<ng-template #dialogCropImage>\r\n  <!-- Richiama il template per le funzionalit\u00E0 del CROPPIE -->\r\n  <div style=\"overflow-x: hidden\" [ngClass]=\"cropDialogClass\">\r\n    <ng-container\r\n      [ngTemplateOutlet]=\"croppieTemplate\"\r\n      [ngTemplateOutletContext]=\"{ form: newAttachmentForm }\"\r\n      *ngIf=\"showCropImage == true\"></ng-container>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #inlinePreviewTemplate let-row=\"row\">\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <img src=\"data:image/png;base64,{{ row.FileThumbnailBase64 ? row.FileThumbnailBase64 : row.FileDataBase64 }}\" />\r\n  </div>\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && !row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <i [ngClass]=\"getAttachmentIcon(row)\"></i>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #dialogPreview>\r\n  <mat-card class=\"example-card\" *ngIf=\"selectedAttachment\">\r\n    <mat-card-content>\r\n      <div class=\"row\">\r\n        <div class=\"header-title-standard\">\r\n          {{ previewLabel }} {{ selectedAttachment?.AttachmentType == attachmentType.FILE ? \"File\" : \"Link\" }}\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn-close closeButton\"\r\n            mat-dialog-close\r\n            (click)=\"selectedAttachment = null\"></button>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-2\">\r\n        <!-- ANTEPRIMA IMMAGINE -->\r\n        <div class=\"col-12 text-center preview-container\" *ngIf=\"selectedAttachment.IsImage\">\r\n          <img\r\n            class=\"image-preview\"\r\n            src=\"data:image/png;base64,{{\r\n              selectedAttachment.FileDataBase64\r\n                ? selectedAttachment.FileDataBase64\r\n                : selectedAttachment.FileThumbnailBase64\r\n            }}\" />\r\n        </div>\r\n\r\n        <!-- ANTEPRIMA LINK -->\r\n        <div class=\"col-12 preview-container\" *ngIf=\"!selectedAttachment.IsImage\">\r\n          <iframe\r\n            class=\"link-preview\"\r\n            [src]=\"selectedAttachment.TrustedUrl\"\r\n            [title]=\"selectedAttachment.FileName\"></iframe>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-3\">\r\n        <div class=\"col-sm-12 text-center\">\r\n          <button\r\n            mat-mini-fab\r\n            color=\"primary\"\r\n            matTooltip=\"Download\"\r\n            (click)=\"viewAttachment(selectedAttachment)\"\r\n            *ngIf=\"selectedAttachment.AttachmentType != AttachmentType.LINK\">\r\n            <mat-icon>download</mat-icon>\r\n          </button>\r\n        </div>\r\n      </div>\r\n    </mat-card-content>\r\n  </mat-card>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER IL PULSANTE DI AGGIUNTA NUOVO ALLEGATO -->\r\n<ng-template #addAttachmentButton>\r\n  <!--\r\n        Pulsanti per l'aggiunta di un file o un link. Ne viene visualizzato uno se:\r\n        - gli allowedTypes sono stati specificati, nell'array ne \u00E8 presente uno solo, quello inserito \u00E8 AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di pi\u00F9 allegati (multipleAttachment == true)\r\n        OPPURE\r\n        - gli allowedTypes sono stati specificati, nell'array ne \u00E8 presente uno solo, quello inserito \u00E8 AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di un singolo allegato (multipleAttachment == true) e non ne \u00E8 ancora stato selezionato uno (ovvero attachmentsList non esiste o non ha elementi)\r\n    -->\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    *ngIf=\"\r\n      allowedTypes &&\r\n      allowedTypes.length == 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \"\r\n    (click)=\"addFile(allowedTypes[0], fileInput)\"\r\n    [disabled]=\"isDisabled\">\r\n    <!-- Per l'aggiunta dei file mostro un'icona diversa dall'aggiunta dei link -->\r\n    <mat-icon *ngIf=\"allowedTypes[0] == 1\">cloud_upload</mat-icon>\r\n    <i class=\"fas fa-link\" *ngIf=\"allowedTypes[0] == 2\"></i>\r\n    <i class=\"fa-brands fa-dropbox\" *ngIf=\"allowedTypes[0] == 3\"></i>\r\n    <span style=\"margin-left: 10px\">\r\n      {{\r\n        allowedTypes[0] == 1\r\n          ? addButtonLabel + \" file\"\r\n          : allowedTypes[0] == 2\r\n          ? addButtonLabel + \" link\"\r\n          : uploadWithDropboxLabel\r\n      }}</span\r\n    >\r\n  </button>\r\n\r\n  <!-- Pulsante per aprire il menu per la scelta del tipo di Attachment da creare -->\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    [matMenuTriggerFor]=\"attachmentTypeMenu\"\r\n    [disabled]=\"isDisabled\"\r\n    *ngIf=\"\r\n      !separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <mat-icon *ngIf=\"multipleAttachment != true\">cloud_upload</mat-icon>\r\n    <mat-icon *ngIf=\"multipleAttachment == true\">add</mat-icon>\r\n    <span style=\"margin-left: 0px\"> {{ addButtonLabel }} </span>\r\n  </button>\r\n  <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n    <input\r\n      #imageInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(1)\"\r\n      mat-menu-item\r\n      (click)=\"imageInput.click()\"\r\n      class=\"eqp-attachments-file-btn\">\r\n      <i class=\"fas fa-file\"></i>\r\n      <span style=\"margin-left: 10px\">File</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(2)\"\r\n      mat-menu-item\r\n      (click)=\"switchToAddingLinkMode()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fas fa-link\"></i>\r\n      <span style=\"margin-left: 10px\">Link</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(3)\"\r\n      mat-menu-item\r\n      (click)=\"chooseDropboxFile()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fa-brands fa-dropbox\"></i>\r\n      <span style=\"margin-left: 10px\">Dropbox</span>\r\n    </button>\r\n  </mat-menu>\r\n\r\n  <div\r\n    *ngIf=\"\r\n      separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <div class=\"btn-group\">\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(1)\"\r\n        (click)=\"imageInput.click()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-solid fa-cloud-upload\"></i>\r\n        <span style=\"margin-left: 10px\">File</span>\r\n      </button>\r\n      <input\r\n        #imageInput\r\n        style=\"display: none\"\r\n        id=\"file_attachment\"\r\n        name=\"file_attachment\"\r\n        type=\"file\"\r\n        (change)=\"onFileAdded($event)\"\r\n        [accept]=\"acceptedFileTypes\"\r\n        [multiple]=\"loadMultipleFiles\" />\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(2)\"\r\n        (click)=\"switchToAddingLinkMode()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fas fa-link\"></i>\r\n        <span style=\"margin-left: 10px\">Link</span>\r\n      </button>\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(3)\"\r\n        (click)=\"chooseDropboxFile()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-brands fa-dropbox\"></i>\r\n        <span style=\"margin-left: 10px\">Dropbox</span>\r\n      </button>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #croppieTemplate>\r\n  <div class=\"row m-3\">\r\n    <h4>{{ cropLabel }}</h4>\r\n  </div>\r\n  <div class=\"row m-2 crop-large\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        [matTooltip]=\"rotateLeftLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateLeft()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_left</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"rotateRightLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateRight()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_right</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipHorinzontalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipHorizontal()\">\r\n        <mat-icon style=\"vertical-align: middle\">flip_horizontal</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipVerticalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipVertical()\">\r\n        <div style=\"transform: rotate(90deg)\"><mat-icon style=\"vertical-align: middle\">flip_vertical</mat-icon></div>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"'Reset'\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"restoreOriginalDimensions()\">\r\n        <mat-icon style=\"vertical-align: middle\">replay</mat-icon>\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row m-2 crop-small\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <mat-icon *ngIf=\"cropOptions.includes(1)\" style=\"font-size: 27px; vertical-align: middle\" (click)=\"rotateLeft()\"\r\n        >rotate_left</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"rotateRight()\"\r\n        >rotate_right</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"flipHorizontal()\"\r\n        >flip_horizontal</mat-icon\r\n      >\r\n      <div class=\"ms-3\" style=\"transform: rotate(90deg)\">\r\n        <mat-icon\r\n          *ngIf=\"cropOptions.includes(2)\"\r\n          style=\"font-size: 27px; vertical-align: middle\"\r\n          (click)=\"flipVertical()\"\r\n          >flip_vertical</mat-icon\r\n        >\r\n      </div>\r\n      <mat-icon class=\"ms-3\" (click)=\"restoreOriginalDimensions()\" style=\"font-size: 27px; vertical-align: middle\"\r\n        >replay</mat-icon\r\n      >\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <div class=\"crop-container\">\r\n        <image-cropper\r\n          [imageFile]=\"selectedFile\"\r\n          [maintainAspectRatio]=\"false\"\r\n          [autoCrop]=\"false\"\r\n          [containWithinAspectRatio]=\"false\"\r\n          [aspectRatio]=\"4 / 3\"\r\n          [cropperMinWidth]=\"128\"\r\n          [onlyScaleDown]=\"true\"\r\n          [roundCropper]=\"false\"\r\n          [canvasRotation]=\"0\"\r\n          [transform]=\"transform\"\r\n          [alignImage]=\"'left'\"\r\n          format=\"png\"\r\n          (imageCropped)=\"imageCropped($event)\"\r\n          [resizeToWidth]=\"customWidth\"\r\n          [resizeToHeight]=\"customHeight\"\r\n          [canvasRotation]=\"canvasRotation\">\r\n        </image-cropper>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-large\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        class=\"btn btn-primary mat-raised-button eqp-attachments-confirm-btn me-2\"\r\n        type=\"button\"\r\n        (click)=\"confirmAddAttachment()\">\r\n        {{ confirmLabel }}\r\n      </button>\r\n      <button class=\"btn mat-raised-button eqp-attachments-abort-btn\" type=\"button\" (click)=\"abortFile()\">\r\n        {{ abortLabel }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-small\">\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-times\" (click)=\"abortFile()\"></i>\r\n    </div>\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-check\" (click)=\"confirmAddAttachment()\"></i>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER FORM DI AGGIUNTA DI UN LINK -->\r\n<ng-template #addingLinkTemplate>\r\n  <span class=\"mb-1\" style=\"font-size: 20px\"><i class=\"fa fa-link\"></i>Inserisci l'URL</span>\r\n  <form [formGroup]=\"newAttachmentForm\" *ngIf=\"newAttachmentForm\">\r\n    <div class=\"row mb-2\" style=\"height: 80px\">\r\n      <div class=\"col-6 d-grid gap-2 mx-auto\">\r\n        <div class=\"input-group mb-1\">\r\n          <input\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"{{ fileNameLabel }}\"\r\n            formControlName=\"name\"\r\n            [(ngModel)]=\"newAttachment.FileName\" />\r\n        </div>\r\n      </div>\r\n      <div class=\"col-12 d-grid gap-2\">\r\n        <div class=\"input-group\">\r\n          <input\r\n            required\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"Link\"\r\n            formControlName=\"path\"\r\n            [(ngModel)]=\"newAttachment.FilePath\" />\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <div class=\"row\">\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-secondary mat-raised-button\"\r\n          (click)=\"selectedAttachment = null; addingLinkMode = false\"\r\n          type=\"button\">\r\n          {{ exitLabel }}\r\n        </button>\r\n      </div>\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-primary mat-raised-button\"\r\n          type=\"submit\"\r\n          (click)=\"confirmAddAttachment(); selectedAttachment = null; addingLinkMode = false\">\r\n          {{ saveLabel }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </form>\r\n</ng-template>\r\n", styles: ["ngx-file-drop ::ng-deep .ngx-file-drop__drop-zone{min-height:30vh;border-radius:5px!important;background-color:#e4e6ea!important;cursor:pointer;font-size:17px!important;border:dotted!important;padding-top:7vh}ngx-file-drop ::ng-deep .ngx-file-drop__drop-zone .ngx-file-drop__content{display:flex;flex-direction:column;align-items:center;justify-content:center;color:#73777a!important;margin:auto}.custom-height .mat-form-field-wrapper{height:20px}.eqp-attachments-header-title{font-weight:700;font-size:19px;line-height:24px;margin-bottom:auto}.single-attachment-inline-preview-container{max-height:400px;max-width:400px;display:flex;align-items:center}.single-attachment-inline-preview-container img{max-width:100%;max-height:120px}.inline-preview-container{max-height:100px;max-width:100px;display:flex;align-items:center;justify-content:center;width:100%;cursor:pointer}.inline-preview-container img{max-width:100%;max-height:100px}.inline-preview-container i{font-size:25px;margin:auto}.preview-container{max-height:60vh;max-width:100%}.preview-container .image-preview{max-width:100%;max-height:100%}.preview-container .link-preview{width:70vw;height:55vh}.closeButton{float:right}@media (max-width: 768px){.crop-large{display:none}}@media (min-width: 768px){.crop-small{display:none}}@media (max-width: 768px){.crop-container{max-width:55%}}@media (min-width: 768px){.crop-container{max-width:35%}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.FormBuilder }, { type: i3.DomSanitizer }, { type: i4.HttpClient }, { type: i0.ChangeDetectorRef }, { type: i5.EqpAttachmentService }]; }, propDecorators: { disableAction: [{
+                type: Input,
+                args: ["disableAction"]
+            }], showHeader: [{
+                type: Input,
+                args: ["showHeader"]
+            }], headerTitle: [{
+                type: Input,
+                args: ["headerTitle"]
+            }], attachmentsList: [{
+                type: Input,
+                args: ["attachmentsList"]
+            }], showMatCard: [{
+                type: Input,
+                args: ["showMatCard"]
+            }], multipleAttachment: [{
+                type: Input,
+                args: ["multipleAttachment"]
+            }], loadMultipleFiles: [{
+                type: Input,
+                args: ["loadMultipleFiles"]
+            }], attachmentsColumns: [{
+                type: Input,
+                args: ["attachmentsColumns"]
+            }], emptyTableMessage: [{
+                type: Input,
+                args: ["emptyTableMessage"]
+            }], allowOnlyImages: [{
+                type: Input,
+                args: ["allowOnlyImages"]
+            }], acceptedFileTypes: [{
+                type: Input,
+                args: ["acceptedFileTypes"]
+            }], isDisabled: [{
+                type: Input,
+                args: ["isDisabled"]
+            }], showInlinePreview: [{
+                type: Input,
+                args: ["showInlinePreview"]
+            }], getAttachmentEndpoint: [{
+                type: Input,
+                args: ["getAttachmentEndpoint"]
+            }], productionBaseUrl: [{
+                type: Input,
+                args: ["productionBaseUrl"]
+            }], compressionOptions: [{
+                type: Input,
+                args: ["compressionOptions"]
+            }], allowedTypes: [{
+                type: Input,
+                args: ["allowedTypes"]
+            }], isEqpTableMultiLanguage: [{
+                type: Input,
+                args: ["isEqpTableMultiLanguage"]
+            }], tablePaginatorVisible: [{
+                type: Input,
+                args: ["tablePaginatorVisible"]
+            }], isTableSearcheable: [{
+                type: Input,
+                args: ["isTableSearcheable"]
+            }], tablePaginatorSize: [{
+                type: Input,
+                args: ["tablePaginatorSize"]
+            }], separatedUploadButtons: [{
+                type: Input,
+                args: ["separatedUploadButtons"]
+            }], showPreview: [{
+                type: Input,
+                args: ["showPreview"]
+            }], singleAttachmentDragAndDrop: [{
+                type: Input,
+                args: ["singleAttachmentDragAndDrop"]
+            }], cropOptions: [{
+                type: Input,
+                args: ["cropOptions"]
+            }], cropDialogClass: [{
+                type: Input,
+                args: ["cropDialogClass"]
+            }], downloadTooltipPosition: [{
+                type: Input,
+                args: ["downloadTooltipPosition"]
+            }], openLinkLabel: [{
+                type: Input,
+                args: ["openLinkLabel"]
+            }], addButtonLabel: [{
+                type: Input,
+                args: ["addButtonLabel"]
+            }], downloadLabel: [{
+                type: Input,
+                args: ["downloadLabel"]
+            }], deleteLabel: [{
+                type: Input,
+                args: ["deleteLabel"]
+            }], fileNameLabel: [{
+                type: Input,
+                args: ["fileNameLabel"]
+            }], previewLabel: [{
+                type: Input,
+                args: ["previewLabel"]
+            }], uploadFileLabel: [{
+                type: Input,
+                args: ["uploadFileLabel"]
+            }], confirmLabel: [{
+                type: Input,
+                args: ["confirmLabel"]
+            }], abortLabel: [{
+                type: Input,
+                args: ["abortLabel"]
+            }], saveLabel: [{
+                type: Input,
+                args: ["saveLabel"]
+            }], exitLabel: [{
+                type: Input,
+                args: ["exitLabel"]
+            }], uploadWithDropboxLabel: [{
+                type: Input,
+                args: ["uploadWithDropboxLabel"]
+            }], cropLabel: [{
+                type: Input,
+                args: ["cropLabel"]
+            }], eqpTableSearchText: [{
+                type: Input,
+                args: ["eqpTableSearchText"]
+            }], deleteDialogTitle: [{
+                type: Input,
+                args: ["deleteDialogTitle"]
+            }], deleteDialogMessage: [{
+                type: Input,
+                args: ["deleteDialogMessage"]
+            }], noImageSelectedErrorMessage: [{
+                type: Input,
+                args: ["noImageSelectedErrorMessage"]
+            }], wrongTypeSelectedErrorMessage: [{
+                type: Input,
+                args: ["wrongTypeSelectedErrorMessage"]
+            }], videoPreviewErrorMessage: [{
+                type: Input,
+                args: ["videoPreviewErrorMessage"]
+            }], audioPreviewErrorMessage: [{
+                type: Input,
+                args: ["videoPreviewErrorMessage"]
+            }], flipHorinzontalLabel: [{
+                type: Input,
+                args: ["flipHorinzontalLabel"]
+            }], flipVerticalLabel: [{
+                type: Input,
+                args: ["flipVerticalLabel"]
+            }], rotateRightLabel: [{
+                type: Input,
+                args: ["rotateRightLabel"]
+            }], rotateLeftLabel: [{
+                type: Input,
+                args: ["rotateLeftLabel"]
+            }], localEditedAttachments: [{
+                type: Output
+            }], abortAddAttachment: [{
+                type: Output
+            }], downloadAttachment: [{
+                type: Output,
+                args: ["downloadAttachment"]
+            }], onDeleteAttachment: [{
+                type: Output,
+                args: ["onDeleteAttachment"]
+            }], dialogAddAttachment: [{
+                type: ViewChild,
+                args: ["dialogAddAttachment", { static: true }]
+            }], dialogAddMultipleAttachment: [{
+                type: ViewChild,
+                args: ["dialogAddMultipleAttachment", { static: true }]
+            }], dialogCropImage: [{
+                type: ViewChild,
+                args: ["dialogCropImage", { static: true }]
+            }], imageCropper: [{
+                type: ViewChild,
+                args: [ImageCropperComponent]
+            }], imageInput: [{
+                type: ViewChild,
+                args: ["imageInput"]
+            }], attachmentTable: [{
+                type: ViewChild,
+                args: ["attachmentTable", { static: false }]
+            }], inlinePreviewTemplate: [{
+                type: ViewChild,
+                args: ["inlinePreviewTemplate", { static: true }]
+            }], dialogPreview: [{
+                type: ViewChild,
+                args: ["dialogPreview", { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eqp-attachments.component.js","sourceRoot":"","sources":["../../../../projects/eqp-attachments/src/lib/eqp-attachments.component.ts","../../../../projects/eqp-attachments/src/lib/eqp-attachments.component.html"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  TemplateRef,\r\n  ViewChild\r\n} from \"@angular/core\";\r\nimport { FormBuilder, FormGroup, Validators } from \"@angular/forms\";\r\nimport { MatDialog, MatDialogRef } from \"@angular/material/dialog\";\r\nimport { DomSanitizer } from \"@angular/platform-browser\";\r\nimport { ConfigColumn, EqpTableComponent, TooltipPositionType, TypeColumn } from \"@eqproject/eqp-table\";\r\nimport imageCompression from \"browser-image-compression\";\r\nimport { base64ToFile, ImageCroppedEvent, ImageCropperComponent, ImageTransform } from \"ngx-image-cropper\";\r\nimport { AttachmentHelperService } from \"./helpers/attachment.helper\";\r\nimport { AttachmentType, CropOptionEnum, IAttachmentDTO } from \"./interfaces/IAttachment\";\r\nimport { IOptions } from \"./interfaces/IOptions\";\r\nimport { EqpAttachmentDialogService } from \"./services/eqp-attachment-dialog.service\";\r\n\r\ndeclare var Dropbox: any;\r\n\r\nimport { concatMap, from, Observable } from \"rxjs\";\r\nimport { EqpAttachmentService } from \"./services/eqp-attachment.service\";\r\n\r\nconst toBase64 = (file) =>\r\n  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: \"eqp-attachments\",\r\n  templateUrl: \"./eqp-attachments.component.html\",\r\n  styleUrls: [\"./eqp-attachments.component.scss\"]\r\n})\r\nexport class EqpAttachmentsComponent implements OnInit {\r\n  //#region @Input del componente\r\n\r\n  /**\r\n   * Se TRUE allora nasconde la colonna per le azioni sull'allegato (nel caso \"multipleAttachment\" è TRUE).\r\n   */\r\n  @Input(\"disableAction\") disableAction: boolean = false;\r\n\r\n  /**\r\n   * Se TRUE mostra il titolo nell'header nel caso in cui \"multipleAttachment\" è TRUE (\"Elenco allegati\" di default).\r\n   */\r\n  @Input(\"showHeader\") showHeader: boolean = true;\r\n\r\n  /**\r\n   * Titolo da visualizzare se il parametro \"showHeader\" è TRUE. Di devault viene visualizzato \"Elenco allegati\".\r\n   */\r\n  @Input(\"headerTitle\") headerTitle: string = \"Elenco allegati\";\r\n\r\n  /**\r\n   * Sorgente dati da visualizzare. Nel caso si vuole gestire un singolo allegato va passato in ogni caso come Array.\r\n   */\r\n  @Input(\"attachmentsList\") attachmentsList: Array<IAttachmentDTO> = null;\r\n\r\n  /**\r\n   * Se TRUE non mostra la MatCard (nel caso in cui \"multipleAttachment\" è TRUE).\r\n   */\r\n  @Input(\"showMatCard\") showMatCard: boolean = true;\r\n\r\n  /**\r\n   * Se FALSE allora il componente mostra solo il pulsante di caricamento di un singolo file, una volta caricato il file invoca l'evento di output \"localEditedAttachments\".\r\n   * Se TRUE allora il componente mostra l'elenco di tutti gli allegati ricevuto nel parametro \"attachmentsList\".\r\n   */\r\n  @Input(\"multipleAttachment\") multipleAttachment: boolean = true;\r\n\r\n  /**\r\n   * Se assume il valore TRUE allora sarà possibile caricare più file per volta. Questa funzionalità è attiva\r\n   * SOLO se si gestiscono allegati multipli, quindi se l'input 'multipleAttachment' assume il valore TRUE, altrimenti è sempre disabilitata.\r\n   */\r\n  @Input(\"loadMultipleFiles\") loadMultipleFiles: boolean = false;\r\n\r\n  /**\r\n   * Configurazione delle colonne della eqp-table per la visualizzazione degli allegati (caso \"multipleAttachment\" è TRUE).\r\n   */\r\n  @Input(\"attachmentsColumns\") attachmentsColumns: Array<ConfigColumn> = null;\r\n\r\n  /**\r\n   * Imposta il messaggio da visualizzare nel caso in cui la tabella degli allegati (nel caso in cui \"multipleAttachment\" è TRUE) è vuota.\r\n   */\r\n  @Input(\"emptyTableMessage\") emptyTableMessage: string = \"Nessun dato trovato\";\r\n\r\n  /**\r\n   * Se TRUE allora permette di selezionare soltanto file di tipo immagine, avente uno dei mimetype\r\n   * specificati dentro AttachmentHelperService.\r\n   * Se FALSE permette di selezionare qualsiasi tipo di file\r\n   */\r\n  @Input(\"allowOnlyImages\") allowOnlyImages: boolean = false;\r\n\r\n  /**\r\n   * Specifica i tipi di file che è possibile caricare\r\n   */\r\n  @Input(\"acceptedFileTypes\") acceptedFileTypes: string;\r\n\r\n  /**\r\n   * Se TRUE disabilita il pulsante di Aggiunta allegato (a prescindere dal valore del parametro \"multipleAttachment\").\r\n   */\r\n  @Input(\"isDisabled\") isDisabled: boolean = false;\r\n\r\n  /**\r\n   * Mostra/nasconde la colonna per visualizzare l'anteprima dei file nella tabella (caso multipleAtatchments = true).\r\n   */\r\n  @Input(\"showInlinePreview\") showInlinePreview: boolean = false;\r\n\r\n  /**\r\n   * Endpoint da chiamare per recueprare l'IAttachmentDTO completo da vedere nell'anteprima. La chiamata sarà in POST e nel body\r\n   * conterrà l'IAttachmentDTO selezionato dall'utente.\r\n   * La chiamata viene eseguita solo per l'anteprima delle immagini essendo necessario il base64 completo dell'immagine a dimensione reale.\r\n   * Per documenti/link basta che sia popolata la proprietà FilePath di IAttachmentDTO.\r\n   */\r\n  @Input(\"getAttachmentEndpoint\") getAttachmentEndpoint: string = null;\r\n\r\n  /**\r\n   * Hostname dell'ambiente di produzione dell'applicativo. Necessario per visualizzare l'anteprima dei documenti\r\n   * tramite il viewer di google.\r\n   * NOTA: Per visualizzare l'anteprima è necessario che la prorietà FilePath dell'IAttachmentDTO sia popolata e che\r\n   * sia abilitato l'accesso alla cartella sul server tramite hostname.\r\n   */\r\n  @Input(\"productionBaseUrl\") productionBaseUrl: string = null;\r\n\r\n  /**\r\n   * Opzioni per la compressione delle immagini caricate.\r\n   */\r\n  @Input(\"compressionOptions\") compressionOptions: IOptions = {\r\n    maxSizeMB: 0.5,\r\n    maxWidthOrHeight: 1920,\r\n    useWebWorker: true\r\n  };\r\n\r\n  /**\r\n   * Array di AttachmentType che si possono aggiungere\r\n   */\r\n  @Input(\"allowedTypes\") allowedTypes: Array<AttachmentType> = [AttachmentType.FILE, AttachmentType.LINK];\r\n\r\n  /**\r\n   * Permette di stabilire se la eqp-table contenente l'elenco degli allegati utilizza\r\n   * il multilingua oppure no\r\n   */\r\n  @Input(\"isEqpTableMultiLanguage\") isEqpTableMultiLanguage: boolean = false;\r\n\r\n  /**\r\n   * Permette di stabilire, in caso di gestione allegati multipli, se la tabella contenente l'elenco\r\n   * degli allegati deve essere paginata oppure no\r\n   */\r\n  @Input(\"tablePaginatorVisible\") tablePaginatorVisible: boolean = true;\r\n\r\n  /**\r\n   * Permette di stabilire, in caso di gestione allegati multipli, se la tabella contenente l'elenco\r\n   * degli allegati deve contenere il campo di ricerca oppure no\r\n   */\r\n  @Input(\"isTableSearcheable\") isTableSearcheable: boolean = true;\r\n\r\n  /**\r\n   * In caso di gestione allegati multipli, permette di stabilire la dimensione pagina di default\r\n   * per la tabella contenente l'elenco degli allegati\r\n   */\r\n  @Input(\"tablePaginatorSize\") tablePaginatorSize: number = null;\r\n\r\n  /**\r\n   * Permette di scegliere il modo in cui i file devono essere caricati\r\n   */\r\n  // @Input(\"uploadType\") uploadType: UploadTypeEnum = UploadTypeEnum.FILE_AND_LINK;\r\n\r\n  /**\r\n   * Permette di stabilire se i pulsanti per il caricamento dei file sono separati o in un menù a tendina\r\n   */\r\n  @Input(\"separatedUploadButtons\") separatedUploadButtons: boolean = false;\r\n\r\n  /**\r\n   * Permette di scegliere se dare la possibilità di vedere o no l'anteprima\r\n   */\r\n  @Input(\"showPreview\") showPreview: boolean = true;\r\n\r\n  /**\r\n   * In caso di allegato singolo, permette di scegliere se aggiungere file tramite drag and drop\r\n   */\r\n  @Input(\"singleAttachmentDragAndDrop\") singleAttachmentDragAndDrop: boolean = false;\r\n\r\n  /**\r\n   * Array di opzioni che si possono utilizzare per il crop\r\n   */\r\n  @Input(\"cropOptions\") cropOptions: Array<CropOptionEnum> = [];\r\n\r\n  /**\r\n   * Classe custom da assegnare al dialog del crop immagini\r\n   */\r\n  @Input(\"cropDialogClass\") cropDialogClass: string;\r\n\r\n  /**\r\n   * Input per definire le label da usare nel componente\r\n   */\r\n  @Input(\"downloadTooltipPosition\") downloadTooltipPosition: TooltipPositionType = TooltipPositionType.Below;\r\n  @Input(\"openLinkLabel\") openLinkLabel: string = \"Apri link\";\r\n  @Input(\"addButtonLabel\") addButtonLabel: string = \"Aggiungi\";\r\n  @Input(\"downloadLabel\") downloadLabel: string = \"Download\";\r\n  @Input(\"deleteLabel\") deleteLabel: string = \"Elimina\";\r\n  @Input(\"fileNameLabel\") fileNameLabel: string = \"Nome file\";\r\n  @Input(\"previewLabel\") previewLabel: string = \"Anteprima\";\r\n  @Input(\"uploadFileLabel\") uploadFileLabel: string = \"Carica file\";\r\n  @Input(\"confirmLabel\") confirmLabel: string = \"Conferma\";\r\n  @Input(\"abortLabel\") abortLabel: string = \"Annulla\";\r\n  @Input(\"saveLabel\") saveLabel: string = \"Salva\";\r\n  @Input(\"exitLabel\") exitLabel: string = \"Esci\";\r\n  @Input(\"uploadWithDropboxLabel\") uploadWithDropboxLabel: string = \"Carica con Dropbox\";\r\n  @Input(\"cropLabel\") cropLabel: string = \"Scegli le dimensioni dell'immagine\";\r\n  @Input(\"eqpTableSearchText\") eqpTableSearchText: string = \"Cerca\";\r\n  @Input(\"deleteDialogTitle\") deleteDialogTitle: string = null;\r\n  @Input(\"deleteDialogMessage\") deleteDialogMessage: string = \"Sei sicuro di voler cancellare quest'allegato?\";\r\n  @Input(\"noImageSelectedErrorMessage\") noImageSelectedErrorMessage: string =\r\n    \"Non è possibile selezionare un file che non sia un'immagine.\";\r\n  @Input(\"wrongTypeSelectedErrorMessage\") wrongTypeSelectedErrorMessage: string =\r\n    \"Non è possibile caricare il file selezionato.\";\r\n  @Input(\"videoPreviewErrorMessage\") videoPreviewErrorMessage: string =\r\n    \"Impossibile aprire l'anteprima di un file video.\";\r\n  @Input(\"videoPreviewErrorMessage\") audioPreviewErrorMessage: string =\r\n    \"Impossibile aprire l'anteprima di un file audio.\";\r\n  @Input(\"flipHorinzontalLabel\") flipHorinzontalLabel: string = \"Capovolgi orizzontalmente\";\r\n  @Input(\"flipVerticalLabel\") flipVerticalLabel: string = \"Capovolgi verticalmente\";\r\n  @Input(\"rotateRightLabel\") rotateRightLabel: string = \"Ruota a destra\";\r\n  @Input(\"rotateLeftLabel\") rotateLeftLabel: string = \"Ruota a sinistra\";\r\n  //#endregion\r\n\r\n  //#region @Output del componente\r\n\r\n  /**\r\n   * Restituisce la lista aggiornata degli allegati.\r\n   */\r\n  @Output() localEditedAttachments: EventEmitter<Array<IAttachmentDTO>> = new EventEmitter<Array<IAttachmentDTO>>();\r\n\r\n  /**\r\n   * Evento scatenato alla pressione del pulsante ESCI della modale di caricamento file.\r\n   */\r\n  @Output() abortAddAttachment: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n  /**\r\n   * Evento di output che restituisce l'IAttachmentDTO selezionato per il download nel caso FileDataBase64, FileContentType o FileName non fossero specificati.\r\n   */\r\n  @Output(\"downloadAttachment\") downloadAttachment: EventEmitter<IAttachmentDTO> = new EventEmitter<IAttachmentDTO>();\r\n\r\n  /**\r\n   * Evento di output che restituisce l'elemento eliminato prima che questo venga effettivamente rismosso dalla lista.\r\n   */\r\n  @Output(\"onDeleteAttachment\") onDeleteAttachment: EventEmitter<IAttachmentDTO> = new EventEmitter<IAttachmentDTO>();\r\n\r\n  //#endregion\r\n\r\n  //#region Proprietà per gestione caricamento nuovo allegato\r\n  newAttachment: IAttachmentDTO = {} as IAttachmentDTO;\r\n  newMultipleAttachments: Array<IAttachmentDTO> = [];\r\n  attachmentType = AttachmentType;\r\n  // uploadTypeEnum = UploadTypeEnum;\r\n  newAttachmentForm: FormGroup;\r\n  selectedFile: File = null;\r\n  selectedFiles: Array<File> = null;\r\n  showCropImage: boolean = false;\r\n  @ViewChild(\"dialogAddAttachment\", { static: true }) dialogAddAttachment: TemplateRef<any>;\r\n  dialogRefAddAttachment: MatDialogRef<TemplateRef<any>>;\r\n  @ViewChild(\"dialogAddMultipleAttachment\", { static: true }) dialogAddMultipleAttachment: TemplateRef<any>;\r\n  dialogRefCropImage: MatDialogRef<TemplateRef<any>>;\r\n  @ViewChild(\"dialogCropImage\", { static: true }) dialogCropImage: TemplateRef<any>;\r\n  //#endregion\r\n\r\n  //#region Proprietà per gestione ridimensionamento file di tipo image\r\n  imageChangedEvent: any = \"\";\r\n  croppedImage: any = \"\";\r\n  transform: ImageTransform = {};\r\n  canvasRotation = 0;\r\n  @ViewChild(ImageCropperComponent) imageCropper: ImageCropperComponent;\r\n  @ViewChild(\"imageInput\") imageInput: any;\r\n  //#endregion\r\n\r\n  AttachmentType = AttachmentType;\r\n  selectedAttachment: IAttachmentDTO;\r\n\r\n  originalWidth: number;\r\n  originalHeight: number;\r\n  customWidth: number;\r\n  customHeight: number;\r\n\r\n  @ViewChild(\"attachmentTable\", { static: false }) attachmentTable: EqpTableComponent;\r\n  @ViewChild(\"inlinePreviewTemplate\", { static: true }) inlinePreviewTemplate: TemplateRef<any>;\r\n  @ViewChild(\"dialogPreview\", { static: true }) dialogPreview: TemplateRef<any>;\r\n\r\n  imageFile: File;\r\n\r\n  addingLinkMode: boolean = false;\r\n\r\n  constructor(\r\n    private dialog: MatDialog,\r\n    private formBuilder: FormBuilder,\r\n    private sanitizer: DomSanitizer,\r\n    private http: HttpClient,\r\n    private cd: ChangeDetectorRef,\r\n    private eqpAttachmentService: EqpAttachmentService\r\n  ) {}\r\n\r\n  async ngOnInit() {\r\n    //Se è stata richiesta la gestione delle sole immagini allora imposta il filtro per le estensioni possibili da caricare\r\n    if (!this.acceptedFileTypes)\r\n      if (this.allowOnlyImages == true) this.acceptedFileTypes = \"image/*\";\r\n      else this.acceptedFileTypes = \"*\";\r\n\r\n    // Se non sono stati specificati i tipi da gestire ma è stato passato null o un array vuoto imposto i tipi di default.\r\n    if (!this.allowedTypes || this.allowedTypes.length == 0)\r\n      this.allowedTypes = [AttachmentType.FILE, AttachmentType.LINK, AttachmentType.DROPBOX];\r\n    else if (\r\n      this.allowedTypes.find((t) => t != AttachmentType.FILE && t != AttachmentType.LINK && t != AttachmentType.DROPBOX)\r\n    ) {\r\n      EqpAttachmentDialogService.Warning(\r\n        'Almeno uno degli AttachmentType selezionati nel parametro \"allowedTypes\" non esiste.'\r\n      );\r\n      this.allowedTypes = [AttachmentType.FILE, AttachmentType.LINK, AttachmentType.DROPBOX];\r\n    }\r\n\r\n    //Se è stata richiesta la gestione multipla degli allegati allora configura l'eqp-table\r\n    if (this.multipleAttachment == true && (!this.attachmentsColumns || this.attachmentsColumns.length == 0)) {\r\n      this.configureColumns();\r\n    }\r\n\r\n    if (this.attachmentsList == null) this.attachmentsList = new Array<IAttachmentDTO>();\r\n\r\n    this.checkAttachmentImage();\r\n\r\n    if (this.allowedTypes.includes(3)) {\r\n      this.eqpAttachmentService.loadDropboxScript();\r\n    }\r\n  }\r\n\r\n  public reloadData() {\r\n    if (this.attachmentTable) this.attachmentTable.reloadDatatable();\r\n  }\r\n\r\n  checkAttachmentImage() {\r\n    this.attachmentsList.forEach((a) => {\r\n      a.IsImage = AttachmentHelperService.checkImageFromMimeType(a.FileContentType);\r\n    });\r\n  }\r\n\r\n  //#region Gestione elenco allegati\r\n\r\n  /**\r\n   * Configura le colonne per l'eqp-table nel caso in cui il parametro \"multipleAttachments\" è TRUE.\r\n   */\r\n  configureColumns() {\r\n    this.attachmentsColumns = [];\r\n    if (this.disableAction != true) {\r\n      this.attachmentsColumns.push({\r\n        key: \"action\",\r\n        display: \"\",\r\n        type: TypeColumn.MenuAction,\r\n        buttonMenuIcon: \"more_vert\",\r\n        styles: { flex: \"0 0 6%\" },\r\n        actions: [\r\n          { name: this.deleteLabel, icon: \"delete\", fn: (element, index, col) => this.deleteAttachment(element) }\r\n        ]\r\n      });\r\n    }\r\n\r\n    let downloadColumn = {\r\n      key: \"attachment\",\r\n      display: \"\",\r\n      type: TypeColumn.SimpleAction,\r\n      styles: { flex: \"0 0 6%\" },\r\n      actions: [\r\n        {\r\n          name: \"\",\r\n          fontawesome: true,\r\n          icon: (element) => {\r\n            return this.showInlinePreview\r\n              ? element.AttachmentType == AttachmentType.FILE\r\n                ? \"fas fa-cloud-download-alt\"\r\n                : \"fas fa-external-link-alt\"\r\n              : this.getAttachmentIcon(element);\r\n          },\r\n          fn: (element, col, elementIndex) => this.viewAttachment(element),\r\n          tooltip: {\r\n            tooltipText: (element) => {\r\n              return element.AttachmentType == AttachmentType.FILE ? this.downloadLabel : this.openLinkLabel;\r\n            },\r\n            tooltipPosition: this.downloadTooltipPosition\r\n          }\r\n        }\r\n      ]\r\n    };\r\n\r\n    let inlinePreviewColumn = {\r\n      key: \"InlinePreview\",\r\n      display: this.previewLabel,\r\n      type: TypeColumn.ExternalTemplate,\r\n      externalTemplate: this.inlinePreviewTemplate,\r\n      styles: { flex: \"0 0 10%\" }\r\n    };\r\n\r\n    let fileNameColumn = { key: \"FileName\", display: this.fileNameLabel };\r\n\r\n    if (this.showInlinePreview) {\r\n      this.attachmentsColumns.push(inlinePreviewColumn);\r\n      this.attachmentsColumns.push(fileNameColumn);\r\n      this.attachmentsColumns.push(downloadColumn);\r\n    } else {\r\n      this.attachmentsColumns.push(downloadColumn);\r\n      this.attachmentsColumns.push(fileNameColumn);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Elimina un allegato eliminando anche il file presente nello storage di archiviazione utilizzato (AWS o cartella progetto)\r\n   * @param element IAttachmentDTO da cancellare\r\n   */\r\n  deleteAttachment(element: IAttachmentDTO) {\r\n    EqpAttachmentDialogService.Confirm(\r\n      this.deleteDialogMessage,\r\n      () => {\r\n        this.removeAttachmentFromList(this.attachmentsList.indexOf(element));\r\n      },\r\n      true,\r\n      this.deleteDialogTitle\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Rimuove l'allegato selezionato dalla lista \"attachmentsList\" e invoca l'evento di output che restituisce la lista aggiornata.\r\n   * @param attachmentIndex Indice dell'attachment da rimuovere\r\n   */\r\n  removeAttachmentFromList(attachmentIndex: number) {\r\n    this.onDeleteAttachment.emit(this.attachmentsList[attachmentIndex]);\r\n\r\n    this.attachmentsList.splice(attachmentIndex, 1);\r\n    if (this.attachmentTable) this.attachmentTable.reloadDatatable();\r\n    this.localEditedAttachments.emit(this.attachmentsList);\r\n  }\r\n\r\n  /**\r\n   * Scarica l'allegato o apre il link\r\n   * @param element Allegato da mostrare\r\n   */\r\n  viewAttachment(attachment: IAttachmentDTO) {\r\n    if (attachment.AttachmentType == AttachmentType.LINK) {\r\n      window.open(attachment.FilePath, \"_blank\");\r\n      return;\r\n    }\r\n\r\n    if (attachment.FileDataBase64 && attachment.FileContentType && attachment.FileName) {\r\n      let source = `data:${attachment.FileContentType};base64,${attachment.FileDataBase64}`;\r\n      const link = document.createElement(\"a\");\r\n      link.href = source;\r\n      link.download = `${attachment.FileName}`;\r\n      link.click();\r\n    } else {\r\n      this.downloadAttachment.emit(attachment);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Ridefinisce l'icona da mostrare nella colonna dell'eqp-table per ogni file.\r\n   * L'icona varia in base all'estensione del file\r\n   * @param attachment\r\n   */\r\n  getAttachmentIcon(attachment: IAttachmentDTO) {\r\n    if (attachment.AttachmentType == AttachmentType.LINK) return \"fas fa-link\";\r\n    else return AttachmentHelperService.getIconFromFileExtensione(attachment.FileExtension);\r\n  }\r\n\r\n  //#endregion\r\n\r\n  /**\r\n   * In caso di allegato singolo, sceglie quale metodo richiamare in base al tipo di allegato\r\n   */\r\n  addFile(attachmentType: AttachmentType, imageInput = null) {\r\n    if (attachmentType == AttachmentType.LINK) {\r\n      this.switchToAddingLinkMode();\r\n    } else if (attachmentType == AttachmentType.FILE) {\r\n      imageInput.click();\r\n    } else {\r\n      this.chooseDropboxFile();\r\n    }\r\n  }\r\n\r\n  createAttachmentForm() {\r\n    //Crea la form per la validazione dei campi\r\n    this.newAttachmentForm = this.formBuilder.group({\r\n      type: [this.newAttachment.AttachmentType, Validators.required],\r\n      name: [this.newAttachment.FileName],\r\n      path: [this.newAttachment.FilePath],\r\n      customHeight: [this.customHeight],\r\n      customWidth: [this.customWidth]\r\n    });\r\n  }\r\n\r\n  close(emitCloseEvent = true) {\r\n    this.newAttachment = {} as IAttachmentDTO;\r\n    this.newMultipleAttachments = new Array<IAttachmentDTO>();\r\n    this.abortFile();\r\n    if (this.newAttachmentForm) this.newAttachmentForm.reset();\r\n\r\n    this.dialogRefCropImage.close();\r\n    this.restoreOriginalDimensions();\r\n\r\n    if (emitCloseEvent == true && this.abortAddAttachment) this.abortAddAttachment.emit();\r\n  }\r\n\r\n  /**\r\n   * In base al tipo di allegato controlla se disabilitare o meno il pulsante per salvare.\r\n   * Funzione usata nel [disable] del pulsante \"Salva\" del dialog per l'aggiunta di un allegato.\r\n   * @returns\r\n   */\r\n  disableSave() {\r\n    if (this.loadMultipleFiles != true) {\r\n      if (this.newAttachment.AttachmentType == AttachmentType.FILE) {\r\n        return !this.newAttachment.FileDataBase64;\r\n      } else {\r\n        return !this.newAttachment.FilePath;\r\n      }\r\n    } else {\r\n      return (\r\n        this.newMultipleAttachments.filter(\r\n          (p) =>\r\n            (p.AttachmentType == AttachmentType.FILE && !p.FileDataBase64) ||\r\n            (p.AttachmentType == AttachmentType.LINK && !p.FilePath)\r\n        ).length > 0\r\n      );\r\n    }\r\n  }\r\n\r\n  confirmAddAttachment() {\r\n    if (this.newAttachment.IsImage) {\r\n      this.newAttachment.FileDataBase64 = this.imageCropper.crop().base64.split(\";base64,\")[1];\r\n    }\r\n\r\n    if (this.loadMultipleFiles != true) {\r\n      if (this.newAttachment.AttachmentType == AttachmentType.LINK && !this.newAttachment.FileName)\r\n        this.newAttachment.FileName = this.newAttachment.FilePath;\r\n\r\n      if (this.attachmentsList == null) this.attachmentsList = new Array<IAttachmentDTO>();\r\n\r\n      this.attachmentsList.push(this.newAttachment);\r\n    } else {\r\n      if (this.newMultipleAttachments == null || this.newMultipleAttachments.length == 0) return;\r\n\r\n      if (this.attachmentsList == null) this.attachmentsList = new Array<IAttachmentDTO>();\r\n\r\n      this.attachmentsList = this.attachmentsList.concat(this.newMultipleAttachments);\r\n    }\r\n\r\n    if (this.attachmentTable) this.attachmentTable.reloadDatatable();\r\n\r\n    this.localEditedAttachments.emit(this.attachmentsList);\r\n\r\n    if (this.newAttachment.IsImage) {\r\n      this.dialogRefCropImage.close();\r\n      this.restoreOriginalDimensions();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apre il dialog per l'anteprima dell'allegato selezionato.\r\n   * @param row\r\n   * @returns\r\n   */\r\n  async openPreviewDialog(row: IAttachmentDTO) {\r\n    this.selectedAttachment = JSON.parse(JSON.stringify(row));\r\n\r\n    if (this.selectedAttachment.AttachmentType == AttachmentType.FILE) {\r\n      if (this.selectedAttachment.FileContentType.startsWith(\"video\")) {\r\n        EqpAttachmentDialogService.Warning(this.videoPreviewErrorMessage);\r\n        return;\r\n      } else if (this.selectedAttachment.FileContentType.startsWith(\"audio\")) {\r\n        EqpAttachmentDialogService.Warning(this.audioPreviewErrorMessage);\r\n        return;\r\n      }\r\n    }\r\n\r\n    if (this.getAttachmentEndpoint && this.selectedAttachment.IsImage && !this.selectedAttachment.FileDataBase64) {\r\n      await this.getAttachmentByID()\r\n        .then((res) => {\r\n          this.selectedAttachment.FileDataBase64 = res.FileDataBase64;\r\n        })\r\n        .catch((err) => {\r\n          EqpAttachmentDialogService.Error(err);\r\n        });\r\n    }\r\n\r\n    if (this.selectedAttachment.AttachmentType == AttachmentType.LINK) {\r\n      this.selectedAttachment.TrustedUrl = this.sanitizer.bypassSecurityTrustResourceUrl(\r\n        this.selectedAttachment.FilePath\r\n      );\r\n    } else if (\r\n      this.selectedAttachment.IsImage &&\r\n      !this.selectedAttachment.FileDataBase64 &&\r\n      !this.selectedAttachment.FileThumbnailBase64\r\n    ) {\r\n      EqpAttachmentDialogService.Info(\"Impossibile aprire l'anteprima dell'allegato, file mancante.\");\r\n      return;\r\n    } else if (!this.selectedAttachment.IsImage) {\r\n      if (this.selectedAttachment.FilePath && this.productionBaseUrl) {\r\n        this.selectedAttachment.TrustedUrl = this.sanitizer.bypassSecurityTrustResourceUrl(\r\n          \"https://docs.google.com/gview?url=\" +\r\n            this.productionBaseUrl +\r\n            \"/\" +\r\n            this.selectedAttachment.FilePath +\r\n            \"&embedded=true\"\r\n        );\r\n      } else {\r\n        EqpAttachmentDialogService.Info(\"Impossibile aprire l'anteprima del documento!\");\r\n        return;\r\n      }\r\n    }\r\n\r\n    this.dialog.open(this.dialogPreview, {\r\n      disableClose: true,\r\n      hasBackdrop: true\r\n    });\r\n  }\r\n\r\n  async getAttachmentByID() {\r\n    return this.http.post<IAttachmentDTO>(this.getAttachmentEndpoint, this.selectedAttachment).toPromise();\r\n  }\r\n\r\n  //#region Gestione caricamento file\r\n\r\n  /**\r\n   * Evento scatenato alla selezione del file (o dei file).\r\n   * Se il caricamento è SINGOLO o se comunque è stato selezionato un solo file allora si occupa di controllare se si tratta di un immagine in modo da\r\n   * mostrare le funzionalità del croppie (per ritagliare l'immagine) oppure no.\r\n   * Se il file caricato non è un immagine allora genera direttamente il base64 e lo associa all'allegato da salvare.\r\n   * Se invece il caricamento dei file è MULTIPLO e sono presenti più file allora esegue le stesse operazioni ignorando però il contrllo\r\n   * immagine per il croppie (in caso di caricamento multiplo le funzionalità del croppie sono disabilitate).\r\n   */\r\n  async onFileAdded(event, isFileDropped: boolean = false) {\r\n    this.showCropImage = false;\r\n    let filesOnInput = isFileDropped ? event : event.target.files;\r\n\r\n    //Se è stato richiesto il caricamento SINGOLO oppure se il caricamento è MULTIPLO ma è stato selezionato un solo file\r\n    //allora verifica se il file è un immagine (per mostrare il CROPPIE)\r\n    if ([...filesOnInput].length == 1 || this.loadMultipleFiles != true) {\r\n      this.selectedFile = filesOnInput[0];\r\n      this.selectedFiles = filesOnInput;\r\n      if (!this.selectedFile) return;\r\n\r\n      //Memorizza i dati per l'allegato\r\n      this.newAttachment = await this.createAttachmentFromUploadedFile(this.selectedFile, false);\r\n      this.newMultipleAttachments = new Array<IAttachmentDTO>();\r\n      this.newMultipleAttachments.push(this.newAttachment);\r\n\r\n      //Se è stata richiesta la gestione delle sole immagini ma per errore è stato selezionato un file che non è un immagine\r\n      let checkOnlyImage = this.checkAllowOnlyImageFile(this.newAttachment);\r\n      if (checkOnlyImage == false) return;\r\n\r\n      this.createAttachmentForm();\r\n\r\n      //Verifica se il file caricato è un'immagine oppure no. Se è un immagine, prima di caricarla mostra il croppie per il resize.\r\n      //Se non è un immagine allora genera il Base64\r\n      if (this.newAttachment.IsImage == true) {\r\n        this.getImageDimensions(filesOnInput[0]);\r\n\r\n        //Mostra il croppie e disabilita la form finchè non termina la modifica dell'immagine\r\n        this.newAttachmentForm.disable();\r\n        this.newAttachmentForm.controls[\"customWidth\"].enable();\r\n        this.newAttachmentForm.controls[\"customHeight\"].enable();\r\n        this.showCropImage = true;\r\n        this.imageFile = event;\r\n\r\n        this.dialogRefCropImage = this.dialog.open(this.dialogCropImage, {\r\n          disableClose: true,\r\n          hasBackdrop: true,\r\n          width: \"60%\",\r\n          maxHeight: \"80%\",\r\n          maxWidth: \"70vh\"\r\n        });\r\n      } else {\r\n        this.showCropImage = false;\r\n        let base64Result = await this.getBase64FromFile(this.selectedFile);\r\n        this.newAttachment.FileDataBase64 = base64Result.Base64File;\r\n        this.newAttachment.FileContentType = base64Result.ContentType;\r\n        this.confirmAddAttachment();\r\n      }\r\n    } else {\r\n      this.selectedFiles = filesOnInput;\r\n      if (!this.selectedFiles || this.selectedFiles.length == 0) return;\r\n\r\n      this.newMultipleAttachments = new Array<IAttachmentDTO>();\r\n      for (let i = 0; i < this.selectedFiles.length; i++) {\r\n        let newAttachment: IAttachmentDTO = await this.createAttachmentFromUploadedFile(\r\n          this.selectedFiles[i],\r\n          true,\r\n          true\r\n        );\r\n        //Se è stata richiesta la gestione delle sole immagini ma per errore è stato selezionato un file che non è un immagine\r\n        let checkOnlyImage = this.checkAllowOnlyImageFile(newAttachment);\r\n        if (checkOnlyImage == false) return;\r\n\r\n        this.newMultipleAttachments.push(newAttachment);\r\n      }\r\n      this.confirmAddAttachment();\r\n    }\r\n\r\n    //Resetto il valore del file input in modo da scatenare il change anche se si dovesse caricare lo stesso file\r\n    if (!isFileDropped) event.target.value = \"\";\r\n  }\r\n\r\n  /**\r\n   * A partire dal FILE ricevuto in input ricostruisce l'oggetto IAttachmentDTO e lo restituisce.\r\n   * Se il parametro getBase64 viene passato a TRUE allora, sempre a partire dal file,genera il base64 e\r\n   * ricava il ContentType da associare all'oggetto IAttachmentDTO da restituire\r\n   * @param currentFile Oggetto FILE da processare\r\n   * @param getBase64 Se TRUE allora calcola base64 e ContentType del file passato in input\r\n   * @returns Restituisce un oggetto di tipo IAttachmentDTO\r\n   */\r\n  private async createAttachmentFromUploadedFile(\r\n    currentFile: File,\r\n    getBase64: boolean = true,\r\n    cropFile: boolean = false\r\n  ): Promise<IAttachmentDTO> {\r\n    let newAttachment: IAttachmentDTO = {} as IAttachmentDTO;\r\n    //Memorizza i dati per l'allegato\r\n    newAttachment.AttachmentType = AttachmentType.FILE;\r\n    newAttachment.FileContentType = currentFile.type;\r\n    newAttachment.FileName = currentFile.name;\r\n    newAttachment.FileExtension = currentFile.name.substr(currentFile.name.lastIndexOf(\".\") + 1);\r\n    newAttachment.IsImage = AttachmentHelperService.checkImageFromMimeType(currentFile.type);\r\n\r\n    if (getBase64 == true) {\r\n      let base64Result = await this.getBase64FromFile(currentFile);\r\n      newAttachment.FileDataBase64 = base64Result.Base64File;\r\n      newAttachment.FileContentType = base64Result.ContentType;\r\n\r\n      if (newAttachment.IsImage && newAttachment.FileDataBase64 && cropFile) {\r\n        this.getCroppedAndUpload(`data:${base64Result.ContentType};base64,${base64Result.Base64File}`, newAttachment);\r\n      }\r\n    }\r\n\r\n    return newAttachment;\r\n  }\r\n\r\n  /**\r\n   * A partire dal file passato in input restituisce un oggetto\r\n   * contenente il base64 del file e il suo contentType\r\n   * @param currentFile Oggetto File da cui estrapolare base64 e contentType\r\n   * @returns Restituisce un oggetto avente le proprietà Base64File e ContentType\r\n   */\r\n  private async getBase64FromFile(currentFile: File): Promise<any> {\r\n    let base64File = await toBase64(currentFile);\r\n    let contentType: string = null;\r\n    if (base64File) {\r\n      // Loris 20/01/2022: PROBLEMA - Quando eseguo l'upload di un file .sql non viene salvato/scaricato correttamente.\r\n      //                   Questo succede perchè non viene popolato il FileContentType. Per risolvere il problema\r\n      //                   faccio un controllo e se non esiste il FileContentType allora lo recupero dal base64 ottenuto.\r\n      contentType = base64File.split(\",\")[0].split(\":\")[1].split(\";\")[0];\r\n      // Un altro metodo per leggere il ccontent type del file è tramite una regular expression:\r\n      base64File = base64File.split(\",\")[1];\r\n    }\r\n\r\n    let result = {\r\n      Base64File: base64File,\r\n      ContentType: contentType\r\n    };\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Controlla se il file che si sta caricando è supportato dal sistema.\r\n   * @returns\r\n   */\r\n  private checkAcceptedFiles(): boolean {\r\n    if (\r\n      (this.loadMultipleFiles != true && this.selectedFile.type.startsWith(\"video\")) ||\r\n      (this.loadMultipleFiles == true && [...this.selectedFiles].filter((p) => p.type.startsWith(\"video\")).length > 0)\r\n    )\r\n      return false;\r\n\r\n    if (this.acceptedFileTypes == \"*\") return true;\r\n\r\n    //Verifica che i tipi del file (o dei file) caricati siano coerenti con quelli accettati dalla direttiva\r\n    let accepted: boolean = true;\r\n    if (this.loadMultipleFiles != true) accepted = this.acceptedFileTypes.includes(this.selectedFile.type);\r\n    else {\r\n      let uploadedFileTypes: string[] = [...this.selectedFiles].map((p) => p.type);\r\n      uploadedFileTypes.forEach((type) => {\r\n        if (!this.acceptedFileTypes.includes(type)) accepted = false;\r\n      });\r\n    }\r\n\r\n    //Questo controllo permette di gestire le casistiche per cui vengono indicati come tipi validi, ad esempio, 'image/*'\r\n    if (!accepted && this.loadMultipleFiles != true) {\r\n      for (let t of this.acceptedFileTypes.split(\",\").filter((t) => t.includes(\"*\"))) {\r\n        accepted = this.selectedFile.type.startsWith(t.split(\"*\")[0]);\r\n        if (accepted) break;\r\n      }\r\n    }\r\n    return accepted;\r\n  }\r\n\r\n  /**\r\n   * Se eqp-attachments è stata configurata per il caricamento delle sole immagini allora verifica che il file passato in\r\n   * input sia effettivamente un immagine o no.\r\n   * Se il controllo va a buon fine restituisce TRUE altrimenti mostra un messaggio d'errore e restituisce FALSE\r\n   */\r\n  private checkAllowOnlyImageFile(newAttachment): boolean {\r\n    if (this.allowOnlyImages == true && newAttachment.IsImage != true) {\r\n      EqpAttachmentDialogService.Error(this.noImageSelectedErrorMessage);\r\n      this.abortFile();\r\n      return false;\r\n    } else if (!this.checkAcceptedFiles()) {\r\n      EqpAttachmentDialogService.Error(this.wrongTypeSelectedErrorMessage);\r\n      this.abortFile();\r\n      return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  //#region Gestione crop file\r\n\r\n  getImageDimensions(img: any) {\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.originalHeight = rs.currentTarget[\"height\"];\r\n        this.originalWidth = rs.currentTarget[\"width\"];\r\n\r\n        if (this.originalWidth > 1280) {\r\n          this.customWidth = 1280;\r\n          this.customHeight = Math.round((1280 * this.originalHeight) / this.originalWidth);\r\n        } else {\r\n          this.customHeight = rs.currentTarget[\"height\"];\r\n          this.customWidth = rs.currentTarget[\"width\"];\r\n        }\r\n      };\r\n    };\r\n    reader.readAsDataURL(img);\r\n  }\r\n\r\n  restoreOriginalDimensions() {\r\n    this.customWidth = this.originalWidth;\r\n    this.customHeight = this.originalHeight;\r\n    this.canvasRotation = 0;\r\n    this.transform = {};\r\n  }\r\n\r\n  onDimensionsChange(dimension: string) {\r\n    if (dimension == \"H\") {\r\n      this.customWidth = Math.round((this.customHeight * this.originalWidth) / this.originalHeight);\r\n    } else if (dimension == \"W\") {\r\n      this.customHeight = Math.round((this.customWidth * this.originalHeight) / this.originalWidth);\r\n    }\r\n  }\r\n\r\n  imageCropped(event: ImageCroppedEvent) {\r\n    this.croppedImage = event.base64;\r\n    this.getCroppedAndUpload(this.croppedImage, this.newAttachment);\r\n  }\r\n\r\n  getCroppedAndUpload(file, newAttachment: IAttachmentDTO) {\r\n    var self = this;\r\n\r\n    var file: any = base64ToFile(file);\r\n\r\n    const options = this.compressionOptions;\r\n\r\n    /**\r\n     * Comprime l'immagine passando come parametri le options create nell'oggetto sopra, e il file dal reader principale\r\n     */\r\n    imageCompression(file, options).then((fileCompressed) => {\r\n      let fileReader = new FileReader();\r\n\r\n      //Faccio la push di ogni file all'interno dell'array di file dell'item da mandare al server\r\n      fileReader.onload = function () {\r\n        let resultReader = <string>fileReader.result;\r\n        var marker = \";base64,\";\r\n        newAttachment.FileDataBase64 = resultReader.substring(resultReader.indexOf(marker) + marker.length);\r\n        self.showCropImage = false;\r\n        if (self.newAttachmentForm) {\r\n          self.newAttachmentForm.enable();\r\n        }\r\n      };\r\n\r\n      fileReader.readAsDataURL(fileCompressed);\r\n    });\r\n  }\r\n\r\n  // confirmCrop() {\r\n  //   this.imageCropper.crop();\r\n  //   this.dialogRefCropImage.close();\r\n  //   this.restoreOriginalDimensions();\r\n  // }\r\n\r\n  rotateLeft() {\r\n    this.canvasRotation--;\r\n    this.flipAfterRotate();\r\n  }\r\n\r\n  rotateRight() {\r\n    this.canvasRotation++;\r\n    this.flipAfterRotate();\r\n  }\r\n\r\n  private flipAfterRotate() {\r\n    const flippedH = this.transform.flipH;\r\n    const flippedV = this.transform.flipV;\r\n    this.transform = {\r\n      ...this.transform,\r\n      flipH: flippedV,\r\n      flipV: flippedH\r\n    };\r\n  }\r\n\r\n  flipHorizontal() {\r\n    this.transform = {\r\n      ...this.transform,\r\n      flipH: !this.transform.flipH\r\n    };\r\n  }\r\n\r\n  flipVertical() {\r\n    this.transform = {\r\n      ...this.transform,\r\n      flipV: !this.transform.flipV\r\n    };\r\n  }\r\n\r\n  //#endregion\r\n\r\n  /**\r\n   * Annulla la selezione del file, svuotando l'input e resettando tutte le proprietà dell'IAttachmentDTO\r\n   */\r\n  abortFile() {\r\n    if (this.imageInput) this.imageInput.nativeElement.value = \"\";\r\n\r\n    this.selectedFile = null;\r\n    this.selectedFiles = null;\r\n    this.showCropImage = false;\r\n\r\n    this.newAttachment.IsImage = false;\r\n    this.newAttachment.FileDataBase64 = null;\r\n    this.newAttachment.FileName = null;\r\n    this.newAttachment.FileExtension = null;\r\n    this.newAttachment.FileContentType = null;\r\n\r\n    this.newMultipleAttachments = new Array<IAttachmentDTO>();\r\n\r\n    this.customHeight = null;\r\n    this.customWidth = null;\r\n    this.originalHeight = null;\r\n    this.originalWidth = null;\r\n\r\n    this.dialogRefCropImage.close();\r\n    this.restoreOriginalDimensions();\r\n  }\r\n\r\n  //#endregion\r\n\r\n  // Viene creato un'array observables per memorizzare tutti gli observable creati dalle chiamate a fileEntry.file().\r\n  // Dopo che tutti gli observables sono stati completati, viene utilizzato il metodo subscribe() per eseguire la funzione onFileAdded().\r\n  fileDropped(files) {\r\n    let filesDropped = [];\r\n\r\n    const observables: Observable<any>[] = [];\r\n    for (let i = 0; i < files.length; i++) {\r\n      if (files[i].fileEntry.isFile) {\r\n        const fileEntry = files[i].fileEntry as FileSystemFileEntry;\r\n        const observable = new Observable((observer) => {\r\n          fileEntry.file((file: File) => {\r\n            filesDropped.push(file);\r\n\r\n            observer.next();\r\n            observer.complete();\r\n          });\r\n        });\r\n        observables.push(observable);\r\n      } else {\r\n        const fileEntry = files[i].fileEntry as FileSystemDirectoryEntry;\r\n        console.log(files[i].relativePath, fileEntry);\r\n      }\r\n    }\r\n\r\n    from(observables)\r\n      .pipe(concatMap((observable) => observable))\r\n      .subscribe({\r\n        complete: () => {\r\n          this.onFileAdded(filesDropped, true);\r\n        }\r\n      });\r\n  }\r\n\r\n  // Se il caricamento del file dropbox va a buon fine, la funzione di callback restituisce un array di oggetti.\r\n  // Viene poi fatta una XMLHttpRequest con responseType 'blob' per convertire il primo elemento della response in un Blob.\r\n  chooseDropboxFile() {\r\n    var options = {\r\n      success: (files: any[]) => {\r\n        const xhr = new XMLHttpRequest();\r\n        xhr.open(\"GET\", files[0].link);\r\n        xhr.setRequestHeader(\"Authorization\", `Bearer ${AttachmentHelperService.dropboxCredentials.accessToken}`);\r\n        xhr.responseType = \"blob\";\r\n\r\n        xhr.onload = () => {\r\n          const blob = xhr.response;\r\n          const file = new File([blob], files[0].name, { type: blob.type });\r\n          let filesAdded = [file];\r\n          this.onFileAdded(filesAdded, true);\r\n        };\r\n\r\n        xhr.send();\r\n      },\r\n      linkType: \"direct\",\r\n      multiselect: false,\r\n      extensions: [\".jpg\", \".png\", \".pdf\", \".doc\", \".docx\", \".txt\"]\r\n    };\r\n    Dropbox.choose(options);\r\n  }\r\n\r\n  // Workaround dropzone: disabilito il click degli elementi inclusi nella dropzone per evitare di cliccare due volte\r\n  onSelectFile(event, fileInput) {\r\n    if (\r\n      (event.target as HTMLButtonElement).tagName === \"BUTTON\" ||\r\n      (event.target as HTMLButtonElement).tagName === \"INPUT\" ||\r\n      this.addingLinkMode == true\r\n    ) {\r\n      return;\r\n    }\r\n    fileInput.click();\r\n  }\r\n\r\n  // Metodo per visualizzare la form di aggiunta di un link\r\n  switchToAddingLinkMode() {\r\n    this.addingLinkMode = true;\r\n    this.newAttachment = {} as IAttachmentDTO;\r\n    this.newAttachment.IsImage = false;\r\n    this.newAttachment.AttachmentType = this.attachmentType.LINK;\r\n    this.newMultipleAttachments = new Array<IAttachmentDTO>();\r\n    this.newMultipleAttachments.push(this.newAttachment);\r\n\r\n    this.createAttachmentForm();\r\n  }\r\n}\r\n","<!-- Se richiesta la gestione singola mostra il pulsante di caricamento di un singolo file -->\r\n<div *ngIf=\"multipleAttachment != true\">\r\n  <div *ngIf=\"!singleAttachmentDragAndDrop\">\r\n    <!-- Template del button per l'aggiunta di un allegato -->\r\n    <div *ngIf=\"!addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addAttachmentButton\"></ng-container>\r\n    </div>\r\n    <!-- Template della form per l'aggiunta di un link -->\r\n    <div *ngIf=\"addingLinkMode\" class=\"text-center\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </div>\r\n  </div>\r\n  <div *ngIf=\"singleAttachmentDragAndDrop\">\r\n    <input\r\n      #fileInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <ngx-file-drop\r\n      (onFileDrop)=\"fileDropped($event)\"\r\n      (click)=\"onSelectFile($event, fileInput)\"\r\n      *ngIf=\"\r\n        allowedTypes &&\r\n        allowedTypes.includes(1) &&\r\n        (!attachmentsList || attachmentsList.length == 0 || (attachmentsList.length > 0 && !attachmentsList[0]))\r\n      \">\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n        <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n        Trascina i file qui\r\n        <div class=\"btn-group mt-1\" role=\"group\">\r\n          <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n          <div class=\"btn-group\" role=\"group\">\r\n            <button\r\n              type=\"button\"\r\n              class=\"btn btn-light border-start dropdown-toggle\"\r\n              [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n            <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(1)\"\r\n                mat-menu-item\r\n                (click)=\"fileInput.click()\"\r\n                class=\"eqp-attachments-file-btn\">\r\n                <i class=\"fas fa-file\"></i>\r\n                <span style=\"margin-left: 10px\">File</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(2)\"\r\n                mat-menu-item\r\n                (click)=\"switchToAddingLinkMode()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fas fa-link\"></i>\r\n                <span style=\"margin-left: 10px\">Link</span>\r\n              </button>\r\n              <button\r\n                *ngIf=\"allowedTypes.includes(3)\"\r\n                mat-menu-item\r\n                (click)=\"chooseDropboxFile()\"\r\n                class=\"eqp-attachments-link-btn\">\r\n                <i class=\"fa-brands fa-dropbox\"></i>\r\n                <span style=\"margin-left: 10px\">Dropbox</span>\r\n              </button>\r\n            </mat-menu>\r\n          </div>\r\n        </div>\r\n      </ng-template>\r\n      <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n        <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n      </ng-template>\r\n    </ngx-file-drop>\r\n  </div>\r\n  <div class=\"text-center\">\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-download-btn\"\r\n      (click)=\"viewAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      color=\"primary\">\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType == AttachmentType.FILE\">download</mat-icon>\r\n      <mat-icon *ngIf=\"attachmentsList[0].AttachmentType != AttachmentType.FILE\">open_in_new</mat-icon>\r\n      {{ attachmentsList[0].AttachmentType == AttachmentType.FILE ? downloadLabel : openLinkLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 me-2 eqp-attachments-preview-btn\"\r\n      (click)=\"openPreviewDialog(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      color=\"primary\"\r\n      *ngIf=\"\r\n        showPreview &&\r\n        attachmentsList &&\r\n        attachmentsList.length > 0 &&\r\n        attachmentsList[0] &&\r\n        (!attachmentsList[0].FileContentType ||\r\n          (!attachmentsList[0].FileContentType.startsWith('video') &&\r\n            !attachmentsList[0].FileContentType.startsWith('audio'))) &&\r\n        attachmentsList[0].IsImage == true\r\n      \">\r\n      <mat-icon>visibility</mat-icon> {{ previewLabel }}\r\n    </button>\r\n    <button\r\n      class=\"mb-2 eqp-attachments-delete-btn\"\r\n      (click)=\"deleteAttachment(attachmentsList[0])\"\r\n      type=\"button\"\r\n      mat-raised-button\r\n      *ngIf=\"attachmentsList && attachmentsList.length > 0 && attachmentsList[0]\"\r\n      [disabled]=\"isDisabled\">\r\n      <mat-icon>delete</mat-icon> {{ deleteLabel }}\r\n    </button>\r\n  </div>\r\n  <div\r\n    class=\"row\"\r\n    style=\"margin-top: 10px\"\r\n    *ngIf=\"\r\n      attachmentsList.length > 0 &&\r\n      attachmentsList[0] &&\r\n      attachmentsList[0].FileDataBase64 &&\r\n      attachmentsList[0].IsImage == true\r\n    \">\r\n    <div class=\"col-sm-12 d-flex justify-content-center\">\r\n      <div class=\"single-attachment-inline-preview-container\">\r\n        <img src=\"data:image/png;base64,{{ attachmentsList[0].FileDataBase64 }}\" />\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row\" *ngIf=\"attachmentsList.length > 0 && attachmentsList[0] && attachmentsList[0].IsImage != true\">\r\n    <div class=\"col-sm-12\">\r\n      <mat-form-field>\r\n        <mat-label>{{ fileNameLabel }}</mat-label>\r\n        <input readonly matInput [(ngModel)]=\"attachmentsList[0].FileName\" />\r\n      </mat-form-field>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div *ngIf=\"multipleAttachment == true\">\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <ngx-file-drop (onFileDrop)=\"fileDropped($event)\" (click)=\"onSelectFile($event, fileInput)\">\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"!addingLinkMode\">\r\n      <i class=\"fa-solid fa-cloud-upload-alt fa-3x mt-3\"></i>\r\n      Trascina i file qui\r\n      <div class=\"btn-group mt-1\" role=\"group\">\r\n        <button type=\"button\" class=\"btn btn-light border-end\" (click)=\"fileInput.click()\">Scegli un file</button>\r\n        <div class=\"btn-group\" role=\"group\">\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn btn-light border-start dropdown-toggle\"\r\n            [matMenuTriggerFor]=\"attachmentTypeMenu\"></button>\r\n          <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(1)\"\r\n              mat-menu-item\r\n              (click)=\"fileInput.click()\"\r\n              class=\"eqp-attachments-file-btn\">\r\n              <i class=\"fas fa-file\"></i>\r\n              <span style=\"margin-left: 10px\">File</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(2)\"\r\n              mat-menu-item\r\n              (click)=\"switchToAddingLinkMode()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fas fa-link\"></i>\r\n              <span style=\"margin-left: 10px\">Link</span>\r\n            </button>\r\n            <button\r\n              *ngIf=\"allowedTypes.includes(3)\"\r\n              mat-menu-item\r\n              (click)=\"chooseDropboxFile()\"\r\n              class=\"eqp-attachments-link-btn\">\r\n              <i class=\"fa-brands fa-dropbox\"></i>\r\n              <span style=\"margin-left: 10px\">Dropbox</span>\r\n            </button>\r\n          </mat-menu>\r\n        </div>\r\n      </div>\r\n    </ng-template>\r\n    <ng-template ngx-file-drop-content-tmp *ngIf=\"addingLinkMode\">\r\n      <ng-container *ngTemplateOutlet=\"addingLinkTemplate\"></ng-container>\r\n    </ng-template>\r\n  </ngx-file-drop>\r\n  <div class=\"mt-2\">\r\n    <eqp-table\r\n      #attachmentTable\r\n      [createMatCard]=\"false\"\r\n      #table\r\n      [columns]=\"attachmentsColumns\"\r\n      [isMultiLanguage]=\"isEqpTableMultiLanguage\"\r\n      [data]=\"attachmentsList\"\r\n      [paginatorVisible]=\"tablePaginatorVisible\"\r\n      [matPaginatorSize]=\"tablePaginatorSize\"\r\n      [emptyTableMessage]=\"emptyTableMessage\"\r\n      [searchText]=\"eqpTableSearchText\"\r\n      [isTableSearcheable]=\"isTableSearcheable\">\r\n    </eqp-table>\r\n  </div>\r\n</div>\r\n\r\n<ng-template #dialogCropImage>\r\n  <!-- Richiama il template per le funzionalità del CROPPIE -->\r\n  <div style=\"overflow-x: hidden\" [ngClass]=\"cropDialogClass\">\r\n    <ng-container\r\n      [ngTemplateOutlet]=\"croppieTemplate\"\r\n      [ngTemplateOutletContext]=\"{ form: newAttachmentForm }\"\r\n      *ngIf=\"showCropImage == true\"></ng-container>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #inlinePreviewTemplate let-row=\"row\">\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <img src=\"data:image/png;base64,{{ row.FileThumbnailBase64 ? row.FileThumbnailBase64 : row.FileDataBase64 }}\" />\r\n  </div>\r\n  <div\r\n    class=\"inline-preview-container\"\r\n    *ngIf=\"row.AttachmentType != AttachmentType.LINK && !row.IsImage\"\r\n    (click)=\"openPreviewDialog(row)\">\r\n    <i [ngClass]=\"getAttachmentIcon(row)\"></i>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #dialogPreview>\r\n  <mat-card class=\"example-card\" *ngIf=\"selectedAttachment\">\r\n    <mat-card-content>\r\n      <div class=\"row\">\r\n        <div class=\"header-title-standard\">\r\n          {{ previewLabel }} {{ selectedAttachment?.AttachmentType == attachmentType.FILE ? \"File\" : \"Link\" }}\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn-close closeButton\"\r\n            mat-dialog-close\r\n            (click)=\"selectedAttachment = null\"></button>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-2\">\r\n        <!-- ANTEPRIMA IMMAGINE -->\r\n        <div class=\"col-12 text-center preview-container\" *ngIf=\"selectedAttachment.IsImage\">\r\n          <img\r\n            class=\"image-preview\"\r\n            src=\"data:image/png;base64,{{\r\n              selectedAttachment.FileDataBase64\r\n                ? selectedAttachment.FileDataBase64\r\n                : selectedAttachment.FileThumbnailBase64\r\n            }}\" />\r\n        </div>\r\n\r\n        <!-- ANTEPRIMA LINK -->\r\n        <div class=\"col-12 preview-container\" *ngIf=\"!selectedAttachment.IsImage\">\r\n          <iframe\r\n            class=\"link-preview\"\r\n            [src]=\"selectedAttachment.TrustedUrl\"\r\n            [title]=\"selectedAttachment.FileName\"></iframe>\r\n        </div>\r\n      </div>\r\n      <div class=\"row mt-3\">\r\n        <div class=\"col-sm-12 text-center\">\r\n          <button\r\n            mat-mini-fab\r\n            color=\"primary\"\r\n            matTooltip=\"Download\"\r\n            (click)=\"viewAttachment(selectedAttachment)\"\r\n            *ngIf=\"selectedAttachment.AttachmentType != AttachmentType.LINK\">\r\n            <mat-icon>download</mat-icon>\r\n          </button>\r\n        </div>\r\n      </div>\r\n    </mat-card-content>\r\n  </mat-card>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER IL PULSANTE DI AGGIUNTA NUOVO ALLEGATO -->\r\n<ng-template #addAttachmentButton>\r\n  <!--\r\n        Pulsanti per l'aggiunta di un file o un link. Ne viene visualizzato uno se:\r\n        - gli allowedTypes sono stati specificati, nell'array ne è presente uno solo, quello inserito è AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di più allegati (multipleAttachment == true)\r\n        OPPURE\r\n        - gli allowedTypes sono stati specificati, nell'array ne è presente uno solo, quello inserito è AttachmentType.FILE (o AttachmentType.LINK)\r\n        e sono nella gestione di un singolo allegato (multipleAttachment == true) e non ne è ancora stato selezionato uno (ovvero attachmentsList non esiste o non ha elementi)\r\n    -->\r\n  <input\r\n    #fileInput\r\n    style=\"display: none\"\r\n    id=\"file_attachment\"\r\n    name=\"file_attachment\"\r\n    type=\"file\"\r\n    (change)=\"onFileAdded($event)\"\r\n    [accept]=\"acceptedFileTypes\"\r\n    [multiple]=\"loadMultipleFiles\" />\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    *ngIf=\"\r\n      allowedTypes &&\r\n      allowedTypes.length == 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \"\r\n    (click)=\"addFile(allowedTypes[0], fileInput)\"\r\n    [disabled]=\"isDisabled\">\r\n    <!-- Per l'aggiunta dei file mostro un'icona diversa dall'aggiunta dei link -->\r\n    <mat-icon *ngIf=\"allowedTypes[0] == 1\">cloud_upload</mat-icon>\r\n    <i class=\"fas fa-link\" *ngIf=\"allowedTypes[0] == 2\"></i>\r\n    <i class=\"fa-brands fa-dropbox\" *ngIf=\"allowedTypes[0] == 3\"></i>\r\n    <span style=\"margin-left: 10px\">\r\n      {{\r\n        allowedTypes[0] == 1\r\n          ? addButtonLabel + \" file\"\r\n          : allowedTypes[0] == 2\r\n          ? addButtonLabel + \" link\"\r\n          : uploadWithDropboxLabel\r\n      }}</span\r\n    >\r\n  </button>\r\n\r\n  <!-- Pulsante per aprire il menu per la scelta del tipo di Attachment da creare -->\r\n  <button\r\n    class=\"btn btn-primary mb-4 me-5 eqp-attachments-add-btn\"\r\n    mat-raised-button\r\n    color=\"primary\"\r\n    type=\"button\"\r\n    [matMenuTriggerFor]=\"attachmentTypeMenu\"\r\n    [disabled]=\"isDisabled\"\r\n    *ngIf=\"\r\n      !separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <mat-icon *ngIf=\"multipleAttachment != true\">cloud_upload</mat-icon>\r\n    <mat-icon *ngIf=\"multipleAttachment == true\">add</mat-icon>\r\n    <span style=\"margin-left: 0px\"> {{ addButtonLabel }} </span>\r\n  </button>\r\n  <mat-menu #attachmentTypeMenu=\"matMenu\">\r\n    <input\r\n      #imageInput\r\n      style=\"display: none\"\r\n      id=\"file_attachment\"\r\n      name=\"file_attachment\"\r\n      type=\"file\"\r\n      (change)=\"onFileAdded($event)\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      [multiple]=\"loadMultipleFiles\" />\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(1)\"\r\n      mat-menu-item\r\n      (click)=\"imageInput.click()\"\r\n      class=\"eqp-attachments-file-btn\">\r\n      <i class=\"fas fa-file\"></i>\r\n      <span style=\"margin-left: 10px\">File</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(2)\"\r\n      mat-menu-item\r\n      (click)=\"switchToAddingLinkMode()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fas fa-link\"></i>\r\n      <span style=\"margin-left: 10px\">Link</span>\r\n    </button>\r\n    <button\r\n      *ngIf=\"allowedTypes.includes(3)\"\r\n      mat-menu-item\r\n      (click)=\"chooseDropboxFile()\"\r\n      class=\"eqp-attachments-link-btn\">\r\n      <i class=\"fa-brands fa-dropbox\"></i>\r\n      <span style=\"margin-left: 10px\">Dropbox</span>\r\n    </button>\r\n  </mat-menu>\r\n\r\n  <div\r\n    *ngIf=\"\r\n      separatedUploadButtons &&\r\n      allowedTypes &&\r\n      allowedTypes.length > 1 &&\r\n      (multipleAttachment == true ||\r\n        !attachmentsList ||\r\n        attachmentsList.length == 0 ||\r\n        (attachmentsList.length > 0 && !attachmentsList[0]))\r\n    \">\r\n    <div class=\"btn-group\">\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(1)\"\r\n        (click)=\"imageInput.click()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-solid fa-cloud-upload\"></i>\r\n        <span style=\"margin-left: 10px\">File</span>\r\n      </button>\r\n      <input\r\n        #imageInput\r\n        style=\"display: none\"\r\n        id=\"file_attachment\"\r\n        name=\"file_attachment\"\r\n        type=\"file\"\r\n        (change)=\"onFileAdded($event)\"\r\n        [accept]=\"acceptedFileTypes\"\r\n        [multiple]=\"loadMultipleFiles\" />\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(2)\"\r\n        (click)=\"switchToAddingLinkMode()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fas fa-link\"></i>\r\n        <span style=\"margin-left: 10px\">Link</span>\r\n      </button>\r\n      <button\r\n        *ngIf=\"allowedTypes.includes(3)\"\r\n        (click)=\"chooseDropboxFile()\"\r\n        class=\"btn btn-secondary eqp-attachments-add-btn\"\r\n        mat-raised-button\r\n        color=\"secondary\"\r\n        type=\"button\">\r\n        <i class=\"fa-brands fa-dropbox\"></i>\r\n        <span style=\"margin-left: 10px\">Dropbox</span>\r\n      </button>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #croppieTemplate>\r\n  <div class=\"row m-3\">\r\n    <h4>{{ cropLabel }}</h4>\r\n  </div>\r\n  <div class=\"row m-2 crop-large\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        [matTooltip]=\"rotateLeftLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateLeft()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_left</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"rotateRightLabel\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"rotateRight()\">\r\n        <mat-icon style=\"vertical-align: middle\">rotate_right</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipHorinzontalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipHorizontal()\">\r\n        <mat-icon style=\"vertical-align: middle\">flip_horizontal</mat-icon>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"flipVerticalLabel\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"flipVertical()\">\r\n        <div style=\"transform: rotate(90deg)\"><mat-icon style=\"vertical-align: middle\">flip_vertical</mat-icon></div>\r\n      </button>\r\n      <button\r\n        [matTooltip]=\"'Reset'\"\r\n        class=\"btn btn-primary mat-raised-button ms-2\"\r\n        (click)=\"restoreOriginalDimensions()\">\r\n        <mat-icon style=\"vertical-align: middle\">replay</mat-icon>\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row m-2 crop-small\">\r\n    <div class=\"col-md-12 d-flex align-items-center justify-content-center\">\r\n      <mat-icon *ngIf=\"cropOptions.includes(1)\" style=\"font-size: 27px; vertical-align: middle\" (click)=\"rotateLeft()\"\r\n        >rotate_left</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(1)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"rotateRight()\"\r\n        >rotate_right</mat-icon\r\n      >\r\n      <mat-icon\r\n        class=\"ms-3\"\r\n        *ngIf=\"cropOptions.includes(2)\"\r\n        style=\"font-size: 27px; vertical-align: middle\"\r\n        (click)=\"flipHorizontal()\"\r\n        >flip_horizontal</mat-icon\r\n      >\r\n      <div class=\"ms-3\" style=\"transform: rotate(90deg)\">\r\n        <mat-icon\r\n          *ngIf=\"cropOptions.includes(2)\"\r\n          style=\"font-size: 27px; vertical-align: middle\"\r\n          (click)=\"flipVertical()\"\r\n          >flip_vertical</mat-icon\r\n        >\r\n      </div>\r\n      <mat-icon class=\"ms-3\" (click)=\"restoreOriginalDimensions()\" style=\"font-size: 27px; vertical-align: middle\"\r\n        >replay</mat-icon\r\n      >\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <div class=\"crop-container\">\r\n        <image-cropper\r\n          [imageFile]=\"selectedFile\"\r\n          [maintainAspectRatio]=\"false\"\r\n          [autoCrop]=\"false\"\r\n          [containWithinAspectRatio]=\"false\"\r\n          [aspectRatio]=\"4 / 3\"\r\n          [cropperMinWidth]=\"128\"\r\n          [onlyScaleDown]=\"true\"\r\n          [roundCropper]=\"false\"\r\n          [canvasRotation]=\"0\"\r\n          [transform]=\"transform\"\r\n          [alignImage]=\"'left'\"\r\n          format=\"png\"\r\n          (imageCropped)=\"imageCropped($event)\"\r\n          [resizeToWidth]=\"customWidth\"\r\n          [resizeToHeight]=\"customHeight\"\r\n          [canvasRotation]=\"canvasRotation\">\r\n        </image-cropper>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-large\">\r\n    <div class=\"col-12 d-flex align-items-center justify-content-center\">\r\n      <button\r\n        class=\"btn btn-primary mat-raised-button eqp-attachments-confirm-btn me-2\"\r\n        type=\"button\"\r\n        (click)=\"confirmAddAttachment()\">\r\n        {{ confirmLabel }}\r\n      </button>\r\n      <button class=\"btn mat-raised-button eqp-attachments-abort-btn\" type=\"button\" (click)=\"abortFile()\">\r\n        {{ abortLabel }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n  <div class=\"row justify-content-center mt-2 mb-2 crop-small\">\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-times\" (click)=\"abortFile()\"></i>\r\n    </div>\r\n    <div class=\"col-6 d-flex align-items-center justify-content-center\" style=\"font-size: 20px\">\r\n      <i class=\"fa fa-check\" (click)=\"confirmAddAttachment()\"></i>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<!-- TEMPLATE PER FORM DI AGGIUNTA DI UN LINK -->\r\n<ng-template #addingLinkTemplate>\r\n  <span class=\"mb-1\" style=\"font-size: 20px\"><i class=\"fa fa-link\"></i>Inserisci l'URL</span>\r\n  <form [formGroup]=\"newAttachmentForm\" *ngIf=\"newAttachmentForm\">\r\n    <div class=\"row mb-2\" style=\"height: 80px\">\r\n      <div class=\"col-6 d-grid gap-2 mx-auto\">\r\n        <div class=\"input-group mb-1\">\r\n          <input\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"{{ fileNameLabel }}\"\r\n            formControlName=\"name\"\r\n            [(ngModel)]=\"newAttachment.FileName\" />\r\n        </div>\r\n      </div>\r\n      <div class=\"col-12 d-grid gap-2\">\r\n        <div class=\"input-group\">\r\n          <input\r\n            required\r\n            type=\"text\"\r\n            class=\"form-control\"\r\n            placeholder=\"Link\"\r\n            formControlName=\"path\"\r\n            [(ngModel)]=\"newAttachment.FilePath\" />\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <div class=\"row\">\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-secondary mat-raised-button\"\r\n          (click)=\"selectedAttachment = null; addingLinkMode = false\"\r\n          type=\"button\">\r\n          {{ exitLabel }}\r\n        </button>\r\n      </div>\r\n      <div class=\"col-6 d-grid gap-2\">\r\n        <button\r\n          class=\"btn btn-primary mat-raised-button\"\r\n          type=\"submit\"\r\n          (click)=\"confirmAddAttachment(); selectedAttachment = null; addingLinkMode = false\">\r\n          {{ saveLabel }}\r\n        </button>\r\n      </div>\r\n    </div>\r\n  </form>\r\n</ng-template>\r\n"]}