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

package/esm2022/lib/content-node-selector/content-node-dialog.service.mjs

@@ -0,0 +1,256 @@
+/*!
+ * @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 { MatDialog } from '@angular/material/dialog';
+import { EventEmitter, Injectable, Output } from '@angular/core';
+import { ThumbnailService, TranslationService } from '@alfresco/adf-core';
+import { Subject, throwError } from 'rxjs';
+import { AllowableOperationsEnum } from '../common/models/allowable-operations.enum';
+import { ContentService } from '../common/services/content.service';
+import { DocumentListService } from '../document-list/services/document-list.service';
+import { ContentNodeSelectorComponent } from './content-node-selector.component';
+import { NodeAction } from '../document-list/models/node-action.enum';
+import { NodeLockDialogComponent } from '../dialogs/node-lock/node-lock.dialog';
+import { switchMap } from 'rxjs/operators';
+import { SitesService } from '../common/services/sites.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../common/services/content.service";
+import * as i3 from "../document-list/services/document-list.service";
+import * as i4 from "../common/services/sites.service";
+import * as i5 from "@alfresco/adf-core";
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class ContentNodeDialogService {
+    static { this.nonDocumentSiteContent = ['blog', 'calendar', 'dataLists', 'discussions', 'links', 'wiki']; }
+    constructor(dialog, contentService, documentListService, siteService, translation, thumbnailService) {
+        this.dialog = dialog;
+        this.contentService = contentService;
+        this.documentListService = documentListService;
+        this.siteService = siteService;
+        this.translation = translation;
+        this.thumbnailService = thumbnailService;
+        /** Emitted when an error occurs. */
+        this.error = new EventEmitter();
+    }
+    /**
+     * Opens a file browser at a chosen folder location.
+     * shows files and folders in the dialog search result.
+     *
+     * @param folderNodeId ID of the folder to use
+     * @returns Information about the selected file(s)
+     */
+    openFileBrowseDialogByFolderId(folderNodeId) {
+        return this.documentListService
+            .getFolderNode(folderNodeId)
+            .pipe(switchMap((nodeEntry) => this.openUploadFileDialog(NodeAction.CHOOSE, nodeEntry.entry, true)));
+    }
+    /**
+     * Opens a lock node dialog.
+     *
+     * @param contentEntry Node to lock
+     * @returns Error/status message (if any)
+     */
+    openLockNodeDialog(contentEntry) {
+        const observable = new Subject();
+        if (this.contentService.hasAllowableOperations(contentEntry, AllowableOperationsEnum.LOCK)) {
+            this.dialog.open(NodeLockDialogComponent, {
+                data: {
+                    node: contentEntry,
+                    onError: (error) => {
+                        this.error.emit(error);
+                        observable.error(error);
+                    }
+                },
+                width: '400px'
+            });
+        }
+        else {
+            observable.error('OPERATION.FAIL.NODE.NO_PERMISSION');
+        }
+        return observable;
+    }
+    /**
+     * Opens a file browser at a chosen site location.
+     * shows files and folders in the dialog search result.
+     *
+     * @returns Information about the selected file(s)
+     */
+    openFileBrowseDialogBySite() {
+        return this.siteService
+            .getSites()
+            .pipe(switchMap((response) => this.openFileBrowseDialogByFolderId(response.list.entries[0].entry.guid)));
+    }
+    /**
+     * Opens a file browser at a default myFile location.
+     * shows files and folders in the dialog search result.
+     *
+     * @returns Information about the selected file(s)
+     */
+    openFileBrowseDialogByDefaultLocation() {
+        return this.openFileBrowseDialogByFolderId('-my-');
+    }
+    /**
+     * Opens a folder browser at a chosen site location.
+     *
+     * @returns Information about the selected folder(s)
+     */
+    openFolderBrowseDialogBySite() {
+        return this.openFolderBrowseDialogByFolderId('-my-');
+    }
+    /**
+     * Opens a folder browser at a chosen folder location.
+     *
+     * @param folderNodeId ID of the folder to use
+     * @returns Information about the selected folder(s)
+     */
+    openFolderBrowseDialogByFolderId(folderNodeId) {
+        return this.documentListService
+            .getFolderNode(folderNodeId)
+            .pipe(switchMap((node) => this.openUploadFolderDialog(NodeAction.CHOOSE, node.entry)));
+    }
+    /**
+     * Opens a dialog to copy or move an item to a new location.
+     *
+     * @param action Name of the action (eg, "Copy" or "Move") to show in the title
+     * @param contentEntry Item to be copied or moved
+     * @param permission Permission for the operation
+     * @param excludeSiteContent The site content that should be filtered out
+     * @returns Information about files that were copied/moved
+     */
+    openCopyMoveDialog(action, contentEntry, permission, excludeSiteContent) {
+        if (this.contentService.hasAllowableOperations(contentEntry, permission)) {
+            const select = new Subject();
+            const data = {
+                title: this.getTitleTranslation(action, contentEntry.name),
+                actionName: action,
+                selectionMode: 'single',
+                currentFolderId: contentEntry.parentId,
+                imageResolver: this.imageResolver.bind(this),
+                where: '(isFolder=true)',
+                isSelectionValid: this.isCopyMoveSelectionValid.bind(this),
+                excludeSiteContent: excludeSiteContent || ContentNodeDialogService.nonDocumentSiteContent,
+                select
+            };
+            const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');
+            dialogRef.afterClosed().subscribe({ next: () => select.complete() });
+            return select;
+        }
+        else {
+            const errors = new Error(JSON.stringify({ error: { statusCode: 403 } }));
+            return throwError(errors);
+        }
+    }
+    /**
+     * Gets the translation of the dialog title.
+     *
+     * @param action Name of the action to display in the dialog title
+     * @param name Name of the item on which the action is being performed
+     * @returns Translated version of the title
+     */
+    getTitleTranslation(action, name) {
+        return this.translation.instant(`NODE_SELECTOR.${action.toUpperCase()}_ITEM`, { name });
+    }
+    /**
+     * Opens a dialog to choose folders to upload.
+     *
+     * @param action Name of the action to show in the title
+     * @param contentEntry  Item to upload
+     * @returns Information about the chosen folder(s)
+     */
+    openUploadFolderDialog(action, contentEntry) {
+        const select = new Subject();
+        const data = {
+            title: this.getTitleTranslation(action, this.translation.instant('DROPDOWN.MY_FILES_OPTION')),
+            actionName: action,
+            selectionMode: 'single',
+            currentFolderId: contentEntry.id,
+            imageResolver: this.imageResolver.bind(this),
+            isSelectionValid: this.hasAllowableOperationsOnNodeFolder.bind(this),
+            where: '(isFolder=true)',
+            select
+        };
+        const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');
+        dialogRef.afterClosed().subscribe({ next: () => select.complete() });
+        return select;
+    }
+    /**
+     * Opens a dialog to choose a file to upload.
+     *
+     * @param action Name of the action to show in the title
+     * @param contentEntry Item to upload
+     * @param showFilesInResult Show files in dialog search result
+     * @returns Information about the chosen file(s)
+     */
+    openUploadFileDialog(action, contentEntry, showFilesInResult = false) {
+        const select = new Subject();
+        const data = {
+            title: this.getTitleTranslation(action, this.translation.instant('DROPDOWN.MY_FILES_OPTION')),
+            actionName: action,
+            selectionMode: 'single',
+            currentFolderId: contentEntry.id,
+            imageResolver: this.imageResolver.bind(this),
+            isSelectionValid: (entry) => entry.isFile,
+            select,
+            showFilesInResult
+        };
+        const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');
+        dialogRef.afterClosed().subscribe({ next: () => select.complete() });
+        return select;
+    }
+    openContentNodeDialog(data, panelClass, width) {
+        return this.dialog.open(ContentNodeSelectorComponent, {
+            data,
+            panelClass,
+            width,
+            disableClose: true
+        });
+    }
+    imageResolver(row) {
+        const entry = row.node.entry;
+        if (!this.contentService.hasAllowableOperations(entry, 'create')) {
+            if (this.isNodeFolder(entry)) {
+                return this.thumbnailService.getMimeTypeIcon('disable/folder');
+            }
+        }
+        return null;
+    }
+    hasAllowableOperationsOnNodeFolder(entry) {
+        return this.isNodeFolder(entry) && this.contentService.hasAllowableOperations(entry, 'create');
+    }
+    isNodeFolder(entry) {
+        return entry.isFolder;
+    }
+    isCopyMoveSelectionValid(entry) {
+        return this.hasEntityCreatePermission(entry) && !this.isSite(entry);
+    }
+    hasEntityCreatePermission(entry) {
+        return this.contentService.hasAllowableOperations(entry, 'create');
+    }
+    isSite(entry) {
+        return !!entry.guid || entry.nodeType === 'st:site' || entry.nodeType === 'st:sites';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentNodeDialogService, deps: [{ token: i1.MatDialog }, { token: i2.ContentService }, { token: i3.DocumentListService }, { token: i4.SitesService }, { token: i5.TranslationService }, { token: i5.ThumbnailService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentNodeDialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContentNodeDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }, { type: i2.ContentService }, { type: i3.DocumentListService }, { type: i4.SitesService }, { type: i5.TranslationService }, { type: i5.ThumbnailService }], propDecorators: { error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-node-dialog.service.js","sourceRoot":"","sources":["../../../../../../lib/content-services/src/lib/content-node-selector/content-node-dialog.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 { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { EventEmitter, Injectable, Output } from '@angular/core';\nimport { ThumbnailService, TranslationService } from '@alfresco/adf-core';\nimport { Subject, Observable, throwError } from 'rxjs';\nimport { ShareDataRow } from '../document-list/data/share-data-row.model';\nimport { AllowableOperationsEnum } from '../common/models/allowable-operations.enum';\nimport { ContentService } from '../common/services/content.service';\nimport { Node, NodeEntry, SitePaging } from '@alfresco/js-api';\nimport { DocumentListService } from '../document-list/services/document-list.service';\nimport { ContentNodeSelectorComponent } from './content-node-selector.component';\nimport { ContentNodeSelectorComponentData } from './content-node-selector.component-data.interface';\nimport { NodeAction } from '../document-list/models/node-action.enum';\nimport { NodeLockDialogComponent } from '../dialogs/node-lock/node-lock.dialog';\nimport { switchMap } from 'rxjs/operators';\nimport { SitesService } from '../common/services/sites.service';\n\n@Injectable({\n    providedIn: 'root'\n})\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class ContentNodeDialogService {\n    static nonDocumentSiteContent = ['blog', 'calendar', 'dataLists', 'discussions', 'links', 'wiki'];\n\n    /** Emitted when an error occurs. */\n    @Output()\n    error: EventEmitter<any> = new EventEmitter<any>();\n\n    constructor(\n        private dialog: MatDialog,\n        private contentService: ContentService,\n        private documentListService: DocumentListService,\n        private siteService: SitesService,\n        private translation: TranslationService,\n        private thumbnailService: ThumbnailService\n    ) {}\n\n    /**\n     * Opens a file browser at a chosen folder location.\n     * shows files and folders in the dialog search result.\n     *\n     * @param folderNodeId ID of the folder to use\n     * @returns Information about the selected file(s)\n     */\n    openFileBrowseDialogByFolderId(folderNodeId: string): Observable<Node[]> {\n        return this.documentListService\n            .getFolderNode(folderNodeId)\n            .pipe(switchMap((nodeEntry: NodeEntry) => this.openUploadFileDialog(NodeAction.CHOOSE, nodeEntry.entry, true)));\n    }\n\n    /**\n     * Opens a lock node dialog.\n     *\n     * @param contentEntry Node to lock\n     * @returns Error/status message (if any)\n     */\n    public openLockNodeDialog(contentEntry: Node): Subject<string> {\n        const observable: Subject<string> = new Subject<string>();\n\n        if (this.contentService.hasAllowableOperations(contentEntry, AllowableOperationsEnum.LOCK)) {\n            this.dialog.open(NodeLockDialogComponent, {\n                data: {\n                    node: contentEntry,\n                    onError: (error) => {\n                        this.error.emit(error);\n                        observable.error(error);\n                    }\n                },\n                width: '400px'\n            });\n        } else {\n            observable.error('OPERATION.FAIL.NODE.NO_PERMISSION');\n        }\n\n        return observable;\n    }\n\n    /**\n     * Opens a file browser at a chosen site location.\n     * shows files and folders in the dialog search result.\n     *\n     * @returns Information about the selected file(s)\n     */\n    openFileBrowseDialogBySite(): Observable<Node[]> {\n        return this.siteService\n            .getSites()\n            .pipe(switchMap((response: SitePaging) => this.openFileBrowseDialogByFolderId(response.list.entries[0].entry.guid)));\n    }\n\n    /**\n     * Opens a file browser at a default myFile location.\n     * shows files and folders in the dialog search result.\n     *\n     * @returns Information about the selected file(s)\n     */\n    openFileBrowseDialogByDefaultLocation(): Observable<Node[]> {\n        return this.openFileBrowseDialogByFolderId('-my-');\n    }\n\n    /**\n     * Opens a folder browser at a chosen site location.\n     *\n     * @returns Information about the selected folder(s)\n     */\n    openFolderBrowseDialogBySite(): Observable<Node[]> {\n        return this.openFolderBrowseDialogByFolderId('-my-');\n    }\n\n    /**\n     * Opens a folder browser at a chosen folder location.\n     *\n     * @param folderNodeId ID of the folder to use\n     * @returns Information about the selected folder(s)\n     */\n    openFolderBrowseDialogByFolderId(folderNodeId: string): Observable<Node[]> {\n        return this.documentListService\n            .getFolderNode(folderNodeId)\n            .pipe(switchMap((node: NodeEntry) => this.openUploadFolderDialog(NodeAction.CHOOSE, node.entry)));\n    }\n\n    /**\n     * Opens a dialog to copy or move an item to a new location.\n     *\n     * @param action Name of the action (eg, \"Copy\" or \"Move\") to show in the title\n     * @param contentEntry Item to be copied or moved\n     * @param permission Permission for the operation\n     * @param excludeSiteContent The site content that should be filtered out\n     * @returns Information about files that were copied/moved\n     */\n    openCopyMoveDialog(action: NodeAction, contentEntry: Node, permission?: string, excludeSiteContent?: string[]): Observable<Node[]> {\n        if (this.contentService.hasAllowableOperations(contentEntry, permission)) {\n            const select = new Subject<Node[]>();\n\n            const data: ContentNodeSelectorComponentData = {\n                title: this.getTitleTranslation(action, contentEntry.name),\n                actionName: action,\n                selectionMode: 'single',\n                currentFolderId: contentEntry.parentId,\n                imageResolver: this.imageResolver.bind(this),\n                where: '(isFolder=true)',\n                isSelectionValid: this.isCopyMoveSelectionValid.bind(this),\n                excludeSiteContent: excludeSiteContent || ContentNodeDialogService.nonDocumentSiteContent,\n                select\n            };\n\n            const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');\n            dialogRef.afterClosed().subscribe({ next: () => select.complete() });\n\n            return select;\n        } else {\n            const errors = new Error(JSON.stringify({ error: { statusCode: 403 } }));\n            return throwError(errors);\n        }\n    }\n\n    /**\n     * Gets the translation of the dialog title.\n     *\n     * @param action Name of the action to display in the dialog title\n     * @param name Name of the item on which the action is being performed\n     * @returns Translated version of the title\n     */\n    getTitleTranslation(action: string, name: string): string {\n        return this.translation.instant(`NODE_SELECTOR.${action.toUpperCase()}_ITEM`, { name });\n    }\n\n    /**\n     * Opens a dialog to choose folders to upload.\n     *\n     * @param action Name of the action to show in the title\n     * @param contentEntry  Item to upload\n     * @returns Information about the chosen folder(s)\n     */\n    openUploadFolderDialog(action: NodeAction, contentEntry: Node): Observable<Node[]> {\n        const select = new Subject<Node[]>();\n\n        const data: ContentNodeSelectorComponentData = {\n            title: this.getTitleTranslation(action, this.translation.instant('DROPDOWN.MY_FILES_OPTION')),\n            actionName: action,\n            selectionMode: 'single',\n            currentFolderId: contentEntry.id,\n            imageResolver: this.imageResolver.bind(this),\n            isSelectionValid: this.hasAllowableOperationsOnNodeFolder.bind(this),\n            where: '(isFolder=true)',\n            select\n        };\n\n        const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');\n        dialogRef.afterClosed().subscribe({ next: () => select.complete() });\n\n        return select;\n    }\n\n    /**\n     * Opens a dialog to choose a file to upload.\n     *\n     * @param action Name of the action to show in the title\n     * @param contentEntry Item to upload\n     * @param showFilesInResult Show files in dialog search result\n     * @returns Information about the chosen file(s)\n     */\n    openUploadFileDialog(action: NodeAction, contentEntry: Node, showFilesInResult = false): Observable<Node[]> {\n        const select = new Subject<Node[]>();\n\n        const data: ContentNodeSelectorComponentData = {\n            title: this.getTitleTranslation(action, this.translation.instant('DROPDOWN.MY_FILES_OPTION')),\n            actionName: action,\n            selectionMode: 'single',\n            currentFolderId: contentEntry.id,\n            imageResolver: this.imageResolver.bind(this),\n            isSelectionValid: (entry: Node) => entry.isFile,\n            select,\n            showFilesInResult\n        };\n\n        const dialogRef = this.openContentNodeDialog(data, 'adf-content-node-selector-dialog', '630px');\n        dialogRef.afterClosed().subscribe({ next: () => select.complete() });\n\n        return select;\n    }\n\n    private openContentNodeDialog(\n        data: ContentNodeSelectorComponentData,\n        panelClass: string,\n        width: string\n    ): MatDialogRef<ContentNodeSelectorComponent> {\n        return this.dialog.open(ContentNodeSelectorComponent, {\n            data,\n            panelClass,\n            width,\n            disableClose: true\n        });\n    }\n\n    private imageResolver(row: ShareDataRow): string | null {\n        const entry: Node = row.node.entry;\n        if (!this.contentService.hasAllowableOperations(entry, 'create')) {\n            if (this.isNodeFolder(entry)) {\n                return this.thumbnailService.getMimeTypeIcon('disable/folder');\n            }\n        }\n\n        return null;\n    }\n\n    private hasAllowableOperationsOnNodeFolder(entry: Node): boolean {\n        return this.isNodeFolder(entry) && this.contentService.hasAllowableOperations(entry, 'create');\n    }\n\n    private isNodeFolder(entry: Node): boolean {\n        return entry.isFolder;\n    }\n\n    private isCopyMoveSelectionValid(entry: Node): boolean {\n        return this.hasEntityCreatePermission(entry) && !this.isSite(entry);\n    }\n\n    private hasEntityCreatePermission(entry: Node): boolean {\n        return this.contentService.hasAllowableOperations(entry, 'create');\n    }\n\n    private isSite(entry) {\n        return !!entry.guid || entry.nodeType === 'st:site' || entry.nodeType === 'st:sites';\n    }\n}\n"]}