@pega/angular-sdk-components 0.23.1

package/esm2022/lib/_components/widget/attachment/attachment.component.mjs

@@ -0,0 +1,588 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import download from 'downloadjs';
+import { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../_bridge/angular-pconnect";
+import * as i2 from "../../../_helpers/utils";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/progress-spinner";
+import * as i5 from "@angular/material/button";
+export class AttachmentComponent {
+    constructor(angularPConnect, utils, ngZone) {
+        this.angularPConnect = angularPConnect;
+        this.utils = utils;
+        this.ngZone = ngZone;
+        // For interaction with AngularPConnect
+        this.angularPConnectData = {};
+        this.label$ = '';
+        this.bRequired$ = false;
+        this.bReadonly$ = false;
+        this.bDisabled$ = false;
+        this.bVisible$ = true;
+        this.bLoading$ = false;
+        this.arFiles$ = [];
+        this.arFileList$ = [];
+        this.arMenuList$ = [];
+        this.bShowSelector$ = true;
+        this.bShowJustDelete$ = false;
+        this.fileTemp = {};
+        this.allowMultiple$ = false;
+        this.extensions$ = '';
+        this.status = '';
+        this.validateMessage = '';
+        this.fileDownload = (data, fileName, ext) => {
+            const file = ext ? `${fileName}.${ext}` : fileName;
+            download(atob(data), file);
+        };
+        this.getAttachmentKey = (name = '') => (name ? `attachmentsList.${name}` : 'attachmentsList');
+        this.getNewListUtilityItemProps = ({ att, cancelFile, downloadFile, deleteFile, removeFile }) => {
+            let actions;
+            let isDownloadable = false;
+            if (att.progress && att.progress !== 100) {
+                actions = [
+                    {
+                        id: `Cancel-${att.ID}`,
+                        text: this.pConn$.getLocalizedValue('Cancel', '', ''),
+                        icon: 'times',
+                        onClick: cancelFile
+                    }
+                ];
+            }
+            else if (att.links) {
+                const isFile = att.type === 'FILE';
+                const ID = att.ID.replace(/\s/gi, '');
+                const actionsMap = new Map([
+                    [
+                        'download',
+                        {
+                            id: `download-${ID}`,
+                            text: isFile ? this.pConn$.getLocalizedValue('Download', '', '') : this.pConn$.getLocalizedValue('Open', '', ''),
+                            icon: isFile ? 'download' : 'open',
+                            onClick: downloadFile
+                        }
+                    ],
+                    [
+                        'delete',
+                        {
+                            id: `Delete-${ID}`,
+                            text: this.pConn$.getLocalizedValue('Delete', '', ''),
+                            icon: 'trash',
+                            onClick: deleteFile
+                        }
+                    ]
+                ]);
+                actions = [];
+                actionsMap.forEach((action, actionKey) => {
+                    if (att.links[actionKey]) {
+                        actions.push(action);
+                    }
+                });
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                isDownloadable = att.links.download;
+            }
+            else if (att.error) {
+                actions = [
+                    {
+                        id: `Remove-${att.ID}`,
+                        text: this.pConn$.getLocalizedValue('Remove', '', ''),
+                        icon: 'trash',
+                        onClick: removeFile
+                    }
+                ];
+            }
+            return {
+                id: att.ID,
+                visual: {
+                    icon: this.utils.getIconForAttachment(att),
+                    progress: att.progress == 100 ? undefined : att.progress
+                },
+                primary: {
+                    type: att.type,
+                    name: att.error ? att.fileName : att.name,
+                    icon: 'trash',
+                    click: removeFile
+                },
+                secondary: {
+                    text: att.meta,
+                    error: att.error
+                },
+                actions
+            };
+        };
+        this.validateFileExtension = (fileObj, allowedExtensions) => {
+            if (!allowedExtensions) {
+                return true;
+            }
+            const allowedExtensionList = allowedExtensions
+                .toLowerCase()
+                .split(',')
+                .map(item => item.replaceAll('.', '').trim());
+            const extension = fileObj.name.split('.').pop().toLowerCase();
+            return allowedExtensionList.includes(extension);
+        };
+    }
+    ngOnInit() {
+        // // First thing in initialization is registering and subscribing to the AngularPConnect service
+        this.angularPConnectData = this.angularPConnect.registerAndSubscribeComponent(this, this.onStateChange);
+        this.removeFileFromList$ = { onClick: this._removeFileFromList.bind(this) };
+        this.caseID = PCore.getStoreValue('.pyID', 'caseInfo.content', this.pConn$.getContextName());
+        // let configProps: any = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps());
+        this.checkAndUpdate();
+    }
+    checkAndUpdate() {
+        // Should always check the bridge to see if the component should
+        // update itself (re-render)
+        const bUpdateSelf = this.angularPConnect.shouldComponentUpdate(this);
+        // ONLY call updateSelf when the component should update
+        if (bUpdateSelf) {
+            this.updateSelf();
+        }
+    }
+    ngOnDestroy() {
+        if (this.angularPConnectData.unsubscribeFn) {
+            this.angularPConnectData.unsubscribeFn();
+        }
+        PCore.getPubSubUtils().unsubscribe(PCore.getConstants().PUB_SUB_EVENTS.CASE_EVENTS.ASSIGNMENT_SUBMISSION, this.caseID);
+    }
+    // Callback passed when subscribing to store change
+    onStateChange() {
+        this.checkAndUpdate();
+    }
+    updateAttachmentsInfo() {
+        // @ts-ignore - Property 'attachmentsInfo' does not exist on type 'C11nEnv'
+        if (!this.pConn$.attachmentsInfo) {
+            // @ts-ignore - Property 'attachmentsInfo' does not exist on type 'C11nEnv'
+            this.pConn$.attachmentsInfo = {
+                type: 'File',
+                attachmentFieldName: this.att_valueRef,
+                category: this.att_categoryName
+            };
+        }
+    }
+    processFile(file, i) {
+        file.props.type = file.responseProps.pyMimeFileExtension;
+        file.props.mimeType = file.responseProps.pyMimeFileExtension;
+        file.props.ID = file.responseProps.pzInsKey;
+        const arMenuList = [
+            {
+                icon: 'download',
+                text: this.pConn$.getLocalizedValue('Download', '', ''),
+                onClick: () => this._downloadFileFromList(this.value$.pxResults[i])
+            },
+            {
+                icon: 'trash',
+                text: this.pConn$.getLocalizedValue('Delete', '', ''),
+                onClick: () => this._removeFileFromList(this.arFileList$[i])
+            }
+        ];
+        const arFilesAttachmentIDs = [];
+        this.arFileList$.forEach(arFile => {
+            arFilesAttachmentIDs.push(arFile.id);
+        });
+        if (!arFilesAttachmentIDs.includes(file.props.ID)) {
+            this.arFileList$.push(this.getNewListUtilityItemProps({
+                att: file.props,
+                downloadFile: null,
+                cancelFile: null,
+                deleteFile: null,
+                removeFile: null
+            }));
+        }
+        this.arFileList$[i].actions = arMenuList;
+        this.arFileList$[i].noDeleteIcon = true;
+        this.bShowSelector$ = false;
+    }
+    updateSelf() {
+        const configProps = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps());
+        const stateProps = this.pConn$.getStateProps();
+        const { value, label, extensions } = configProps;
+        if (configProps.required != null) {
+            this.bRequired$ = this.utils.getBooleanValue(configProps.required);
+        }
+        if (configProps.visibility != null) {
+            this.bVisible$ = this.utils.getBooleanValue(configProps.visibility);
+        }
+        // disabled
+        if (configProps.disabled != undefined) {
+            this.bDisabled$ = this.utils.getBooleanValue(configProps.disabled);
+        }
+        if (configProps.readOnly != null) {
+            this.bReadonly$ = this.utils.getBooleanValue(configProps.readOnly);
+        }
+        if (configProps.allowMultiple != null) {
+            this.allowMultiple$ = this.utils.getBooleanValue(configProps.allowMultiple);
+        }
+        this.bShowJustDelete$ = true;
+        this.label$ = label;
+        this.value$ = value;
+        this.status = stateProps.status;
+        this.validateMessage = this.angularPConnectData.validateMessage;
+        this.extensions$ = extensions;
+        this.valueRef = this.pConn$.getStateProps().value;
+        this.valueRef = this.valueRef.startsWith('.') ? this.valueRef.substring(1) : this.valueRef;
+        /* this is a temporary fix because required is supposed to be passed as a boolean and NOT as a string */
+        let { required, disabled } = configProps;
+        [required, disabled] = [required, disabled].map(prop => prop === true || (typeof prop === 'string' && prop === 'true'));
+        this.att_categoryName = '';
+        if (value && value.pyCategoryName) {
+            this.att_categoryName = value.pyCategoryName;
+        }
+        this.att_valueRef = this.pConn$.getStateProps().value;
+        this.att_valueRef = this.att_valueRef.indexOf('.') === 0 ? this.att_valueRef.substring(1) : this.att_valueRef;
+        this.updateAttachments();
+    }
+    updateAttachments() {
+        const attachmentsFromServer = this.value$ && this.value$.pxResults && +this.value$.pyCount > 0;
+        if (attachmentsFromServer) {
+            this.updateAttachmentsFromServer();
+        }
+        else {
+            // Get the attachments from the Redux
+            this.myFiles = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());
+            if (this.myFiles?.length && this.arFiles$.length === 0) {
+                this.arFileList$ = this.myFiles.map(att => {
+                    return this.getNewListUtilityItemProps({
+                        att,
+                        downloadFile: null,
+                        cancelFile: null,
+                        deleteFile: null,
+                        removeFile: null
+                    });
+                });
+            }
+            const myFilesAttachmentIDs = [];
+            this.myFiles.forEach(myFile => {
+                myFilesAttachmentIDs.push(myFile.ID);
+            });
+            this.arFiles$.forEach(arFile => {
+                if (!myFilesAttachmentIDs.includes(arFile.ID)) {
+                    this.myFiles = [...this.myFiles, arFile];
+                }
+            });
+        }
+        this.bShowJustDelete$ = true;
+        this.bShowSelector$ = !(this.arFileList$?.length > 0) || this.allowMultiple$;
+        if (this.arFileList$.length > 0) {
+            this.CheckForInvalidAttachment();
+        }
+        PCore.getPubSubUtils().subscribe(PCore.getConstants().PUB_SUB_EVENTS.CASE_EVENTS.ASSIGNMENT_SUBMISSION, this.resetAttachmentStoredState.bind(this), this.caseID);
+    }
+    updateAttachmentsFromServer() {
+        this.value$.pxResults.forEach((attachment, i) => {
+            const file = this.buildFilePropsFromResponse(attachment);
+            if (file.responseProps) {
+                this.updateAttachmentsInfo();
+                if (file.responseProps.pzInsKey && !file.responseProps.pzInsKey.includes('temp')) {
+                    this.processFile(file, i);
+                }
+                if (file) {
+                    const currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());
+                    const index = currentAttachmentList.findIndex(element => element.props.ID === file.props.ID);
+                    let tempFiles = [];
+                    if (index < 0) {
+                        tempFiles = [file];
+                    }
+                    PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), [...currentAttachmentList, ...tempFiles], {
+                        pageReference: 'context_data',
+                        isArrayDeepMerge: false
+                    });
+                }
+            }
+        });
+    }
+    resetAttachmentStoredState() {
+        PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), undefined, {
+            pageReference: 'context_data',
+            isArrayDeepMerge: false
+        });
+    }
+    _downloadFileFromList(fileObj) {
+        PCore.getAttachmentUtils()
+            // @ts-ignore - 3rd parameter "responseEncoding" should be optional
+            .downloadAttachment(fileObj.pzInsKey, this.pConn$.getContextName())
+            .then((content) => {
+            const extension = fileObj.pyAttachName.split('.').pop();
+            this.fileDownload(content.data, fileObj.pyFileName, extension);
+        })
+            .catch(e => {
+            console.log(e);
+        });
+    }
+    CheckForInvalidAttachment() {
+        let isValid = true;
+        this.arFileList$.forEach(file => {
+            if (file.secondary.error) {
+                isValid = false;
+            }
+        });
+        if (isValid) {
+            // @ts-ignore
+            PCore.getMessageManager().clearMessages({
+                type: PCore.getConstants().MESSAGES.MESSAGES_TYPE_ERROR,
+                property: this.pConn$.getStateProps().value,
+                pageReference: this.pConn$.getPageReference(),
+                context: this.pConn$.getContextName()
+            });
+        }
+    }
+    _removeFileFromList(item) {
+        const fileListIndex = this.arFileList$.findIndex(element => element?.id === item?.id);
+        const fileIndex = this.arFiles$.findIndex(element => element?.ID === item?.id);
+        const attachmentsList = [];
+        let currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());
+        if (this.value$ && this.value$.pxResults && +this.value$.pyCount > 0 && item.actions) {
+            const updatedAttachments = currentAttachmentList.map(attachment => {
+                if (attachment?.ID === this.arFileList$[fileListIndex].id || attachment?.props?.ID === this.arFileList$[fileListIndex].id) {
+                    return { ...attachment, delete: true, label: this.valueRef };
+                }
+                return attachment;
+            });
+            // updating the redux store to help form-handler in passing the data to delete the file from server
+            PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), updatedAttachments, {
+                pageReference: 'context_data',
+                isArrayDeepMerge: false
+            });
+        }
+        else {
+            currentAttachmentList = currentAttachmentList.filter(f => f.ID !== item.id);
+            PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), [...currentAttachmentList, ...attachmentsList], {
+                pageReference: 'context_data',
+                isArrayDeepMerge: false
+            });
+        }
+        if (fileListIndex > -1) {
+            this.arFileList$.splice(fileListIndex, 1);
+        }
+        if (fileIndex > -1) {
+            this.arFiles$.splice(fileIndex, 1);
+        }
+        this.CheckForInvalidAttachment();
+        this.bShowSelector$ = !(this.arFileList$?.length > 0) || this.allowMultiple$;
+    }
+    getCurrentAttachmentsList(key, context) {
+        return PCore.getStoreValue(`.${key}`, 'context_data', context) || [];
+    }
+    errorHandler(isFetchCanceled, file) {
+        return error => {
+            if (!isFetchCanceled(error)) {
+                let uploadFailMsg = this.pConn$.getLocalizedValue('Something went wrong', '', '');
+                if (error.response && error.response.data && error.response.data.errorDetails) {
+                    uploadFailMsg = this.pConn$.getLocalizedValue(error.response.data.errorDetails[0].localizedValue, '', '');
+                }
+                for (const myFile of this.myFiles) {
+                    if (myFile.ID === file.ID) {
+                        myFile.meta = uploadFailMsg;
+                        myFile.error = true;
+                        myFile.fileName = this.pConn$.getLocalizedValue('Unable to upload file', '', '');
+                    }
+                }
+                this.bShowSelector$ = false;
+                this.arFileList$ = this.myFiles.map(att => {
+                    if (att.id) {
+                        return att;
+                    }
+                    return this.getNewListUtilityItemProps({
+                        att,
+                        downloadFile: null,
+                        cancelFile: null,
+                        deleteFile: null,
+                        removeFile: null
+                    });
+                });
+                PCore.getMessageManager().addMessages({
+                    // @ts-ignore
+                    messages: [
+                        {
+                            type: 'error',
+                            message: this.pConn$.getLocalizedValue('Error with one or more files', '', '')
+                        }
+                    ],
+                    property: this.pConn$.getStateProps().value,
+                    pageReference: this.pConn$.getPageReference(),
+                    context: this.pConn$.getContextName()
+                });
+                this.bShowJustDelete$ = true;
+                this.bLoading$ = false;
+            }
+            throw error;
+        };
+    }
+    uploadMyFiles(event) {
+        let arrAttachmentFiles = [];
+        if (this.arFiles$.length) {
+            arrAttachmentFiles = this.arFiles$;
+        }
+        else {
+            arrAttachmentFiles = this.arFileList$;
+        }
+        this.arFiles$ = [...arrAttachmentFiles, ...this.getFiles(event.target.files)];
+        // convert FileList to an array
+        this.myFiles = Array.from(this.arFiles$);
+        this.bLoading$ = true;
+        const filesToBeUploaded = this.myFiles
+            .filter(e => {
+            if (e.id) {
+                return false;
+            }
+            const isFileUploaded = e && e.progress === 100;
+            const fileHasError = e && e.error;
+            const isFileUploadedinLastStep = e.responseProps && e.responseProps.pzInsKey;
+            return !isFileUploaded && !fileHasError && !isFileUploadedinLastStep;
+        })
+            .map(f => PCore.getAttachmentUtils().uploadAttachment(f, () => {
+            this.onUploadProgress();
+        }, isFetchCanceled => {
+            return this.errorHandler(isFetchCanceled, f);
+        }, this.pConn$.getContextName()));
+        Promise.allSettled(filesToBeUploaded)
+            .then((fileResponses) => {
+            this.handleFileUploadSuccess(fileResponses);
+        })
+            .catch(error => {
+            console.log(error);
+            this.handleFileUploadFailure();
+        });
+    }
+    handleFileUploadSuccess(fileResponses) {
+        const successFileResponses = fileResponses.filter(fr => fr.status !== 'rejected'); // in case of deleting an in progress file, promise gets cancelled but still enters then block
+        let reqObj;
+        if (successFileResponses.length > 0) {
+            const tempFilesUploaded = [...this.arFiles$.filter(file => !file.id)];
+            let newAttachments = [];
+            tempFilesUploaded.forEach(fileRes => {
+                const index = successFileResponses.findIndex((fr) => fr.value.clientFileID === fileRes.ID);
+                if (index >= 0) {
+                    reqObj = {
+                        type: 'File',
+                        label: this.att_valueRef,
+                        category: this.att_categoryName,
+                        handle: successFileResponses[index].value.ID,
+                        ID: fileRes.ID,
+                        name: fileRes.name
+                    };
+                    newAttachments = [...newAttachments, reqObj];
+                }
+            });
+            const currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName()).filter(f => f.label !== this.att_valueRef);
+            PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), [...currentAttachmentList, ...newAttachments], {
+                pageReference: 'context_data',
+                isArrayDeepMerge: false
+            });
+            this.arFiles$ = tempFilesUploaded;
+            this.ngZone.run(() => {
+                this.bShowSelector$ = this.allowMultiple$;
+                this.arFiles$.forEach(file => {
+                    if (!file.error) {
+                        file.meta = this.pConn$.getLocalizedValue('File uploaded successfully', '', '');
+                    }
+                });
+                this.arFileList$ = this.myFiles.map(att => {
+                    if (att.id) {
+                        return att;
+                    }
+                    return this.getNewListUtilityItemProps({
+                        att,
+                        downloadFile: null,
+                        cancelFile: null,
+                        deleteFile: null,
+                        removeFile: null
+                    });
+                });
+                this.CheckForInvalidAttachment();
+                this.bShowJustDelete$ = true;
+                this.bLoading$ = false;
+            });
+        }
+    }
+    handleFileUploadFailure() {
+        this.bShowJustDelete$ = true;
+        this.bLoading$ = false;
+        this.bShowSelector$ = this.allowMultiple$;
+        this.myFiles.forEach(file => {
+            if (file?.secondary?.error) {
+                file.meta = 'File uploaded failed';
+            }
+        });
+        this.arFileList$ = this.myFiles.map(att => {
+            return this.getNewListUtilityItemProps({
+                att,
+                downloadFile: null,
+                cancelFile: null,
+                deleteFile: null,
+                removeFile: null
+            });
+        });
+        this.bShowJustDelete$ = true;
+        this.bLoading$ = false;
+    }
+    onUploadProgress() { }
+    getFiles(arFiles) {
+        const files = this.allowMultiple$ ? arFiles : [arFiles[0]];
+        return this.setNewFiles(files);
+    }
+    setNewFiles(arFiles) {
+        let index = 0;
+        const maxAttachmentSize = PCore.getEnvironmentInfo().getMaxAttachmentSize() || 5;
+        for (const file of arFiles) {
+            file.mimeType = file.type;
+            file.icon = this.utils.getIconFromFileType(file.type);
+            file.ID = `${new Date().getTime()}I${index}`;
+            if (!this.validateMaxSize(file, maxAttachmentSize)) {
+                file.error = true;
+                file.meta = this.pConn$.getLocalizedValue('File is too big. Max allowed size is 5MB.', '', '');
+            }
+            else if (!this.validateFileExtension(file, this.extensions$)) {
+                file.error = true;
+                file.meta = `${this.pConn$.getLocalizedValue('File has invalid extension. Allowed extensions are:', '', '')} ${this.extensions$.replaceAll('.', '')}`;
+            }
+            if (file.error) {
+                const fieldName = this.pConn$.getStateProps().value;
+                const context = this.pConn$.getContextName();
+                PCore.getMessageManager().addMessages({
+                    // @ts-ignore
+                    messages: [
+                        {
+                            type: 'error',
+                            message: this.pConn$.getLocalizedValue('Error with one or more files', '', '')
+                        }
+                    ],
+                    property: fieldName,
+                    pageReference: this.pConn$.getPageReference(),
+                    context
+                });
+            }
+            index++;
+        }
+        return [...arFiles];
+    }
+    validateMaxSize(fileObj, maxSizeInMB) {
+        const fileSize = (fileObj.size / 1048576).toFixed(2);
+        return parseFloat(fileSize) < parseFloat(maxSizeInMB);
+    }
+    buildFilePropsFromResponse(respObj) {
+        return {
+            props: {
+                meta: `${respObj.pyCategoryName}, ${respObj.pxCreateOperator}`,
+                name: respObj.pyAttachName,
+                icon: this.utils.getIconFromFileType(respObj.pyMimeFileExtension)
+            },
+            responseProps: {
+                ...respObj
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttachmentComponent, deps: [{ token: i1.AngularPConnectService }, { token: i2.Utils }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AttachmentComponent, isStandalone: true, selector: "app-attachment", inputs: { pConn$: "pConn$", formGroup$: "formGroup$" }, ngImport: i0, template: "<div class=\"psdk-label-infix-readonly\" *ngIf=\"bVisible$\">\n  <span class=\"psdk-label-wrapper-readonly\">\n    <label [ngClass]=\"{ 'psdk-label-readonly': true, 'label-required': bRequired$ === true }\" [htmlFor]=\"att_valueRef\">{{ label$ }}</label>\n  </span>\n  <div\n    [ngClass]=\"{ 'psdk-modal-file-selector': status !== 'error', 'psdk-modal-file-selector-error': status === 'error' }\"\n    id=\"attachment-container\"\n    *ngIf=\"bShowSelector$\"\n  >\n    <mat-spinner *ngIf=\"bLoading$\" class=\"progress-spinner\" diameter=\"40\"></mat-spinner>\n    <input hidden type=\"file\" [required]=\"bRequired$\" #uploader [id]=\"att_valueRef\" [multiple]=\"allowMultiple$\" (change)=\"uploadMyFiles($event)\" />\n\n    <button mat-stroked-button color=\"primary\" [disabled]=\"bDisabled$\" (click)=\"uploader.click()\">\n      {{ allowMultiple$ ? 'Upload files' : 'Upload file' }}\n    </button>\n  </div>\n  <span *ngIf=\"validateMessage\" class=\"file-error\">{{ validateMessage }}</span>\n\n  <div class=\"psdk-attachment-list\" *ngIf=\"arFileList$ != null && arFileList$.length > 0\">\n    <div *ngFor=\"let attachment of arFileList$\">\n      <component-mapper\n        *ngIf=\"attachment.noDeleteIcon !== true; else showfull\"\n        name=\"SummaryItem\"\n        [props]=\"{ item$: attachment, menuIconOverride$: 'trash', menuIconOverrideAction$: removeFileFromList$ }\"\n      ></component-mapper>\n      <ng-template #showfull>\n        <component-mapper name=\"SummaryItem\" [props]=\"{ item$: attachment, menuIconOverrideAction$: removeFileFromList$ }\"></component-mapper>\n      </ng-template>\n    </div>\n  </div>\n</div>\n", styles: [".progress-spinner{text-align:center;position:absolute;left:45%}.psdk-modal-file-selector{border:1px dashed #262626;width:100%;padding:.3rem;text-align:center;position:relative}.label-required:after{display:inline;content:\" *\";vertical-align:top;color:#262626}.file-error{color:#e57373}.psdk-modal-file-selector-error{border:1px dashed #e57373;width:100%;padding:.3rem;text-align:center;position:relative}.psdk-full-width{width:100%}.psdk-label-readonly{opacity:54%;font-size:.8rem;font-weight:400}.psdk-data-readonly{padding-top:.625rem;width:100%}.psdk-attachment-list{border:1px solid grey}::ng-deep .mat-mdc-form-field-infix{width:auto}\n"], dependencies: [{ kind: "ngmodule", type: i0.forwardRef(function () { return CommonModule; }) }, { kind: "directive", type: i0.forwardRef(function () { return i3.NgClass; }), selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i0.forwardRef(function () { return i3.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i0.forwardRef(function () { return i3.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatProgressSpinnerModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i4.MatProgressSpinner; }), selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "ngmodule", type: i0.forwardRef(function () { return MatButtonModule; }) }, { kind: "component", type: i0.forwardRef(function () { return i5.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: i0.forwardRef(function () { return ComponentMapperComponent; }), selector: "component-mapper", inputs: ["name", "props", "errorMsg", "outputEvents", "parent"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AttachmentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-attachment', standalone: true, imports: [CommonModule, MatProgressSpinnerModule, MatButtonModule, forwardRef(() => ComponentMapperComponent)], template: "<div class=\"psdk-label-infix-readonly\" *ngIf=\"bVisible$\">\n  <span class=\"psdk-label-wrapper-readonly\">\n    <label [ngClass]=\"{ 'psdk-label-readonly': true, 'label-required': bRequired$ === true }\" [htmlFor]=\"att_valueRef\">{{ label$ }}</label>\n  </span>\n  <div\n    [ngClass]=\"{ 'psdk-modal-file-selector': status !== 'error', 'psdk-modal-file-selector-error': status === 'error' }\"\n    id=\"attachment-container\"\n    *ngIf=\"bShowSelector$\"\n  >\n    <mat-spinner *ngIf=\"bLoading$\" class=\"progress-spinner\" diameter=\"40\"></mat-spinner>\n    <input hidden type=\"file\" [required]=\"bRequired$\" #uploader [id]=\"att_valueRef\" [multiple]=\"allowMultiple$\" (change)=\"uploadMyFiles($event)\" />\n\n    <button mat-stroked-button color=\"primary\" [disabled]=\"bDisabled$\" (click)=\"uploader.click()\">\n      {{ allowMultiple$ ? 'Upload files' : 'Upload file' }}\n    </button>\n  </div>\n  <span *ngIf=\"validateMessage\" class=\"file-error\">{{ validateMessage }}</span>\n\n  <div class=\"psdk-attachment-list\" *ngIf=\"arFileList$ != null && arFileList$.length > 0\">\n    <div *ngFor=\"let attachment of arFileList$\">\n      <component-mapper\n        *ngIf=\"attachment.noDeleteIcon !== true; else showfull\"\n        name=\"SummaryItem\"\n        [props]=\"{ item$: attachment, menuIconOverride$: 'trash', menuIconOverrideAction$: removeFileFromList$ }\"\n      ></component-mapper>\n      <ng-template #showfull>\n        <component-mapper name=\"SummaryItem\" [props]=\"{ item$: attachment, menuIconOverrideAction$: removeFileFromList$ }\"></component-mapper>\n      </ng-template>\n    </div>\n  </div>\n</div>\n", styles: [".progress-spinner{text-align:center;position:absolute;left:45%}.psdk-modal-file-selector{border:1px dashed #262626;width:100%;padding:.3rem;text-align:center;position:relative}.label-required:after{display:inline;content:\" *\";vertical-align:top;color:#262626}.file-error{color:#e57373}.psdk-modal-file-selector-error{border:1px dashed #e57373;width:100%;padding:.3rem;text-align:center;position:relative}.psdk-full-width{width:100%}.psdk-label-readonly{opacity:54%;font-size:.8rem;font-weight:400}.psdk-data-readonly{padding-top:.625rem;width:100%}.psdk-attachment-list{border:1px solid grey}::ng-deep .mat-mdc-form-field-infix{width:auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AngularPConnectService }, { type: i2.Utils }, { type: i0.NgZone }]; }, propDecorators: { pConn$: [{
+                type: Input
+            }], formGroup$: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attachment.component.js","sourceRoot":"","sources":["../../../../../../../packages/angular-sdk-components/src/lib/_components/widget/attachment/attachment.component.ts","../../../../../../../packages/angular-sdk-components/src/lib/_components/widget/attachment/attachment.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, NgZone, forwardRef, OnDestroy } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { CommonModule } from '@angular/common';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport download from 'downloadjs';\nimport { AngularPConnectData, AngularPConnectService } from '../../../_bridge/angular-pconnect';\nimport { Utils } from '../../../_helpers/utils';\nimport { ComponentMapperComponent } from '../../../_bridge/component-mapper/component-mapper.component';\nimport { PConnFieldProps } from '../../../_types/PConnProps.interface';\n\ninterface AttachmentProps extends Omit<PConnFieldProps, 'value'> {\n  // If any, enter additional props that only exist on this component\n  value: any;\n  extensions: any;\n  allowMultiple: boolean;\n}\n\n@Component({\n  selector: 'app-attachment',\n  templateUrl: './attachment.component.html',\n  styleUrls: ['./attachment.component.scss'],\n  standalone: true,\n  imports: [CommonModule, MatProgressSpinnerModule, MatButtonModule, forwardRef(() => ComponentMapperComponent)]\n})\nexport class AttachmentComponent implements OnInit, OnDestroy {\n  @Input() pConn$: typeof PConnect;\n  @Input() formGroup$: FormGroup;\n\n  // For interaction with AngularPConnect\n  angularPConnectData: AngularPConnectData = {};\n\n  label$ = '';\n  value$: any;\n  bRequired$ = false;\n  bReadonly$ = false;\n  bDisabled$ = false;\n  bVisible$ = true;\n  bLoading$ = false;\n  arFiles$: any[] = [];\n  arFileList$: any[] = [];\n  removeFileFromList$: any;\n  arMenuList$: any[] = [];\n  bShowSelector$ = true;\n  bShowJustDelete$ = false;\n  att_valueRef: any;\n  att_categoryName: string;\n  att_id: string;\n  myFiles: any;\n  fileTemp: any = {};\n  caseID: any;\n  allowMultiple$ = false;\n  extensions$ = '';\n  status = '';\n  validateMessage: string | undefined = '';\n  valueRef: string;\n  imagePath$: string;\n\n  constructor(\n    private angularPConnect: AngularPConnectService,\n    private utils: Utils,\n    private ngZone: NgZone\n  ) {}\n\n  ngOnInit(): void {\n    // // First thing in initialization is registering and subscribing to the AngularPConnect service\n    this.angularPConnectData = this.angularPConnect.registerAndSubscribeComponent(this, this.onStateChange);\n\n    this.removeFileFromList$ = { onClick: this._removeFileFromList.bind(this) };\n\n    this.caseID = PCore.getStoreValue('.pyID', 'caseInfo.content', this.pConn$.getContextName());\n\n    // let configProps: any = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps());\n    this.checkAndUpdate();\n  }\n\n  checkAndUpdate() {\n    // Should always check the bridge to see if the component should\n    // update itself (re-render)\n    const bUpdateSelf = this.angularPConnect.shouldComponentUpdate(this);\n\n    // ONLY call updateSelf when the component should update\n    if (bUpdateSelf) {\n      this.updateSelf();\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.angularPConnectData.unsubscribeFn) {\n      this.angularPConnectData.unsubscribeFn();\n    }\n\n    PCore.getPubSubUtils().unsubscribe(PCore.getConstants().PUB_SUB_EVENTS.CASE_EVENTS.ASSIGNMENT_SUBMISSION, this.caseID);\n  }\n\n  // Callback passed when subscribing to store change\n  onStateChange() {\n    this.checkAndUpdate();\n  }\n\n  updateAttachmentsInfo() {\n    // @ts-ignore - Property 'attachmentsInfo' does not exist on type 'C11nEnv'\n    if (!this.pConn$.attachmentsInfo) {\n      // @ts-ignore - Property 'attachmentsInfo' does not exist on type 'C11nEnv'\n      this.pConn$.attachmentsInfo = {\n        type: 'File',\n        attachmentFieldName: this.att_valueRef,\n        category: this.att_categoryName\n      };\n    }\n  }\n\n  processFile(file, i) {\n    file.props.type = file.responseProps.pyMimeFileExtension;\n    file.props.mimeType = file.responseProps.pyMimeFileExtension;\n    file.props.ID = file.responseProps.pzInsKey;\n\n    const arMenuList = [\n      {\n        icon: 'download',\n        text: this.pConn$.getLocalizedValue('Download', '', ''),\n        onClick: () => this._downloadFileFromList(this.value$.pxResults[i])\n      },\n      {\n        icon: 'trash',\n        text: this.pConn$.getLocalizedValue('Delete', '', ''),\n        onClick: () => this._removeFileFromList(this.arFileList$[i])\n      }\n    ];\n\n    const arFilesAttachmentIDs: any = [];\n    this.arFileList$.forEach(arFile => {\n      arFilesAttachmentIDs.push(arFile.id);\n    });\n\n    if (!arFilesAttachmentIDs.includes(file.props.ID)) {\n      this.arFileList$.push(\n        this.getNewListUtilityItemProps({\n          att: file.props,\n          downloadFile: null,\n          cancelFile: null,\n          deleteFile: null,\n          removeFile: null\n        })\n      );\n    }\n\n    this.arFileList$[i].actions = arMenuList;\n    this.arFileList$[i].noDeleteIcon = true;\n\n    this.bShowSelector$ = false;\n  }\n\n  updateSelf() {\n    const configProps: AttachmentProps = this.pConn$.resolveConfigProps(this.pConn$.getConfigProps()) as AttachmentProps;\n    const stateProps: any = this.pConn$.getStateProps();\n\n    const { value, label, extensions } = configProps;\n\n    if (configProps.required != null) {\n      this.bRequired$ = this.utils.getBooleanValue(configProps.required);\n    }\n    if (configProps.visibility != null) {\n      this.bVisible$ = this.utils.getBooleanValue(configProps.visibility);\n    }\n\n    // disabled\n    if (configProps.disabled != undefined) {\n      this.bDisabled$ = this.utils.getBooleanValue(configProps.disabled);\n    }\n\n    if (configProps.readOnly != null) {\n      this.bReadonly$ = this.utils.getBooleanValue(configProps.readOnly);\n    }\n\n    if (configProps.allowMultiple != null) {\n      this.allowMultiple$ = this.utils.getBooleanValue(configProps.allowMultiple);\n    }\n\n    this.bShowJustDelete$ = true;\n    this.label$ = label;\n    this.value$ = value;\n    this.status = stateProps.status;\n    this.validateMessage = this.angularPConnectData.validateMessage;\n    this.extensions$ = extensions;\n    this.valueRef = (this.pConn$.getStateProps() as any).value;\n    this.valueRef = this.valueRef.startsWith('.') ? this.valueRef.substring(1) : this.valueRef;\n\n    /* this is a temporary fix because required is supposed to be passed as a boolean and NOT as a string */\n    let { required, disabled } = configProps;\n    [required, disabled] = [required, disabled].map(prop => prop === true || (typeof prop === 'string' && prop === 'true'));\n\n    this.att_categoryName = '';\n    if (value && value.pyCategoryName) {\n      this.att_categoryName = value.pyCategoryName;\n    }\n\n    this.att_valueRef = (this.pConn$.getStateProps() as any).value;\n    this.att_valueRef = this.att_valueRef.indexOf('.') === 0 ? this.att_valueRef.substring(1) : this.att_valueRef;\n\n    this.updateAttachments();\n  }\n\n  updateAttachments() {\n    const attachmentsFromServer = this.value$ && this.value$.pxResults && +this.value$.pyCount > 0;\n\n    if (attachmentsFromServer) {\n      this.updateAttachmentsFromServer();\n    } else {\n      // Get the attachments from the Redux\n      this.myFiles = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());\n\n      if (this.myFiles?.length && this.arFiles$.length === 0) {\n        this.arFileList$ = this.myFiles.map(att => {\n          return this.getNewListUtilityItemProps({\n            att,\n            downloadFile: null,\n            cancelFile: null,\n            deleteFile: null,\n            removeFile: null\n          });\n        });\n      }\n\n      const myFilesAttachmentIDs: any = [];\n      this.myFiles.forEach(myFile => {\n        myFilesAttachmentIDs.push(myFile.ID);\n      });\n\n      this.arFiles$.forEach(arFile => {\n        if (!myFilesAttachmentIDs.includes(arFile.ID)) {\n          this.myFiles = [...this.myFiles, arFile];\n        }\n      });\n    }\n\n    this.bShowJustDelete$ = true;\n    this.bShowSelector$ = !(this.arFileList$?.length > 0) || this.allowMultiple$;\n\n    if (this.arFileList$.length > 0) {\n      this.CheckForInvalidAttachment();\n    }\n    PCore.getPubSubUtils().subscribe(\n      PCore.getConstants().PUB_SUB_EVENTS.CASE_EVENTS.ASSIGNMENT_SUBMISSION,\n      this.resetAttachmentStoredState.bind(this),\n      this.caseID\n    );\n  }\n\n  updateAttachmentsFromServer() {\n    this.value$.pxResults.forEach((attachment, i) => {\n      const file: any = this.buildFilePropsFromResponse(attachment);\n      if (file.responseProps) {\n        this.updateAttachmentsInfo();\n        if (file.responseProps.pzInsKey && !file.responseProps.pzInsKey.includes('temp')) {\n          this.processFile(file, i);\n        }\n        if (file) {\n          const currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());\n          const index = currentAttachmentList.findIndex(element => element.props.ID === file.props.ID);\n          let tempFiles: any = [];\n          if (index < 0) {\n            tempFiles = [file];\n          }\n\n          PCore.getStateUtils().updateState(\n            this.pConn$.getContextName(),\n            this.getAttachmentKey(this.att_valueRef),\n            [...currentAttachmentList, ...tempFiles],\n            {\n              pageReference: 'context_data',\n              isArrayDeepMerge: false\n            }\n          );\n        }\n      }\n    });\n  }\n\n  resetAttachmentStoredState() {\n    PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), undefined, {\n      pageReference: 'context_data',\n      isArrayDeepMerge: false\n    });\n  }\n\n  _downloadFileFromList(fileObj: any) {\n    PCore.getAttachmentUtils()\n      // @ts-ignore - 3rd parameter \"responseEncoding\" should be optional\n      .downloadAttachment(fileObj.pzInsKey, this.pConn$.getContextName())\n      .then((content: any) => {\n        const extension = fileObj.pyAttachName.split('.').pop();\n        this.fileDownload(content.data, fileObj.pyFileName, extension);\n      })\n      .catch(e => {\n        console.log(e);\n      });\n  }\n\n  fileDownload = (data, fileName, ext) => {\n    const file = ext ? `${fileName}.${ext}` : fileName;\n    download(atob(data), file);\n  };\n\n  getAttachmentKey = (name = '') => (name ? `attachmentsList.${name}` : 'attachmentsList');\n\n  CheckForInvalidAttachment() {\n    let isValid = true;\n    this.arFileList$.forEach(file => {\n      if (file.secondary.error) {\n        isValid = false;\n      }\n    });\n    if (isValid) {\n      // @ts-ignore\n      PCore.getMessageManager().clearMessages({\n        type: PCore.getConstants().MESSAGES.MESSAGES_TYPE_ERROR,\n        property: (this.pConn$.getStateProps() as any).value,\n        pageReference: this.pConn$.getPageReference(),\n        context: this.pConn$.getContextName()\n      });\n    }\n  }\n\n  _removeFileFromList(item: any) {\n    const fileListIndex = this.arFileList$.findIndex(element => element?.id === item?.id);\n    const fileIndex = this.arFiles$.findIndex(element => element?.ID === item?.id);\n\n    const attachmentsList = [];\n    let currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName());\n    if (this.value$ && this.value$.pxResults && +this.value$.pyCount > 0 && item.actions) {\n      const updatedAttachments = currentAttachmentList.map(attachment => {\n        if (attachment?.ID === this.arFileList$[fileListIndex].id || attachment?.props?.ID === this.arFileList$[fileListIndex].id) {\n          return { ...attachment, delete: true, label: this.valueRef };\n        }\n        return attachment;\n      });\n\n      // updating the redux store to help form-handler in passing the data to delete the file from server\n      PCore.getStateUtils().updateState(this.pConn$.getContextName(), this.getAttachmentKey(this.att_valueRef), updatedAttachments, {\n        pageReference: 'context_data',\n        isArrayDeepMerge: false\n      });\n    } else {\n      currentAttachmentList = currentAttachmentList.filter(f => f.ID !== item.id);\n      PCore.getStateUtils().updateState(\n        this.pConn$.getContextName(),\n        this.getAttachmentKey(this.att_valueRef),\n        [...currentAttachmentList, ...attachmentsList],\n        {\n          pageReference: 'context_data',\n          isArrayDeepMerge: false\n        }\n      );\n    }\n\n    if (fileListIndex > -1) {\n      this.arFileList$.splice(fileListIndex, 1);\n    }\n    if (fileIndex > -1) {\n      this.arFiles$.splice(fileIndex, 1);\n    }\n\n    this.CheckForInvalidAttachment();\n\n    this.bShowSelector$ = !(this.arFileList$?.length > 0) || this.allowMultiple$;\n  }\n\n  getCurrentAttachmentsList(key, context) {\n    return PCore.getStoreValue(`.${key}`, 'context_data', context) || [];\n  }\n\n  errorHandler(isFetchCanceled, file) {\n    return error => {\n      if (!isFetchCanceled(error)) {\n        let uploadFailMsg = this.pConn$.getLocalizedValue('Something went wrong', '', '');\n        if (error.response && error.response.data && error.response.data.errorDetails) {\n          uploadFailMsg = this.pConn$.getLocalizedValue(error.response.data.errorDetails[0].localizedValue, '', '');\n        }\n        for (const myFile of this.myFiles) {\n          if (myFile.ID === file.ID) {\n            myFile.meta = uploadFailMsg;\n            myFile.error = true;\n            myFile.fileName = this.pConn$.getLocalizedValue('Unable to upload file', '', '');\n          }\n        }\n        this.bShowSelector$ = false;\n        this.arFileList$ = this.myFiles.map(att => {\n          if (att.id) {\n            return att;\n          }\n          return this.getNewListUtilityItemProps({\n            att,\n            downloadFile: null,\n            cancelFile: null,\n            deleteFile: null,\n            removeFile: null\n          });\n        });\n\n        PCore.getMessageManager().addMessages({\n          // @ts-ignore\n          messages: [\n            {\n              type: 'error',\n              message: this.pConn$.getLocalizedValue('Error with one or more files', '', '')\n            }\n          ],\n          property: (this.pConn$.getStateProps() as any).value,\n          pageReference: this.pConn$.getPageReference(),\n          context: this.pConn$.getContextName()\n        });\n\n        this.bShowJustDelete$ = true;\n        this.bLoading$ = false;\n      }\n      throw error;\n    };\n  }\n\n  uploadMyFiles(event: any) {\n    let arrAttachmentFiles: any = [];\n    if (this.arFiles$.length) {\n      arrAttachmentFiles = this.arFiles$;\n    } else {\n      arrAttachmentFiles = this.arFileList$;\n    }\n    this.arFiles$ = [...arrAttachmentFiles, ...this.getFiles(event.target.files)];\n\n    // convert FileList to an array\n    this.myFiles = Array.from(this.arFiles$);\n\n    this.bLoading$ = true;\n\n    const filesToBeUploaded = this.myFiles\n      .filter(e => {\n        if (e.id) {\n          return false;\n        }\n        const isFileUploaded = e && e.progress === 100;\n        const fileHasError = e && e.error;\n        const isFileUploadedinLastStep = e.responseProps && e.responseProps.pzInsKey;\n        return !isFileUploaded && !fileHasError && !isFileUploadedinLastStep;\n      })\n      .map(f =>\n        PCore.getAttachmentUtils().uploadAttachment(\n          f,\n          () => {\n            this.onUploadProgress();\n          },\n          isFetchCanceled => {\n            return this.errorHandler(isFetchCanceled, f);\n          },\n          this.pConn$.getContextName()\n        )\n      );\n\n    Promise.allSettled(filesToBeUploaded)\n      .then((fileResponses: any) => {\n        this.handleFileUploadSuccess(fileResponses);\n      })\n      .catch(error => {\n        console.log(error);\n        this.handleFileUploadFailure();\n      });\n  }\n\n  handleFileUploadSuccess(fileResponses) {\n    const successFileResponses = fileResponses.filter(fr => fr.status !== 'rejected'); // in case of deleting an in progress file, promise gets cancelled but still enters then block\n    let reqObj;\n    if (successFileResponses.length > 0) {\n      const tempFilesUploaded = [...this.arFiles$.filter(file => !file.id)];\n      let newAttachments: any = [];\n      tempFilesUploaded.forEach(fileRes => {\n        const index = successFileResponses.findIndex((fr: any) => fr.value.clientFileID === fileRes.ID);\n        if (index >= 0) {\n          reqObj = {\n            type: 'File',\n            label: this.att_valueRef,\n            category: this.att_categoryName,\n            handle: successFileResponses[index].value.ID,\n            ID: fileRes.ID,\n            name: fileRes.name\n          };\n          newAttachments = [...newAttachments, reqObj];\n        }\n      });\n      const currentAttachmentList = this.getCurrentAttachmentsList(this.getAttachmentKey(this.att_valueRef), this.pConn$.getContextName()).filter(\n        f => f.label !== this.att_valueRef\n      );\n      PCore.getStateUtils().updateState(\n        this.pConn$.getContextName(),\n        this.getAttachmentKey(this.att_valueRef),\n        [...currentAttachmentList, ...newAttachments],\n        {\n          pageReference: 'context_data',\n          isArrayDeepMerge: false\n        }\n      );\n      this.arFiles$ = tempFilesUploaded;\n\n      this.ngZone.run(() => {\n        this.bShowSelector$ = this.allowMultiple$;\n        this.arFiles$.forEach(file => {\n          if (!file.error) {\n            file.meta = this.pConn$.getLocalizedValue('File uploaded successfully', '', '');\n          }\n        });\n        this.arFileList$ = this.myFiles.map(att => {\n          if (att.id) {\n            return att;\n          }\n          return this.getNewListUtilityItemProps({\n            att,\n            downloadFile: null,\n            cancelFile: null,\n            deleteFile: null,\n            removeFile: null\n          });\n        });\n\n        this.CheckForInvalidAttachment();\n\n        this.bShowJustDelete$ = true;\n        this.bLoading$ = false;\n      });\n    }\n  }\n\n  handleFileUploadFailure() {\n    this.bShowJustDelete$ = true;\n    this.bLoading$ = false;\n    this.bShowSelector$ = this.allowMultiple$;\n    this.myFiles.forEach(file => {\n      if (file?.secondary?.error) {\n        file.meta = 'File uploaded failed';\n      }\n    });\n\n    this.arFileList$ = this.myFiles.map(att => {\n      return this.getNewListUtilityItemProps({\n        att,\n        downloadFile: null,\n        cancelFile: null,\n        deleteFile: null,\n        removeFile: null\n      });\n    });\n\n    this.bShowJustDelete$ = true;\n    this.bLoading$ = false;\n  }\n\n  getNewListUtilityItemProps = ({ att, cancelFile, downloadFile, deleteFile, removeFile }) => {\n    let actions;\n    let isDownloadable = false;\n\n    if (att.progress && att.progress !== 100) {\n      actions = [\n        {\n          id: `Cancel-${att.ID}`,\n          text: this.pConn$.getLocalizedValue('Cancel', '', ''),\n          icon: 'times',\n          onClick: cancelFile\n        }\n      ];\n    } else if (att.links) {\n      const isFile = att.type === 'FILE';\n      const ID = att.ID.replace(/\\s/gi, '');\n      const actionsMap = new Map([\n        [\n          'download',\n          {\n            id: `download-${ID}`,\n            text: isFile ? this.pConn$.getLocalizedValue('Download', '', '') : this.pConn$.getLocalizedValue('Open', '', ''),\n            icon: isFile ? 'download' : 'open',\n            onClick: downloadFile\n          }\n        ],\n        [\n          'delete',\n          {\n            id: `Delete-${ID}`,\n            text: this.pConn$.getLocalizedValue('Delete', '', ''),\n            icon: 'trash',\n            onClick: deleteFile\n          }\n        ]\n      ]);\n      actions = [];\n      actionsMap.forEach((action, actionKey) => {\n        if (att.links[actionKey]) {\n          actions.push(action);\n        }\n      });\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      isDownloadable = att.links.download;\n    } else if (att.error) {\n      actions = [\n        {\n          id: `Remove-${att.ID}`,\n          text: this.pConn$.getLocalizedValue('Remove', '', ''),\n          icon: 'trash',\n          onClick: removeFile\n        }\n      ];\n    }\n\n    return {\n      id: att.ID,\n      visual: {\n        icon: this.utils.getIconForAttachment(att),\n        progress: att.progress == 100 ? undefined : att.progress\n      },\n      primary: {\n        type: att.type,\n        name: att.error ? att.fileName : att.name,\n        icon: 'trash',\n        click: removeFile\n      },\n      secondary: {\n        text: att.meta,\n        error: att.error\n      },\n      actions\n    };\n  };\n\n  onUploadProgress() {}\n\n  getFiles(arFiles: any[]): any[] {\n    const files = this.allowMultiple$ ? arFiles : [arFiles[0]];\n    return this.setNewFiles(files);\n  }\n\n  setNewFiles(arFiles) {\n    let index = 0;\n    const maxAttachmentSize = PCore.getEnvironmentInfo().getMaxAttachmentSize() || 5;\n    for (const file of arFiles) {\n      file.mimeType = file.type;\n      file.icon = this.utils.getIconFromFileType(file.type);\n      file.ID = `${new Date().getTime()}I${index}`;\n\n      if (!this.validateMaxSize(file, maxAttachmentSize)) {\n        file.error = true;\n        file.meta = this.pConn$.getLocalizedValue('File is too big. Max allowed size is 5MB.', '', '');\n      } else if (!this.validateFileExtension(file, this.extensions$)) {\n        file.error = true;\n        file.meta = `${this.pConn$.getLocalizedValue('File has invalid extension. Allowed extensions are:', '', '')} ${this.extensions$.replaceAll(\n          '.',\n          ''\n        )}`;\n      }\n      if (file.error) {\n        const fieldName = (this.pConn$.getStateProps() as any).value;\n        const context = this.pConn$.getContextName();\n        PCore.getMessageManager().addMessages({\n          // @ts-ignore\n          messages: [\n            {\n              type: 'error',\n              message: this.pConn$.getLocalizedValue('Error with one or more files', '', '')\n            }\n          ],\n          property: fieldName,\n          pageReference: this.pConn$.getPageReference(),\n          context\n        });\n      }\n      index++;\n    }\n\n    return [...arFiles];\n  }\n\n  validateMaxSize(fileObj, maxSizeInMB): boolean {\n    const fileSize = (fileObj.size / 1048576).toFixed(2);\n    return parseFloat(fileSize) < parseFloat(maxSizeInMB);\n  }\n\n  validateFileExtension = (fileObj, allowedExtensions) => {\n    if (!allowedExtensions) {\n      return true;\n    }\n    const allowedExtensionList = allowedExtensions\n      .toLowerCase()\n      .split(',')\n      .map(item => item.replaceAll('.', '').trim());\n    const extension = fileObj.name.split('.').pop().toLowerCase();\n    return allowedExtensionList.includes(extension);\n  };\n\n  buildFilePropsFromResponse(respObj) {\n    return {\n      props: {\n        meta: `${respObj.pyCategoryName}, ${respObj.pxCreateOperator}`,\n        name: respObj.pyAttachName,\n        icon: this.utils.getIconFromFileType(respObj.pyMimeFileExtension)\n      },\n      responseProps: {\n        ...respObj\n      }\n    };\n  }\n}\n","<div class=\"psdk-label-infix-readonly\" *ngIf=\"bVisible$\">\n  <span class=\"psdk-label-wrapper-readonly\">\n    <label [ngClass]=\"{ 'psdk-label-readonly': true, 'label-required': bRequired$ === true }\" [htmlFor]=\"att_valueRef\">{{ label$ }}</label>\n  </span>\n  <div\n    [ngClass]=\"{ 'psdk-modal-file-selector': status !== 'error', 'psdk-modal-file-selector-error': status === 'error' }\"\n    id=\"attachment-container\"\n    *ngIf=\"bShowSelector$\"\n  >\n    <mat-spinner *ngIf=\"bLoading$\" class=\"progress-spinner\" diameter=\"40\"></mat-spinner>\n    <input hidden type=\"file\" [required]=\"bRequired$\" #uploader [id]=\"att_valueRef\" [multiple]=\"allowMultiple$\" (change)=\"uploadMyFiles($event)\" />\n\n    <button mat-stroked-button color=\"primary\" [disabled]=\"bDisabled$\" (click)=\"uploader.click()\">\n      {{ allowMultiple$ ? 'Upload files' : 'Upload file' }}\n    </button>\n  </div>\n  <span *ngIf=\"validateMessage\" class=\"file-error\">{{ validateMessage }}</span>\n\n  <div class=\"psdk-attachment-list\" *ngIf=\"arFileList$ != null && arFileList$.length > 0\">\n    <div *ngFor=\"let attachment of arFileList$\">\n      <component-mapper\n        *ngIf=\"attachment.noDeleteIcon !== true; else showfull\"\n        name=\"SummaryItem\"\n        [props]=\"{ item$: attachment, menuIconOverride$: 'trash', menuIconOverrideAction$: removeFileFromList$ }\"\n      ></component-mapper>\n      <ng-template #showfull>\n        <component-mapper name=\"SummaryItem\" [props]=\"{ item$: attachment, menuIconOverrideAction$: removeFileFromList$ }\"></component-mapper>\n      </ng-template>\n    </div>\n  </div>\n</div>\n"]}