mmhglobal-dynamicform 1.2.3 → 1.3.2

package/esm2020/lib/zupload/zupload.component.mjs

@@ -0,0 +1,359 @@
+/********** Angular **********/
+import { Component, Input, ViewChild } from "@angular/core";
+import { Validators } from "@angular/forms";
+/********** Ionic **********/
+/********** Plugin **********/
+// import { environment } from "src/environments/environment";
+import { take } from 'rxjs/operators';
+import { HttpEventType } from '@angular/common/http';
+/********** Component & Service **********/
+import { ZComponentHelper, ZComponentProperties, UploadMetaData } from "mmhglobal-zcore";
+import * as i0 from "@angular/core";
+import * as i1 from "mmhglobal-zcore";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@progress/kendo-angular-upload";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+export class MyFileInfo {
+}
+export class ZuploadComponent {
+    // zModelValue = [{
+    //   name: "RXJS 01.png",
+    //   size: 128753,
+    //   uid: "c96e234d-af61-4587-adcc-3b400ddef884"
+    // }];
+    // fieldElement = [{
+    //   Name: 'FileUploadList',
+    //   Type: 'zupload',
+    //   Value: 'FileUploadList',
+    //   SelectionOptions: ['jpg', 'jpeg', 'png', 'bmp', 'pdf'],
+    //   UploadMetaData: 'group.UploadMetaData',
+    //   AutoUpload: false,
+    //   AllowRemove: true,
+    //   Multiple: false,
+    //   OnSuccess: 'group.onSuccess()',
+    //   DivClass: "col-md-12 col-md-6",
+    //   Visible: true
+    // }];
+    constructor(authService, compressImage, zcoreService, ngZone) {
+        this.authService = authService;
+        this.compressImage = compressImage;
+        this.zcoreService = zcoreService;
+        this.ngZone = ngZone;
+        this.componentProperties = new ZComponentProperties();
+        this.uploadAttachmentUrl = null;
+        this.uploadSaveUrl = "/Attachment/Chunk_Upload_Save"; // should represent an actual API endpoint
+        this.uploadRemoveUrl = "/Attachment/Chunk_Upload_Remove"; // should represent an actual API endpoint
+        this.downloadFileUrl = "/Attachment/downloadFile";
+        this.getImageUrl = "/Attachment/getImage"; // GET method
+        this.isAutoUpload = false;
+        this.isMultiple = false;
+        this.imagePreviews = [];
+        this.uid = [];
+        this.showFileList = true;
+        this.fileList = [];
+        this.restrictions = {
+            minFileSize: 1,
+            maxFileSize: 4194304,
+            allowedExtensions: [
+                "jpg",
+                "jpeg",
+                "png",
+                "bmp",
+                "pdf",
+                "txt",
+                "docx",
+                "doc",
+                "xlsx",
+                "xls",
+                "ppt",
+                "pptx",
+                "csv",
+            ],
+        };
+        this.chunkSettings = {
+            size: 102400,
+            maxAutoRetries: 3,
+        };
+        this.setEnable = (status) => {
+            const fc = this.group.form.controls[this.data.Value];
+            status ? fc.enable() : fc.disable();
+            this.componentProperties.isReadOnly = !status;
+        };
+        this.setVisible = (status) => {
+            this.componentProperties.isVisible = status;
+            this.data.Visible = status;
+        };
+        this.setRequire = (status) => {
+            this.componentProperties.isRequired = status;
+            ZComponentHelper.changeValidator(status, this.group, this.data.Value, this.componentProperties, Validators.required);
+        };
+        this.uploadAttachmentUrl = this.zcoreService.getEnvironment().uploadAttachmentUrl;
+        this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;
+        this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;
+    }
+    ngOnInit() {
+        ZComponentHelper.setComponentProperties(this);
+        ZComponentHelper.registerComponent(this);
+        // this.group['UploadMetaData'] = new UploadMetaData(null, '15', 'SO-No-1234', 'SaleOrder');
+        // this.uploadSaveUrl = uploadAttachmentUrl + this.uploadSaveUrl;
+        // this.uploadRemoveUrl = uploadAttachmentUrl + this.uploadRemoveUrl;
+        if (this.data.SelectOptions) {
+            this.restrictions.allowedExtensions = this.data
+                .SelectOptions;
+        }
+        if (this.data.MinFileSize) {
+            this.restrictions.minFileSize = this.data.MinFileSize;
+        }
+        if (this.data.MaxFileSize) {
+            this.restrictions.maxFileSize = this.data.MaxFileSize;
+        }
+        this.isAutoUpload = this.data.AutoUpload || false;
+        if (!this.data.AllowRemove) {
+            this.uploadRemoveUrl = "";
+        }
+        if (this.data.Multiple) {
+            this.isMultiple = this.data.Multiple;
+        }
+    }
+    getIon_InvalidClass(form, data) {
+        return ZComponentHelper.getIon_InvalidClass(form, data);
+    }
+    onSuccess(e) {
+        // angular kendo upload didn't filter away Sent event for remove, so we have to handle it here
+        // upload progress not required for removal, thus it's also removed
+        // @ts-ignore
+        if (e.operation === "remove" && (e.response.type === HttpEventType.Sent || e.response.type === HttpEventType.UploadProgress)) {
+            return;
+        }
+        if (!Array.isArray(this.group.zModel[this.data.Value])) {
+            this.group.zModel[this.data.Value] = [];
+        }
+        const file = e.files[0];
+        const existingFileIndex = this.group.zModel[this.data.Value].findIndex(f => f.name === file.name && f.uid === file.uid);
+        if (e.operation === "upload") {
+            // console.log('upload Success: ', e);
+            file.myUid = file.uid;
+            delete file['httpSubscription'];
+            if (existingFileIndex !== -1) {
+                this.group.zModel[this.data.Value][existingFileIndex] = file;
+            }
+            else {
+                this.group.zModel[this.data.Value].push(file);
+            }
+        }
+        else if (e.operation === "remove") {
+            if (existingFileIndex !== -1) {
+                this.group.zModel[this.data.Value].splice(existingFileIndex, 1);
+            }
+        }
+        this.group.subject.next({
+            type: "zupload-onSuccess",
+            target: this.data.OnSuccess,
+            event: e,
+            data: { value: e.files[0], field: this.data },
+        });
+    }
+    compressionConfigHandler(imgConfig) {
+        if (imgConfig.FileSizeMaxSize) {
+            imgConfig.FileSizeMaxSizeByte = this.convertSizeToByte(imgConfig.FileSizeMaxSize);
+        }
+        if (imgConfig.FileSizeMinSize) {
+            imgConfig.FileSizeMinSizeByte = this.convertSizeToByte(imgConfig.FileSizeMinSize);
+        }
+        else {
+            imgConfig.FileSizeMinSizeByte = 0;
+        }
+        return imgConfig;
+    }
+    convertSizeToByte(sizeString) {
+        let _tempFileSizeMaxSize = 0;
+        let sizeByByte = 0;
+        let sizeType = 'b';
+        // remove all space
+        const _tempFileSize = sizeString.replace(/ /g, '');
+        // check last char is alphabetic
+        const lastChar = _tempFileSize.substr(_tempFileSize.length - 1);
+        if (isNaN(parseFloat(lastChar))) {
+            const secLastChar = _tempFileSize.substr(_tempFileSize.length - 2).slice(0, -1);
+            if (isNaN(parseFloat(secLastChar))) {
+                // check last 2nd char is alphabetic
+                sizeType = secLastChar + sizeType;
+                _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -2));
+            }
+            else {
+                _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -1));
+            }
+            switch (sizeType.toLowerCase()) {
+                case "b":
+                    sizeByByte = _tempFileSizeMaxSize;
+                    break;
+                case "kb":
+                    sizeByByte = _tempFileSizeMaxSize * 1024;
+                    break;
+                case "mb":
+                    sizeByByte = _tempFileSizeMaxSize * 1048576;
+                    break;
+                case "gb":
+                    sizeByByte = _tempFileSizeMaxSize * 1073741824;
+                    break;
+            }
+        }
+        else {
+            // default using bytes if no size type
+            sizeByByte = parseFloat(_tempFileSize);
+        }
+        return sizeByByte;
+    }
+    uploadEventHandler(e) {
+        // Image Preview
+        const me = this;
+        e.files.forEach((file) => {
+            if (file.rawFile && file.rawFile.type.includes("image")) {
+                if (!file.validationErrors) {
+                    const reader = new FileReader();
+                    reader.onload = function (ev) {
+                        if (me.data.EnableImagePreview) {
+                            if (!me.uid.includes(file.uid)) {
+                                me.uid.push(file.uid);
+                                me.imagePreviews.push({ ...file, src: reader.result });
+                            }
+                        }
+                    };
+                    reader.readAsDataURL(file.rawFile);
+                }
+            }
+        });
+        // Add metadata to the upload event
+        let additional = ZComponentHelper.getGroupEvalValue.call(this, this.data.UploadMetaData);
+        if (!(additional instanceof UploadMetaData)) {
+            console.error("UploadMetaData defined at " + this.data.UploadMetaData + " is invalid: ", additional);
+            additional = new UploadMetaData(null, "0");
+        }
+        const str = JSON.stringify(additional);
+        e.data = { additional: str, };
+        e.headers = e.headers.append("Authorization", "Bearer " + this.authService.e1AccessToken);
+    }
+    onRemove(e) {
+        // remove file from component memory
+        const index = this.fileList.findIndex((item) => item.uid === e.files[0].uid);
+        if (index >= 0) {
+            this.fileList.splice(index, 1);
+            this.group['zupload_' + this.data.Value] = this.fileList;
+        }
+        if (this.data['FileRemovedEvent']) {
+            this.group.subject.next({
+                type: "zupload-fileRemovedEvent",
+                target: this.data['FileRemovedEvent'],
+                data: e
+            });
+        }
+        else {
+            const myFile = e.files[0];
+            // console.log('remove done: ', e);
+            e.data = {
+                id: myFile.myUid,
+            };
+            e.headers = e.headers.append("Authorization", "Bearer " + this.authService.e1AccessToken);
+            if (this.data.EnableImagePreview) {
+                e.files.forEach((file) => {
+                    this.imagePreviews = this.imagePreviews.filter(f => f.uid !== file.uid);
+                });
+            }
+        }
+    }
+    onChange(file) {
+        if (this.data['FileChangedEvent']) {
+            this.group.subject.next({
+                type: "zupload-fileChangedEvent",
+                target: this.data['FileChangedEvent'],
+                data: file
+            });
+        }
+    }
+    selectEventHandler(e) {
+        const me = this;
+        if (this.data['SelectFileOnly']) {
+            // append all file to component memory
+            e.files.forEach(async (file) => {
+                if (file.rawFile) {
+                    const reader = new FileReader();
+                    reader.onload = function (ev) {
+                        // clone the data and also add the readed file to the object
+                        const fileData = Object.assign({}, file);
+                        fileData['file'] = ev.target["result"];
+                        // push to component fileList
+                        me.fileList.push(fileData);
+                        me.group['zupload_' + me.data.Value] = me.fileList;
+                        if (me.data['FileSelectedEvent']) {
+                            // call the project event
+                            me.group.subject.next({
+                                type: "zupload-fileSelectedEvent",
+                                target: me.data['FileSelectedEvent'],
+                                data: me.fileList
+                            });
+                        }
+                    };
+                    await reader.readAsDataURL(file.rawFile);
+                }
+            });
+        }
+        else {
+            // Only workable for Auto Upload = false
+            if (!this.data.AutoUpload) {
+                // Compression for image file
+                const imageCompressionEnabled = this.data.Compression ? true : false;
+                //Check if Image Compression is enabled.
+                if (imageCompressionEnabled === true) {
+                    e.files.forEach((file) => {
+                        // Compress only if it is an image file
+                        if (file.rawFile && file.rawFile.type.includes("image")) {
+                            if (!file.validationErrors) {
+                                const imgConfig = this.compressionConfigHandler(this.data.Compression);
+                                if (file.size > imgConfig.FileSizeMinSizeByte) {
+                                    me.compressImage.compress(file.rawFile, imgConfig) //Pass in parameter to set the Compression Options
+                                        .pipe(take(1))
+                                        .subscribe(compressFile => {
+                                        this.ngZone.run(() => {
+                                            file.rawFile = compressFile;
+                                            file.size = compressFile.size;
+                                            // clone the data and also add the readed file to the object
+                                            const fileData = Object.assign({}, file);
+                                            // push to component fileList
+                                            me.fileList.push(fileData);
+                                            const reader = new FileReader();
+                                            reader.readAsDataURL(file.rawFile);
+                                        });
+                                        console.log(`Compressed file size: ${(file.rawFile.size / 1024).toFixed(2)}KB`);
+                                    });
+                                } // file size check
+                            } // validationErrors check
+                        } // file type check
+                    }); // loop each file
+                } // imagecompression check
+                // add to group scope
+                me.group['zupload_' + me.data.Value] = e.files;
+            }
+        }
+    }
+    clearFiles() {
+        this.uploadComponent.clearFiles();
+        this.group['zupload_' + this.data.Value] = this.fileList;
+    }
+}
+ZuploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.4", ngImport: i0, type: ZuploadComponent, deps: [{ token: i1.AuthService }, { token: i1.CompressImageService }, { token: i1.ZCoreService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+ZuploadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.4", type: ZuploadComponent, selector: "app-zupload", inputs: { data: "data", group: "group", form: "form" }, viewQueries: [{ propertyName: "uploadComponent", first: true, predicate: ["uploadComponent"], descendants: true }], ngImport: i0, template: "<ion-item [formGroup]=\"form\" *ngIf=\"(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\" [ngClass]=\"getIon_InvalidClass(form, data)\" style=\"margin-left: -15px;\">\r\n  <ion-label [attr.for]=\"data.Value\" *ngIf=\"data.ShowLabel === undefined || data.ShowLabel\" position=\"stacked\" style=\"margin-bottom: 10px;\">\r\n    {{data.Label}} <ion-text *ngIf=\"(!!componentProperties.isRequiredField ? group[componentProperties.isRequiredField] : componentProperties.isRequired)\" color=\"danger\">*</ion-text>\r\n  </ion-label>\r\n  <div class=\"ion-row\" style=\"justify-content: space-between; width: 100%\">\r\n    <span style=\"flex: 1;\">\r\n      <kendo-upload #uploadComponent\r\n                    *ngIf=\"!data.SelectFileOnly\"\r\n                    [id]=\"data.Value\"\r\n                    [autoUpload]=\"isAutoUpload\"\r\n                    [saveUrl]=\"uploadSaveUrl\"\r\n                    [removeUrl]=\"uploadRemoveUrl\"\r\n                    [restrictions]=\"restrictions\"\r\n                    [formControlName]=\"data.Value\"\r\n                    [multiple]=\"isMultiple\"\r\n                    [chunkable]=\"chunkSettings\"\r\n                    [showFileList]=\"showFileList\"\r\n                    (select)=\"selectEventHandler($event)\"\r\n                    (remove)=\"onRemove($event)\" \r\n                    (success)=\"onSuccess($event)\"\r\n                    (upload)=\"uploadEventHandler($event)\">\r\n      </kendo-upload>\r\n\r\n      <kendo-fileselect #uploadComponent\r\n                        *ngIf=\"data.SelectFileOnly\"\r\n                        [id]=\"data.Value\"\r\n                        (select)=\"selectEventHandler($event)\"\r\n                        (remove)=\"onRemove($event)\" \r\n                        (valueChange)=\"onChange($event)\"\r\n                        [restrictions]=\"restrictions\" >\r\n      </kendo-fileselect>\r\n    </span>\r\n  </div>\r\n</ion-item>\r\n<br />\r\n<!--<div class=\"wrap\" *ngIf=\"data.EnableCompression\">\r\n  <ion-label>Enable Compression: </ion-label>\r\n  <ion-checkbox style=\"margin: -5px 0;\" color=\"primary\" (ionChange)=\"toogleEnableCompression($event)\"></ion-checkbox>\r\n</div>-->\r\n<ion-label *ngIf=\"imagePreviews.length\" position=\"stacked\">\r\n  Image Preview:\r\n</ion-label>\r\n<div *ngIf=\"imagePreviews.length\" >\r\n  <img *ngFor=\"let image of imagePreviews\"\r\n       [src]=\"image.src\"\r\n       alt=\"image preview\"\r\n       height=\"100\"\r\n       style=\"margin: 5px; border: 1px solid gray;\"/>\r\n</div>\r\n", styles: [""], components: [{ type: i2.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { type: i2.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i2.IonText, selector: "ion-text", inputs: ["color", "mode"] }, { type: i3.UploadComponent, selector: "kendo-upload", inputs: ["chunkable", "multiple", "disabled", "showFileList", "tabindex", "focusableId", "actionsLayout", "autoUpload", "batch", "withCredentials", "saveField", "saveHeaders", "saveMethod", "saveUrl", "responseType", "removeField", "removeHeaders", "removeMethod", "removeUrl", "concurrent", "tabIndex", "restrictions", "zoneId", "accept"], outputs: ["blur", "cancel", "clear", "complete", "error", "focus", "pause", "remove", "resume", "select", "success", "upload", "uploadProgress", "valueChange"], exportAs: ["kendoUpload"] }, { type: i3.FileSelectComponent, selector: "kendo-fileselect", inputs: ["disabled", "multiple", "showFileList", "tabindex", "focusableId", "name", "restrictions", "accept", "zoneId"], outputs: ["blur", "focus", "select", "remove", "valueChange"], exportAs: ["kendoFileSelect"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.4", ngImport: i0, type: ZuploadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-zupload", template: "<ion-item [formGroup]=\"form\" *ngIf=\"(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\" [ngClass]=\"getIon_InvalidClass(form, data)\" style=\"margin-left: -15px;\">\r\n  <ion-label [attr.for]=\"data.Value\" *ngIf=\"data.ShowLabel === undefined || data.ShowLabel\" position=\"stacked\" style=\"margin-bottom: 10px;\">\r\n    {{data.Label}} <ion-text *ngIf=\"(!!componentProperties.isRequiredField ? group[componentProperties.isRequiredField] : componentProperties.isRequired)\" color=\"danger\">*</ion-text>\r\n  </ion-label>\r\n  <div class=\"ion-row\" style=\"justify-content: space-between; width: 100%\">\r\n    <span style=\"flex: 1;\">\r\n      <kendo-upload #uploadComponent\r\n                    *ngIf=\"!data.SelectFileOnly\"\r\n                    [id]=\"data.Value\"\r\n                    [autoUpload]=\"isAutoUpload\"\r\n                    [saveUrl]=\"uploadSaveUrl\"\r\n                    [removeUrl]=\"uploadRemoveUrl\"\r\n                    [restrictions]=\"restrictions\"\r\n                    [formControlName]=\"data.Value\"\r\n                    [multiple]=\"isMultiple\"\r\n                    [chunkable]=\"chunkSettings\"\r\n                    [showFileList]=\"showFileList\"\r\n                    (select)=\"selectEventHandler($event)\"\r\n                    (remove)=\"onRemove($event)\" \r\n                    (success)=\"onSuccess($event)\"\r\n                    (upload)=\"uploadEventHandler($event)\">\r\n      </kendo-upload>\r\n\r\n      <kendo-fileselect #uploadComponent\r\n                        *ngIf=\"data.SelectFileOnly\"\r\n                        [id]=\"data.Value\"\r\n                        (select)=\"selectEventHandler($event)\"\r\n                        (remove)=\"onRemove($event)\" \r\n                        (valueChange)=\"onChange($event)\"\r\n                        [restrictions]=\"restrictions\" >\r\n      </kendo-fileselect>\r\n    </span>\r\n  </div>\r\n</ion-item>\r\n<br />\r\n<!--<div class=\"wrap\" *ngIf=\"data.EnableCompression\">\r\n  <ion-label>Enable Compression: </ion-label>\r\n  <ion-checkbox style=\"margin: -5px 0;\" color=\"primary\" (ionChange)=\"toogleEnableCompression($event)\"></ion-checkbox>\r\n</div>-->\r\n<ion-label *ngIf=\"imagePreviews.length\" position=\"stacked\">\r\n  Image Preview:\r\n</ion-label>\r\n<div *ngIf=\"imagePreviews.length\" >\r\n  <img *ngFor=\"let image of imagePreviews\"\r\n       [src]=\"image.src\"\r\n       alt=\"image preview\"\r\n       height=\"100\"\r\n       style=\"margin: 5px; border: 1px solid gray;\"/>\r\n</div>\r\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i1.AuthService }, { type: i1.CompressImageService }, { type: i1.ZCoreService }, { type: i0.NgZone }]; }, propDecorators: { data: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], uploadComponent: [{
+                type: ViewChild,
+                args: ["uploadComponent"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zupload.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/zupload/zupload.component.html"],"names":[],"mappings":"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","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, Input, NgZone, ViewChild } from \"@angular/core\";\r\nimport { FormGroup, Validators } from \"@angular/forms\";\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\n// import { environment } from \"src/environments/environment\";\r\nimport { take } from 'rxjs/operators';\r\nimport { HttpEventType } from '@angular/common/http';\r\nimport {\r\n  FileInfo,\r\n  SuccessEvent,\r\n  RemoveEvent,\r\n  UploadEvent,\r\n  FileRestrictions,\r\n  ChunkSettings,\r\n  SelectEvent,\r\n  UploadComponent\r\n} from \"@progress/kendo-angular-upload\";\r\n\r\n/********** Component & Service **********/\r\nimport {\r\n  AuthService, ZCoreService, CompressImageService,\r\n  ZComponent, ZComponentHelper, ZComponentOutputEvent, ZComponentProperties,\r\n  ZField, ZGroup, UploadMetaData, ImageCompressionConfig\r\n} from \"mmhglobal-zcore\";\r\n\r\nexport class MyFileInfo implements FileInfo {\r\n  name: string;\r\n  uid?: string;\r\n  myUid?: string;\r\n}\r\n\r\n@Component({\r\n  selector: \"app-zupload\",\r\n  templateUrl: \"./zupload.component.html\",\r\n  styleUrls: [\"./zupload.component.scss\"],\r\n})\r\nexport class ZuploadComponent implements ZComponent, OnInit {\r\n  @Input() data: ZField;\r\n  @Input() group: ZGroup;\r\n  @Input() form: FormGroup;\r\n  @ViewChild(\"uploadComponent\") uploadComponent: UploadComponent;\r\n\r\n  componentProperties = new ZComponentProperties();\r\n  uploadAttachmentUrl: string = null;\r\n  uploadSaveUrl = \"/Attachment/Chunk_Upload_Save\"; // should represent an actual API endpoint\r\n  uploadRemoveUrl = \"/Attachment/Chunk_Upload_Remove\"; // should represent an actual API endpoint\r\n  downloadFileUrl = \"/Attachment/downloadFile\";\r\n  getImageUrl = \"/Attachment/getImage\"; // GET method\r\n  isAutoUpload = false;\r\n  isMultiple = false;\r\n  imagePreviews: any[] = [];\r\n  uid: string[] = [];\r\n  showFileList = true;\r\n  fileList: any[] = [];\r\n\r\n  public restrictions: FileRestrictions = {\r\n\r\n    minFileSize: 1,\r\n    maxFileSize: 4194304,\r\n    allowedExtensions: [\r\n      \"jpg\",\r\n      \"jpeg\",\r\n      \"png\",\r\n      \"bmp\",\r\n      \"pdf\",\r\n      \"txt\",\r\n      \"docx\",\r\n      \"doc\",\r\n      \"xlsx\",\r\n      \"xls\",\r\n      \"ppt\",\r\n      \"pptx\",\r\n      \"csv\",\r\n    ],\r\n  };\r\n\r\n  public chunkSettings: ChunkSettings = {\r\n    size: 102400,\r\n    maxAutoRetries: 3,\r\n  };\r\n\r\n  // zModelValue = [{\r\n  //   name: \"RXJS 01.png\",\r\n  //   size: 128753,\r\n  //   uid: \"c96e234d-af61-4587-adcc-3b400ddef884\"\r\n  // }];\r\n\r\n  // fieldElement = [{\r\n  //   Name: 'FileUploadList',\r\n  //   Type: 'zupload',\r\n  //   Value: 'FileUploadList',\r\n  //   SelectionOptions: ['jpg', 'jpeg', 'png', 'bmp', 'pdf'],\r\n  //   UploadMetaData: 'group.UploadMetaData',\r\n  //   AutoUpload: false,\r\n  //   AllowRemove: true,\r\n  //   Multiple: false,\r\n  //   OnSuccess: 'group.onSuccess()',\r\n  //   DivClass: \"col-md-12 col-md-6\",\r\n  //   Visible: true\r\n  // }];\r\n\r\n  constructor(\r\n    private authService: AuthService,\r\n    private compressImage: CompressImageService,\r\n    private zcoreService: ZCoreService,\r\n    private ngZone: NgZone\r\n  ) {\r\n    this.uploadAttachmentUrl = this.zcoreService.getEnvironment().uploadAttachmentUrl;\r\n    this.uploadSaveUrl = this.uploadAttachmentUrl + this.uploadSaveUrl;\r\n    this.uploadRemoveUrl = this.uploadAttachmentUrl + this.uploadRemoveUrl;\r\n  }\r\n\r\n  ngOnInit() {\r\n    ZComponentHelper.setComponentProperties(this);\r\n    ZComponentHelper.registerComponent(this);\r\n\r\n    // this.group['UploadMetaData'] = new UploadMetaData(null, '15', 'SO-No-1234', 'SaleOrder');\r\n\r\n\r\n    // this.uploadSaveUrl = uploadAttachmentUrl + this.uploadSaveUrl;\r\n    // this.uploadRemoveUrl = uploadAttachmentUrl + this.uploadRemoveUrl;\r\n\r\n    if (this.data.SelectOptions) {\r\n      this.restrictions.allowedExtensions = (this.data\r\n        .SelectOptions as unknown) as string[];\r\n    }\r\n\r\n    if (this.data.MinFileSize) {\r\n      this.restrictions.minFileSize = this.data.MinFileSize;\r\n    }\r\n\r\n    if (this.data.MaxFileSize) {\r\n      this.restrictions.maxFileSize = this.data.MaxFileSize;\r\n    }\r\n\r\n    this.isAutoUpload = this.data.AutoUpload || false;\r\n\r\n    if (!this.data.AllowRemove) {\r\n      this.uploadRemoveUrl = \"\";\r\n    }\r\n\r\n    if (this.data.Multiple) {\r\n      this.isMultiple = this.data.Multiple;\r\n    }\r\n  }\r\n\r\n  public setEnable = (status: boolean) => {\r\n    const fc = this.group.form.controls[this.data.Value];\r\n    status ? fc.enable() : fc.disable();\r\n    this.componentProperties.isReadOnly = !status;\r\n  };\r\n\r\n  public setVisible = (status: boolean) => {\r\n    this.componentProperties.isVisible = status;\r\n    this.data.Visible = status;\r\n  };\r\n\r\n  public setRequire = (status: boolean) => {\r\n    this.componentProperties.isRequired = status;\r\n    ZComponentHelper.changeValidator(\r\n      status,\r\n      this.group,\r\n      this.data.Value,\r\n      this.componentProperties,\r\n      Validators.required\r\n    );\r\n  };\r\n\r\n  getIon_InvalidClass(form: FormGroup, data: ZField) {\r\n    return ZComponentHelper.getIon_InvalidClass(form, data);\r\n  }\r\n\r\n  onSuccess(e: SuccessEvent): void {\r\n    // angular kendo upload didn't filter away Sent event for remove, so we have to handle it here\r\n    // upload progress not required for removal, thus it's also removed\r\n    // @ts-ignore\r\n    if (e.operation === \"remove\" && (e.response.type === HttpEventType.Sent || e.response.type === HttpEventType.UploadProgress)) {\r\n      return;\r\n    }\r\n\r\n    if (!Array.isArray(this.group.zModel[this.data.Value])) {\r\n      this.group.zModel[this.data.Value] = [];\r\n    }\r\n\r\n    const file = e.files[0] as MyFileInfo;\r\n    const existingFileIndex = this.group.zModel[this.data.Value].findIndex(f => f.name === file.name && f.uid === file.uid);\r\n    if (e.operation === \"upload\") {\r\n      // console.log('upload Success: ', e);\r\n      file.myUid = file.uid;\r\n      delete file['httpSubscription'];\r\n\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[this.data.Value][existingFileIndex] = file;\r\n      } else {\r\n        this.group.zModel[this.data.Value].push(file);\r\n      }\r\n\r\n    } else if (e.operation === \"remove\") {\r\n      if (existingFileIndex !== -1) {\r\n        this.group.zModel[this.data.Value].splice(existingFileIndex, 1);\r\n      }\r\n    }\r\n\r\n    this.group.subject.next({\r\n      type: \"zupload-onSuccess\",\r\n      target: this.data.OnSuccess,\r\n      event: e,\r\n      data: { value: e.files[0], field: this.data },\r\n    } as ZComponentOutputEvent);\r\n  }\r\n\r\n  private compressionConfigHandler(imgConfig: ImageCompressionConfig): ImageCompressionConfig {\r\n    if (imgConfig.FileSizeMaxSize) {\r\n      imgConfig.FileSizeMaxSizeByte = this.convertSizeToByte(imgConfig.FileSizeMaxSize);\r\n    }\r\n\r\n    if (imgConfig.FileSizeMinSize) {\r\n      imgConfig.FileSizeMinSizeByte = this.convertSizeToByte(imgConfig.FileSizeMinSize);\r\n    }\r\n    else {\r\n      imgConfig.FileSizeMinSizeByte = 0;\r\n    }\r\n\r\n    return imgConfig;\r\n  }\r\n\r\n  private convertSizeToByte(sizeString: string): number {\r\n    let _tempFileSizeMaxSize: number = 0;\r\n    let sizeByByte: number = 0;\r\n    let sizeType = 'b';\r\n\r\n    // remove all space\r\n    const _tempFileSize = sizeString.replace(/ /g, '');\r\n\r\n    // check last char is alphabetic\r\n    const lastChar = _tempFileSize.substr(_tempFileSize.length - 1);\r\n    if (isNaN(parseFloat(lastChar))) {\r\n      const secLastChar = _tempFileSize.substr(_tempFileSize.length - 2).slice(0, -1);\r\n\r\n      if (isNaN(parseFloat(secLastChar))) {\r\n        // check last 2nd char is alphabetic\r\n        sizeType = secLastChar + sizeType;\r\n        _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -2));\r\n      }\r\n      else {\r\n        _tempFileSizeMaxSize = parseFloat(_tempFileSize.slice(0, -1));\r\n      }\r\n\r\n      switch (sizeType.toLowerCase()) {\r\n        case \"b\":\r\n          sizeByByte = _tempFileSizeMaxSize\r\n          break;\r\n        case \"kb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1024\r\n          break;\r\n        case \"mb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1048576\r\n          break;\r\n        case \"gb\":\r\n          sizeByByte = _tempFileSizeMaxSize * 1073741824\r\n          break;\r\n      }\r\n    }\r\n    else {\r\n      // default using bytes if no size type\r\n      sizeByByte = parseFloat(_tempFileSize);\r\n    }\r\n\r\n    return sizeByByte;\r\n  }\r\n\r\n  uploadEventHandler(e: UploadEvent) {\r\n    // Image Preview\r\n    const me = this;\r\n    e.files.forEach((file: FileInfo) => {\r\n      if (file.rawFile && file.rawFile.type.includes(\"image\")) {\r\n        if (!file.validationErrors) {\r\n          const reader = new FileReader();\r\n          reader.onload = function (ev) {\r\n            if (me.data.EnableImagePreview) {\r\n              if (!me.uid.includes(file.uid)) {\r\n                me.uid.push(file.uid);\r\n                me.imagePreviews.push({ ...file, src: <string>reader.result });\r\n              }\r\n            }\r\n          }\r\n          reader.readAsDataURL(file.rawFile);\r\n        }\r\n      }\r\n    });\r\n\r\n    // Add metadata to the upload event\r\n    let additional: UploadMetaData = ZComponentHelper.getGroupEvalValue.call(this, this.data.UploadMetaData);\r\n\r\n    if (!(additional instanceof UploadMetaData)) {\r\n      console.error(\"UploadMetaData defined at \" + this.data.UploadMetaData + \" is invalid: \", additional);\r\n      additional = new UploadMetaData(null, \"0\");\r\n    }\r\n\r\n    const str = JSON.stringify(additional);\r\n\r\n    e.data = { additional: str, };\r\n    e.headers = e.headers.append(\"Authorization\", \"Bearer \" + this.authService.e1AccessToken);\r\n  }\r\n\r\n  onRemove(e: RemoveEvent): void {\r\n    // remove file from component memory\r\n    const index = this.fileList.findIndex(\r\n      (item) => item.uid === e.files[0].uid\r\n    );\r\n\r\n    if (index >= 0) {\r\n      this.fileList.splice(index, 1);\r\n      this.group['zupload_' + this.data.Value] = this.fileList;\r\n    }\r\n\r\n    if (this.data['FileRemovedEvent']) {\r\n      this.group.subject.next({\r\n        type: \"zupload-fileRemovedEvent\",\r\n        target: this.data['FileRemovedEvent'],\r\n        data: e\r\n      } as ZComponentOutputEvent);\r\n    }\r\n    else {\r\n      const myFile: MyFileInfo = e.files[0] as MyFileInfo;\r\n\r\n      // console.log('remove done: ', e);\r\n      e.data = {\r\n        id: myFile.myUid,\r\n      };\r\n      e.headers = e.headers.append(\r\n        \"Authorization\",\r\n        \"Bearer \" + this.authService.e1AccessToken\r\n      );\r\n\r\n      if (this.data.EnableImagePreview) {\r\n        e.files.forEach((file: FileInfo) => {\r\n          this.imagePreviews = this.imagePreviews.filter(f => f.uid !== file.uid);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  onChange(file: FileInfo[]): void {\r\n    if (this.data['FileChangedEvent']) {\r\n      this.group.subject.next({\r\n        type: \"zupload-fileChangedEvent\",\r\n        target: this.data['FileChangedEvent'],\r\n        data: file\r\n      } as ZComponentOutputEvent);\r\n    }\r\n  }\r\n\r\n  selectEventHandler(e: SelectEvent) {\r\n    const me = this;\r\n\r\n    if (this.data['SelectFileOnly']) {\r\n      // append all file to component memory\r\n      e.files.forEach(async (file: FileInfo) => {\r\n        if (file.rawFile) {\r\n          const reader = new FileReader();\r\n          reader.onload = function (ev) {\r\n            // clone the data and also add the readed file to the object\r\n            const fileData = Object.assign({}, file);\r\n            fileData['file'] = ev.target[\"result\"];\r\n            // push to component fileList\r\n            me.fileList.push(fileData);\r\n            me.group['zupload_' + me.data.Value] = me.fileList;\r\n\r\n            if (me.data['FileSelectedEvent']) {\r\n              // call the project event\r\n              me.group.subject.next({\r\n                type: \"zupload-fileSelectedEvent\",\r\n                target: me.data['FileSelectedEvent'],\r\n                data: me.fileList\r\n              } as ZComponentOutputEvent);\r\n            }\r\n          };\r\n          await reader.readAsDataURL(file.rawFile);\r\n        }\r\n      });\r\n    }\r\n    else {\r\n      // Only workable for Auto Upload = false\r\n      if (!this.data.AutoUpload) {\r\n        // Compression for image file\r\n        const imageCompressionEnabled = this.data.Compression ? true : false;\r\n\r\n        //Check if Image Compression is enabled.\r\n        if (imageCompressionEnabled === true) {\r\n          e.files.forEach((file: FileInfo) => {\r\n            // Compress only if it is an image file\r\n            if (file.rawFile && file.rawFile.type.includes(\"image\")) {\r\n              if (!file.validationErrors) {\r\n                const imgConfig = this.compressionConfigHandler(this.data.Compression);\r\n                if (file.size > imgConfig.FileSizeMinSizeByte) {\r\n                  me.compressImage.compress(file.rawFile, imgConfig)  //Pass in parameter to set the Compression Options\r\n                    .pipe(take(1))\r\n                    .subscribe(compressFile => {\r\n                      this.ngZone.run(() => {\r\n                        file.rawFile = compressFile;\r\n                        file.size = compressFile.size;\r\n\r\n                        // clone the data and also add the readed file to the object\r\n                        const fileData = Object.assign({}, file);\r\n                        // push to component fileList\r\n                        me.fileList.push(fileData);\r\n\r\n                        const reader = new FileReader();\r\n                        reader.readAsDataURL(file.rawFile);\r\n                      });\r\n                      console.log(`Compressed file size: ${(file.rawFile.size / 1024).toFixed(2)}KB`);\r\n                    });\r\n                } // file size check\r\n              } // validationErrors check\r\n            } // file type check\r\n          }) // loop each file\r\n        } // imagecompression check\r\n\r\n        // add to group scope\r\n        me.group['zupload_' + me.data.Value] = e.files;\r\n      }\r\n    }\r\n  }\r\n\r\n  clearFiles() {\r\n    this.uploadComponent.clearFiles();\r\n    this.group['zupload_' + this.data.Value] = this.fileList;\r\n  }\r\n}\r\n","<ion-item [formGroup]=\"form\" *ngIf=\"(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\" [ngClass]=\"getIon_InvalidClass(form, data)\" style=\"margin-left: -15px;\">\r\n  <ion-label [attr.for]=\"data.Value\" *ngIf=\"data.ShowLabel === undefined || data.ShowLabel\" position=\"stacked\" style=\"margin-bottom: 10px;\">\r\n    {{data.Label}} <ion-text *ngIf=\"(!!componentProperties.isRequiredField ? group[componentProperties.isRequiredField] : componentProperties.isRequired)\" color=\"danger\">*</ion-text>\r\n  </ion-label>\r\n  <div class=\"ion-row\" style=\"justify-content: space-between; width: 100%\">\r\n    <span style=\"flex: 1;\">\r\n      <kendo-upload #uploadComponent\r\n                    *ngIf=\"!data.SelectFileOnly\"\r\n                    [id]=\"data.Value\"\r\n                    [autoUpload]=\"isAutoUpload\"\r\n                    [saveUrl]=\"uploadSaveUrl\"\r\n                    [removeUrl]=\"uploadRemoveUrl\"\r\n                    [restrictions]=\"restrictions\"\r\n                    [formControlName]=\"data.Value\"\r\n                    [multiple]=\"isMultiple\"\r\n                    [chunkable]=\"chunkSettings\"\r\n                    [showFileList]=\"showFileList\"\r\n                    (select)=\"selectEventHandler($event)\"\r\n                    (remove)=\"onRemove($event)\" \r\n                    (success)=\"onSuccess($event)\"\r\n                    (upload)=\"uploadEventHandler($event)\">\r\n      </kendo-upload>\r\n\r\n      <kendo-fileselect #uploadComponent\r\n                        *ngIf=\"data.SelectFileOnly\"\r\n                        [id]=\"data.Value\"\r\n                        (select)=\"selectEventHandler($event)\"\r\n                        (remove)=\"onRemove($event)\" \r\n                        (valueChange)=\"onChange($event)\"\r\n                        [restrictions]=\"restrictions\" >\r\n      </kendo-fileselect>\r\n    </span>\r\n  </div>\r\n</ion-item>\r\n<br />\r\n<!--<div class=\"wrap\" *ngIf=\"data.EnableCompression\">\r\n  <ion-label>Enable Compression: </ion-label>\r\n  <ion-checkbox style=\"margin: -5px 0;\" color=\"primary\" (ionChange)=\"toogleEnableCompression($event)\"></ion-checkbox>\r\n</div>-->\r\n<ion-label *ngIf=\"imagePreviews.length\" position=\"stacked\">\r\n  Image Preview:\r\n</ion-label>\r\n<div *ngIf=\"imagePreviews.length\" >\r\n  <img *ngFor=\"let image of imagePreviews\"\r\n       [src]=\"image.src\"\r\n       alt=\"image preview\"\r\n       height=\"100\"\r\n       style=\"margin: 5px; border: 1px solid gray;\"/>\r\n</div>\r\n"]}