@netgrif/components-core 6.0.1

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

@@ -0,0 +1,390 @@
+import { Inject, Input, Optional, ViewChild } from '@angular/core';
+import { FilePreviewType } from './models/file-field';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { TaskResourceService } from '../../resources/engine-endpoint/task-resource.service';
+import { ProgressType } from '../../resources/resource-provider.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { NAE_INFORM_ABOUT_INVALID_DATA } from '../models/invalid-data-policy-token';
+import { DomSanitizer } from '@angular/platform-browser';
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { EventService } from '../../event/services/event.service';
+const preview = 'preview';
+const fieldHeight = 105;
+const fieldPadding = 16;
+/**
+ * Component that is created in the body of the task panel accord on the Petri Net, which must be bind properties.
+ */
+export class AbstractFileFieldComponent extends AbstractDataFieldComponent {
+    /**
+     * Only inject services.
+     * @param _taskResourceService Provides to download a file from the backend
+     * @param _log Logger service
+     * @param _snackbar Snackbar service to notify user
+     * @param _translate Translate service for I18N
+     * @param _eventService used for parsing of backend response
+     * @param informAboutInvalidData whether the backend should be notified about invalid values.
+     * Option injected trough `NAE_INFORM_ABOUT_INVALID_DATA` InjectionToken
+     * @param _sanitizer Sanitize url of image preview
+     */
+    constructor(_taskResourceService, _log, _snackbar, _translate, _eventService, informAboutInvalidData, _sanitizer) {
+        super(informAboutInvalidData);
+        this._taskResourceService = _taskResourceService;
+        this._log = _log;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this._eventService = _eventService;
+        this._sanitizer = _sanitizer;
+        /**
+         * If file preview should be displayed
+         */
+        this.filePreview = false;
+        /**
+         * If file type can be displayed
+         */
+        this.isDisplayable = false;
+        this.state = this.defaultState;
+        this.fullSource = new BehaviorSubject(null);
+    }
+    /**
+     * Set :
+     *  - File field to [FileFieldService]{@link FileFieldService}
+     *  - Display name
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.filePreview = this.dataField && this.dataField.component && this.dataField.component.name
+            && this.dataField.component.name === preview;
+    }
+    ngAfterViewInit() {
+        if (this.fileUploadEl) {
+            this.fileUploadEl.nativeElement.onchange = () => {
+                this.upload();
+            };
+        }
+        if (this.filePreview) {
+            if (!!this.imageDivEl) {
+                if (!this.isEmpty()) {
+                    this.initializePreviewIfDisplayable();
+                }
+            }
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.fullSource.complete();
+    }
+    chooseFile() {
+        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.
+     */
+    upload() {
+        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.dataField.value &&
+            this.dataField.value.name &&
+            this.fileUploadEl.nativeElement.files.item(0).name === this.dataField.value.name) {
+            this._log.error('User chose the same file. Uploading skipped');
+            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFile'));
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        if (this.dataField.maxUploadSizeInBytes &&
+            this.dataField.maxUploadSizeInBytes < this.fileUploadEl.nativeElement.files.item(0).size) {
+            this._log.error('File cannot be uploaded. Maximum size of file exceeded.');
+            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.maxFilesSizeExceeded') + this.dataField.maxUploadSizeInBytes);
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        this.state = this.defaultState;
+        this.state.uploading = true;
+        const fileFormData = new FormData();
+        const fileToUpload = this.fileUploadEl.nativeElement.files.item(0);
+        fileFormData.append('file', fileToUpload);
+        this._taskResourceService.uploadFile(this.resolveParentTaskId(), this.dataField.stringId, fileFormData, false)
+            .subscribe((response) => {
+            if (response.type && response.type === ProgressType.UPLOAD) {
+                this.state.progress = response.progress;
+            }
+            else {
+                const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);
+                this.dataField.emitChangedFields(changedFieldsMap);
+                this._log.debug(`File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0).name} was successfully uploaded`);
+                this.state.completed = true;
+                this.state.error = false;
+                this.state.uploading = false;
+                this.state.progress = 0;
+                this.dataField.downloaded = false;
+                this.dataField.value.name = fileToUpload.name;
+                if (this.filePreview) {
+                    this.initializePreviewIfDisplayable();
+                }
+                this.fullSource.next(undefined);
+                this.fileForDownload = undefined;
+                this.formControl.setValue(this.dataField.value.name);
+                this.dataField.touch = true;
+                this.dataField.update();
+                this.fileUploadEl.nativeElement.value = '';
+            }
+        }, 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 = '';
+        });
+    }
+    download() {
+        if (!this.checkFileBeforeDownload()) {
+            return;
+        }
+        if (!!this.fileForDownload) {
+            this.downloadViaAnchor(this.fileForDownload);
+            return;
+        }
+        this.state = this.defaultState;
+        this.state.downloading = true;
+        this._taskResourceService.downloadFile(this.resolveParentTaskId(), this.dataField.stringId).subscribe(response => {
+            if (!response.type || response.type !== ProgressType.DOWNLOAD) {
+                this._log.debug(`File [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);
+                this.downloadViaAnchor(response);
+                if (this.filePreview) {
+                    this.initDownloadFile(response);
+                }
+                this.state.downloading = false;
+                this.state.progress = 0;
+                this.dataField.downloaded = true;
+            }
+        }, error => {
+            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);
+            this._snackbar.openErrorSnackBar(this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));
+            this.state.downloading = false;
+            this.state.progress = 0;
+        });
+    }
+    initDownloadFile(response) {
+        if (response instanceof Blob) {
+            if (this.previewExtension === FilePreviewType.pdf) {
+                this.fileForDownload = new Blob([response], { type: 'application/pdf' });
+                this.fullSource.next(this._sanitizer.bypassSecurityTrustResourceUrl(URL.createObjectURL(this.fileForDownload)));
+            }
+            else {
+                this.fileForDownload = new Blob([response], { type: 'application/octet-stream' });
+                this.fullSource.next(this._sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(this.fileForDownload)));
+            }
+        }
+    }
+    downloadViaAnchor(blob) {
+        const a = document.createElement('a');
+        document.body.appendChild(a);
+        a.setAttribute('style', 'display: none');
+        if (!this.fileForDownload) {
+            blob = new Blob([blob], { type: 'application/octet-stream' });
+        }
+        const url = window.URL.createObjectURL(!!this.fileForDownload ? this.fileForDownload : blob);
+        a.href = url;
+        a.download = this.dataField.value.name;
+        a.click();
+        window.URL.revokeObjectURL(url);
+        document.body.removeChild(a);
+    }
+    deleteFile() {
+        if (!this.dataField.value || !this.dataField.value.name) {
+            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).pipe(take(1)).subscribe(response => {
+            if (response.success) {
+                const filename = this.dataField.value.name;
+                this.dataField.value = {};
+                this.formControl.setValue('');
+                this.dataField.update();
+                this.dataField.downloaded = false;
+                this.fullSource.next(undefined);
+                this.fileForDownload = undefined;
+                this.previewSource = undefined;
+                this.fileForPreview = undefined;
+                this._log.debug(`File [${this.dataField.stringId}] ${filename} was successfully deleted`);
+                this.formControl.markAsTouched();
+            }
+            else {
+                this._log.error(`Deleting file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, response.error);
+                this._snackbar.openErrorSnackBar(this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.fileDeleteFailed'));
+            }
+        });
+    }
+    isEmpty() {
+        return !this.dataField.value || !this.dataField.value.name;
+    }
+    get defaultState() {
+        return {
+            progress: 0,
+            completed: false,
+            error: false,
+            uploading: false,
+            downloading: false
+        };
+    }
+    /**
+     * Construct display name.
+     */
+    constructDisplayName() {
+        var _a, _b, _c, _d, _e;
+        return (_c = (_b = (_a = this.dataField) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : ((_e = (_d = this.dataField) === null || _d === void 0 ? void 0 : _d.placeholder) !== null && _e !== void 0 ? _e : this._translate.instant('dataField.file.noFile'));
+    }
+    /**
+     * Initialize file field image from backend if it is image type.
+     */
+    initFileFieldImage() {
+        if (!this.checkFileBeforeDownload()) {
+            return;
+        }
+        this.state.downloading = true;
+        this._taskResourceService.downloadFilePreview(this.taskId, this.dataField.stringId).subscribe(response => {
+            if (response instanceof Blob) {
+                this._log.debug(`Preview of file [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);
+                this.fileForPreview = new Blob([response], { type: 'application/octet-stream' });
+                this.previewSource = this._sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(this.fileForPreview));
+            }
+            if (response == null || response instanceof Blob) {
+                this.state.downloading = false;
+            }
+        }, error => {
+            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);
+            this._snackbar.openErrorSnackBar(this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));
+            this.state.downloading = false;
+            this.state.progress = 0;
+        });
+    }
+    checkFileBeforeDownload() {
+        if (this.isEmpty()) {
+            return false;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be downloaded. No task is set to the field.');
+            return false;
+        }
+        return true;
+    }
+    showPreviewDialog() {
+        if (!this.checkFileBeforeDownload()) {
+            return;
+        }
+        this._taskResourceService.downloadFile(this.taskId, this.dataField.stringId).subscribe(response => {
+            if (!response.type || response.type !== ProgressType.DOWNLOAD) {
+                this._log.debug(`File [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);
+                this.initDownloadFile(response);
+            }
+        }, error => {
+            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);
+            this._snackbar.openErrorSnackBar(this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));
+            this.state.progress = 0;
+        });
+    }
+    changeMaxWidth(event) {
+        if (!!this.imageEl) {
+            this.imageEl.nativeElement.style.maxWidth = event.newWidth + 'px';
+        }
+    }
+    initializePreviewIfDisplayable() {
+        const extension = this.dataField.value.name.split('.').reverse()[0];
+        this.isDisplayable = Object.values(FilePreviewType).includes(extension);
+        if (this.isDisplayable) {
+            this.previewExtension = FilePreviewType[extension];
+            this.initFileFieldImage();
+        }
+    }
+    getHeight() {
+        return this.dataField.layout && this.dataField.layout.rows && this.dataField.layout.rows !== 1 ?
+            (this.dataField.layout.rows) * fieldHeight - fieldPadding : fieldHeight - fieldPadding;
+    }
+    getPreviewBorderWidth() {
+        if (this.borderPropertyEnabled('borderWidth')) {
+            return this.dataField.component.properties.borderWidth + 'px';
+        }
+        return `${AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_WIDTH}px`;
+    }
+    getPreviewBorderStyle() {
+        if (this.borderPropertyEnabled('borderStyle')) {
+            return this.dataField.component.properties.borderStyle;
+        }
+        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_STYLE;
+    }
+    getPreviewBorderColor() {
+        if (this.borderPropertyEnabled('borderColor')) {
+            return this.dataField.component.properties.borderColor;
+        }
+        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_COLOR;
+    }
+    isBorderLGBTQ() {
+        if (this.borderPropertyEnabled('borderLGBTQ')) {
+            return this.dataField.component.properties.borderLGBTQ === 'true';
+        }
+        return false;
+    }
+    isBorderDefault() {
+        if (this.borderPropertyEnabled('borderEnabled')) {
+            return this.dataField.component.properties.borderEnabled === 'true';
+        }
+        return false;
+    }
+    borderPropertyEnabled(property) {
+        return !!this.dataField.component && !!this.dataField.component.properties && property in this.dataField.component.properties;
+    }
+    resolveParentTaskId() {
+        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;
+    }
+}
+/**
+ * The width of the default file preview border in pixels. The `px` string is appended in the code.
+ */
+AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_WIDTH = 0;
+/**
+ * The CSS style attribute of the default file preview border.
+ */
+AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_STYLE = 'none';
+/**
+ * The CSS color string of the default file preview border.
+ */
+AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_COLOR = 'black';
+AbstractFileFieldComponent.ctorParameters = () => [
+    { type: TaskResourceService },
+    { type: LoggerService },
+    { type: SnackBarService },
+    { type: TranslateService },
+    { type: EventService },
+    { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_INFORM_ABOUT_INVALID_DATA,] }] },
+    { type: DomSanitizer }
+];
+AbstractFileFieldComponent.propDecorators = {
+    taskId: [{ type: Input }],
+    dataField: [{ type: Input }],
+    fileUploadEl: [{ type: ViewChild, args: ['fileUploadInput',] }],
+    imageEl: [{ type: ViewChild, args: ['imageEl',] }],
+    imageDivEl: [{ type: ViewChild, args: ['imageDiv',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-file-field.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/data-fields/file-field/abstract-file-field.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, ElementRef, Inject, Input, OnDestroy, OnInit, Optional, ViewChild} from '@angular/core';\nimport {FileField, FilePreviewType} from './models/file-field';\nimport {AbstractDataFieldComponent} from '../models/abstract-data-field-component';\nimport {TaskResourceService} from '../../resources/engine-endpoint/task-resource.service';\nimport {ProgressType, ProviderProgress} from '../../resources/resource-provider.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {NAE_INFORM_ABOUT_INVALID_DATA} from '../models/invalid-data-policy-token';\nimport {DomSanitizer, SafeUrl} from '@angular/platform-browser';\nimport {BehaviorSubject} from 'rxjs';\nimport {ResizedEvent} from 'angular-resize-event';\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';\n\nexport interface FileState {\n    progress: number;\n    uploading: boolean;\n    downloading: boolean;\n    completed: boolean;\n    error: boolean;\n}\n\nconst preview = 'preview';\n\nconst fieldHeight = 105;\n\nconst fieldPadding = 16;\n\n/**\n * Component that is created in the body of the task panel accord on the Petri Net, which must be bind properties.\n */\nexport abstract class AbstractFileFieldComponent extends AbstractDataFieldComponent implements OnInit, AfterViewInit, OnDestroy {\n\n    /**\n     * The width of the default file preview border in pixels. The `px` string is appended in the code.\n     */\n    public static readonly DEFAULT_PREVIEW_BORDER_WIDTH = 0;\n    /**\n     * The CSS style attribute of the default file preview border.\n     */\n    public static readonly DEFAULT_PREVIEW_BORDER_STYLE = 'none';\n    /**\n     * The CSS color string of the default file preview border.\n     */\n    public static readonly DEFAULT_PREVIEW_BORDER_COLOR = 'black';\n\n    public state: FileState;\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: FileField;\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     * Image field view element reference from component template that is initialized after view init.\n     */\n    @ViewChild('imageEl') public imageEl: ElementRef;\n\n    @ViewChild('imageDiv') public imageDivEl: ElementRef;\n    /**\n     * If file preview should be displayed\n     */\n    public filePreview = false;\n    /**\n     * If file type can be displayed\n     */\n    public isDisplayable = false;\n    /**\n     * Max height of preview\n     */\n    private maxHeight: string;\n    /**\n     * Store file for preview\n     */\n    private fileForPreview: Blob;\n    /**\n     * Url of preview file\n     */\n    public previewSource: SafeUrl;\n    /**\n     * Store file to show/download\n     */\n    private fileForDownload: Blob;\n    /**\n     * Full size file url\n     */\n    public fullSource: BehaviorSubject<SafeUrl>;\n    /**\n     * Extension of file to preview\n     */\n    public previewExtension: FilePreviewType;\n\n    /**\n     * Only inject services.\n     * @param _taskResourceService Provides to download a file from the backend\n     * @param _log Logger service\n     * @param _snackbar Snackbar service to notify user\n     * @param _translate Translate service for I18N\n     * @param _eventService used for parsing of backend response\n     * @param informAboutInvalidData whether the backend should be notified about invalid values.\n     * Option injected trough `NAE_INFORM_ABOUT_INVALID_DATA` InjectionToken\n     * @param _sanitizer Sanitize url of image preview\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                          protected _sanitizer: DomSanitizer) {\n        super(informAboutInvalidData);\n        this.state = this.defaultState;\n        this.fullSource = new BehaviorSubject<SafeUrl>(null);\n    }\n\n    /**\n     * Set :\n     *  - File field to [FileFieldService]{@link FileFieldService}\n     *  - Display name\n     */\n    ngOnInit() {\n        super.ngOnInit();\n        this.filePreview = this.dataField && this.dataField.component && this.dataField.component.name\n            && this.dataField.component.name === preview;\n    }\n\n    ngAfterViewInit() {\n        if (this.fileUploadEl) {\n            this.fileUploadEl.nativeElement.onchange = () => {\n                this.upload();\n            };\n        }\n        if (this.filePreview) {\n            if (!!this.imageDivEl) {\n                if (!this.isEmpty()) {\n                    this.initializePreviewIfDisplayable();\n                }\n            }\n        }\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.fullSource.complete();\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.dataField.value &&\n            this.dataField.value.name &&\n            this.fileUploadEl.nativeElement.files.item(0).name === this.dataField.value.name) {\n            this._log.error('User chose the same file. Uploading skipped');\n            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFile'));\n            this.fileUploadEl.nativeElement.value = '';\n            return;\n        }\n        if (this.dataField.maxUploadSizeInBytes &&\n            this.dataField.maxUploadSizeInBytes < this.fileUploadEl.nativeElement.files.item(0).size) {\n            this._log.error('File cannot be uploaded. Maximum size of file 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        this.state = this.defaultState;\n        this.state.uploading = true;\n        const fileFormData = new FormData();\n        const fileToUpload = this.fileUploadEl.nativeElement.files.item(0) as File;\n        fileFormData.append('file', fileToUpload);\n        this._taskResourceService.uploadFile(this.resolveParentTaskId(), this.dataField.stringId, fileFormData, false)\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                    const changedFieldsMap: ChangedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);\n                    this.dataField.emitChangedFields(changedFieldsMap);\n                    this._log.debug(\n                        `File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0).name} was successfully uploaded`\n                    );\n                    this.state.completed = true;\n                    this.state.error = false;\n                    this.state.uploading = false;\n                    this.state.progress = 0;\n                    this.dataField.downloaded = false;\n                    this.dataField.value.name = fileToUpload.name;\n                    if (this.filePreview) {\n                        this.initializePreviewIfDisplayable();\n                    }\n                    this.fullSource.next(undefined);\n                    this.fileForDownload = undefined;\n                    this.formControl.setValue(this.dataField.value.name);\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() {\n        if (!this.checkFileBeforeDownload()) {\n            return;\n        }\n        if (!!this.fileForDownload) {\n            this.downloadViaAnchor(this.fileForDownload);\n            return;\n        }\n        this.state = this.defaultState;\n        this.state.downloading = true;\n        this._taskResourceService.downloadFile(this.resolveParentTaskId(),\n            this.dataField.stringId).subscribe(response => {\n            if (!(response as ProviderProgress).type || (response as ProviderProgress).type !== ProgressType.DOWNLOAD) {\n                this._log.debug(`File [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);\n                this.downloadViaAnchor(response as Blob);\n                if (this.filePreview) {\n                    this.initDownloadFile(response);\n                }\n                this.state.downloading = false;\n                this.state.progress = 0;\n                this.dataField.downloaded = true;\n            }\n        }, error => {\n            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);\n            this._snackbar.openErrorSnackBar(\n                this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail')\n            );\n            this.state.downloading = false;\n            this.state.progress = 0;\n        });\n    }\n\n    private initDownloadFile(response: Blob | ProviderProgress) {\n        if (response instanceof Blob) {\n            if (this.previewExtension === FilePreviewType.pdf) {\n                this.fileForDownload = new Blob([response], {type: 'application/pdf'});\n                this.fullSource.next(this._sanitizer.bypassSecurityTrustResourceUrl(URL.createObjectURL(this.fileForDownload)));\n            } else {\n                this.fileForDownload = new Blob([response], {type: 'application/octet-stream'});\n                this.fullSource.next(this._sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(this.fileForDownload)));\n            }\n        }\n    }\n\n    protected downloadViaAnchor(blob: Blob): void {\n        const a = document.createElement('a');\n        document.body.appendChild(a);\n        a.setAttribute('style', 'display: none');\n        if (!this.fileForDownload) {\n            blob = new Blob([blob], {type: 'application/octet-stream'});\n        }\n        const url = window.URL.createObjectURL(!!this.fileForDownload ? this.fileForDownload : blob);\n        a.href = url;\n        a.download = this.dataField.value.name;\n        a.click();\n        window.URL.revokeObjectURL(url);\n        document.body.removeChild(a);\n    }\n\n    public deleteFile() {\n        if (!this.dataField.value || !this.dataField.value.name) {\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).pipe(take(1)).subscribe(response => {\n            if (response.success) {\n                const filename = this.dataField.value.name;\n                this.dataField.value = {};\n                this.formControl.setValue('');\n                this.dataField.update();\n                this.dataField.downloaded = false;\n                this.fullSource.next(undefined);\n                this.fileForDownload = undefined;\n                this.previewSource = undefined;\n                this.fileForPreview = undefined;\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}] ${this.dataField.value.name} has failed!`, response.error);\n                this._snackbar.openErrorSnackBar(\n                    this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.fileDeleteFailed')\n                );\n            }\n        });\n    }\n\n    isEmpty(): boolean {\n        return !this.dataField.value || !this.dataField.value.name;\n    }\n\n    protected get defaultState(): FileState {\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?.value?.name ?? (this.dataField?.placeholder ?? this._translate.instant('dataField.file.noFile'));\n    }\n\n    /**\n     * Initialize file field image from backend if it is image type.\n     */\n    protected initFileFieldImage() {\n        if (!this.checkFileBeforeDownload()) {\n            return;\n        }\n        this.state.downloading = true;\n        this._taskResourceService.downloadFilePreview(this.taskId, this.dataField.stringId).subscribe(response => {\n            if (response instanceof Blob) {\n                this._log.debug(`Preview of file [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);\n                this.fileForPreview = new Blob([response], {type: 'application/octet-stream'});\n                this.previewSource = this._sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(this.fileForPreview));\n            }\n            if (response == null || response instanceof Blob) {\n                this.state.downloading = false;\n            }\n        }, error => {\n            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);\n            this._snackbar.openErrorSnackBar(\n                this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail')\n            );\n            this.state.downloading = false;\n            this.state.progress = 0;\n        });\n    }\n\n    private checkFileBeforeDownload() {\n        if (this.isEmpty()) {\n            return false;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be downloaded. No task is set to the field.');\n            return false;\n        }\n        return true;\n    }\n\n    public showPreviewDialog() {\n        if (!this.checkFileBeforeDownload()) {\n            return;\n        }\n        this._taskResourceService.downloadFile(this.taskId, this.dataField.stringId).subscribe(response => {\n            if (!(response as ProviderProgress).type || (response as ProviderProgress).type !== ProgressType.DOWNLOAD) {\n                this._log.debug(`File [${this.dataField.stringId}] ${this.dataField.value.name} was successfully downloaded`);\n                this.initDownloadFile(response);\n            }\n        }, error => {\n            this._log.error(`Downloading file [${this.dataField.stringId}] ${this.dataField.value.name} has failed!`, error);\n            this._snackbar.openErrorSnackBar(\n                this.dataField.value.name + ' ' + this._translate.instant('dataField.snackBar.downloadFail')\n            );\n            this.state.progress = 0;\n        });\n    }\n\n    public changeMaxWidth(event: ResizedEvent) {\n        if (!!this.imageEl) {\n            this.imageEl.nativeElement.style.maxWidth = event.newWidth + 'px';\n        }\n    }\n\n    private initializePreviewIfDisplayable() {\n        const extension = this.dataField.value.name.split('.').reverse()[0];\n        this.isDisplayable = Object.values(FilePreviewType).includes(extension as any);\n        if (this.isDisplayable) {\n            this.previewExtension = FilePreviewType[extension];\n            this.initFileFieldImage();\n        }\n    }\n\n    public getHeight() {\n        return this.dataField.layout && this.dataField.layout.rows && this.dataField.layout.rows !== 1 ?\n            (this.dataField.layout.rows) * fieldHeight - fieldPadding : fieldHeight - fieldPadding;\n    }\n\n    public getPreviewBorderWidth(): string {\n        if (this.borderPropertyEnabled('borderWidth')) {\n            return this.dataField.component.properties.borderWidth + 'px';\n        }\n        return `${AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_WIDTH}px`;\n    }\n\n    public getPreviewBorderStyle(): string {\n        if (this.borderPropertyEnabled('borderStyle')) {\n            return this.dataField.component.properties.borderStyle;\n        }\n        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_STYLE;\n    }\n\n    public getPreviewBorderColor(): string {\n        if (this.borderPropertyEnabled('borderColor')) {\n            return this.dataField.component.properties.borderColor;\n        }\n        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_COLOR;\n    }\n\n    public isBorderLGBTQ(): boolean {\n        if (this.borderPropertyEnabled('borderLGBTQ')) {\n            return this.dataField.component.properties.borderLGBTQ === 'true';\n        }\n        return false;\n    }\n\n    public isBorderDefault(): boolean {\n        if (this.borderPropertyEnabled('borderEnabled')) {\n            return this.dataField.component.properties.borderEnabled === 'true';\n        }\n        return false;\n    }\n\n    public borderPropertyEnabled(property: string): boolean {\n        return !!this.dataField.component && !!this.dataField.component.properties && property in this.dataField.component.properties;\n    }\n\n    protected resolveParentTaskId(): string {\n        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;\n    }\n}\n"]}

package/esm2015/lib/data-fields/file-field/abstract-preview-dialog/preview-dialog-data.js

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

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

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

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

@@ -0,0 +1,106 @@
+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
+ */
+export class FileField extends DataField {
+    /**
+     * Create new instance for file field with all his properties.
+     *
+     * Placeholder is a substitute for the value name if not set value.
+     */
+    constructor(stringId, title, behavior, value, placeholder, description, layout, _maxUploadSizeInBytes, _allowTypes, validations, component, parentTaskId) {
+        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);
+        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();
+    }
+    set value(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;
+    }
+    get value() {
+        return this._value.getValue();
+    }
+    valueWithoutChange(value) {
+        this.changed = false;
+        this._value.next(value !== null && value !== void 0 ? value : {});
+    }
+    get maxUploadSizeInBytes() {
+        return this._maxUploadSizeInBytes;
+    }
+    get allowTypes() {
+        return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;
+    }
+    get changedFields$() {
+        return this._changedFields$.asObservable();
+    }
+    emitChangedFields(change) {
+        this._changedFields$.next(change);
+    }
+    valueEquality(a, b) {
+        let 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);
+    }
+    registerFormControl(formControl) {
+        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(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;
+    }
+    updateFormControlState(formControl) {
+        this.subscribeToInnerSubjects(formControl);
+        this.update();
+    }
+}
+//# 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":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,kCAAkC,CAAC;AAI3D,OAAO,EAAa,OAAO,EAAC,MAAM,MAAM,CAAC;AAKzC,OAAO,EAAC,oBAAoB,EAAC,MAAM,gBAAgB,CAAC;AAEpD;;GAEG;AACH,MAAM,CAAN,IAAY,kBASX;AATD,WAAY,kBAAkB;IAC1B,uCAAiB,CAAA;IACjB,uCAAiB,CAAA;IACjB,uCAAiB,CAAA;IACjB,kCAAY,CAAA;IACZ,kCAAY,CAAA;IACZ,kCAAY,CAAA;IACZ,6CAAuB,CAAA;IACvB,6CAAuB,CAAA;AAC3B,CAAC,EATW,kBAAkB,KAAlB,kBAAkB,QAS7B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,eAKX;AALD,WAAY,eAAe;IACvB,mDAAG,CAAA;IACH,mDAAG,CAAA;IACH,qDAAI,CAAA;IACJ,mDAAG,CAAA;AACP,CAAC,EALW,eAAe,KAAf,eAAe,QAK1B;AAWD;;GAEG;AACH,MAAM,OAAO,SAAU,SAAQ,SAAyB;IAkCpD;;;;OAIG;IACH,YAAY,QAAgB,EAAE,KAAa,EAAE,QAAkB,EAAE,KAAsB,EAAE,WAAoB,EAAE,WAAoB,EACvH,MAAe,EAAU,qBAA8B,EAC/C,WAAqE,EAC7E,WAA+B,EAAE,SAAqB,EAAE,YAAqB;QACrF,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QAH/E,0BAAqB,GAArB,qBAAqB,CAAS;QAC/C,gBAAW,GAAX,WAAW,CAA0D;QAxCzF;;;;WAIG;QACI,cAAS,GAAG,CAAC,CAAC;QAsCjB,IAAI,CAAC,eAAe,GAAG,IAAI,OAAO,EAAoB,CAAC;IAC3D,CAAC;IA9BD,IAAI,KAAK,CAAC,KAAqB;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACvE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,gBAAgB,CAAC,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,CAAC,CAAC;SACtC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,CAAC,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAEM,kBAAkB,CAAC,KAAqB;QAC3C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,CAAC,CAAC;IAClC,CAAC;IAeD,IAAI,oBAAoB;QACpB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACtC,CAAC;IAED,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;IAC9F,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAEM,iBAAiB,CAAC,MAAwB;QAC7C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAES,aAAa,CAAC,CAAiB,EAAE,CAAiB;QACxD,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE;YAC5B,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;SACtC;QACD,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;IACnE,CAAC;IAEM,mBAAmB,CAAC,WAAwB;QAC/C,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,0CAA0C;kBACpD,iFAAiF,CAAC,CAAC;SAC5F;QAED,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,4BAA4B,EAAE,CAAC,CAAC;QAE/D,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CACxC,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAC3C,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;;YACnB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,6BAA6B,CAAC,WAAW,CAAC,CAAC;YAC7D,WAAW,CAAC,QAAQ,OAAC,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,IAAI,mCAAI,EAAE,CAAC,CAAC;YAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;QACzC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IACpC,CAAC;IAES,sBAAsB,CAAC,WAAwB;QACrD,IAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;IAClB,CAAC;CACJ","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"]}