@alfresco/adf-content-services
Version:
Alfresco ADF content services
176 lines • 22.7 kB
JavaScript
/*!
* @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 { TranslationService } from '@alfresco/adf-core';
import { FileModel } from '../../../common/models/file.model';
import { UploadService } from '../../../common/services/upload.service';
import { DestroyRef, Directive, EventEmitter, inject, Input, NgZone, Output } from '@angular/core';
import { UploadFilesEvent } from '../upload-files.event';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import * as i0 from "@angular/core";
// eslint-disable-next-line @angular-eslint/directive-class-suffix
export class UploadBase {
constructor() {
this.uploadService = inject(UploadService);
this.translationService = inject(TranslationService);
this.ngZone = inject(NgZone);
/**
* The ID of the root. Use the nodeId for
* Content Services or the taskId/processId for Process Services.
*/
this.rootFolderId = '-root-';
/** Toggles component disabled state (if there is no node permission checking). */
this.disabled = false;
/** Filter for accepted file types. */
this.acceptedFilesType = '*';
/** Toggles versioning. */
this.versioning = false;
/** majorVersion boolean field to true to indicate a major version should be created. */
this.majorVersion = false;
/** Custom node type for uploaded file */
this.nodeType = 'cm:content';
/** Emitted when the file is uploaded successfully. */
this.success = new EventEmitter();
/** Emitted when an error occurs. */
this.error = new EventEmitter();
/** Emitted when the upload begins. */
this.beginUpload = new EventEmitter();
/** Emitted when dropping a file over another file to update the version. */
this.updateFileVersion = new EventEmitter();
this.destroyRef = inject(DestroyRef);
}
ngOnInit() {
this.uploadService.fileUploadError
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe(error => this.error.emit(error));
}
/**
* Upload a list of file in the specified path
*
* @param files files to upload
*/
uploadFiles(files) {
const filteredFiles = files.map((file) => this.createFileModel(file, this.rootFolderId, ((file).webkitRelativePath || '').replace(/\/[^/]*$/, '')));
this.uploadQueue(filteredFiles);
}
uploadFilesInfo(files) {
const filteredFiles = files.map((fileInfo) => this.createFileModel(fileInfo.file, this.rootFolderId, fileInfo.relativeFolder));
this.uploadQueue(filteredFiles);
}
uploadQueue(files) {
const filteredFiles = files.filter(this.isFileAcceptable.bind(this)).filter(this.isFileSizeAcceptable.bind(this));
this.ngZone.run(() => {
const event = new UploadFilesEvent([...filteredFiles], this.uploadService, this.success, this.error);
this.beginUpload.emit(event);
if (!event.defaultPrevented) {
if (filteredFiles.length > 0) {
this.uploadService.addToQueue(...filteredFiles);
this.uploadService.uploadFilesInTheQueue(this.success, this.error);
}
}
});
}
/**
* Checks if the given file is allowed by the extension filters
*
* @param file FileModel
* @returns `true` if file is acceptable, otherwise `false`
*/
isFileAcceptable(file) {
if (this.acceptedFilesType === '*') {
return true;
}
const allowedExtensions = this.acceptedFilesType.split(',').map((ext) => ext.trim().replace(/^\./, ''));
return allowedExtensions.indexOf(file.extension) !== -1;
}
/**
* Creates FileModel from File
*
* @param file file instance
* @param parentId parent id
* @param path upload path
* @param id model id
* @returns file model
*/
createFileModel(file, parentId, path, id) {
return new FileModel(file, {
comment: this.comment,
majorVersion: this.majorVersion,
newVersion: this.versioning,
parentId,
path,
nodeType: this.nodeType
}, id);
}
isFileSizeAllowed(file) {
let isFileSizeAllowed = true;
if (this.isMaxFileSizeDefined()) {
isFileSizeAllowed = this.isFileSizeCorrect(file);
}
return isFileSizeAllowed;
}
isMaxFileSizeDefined() {
return this.maxFilesSize !== undefined && this.maxFilesSize !== null;
}
isFileSizeCorrect(file) {
return this.maxFilesSize >= 0 && file.size <= this.maxFilesSize;
}
/**
* Checks if the given file is an acceptable size
*
* @param file FileModel
* @returns `true` if file size is acceptable, otherwise `false`
*/
isFileSizeAcceptable(file) {
let acceptableSize = true;
if (!this.isFileSizeAllowed(file)) {
acceptableSize = false;
const message = this.translationService.instant('FILE_UPLOAD.MESSAGES.EXCEED_MAX_FILE_SIZE', { fileName: file.name });
this.error.emit(message);
}
return acceptableSize;
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: UploadBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: UploadBase, inputs: { maxFilesSize: "maxFilesSize", rootFolderId: "rootFolderId", disabled: "disabled", acceptedFilesType: "acceptedFilesType", versioning: "versioning", majorVersion: "majorVersion", comment: "comment", nodeType: "nodeType" }, outputs: { success: "success", error: "error", beginUpload: "beginUpload", updateFileVersion: "updateFileVersion" }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: UploadBase, decorators: [{
type: Directive
}], propDecorators: { maxFilesSize: [{
type: Input
}], rootFolderId: [{
type: Input
}], disabled: [{
type: Input
}], acceptedFilesType: [{
type: Input
}], versioning: [{
type: Input
}], majorVersion: [{
type: Input
}], comment: [{
type: Input
}], nodeType: [{
type: Input
}], success: [{
type: Output
}], error: [{
type: Output
}], beginUpload: [{
type: Output
}], updateFileVersion: [{
type: Output
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-base.js","sourceRoot":"","sources":["../../../../../../../../lib/content-services/src/lib/upload/components/base-upload/upload-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAY,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,eAAe,CAAC;AAC3G,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;;AAGhE,kEAAkE;AAClE,MAAM,OAAgB,UAAU;IAFhC;QAGc,kBAAa,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QACtC,uBAAkB,GAAuB,MAAM,CAAC,kBAAkB,CAAC,CAAC;QACpE,WAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QASlC;;;WAGG;QAEH,iBAAY,GAAW,QAAQ,CAAC;QAEhC,kFAAkF;QAElF,aAAQ,GAAY,KAAK,CAAC;QAE1B,sCAAsC;QAEtC,sBAAiB,GAAW,GAAG,CAAC;QAEhC,0BAA0B;QAE1B,eAAU,GAAY,KAAK,CAAC;QAE5B,wFAAwF;QAExF,iBAAY,GAAY,KAAK,CAAC;QAM9B,yCAAyC;QAEzC,aAAQ,GAAW,YAAY,CAAC;QAEhC,sDAAsD;QAEtD,YAAO,GAAG,IAAI,YAAY,EAAE,CAAC;QAE7B,oCAAoC;QAEpC,UAAK,GAAG,IAAI,YAAY,EAAwB,CAAC;QAEjD,sCAAsC;QAEtC,gBAAW,GAAG,IAAI,YAAY,EAAoB,CAAC;QAEnD,4EAA4E;QAE5E,sBAAiB,GAAG,IAAI,YAAY,EAAe,CAAC;QAEnC,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;KAyHpD;IAvHG,QAAQ;QACJ,IAAI,CAAC,aAAa,CAAC,eAAe;aAC7B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAa;QACrB,MAAM,aAAa,GAAgB,KAAK,CAAC,GAAG,CAAY,CAAC,IAAU,EAAE,EAAE,CACnE,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAC3G,CAAC;QAEF,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACpC,CAAC;IAED,eAAe,CAAC,KAAiB;QAC7B,MAAM,aAAa,GAAgB,KAAK,CAAC,GAAG,CAAY,CAAC,QAAkB,EAAE,EAAE,CAC3E,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,cAAc,CAAC,CAClF,CAAC;QAEF,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACpC,CAAC;IAEO,WAAW,CAAC,KAAkB;QAClC,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAElH,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;YACjB,MAAM,KAAK,GAAG,IAAI,gBAAgB,CAAC,CAAC,GAAG,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACrG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE7B,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;gBAC1B,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC3B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,CAAC;oBAChD,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;gBACvE,CAAC;YACL,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;OAKG;IACO,gBAAgB,CAAC,IAAe;QACtC,IAAI,IAAI,CAAC,iBAAiB,KAAK,GAAG,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;QAExG,OAAO,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;OAQG;IACO,eAAe,CAAC,IAAU,EAAE,QAAgB,EAAE,IAAY,EAAE,EAAW;QAC7E,OAAO,IAAI,SAAS,CAChB,IAAI,EACJ;YACI,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,QAAQ;YACR,IAAI;YACJ,QAAQ,EAAE,IAAI,CAAC,QAAQ;SAC1B,EACD,EAAE,CACL,CAAC;IACN,CAAC;IAES,iBAAiB,CAAC,IAAe;QACvC,IAAI,iBAAiB,GAAG,IAAI,CAAC;QAC7B,IAAI,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC;YAC9B,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,iBAAiB,CAAC;IAC7B,CAAC;IAES,oBAAoB;QAC1B,OAAO,IAAI,CAAC,YAAY,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC;IACzE,CAAC;IAES,iBAAiB,CAAC,IAAe;QACvC,OAAO,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC;IACpE,CAAC;IAED;;;;;OAKG;IACK,oBAAoB,CAAC,IAAe;QACxC,IAAI,cAAc,GAAG,IAAI,CAAC;QAE1B,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,cAAc,GAAG,KAAK,CAAC;YAEvB,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,2CAA2C,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAEtH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;QAED,OAAO,cAAc,CAAC;IAC1B,CAAC;8GAnLiB,UAAU;kGAAV,UAAU;;2FAAV,UAAU;kBAF/B,SAAS;8BAYN,YAAY;sBADX,KAAK;gBAQN,YAAY;sBADX,KAAK;gBAKN,QAAQ;sBADP,KAAK;gBAKN,iBAAiB;sBADhB,KAAK;gBAKN,UAAU;sBADT,KAAK;gBAKN,YAAY;sBADX,KAAK;gBAKN,OAAO;sBADN,KAAK;gBAKN,QAAQ;sBADP,KAAK;gBAKN,OAAO;sBADN,MAAM;gBAKP,KAAK;sBADJ,MAAM;gBAKP,WAAW;sBADV,MAAM;gBAKP,iBAAiB;sBADhB,MAAM","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 { FileInfo, TranslationService } from '@alfresco/adf-core';\nimport { FileUploadErrorEvent } from '../../../common/events/file.event';\nimport { FileModel } from '../../../common/models/file.model';\nimport { UploadService } from '../../../common/services/upload.service';\nimport { DestroyRef, Directive, EventEmitter, inject, Input, NgZone, OnInit, Output } from '@angular/core';\nimport { UploadFilesEvent } from '../upload-files.event';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class UploadBase implements OnInit {\n    protected uploadService = inject(UploadService);\n    protected translationService: TranslationService = inject(TranslationService);\n    protected ngZone = inject(NgZone);\n\n    /**\n     * Sets a limit on the maximum size (in bytes) of a file to be uploaded.\n     * Has no effect if undefined.\n     */\n    @Input()\n    maxFilesSize: number;\n\n    /**\n     * The ID of the root. Use the nodeId for\n     * Content Services or the taskId/processId for Process Services.\n     */\n    @Input()\n    rootFolderId: string = '-root-';\n\n    /** Toggles component disabled state (if there is no node permission checking). */\n    @Input()\n    disabled: boolean = false;\n\n    /** Filter for accepted file types. */\n    @Input()\n    acceptedFilesType: string = '*';\n\n    /** Toggles versioning. */\n    @Input()\n    versioning: boolean = false;\n\n    /** majorVersion boolean field to true to indicate a major version should be created. */\n    @Input()\n    majorVersion: boolean = false;\n\n    /** When you overwrite existing content, you can use the comment field to add a version comment that appears in the version history */\n    @Input()\n    comment: string;\n\n    /** Custom node type for uploaded file */\n    @Input()\n    nodeType: string = 'cm:content';\n\n    /** Emitted when the file is uploaded successfully. */\n    @Output()\n    success = new EventEmitter();\n\n    /** Emitted when an error occurs. */\n    @Output()\n    error = new EventEmitter<FileUploadErrorEvent>();\n\n    /** Emitted when the upload begins. */\n    @Output()\n    beginUpload = new EventEmitter<UploadFilesEvent>();\n\n    /** Emitted when dropping a file over another file to update the version. */\n    @Output()\n    updateFileVersion = new EventEmitter<CustomEvent>();\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    ngOnInit() {\n        this.uploadService.fileUploadError\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe(error => this.error.emit(error));\n    }\n\n    /**\n     * Upload a list of file in the specified path\n     *\n     * @param files files to upload\n     */\n    uploadFiles(files: File[]): void {\n        const filteredFiles: FileModel[] = files.map<FileModel>((file: File) =>\n            this.createFileModel(file, this.rootFolderId, ((file).webkitRelativePath || '').replace(/\\/[^/]*$/, ''))\n        );\n\n        this.uploadQueue(filteredFiles);\n    }\n\n    uploadFilesInfo(files: FileInfo[]): void {\n        const filteredFiles: FileModel[] = files.map<FileModel>((fileInfo: FileInfo) =>\n            this.createFileModel(fileInfo.file, this.rootFolderId, fileInfo.relativeFolder)\n        );\n\n        this.uploadQueue(filteredFiles);\n    }\n\n    private uploadQueue(files: FileModel[]) {\n        const filteredFiles = files.filter(this.isFileAcceptable.bind(this)).filter(this.isFileSizeAcceptable.bind(this));\n\n        this.ngZone.run(() => {\n            const event = new UploadFilesEvent([...filteredFiles], this.uploadService, this.success, this.error);\n            this.beginUpload.emit(event);\n\n            if (!event.defaultPrevented) {\n                if (filteredFiles.length > 0) {\n                    this.uploadService.addToQueue(...filteredFiles);\n                    this.uploadService.uploadFilesInTheQueue(this.success, this.error);\n                }\n            }\n        });\n    }\n\n    /**\n     * Checks if the given file is allowed by the extension filters\n     *\n     * @param file FileModel\n     * @returns `true` if file is acceptable, otherwise `false`\n     */\n    protected isFileAcceptable(file: FileModel): boolean {\n        if (this.acceptedFilesType === '*') {\n            return true;\n        }\n\n        const allowedExtensions = this.acceptedFilesType.split(',').map((ext) => ext.trim().replace(/^\\./, ''));\n\n        return allowedExtensions.indexOf(file.extension) !== -1;\n    }\n\n    /**\n     * Creates FileModel from File\n     *\n     * @param file file instance\n     * @param parentId parent id\n     * @param path upload path\n     * @param id model id\n     * @returns file model\n     */\n    protected createFileModel(file: File, parentId: string, path: string, id?: string): FileModel {\n        return new FileModel(\n            file,\n            {\n                comment: this.comment,\n                majorVersion: this.majorVersion,\n                newVersion: this.versioning,\n                parentId,\n                path,\n                nodeType: this.nodeType\n            },\n            id\n        );\n    }\n\n    protected isFileSizeAllowed(file: FileModel) {\n        let isFileSizeAllowed = true;\n        if (this.isMaxFileSizeDefined()) {\n            isFileSizeAllowed = this.isFileSizeCorrect(file);\n        }\n\n        return isFileSizeAllowed;\n    }\n\n    protected isMaxFileSizeDefined() {\n        return this.maxFilesSize !== undefined && this.maxFilesSize !== null;\n    }\n\n    protected isFileSizeCorrect(file: FileModel) {\n        return this.maxFilesSize >= 0 && file.size <= this.maxFilesSize;\n    }\n\n    /**\n     * Checks if the given file is an acceptable size\n     *\n     * @param file FileModel\n     * @returns `true` if file size is acceptable, otherwise `false`\n     */\n    private isFileSizeAcceptable(file: FileModel): boolean {\n        let acceptableSize = true;\n\n        if (!this.isFileSizeAllowed(file)) {\n            acceptableSize = false;\n\n            const message = this.translationService.instant('FILE_UPLOAD.MESSAGES.EXCEED_MAX_FILE_SIZE', { fileName: file.name });\n\n            this.error.emit(message);\n        }\n\n        return acceptableSize;\n    }\n}\n"]}