imm-element-ui 2.6.8 → 2.6.9

package/esm2022/lib/grid/cell-render/upload-renderer.mjs

@@ -0,0 +1,228 @@
+import { Component, inject } from '@angular/core';
+import { HttpClient, HttpEventType, HttpRequest } from '@angular/common/http';
+import { ButtonModule } from 'primeng/button';
+import { FileUpload } from 'primeng/fileupload';
+import { filter, forkJoin } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/button";
+export class UploadRenderer {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.uploadParams = {};
+        this.fileList = [];
+        this.loading = false;
+    }
+    agInit(params) {
+        this.refresh(params);
+    }
+    refresh(params) {
+        this.params = params;
+        this.uploadParams = this.resolveUploadParams(params);
+        this.fileList = this.toFileList(params.value);
+        return true;
+    }
+    uploadHandler(event, fu) {
+        const files = Array.from(event.files || []);
+        if (!files.length || this.isDisabled()) {
+            return;
+        }
+        const uploadRequests = files.map((file) => this.uploadFile(file));
+        this.loading = true;
+        forkJoin(uploadRequests).subscribe({
+            next: (responses) => {
+                const uploadedFiles = responses.map((response) => response.body?.fileName).filter(Boolean);
+                this.fileList = [...this.fileList, ...uploadedFiles];
+                this.commitValue();
+                fu.clear();
+            },
+            error: () => {
+                this.loading = false;
+                fu.clear();
+            },
+        });
+    }
+    deleteHandler(file, index) {
+        if (this.isDisabled() || this.loading) {
+            return;
+        }
+        this.loading = true;
+        this.delFile(file).subscribe({
+            next: () => {
+                this.fileList = this.fileList.filter((_, fileIndex) => fileIndex !== index);
+                this.commitValue();
+            },
+            error: () => {
+                this.loading = false;
+            },
+        });
+    }
+    isDisabled() {
+        if (typeof this.uploadParams.disabled === 'function') {
+            return this.uploadParams.disabled(this.params);
+        }
+        if (this.uploadParams.disabled !== undefined) {
+            return this.uploadParams.disabled;
+        }
+        return Boolean(this.params.context?.gridDisabled?.());
+    }
+    getDownloadUrl(file) {
+        const baseUrl = this.uploadParams.downloadBaseUrl ?? 'https://file-filer.myfoodiepet.com/';
+        return `${baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`}${file}`;
+    }
+    uploadFile(file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http
+            .request(new HttpRequest('POST', this.uploadParams.url ?? 'filerUpload', formData, {
+            reportProgress: true,
+            withCredentials: this.uploadParams.withCredentials ?? false,
+        }))
+            .pipe(filter((response) => response.type == HttpEventType.Response));
+    }
+    delFile(file) {
+        return this.http.post(this.uploadParams.deleteUrl ?? 'filerDelete', { fileName: file });
+    }
+    commitValue() {
+        this.loading = false;
+        const field = this.params.colDef?.field;
+        if (!field) {
+            return;
+        }
+        const oldValue = this.params.data?.[field];
+        const newValue = this.toValue(this.fileList);
+        const grid = this.params.context?.grid?.();
+        this.params.data[field] = newValue;
+        grid?.cellValueChanged({
+            colDef: this.params.colDef,
+            oldValue,
+            newValue,
+            rowIndex: this.params.node.rowIndex,
+            data: this.params.data,
+        });
+        setTimeout(() => this.params.api.resetRowHeights());
+    }
+    resolveUploadParams(params) {
+        if (typeof params.colDef?.cellRendererParams === 'function') {
+            return params.colDef.cellRendererParams(params) || {};
+        }
+        return params.colDef?.cellRendererParams || {};
+    }
+    toFileList(value) {
+        if (Array.isArray(value)) {
+            return value.filter(Boolean);
+        }
+        return typeof value === 'string' && value.length > 0 ? value.split(';').filter(Boolean) : [];
+    }
+    toValue(files) {
+        return files.join(';');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadRenderer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: UploadRenderer, isStandalone: true, selector: "ng-component", ngImport: i0, template: `
+		<div class="upload-renderer">
+			<p-fileUpload
+				#fu
+				auto
+				mode="basic"
+				[name]="uploadParams.name || 'file'"
+				[multiple]="uploadParams.multiple ?? true"
+				[accept]="uploadParams.accept"
+				[maxFileSize]="uploadParams.maxFileSize"
+				[fileLimit]="uploadParams.fileLimit"
+				[withCredentials]="uploadParams.withCredentials ?? false"
+				[customUpload]="true"
+				[disabled]="isDisabled() || loading"
+				mode="advanced"
+				[styleClass]="'upload-renderer-choose'"
+				(uploadHandler)="uploadHandler($event, fu)">
+				<ng-template
+					#header
+					let-chooseCallback="chooseCallback">
+					<p-button
+						icon="pi pi-cloud-upload"
+						[text]="true"
+						size="small"
+						[disabled]="isDisabled() || loading"
+						(onClick)="chooseCallback()" />
+				</ng-template>
+			</p-fileUpload>
+
+			<div class="upload-renderer-files">
+				@for (file of fileList; track index; let index = $index) {
+					<div class="upload-renderer-file">
+						<a
+							class="upload-renderer-file-name"
+							[href]="getDownloadUrl(file)"
+							[download]="file"
+							target="_blank"
+							(click)="$event.stopPropagation()"
+							>{{ file }}</a
+						>
+						<p-button
+							icon="pi pi-times"
+							severity="danger"
+							size="small"
+							[text]="true"
+							[disabled]="isDisabled() || loading"
+							(onClick)="deleteHandler(file, index)" />
+					</div>
+				}
+			</div>
+		</div>
+	`, isInline: true, styles: [".upload-renderer{display:flex;flex-direction:column;align-items:flex-start;justify-content:center;gap:2px;width:100%;min-width:0;padding:2px 0}:host ::ng-deep .upload-renderer-choose{display:inline-flex;align-items:center;width:28px;height:28px;border:0;background:transparent}:host ::ng-deep .upload-renderer-choose .p-fileupload-header{display:flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:0;background:transparent}:host ::ng-deep .upload-renderer-choose .p-fileupload-content{display:none;padding:0;border:0}:host ::ng-deep .upload-renderer-choose .p-button,:host ::ng-deep .upload-renderer-choose p-button{width:28px;height:28px;padding:0}:host ::ng-deep .upload-renderer-choose .p-button-label{display:none}.upload-renderer-files{display:flex;flex-direction:column;align-items:stretch;gap:2px;width:100%;min-width:0;overflow:hidden}.upload-renderer-file{display:flex;align-items:center;justify-content:space-between;gap:4px;min-width:0;width:100%}.upload-renderer-file-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--p-primary-color);text-decoration:none}.upload-renderer-file-name:hover{text-decoration:underline}\n"], dependencies: [{ kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "component", type: FileUpload, selector: "p-fileupload, p-fileUpload", inputs: ["name", "url", "method", "multiple", "accept", "disabled", "auto", "withCredentials", "maxFileSize", "invalidFileSizeMessageSummary", "invalidFileSizeMessageDetail", "invalidFileTypeMessageSummary", "invalidFileTypeMessageDetail", "invalidFileLimitMessageDetail", "invalidFileLimitMessageSummary", "style", "styleClass", "previewWidth", "chooseLabel", "uploadLabel", "cancelLabel", "chooseIcon", "uploadIcon", "cancelIcon", "showUploadButton", "showCancelButton", "mode", "headers", "customUpload", "fileLimit", "uploadStyleClass", "cancelStyleClass", "removeStyleClass", "chooseStyleClass", "chooseButtonProps", "uploadButtonProps", "cancelButtonProps", "files"], outputs: ["onBeforeUpload", "onSend", "onUpload", "onError", "onClear", "onRemove", "onSelect", "onProgress", "uploadHandler", "onImageError", "onRemoveUploadedFile"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadRenderer, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [ButtonModule, FileUpload], template: `
+		<div class="upload-renderer">
+			<p-fileUpload
+				#fu
+				auto
+				mode="basic"
+				[name]="uploadParams.name || 'file'"
+				[multiple]="uploadParams.multiple ?? true"
+				[accept]="uploadParams.accept"
+				[maxFileSize]="uploadParams.maxFileSize"
+				[fileLimit]="uploadParams.fileLimit"
+				[withCredentials]="uploadParams.withCredentials ?? false"
+				[customUpload]="true"
+				[disabled]="isDisabled() || loading"
+				mode="advanced"
+				[styleClass]="'upload-renderer-choose'"
+				(uploadHandler)="uploadHandler($event, fu)">
+				<ng-template
+					#header
+					let-chooseCallback="chooseCallback">
+					<p-button
+						icon="pi pi-cloud-upload"
+						[text]="true"
+						size="small"
+						[disabled]="isDisabled() || loading"
+						(onClick)="chooseCallback()" />
+				</ng-template>
+			</p-fileUpload>
+
+			<div class="upload-renderer-files">
+				@for (file of fileList; track index; let index = $index) {
+					<div class="upload-renderer-file">
+						<a
+							class="upload-renderer-file-name"
+							[href]="getDownloadUrl(file)"
+							[download]="file"
+							target="_blank"
+							(click)="$event.stopPropagation()"
+							>{{ file }}</a
+						>
+						<p-button
+							icon="pi pi-times"
+							severity="danger"
+							size="small"
+							[text]="true"
+							[disabled]="isDisabled() || loading"
+							(onClick)="deleteHandler(file, index)" />
+					</div>
+				}
+			</div>
+		</div>
+	`, styles: [".upload-renderer{display:flex;flex-direction:column;align-items:flex-start;justify-content:center;gap:2px;width:100%;min-width:0;padding:2px 0}:host ::ng-deep .upload-renderer-choose{display:inline-flex;align-items:center;width:28px;height:28px;border:0;background:transparent}:host ::ng-deep .upload-renderer-choose .p-fileupload-header{display:flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:0;background:transparent}:host ::ng-deep .upload-renderer-choose .p-fileupload-content{display:none;padding:0;border:0}:host ::ng-deep .upload-renderer-choose .p-button,:host ::ng-deep .upload-renderer-choose p-button{width:28px;height:28px;padding:0}:host ::ng-deep .upload-renderer-choose .p-button-label{display:none}.upload-renderer-files{display:flex;flex-direction:column;align-items:stretch;gap:2px;width:100%;min-width:0;overflow:hidden}.upload-renderer-file{display:flex;align-items:center;justify-content:space-between;gap:4px;min-width:0;width:100%}.upload-renderer-file-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--p-primary-color);text-decoration:none}.upload-renderer-file-name:hover{text-decoration:underline}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-renderer.js","sourceRoot":"","sources":["../../../../../../projects/imm-element-ui/src/lib/grid/cell-render/upload-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, inject } from '@angular/core';\nimport { HttpClient, HttpEvent, HttpEventType, HttpRequest } from '@angular/common/http';\nimport type { ICellRendererAngularComp } from 'ag-grid-angular';\nimport type { ICellRendererParams } from 'ag-grid-community';\nimport { GridComponent } from '../grid/grid.component';\nimport { ButtonModule } from 'primeng/button';\nimport { FileUpload } from 'primeng/fileupload';\nimport { filter, forkJoin, Observable } from 'rxjs';\n\nexport interface UploadRendererParams {\n\turl?: string;\n\tdeleteUrl?: string;\n\tdownloadBaseUrl?: string;\n\tmultiple?: boolean;\n\taccept?: string;\n\tmaxFileSize?: number;\n\tfileLimit?: number;\n\tname?: string;\n\twithCredentials?: boolean;\n\tdisabled?: boolean | ((params: ICellRendererParams) => boolean);\n}\n\n@Component({\n\tstandalone: true,\n\timports: [ButtonModule, FileUpload],\n\ttemplate: `\n\t\t<div class=\"upload-renderer\">\n\t\t\t<p-fileUpload\n\t\t\t\t#fu\n\t\t\t\tauto\n\t\t\t\tmode=\"basic\"\n\t\t\t\t[name]=\"uploadParams.name || 'file'\"\n\t\t\t\t[multiple]=\"uploadParams.multiple ?? true\"\n\t\t\t\t[accept]=\"uploadParams.accept\"\n\t\t\t\t[maxFileSize]=\"uploadParams.maxFileSize\"\n\t\t\t\t[fileLimit]=\"uploadParams.fileLimit\"\n\t\t\t\t[withCredentials]=\"uploadParams.withCredentials ?? false\"\n\t\t\t\t[customUpload]=\"true\"\n\t\t\t\t[disabled]=\"isDisabled() || loading\"\n\t\t\t\tmode=\"advanced\"\n\t\t\t\t[styleClass]=\"'upload-renderer-choose'\"\n\t\t\t\t(uploadHandler)=\"uploadHandler($event, fu)\">\n\t\t\t\t<ng-template\n\t\t\t\t\t#header\n\t\t\t\t\tlet-chooseCallback=\"chooseCallback\">\n\t\t\t\t\t<p-button\n\t\t\t\t\t\ticon=\"pi pi-cloud-upload\"\n\t\t\t\t\t\t[text]=\"true\"\n\t\t\t\t\t\tsize=\"small\"\n\t\t\t\t\t\t[disabled]=\"isDisabled() || loading\"\n\t\t\t\t\t\t(onClick)=\"chooseCallback()\" />\n\t\t\t\t</ng-template>\n\t\t\t</p-fileUpload>\n\n\t\t\t<div class=\"upload-renderer-files\">\n\t\t\t\t@for (file of fileList; track index; let index = $index) {\n\t\t\t\t\t<div class=\"upload-renderer-file\">\n\t\t\t\t\t\t<a\n\t\t\t\t\t\t\tclass=\"upload-renderer-file-name\"\n\t\t\t\t\t\t\t[href]=\"getDownloadUrl(file)\"\n\t\t\t\t\t\t\t[download]=\"file\"\n\t\t\t\t\t\t\ttarget=\"_blank\"\n\t\t\t\t\t\t\t(click)=\"$event.stopPropagation()\"\n\t\t\t\t\t\t\t>{{ file }}</a\n\t\t\t\t\t\t>\n\t\t\t\t\t\t<p-button\n\t\t\t\t\t\t\ticon=\"pi pi-times\"\n\t\t\t\t\t\t\tseverity=\"danger\"\n\t\t\t\t\t\t\tsize=\"small\"\n\t\t\t\t\t\t\t[text]=\"true\"\n\t\t\t\t\t\t\t[disabled]=\"isDisabled() || loading\"\n\t\t\t\t\t\t\t(onClick)=\"deleteHandler(file, index)\" />\n\t\t\t\t\t</div>\n\t\t\t\t}\n\t\t\t</div>\n\t\t</div>\n\t`,\n\tstyles: `\n\t\t.upload-renderer {\n\t\t\tdisplay: flex;\n\t\t\tflex-direction: column;\n\t\t\talign-items: flex-start;\n\t\t\tjustify-content: center;\n\t\t\tgap: 2px;\n\t\t\twidth: 100%;\n\t\t\tmin-width: 0;\n\t\t\tpadding: 2px 0;\n\t\t}\n\t\t:host ::ng-deep .upload-renderer-choose {\n\t\t\tdisplay: inline-flex;\n\t\t\talign-items: center;\n\t\t\twidth: 28px;\n\t\t\theight: 28px;\n\t\t\tborder: 0;\n\t\t\tbackground: transparent;\n\t\t}\n\t\t:host ::ng-deep .upload-renderer-choose .p-fileupload-header {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tjustify-content: center;\n\t\t\twidth: 28px;\n\t\t\theight: 28px;\n\t\t\tpadding: 0;\n\t\t\tborder: 0;\n\t\t\tbackground: transparent;\n\t\t}\n\t\t:host ::ng-deep .upload-renderer-choose .p-fileupload-content {\n\t\t\tdisplay: none;\n\t\t\tpadding: 0;\n\t\t\tborder: 0;\n\t\t}\n\t\t:host ::ng-deep .upload-renderer-choose .p-button,\n\t\t:host ::ng-deep .upload-renderer-choose p-button {\n\t\t\twidth: 28px;\n\t\t\theight: 28px;\n\t\t\tpadding: 0;\n\t\t}\n\t\t:host ::ng-deep .upload-renderer-choose .p-button-label {\n\t\t\tdisplay: none;\n\t\t}\n\t\t.upload-renderer-files {\n\t\t\tdisplay: flex;\n\t\t\tflex-direction: column;\n\t\t\talign-items: stretch;\n\t\t\tgap: 2px;\n\t\t\twidth: 100%;\n\t\t\tmin-width: 0;\n\t\t\toverflow: hidden;\n\t\t}\n\t\t.upload-renderer-file {\n\t\t\tdisplay: flex;\n\t\t\talign-items: center;\n\t\t\tjustify-content: space-between;\n\t\t\tgap: 4px;\n\t\t\tmin-width: 0;\n\t\t\twidth: 100%;\n\t\t}\n\t\t.upload-renderer-file-name {\n\t\t\tmin-width: 0;\n\t\t\toverflow: hidden;\n\t\t\ttext-overflow: ellipsis;\n\t\t\twhite-space: nowrap;\n\t\t\tcolor: var(--p-primary-color);\n\t\t\ttext-decoration: none;\n\t\t}\n\t\t.upload-renderer-file-name:hover {\n\t\t\ttext-decoration: underline;\n\t\t}\n\t`,\n})\nexport class UploadRenderer implements ICellRendererAngularComp {\n\tprivate http = inject(HttpClient);\n\tparams!: ICellRendererParams;\n\tuploadParams: UploadRendererParams = {};\n\tfileList: string[] = [];\n\tloading = false;\n\n\tagInit(params: ICellRendererParams): void {\n\t\tthis.refresh(params);\n\t}\n\n\trefresh(params: ICellRendererParams): boolean {\n\t\tthis.params = params;\n\t\tthis.uploadParams = this.resolveUploadParams(params);\n\t\tthis.fileList = this.toFileList(params.value);\n\t\treturn true;\n\t}\n\n\tuploadHandler(event: any, fu: any) {\n\t\tconst files = Array.from(event.files || []) as File[];\n\t\tif (!files.length || this.isDisabled()) {\n\t\t\treturn;\n\t\t}\n\t\tconst uploadRequests: Observable<any>[] = files.map((file) => this.uploadFile(file));\n\t\tthis.loading = true;\n\t\tforkJoin(uploadRequests).subscribe({\n\t\t\tnext: (responses) => {\n\t\t\t\tconst uploadedFiles = responses.map((response: any) => response.body?.fileName).filter(Boolean);\n\t\t\t\tthis.fileList = [...this.fileList, ...uploadedFiles];\n\t\t\t\tthis.commitValue();\n\t\t\t\tfu.clear();\n\t\t\t},\n\t\t\terror: () => {\n\t\t\t\tthis.loading = false;\n\t\t\t\tfu.clear();\n\t\t\t},\n\t\t});\n\t}\n\n\tdeleteHandler(file: string, index: number) {\n\t\tif (this.isDisabled() || this.loading) {\n\t\t\treturn;\n\t\t}\n\t\tthis.loading = true;\n\t\tthis.delFile(file).subscribe({\n\t\t\tnext: () => {\n\t\t\t\tthis.fileList = this.fileList.filter((_, fileIndex) => fileIndex !== index);\n\t\t\t\tthis.commitValue();\n\t\t\t},\n\t\t\terror: () => {\n\t\t\t\tthis.loading = false;\n\t\t\t},\n\t\t});\n\t}\n\n\tisDisabled(): boolean {\n\t\tif (typeof this.uploadParams.disabled === 'function') {\n\t\t\treturn this.uploadParams.disabled(this.params);\n\t\t}\n\t\tif (this.uploadParams.disabled !== undefined) {\n\t\t\treturn this.uploadParams.disabled;\n\t\t}\n\t\treturn Boolean(this.params.context?.gridDisabled?.());\n\t}\n\n\tgetDownloadUrl(file: string): string {\n\t\tconst baseUrl = this.uploadParams.downloadBaseUrl ?? 'https://file-filer.myfoodiepet.com/';\n\t\treturn `${baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`}${file}`;\n\t}\n\n\tprivate uploadFile(file: File): Observable<any> {\n\t\tconst formData = new FormData();\n\t\tformData.append('file', file);\n\t\treturn this.http\n\t\t\t.request(\n\t\t\t\tnew HttpRequest('POST', this.uploadParams.url ?? 'filerUpload', formData, {\n\t\t\t\t\treportProgress: true,\n\t\t\t\t\twithCredentials: this.uploadParams.withCredentials ?? false,\n\t\t\t\t}),\n\t\t\t)\n\t\t\t.pipe(filter((response: HttpEvent<any>) => response.type == HttpEventType.Response));\n\t}\n\n\tprivate delFile(file: string): Observable<any> {\n\t\treturn this.http.post(this.uploadParams.deleteUrl ?? 'filerDelete', { fileName: file });\n\t}\n\n\tprivate commitValue() {\n\t\tthis.loading = false;\n\t\tconst field = this.params.colDef?.field;\n\t\tif (!field) {\n\t\t\treturn;\n\t\t}\n\t\tconst oldValue = this.params.data?.[field];\n\t\tconst newValue = this.toValue(this.fileList);\n\t\tconst grid: GridComponent | undefined = this.params.context?.grid?.();\n\t\tthis.params.data[field] = newValue;\n\t\tgrid?.cellValueChanged({\n\t\t\tcolDef: this.params.colDef,\n\t\t\toldValue,\n\t\t\tnewValue,\n\t\t\trowIndex: this.params.node.rowIndex,\n\t\t\tdata: this.params.data,\n\t\t} as any);\n\t\tsetTimeout(() => this.params.api.resetRowHeights());\n\t}\n\n\tprivate resolveUploadParams(params: ICellRendererParams): UploadRendererParams {\n\t\tif (typeof params.colDef?.cellRendererParams === 'function') {\n\t\t\treturn params.colDef.cellRendererParams(params) || {};\n\t\t}\n\t\treturn params.colDef?.cellRendererParams || {};\n\t}\n\n\tprivate toFileList(value: any): string[] {\n\t\tif (Array.isArray(value)) {\n\t\t\treturn value.filter(Boolean);\n\t\t}\n\t\treturn typeof value === 'string' && value.length > 0 ? value.split(';').filter(Boolean) : [];\n\t}\n\n\tprivate toValue(files: string[]): string {\n\t\treturn files.join(';');\n\t}\n}\n"]}