@colijnit/sharedcomponents 1.0.57 → 1.0.59

package/esm2015/lib/components/files-upload/components/base-file-upload.component.js

@@ -0,0 +1,469 @@
+import { __awaiter, __decorate } from "tslib";
+import { ComponentFactoryResolver, Directive, EventEmitter, HostBinding, HostListener, Input, Output, ViewContainerRef } from "@angular/core";
+import { TableName } from "../../../enum/table-name.enum";
+import { DictionaryService } from "../../../service/dictionary.service";
+import { FileType } from "@colijnit/mainapi/build/enum/file-type.enum";
+import { OperationWithAlwaysSuccessCallback } from "../../../interface/operation-callback-simple-function";
+import { ArrayUtils } from "../../../utils/array-utils";
+import { RefCodeUtils } from "../../../utils/ref-code-utils";
+import { CoDocumentSharedFieldLogic } from "../../../utils/co-document-shared-field-logic";
+import { ObjectRightType } from "@colijnit/sharedapi/build/enum/object-right-type.enum";
+import { InputBoolean } from "../../../decorator/input-boolean.decorator";
+import { AppFileDropzoneComponent } from "../../app-file-dropzone/app-file-dropzone.component";
+import { FileUtils } from "@colijnit/mainapi/build/utils/file-utils";
+import { CoDocument } from "@colijnit/mainapi/build/model/co-document";
+import { CoDocumentType } from "@colijnit/mainapi/build/enum/co-document-type.enum";
+import { FileUploadPopupComponent } from "../../file-upload-popup/file-upload-popup.component";
+// A base component that lets the user make a list of files from its device. Doesn't actually upload, but outputs chosen files as filesChanged.
+export class BaseFileUploadComponent {
+    // private static readonly _dummyTrueFunction: OperationCallbackSimpleFunction = (object: any) => Promise.resolve(true);
+    constructor(
+    //protected _promptService: PromptService,
+    _dictionaryService, 
+    //protected _userService: UserService,
+    _container, _factory) {
+        this._dictionaryService = _dictionaryService;
+        this._container = _container;
+        this._factory = _factory;
+        this.documents = [];
+        // The ability to drop files on the page
+        this.fullPageDrop = false;
+        // If user gets the ability of adding files.
+        this.canAdd = true;
+        // Show add button
+        this.addWithButton = true;
+        // If user gets the ability of deleting files.
+        this.canDelete = true;
+        this.noDragDropOrdering = false;
+        this.askBeforeDelete = true;
+        this.resizeImages = false;
+        this.lockOperation = OperationWithAlwaysSuccessCallback;
+        this.unlockOperation = OperationWithAlwaysSuccessCallback;
+        this.beforeDeleteOperation = OperationWithAlwaysSuccessCallback;
+        this.afterDeleteOperation = OperationWithAlwaysSuccessCallback;
+        this.beforeCreateOperation = OperationWithAlwaysSuccessCallback;
+        this.afterCreateOperation = OperationWithAlwaysSuccessCallback;
+        this.beforeEditOperation = OperationWithAlwaysSuccessCallback;
+        this.dontAskBeforeDelete = false;
+        this.noOwnDeleteOperation = false;
+        this.useWithoutSettingProps = false;
+        this.medicalUserGroups = false;
+        // Use with customFileDropEvent
+        this.useCustomFileDropEvent = false;
+        // Use in conjunction with useCustomFileDropEvent
+        this.customFileDropEvent = new EventEmitter();
+        // Emits if user wants to add multiple documents at once
+        this.documentsAdded = new EventEmitter();
+        this.documentDeleted = new EventEmitter();
+        // Emits every time the order of documents was changed
+        this.sortableListChanged = new EventEmitter();
+        this.documentChangeEvent = new EventEmitter();
+        // Use this if consumer requires to perform extra actions, like locking a parent businessObject if it contains the collection of documents. Emit with true when popup opened, false for close
+        this.popupOpenedStateChange = new EventEmitter();
+        this._documentKey = "";
+        this._readonly = false;
+    }
+    // The fileType that the documents should be saved as, leave empty to automatically detect filetype. Also determines file picker filter
+    set fileType(value) {
+        if (value) {
+            this._fileType = value;
+            //TODO Documentdataloader fix
+            //this._coDocumentDataLoader.loadAllowedTypes().then(() => {this.handleAcceptedFileTypesLoaded(value)});
+        }
+    }
+    get fileType() {
+        return this._fileType;
+    }
+    set documentKey(value) {
+        this._documentKey = value + ""; // force string
+    }
+    get documentKey() {
+        return this._documentKey;
+    }
+    set readonly(value) {
+        this._readonly = value;
+        if (this._popup && this._popup.instance) {
+            this._popup.instance.readonly = value;
+        }
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    set maxUploadSizeParam(value) {
+        if (value) {
+            this._setInternalParamObj(value);
+        }
+    }
+    onDrop(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!this.useCustomFileDropEvent) {
+            this.filesPicked(event.dataTransfer.files);
+        }
+        else {
+            this.customFileDropEvent.emit(event.dataTransfer.files);
+        }
+        this._clearDropzone();
+    }
+    onDragEnd(event) {
+        event.dataTransfer.clearData();
+        this._clearDropzone();
+    }
+    onDragOver(event) {
+        event.preventDefault();
+    }
+    onDragEnter(event) {
+        this._dragEnterTarget = event.target;
+        this._showDropzone();
+    }
+    onDragLeave(event) {
+        if (event.target === this._dragEnterTarget) {
+            this._clearDropzone();
+        }
+    }
+    ngOnDestroy() {
+        this._clearDropzone();
+    }
+    _showDropzone() {
+        if (!this._dropZone) {
+            const fact = this._factory.resolveComponentFactory(AppFileDropzoneComponent);
+            this._dropZone = this._container.createComponent(fact);
+            this._dropZone.instance.customDropActionMessage = this.dropMessage;
+        }
+    }
+    _clearDropzone() {
+        this._container.clear();
+        if (this._dropZone) {
+            this._dropZone.destroy();
+            this._dropZone = undefined;
+        }
+    }
+    // Remove file from upload array.
+    handleDelete(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let success = yield this.beforeDeleteOperation(file);
+            try {
+                if (success) {
+                    yield this._delete(file);
+                    success = true;
+                }
+            }
+            finally {
+                yield this.afterDeleteOperation(file);
+            }
+            return Promise.resolve(success);
+        });
+    }
+    _delete(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let doDelete = true;
+            if (!this.dontAskBeforeDelete) {
+                //TODO make dialogService
+                //doDelete = await this._promptService.showYesNo("MESSAGE_DELETE_RECORD_QUESTION");
+            }
+            if (doDelete) {
+                if (!this.noOwnDeleteOperation) {
+                    ArrayUtils.RemoveElement(file, this.documents);
+                }
+                this.documentDeleted.emit(file);
+            }
+        });
+    }
+    handleSortingChange(docs) {
+        this.sortableListChanged.emit(docs);
+    }
+    handleFileChange(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (event && event.target && event.target.files && event.target.files.length > 0) {
+                // check file sizes and extension
+                //Todo: fix this
+                //const allowedExtensions = await this._baseDataDalRepository.getAllowedExtensions();
+                let allFilesAreSmallEnough = true;
+                let allFilesHaveAllowedExtensions = true;
+                const sizeToCompare = this._maxUploadFileSize ? this._maxUploadFileSize : undefined;
+                const len = event.target.files.length;
+                for (let i = 0; i < len; i++) {
+                    const uploadSizeAllowed = FileUtils.CheckMaxUploadSize(event.target.files[i], sizeToCompare);
+                    if (!uploadSizeAllowed) {
+                        allFilesAreSmallEnough = false;
+                        break;
+                    }
+                    const extensionAllowed = true; //FileUtils.CheckExtension(event.target.files[i], allowedExtensions);
+                    if (!extensionAllowed) {
+                        allFilesHaveAllowedExtensions = false;
+                        break;
+                    }
+                }
+                if (!allFilesAreSmallEnough) {
+                    //TODO make dialogService
+                    //this._promptService.showWarning(this._dictionaryService.get("FILE_TOO_LARGE_TO_UPLOAD", true, "" + [FileUtils.getMaxUploadSizeInMb(sizeToCompare)]));
+                }
+                else if (!allFilesHaveAllowedExtensions) {
+                    //const extensionsList = allowedExtensions.map(allowedExtension => allowedExtension.extension).sort().join(", ");
+                    //this._promptService.showWarning(this._dictionaryService.get("FILE_HAS_DISALLOWED_EXTENSION", false, extensionsList));
+                }
+                else {
+                    const filesToAdd = yield this.convertFilesIntoCoDocuments(event.target.files);
+                    if (filesToAdd.length > 1) {
+                        this.documentsAdded.emit(filesToAdd);
+                    }
+                    else {
+                        if (this.useWithoutSettingProps) {
+                            this.documentsAdded.next(filesToAdd);
+                        }
+                        else {
+                            this.documentUnderEdit = filesToAdd[0];
+                            this.openPopup();
+                        }
+                    }
+                }
+            }
+        });
+    }
+    handleEditDocumentClick(docToEdit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.documentUnderEdit = docToEdit;
+            const showPopup = yield this.beforeEditOperation(docToEdit);
+            if (showPopup) {
+                this.openPopup();
+            }
+        });
+    }
+    openPopup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._createAndFillPopupInstance();
+            this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc) => {
+                this.documentChangeEvent.emit(doc);
+            });
+        });
+    }
+    openPopupToAddDocumentByUrl() {
+        this._createDocumentToAddByUrl();
+        this._createAndFillPopupInstance(true);
+        this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc) => {
+            doc.fileName = doc.filePath;
+            this.documentChangeEvent.emit(doc);
+        });
+    }
+    _createDocumentToAddByUrl() {
+        this.documentUnderEdit = new CoDocument();
+        this.documentUnderEdit.table = this.documentTable;
+        this.documentUnderEdit.key = this.documentKey;
+        this.documentUnderEdit.fileType = this.fileType;
+        this.documentUnderEdit.documentType = CoDocumentType.SaveAsLinkOnRandomLocation;
+        this.documentUnderEdit.pathIsUrl = true;
+        //TODO Fix user Input
+        //this.documentUnderEdit.creationUser = this._userService.userName.toUpperCase();
+        //this.documentUnderEdit.modifiedUser = this._userService.userName.toUpperCase();
+        this.documentUnderEdit.creationDate = new Date();
+        this.documentUnderEdit.modifiedDate = new Date();
+    }
+    _createAndFillPopupInstance(addDocumentByUrl = false) {
+        this.popupOpenedStateChange.emit(true);
+        const factory = this._factory.resolveComponentFactory(FileUploadPopupComponent);
+        this._popup = this._container.createComponent(factory);
+        this._popup.instance.readonly = this._readonly;
+        this._popup.instance.addDocumentByUrl = addDocumentByUrl;
+        this._popup.instance.hasPublicAccessVisible = this.documentTable === TableName.Goods;
+        this._popup.instance.showDocumentReportPicker = (this.documentTable === TableName.Transactions || this.documentTable === TableName.TransactionLines);
+        this._popup.instance.documentUnderEdit = this.documentUnderEdit;
+        this._popup.instance.filesUploadConfigObjects = this.filesUploadConfigObjects;
+        this._popup.instance.medicalUserGroups = this.medicalUserGroups;
+        this._popup.instance.tagCategory = this.tagCategory;
+        this._popup.instance.displayReadWriteAccess = this.displayReadWriteAccess;
+        this._popup.instance.tagReferenceTable = this.tagReferenceTable;
+        this._popup.instance.publicationIds = RefCodeUtils.GetMultiRefCodeChoices(this.documentUnderEdit.publication);
+        this._popup.instance.storeGroupIds = this.documentUnderEdit.retailFormulas;
+        this._popup.instance.fileType = this.fileType;
+        this._prepareFileRights();
+        this._popupCloseSub = this._popup.instance.popupCloseEvent.subscribe(() => {
+            this._unlockDocument();
+            this.popupOpenedStateChange.emit(false);
+            this._popupCloseSub.unsubscribe();
+            this._docChangeSub.unsubscribe();
+            this._popup.destroy();
+            this._popup = undefined;
+        });
+    }
+    convertFilesIntoCoDocuments(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amountOfFiles = files.length;
+            const filesToAdd = [];
+            for (let i = 0; i < amountOfFiles; i++) {
+                const fileAsDocument = yield this._getFileAsDocument(files[i]);
+                fileAsDocument.index = CoDocumentSharedFieldLogic.GenerateAvailableIndexNr(this.documents || []) + i;
+                filesToAdd.push(fileAsDocument);
+            }
+            return filesToAdd;
+        });
+    }
+    filesPicked(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (files && files.length) {
+                let allFilesAreValid = true;
+                const amountOfFiles = files.length;
+                for (let i = 0; i < amountOfFiles; i++) {
+                    if (!FileUtils.CheckMaxUploadSize(files[i], this._maxUploadFileSize)) {
+                        allFilesAreValid = false;
+                        break;
+                    }
+                }
+                if (!allFilesAreValid) {
+                    //TODO make dialogService
+                    //this._promptService.showWarning(this._dictionaryService.get("FILE_TOO_LARGE_TO_UPLOAD", true, "" + FileUtils.getMaxUploadSizeInMb(this._maxUploadFileSize).toString()));
+                }
+                else {
+                    const filesToAdd = yield this.convertFilesIntoCoDocuments(files);
+                    if (filesToAdd.length > 1 || this.useWithoutSettingProps) {
+                        this.documentsAdded.emit(filesToAdd);
+                    }
+                    else {
+                        this.documentUnderEdit = filesToAdd[0]; // Setting docUnderEdit opens the popup window
+                        this.openPopup();
+                    }
+                }
+            }
+        });
+    }
+    handleAcceptedFileTypesLoaded(value) {
+        //TODO fix loading
+        //this.acceptedUploadFormats = this._coDocumentDataLoader.getAllowedExtensionsForType(value);
+    }
+    _getFileAsDocument(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileAsCoDocument = yield FileUtils.ReadFileAsNewCoDocument(file, this.resizeImages);
+            // set some extra known fields for the codocument:
+            fileAsCoDocument.table = this.documentTable;
+            fileAsCoDocument.key = this.documentKey;
+            //TODO fix add users
+            //fileAsCoDocument.creationUser = this._userService.userName.toUpperCase();
+            //fileAsCoDocument.modifiedUser = this._userService.userName.toUpperCase();
+            fileAsCoDocument.creationDate = new Date();
+            fileAsCoDocument.modifiedDate = new Date();
+            fileAsCoDocument.fileType = this.fileType ? this.fileType : FileUtils.IsImageFile(file) ? FileType.Image : FileType.Document;
+            if (fileAsCoDocument) {
+                return fileAsCoDocument;
+            }
+        });
+    }
+    _setInternalParamObj(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //TODO fix params
+            //const param: InternalParameterObject = await this._generalDalRepository.getInternalParamObject(value);
+            //this._maxUploadFileSize = isNaN(parseInt(param.value, 0)) ? undefined : parseInt(param.value, 0);
+        });
+    }
+    _lockDocument() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.documentUnderEdit.documentId) {
+                return true; // New document does not have an ID and therefore does not have to be locked
+            }
+            const lockOk = yield this.lockOperation(CoDocument);
+            return lockOk;
+        });
+    }
+    _unlockDocument() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.documentUnderEdit.documentId) {
+                return true; // New document does not have an ID and therefore does not have to be locked
+            }
+            const unlockOk = yield this.unlockOperation(CoDocument);
+            return unlockOk;
+        });
+    }
+    _prepareFileRights() {
+        const len = this.documentUnderEdit.rights.length;
+        for (let i = 0; i < len; i++) {
+            const right = this.documentUnderEdit.rights[i];
+            if (right.rightLevel === ObjectRightType.ReadWrite) {
+                this._popup.instance.userGroupsForWrite.push(right.userGroupId);
+            }
+            if (right.rightLevel === ObjectRightType.ReadOnly) {
+                this._popup.instance.userGroupsForRead.push(right.userGroupId);
+            }
+        }
+    }
+}
+BaseFileUploadComponent.decorators = [
+    { type: Directive }
+];
+BaseFileUploadComponent.ctorParameters = () => [
+    { type: DictionaryService },
+    { type: ViewContainerRef },
+    { type: ComponentFactoryResolver }
+];
+BaseFileUploadComponent.propDecorators = {
+    fileType: [{ type: Input }],
+    documents: [{ type: Input }],
+    documentTable: [{ type: Input }],
+    documentKey: [{ type: Input }],
+    fullPageDrop: [{ type: Input }],
+    canAdd: [{ type: Input }],
+    dropMessage: [{ type: Input }],
+    addWithButton: [{ type: Input }],
+    canDelete: [{ type: Input }],
+    noDragDropOrdering: [{ type: Input }],
+    readonly: [{ type: Input }],
+    askBeforeDelete: [{ type: Input }],
+    resizeImages: [{ type: Input }],
+    lockOperation: [{ type: Input }],
+    unlockOperation: [{ type: Input }],
+    beforeDeleteOperation: [{ type: Input }],
+    afterDeleteOperation: [{ type: Input }],
+    beforeCreateOperation: [{ type: Input }],
+    afterCreateOperation: [{ type: Input }],
+    beforeEditOperation: [{ type: Input }],
+    dontAskBeforeDelete: [{ type: Input }],
+    noOwnDeleteOperation: [{ type: Input }],
+    maxUploadSizeParam: [{ type: Input }],
+    useWithoutSettingProps: [{ type: Input }],
+    filesUploadConfigObjects: [{ type: Input }],
+    medicalUserGroups: [{ type: Input }],
+    tagCategory: [{ type: Input }],
+    tagReferenceTable: [{ type: Input }],
+    displayReadWriteAccess: [{ type: Input }],
+    useCustomFileDropEvent: [{ type: Input }],
+    customFileDropEvent: [{ type: Output }],
+    documentsAdded: [{ type: Output }],
+    documentDeleted: [{ type: Output }],
+    sortableListChanged: [{ type: Output }],
+    documentChangeEvent: [{ type: Output }],
+    popupOpenedStateChange: [{ type: Output }],
+    hidden: [{ type: HostBinding, args: ["class.hidden",] }],
+    onDrop: [{ type: HostListener, args: ["drop", ["$event"],] }],
+    onDragEnd: [{ type: HostListener, args: ["dragend", ["$event"],] }],
+    onDragOver: [{ type: HostListener, args: ["dragover", ["$event"],] }],
+    onDragEnter: [{ type: HostListener, args: ["dragenter", ["$event"],] }],
+    onDragLeave: [{ type: HostListener, args: ["dragleave", ["$event"],] }]
+};
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "noDragDropOrdering", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "readonly", null);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "askBeforeDelete", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "resizeImages", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "dontAskBeforeDelete", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "noOwnDeleteOperation", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "useWithoutSettingProps", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "medicalUserGroups", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "displayReadWriteAccess", void 0);
+__decorate([
+    InputBoolean()
+], BaseFileUploadComponent.prototype, "useCustomFileDropEvent", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-file-upload.component.js","sourceRoot":"","sources":["../../../../../../../projects/sharedcomponents/src/lib/components/files-upload/components/base-file-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ComponentFactory,\n    ComponentFactoryResolver,\n    ComponentRef,\n    Directive,\n    EventEmitter,\n    HostBinding,\n    HostListener,\n    Input,\n    OnDestroy,\n    Output,\n    ViewContainerRef\n} from \"@angular/core\";\nimport {ScreenConfigAdapterComponent} from \"@colijnit/corecomponents_v12\";\nimport {Subscription} from \"rxjs\";\nimport {TableName} from \"../../../enum/table-name.enum\";\nimport {DictionaryService} from \"../../../service/dictionary.service\";\nimport {FileType} from \"@colijnit/mainapi/build/enum/file-type.enum\";\nimport {\n    OperationCallbackSimpleFunction,\n    OperationWithAlwaysSuccessCallback\n} from \"../../../interface/operation-callback-simple-function\";\nimport {InternalParam} from \"../../../enum/internal-param.enum\";\nimport {FilesUploadConfigObjects} from \"../../../enum/files-upload-config-objects\";\nimport {TagCategory} from \"../../../enum/tag-category.enum\";\nimport {ArrayUtils} from \"../../../utils/array-utils\";\nimport {RefCodeUtils} from \"../../../utils/ref-code-utils\";\nimport {CoDocumentSharedFieldLogic} from \"../../../utils/co-document-shared-field-logic\";\nimport {CoDocumentRight} from \"../../../businessobject/co-document-right.bo\";\nimport {ObjectRightType} from \"@colijnit/sharedapi/build/enum/object-right-type.enum\";\nimport {InputBoolean} from \"../../../decorator/input-boolean.decorator\";\nimport {AppFileDropzoneComponent} from \"../../app-file-dropzone/app-file-dropzone.component\";\nimport {FileUtils} from \"@colijnit/mainapi/build/utils/file-utils\";\nimport {CoDocument} from \"@colijnit/mainapi/build/model/co-document\";\nimport {CoDocumentType} from \"@colijnit/mainapi/build/enum/co-document-type.enum\";\nimport {FileUploadPopupComponent} from \"../../file-upload-popup/file-upload-popup.component\";\n\n\n\n// A base component that lets the user make a list of files from its device. Doesn't actually upload, but outputs chosen files as filesChanged.\n@Directive()\nexport abstract class BaseFileUploadComponent implements ScreenConfigAdapterComponent, OnDestroy {\n    decimals: number;\n    forceReadonly: boolean;\n    maxLength: number;\n    objectConfigName: string;\n    redErrorBackground: boolean;\n    required: boolean;\n\n    // The fileType that the documents should be saved as, leave empty to automatically detect filetype. Also determines file picker filter\n    @Input()\n    public set fileType(value: FileType) {\n        if (value) {\n            this._fileType = value;\n            //TODO Documentdataloader fix\n            //this._coDocumentDataLoader.loadAllowedTypes().then(() => {this.handleAcceptedFileTypesLoaded(value)});\n        }\n    }\n\n    public get fileType(): FileType {\n        return this._fileType;\n    }\n\n    @Input()\n    public documents: CoDocument[] = [];\n\n    @Input()\n    public documentTable: TableName;\n\n    @Input()\n    public set documentKey(value: string) {\n        this._documentKey = value + \"\"; // force string\n    }\n\n    public get documentKey(): string {\n        return this._documentKey;\n    }\n\n    // The ability to drop files on the page\n    @Input()\n    public fullPageDrop: boolean = false;\n\n    // If user gets the ability of adding files.\n    @Input()\n    public canAdd: boolean = true;\n\n    @Input()\n    public dropMessage: string;\n\n    // Show add button\n    @Input()\n    public addWithButton: boolean = true;\n\n    // If user gets the ability of deleting files.\n    @Input()\n    public canDelete: boolean = true;\n\n    @Input()\n    @InputBoolean()\n    public noDragDropOrdering: boolean = false;\n\n    @Input()\n    @InputBoolean()\n    public set readonly(value: boolean) {\n        this._readonly = value;\n\n        if (this._popup && this._popup.instance) {\n            this._popup.instance.readonly = value;\n        }\n    }\n\n    public get readonly(): boolean {\n        return this._readonly;\n    }\n\n    @Input()\n    @InputBoolean()\n    public askBeforeDelete: boolean = true;\n\n    @Input()\n    @InputBoolean()\n    public resizeImages: boolean = false;\n\n    @Input()\n    public lockOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    public unlockOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n\n\n\n    @Input()\n    public beforeDeleteOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    public afterDeleteOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    public beforeCreateOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    public afterCreateOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    public beforeEditOperation: OperationCallbackSimpleFunction = OperationWithAlwaysSuccessCallback;\n\n    @Input()\n    @InputBoolean()\n    public dontAskBeforeDelete: boolean = false;\n\n    @Input()\n    @InputBoolean()\n    public noOwnDeleteOperation: boolean = false;\n\n    private _fileType: FileType;\n\n    @Input()\n    public set maxUploadSizeParam(value: InternalParam) {\n        if (value) {\n            this._setInternalParamObj(value);\n        }\n    }\n\n    @Input()\n    @InputBoolean()\n    public useWithoutSettingProps: boolean = false;\n\n    @Input()\n    public filesUploadConfigObjects: FilesUploadConfigObjects;\n\n    @Input()\n    @InputBoolean()\n    public medicalUserGroups: boolean = false;\n\n    @Input()\n    public tagCategory: TagCategory;\n\n    @Input()\n    public tagReferenceTable: TableName;\n\n    @Input()\n    @InputBoolean()\n    public displayReadWriteAccess: boolean;\n\n    // Use with customFileDropEvent\n    @Input() @InputBoolean()\n    public useCustomFileDropEvent: boolean = false;\n\n    // Use in conjunction with useCustomFileDropEvent\n    @Output()\n    public customFileDropEvent: EventEmitter<FileList> = new EventEmitter<FileList>();\n\n    // Emits if user wants to add multiple documents at once\n    @Output()\n    public readonly documentsAdded: EventEmitter<CoDocument[]> = new EventEmitter<CoDocument[]>();\n\n    @Output()\n    public readonly documentDeleted: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\n\n    // Emits every time the order of documents was changed\n    @Output()\n    public readonly sortableListChanged: EventEmitter<CoDocument[]> = new EventEmitter<CoDocument[]>();\n\n    @Output()\n    public documentChangeEvent: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\n\n    // Use this if consumer requires to perform extra actions, like locking a parent businessObject if it contains the collection of documents. Emit with true when popup opened, false for close\n    @Output()\n    public popupOpenedStateChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    @HostBinding(\"class.hidden\")\n    public hidden: boolean;\n\n    @HostListener(\"drop\", [\"$event\"])\n    public onDrop(event: DragEvent): void {\n        event.preventDefault();\n        event.stopPropagation();\n\n        if (!this.useCustomFileDropEvent) {\n            this.filesPicked(event.dataTransfer.files);\n        } else {\n            this.customFileDropEvent.emit(event.dataTransfer.files);\n        }\n\n        this._clearDropzone();\n    }\n\n    @HostListener(\"dragend\", [\"$event\"])\n    public onDragEnd(event: DragEvent): void {\n        event.dataTransfer.clearData();\n        this._clearDropzone();\n    }\n\n    @HostListener(\"dragover\", [\"$event\"])\n    public onDragOver(event: DragEvent): void {\n        event.preventDefault();\n    }\n\n    @HostListener(\"dragenter\", [\"$event\"])\n    public onDragEnter(event: DragEvent): void {\n        this._dragEnterTarget = event.target;\n        this._showDropzone();\n    }\n\n    @HostListener(\"dragleave\", [\"$event\"])\n    public onDragLeave(event: DragEvent): void {\n        if (event.target === this._dragEnterTarget) {\n            this._clearDropzone();\n        }\n    }\n\n    public documentUnderEdit: CoDocument;\n    public acceptedUploadFormats: string;\n\n    protected _maxUploadFileSize: number;\n\n    private _dragEnterTarget: EventTarget;\n    private _documentKey: string = \"\";\n    private _dropZone: ComponentRef<AppFileDropzoneComponent>;\n    private _popup: ComponentRef<FileUploadPopupComponent>;\n    private _docChangeSub: Subscription;\n    private _popupCloseSub: Subscription;\n    private _readonly: boolean = false;\n\n    // private static readonly _dummyTrueFunction: OperationCallbackSimpleFunction = (object: any) => Promise.resolve(true);\n\n    constructor(\n\n        //protected _promptService: PromptService,\n        protected _dictionaryService: DictionaryService,\n        //protected _userService: UserService,\n        protected _container: ViewContainerRef,\n        protected _factory: ComponentFactoryResolver,\n        //protected _generalDalRepository: GeneralDalRepository,\n        //protected _dataService: DataService,\n        //protected _baseDataDalRepository: BaseDataDalRepository,\n        //protected _coDocumentDataLoader: CoDocumentDataLoaderService\n    ) {\n\n    }\n\n    ngOnDestroy(): void {\n        this._clearDropzone();\n    }\n\n    private _showDropzone(): void {\n        if (!this._dropZone) {\n            const fact: ComponentFactory<AppFileDropzoneComponent> = this._factory.resolveComponentFactory(AppFileDropzoneComponent);\n            this._dropZone = this._container.createComponent(fact);\n            this._dropZone.instance.customDropActionMessage = this.dropMessage;\n        }\n    }\n\n    private _clearDropzone(): void {\n        this._container.clear();\n        if (this._dropZone) {\n            this._dropZone.destroy();\n            this._dropZone = undefined;\n        }\n    }\n\n    // Remove file from upload array.\n    public async handleDelete(file: CoDocument): Promise<boolean> {\n        let success: boolean = await this.beforeDeleteOperation(file);\n        try {\n            if (success) {\n                await this._delete(file);\n                success = true;\n            }\n        } finally {\n            await this.afterDeleteOperation(file);\n        }\n        return Promise.resolve(success);\n    }\n\n    private async _delete(file: CoDocument): Promise<void> {\n        let doDelete: boolean = true;\n        if (!this.dontAskBeforeDelete) {\n          //TODO make dialogService\n            //doDelete = await this._promptService.showYesNo(\"MESSAGE_DELETE_RECORD_QUESTION\");\n        }\n        if (doDelete) {\n            if (!this.noOwnDeleteOperation) {\n                ArrayUtils.RemoveElement(file, this.documents);\n            }\n            this.documentDeleted.emit(file);\n        }\n    }\n\n    public handleSortingChange(docs: CoDocument[]): void {\n        this.sortableListChanged.emit(docs);\n    }\n\n    public async handleFileChange(event: any): Promise<void> {\n        if (event && event.target && event.target.files && event.target.files.length > 0) {\n            // check file sizes and extension\n            //Todo: fix this\n            //const allowedExtensions = await this._baseDataDalRepository.getAllowedExtensions();\n            let allFilesAreSmallEnough: boolean = true;\n            let allFilesHaveAllowedExtensions: boolean = true;\n            const sizeToCompare: number = this._maxUploadFileSize ? this._maxUploadFileSize : undefined;\n            const len: number = event.target.files.length;\n            for (let i: number = 0; i < len; i++) {\n                const uploadSizeAllowed = FileUtils.CheckMaxUploadSize(event.target.files[i], sizeToCompare);\n                if (!uploadSizeAllowed) {\n                    allFilesAreSmallEnough = false;\n                    break;\n                }\n                const extensionAllowed = true//FileUtils.CheckExtension(event.target.files[i], allowedExtensions);\n                if (!extensionAllowed) {\n                    allFilesHaveAllowedExtensions = false;\n                    break;\n                }\n            }\n\n            if (!allFilesAreSmallEnough) {\n              //TODO make dialogService\n                //this._promptService.showWarning(this._dictionaryService.get(\"FILE_TOO_LARGE_TO_UPLOAD\", true, \"\" + [FileUtils.getMaxUploadSizeInMb(sizeToCompare)]));\n            } else if (!allFilesHaveAllowedExtensions) {\n                //const extensionsList = allowedExtensions.map(allowedExtension => allowedExtension.extension).sort().join(\", \");\n                //this._promptService.showWarning(this._dictionaryService.get(\"FILE_HAS_DISALLOWED_EXTENSION\", false, extensionsList));\n            } else {\n                const filesToAdd: CoDocument[] = await this.convertFilesIntoCoDocuments(event.target.files);\n\n                if (filesToAdd.length > 1) {\n                    this.documentsAdded.emit(filesToAdd);\n                } else {\n                    if (this.useWithoutSettingProps) {\n                        this.documentsAdded.next(filesToAdd);\n                    } else {\n                        this.documentUnderEdit = filesToAdd[0];\n                        this.openPopup();\n                    }\n                }\n            }\n        }\n    }\n\n    public async handleEditDocumentClick(docToEdit: CoDocument): Promise<void> {\n        this.documentUnderEdit = docToEdit;\n        const showPopup: boolean = await this.beforeEditOperation(docToEdit);\n        if (showPopup) {\n            this.openPopup();\n        }\n    }\n\n    public async openPopup(): Promise<void> {\n        this._createAndFillPopupInstance();\n\n        this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc: CoDocument) => {\n            this.documentChangeEvent.emit(doc);\n        });\n    }\n\n    public openPopupToAddDocumentByUrl(): void {\n        this._createDocumentToAddByUrl();\n        this._createAndFillPopupInstance(true);\n\n        this._docChangeSub = this._popup.instance.documentChangeEvent.subscribe((doc: CoDocument) => {\n            doc.fileName = doc.filePath;\n            this.documentChangeEvent.emit(doc);\n        });\n    }\n\n    private _createDocumentToAddByUrl(): void {\n        this.documentUnderEdit = new CoDocument();\n        this.documentUnderEdit.table = this.documentTable;\n        this.documentUnderEdit.key = this.documentKey;\n        this.documentUnderEdit.fileType = this.fileType;\n        this.documentUnderEdit.documentType = CoDocumentType.SaveAsLinkOnRandomLocation;\n        this.documentUnderEdit.pathIsUrl = true;\n        //TODO Fix user Input\n        //this.documentUnderEdit.creationUser = this._userService.userName.toUpperCase();\n        //this.documentUnderEdit.modifiedUser = this._userService.userName.toUpperCase();\n        this.documentUnderEdit.creationDate = new Date();\n        this.documentUnderEdit.modifiedDate = new Date();\n    }\n\n    private _createAndFillPopupInstance(addDocumentByUrl: boolean = false): void {\n        this.popupOpenedStateChange.emit(true);\n\n        const factory: ComponentFactory<FileUploadPopupComponent> = this._factory.resolveComponentFactory(FileUploadPopupComponent);\n\n        this._popup = this._container.createComponent(factory);\n\n        this._popup.instance.readonly = this._readonly;\n        this._popup.instance.addDocumentByUrl = addDocumentByUrl;\n        this._popup.instance.hasPublicAccessVisible = this.documentTable === TableName.Goods;\n        this._popup.instance.showDocumentReportPicker = (this.documentTable === TableName.Transactions || this.documentTable === TableName.TransactionLines);\n        this._popup.instance.documentUnderEdit = this.documentUnderEdit;\n        this._popup.instance.filesUploadConfigObjects = this.filesUploadConfigObjects;\n        this._popup.instance.medicalUserGroups = this.medicalUserGroups;\n        this._popup.instance.tagCategory = this.tagCategory;\n        this._popup.instance.displayReadWriteAccess = this.displayReadWriteAccess;\n        this._popup.instance.tagReferenceTable = this.tagReferenceTable;\n        this._popup.instance.publicationIds = RefCodeUtils.GetMultiRefCodeChoices(this.documentUnderEdit.publication);\n        this._popup.instance.storeGroupIds = this.documentUnderEdit.retailFormulas;\n        this._popup.instance.fileType = this.fileType;\n\n        this._prepareFileRights();\n\n        this._popupCloseSub = this._popup.instance.popupCloseEvent.subscribe(() => {\n            this._unlockDocument();\n            this.popupOpenedStateChange.emit(false);\n            this._popupCloseSub.unsubscribe();\n            this._docChangeSub.unsubscribe();\n            this._popup.destroy();\n            this._popup = undefined;\n        });\n    }\n\n    protected async convertFilesIntoCoDocuments(files: FileList): Promise<CoDocument[]> {\n        const amountOfFiles: number = files.length;\n        const filesToAdd: CoDocument[] = [];\n\n        for (let i: number = 0; i < amountOfFiles; i++) {\n            const fileAsDocument: CoDocument = await this._getFileAsDocument(files[i]);\n            fileAsDocument.index = CoDocumentSharedFieldLogic.GenerateAvailableIndexNr(this.documents || []) + i;\n            filesToAdd.push(fileAsDocument);\n        }\n        return filesToAdd;\n    }\n\n    public async filesPicked(files: FileList): Promise<void> {\n        if (files && files.length) {\n            let allFilesAreValid: boolean = true;\n            const amountOfFiles: number = files.length;\n            for (let i: number = 0; i < amountOfFiles; i++) {\n                if (!FileUtils.CheckMaxUploadSize(files[i], this._maxUploadFileSize)) {\n                    allFilesAreValid = false;\n                    break;\n                }\n            }\n\n            if (!allFilesAreValid) {\n              //TODO make dialogService\n                //this._promptService.showWarning(this._dictionaryService.get(\"FILE_TOO_LARGE_TO_UPLOAD\", true, \"\" + FileUtils.getMaxUploadSizeInMb(this._maxUploadFileSize).toString()));\n            } else {\n                const filesToAdd: CoDocument[] = await this.convertFilesIntoCoDocuments(files);\n\n                if (filesToAdd.length > 1 || this.useWithoutSettingProps) {\n                    this.documentsAdded.emit(filesToAdd);\n                } else {\n                    this.documentUnderEdit = filesToAdd[0]; // Setting docUnderEdit opens the popup window\n                    this.openPopup();\n                }\n            }\n        }\n    }\n\n    public handleAcceptedFileTypesLoaded(value: FileType): void {\n        //TODO fix loading\n        //this.acceptedUploadFormats = this._coDocumentDataLoader.getAllowedExtensionsForType(value);\n    }\n\n    private async _getFileAsDocument(file: File): Promise<CoDocument> {\n        const fileAsCoDocument: CoDocument = await FileUtils.ReadFileAsNewCoDocument(file, this.resizeImages);\n        // set some extra known fields for the codocument:\n        fileAsCoDocument.table = this.documentTable;\n        fileAsCoDocument.key = this.documentKey;\n        //TODO fix add users\n        //fileAsCoDocument.creationUser = this._userService.userName.toUpperCase();\n        //fileAsCoDocument.modifiedUser = this._userService.userName.toUpperCase();\n        fileAsCoDocument.creationDate = new Date();\n        fileAsCoDocument.modifiedDate = new Date();\n        fileAsCoDocument.fileType = this.fileType ? this.fileType : FileUtils.IsImageFile(file) ? FileType.Image : FileType.Document;\n\n        if (fileAsCoDocument) {\n            return fileAsCoDocument;\n        }\n    }\n\n    private async _setInternalParamObj(value: InternalParam): Promise<void> {\n        //TODO fix params\n        //const param: InternalParameterObject = await this._generalDalRepository.getInternalParamObject(value);\n        //this._maxUploadFileSize = isNaN(parseInt(param.value, 0)) ? undefined : parseInt(param.value, 0);\n    }\n\n    private async _lockDocument(): Promise<boolean> {\n        if (!this.documentUnderEdit.documentId) {\n            return true; // New document does not have an ID and therefore does not have to be locked\n        }\n\n        const lockOk: boolean = await this.lockOperation(CoDocument);\n        return lockOk;\n    }\n\n    private async _unlockDocument(): Promise<boolean> {\n      if (!this.documentUnderEdit.documentId) {\n        return true; // New document does not have an ID and therefore does not have to be locked\n      }\n\n      const unlockOk: boolean = await this.unlockOperation(CoDocument);\n      return unlockOk;\n    }\n\n    private _prepareFileRights(): void {\n        const len: number = this.documentUnderEdit.rights.length;\n        for (let i: number = 0; i < len; i++) {\n            const right: CoDocumentRight = this.documentUnderEdit.rights[i];\n            if (right.rightLevel === ObjectRightType.ReadWrite) {\n                this._popup.instance.userGroupsForWrite.push(right.userGroupId);\n            }\n            if (right.rightLevel === ObjectRightType.ReadOnly) {\n                this._popup.instance.userGroupsForRead.push(right.userGroupId);\n            }\n        }\n    }\n}\n"]}