@alfresco/adf-content-services 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/common/services/upload.service.mjs

@@ -0,0 +1,391 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { inject, Injectable } from '@angular/core';
+import { Minimatch } from 'minimatch';
+import { Subject } from 'rxjs';
+import { FileUploadCompleteEvent, FileUploadDeleteEvent, FileUploadErrorEvent, FileUploadEvent } from '../events/file.event';
+import { FileUploadStatus } from '../models/file.model';
+import { AppConfigService } from '@alfresco/adf-core';
+import { filter } from 'rxjs/operators';
+import { DiscoveryApiService } from '../../common/services/discovery-api.service';
+import { NodesApi, UploadApi, VersionsApi } from '@alfresco/js-api';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import * as i0 from "@angular/core";
+const MIN_CANCELLABLE_FILE_SIZE = 1000000;
+const MAX_CANCELLABLE_FILE_PERCENTAGE = 50;
+export class UploadService {
+    get uploadApi() {
+        this._uploadApi = this._uploadApi ?? new UploadApi(this.apiService.getInstance());
+        return this._uploadApi;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    get versionsApi() {
+        this._versionsApi = this._versionsApi ?? new VersionsApi(this.apiService.getInstance());
+        return this._versionsApi;
+    }
+    constructor() {
+        this.queue = [];
+        this.queueChanged = new Subject();
+        this.fileUpload = new Subject();
+        this.fileUploadStarting = new Subject();
+        this.fileUploadCancelled = new Subject();
+        this.fileUploadProgress = new Subject();
+        this.fileUploadAborted = new Subject();
+        this.fileUploadError = new Subject();
+        this.fileUploadComplete = new Subject();
+        this.fileUploadDeleted = new Subject();
+        this.fileDeleted = new Subject();
+        this.cache = {};
+        this.totalComplete = 0;
+        this.totalAborted = 0;
+        this.totalError = 0;
+        this.excludedFileList = [];
+        this.excludedFoldersList = [];
+        this.matchingOptions = null;
+        this.folderMatchingOptions = null;
+        this.apiService = inject(AlfrescoApiService);
+        this.appConfigService = inject(AppConfigService);
+        this.discoveryApiService = inject(DiscoveryApiService);
+        this.discoveryApiService.ecmProductInfo$.pipe(filter((info) => !!info)).subscribe(({ status }) => {
+            this.isThumbnailGenerationEnabled = status.isThumbnailGenerationEnabled;
+        });
+    }
+    clearCache() {
+        this.cache = {};
+    }
+    /**
+     * Returns the number of concurrent threads for uploading.
+     *
+     * @returns Number of concurrent threads (default 1)
+     */
+    getThreadsCount() {
+        return this.appConfigService.get('upload.threads', 1);
+    }
+    /**
+     * Checks whether the service still has files uploading or awaiting upload.
+     *
+     * @returns True if files in the queue are still uploading, false otherwise
+     */
+    isUploading() {
+        const finishedFileStates = [
+            FileUploadStatus.Complete,
+            FileUploadStatus.Cancelled,
+            FileUploadStatus.Aborted,
+            FileUploadStatus.Error,
+            FileUploadStatus.Deleted
+        ];
+        return this.queue.reduce((stillUploading, currentFile) => stillUploading || finishedFileStates.indexOf(currentFile.status) === -1, false);
+    }
+    /**
+     * Gets the file Queue
+     *
+     * @returns Array of files that form the queue
+     */
+    getQueue() {
+        return this.queue;
+    }
+    /**
+     * Adds files to the uploading queue to be uploaded
+     *
+     * @param files One or more separate parameters or an array of files to queue
+     * @returns Array of files that were not blocked from upload by the ignore list
+     */
+    addToQueue(...files) {
+        const allowedFiles = files.filter((currentFile) => this.filterElement(currentFile));
+        this.queue = this.queue.concat(allowedFiles);
+        this.queueChanged.next(this.queue);
+        return allowedFiles;
+    }
+    /**
+     * Finds all the files in the queue that are not yet uploaded and uploads them into the directory folder.
+     *
+     * @param successEmitter Emitter to invoke on file success status change
+     * @param errorEmitter Emitter to invoke on file error status change
+     */
+    uploadFilesInTheQueue(successEmitter, errorEmitter) {
+        const files = this.getFilesToUpload();
+        if (files && files.length > 0) {
+            for (const file of files) {
+                this.onUploadStarting(file);
+                const promise = this.beginUpload(file, successEmitter, errorEmitter);
+                this.cache[file.name] = promise;
+                const next = () => {
+                    setTimeout(() => this.uploadFilesInTheQueue(successEmitter, errorEmitter), 100);
+                };
+                promise.next = next;
+                promise.then(() => next(), () => next());
+            }
+        }
+    }
+    /**
+     * Cancels uploading of files.
+     * If the file is smaller than 1 MB the file will be uploaded and then the node deleted
+     * to prevent having files that were aborted but still uploaded.
+     *
+     * @param files One or more separate parameters or an array of files specifying uploads to cancel
+     */
+    cancelUpload(...files) {
+        files.forEach((file) => {
+            const promise = this.cache[file.name];
+            if (promise) {
+                if (this.isSaveToAbortFile(file)) {
+                    promise.abort();
+                }
+                else {
+                    this.abortedFile = file.name;
+                }
+                delete this.cache[file.name];
+                promise.next();
+            }
+            else {
+                const performAction = this.getAction(file);
+                if (performAction) {
+                    performAction();
+                }
+            }
+        });
+    }
+    /** Clears the upload queue */
+    clearQueue() {
+        this.queue = [];
+        this.totalComplete = 0;
+        this.totalAborted = 0;
+        this.totalError = 0;
+    }
+    /**
+     * Gets an upload promise for a file.
+     *
+     * @param file The target file
+     * @returns Promise that is resolved if the upload is successful or error otherwise
+     */
+    getUploadPromise(file) {
+        const opts = {
+            include: ['allowableOperations']
+        };
+        if (this.isThumbnailGenerationEnabled) {
+            opts.renditions = 'doclib';
+        }
+        if (file.options?.versioningEnabled !== undefined) {
+            opts.versioningEnabled = file.options.versioningEnabled;
+        }
+        if (file.options.newVersion === true) {
+            opts.overwrite = true;
+            opts.majorVersion = file.options.majorVersion;
+            opts.comment = file.options.comment;
+            opts.name = file.name;
+        }
+        else {
+            opts.autoRename = true;
+        }
+        if (file.options.nodeType) {
+            opts.nodeType = file.options.nodeType;
+        }
+        if (file.id) {
+            return this.nodesApi.updateNodeContent(file.id, file.file, opts);
+        }
+        else {
+            const nodeBody = { ...file.options, name: file.name, nodeType: file.options.nodeType };
+            delete nodeBody['versioningEnabled'];
+            return this.uploadApi.uploadFile(file.file, file.options.path, file.options.parentId, nodeBody, opts);
+        }
+    }
+    getFilesToUpload() {
+        const cached = Object.keys(this.cache);
+        const threadsCount = this.getThreadsCount();
+        if (cached.length >= threadsCount) {
+            return [];
+        }
+        const files = this.queue
+            .filter((toUpload) => !cached.includes(toUpload.name) && toUpload.status === FileUploadStatus.Pending)
+            .slice(0, threadsCount);
+        return files;
+    }
+    beginUpload(file, successEmitter, errorEmitter) {
+        const promise = this.getUploadPromise(file);
+        promise
+            .on('progress', (progress) => {
+            this.onUploadProgress(file, progress);
+        })
+            .on('abort', () => {
+            this.onUploadAborted(file);
+            if (successEmitter) {
+                successEmitter.emit({ value: 'File aborted' });
+            }
+        })
+            .on('error', (err) => {
+            this.onUploadError(file, err);
+            if (errorEmitter) {
+                errorEmitter.emit({ value: 'Error file uploaded' });
+            }
+        })
+            .on('success', (data) => {
+            if (this.abortedFile === file.name) {
+                this.onUploadAborted(file);
+                if (file.id === undefined) {
+                    this.deleteAbortedNode(data.entry.id);
+                }
+                else {
+                    this.deleteAbortedNodeVersion(data.entry.id, data.entry.properties['cm:versionLabel']);
+                }
+                if (successEmitter) {
+                    successEmitter.emit({ value: 'File deleted' });
+                }
+            }
+            else {
+                this.onUploadComplete(file, data);
+                if (successEmitter) {
+                    successEmitter.emit({ value: data });
+                }
+            }
+        })
+            .catch(() => { });
+        return promise;
+    }
+    onUploadStarting(file) {
+        if (file) {
+            file.status = FileUploadStatus.Starting;
+            const event = new FileUploadEvent(file, FileUploadStatus.Starting);
+            this.fileUpload.next(event);
+            this.fileUploadStarting.next(event);
+        }
+    }
+    onUploadProgress(file, progress) {
+        if (file) {
+            file.progress = progress;
+            file.status = FileUploadStatus.Progress;
+            const event = new FileUploadEvent(file, FileUploadStatus.Progress);
+            this.fileUpload.next(event);
+            this.fileUploadProgress.next(event);
+        }
+    }
+    onUploadError(file, error) {
+        if (file) {
+            file.errorCode = error?.status;
+            file.status = FileUploadStatus.Error;
+            this.totalError++;
+            const promise = this.cache[file.name];
+            if (promise) {
+                delete this.cache[file.name];
+            }
+            const event = new FileUploadErrorEvent(file, error, this.totalError);
+            this.fileUpload.next(event);
+            this.fileUploadError.next(event);
+        }
+    }
+    onUploadComplete(file, data) {
+        if (file) {
+            file.status = FileUploadStatus.Complete;
+            file.data = data;
+            this.totalComplete++;
+            const promise = this.cache[file.name];
+            if (promise) {
+                delete this.cache[file.name];
+            }
+            const event = new FileUploadCompleteEvent(file, this.totalComplete, data, this.totalAborted);
+            this.fileUpload.next(event);
+            this.fileUploadComplete.next(event);
+        }
+    }
+    onUploadAborted(file) {
+        if (file) {
+            file.status = FileUploadStatus.Aborted;
+            this.totalAborted++;
+            const event = new FileUploadEvent(file, FileUploadStatus.Aborted);
+            this.fileUpload.next(event);
+            this.fileUploadAborted.next(event);
+        }
+    }
+    onUploadCancelled(file) {
+        if (file) {
+            file.status = FileUploadStatus.Cancelled;
+            const event = new FileUploadEvent(file, FileUploadStatus.Cancelled);
+            this.fileUpload.next(event);
+            this.fileUploadCancelled.next(event);
+        }
+    }
+    onUploadDeleted(file) {
+        if (file) {
+            file.status = FileUploadStatus.Deleted;
+            this.totalComplete--;
+            const event = new FileUploadDeleteEvent(file, this.totalComplete);
+            this.fileUpload.next(event);
+            this.fileUploadDeleted.next(event);
+        }
+    }
+    getAction(file) {
+        const actions = {
+            [FileUploadStatus.Pending]: () => this.onUploadCancelled(file),
+            [FileUploadStatus.Deleted]: () => this.onUploadDeleted(file),
+            [FileUploadStatus.Error]: () => this.onUploadError(file, null)
+        };
+        return actions[file.status];
+    }
+    deleteAbortedNode(nodeId) {
+        this.nodesApi.deleteNode(nodeId, { permanent: true }).then(() => (this.abortedFile = undefined));
+    }
+    deleteAbortedNodeVersion(nodeId, versionId) {
+        this.versionsApi.deleteVersion(nodeId, versionId).then(() => (this.abortedFile = undefined));
+    }
+    isSaveToAbortFile(file) {
+        return file.size > MIN_CANCELLABLE_FILE_SIZE && file.progress.percent < MAX_CANCELLABLE_FILE_PERCENTAGE;
+    }
+    filterElement(file) {
+        this.excludedFileList = this.appConfigService.get('files.excluded');
+        this.excludedFoldersList = this.appConfigService.get('folders.excluded');
+        let isAllowed = true;
+        if (this.excludedFileList) {
+            this.matchingOptions = this.appConfigService.get('files.match-options');
+            isAllowed = this.isFileNameAllowed(file);
+        }
+        if (isAllowed && this.excludedFoldersList) {
+            this.folderMatchingOptions = this.appConfigService.get('folders.match-options');
+            isAllowed = this.isParentFolderAllowed(file);
+        }
+        return isAllowed;
+    }
+    isParentFolderAllowed(file) {
+        let isAllowed = true;
+        const currentFile = file.file;
+        const fileRelativePath = currentFile.webkitRelativePath ? currentFile.webkitRelativePath : file.options.path;
+        if (currentFile && fileRelativePath) {
+            isAllowed =
+                this.excludedFoldersList.filter((folderToExclude) => fileRelativePath.split('/').some((pathElement) => {
+                    const minimatch = new Minimatch(folderToExclude, this.folderMatchingOptions);
+                    return minimatch.match(pathElement);
+                })).length === 0;
+        }
+        return isAllowed;
+    }
+    isFileNameAllowed(file) {
+        return (this.excludedFileList.filter((pattern) => {
+            const minimatch = new Minimatch(pattern, this.matchingOptions);
+            return minimatch.match(file.name);
+        }).length === 0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter, inject, Injectable } from '@angular/core';\nimport { Minimatch } from 'minimatch';\nimport { Subject } from 'rxjs';\nimport { FileUploadCompleteEvent, FileUploadDeleteEvent, FileUploadErrorEvent, FileUploadEvent } from '../events/file.event';\nimport { FileModel, FileUploadProgress, FileUploadStatus } from '../models/file.model';\nimport { AppConfigService } from '@alfresco/adf-core';\nimport { filter } from 'rxjs/operators';\nimport { DiscoveryApiService } from '../../common/services/discovery-api.service';\nimport { NodeBodyCreate, NodesApi, UploadApi, VersionsApi } from '@alfresco/js-api';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\nconst MIN_CANCELLABLE_FILE_SIZE = 1000000;\nconst MAX_CANCELLABLE_FILE_PERCENTAGE = 50;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UploadService {\n    queue: FileModel[] = [];\n    queueChanged: Subject<FileModel[]> = new Subject<FileModel[]>();\n    fileUpload: Subject<FileUploadEvent> = new Subject<FileUploadEvent>();\n    fileUploadStarting: Subject<FileUploadEvent> = new Subject<FileUploadEvent>();\n    fileUploadCancelled: Subject<FileUploadEvent> = new Subject<FileUploadEvent>();\n    fileUploadProgress: Subject<FileUploadEvent> = new Subject<FileUploadEvent>();\n    fileUploadAborted: Subject<FileUploadEvent> = new Subject<FileUploadEvent>();\n    fileUploadError: Subject<FileUploadErrorEvent> = new Subject<FileUploadErrorEvent>();\n    fileUploadComplete: Subject<FileUploadCompleteEvent> = new Subject<FileUploadCompleteEvent>();\n    fileUploadDeleted: Subject<FileUploadDeleteEvent> = new Subject<FileUploadDeleteEvent>();\n    fileDeleted: Subject<string> = new Subject<string>();\n\n    private cache: { [key: string]: any } = {};\n    private totalComplete: number = 0;\n    private totalAborted: number = 0;\n    private totalError: number = 0;\n    private excludedFileList: string[] = [];\n    private excludedFoldersList: string[] = [];\n    private matchingOptions: any = null;\n    private folderMatchingOptions: any = null;\n    private abortedFile: string;\n    private isThumbnailGenerationEnabled: boolean;\n\n    private _uploadApi: UploadApi;\n    get uploadApi(): UploadApi {\n        this._uploadApi = this._uploadApi ?? new UploadApi(this.apiService.getInstance());\n        return this._uploadApi;\n    }\n\n    private _nodesApi: NodesApi;\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());\n        return this._nodesApi;\n    }\n\n    private _versionsApi: VersionsApi;\n    get versionsApi(): VersionsApi {\n        this._versionsApi = this._versionsApi ?? new VersionsApi(this.apiService.getInstance());\n        return this._versionsApi;\n    }\n\n    protected apiService = inject(AlfrescoApiService);\n    protected appConfigService = inject(AppConfigService);\n    protected discoveryApiService = inject(DiscoveryApiService);\n\n    constructor() {\n        this.discoveryApiService.ecmProductInfo$.pipe(filter((info) => !!info)).subscribe(({ status }) => {\n            this.isThumbnailGenerationEnabled = status.isThumbnailGenerationEnabled;\n        });\n    }\n\n    clearCache() {\n        this.cache = {};\n    }\n\n    /**\n     * Returns the number of concurrent threads for uploading.\n     *\n     * @returns Number of concurrent threads (default 1)\n     */\n    getThreadsCount(): number {\n        return this.appConfigService.get<number>('upload.threads', 1);\n    }\n\n    /**\n     * Checks whether the service still has files uploading or awaiting upload.\n     *\n     * @returns True if files in the queue are still uploading, false otherwise\n     */\n    isUploading(): boolean {\n        const finishedFileStates = [\n            FileUploadStatus.Complete,\n            FileUploadStatus.Cancelled,\n            FileUploadStatus.Aborted,\n            FileUploadStatus.Error,\n            FileUploadStatus.Deleted\n        ];\n        return this.queue.reduce(\n            (stillUploading: boolean, currentFile: FileModel) => stillUploading || finishedFileStates.indexOf(currentFile.status) === -1,\n            false\n        );\n    }\n\n    /**\n     * Gets the file Queue\n     *\n     * @returns Array of files that form the queue\n     */\n    getQueue(): FileModel[] {\n        return this.queue;\n    }\n\n    /**\n     * Adds files to the uploading queue to be uploaded\n     *\n     * @param files One or more separate parameters or an array of files to queue\n     * @returns Array of files that were not blocked from upload by the ignore list\n     */\n    addToQueue(...files: FileModel[]): FileModel[] {\n        const allowedFiles = files.filter((currentFile) => this.filterElement(currentFile));\n        this.queue = this.queue.concat(allowedFiles);\n        this.queueChanged.next(this.queue);\n        return allowedFiles;\n    }\n\n    /**\n     * Finds all the files in the queue that are not yet uploaded and uploads them into the directory folder.\n     *\n     * @param successEmitter Emitter to invoke on file success status change\n     * @param errorEmitter Emitter to invoke on file error status change\n     */\n    uploadFilesInTheQueue(successEmitter?: EventEmitter<any>, errorEmitter?: EventEmitter<any>): void {\n        const files = this.getFilesToUpload();\n\n        if (files && files.length > 0) {\n            for (const file of files) {\n                this.onUploadStarting(file);\n\n                const promise = this.beginUpload(file, successEmitter, errorEmitter);\n                this.cache[file.name] = promise;\n\n                const next = () => {\n                    setTimeout(() => this.uploadFilesInTheQueue(successEmitter, errorEmitter), 100);\n                };\n\n                promise.next = next;\n\n                promise.then(\n                    () => next(),\n                    () => next()\n                );\n            }\n        }\n    }\n\n    /**\n     * Cancels uploading of files.\n     * If the file is smaller than 1 MB the file will be uploaded and then the node deleted\n     * to prevent having files that were aborted but still uploaded.\n     *\n     * @param files One or more separate parameters or an array of files specifying uploads to cancel\n     */\n    cancelUpload(...files: FileModel[]) {\n        files.forEach((file) => {\n            const promise = this.cache[file.name];\n            if (promise) {\n                if (this.isSaveToAbortFile(file)) {\n                    promise.abort();\n                } else {\n                    this.abortedFile = file.name;\n                }\n                delete this.cache[file.name];\n                promise.next();\n            } else {\n                const performAction = this.getAction(file);\n\n                if (performAction) {\n                    performAction();\n                }\n            }\n        });\n    }\n\n    /** Clears the upload queue */\n    clearQueue() {\n        this.queue = [];\n        this.totalComplete = 0;\n        this.totalAborted = 0;\n        this.totalError = 0;\n    }\n\n    /**\n     * Gets an upload promise for a file.\n     *\n     * @param file The target file\n     * @returns Promise that is resolved if the upload is successful or error otherwise\n     */\n    getUploadPromise(file: FileModel): any {\n        const opts: any = {\n            include: ['allowableOperations']\n        };\n\n        if (this.isThumbnailGenerationEnabled) {\n            opts.renditions = 'doclib';\n        }\n\n        if (file.options?.versioningEnabled !== undefined) {\n            opts.versioningEnabled = file.options.versioningEnabled;\n        }\n\n        if (file.options.newVersion === true) {\n            opts.overwrite = true;\n            opts.majorVersion = file.options.majorVersion;\n            opts.comment = file.options.comment;\n            opts.name = file.name;\n        } else {\n            opts.autoRename = true;\n        }\n\n        if (file.options.nodeType) {\n            opts.nodeType = file.options.nodeType;\n        }\n\n        if (file.id) {\n            return this.nodesApi.updateNodeContent(file.id, file.file as any, opts);\n        } else {\n            const nodeBody: NodeBodyCreate = { ...file.options, name: file.name, nodeType: file.options.nodeType };\n            delete nodeBody['versioningEnabled'];\n\n            return this.uploadApi.uploadFile(file.file, file.options.path, file.options.parentId, nodeBody, opts);\n        }\n    }\n\n    private getFilesToUpload(): FileModel[] {\n        const cached = Object.keys(this.cache);\n        const threadsCount = this.getThreadsCount();\n\n        if (cached.length >= threadsCount) {\n            return [];\n        }\n\n        const files = this.queue\n            .filter((toUpload) => !cached.includes(toUpload.name) && toUpload.status === FileUploadStatus.Pending)\n            .slice(0, threadsCount);\n\n        return files;\n    }\n\n    private beginUpload(file: FileModel, successEmitter?: EventEmitter<any>, errorEmitter?: EventEmitter<any>): any {\n        const promise = this.getUploadPromise(file);\n        promise\n            .on('progress', (progress: FileUploadProgress) => {\n                this.onUploadProgress(file, progress);\n            })\n            .on('abort', () => {\n                this.onUploadAborted(file);\n                if (successEmitter) {\n                    successEmitter.emit({ value: 'File aborted' });\n                }\n            })\n            .on('error', (err) => {\n                this.onUploadError(file, err);\n                if (errorEmitter) {\n                    errorEmitter.emit({ value: 'Error file uploaded' });\n                }\n            })\n            .on('success', (data) => {\n                if (this.abortedFile === file.name) {\n                    this.onUploadAborted(file);\n                    if (file.id === undefined) {\n                        this.deleteAbortedNode(data.entry.id);\n                    } else {\n                        this.deleteAbortedNodeVersion(data.entry.id, data.entry.properties['cm:versionLabel']);\n                    }\n                    if (successEmitter) {\n                        successEmitter.emit({ value: 'File deleted' });\n                    }\n                } else {\n                    this.onUploadComplete(file, data);\n                    if (successEmitter) {\n                        successEmitter.emit({ value: data });\n                    }\n                }\n            })\n            .catch(() => {});\n\n        return promise;\n    }\n\n    private onUploadStarting(file: FileModel): void {\n        if (file) {\n            file.status = FileUploadStatus.Starting;\n            const event = new FileUploadEvent(file, FileUploadStatus.Starting);\n            this.fileUpload.next(event);\n            this.fileUploadStarting.next(event);\n        }\n    }\n\n    private onUploadProgress(file: FileModel, progress: FileUploadProgress): void {\n        if (file) {\n            file.progress = progress;\n            file.status = FileUploadStatus.Progress;\n\n            const event = new FileUploadEvent(file, FileUploadStatus.Progress);\n            this.fileUpload.next(event);\n            this.fileUploadProgress.next(event);\n        }\n    }\n\n    private onUploadError(file: FileModel, error: { status?: number }): void {\n        if (file) {\n            file.errorCode = error?.status;\n            file.status = FileUploadStatus.Error;\n            this.totalError++;\n\n            const promise = this.cache[file.name];\n            if (promise) {\n                delete this.cache[file.name];\n            }\n\n            const event = new FileUploadErrorEvent(file, error, this.totalError);\n            this.fileUpload.next(event);\n            this.fileUploadError.next(event);\n        }\n    }\n\n    private onUploadComplete(file: FileModel, data: any): void {\n        if (file) {\n            file.status = FileUploadStatus.Complete;\n            file.data = data;\n            this.totalComplete++;\n            const promise = this.cache[file.name];\n            if (promise) {\n                delete this.cache[file.name];\n            }\n\n            const event = new FileUploadCompleteEvent(file, this.totalComplete, data, this.totalAborted);\n            this.fileUpload.next(event);\n            this.fileUploadComplete.next(event);\n        }\n    }\n\n    private onUploadAborted(file: FileModel): void {\n        if (file) {\n            file.status = FileUploadStatus.Aborted;\n            this.totalAborted++;\n\n            const event = new FileUploadEvent(file, FileUploadStatus.Aborted);\n            this.fileUpload.next(event);\n            this.fileUploadAborted.next(event);\n        }\n    }\n\n    private onUploadCancelled(file: FileModel): void {\n        if (file) {\n            file.status = FileUploadStatus.Cancelled;\n\n            const event = new FileUploadEvent(file, FileUploadStatus.Cancelled);\n            this.fileUpload.next(event);\n            this.fileUploadCancelled.next(event);\n        }\n    }\n\n    private onUploadDeleted(file: FileModel): void {\n        if (file) {\n            file.status = FileUploadStatus.Deleted;\n            this.totalComplete--;\n\n            const event = new FileUploadDeleteEvent(file, this.totalComplete);\n            this.fileUpload.next(event);\n            this.fileUploadDeleted.next(event);\n        }\n    }\n\n    private getAction(file: FileModel) {\n        const actions = {\n            [FileUploadStatus.Pending]: () => this.onUploadCancelled(file),\n            [FileUploadStatus.Deleted]: () => this.onUploadDeleted(file),\n            [FileUploadStatus.Error]: () => this.onUploadError(file, null)\n        };\n\n        return actions[file.status];\n    }\n\n    private deleteAbortedNode(nodeId: string) {\n        this.nodesApi.deleteNode(nodeId, { permanent: true }).then(() => (this.abortedFile = undefined));\n    }\n\n    private deleteAbortedNodeVersion(nodeId: string, versionId: string) {\n        this.versionsApi.deleteVersion(nodeId, versionId).then(() => (this.abortedFile = undefined));\n    }\n\n    private isSaveToAbortFile(file: FileModel): boolean {\n        return file.size > MIN_CANCELLABLE_FILE_SIZE && file.progress.percent < MAX_CANCELLABLE_FILE_PERCENTAGE;\n    }\n\n    private filterElement(file: FileModel) {\n        this.excludedFileList = this.appConfigService.get<string[]>('files.excluded');\n        this.excludedFoldersList = this.appConfigService.get<string[]>('folders.excluded');\n        let isAllowed = true;\n\n        if (this.excludedFileList) {\n            this.matchingOptions = this.appConfigService.get('files.match-options');\n            isAllowed = this.isFileNameAllowed(file);\n        }\n\n        if (isAllowed && this.excludedFoldersList) {\n            this.folderMatchingOptions = this.appConfigService.get('folders.match-options');\n            isAllowed = this.isParentFolderAllowed(file);\n        }\n        return isAllowed;\n    }\n\n    private isParentFolderAllowed(file: FileModel): boolean {\n        let isAllowed: boolean = true;\n        const currentFile: any = file.file;\n        const fileRelativePath = currentFile.webkitRelativePath ? currentFile.webkitRelativePath : file.options.path;\n        if (currentFile && fileRelativePath) {\n            isAllowed =\n                this.excludedFoldersList.filter((folderToExclude) =>\n                    fileRelativePath.split('/').some((pathElement) => {\n                        const minimatch = new Minimatch(folderToExclude, this.folderMatchingOptions);\n                        return minimatch.match(pathElement);\n                    })\n                ).length === 0;\n        }\n        return isAllowed;\n    }\n\n    private isFileNameAllowed(file: FileModel): boolean {\n        return (\n            this.excludedFileList.filter((pattern) => {\n                const minimatch = new Minimatch(pattern, this.matchingOptions);\n                return minimatch.match(file.name);\n            }).length === 0\n        );\n    }\n}\n"]}

package/esm2022/lib/content-metadata/components/content-metadata/content-metadata-header.component.mjs

@@ -0,0 +1,54 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CommonModule } from '@angular/common';
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatIconModule } from '@angular/material/icon';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/expansion";
+export class ContentMetadataHeaderComponent {
+    constructor() {
+        this.title = null;
+        this.expanded = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentMetadataHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ContentMetadataHeaderComponent, isStandalone: true, selector: "adf-content-metadata-header", inputs: { title: "title", expanded: "expanded" }, ngImport: i0, template: `
+        <ng-container>
+            <mat-icon>{{ expanded ? 'expand_more' : 'chevron_right' }}</mat-icon>
+            <mat-panel-title *ngIf="title" class="adf-metadata-properties-title" [title]="title | translate">{{ title | translate }}</mat-panel-title>
+            <ng-content />
+        </ng-container>
+    `, isInline: true, styles: ["adf-content-metadata-header{display:flex;align-items:center;width:100%}.adf-metadata-properties-title{display:block;overflow:hidden;text-overflow:ellipsis;font-weight:700;font-size:15px;padding-left:12px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatExpansionModule }, { kind: "directive", type: i3.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "pipe", type: TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentMetadataHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, MatIconModule, MatExpansionModule, TranslatePipe], selector: 'adf-content-metadata-header', encapsulation: ViewEncapsulation.None, template: `
+        <ng-container>
+            <mat-icon>{{ expanded ? 'expand_more' : 'chevron_right' }}</mat-icon>
+            <mat-panel-title *ngIf="title" class="adf-metadata-properties-title" [title]="title | translate">{{ title | translate }}</mat-panel-title>
+            <ng-content />
+        </ng-container>
+    `, styles: ["adf-content-metadata-header{display:flex;align-items:center;width:100%}.adf-metadata-properties-title{display:block;overflow:hidden;text-overflow:ellipsis;font-weight:700;font-size:15px;padding-left:12px}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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