@colijnit/sharedcomponents 1.0.57 → 1.0.59

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

@@ -0,0 +1,189 @@
+import { __awaiter, __decorate } from "tslib";
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { FormComponent, PromptService } from "@colijnit/corecomponents_v12";
+import { Icon } from "../../enum/icon.enum";
+import { InputBoolean } from "../../decorator/input-boolean.decorator";
+import { FileTypeImagePipe } from "../../pipe/file-type-image.pipe";
+import { IconCacheService } from "../../service/icon-cache.service";
+// The GUI part of the files-upload component. Not a standalone component.
+export class FileUploadComponent {
+    constructor(_promptService, _fileTypeImgPipe, iconService) {
+        this._promptService = _promptService;
+        this._fileTypeImgPipe = _fileTypeImgPipe;
+        this.iconService = iconService;
+        this.icons = Icon;
+        // Element clickable
+        this.link = false;
+        this.readonly = false;
+        // Is tile an 'adding' tile
+        this.isAddingTile = false;
+        // Set this parameter to false if clicking ok on the document edit popup does not save the document
+        // so that refreshing of content on file open works correctly
+        this.fileSavesOnPopupOkClick = true;
+        this.isEditable = false;
+        // Show a trashcan icon
+        this.showTrashCan = false;
+        // Show an image as placeholder
+        this.showImage = false;
+        this.customImageClick = false;
+        this.deleteClick = new EventEmitter();
+        this.editClick = new EventEmitter();
+        this.imageClick = new EventEmitter();
+        this.previewImage = "";
+        this._label = "";
+    }
+    // Input file to upload.
+    set file(document) {
+        this._file = document;
+        this._updatePreviewImage();
+        // we should produce a preview image from given document, but its contents might not yet have been loaded:
+        this._listenForDocumentBodyChanges();
+    }
+    get file() {
+        return this._file;
+    }
+    set label(value) {
+        this._label = value;
+    }
+    get label() {
+        if (this._file && this._file.description) {
+            return this._file.description;
+        }
+        else {
+            return this._label;
+        }
+    }
+    showClass() {
+        return true;
+    }
+    get isLink() {
+        return this.link;
+    }
+    ngOnDestroy() {
+        if (this._docBodyChangeSub) {
+            this._docBodyChangeSub.unsubscribe();
+        }
+    }
+    onDeleteClick() {
+        this.deleteClick.emit();
+    }
+    onImageClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isAddingTile) {
+                return;
+            }
+            if (this.customImageClick) {
+                this.imageClick.next(this._file);
+                return;
+            }
+            //todo fix methods
+            //first download document body if it is stored in a private cdn directory
+            if (!this._file.documentBody) {
+                //await this._generalDal.getDocumentContent(this._file).then(documentBody => this._file.documentBody = documentBody);
+            }
+            if (this._file.isImageDocument()) { //preview image
+                this._promptService.showImage(this.file.documentBodyAsDataUri, "Preview");
+            }
+            else { //download document
+                try {
+                    //FileUtils.DownloadFromDataUri(this._file.bodyAsDataUri, this._file.fileName);
+                }
+                catch (e) {
+                }
+            }
+        });
+    }
+    onPencilClick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // refresh file content if files are saved individually
+            if (this._file.hasId() && this.fileSavesOnPopupOkClick) {
+                let idForLink;
+                if (this._file.idForLink) {
+                    idForLink = this._file.idForLink;
+                }
+                // Get most recent version of this file if it has an id and therefore has been saved in the db
+                //TODO fix fetch
+                // this._file = await this._generalDal.getDocumentFromTable(this._file.documentId);
+                //this._file.idForLink = idForLink; // Restore the idForLink
+            }
+            this.editClick.emit(this._file);
+        });
+    }
+    // updates this.previewImage when doc body changes
+    _listenForDocumentBodyChanges() {
+        if (this._file) {
+            if (this._docBodyChangeSub) {
+                this._docBodyChangeSub.unsubscribe();
+            }
+            // @ts-ignore
+            this._docBodyChangeSub = this._file.documentBodyChange.subscribe(() => {
+                this._updatePreviewImage();
+            });
+        }
+    }
+    _updatePreviewImage() {
+        if (this._file) {
+            if (this._file.isImageDocument()) {
+                this.previewImage = this._file.documentBodyAsDataUri;
+                if (this.previewImage === "") {
+                    //TODO fix fetch
+                    //this._generalDal.getDocumentContent(this._file).then(documentBody => this._file.documentBody = documentBody);
+                    //this.previewImage = this._file.documentBody;
+                }
+            }
+            else {
+                this.previewImage = this._fileTypeImgPipe.transform(this.file.fileTypeInternal);
+            }
+        }
+    }
+}
+FileUploadComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-file-upload",
+                template: `
+        <co-tile-render [hideImageDisplayWhenNoImage]="true" [imageDataUri]="previewImage" [description]="label" (imageClick)="onImageClick()">
+            <ng-template #infoTemplate>
+                <co-button *ngIf="isEditable && !readonly" class="edit-file" [iconData]="iconService.getIcon(icons.Account)"
+                               (click)="onPencilClick()"></co-button>
+            </ng-template>
+            <co-icon *ngIf="showTrashCan && !readonly" [iconData]="iconService.getIcon(icons.Trashbin)" class="trash" (click)="onDeleteClick()"></co-icon>
+            <co-icon tile-render-image-content *ngIf="icon" class="dark add-button" [icon]="icon"></co-icon>
+        </co-tile-render>
+    `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+FileUploadComponent.ctorParameters = () => [
+    { type: PromptService },
+    { type: FileTypeImagePipe },
+    { type: IconCacheService }
+];
+FileUploadComponent.propDecorators = {
+    form: [{ type: ViewChild, args: [FormComponent,] }],
+    file: [{ type: Input }],
+    icon: [{ type: Input }],
+    link: [{ type: Input }],
+    readonly: [{ type: Input }],
+    isAddingTile: [{ type: Input }],
+    fileSavesOnPopupOkClick: [{ type: Input }],
+    isEditable: [{ type: Input }],
+    label: [{ type: Input }],
+    showTrashCan: [{ type: Input }],
+    showImage: [{ type: Input }],
+    customImageClick: [{ type: Input }],
+    deleteClick: [{ type: Output }],
+    editClick: [{ type: Output }],
+    imageClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-file-upload',] }],
+    isLink: [{ type: HostBinding, args: ["class.link",] }]
+};
+__decorate([
+    InputBoolean()
+], FileUploadComponent.prototype, "isAddingTile", void 0);
+__decorate([
+    InputBoolean()
+], FileUploadComponent.prototype, "fileSavesOnPopupOkClick", void 0);
+__decorate([
+    InputBoolean()
+], FileUploadComponent.prototype, "isEditable", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-upload.component.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/components/file-upload/file-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Output,\n  ViewChild,\n  ViewEncapsulation\n} from \"@angular/core\";\nimport {FormComponent, PromptService} from \"@colijnit/corecomponents_v12\";\nimport {CoDocument} from \"@colijnit/mainapi/build/model/co-document\";\nimport {Icon} from \"../../enum/icon.enum\";\nimport {InputBoolean} from \"../../decorator/input-boolean.decorator\";\nimport {FileTypeImagePipe} from \"../../pipe/file-type-image.pipe\";\nimport {IconCacheService} from \"../../service/icon-cache.service\";\nimport {Subscription} from \"rxjs\";\n\n@Component({\n    selector: \"co-file-upload\",\n    template: `\n        <co-tile-render [hideImageDisplayWhenNoImage]=\"true\" [imageDataUri]=\"previewImage\" [description]=\"label\" (imageClick)=\"onImageClick()\">\n            <ng-template #infoTemplate>\n                <co-button *ngIf=\"isEditable && !readonly\" class=\"edit-file\" [iconData]=\"iconService.getIcon(icons.Account)\"\n                               (click)=\"onPencilClick()\"></co-button>\n            </ng-template>\n            <co-icon *ngIf=\"showTrashCan && !readonly\" [iconData]=\"iconService.getIcon(icons.Trashbin)\" class=\"trash\" (click)=\"onDeleteClick()\"></co-icon>\n            <co-icon tile-render-image-content *ngIf=\"icon\" class=\"dark add-button\" [icon]=\"icon\"></co-icon>\n        </co-tile-render>\n    `,\n    encapsulation: ViewEncapsulation.None,\n})\n// The GUI part of the files-upload component. Not a standalone component.\nexport class FileUploadComponent implements OnDestroy {\n    public readonly icons: typeof Icon = Icon;\n\n    @ViewChild(FormComponent)\n    public form: FormComponent;\n\n    // Input file to upload.\n    @Input()\n    public set file(document: CoDocument) {\n        this._file = document;\n        this._updatePreviewImage();\n        // we should produce a preview image from given document, but its contents might not yet have been loaded:\n        this._listenForDocumentBodyChanges();\n    }\n\n    public get file(): CoDocument {\n        return this._file;\n    }\n\n    // Show icon as placeholder\n    @Input()\n    public icon: Icon;\n\n    // Element clickable\n    @Input()\n    public link: boolean = false;\n\n    @Input()\n    public readonly: boolean = false;\n\n    // Is tile an 'adding' tile\n    @Input()\n    @InputBoolean()\n    public isAddingTile: boolean = false;\n\n    // Set this parameter to false if clicking ok on the document edit popup does not save the document\n    // so that refreshing of content on file open works correctly\n    @Input()\n    @InputBoolean()\n    public fileSavesOnPopupOkClick: boolean = true;\n\n    @Input()\n    @InputBoolean()\n    public isEditable: boolean = false;\n\n    @Input()\n    set label(value: string) {\n        this._label = value;\n    }\n\n    get label(): string {\n        if (this._file && this._file.description) {\n            return this._file.description;\n        } else {\n            return this._label;\n        }\n    }\n\n    // Show a trashcan icon\n    @Input()\n    public showTrashCan: boolean = false;\n\n    // Show an image as placeholder\n    @Input()\n    public showImage: boolean = false;\n\n    @Input()\n    public customImageClick: boolean = false;\n\n    @Output()\n    public deleteClick: EventEmitter<any> = new EventEmitter<any>();\n\n    @Output()\n    public editClick: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\n\n    @Output()\n    public imageClick: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\n\n    @HostBinding('class.co-file-upload')\n    public showClass(): boolean {\n      return true;\n    }\n\n    @HostBinding(\"class.link\")\n    public get isLink(): boolean {\n        return this.link;\n    }\n\n    public previewImage: string = \"\";\n\n    private _file: CoDocument;\n    private _docBodyChangeSub: Subscription;\n    private _label: string = \"\";\n\n    constructor(\n        private _promptService: PromptService,\n        private _fileTypeImgPipe: FileTypeImagePipe,\n        public iconService: IconCacheService,\n        //private _generalDal: GeneralDalRepository\n        ) {\n    }\n\n    ngOnDestroy(): void {\n        if (this._docBodyChangeSub) {\n            this._docBodyChangeSub.unsubscribe();\n        }\n    }\n\n    public onDeleteClick(): void {\n        this.deleteClick.emit();\n    }\n\n    public async  onImageClick(): Promise<void> {\n        if (this.isAddingTile) {\n            return;\n        }\n        if (this.customImageClick) {\n            this.imageClick.next(this._file);\n            return;\n        }\n        //todo fix methods\n        //first download document body if it is stored in a private cdn directory\n        if (!this._file.documentBody) {\n            //await this._generalDal.getDocumentContent(this._file).then(documentBody => this._file.documentBody = documentBody);\n        }\n        if (this._file.isImageDocument()) { //preview image\n            this._promptService.showImage(this.file.documentBodyAsDataUri, \"Preview\");\n        } else { //download document\n            try {\n                //FileUtils.DownloadFromDataUri(this._file.bodyAsDataUri, this._file.fileName);\n            } catch (e) {\n\n            }\n        }\n    }\n\n    public async onPencilClick(): Promise<void> {\n        // refresh file content if files are saved individually\n        if (this._file.hasId() && this.fileSavesOnPopupOkClick) {\n            let idForLink: number;\n            if (this._file.idForLink) {\n                idForLink = this._file.idForLink;\n            }\n            // Get most recent version of this file if it has an id and therefore has been saved in the db\n            //TODO fix fetch\n           // this._file = await this._generalDal.getDocumentFromTable(this._file.documentId);\n            //this._file.idForLink = idForLink; // Restore the idForLink\n        }\n\n        this.editClick.emit(this._file);\n    }\n\n    // updates this.previewImage when doc body changes\n    private _listenForDocumentBodyChanges(): void {\n        if (this._file) {\n            if (this._docBodyChangeSub) {\n                this._docBodyChangeSub.unsubscribe();\n            }\n\n            // @ts-ignore\n          this._docBodyChangeSub = this._file.documentBodyChange.subscribe(() => {\n                this._updatePreviewImage();\n            });\n        }\n    }\n\n    private _updatePreviewImage(): void {\n        if (this._file) {\n            if (this._file.isImageDocument()) {\n                this.previewImage = this._file.documentBodyAsDataUri;\n                if (this.previewImage === \"\") {\n                    //TODO fix fetch\n                    //this._generalDal.getDocumentContent(this._file).then(documentBody => this._file.documentBody = documentBody);\n                    //this.previewImage = this._file.documentBody;\n                }\n            } else {\n                this.previewImage = this._fileTypeImgPipe.transform(this.file.fileTypeInternal);\n            }\n        }\n    }\n\n}\n"]}

