@netgrif/components-core 6.0.1

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

@@ -0,0 +1,405 @@
+import { __extends } from "tslib";
+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';
+var preview = 'preview';
+var fieldHeight = 105;
+var fieldPadding = 16;
+/**
+ * Component that is created in the body of the task panel accord on the Petri Net, which must be bind properties.
+ */
+var AbstractFileFieldComponent = /** @class */ (function (_super) {
+    __extends(AbstractFileFieldComponent, _super);
+    /**
+     * 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
+     */
+    function AbstractFileFieldComponent(_taskResourceService, _log, _snackbar, _translate, _eventService, informAboutInvalidData, _sanitizer) {
+        var _this = _super.call(this, informAboutInvalidData) || this;
+        _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);
+        return _this;
+    }
+    /**
+     * Set :
+     *  - File field to [FileFieldService]{@link FileFieldService}
+     *  - Display name
+     */
+    AbstractFileFieldComponent.prototype.ngOnInit = function () {
+        _super.prototype.ngOnInit.call(this);
+        this.filePreview = this.dataField && this.dataField.component && this.dataField.component.name
+            && this.dataField.component.name === preview;
+    };
+    AbstractFileFieldComponent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        if (this.fileUploadEl) {
+            this.fileUploadEl.nativeElement.onchange = function () {
+                _this.upload();
+            };
+        }
+        if (this.filePreview) {
+            if (!!this.imageDivEl) {
+                if (!this.isEmpty()) {
+                    this.initializePreviewIfDisplayable();
+                }
+            }
+        }
+    };
+    AbstractFileFieldComponent.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.fullSource.complete();
+    };
+    AbstractFileFieldComponent.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.
+     */
+    AbstractFileFieldComponent.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.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;
+        var fileFormData = new FormData();
+        var fileToUpload = this.fileUploadEl.nativeElement.files.item(0);
+        fileFormData.append('file', fileToUpload);
+        this._taskResourceService.uploadFile(this.resolveParentTaskId(), this.dataField.stringId, fileFormData, false)
+            .subscribe(function (response) {
+            if (response.type && response.type === ProgressType.UPLOAD) {
+                _this.state.progress = response.progress;
+            }
+            else {
+                var 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 = '';
+            }
+        }, 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 = '';
+        });
+    };
+    AbstractFileFieldComponent.prototype.download = function () {
+        var _this = this;
+        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(function (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;
+            }
+        }, function (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;
+        });
+    };
+    AbstractFileFieldComponent.prototype.initDownloadFile = function (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)));
+            }
+        }
+    };
+    AbstractFileFieldComponent.prototype.downloadViaAnchor = function (blob) {
+        var a = document.createElement('a');
+        document.body.appendChild(a);
+        a.setAttribute('style', 'display: none');
+        if (!this.fileForDownload) {
+            blob = new Blob([blob], { type: 'application/octet-stream' });
+        }
+        var 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);
+    };
+    AbstractFileFieldComponent.prototype.deleteFile = function () {
+        var _this = this;
+        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(function (response) {
+            if (response.success) {
+                var 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'));
+            }
+        });
+    };
+    AbstractFileFieldComponent.prototype.isEmpty = function () {
+        return !this.dataField.value || !this.dataField.value.name;
+    };
+    Object.defineProperty(AbstractFileFieldComponent.prototype, "defaultState", {
+        get: function () {
+            return {
+                progress: 0,
+                completed: false,
+                error: false,
+                uploading: false,
+                downloading: false
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Construct display name.
+     */
+    AbstractFileFieldComponent.prototype.constructDisplayName = function () {
+        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.
+     */
+    AbstractFileFieldComponent.prototype.initFileFieldImage = function () {
+        var _this = this;
+        if (!this.checkFileBeforeDownload()) {
+            return;
+        }
+        this.state.downloading = true;
+        this._taskResourceService.downloadFilePreview(this.taskId, this.dataField.stringId).subscribe(function (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;
+            }
+        }, function (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;
+        });
+    };
+    AbstractFileFieldComponent.prototype.checkFileBeforeDownload = function () {
+        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;
+    };
+    AbstractFileFieldComponent.prototype.showPreviewDialog = function () {
+        var _this = this;
+        if (!this.checkFileBeforeDownload()) {
+            return;
+        }
+        this._taskResourceService.downloadFile(this.taskId, this.dataField.stringId).subscribe(function (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);
+            }
+        }, function (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;
+        });
+    };
+    AbstractFileFieldComponent.prototype.changeMaxWidth = function (event) {
+        if (!!this.imageEl) {
+            this.imageEl.nativeElement.style.maxWidth = event.newWidth + 'px';
+        }
+    };
+    AbstractFileFieldComponent.prototype.initializePreviewIfDisplayable = function () {
+        var extension = this.dataField.value.name.split('.').reverse()[0];
+        this.isDisplayable = Object.values(FilePreviewType).includes(extension);
+        if (this.isDisplayable) {
+            this.previewExtension = FilePreviewType[extension];
+            this.initFileFieldImage();
+        }
+    };
+    AbstractFileFieldComponent.prototype.getHeight = function () {
+        return this.dataField.layout && this.dataField.layout.rows && this.dataField.layout.rows !== 1 ?
+            (this.dataField.layout.rows) * fieldHeight - fieldPadding : fieldHeight - fieldPadding;
+    };
+    AbstractFileFieldComponent.prototype.getPreviewBorderWidth = function () {
+        if (this.borderPropertyEnabled('borderWidth')) {
+            return this.dataField.component.properties.borderWidth + 'px';
+        }
+        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_WIDTH + "px";
+    };
+    AbstractFileFieldComponent.prototype.getPreviewBorderStyle = function () {
+        if (this.borderPropertyEnabled('borderStyle')) {
+            return this.dataField.component.properties.borderStyle;
+        }
+        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_STYLE;
+    };
+    AbstractFileFieldComponent.prototype.getPreviewBorderColor = function () {
+        if (this.borderPropertyEnabled('borderColor')) {
+            return this.dataField.component.properties.borderColor;
+        }
+        return AbstractFileFieldComponent.DEFAULT_PREVIEW_BORDER_COLOR;
+    };
+    AbstractFileFieldComponent.prototype.isBorderLGBTQ = function () {
+        if (this.borderPropertyEnabled('borderLGBTQ')) {
+            return this.dataField.component.properties.borderLGBTQ === 'true';
+        }
+        return false;
+    };
+    AbstractFileFieldComponent.prototype.isBorderDefault = function () {
+        if (this.borderPropertyEnabled('borderEnabled')) {
+            return this.dataField.component.properties.borderEnabled === 'true';
+        }
+        return false;
+    };
+    AbstractFileFieldComponent.prototype.borderPropertyEnabled = function (property) {
+        return !!this.dataField.component && !!this.dataField.component.properties && property in this.dataField.component.properties;
+    };
+    AbstractFileFieldComponent.prototype.resolveParentTaskId = function () {
+        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 = 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,] }] },
+        { 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',] }]
+    };
+    return AbstractFileFieldComponent;
+}(AbstractDataFieldComponent));
+export { AbstractFileFieldComponent };
+//# 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/esm5/lib/data-fields/file-field/abstract-preview-dialog/preview-dialog-data.js

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

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

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