@netgrif/components-core 6.0.1

package/esm5/lib/data-fields/file-field/models/file-field.js

@@ -0,0 +1,128 @@
+import { __extends } from "tslib";
+import { DataField } from '../../models/abstract-data-field';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+/**
+ * Supported types of files a user can select through a file picker.
+ */
+export var FileUploadMIMEType;
+(function (FileUploadMIMEType) {
+    FileUploadMIMEType["IMAGE"] = "image/*";
+    FileUploadMIMEType["VIDEO"] = "video/*";
+    FileUploadMIMEType["AUDIO"] = "audio/*";
+    FileUploadMIMEType["PDF"] = ".pdf";
+    FileUploadMIMEType["JPG"] = ".jpg";
+    FileUploadMIMEType["XML"] = ".xml";
+    FileUploadMIMEType["DOC_DOCX"] = ".doc,.docx";
+    FileUploadMIMEType["XLS_XLSX"] = ".xls,.xlsx";
+})(FileUploadMIMEType || (FileUploadMIMEType = {}));
+/**
+ * Supported types for file preview
+ */
+export var FilePreviewType;
+(function (FilePreviewType) {
+    FilePreviewType[FilePreviewType["pdf"] = 0] = "pdf";
+    FilePreviewType[FilePreviewType["jpg"] = 1] = "jpg";
+    FilePreviewType[FilePreviewType["jpeg"] = 2] = "jpeg";
+    FilePreviewType[FilePreviewType["png"] = 3] = "png";
+})(FilePreviewType || (FilePreviewType = {}));
+/**
+ * Holds information represent file field implements in Petri Net
+ */
+var FileField = /** @class */ (function (_super) {
+    __extends(FileField, _super);
+    /**
+     * Create new instance for file field with all his properties.
+     *
+     * Placeholder is a substitute for the value name if not set value.
+     */
+    function FileField(stringId, title, behavior, value, placeholder, description, layout, _maxUploadSizeInBytes, _allowTypes, validations, component, parentTaskId) {
+        var _this = _super.call(this, stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId) || this;
+        _this._maxUploadSizeInBytes = _maxUploadSizeInBytes;
+        _this._allowTypes = _allowTypes;
+        /**
+         * Specifies the size of all uploaded files in bytes.
+         *
+         * It is an indicator for checking the oversized size in the Petri Net.
+         */
+        _this.filesSize = 0;
+        _this._changedFields$ = new Subject();
+        return _this;
+    }
+    Object.defineProperty(FileField.prototype, "value", {
+        get: function () {
+            return this._value.getValue();
+        },
+        set: function (value) {
+            if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {
+                this.changed = true;
+                this.waitingForResponse = true;
+                this.resolvePrevValue(value !== null && value !== void 0 ? value : {});
+            }
+            this._value.next(value !== null && value !== void 0 ? value : {});
+            this.reverting = false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FileField.prototype.valueWithoutChange = function (value) {
+        this.changed = false;
+        this._value.next(value !== null && value !== void 0 ? value : {});
+    };
+    Object.defineProperty(FileField.prototype, "maxUploadSizeInBytes", {
+        get: function () {
+            return this._maxUploadSizeInBytes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileField.prototype, "allowTypes", {
+        get: function () {
+            return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileField.prototype, "changedFields$", {
+        get: function () {
+            return this._changedFields$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FileField.prototype.emitChangedFields = function (change) {
+        this._changedFields$.next(change);
+    };
+    FileField.prototype.valueEquality = function (a, b) {
+        var file = JSON.stringify(a) === JSON.stringify(b);
+        if (a && a.file && b && b.file) {
+            file = a.file.name === b.file.name;
+        }
+        return (!a && !b) || (!!a && !!b && a.name === b.name && file);
+    };
+    FileField.prototype.registerFormControl = function (formControl) {
+        var _this = this;
+        if (this.initialized) {
+            throw new Error('Data field can be initialized only once!'
+                + ' Disconnect the previous form control before initializing the data field again!');
+        }
+        formControl.setValidators(this.resolveFormControlValidators());
+        this._myValueSubscription = this._value.pipe(distinctUntilChanged(this.valueEquality)).subscribe(function (newValue) {
+            var _a;
+            _this.valid = _this._determineFormControlValidity(formControl);
+            formControl.setValue((_a = newValue === null || newValue === void 0 ? void 0 : newValue.name) !== null && _a !== void 0 ? _a : '');
+            _this.update();
+        });
+        this.updateFormControlState(formControl);
+        this._initialized$.next(true);
+        this.changed = false;
+        this.waitingForResponse = false;
+    };
+    FileField.prototype.updateFormControlState = function (formControl) {
+        this.subscribeToInnerSubjects(formControl);
+        this.update();
+    };
+    return FileField;
+}(DataField));
+export { FileField };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-field.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/data-fields/file-field/models/file-field.ts"],"names":[],"mappings":"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","sourcesContent":["import {DataField} from '../../models/abstract-data-field';\nimport {Behavior} from '../../models/behavior';\nimport {Layout} from '../../models/layout';\nimport {FileFieldValue} from './file-field-value';\nimport {Observable, Subject} from 'rxjs';\nimport {Component} from '../../models/component';\nimport {FormControl} from '@angular/forms';\nimport {Validation} from '../../models/validation';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\nimport {distinctUntilChanged} from 'rxjs/operators';\n\n/**\n * Supported types of files a user can select through a file picker.\n */\nexport enum FileUploadMIMEType {\n    IMAGE = 'image/*',\n    VIDEO = 'video/*',\n    AUDIO = 'audio/*',\n    PDF = '.pdf',\n    JPG = '.jpg',\n    XML = '.xml',\n    DOC_DOCX = '.doc,.docx',\n    XLS_XLSX = '.xls,.xlsx'\n}\n\n/**\n * Supported types for file preview\n */\nexport enum FilePreviewType {\n    pdf,\n    jpg,\n    jpeg,\n    png\n}\n\n/**\n * Extended structure for file by name and extension.\n */\nexport interface FileUploadDataModel {\n    file: File;\n    name: string;\n    extension: string;\n}\n\n/**\n * Holds information represent file field implements in Petri Net\n */\nexport class FileField extends DataField<FileFieldValue> {\n    /**\n     * Specifies the size of all uploaded files in bytes.\n     *\n     * It is an indicator for checking the oversized size in the Petri Net.\n     */\n    public filesSize = 0;\n\n    /**\n     * Used to forward the result of the upload file backend call to the task content\n     */\n    private _changedFields$: Subject<ChangedFieldsMap>;\n\n    public downloaded: boolean;\n\n    set value(value: FileFieldValue) {\n        if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {\n            this.changed = true;\n            this.waitingForResponse = true;\n            this.resolvePrevValue(value ?? {});\n        }\n        this._value.next(value ?? {});\n        this.reverting = false;\n    }\n\n    get value(): FileFieldValue {\n        return this._value.getValue();\n    }\n\n    public valueWithoutChange(value: FileFieldValue) {\n        this.changed = false;\n        this._value.next(value ?? {});\n    }\n\n    /**\n     * Create new instance for file field with all his properties.\n     *\n     * Placeholder is a substitute for the value name if not set value.\n     */\n    constructor(stringId: string, title: string, behavior: Behavior, value?: FileFieldValue, placeholder?: string, description?: string,\n                layout?: Layout, private _maxUploadSizeInBytes?: number,\n                private _allowTypes?: string | FileUploadMIMEType | Array<FileUploadMIMEType>,\n                validations?: Array<Validation>, component?: Component, parentTaskId?: string) {\n        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);\n        this._changedFields$ = new Subject<ChangedFieldsMap>();\n    }\n\n    get maxUploadSizeInBytes(): number {\n        return this._maxUploadSizeInBytes;\n    }\n\n    get allowTypes(): string {\n        return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;\n    }\n\n    get changedFields$(): Observable<ChangedFieldsMap> {\n        return this._changedFields$.asObservable();\n    }\n\n    public emitChangedFields(change: ChangedFieldsMap): void {\n        this._changedFields$.next(change);\n    }\n\n    protected valueEquality(a: FileFieldValue, b: FileFieldValue): boolean {\n        let file = JSON.stringify(a) === JSON.stringify(b);\n        if (a && a.file && b && b.file) {\n            file = a.file.name === b.file.name;\n        }\n        return (!a && !b) || (!!a && !!b && a.name === b.name && file);\n    }\n\n    public registerFormControl(formControl: FormControl): void {\n        if (this.initialized) {\n            throw new Error('Data field can be initialized only once!'\n                + ' Disconnect the previous form control before initializing the data field again!');\n        }\n\n        formControl.setValidators(this.resolveFormControlValidators());\n\n        this._myValueSubscription = this._value.pipe(\n            distinctUntilChanged(this.valueEquality)\n        ).subscribe(newValue => {\n            this.valid = this._determineFormControlValidity(formControl);\n            formControl.setValue(newValue?.name ?? '');\n            this.update();\n        });\n\n        this.updateFormControlState(formControl);\n        this._initialized$.next(true);\n        this.changed = false;\n        this.waitingForResponse = false;\n    }\n\n    protected updateFormControlState(formControl: FormControl): void {\n        this.subscribeToInnerSubjects(formControl);\n        this.update();\n    }\n}\n"]}

package/esm5/lib/data-fields/file-list-field/abstract-file-list-field.component.js

@@ -0,0 +1,278 @@
+import { __extends } from "tslib";
+import { Inject, Input, Optional, ViewChild } from '@angular/core';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { ProgressType } from '../../resources/resource-provider.service';
+import { FileListFieldValidation } from './models/file-list-field';
+import { NAE_INFORM_ABOUT_INVALID_DATA } from '../models/invalid-data-policy-token';
+import { take } from 'rxjs/operators';
+import { EventService } from '../../event/services/event.service';
+var AbstractFileListFieldComponent = /** @class */ (function (_super) {
+    __extends(AbstractFileListFieldComponent, _super);
+    function AbstractFileListFieldComponent(_taskResourceService, _log, _snackbar, _translate, _eventService, informAboutInvalidData) {
+        var _this = _super.call(this, informAboutInvalidData) || this;
+        _this._taskResourceService = _taskResourceService;
+        _this._log = _log;
+        _this._snackbar = _snackbar;
+        _this._translate = _translate;
+        _this._eventService = _eventService;
+        _this.state = _this.defaultState;
+        _this.uploadedFiles = new Array();
+        _this.maxFilesNumber = Number.POSITIVE_INFINITY;
+        return _this;
+    }
+    AbstractFileListFieldComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        _super.prototype.ngOnInit.call(this);
+        this.valueChange$ = this.dataField.valueChanges().subscribe(function (newValue) {
+            _this.parseResponse();
+        });
+        if (this.dataField.validations && this.dataField.validations.length !== 0) {
+            var val = this.dataField.validations.find(function (validation) {
+                return validation.validationRule.includes(FileListFieldValidation.MAX_FILES);
+            });
+            if (val && val.validationRule.split(' ').length === 2 && !isNaN(parseInt(val.validationRule.split(' ')[1], 10))) {
+                this.maxFilesNumber = parseInt(val.validationRule.split(' ')[1], 10);
+                this.maxFilesMessage = val.validationMessage && val.validationMessage !== '' ? val.validationMessage : null;
+            }
+        }
+    };
+    /**
+     * Set file picker and image elements to [FileFieldService]{@link FileFieldService}.
+     *
+     * Initialize file image.
+     */
+    AbstractFileListFieldComponent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        if (this.fileUploadEl) {
+            this.fileUploadEl.nativeElement.onchange = function () {
+                _this.upload();
+            };
+        }
+    };
+    AbstractFileListFieldComponent.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.valueChange$.unsubscribe();
+    };
+    AbstractFileListFieldComponent.prototype.chooseFile = function () {
+        if (this.state.uploading || this.formControl.disabled) {
+            return;
+        }
+        this.fileUploadEl.nativeElement.click();
+    };
+    /**
+     * Call after click on file field.
+     *
+     * If file field has no file uploaded
+     * [FilesUploadComponent]{@link AbstractFilesUploadComponent} via [SideMenu]{@link SideMenuService} opens.
+     *
+     * Otherwise opens a file picker from which the user can select files.
+     */
+    AbstractFileListFieldComponent.prototype.upload = function () {
+        var _this = this;
+        if (!this.fileUploadEl.nativeElement.files || this.fileUploadEl.nativeElement.files.length === 0) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be uploaded. No task is set to the field.');
+            return;
+        }
+        if (this.fileUploadEl.nativeElement.files.length + this.uploadedFiles.length > this.maxFilesNumber) {
+            this._snackbar.openErrorSnackBar(this.maxFilesMessage ? this.maxFilesMessage :
+                this._translate.instant('dataField.snackBar.maxFilesExceeded') + this.maxFilesNumber);
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        var filesToUpload = Array.from(this.fileUploadEl.nativeElement.files);
+        var sum = 0;
+        filesToUpload.forEach(function (item) { return sum += item.size; });
+        if (this.dataField.maxUploadSizeInBytes &&
+            this.dataField.maxUploadSizeInBytes < sum) {
+            this._log.error('Files cannot be uploaded. Maximum size of files exceeded.');
+            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.maxFilesSizeExceeded') + this.dataField.maxUploadSizeInBytes);
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        if (this.dataField.value && this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {
+            this.dataField.value.namesPaths.forEach(function (namePath) {
+                filesToUpload = filesToUpload.filter(function (fileToUpload) { return fileToUpload.name !== namePath.name; });
+            });
+            if (filesToUpload.length === 0) {
+                this._log.error('User chose the same files that are already uploaded. Uploading skipped');
+                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFiles'));
+                this.fileUploadEl.nativeElement.value = '';
+                return;
+            }
+        }
+        this.state = this.defaultState;
+        this.state.uploading = true;
+        var fileFormData = new FormData();
+        filesToUpload.forEach(function (fileToUpload) {
+            fileFormData.append('files', fileToUpload);
+        });
+        this._taskResourceService.uploadFile(this.resolveParentTaskId(), this.dataField.stringId, fileFormData, true)
+            .subscribe(function (response) {
+            if (response.type && response.type === ProgressType.UPLOAD) {
+                _this.state.progress = response.progress;
+            }
+            else {
+                _this._log.debug("Files [" + _this.dataField.stringId + "] were successfully uploaded");
+                var changedFieldsMap = _this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);
+                _this.dataField.emitChangedFields(changedFieldsMap);
+                _this.state.completed = true;
+                _this.state.error = false;
+                _this.state.uploading = false;
+                _this.state.progress = 0;
+                filesToUpload.forEach(function (fileToUpload) {
+                    _this.uploadedFiles.push(fileToUpload.name);
+                    _this.dataField.value.namesPaths.push({ name: fileToUpload.name });
+                    _this.formControl.setValue(_this.dataField.value.namesPaths.map(function (namePath) {
+                        return namePath['name'];
+                    }).join('/'));
+                });
+                _this.dataField.touch = true;
+                _this.dataField.update();
+                _this.fileUploadEl.nativeElement.value = '';
+            }
+        }, function (error) {
+            _this.state.completed = true;
+            _this.state.error = true;
+            _this.state.uploading = false;
+            _this.state.progress = 0;
+            _this._log.error("File [" + _this.dataField.stringId + "] " + _this.fileUploadEl.nativeElement.files.item(0) + " uploading has failed!", error);
+            _this._snackbar.openErrorSnackBar(_this._translate.instant('dataField.snackBar.fileUploadFailed'));
+            _this.dataField.touch = true;
+            _this.dataField.update();
+            _this.fileUploadEl.nativeElement.value = '';
+        });
+    };
+    AbstractFileListFieldComponent.prototype.download = function (fileName) {
+        var _this = this;
+        if (!this.dataField.value || !this.dataField.value.namesPaths ||
+            !this.dataField.value.namesPaths.find(function (namePath) { return namePath.name === fileName; })) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be downloaded. No task is set to the field.');
+            return;
+        }
+        this.state = this.defaultState;
+        this.state.downloading = true;
+        this._taskResourceService.downloadFile(this.resolveParentTaskId(), this.dataField.stringId, fileName).subscribe(function (response) {
+            if (response.type && response.type === ProgressType.DOWNLOAD) {
+                _this.state.progress = response.progress;
+            }
+            else {
+                _this._log.debug("File [" + _this.dataField.stringId + "] " + fileName + " was successfully downloaded");
+                _this.downloadViaAnchor(response, fileName);
+                _this.state.downloading = false;
+                _this.state.progress = 0;
+                _this.dataField.downloaded.push(fileName);
+            }
+        }, function (error) {
+            _this._log.error("Downloading file [" + _this.dataField.stringId + "] " + fileName + " has failed!", error);
+            _this._snackbar.openErrorSnackBar(fileName + ' ' + _this._translate.instant('dataField.snackBar.downloadFail'));
+            _this.state.downloading = false;
+            _this.state.progress = 0;
+        });
+    };
+    AbstractFileListFieldComponent.prototype.downloadViaAnchor = function (blob, fileName) {
+        var a = document.createElement('a');
+        document.body.appendChild(a);
+        a.setAttribute('style', 'display: none');
+        blob = new Blob([blob], { type: 'application/octet-stream' });
+        var url = window.URL.createObjectURL(blob);
+        a.href = url;
+        a.download = fileName;
+        a.click();
+        window.URL.revokeObjectURL(url);
+        document.body.removeChild(a);
+    };
+    AbstractFileListFieldComponent.prototype.deleteFile = function (fileName) {
+        var _this = this;
+        if (!this.dataField.value || !this.dataField.value.namesPaths ||
+            !this.dataField.value.namesPaths.find(function (namePath) { return namePath.name === fileName; })) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be deleted. No task is set to the field.');
+            return;
+        }
+        this._taskResourceService.deleteFile(this.resolveParentTaskId(), this.dataField.stringId, fileName).pipe(take(1)).subscribe(function (response) {
+            if (response.success) {
+                _this.uploadedFiles = _this.uploadedFiles.filter(function (uploadedFile) { return uploadedFile !== fileName; });
+                if (_this.dataField.value.namesPaths) {
+                    _this.dataField.value.namesPaths = _this.dataField.value.namesPaths.filter(function (namePath) { return namePath.name !== fileName; });
+                    _this.formControl.setValue(_this.dataField.value.namesPaths.map(function (namePath) {
+                        return namePath['name'];
+                    }).join('/'));
+                    _this.dataField.update();
+                }
+                _this.dataField.downloaded = _this.dataField.downloaded.filter(function (one) { return one !== fileName; });
+                _this._log.debug("File [" + _this.dataField.stringId + "] " + fileName + " was successfully deleted");
+                _this.formControl.markAsTouched();
+            }
+            else {
+                _this._log.error("Deleting file [" + _this.dataField.stringId + "] " + fileName + " has failed!", response.error);
+                _this._snackbar.openErrorSnackBar(fileName + ' ' + _this._translate.instant('dataField.snackBar.fileDeleteFailed'));
+            }
+        });
+    };
+    Object.defineProperty(AbstractFileListFieldComponent.prototype, "defaultState", {
+        get: function () {
+            return {
+                progress: 0,
+                completed: false,
+                error: false,
+                uploading: false,
+                downloading: false
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Construct display name.
+     */
+    AbstractFileListFieldComponent.prototype.constructDisplayName = function () {
+        var _a, _b;
+        return (_b = (_a = this.dataField) === null || _a === void 0 ? void 0 : _a.placeholder) !== null && _b !== void 0 ? _b : this._translate.instant('dataField.file.noFile');
+    };
+    AbstractFileListFieldComponent.prototype.parseResponse = function () {
+        var _this = this;
+        if (this.dataField.value) {
+            if (!!this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {
+                this.uploadedFiles = new Array();
+                this.dataField.value.namesPaths.forEach(function (namePath) {
+                    _this.uploadedFiles.push(namePath.name);
+                });
+            }
+            else {
+                this.dataField.value.namesPaths = new Array();
+            }
+            this.uploadedFiles = this.dataField.value.namesPaths.map(function (namePath) { return namePath.name; });
+        }
+    };
+    AbstractFileListFieldComponent.prototype.resolveParentTaskId = function () {
+        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;
+    };
+    AbstractFileListFieldComponent.ctorParameters = function () { return [
+        { type: TaskResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: EventService },
+        { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_INFORM_ABOUT_INVALID_DATA,] }] }
+    ]; };
+    AbstractFileListFieldComponent.propDecorators = {
+        taskId: [{ type: Input }],
+        dataField: [{ type: Input }],
+        fileUploadEl: [{ type: ViewChild, args: ['fileUploadInput',] }]
+    };
+    return AbstractFileListFieldComponent;
+}(AbstractDataFieldComponent));
+export { AbstractFileListFieldComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-file-list-field.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/data-fields/file-list-field/abstract-file-list-field.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, ElementRef, Inject, Input, OnDestroy, OnInit, Optional, ViewChild} from '@angular/core';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {AbstractDataFieldComponent} from '../models/abstract-data-field-component';\nimport {ProgressType, ProviderProgress} from '../../resources/resource-provider.service';\nimport {FileListField, FileListFieldValidation} from './models/file-list-field';\nimport {FileFieldValue} from '../file-field/models/file-field-value';\nimport {NAE_INFORM_ABOUT_INVALID_DATA} from '../models/invalid-data-policy-token';\nimport {take} from 'rxjs/operators';\nimport {EventOutcomeMessageResource} from '../../resources/interface/message-resource';\nimport {EventService} from '../../event/services/event.service';\nimport {ChangedFieldsMap} from '../../event/services/interfaces/changed-fields-map';\nimport {Subscription} from 'rxjs';\n\nexport interface FilesState {\n    progress: number;\n    uploading: boolean;\n    downloading: boolean;\n    completed: boolean;\n    error: boolean;\n}\n\nexport abstract class AbstractFileListFieldComponent extends AbstractDataFieldComponent implements OnInit, AfterViewInit, OnDestroy {\n\n    public uploadedFiles: Array<string>;\n    public state: FilesState;\n    private valueChange$: Subscription;\n\n    /**\n     * Values from file list field validation (eg. maxFiles 5)\n     * maxFilesNumber - maximum uploadable files\n     * maxFilesMessage - error message if number of files is exceeded\n     */\n    protected maxFilesNumber: number;\n    protected maxFilesMessage: string;\n\n    /**\n     * Task mongo string id is binding property from parent component.\n     */\n    @Input() public taskId: string;\n    /**\n     * Binding property as instance from parent component.\n     */\n    @Input() public dataField: FileListField;\n    /**\n     * File picker element reference from component template that is initialized after view init.\n     */\n    @ViewChild('fileUploadInput') public fileUploadEl: ElementRef<HTMLInputElement>;\n\n    protected constructor(protected _taskResourceService: TaskResourceService,\n                          protected _log: LoggerService,\n                          protected _snackbar: SnackBarService,\n                          protected _translate: TranslateService,\n                          protected _eventService: EventService,\n                          @Optional() @Inject(NAE_INFORM_ABOUT_INVALID_DATA) informAboutInvalidData: boolean | null) {\n        super(informAboutInvalidData);\n        this.state = this.defaultState;\n        this.uploadedFiles = new Array<string>();\n        this.maxFilesNumber = Number.POSITIVE_INFINITY;\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this.valueChange$ = this.dataField.valueChanges().subscribe(newValue => {\n            this.parseResponse();\n        });\n        if (this.dataField.validations && this.dataField.validations.length !== 0) {\n            const val = this.dataField.validations.find(validation =>\n                validation.validationRule.includes(FileListFieldValidation.MAX_FILES)\n            );\n            if (val && val.validationRule.split(' ').length === 2 && !isNaN(parseInt(val.validationRule.split(' ')[1], 10))) {\n                this.maxFilesNumber = parseInt(val.validationRule.split(' ')[1], 10);\n                this.maxFilesMessage = val.validationMessage && val.validationMessage !== '' ? val.validationMessage : null;\n            }\n        }\n    }\n\n    /**\n     * Set file picker and image elements to [FileFieldService]{@link FileFieldService}.\n     *\n     * Initialize file image.\n     */\n    ngAfterViewInit(): void {\n        if (this.fileUploadEl) {\n            this.fileUploadEl.nativeElement.onchange = () => {\n                this.upload();\n            };\n        }\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.valueChange$.unsubscribe();\n    }\n\n    public chooseFile() {\n        if (this.state.uploading || this.formControl.disabled) {\n            return;\n        }\n        this.fileUploadEl.nativeElement.click();\n    }\n\n    /**\n     * Call after click on file field.\n     *\n     * If file field has no file uploaded\n     * [FilesUploadComponent]{@link AbstractFilesUploadComponent} via [SideMenu]{@link SideMenuService} opens.\n     *\n     * Otherwise opens a file picker from which the user can select files.\n     */\n    public upload() {\n        if (!this.fileUploadEl.nativeElement.files || this.fileUploadEl.nativeElement.files.length === 0) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be uploaded. No task is set to the field.');\n            return;\n        }\n        if (this.fileUploadEl.nativeElement.files.length + this.uploadedFiles.length > this.maxFilesNumber) {\n            this._snackbar.openErrorSnackBar(this.maxFilesMessage ? this.maxFilesMessage :\n                this._translate.instant('dataField.snackBar.maxFilesExceeded') + this.maxFilesNumber\n            );\n            this.fileUploadEl.nativeElement.value = '';\n            return;\n        }\n\n        let filesToUpload = Array.from(this.fileUploadEl.nativeElement.files);\n        let sum = 0;\n        filesToUpload.forEach(item => sum += item.size);\n        if (this.dataField.maxUploadSizeInBytes &&\n            this.dataField.maxUploadSizeInBytes < sum) {\n            this._log.error('Files cannot be uploaded. Maximum size of files exceeded.');\n            this._snackbar.openErrorSnackBar(\n                this._translate.instant('dataField.snackBar.maxFilesSizeExceeded') + this.dataField.maxUploadSizeInBytes\n            );\n            this.fileUploadEl.nativeElement.value = '';\n            return;\n        }\n\n        if (this.dataField.value && this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {\n            this.dataField.value.namesPaths.forEach(namePath => {\n                filesToUpload = filesToUpload.filter(fileToUpload => fileToUpload.name !== namePath.name);\n            });\n            if (filesToUpload.length === 0) {\n                this._log.error('User chose the same files that are already uploaded. Uploading skipped');\n                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFiles'));\n                this.fileUploadEl.nativeElement.value = '';\n                return;\n            }\n        }\n\n        this.state = this.defaultState;\n        this.state.uploading = true;\n        const fileFormData = new FormData();\n\n        filesToUpload.forEach(fileToUpload => {\n            fileFormData.append('files', fileToUpload);\n        });\n        this._taskResourceService.uploadFile(this.resolveParentTaskId(),\n            this.dataField.stringId, fileFormData, true)\n            .subscribe((response: EventOutcomeMessageResource) => {\n                if ((response as ProviderProgress).type && (response as ProviderProgress).type === ProgressType.UPLOAD) {\n                    this.state.progress = (response as ProviderProgress).progress;\n                } else {\n                    this._log.debug(\n                        `Files [${this.dataField.stringId}] were successfully uploaded`\n                    );\n                    const changedFieldsMap: ChangedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);\n                    this.dataField.emitChangedFields(changedFieldsMap);\n                    this.state.completed = true;\n                    this.state.error = false;\n                    this.state.uploading = false;\n                    this.state.progress = 0;\n                    filesToUpload.forEach(fileToUpload => {\n                        this.uploadedFiles.push(fileToUpload.name);\n                        this.dataField.value.namesPaths.push({name: fileToUpload.name});\n                        this.formControl.setValue(this.dataField.value.namesPaths.map(namePath => {\n                            return namePath['name'];\n                        }).join('/'));\n                    });\n                    this.dataField.touch = true;\n                    this.dataField.update();\n                    this.fileUploadEl.nativeElement.value = '';\n                }\n            }, error => {\n                this.state.completed = true;\n                this.state.error = true;\n                this.state.uploading = false;\n                this.state.progress = 0;\n                this._log.error(\n                    `File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0)} uploading has failed!`, error\n                );\n                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.fileUploadFailed'));\n                this.dataField.touch = true;\n                this.dataField.update();\n                this.fileUploadEl.nativeElement.value = '';\n            });\n    }\n\n    public download(fileName: string) {\n        if (!this.dataField.value || !this.dataField.value.namesPaths ||\n            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be downloaded. No task is set to the field.');\n            return;\n        }\n\n        this.state = this.defaultState;\n        this.state.downloading = true;\n        this._taskResourceService.downloadFile(this.resolveParentTaskId(),\n            this.dataField.stringId, fileName).subscribe(response => {\n            if ((response as ProviderProgress).type && (response as ProviderProgress).type === ProgressType.DOWNLOAD) {\n                this.state.progress = (response as ProviderProgress).progress;\n            } else {\n                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully downloaded`);\n                this.downloadViaAnchor(response as Blob, fileName);\n                this.state.downloading = false;\n                this.state.progress = 0;\n                this.dataField.downloaded.push(fileName);\n            }\n        }, error => {\n            this._log.error(`Downloading file [${this.dataField.stringId}] ${fileName} has failed!`, error);\n            this._snackbar.openErrorSnackBar(fileName + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));\n            this.state.downloading = false;\n            this.state.progress = 0;\n        });\n    }\n\n    protected downloadViaAnchor(blob: Blob, fileName: string): void {\n        const a = document.createElement('a');\n        document.body.appendChild(a);\n        a.setAttribute('style', 'display: none');\n        blob = new Blob([blob], {type: 'application/octet-stream'});\n        const url = window.URL.createObjectURL(blob);\n        a.href = url;\n        a.download = fileName;\n        a.click();\n        window.URL.revokeObjectURL(url);\n        document.body.removeChild(a);\n    }\n\n    public deleteFile(fileName: string) {\n        if (!this.dataField.value || !this.dataField.value.namesPaths ||\n            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be deleted. No task is set to the field.');\n            return;\n        }\n\n        this._taskResourceService.deleteFile(this.resolveParentTaskId(),\n            this.dataField.stringId, fileName).pipe(take(1)).subscribe(response => {\n            if (response.success) {\n                this.uploadedFiles = this.uploadedFiles.filter(uploadedFile => uploadedFile !== fileName);\n                if (this.dataField.value.namesPaths) {\n                    this.dataField.value.namesPaths = this.dataField.value.namesPaths.filter(namePath => namePath.name !== fileName);\n                    this.formControl.setValue(this.dataField.value.namesPaths.map(namePath => {\n                        return namePath['name'];\n                    }).join('/'));\n                    this.dataField.update();\n                }\n                this.dataField.downloaded = this.dataField.downloaded.filter(one => one !== fileName);\n                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully deleted`);\n                this.formControl.markAsTouched();\n            } else {\n                this._log.error(`Deleting file [${this.dataField.stringId}] ${fileName} has failed!`, response.error);\n                this._snackbar.openErrorSnackBar(\n                    fileName + ' ' + this._translate.instant('dataField.snackBar.fileDeleteFailed')\n                );\n            }\n        });\n    }\n\n    protected get defaultState(): FilesState {\n        return {\n            progress: 0,\n            completed: false,\n            error: false,\n            uploading: false,\n            downloading: false\n        };\n    }\n\n    /**\n     * Construct display name.\n     */\n    public constructDisplayName(): string {\n        return this.dataField?.placeholder ?? this._translate.instant('dataField.file.noFile');\n    }\n\n    protected parseResponse(): void {\n        if (this.dataField.value) {\n            if (!!this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {\n                this.uploadedFiles = new Array<string>();\n                this.dataField.value.namesPaths.forEach(namePath => {\n                    this.uploadedFiles.push(namePath.name);\n                });\n            } else {\n                this.dataField.value.namesPaths = new Array<FileFieldValue>();\n            }\n            this.uploadedFiles = this.dataField.value.namesPaths.map(namePath => namePath.name);\n        }\n    }\n\n    private resolveParentTaskId(): string {\n        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;\n    }\n}\n"]}

package/esm5/lib/data-fields/file-list-field/models/file-list-field-value.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1saXN0LWZpZWxkLXZhbHVlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2RhdGEtZmllbGRzL2ZpbGUtbGlzdC1maWVsZC9tb2RlbHMvZmlsZS1saXN0LWZpZWxkLXZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0ZpbGVGaWVsZFZhbHVlfSBmcm9tICcuLi8uLi9maWxlLWZpZWxkL21vZGVscy9maWxlLWZpZWxkLXZhbHVlJztcblxuZXhwb3J0IGludGVyZmFjZSBGaWxlTGlzdEZpZWxkVmFsdWUge1xuICAgIG5hbWVzUGF0aHM/OiBBcnJheTxGaWxlRmllbGRWYWx1ZT47XG59XG4iXX0=

package/esm5/lib/data-fields/file-list-field/models/file-list-field.js

@@ -0,0 +1,105 @@
+import { __extends } from "tslib";
+import { Subject } from 'rxjs';
+import { DataField } from '../../models/abstract-data-field';
+import { distinctUntilChanged } from 'rxjs/operators';
+export var FileListFieldValidation;
+(function (FileListFieldValidation) {
+    FileListFieldValidation["MAX_FILES"] = "maxFiles";
+})(FileListFieldValidation || (FileListFieldValidation = {}));
+var FileListField = /** @class */ (function (_super) {
+    __extends(FileListField, _super);
+    /**
+     * Create new instance for file field with all his properties.
+     *
+     * Placeholder is a substitute for the value name if not set value.
+     */
+    function FileListField(stringId, title, behavior, value, placeholder, description, layout, validations, _maxUploadSizeInBytes, _allowTypes, component, parentTaskId) {
+        var _this = _super.call(this, stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId) || this;
+        _this._maxUploadSizeInBytes = _maxUploadSizeInBytes;
+        _this._allowTypes = _allowTypes;
+        _this._changedFields$ = new Subject();
+        _this.downloaded = new Array();
+        return _this;
+    }
+    Object.defineProperty(FileListField.prototype, "value", {
+        get: function () {
+            return this._value.getValue();
+        },
+        set: function (value) {
+            if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {
+                this.changed = true;
+                this.waitingForResponse = true;
+                this.resolvePrevValue(value !== null && value !== void 0 ? value : { namesPaths: [] });
+            }
+            this._value.next(value !== null && value !== void 0 ? value : { namesPaths: [] });
+            this.reverting = false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FileListField.prototype.valueWithoutChange = function (value) {
+        this.changed = false;
+        this._value.next(value !== null && value !== void 0 ? value : { namesPaths: [] });
+    };
+    Object.defineProperty(FileListField.prototype, "maxUploadSizeInBytes", {
+        get: function () {
+            return this._maxUploadSizeInBytes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileListField.prototype, "allowTypes", {
+        get: function () {
+            return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FileListField.prototype, "changedFields$", {
+        get: function () {
+            return this._changedFields$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FileListField.prototype.emitChangedFields = function (change) {
+        this._changedFields$.next(change);
+    };
+    /**
+     * We assume that files are always given in the same order.
+     */
+    FileListField.prototype.valueEquality = function (a, b) {
+        var array = (JSON.stringify(a) === '{}' || !a.namesPaths || a.namesPaths.length === 0) &&
+            (JSON.stringify(b) === '{}' || !b.namesPaths || b.namesPaths.length === 0);
+        if (a && a.namesPaths && a.namesPaths.length !== 0 && b && b.namesPaths && b.namesPaths.length !== 0) {
+            array = a.namesPaths.every(function (element, index) { return element.name === b.namesPaths[index].name; });
+        }
+        return (!a && !b) || (!!a && !!b && array);
+    };
+    FileListField.prototype.registerFormControl = function (formControl) {
+        var _this = this;
+        if (this.initialized) {
+            throw new Error('Data field can be initialized only once!'
+                + ' Disconnect the previous form control before initializing the data field again!');
+        }
+        formControl.setValidators(this.resolveFormControlValidators());
+        this._myValueSubscription = this._value.pipe(distinctUntilChanged(this.valueEquality)).subscribe(function (newValue) {
+            _this.valid = _this._determineFormControlValidity(formControl);
+            formControl.setValue(!newValue || !newValue.namesPaths ? '' : newValue.namesPaths.map(function (namePath) {
+                return namePath.name;
+            }).join('/'));
+            _this.update();
+        });
+        this.updateFormControlState(formControl);
+        this._initialized$.next(true);
+        this.changed = false;
+        this.waitingForResponse = false;
+    };
+    FileListField.prototype.updateFormControlState = function (formControl) {
+        this.subscribeToInnerSubjects(formControl);
+        this.update();
+    };
+    return FileListField;
+}(DataField));
+export { FileListField };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-list-field.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/data-fields/file-list-field/models/file-list-field.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable, Subject} from 'rxjs';\nimport {Behavior} from '../../models/behavior';\nimport {Layout} from '../../models/layout';\nimport {FileUploadMIMEType} from '../../file-field/models/file-field';\nimport {DataField} from '../../models/abstract-data-field';\nimport {FileListFieldValue} from './file-list-field-value';\nimport {Validation} from '../../models/validation';\nimport {Component} from '../../models/component';\nimport {FormControl} from '@angular/forms';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\nimport {distinctUntilChanged} from 'rxjs/operators';\n\nexport enum FileListFieldValidation {\n    MAX_FILES = 'maxFiles'\n}\n\nexport class FileListField extends DataField<FileListFieldValue> {\n    /**\n     * Used to forward the result of the upload file backend call to the task content\n     */\n    private _changedFields$: Subject<ChangedFieldsMap>;\n    public downloaded: Array<string>;\n\n    set value(value: FileListFieldValue) {\n        if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {\n            this.changed = true;\n            this.waitingForResponse = true;\n            this.resolvePrevValue(value ?? {namesPaths: []});\n        }\n        this._value.next(value ?? {namesPaths: []});\n        this.reverting = false;\n    }\n\n    get value(): FileListFieldValue {\n        return this._value.getValue();\n    }\n\n    public valueWithoutChange(value: FileListFieldValue) {\n        this.changed = false;\n        this._value.next(value ?? {namesPaths: []});\n    }\n\n    /**\n     * Create new instance for file field with all his properties.\n     *\n     * Placeholder is a substitute for the value name if not set value.\n     */\n    constructor(stringId: string, title: string, behavior: Behavior, value?: FileListFieldValue, placeholder?: string, description?: string,\n                layout?: Layout, validations?: Array<Validation>, private _maxUploadSizeInBytes?: number,\n                private _allowTypes?: string | FileUploadMIMEType | Array<FileUploadMIMEType>,\n                component?: Component, parentTaskId?: string) {\n        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);\n        this._changedFields$ = new Subject<ChangedFieldsMap>();\n        this.downloaded = new Array<string>();\n    }\n\n    get maxUploadSizeInBytes(): number {\n        return this._maxUploadSizeInBytes;\n    }\n\n    get allowTypes(): string {\n        return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;\n    }\n\n    get changedFields$(): Observable<ChangedFieldsMap> {\n        return this._changedFields$.asObservable();\n    }\n\n    public emitChangedFields(change: ChangedFieldsMap): void {\n        this._changedFields$.next(change);\n    }\n\n    /**\n     * We assume that files are always given in the same order.\n     */\n    protected valueEquality(a: FileListFieldValue, b: FileListFieldValue): boolean {\n        let array = (JSON.stringify(a) === '{}' || !a.namesPaths || a.namesPaths.length === 0) &&\n            (JSON.stringify(b) === '{}' || !b.namesPaths || b.namesPaths.length === 0);\n        if (a && a.namesPaths && a.namesPaths.length !== 0 && b && b.namesPaths && b.namesPaths.length !== 0) {\n            array = a.namesPaths.every((element, index) => element.name === b.namesPaths[index].name);\n        }\n        return (!a && !b) || (!!a && !!b && array);\n    }\n\n    public registerFormControl(formControl: FormControl): void {\n        if (this.initialized) {\n            throw new Error('Data field can be initialized only once!'\n                + ' Disconnect the previous form control before initializing the data field again!');\n        }\n\n        formControl.setValidators(this.resolveFormControlValidators());\n\n        this._myValueSubscription = this._value.pipe(\n            distinctUntilChanged(this.valueEquality)\n        ).subscribe(newValue => {\n            this.valid = this._determineFormControlValidity(formControl);\n            formControl.setValue(!newValue || !newValue.namesPaths ? '' : newValue.namesPaths.map(namePath => {\n                return namePath.name;\n            }).join('/'));\n            this.update();\n        });\n\n        this.updateFormControlState(formControl);\n        this._initialized$.next(true);\n        this.changed = false;\n        this.waitingForResponse = false;\n    }\n\n    protected updateFormControlState(formControl: FormControl): void {\n        this.subscribeToInnerSubjects(formControl);\n        this.update();\n    }\n}\n"]}