package/esm2015/lib/components/file-upload/file-upload.module.js

@@ -0,0 +1,25 @@
+import { NgModule } from "@angular/core";
+import { FileUploadComponent } from "./file-upload.component";
+import { ButtonModule, IconModule } from "@colijnit/corecomponents_v12";
+import { TileRenderModule } from "../tile-renderer/tile-render.module";
+import { CommonModule } from "@angular/common";
+export class FileUploadModule {
+}
+FileUploadModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    IconModule,
+                    TileRenderModule,
+                    CommonModule,
+                    ButtonModule
+                ],
+                declarations: [
+                    FileUploadComponent
+                ],
+                exports: [
+                    FileUploadComponent
+                ],
+                providers: []
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2hhcmVkY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvZmlsZS11cGxvYWQvZmlsZS11cGxvYWQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0seUJBQXlCLENBQUM7QUFDNUQsT0FBTyxFQUFDLFlBQVksRUFBRSxVQUFVLEVBQUMsTUFBTSw4QkFBOEIsQ0FBQztBQUN0RSxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxxQ0FBcUMsQ0FBQztBQUNyRSxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFtQjdDLE1BQU0sT0FBTyxnQkFBZ0I7OztZQWhCNUIsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxVQUFVO29CQUNWLGdCQUFnQjtvQkFDaEIsWUFBWTtvQkFDWixZQUFZO2lCQUNiO2dCQUNELFlBQVksRUFBRTtvQkFDWixtQkFBbUI7aUJBQ3BCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxtQkFBbUI7aUJBQ3BCO2dCQUNELFNBQVMsRUFBRSxFQUNWO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHtGaWxlVXBsb2FkQ29tcG9uZW50fSBmcm9tIFwiLi9maWxlLXVwbG9hZC5jb21wb25lbnRcIjtcbmltcG9ydCB7QnV0dG9uTW9kdWxlLCBJY29uTW9kdWxlfSBmcm9tIFwiQGNvbGlqbml0L2NvcmVjb21wb25lbnRzX3YxMlwiO1xuaW1wb3J0IHtUaWxlUmVuZGVyTW9kdWxlfSBmcm9tIFwiLi4vdGlsZS1yZW5kZXJlci90aWxlLXJlbmRlci5tb2R1bGVcIjtcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uXCI7XG5cblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIEljb25Nb2R1bGUsXG4gICAgVGlsZVJlbmRlck1vZHVsZSxcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgQnV0dG9uTW9kdWxlXG4gIF0sXG4gIGRlY2xhcmF0aW9uczogW1xuICAgIEZpbGVVcGxvYWRDb21wb25lbnRcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIEZpbGVVcGxvYWRDb21wb25lbnRcbiAgXSxcbiAgcHJvdmlkZXJzOiBbXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgRmlsZVVwbG9hZE1vZHVsZSB7XG5cbn1cbiJdfQ==