@alfresco/adf-content-services 8.1.0-15488125964 → 8.1.0-15490395570

package/esm2022/lib/document-list/services/custom-resources.service.mjs

@@ -0,0 +1,377 @@
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { SiteMemberPaging, PeopleApi, SitesApi, SearchApi, FavoritesApi, SharedlinksApi, TrashcanApi, NodesApi, SEARCH_LANGUAGE } from '@alfresco/js-api';
+import { Injectable } from '@angular/core';
+import { Observable, from, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/alfresco-api.service";
+const CREATE_PERMISSION = 'create';
+export class CustomResourcesService {
+    get peopleApi() {
+        this._peopleApi = this._peopleApi ?? new PeopleApi(this.apiService.getInstance());
+        return this._peopleApi;
+    }
+    get sitesApi() {
+        this._sitesApi = this._sitesApi ?? new SitesApi(this.apiService.getInstance());
+        return this._sitesApi;
+    }
+    get trashcanApi() {
+        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.apiService.getInstance());
+        return this._trashcanApi;
+    }
+    get searchApi() {
+        this._searchApi = this._searchApi ?? new SearchApi(this.apiService.getInstance());
+        return this._searchApi;
+    }
+    get sharedLinksApi() {
+        this._sharedLinksApi = this._sharedLinksApi ?? new SharedlinksApi(this.apiService.getInstance());
+        return this._sharedLinksApi;
+    }
+    get favoritesApi() {
+        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.apiService.getInstance());
+        return this._favoritesApi;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
+        return this._nodesApi;
+    }
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    /**
+     * Gets files recently accessed by a user.
+     *
+     * @param personId ID of the user
+     * @param pagination Specifies how to paginate the results
+     * @param filters Specifies additional filters to apply (joined with **AND**)
+     * @returns List of nodes for the recently used files
+     */
+    getRecentFiles(personId, pagination, filters) {
+        const defaultFilter = [
+            'TYPE:"content"',
+            '-PATH:"//cm:wiki/*"',
+            '-TYPE:"app:filelink"',
+            '-TYPE:"cm:thumbnail"',
+            '-TYPE:"cm:failedThumbnail"',
+            '-TYPE:"cm:rating"',
+            '-TYPE:"dl:dataList"',
+            '-TYPE:"dl:todoList"',
+            '-TYPE:"dl:issue"',
+            '-TYPE:"dl:contact"',
+            '-TYPE:"dl:eventAgenda"',
+            '-TYPE:"dl:event"',
+            '-TYPE:"dl:task"',
+            '-TYPE:"dl:simpletask"',
+            '-TYPE:"dl:meetingAgenda"',
+            '-TYPE:"dl:location"',
+            '-TYPE:"fm:topic"',
+            '-TYPE:"fm:post"',
+            '-TYPE:"ia:calendarEvent"',
+            '-TYPE:"lnk:link"'
+        ];
+        return new Observable((observer) => {
+            this.peopleApi.getPerson(personId).then((person) => {
+                const username = person.entry.id;
+                const filterQueries = [
+                    { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },
+                    { query: `cm:modifier:'${username}' OR cm:creator:'${username}'` },
+                    { query: defaultFilter.join(' AND ') }
+                ];
+                if (filters && filters.length > 0) {
+                    filterQueries.push({
+                        query: filters.join()
+                    });
+                }
+                const query = {
+                    query: {
+                        query: '*',
+                        language: SEARCH_LANGUAGE.AFTS
+                    },
+                    filterQueries,
+                    include: ['path', 'properties', 'allowableOperations', 'aspectNames'],
+                    sort: [
+                        {
+                            type: 'FIELD',
+                            field: 'cm:modified',
+                            ascending: false
+                        }
+                    ],
+                    paging: {
+                        maxItems: pagination.maxItems,
+                        skipCount: pagination.skipCount
+                    }
+                };
+                return this.searchApi.search(query).then((searchResult) => {
+                    observer.next(searchResult);
+                    observer.complete();
+                }, (err) => {
+                    observer.error(err);
+                    observer.complete();
+                });
+            }, (err) => {
+                observer.error(err);
+                observer.complete();
+            });
+        });
+    }
+    /**
+     * Gets favorite files for the current user.
+     *
+     * @param pagination Specifies how to paginate the results
+     * @param includeFields List of data field names to include in the results
+     * @param where A string to restrict the returned objects by using a predicate
+     * @returns List of favorite files
+     */
+    loadFavorites(pagination, includeFields = [], where) {
+        const includeFieldsRequest = this.getIncludesFields(includeFields);
+        const defaultPredicate = '(EXISTS(target/file) OR EXISTS(target/folder))';
+        const options = {
+            maxItems: pagination.maxItems,
+            skipCount: pagination.skipCount,
+            where: where ? `${where} AND ${defaultPredicate}` : defaultPredicate,
+            include: includeFieldsRequest
+        };
+        return new Observable((observer) => {
+            this.favoritesApi.listFavorites('-me-', options).then((result) => {
+                const page = {
+                    list: {
+                        entries: result.list.entries.map(({ entry }) => {
+                            const target = entry.target.file || entry.target.folder;
+                            target.properties = {
+                                ...(target.properties || {
+                                    'cm:title': entry.title || target.title,
+                                    'cm:description': entry.description || target.description
+                                }),
+                                ...(entry.properties || {})
+                            };
+                            target.aspectNames = entry?.aspectNames ?? [];
+                            target.allowableOperations = entry?.allowableOperations ?? [];
+                            return {
+                                entry: target
+                            };
+                        }),
+                        pagination: result.list.pagination
+                    }
+                };
+                observer.next(page);
+                observer.complete();
+            }, (err) => {
+                observer.error(err);
+                observer.complete();
+            });
+        });
+    }
+    /**
+     * Gets sites that the current user is a member of.
+     *
+     * @param pagination Specifies how to paginate the results
+     * @param where A string to restrict the returned objects by using a predicate
+     * @returns List of sites
+     */
+    loadMemberSites(pagination, where) {
+        const options = {
+            include: ['properties'],
+            maxItems: pagination.maxItems,
+            skipCount: pagination.skipCount,
+            where
+        };
+        return new Observable((observer) => {
+            this.sitesApi.listSiteMembershipsForPerson('-me-', options).then((result) => {
+                const page = new SiteMemberPaging({
+                    list: {
+                        entries: result.list.entries.map(({ entry: { site } }) => {
+                            site.allowableOperations = site.allowableOperations ? site.allowableOperations : [CREATE_PERMISSION];
+                            site.name = site.name || site.title;
+                            return {
+                                entry: site
+                            };
+                        }),
+                        pagination: result.list.pagination
+                    }
+                });
+                observer.next(page);
+                observer.complete();
+            }, (err) => {
+                observer.error(err);
+                observer.complete();
+            });
+        });
+    }
+    /**
+     * Gets all sites in the repository.
+     *
+     * @param pagination Specifies how to paginate the results
+     * @param where A string to restrict the returned objects by using a predicate
+     * @returns List of sites
+     */
+    loadSites(pagination, where) {
+        const options = {
+            include: ['properties', 'aspectNames'],
+            maxItems: pagination.maxItems,
+            skipCount: pagination.skipCount,
+            where
+        };
+        return new Observable((observer) => {
+            this.sitesApi.listSites(options).then((page) => {
+                page.list.entries.map(({ entry }) => {
+                    entry.name = entry.name || entry.title;
+                    return { entry };
+                });
+                observer.next(page);
+                observer.complete();
+            }, (err) => {
+                observer.error(err);
+                observer.complete();
+            });
+        });
+    }
+    /**
+     * Gets all items currently in the trash.
+     *
+     * @param pagination Specifies how to paginate the results
+     * @param includeFields List of data field names to include in the results
+     * @returns List of deleted items
+     */
+    loadTrashcan(pagination, includeFields = []) {
+        const includeFieldsRequest = this.getIncludesFields(includeFields);
+        const options = {
+            include: includeFieldsRequest,
+            maxItems: pagination.maxItems,
+            skipCount: pagination.skipCount
+        };
+        return from(this.trashcanApi.listDeletedNodes(options));
+    }
+    /**
+     * Gets shared links for the current user.
+     *
+     * @param pagination Specifies how to paginate the results
+     * @param includeFields List of data field names to include in the results
+     * @param where A string to restrict the returned objects by using a predicate
+     * @returns List of shared links
+     */
+    loadSharedLinks(pagination, includeFields = [], where) {
+        const includeFieldsRequest = this.getIncludesFields(includeFields);
+        const options = {
+            include: includeFieldsRequest,
+            maxItems: pagination.maxItems,
+            skipCount: pagination.skipCount,
+            where
+        };
+        return from(this.sharedLinksApi.listSharedLinks(options));
+    }
+    /**
+     * Is the folder ID one of the well-known aliases?
+     *
+     * @param folderId Folder ID name to check
+     * @returns True if the ID is a well-known name, false otherwise
+     */
+    isCustomSource(folderId) {
+        let isCustomSources = false;
+        const sources = ['-trashcan-', '-sharedlinks-', '-sites-', '-mysites-', '-favorites-', '-recent-'];
+        if (sources.indexOf(folderId) > -1) {
+            isCustomSources = true;
+        }
+        return isCustomSources;
+    }
+    /**
+     * Is the folder ID a "-my", "-root-", or "-shared-" alias?
+     *
+     * @param folderId Folder ID name to check
+     * @returns True if the ID is one of the supported sources, false otherwise
+     */
+    isSupportedSource(folderId) {
+        let isSupportedSources = false;
+        const sources = ['-my-', '-root-', '-shared-'];
+        if (sources.indexOf(folderId) > -1) {
+            isSupportedSources = true;
+        }
+        return isSupportedSources;
+    }
+    /**
+     * Gets a folder's contents.
+     *
+     * @param nodeId ID of the target folder node
+     * @param pagination Specifies how to paginate the results
+     * @param includeFields List of data field names to include in the results
+     * @param where  Filters the Node list using the *where* condition of the REST API (for example, isFolder=true). See the REST API documentation for more information.
+     * @returns List of items contained in the folder
+     */
+    loadFolderByNodeId(nodeId, pagination, includeFields = [], where) {
+        if (nodeId === '-trashcan-') {
+            return this.loadTrashcan(pagination, includeFields);
+        }
+        else if (nodeId === '-sharedlinks-') {
+            return this.loadSharedLinks(pagination, includeFields, where);
+        }
+        else if (nodeId === '-sites-') {
+            return this.loadSites(pagination, where);
+        }
+        else if (nodeId === '-mysites-') {
+            return this.loadMemberSites(pagination, where);
+        }
+        else if (nodeId === '-favorites-') {
+            return this.loadFavorites(pagination, includeFields, where);
+        }
+        else if (nodeId === '-recent-') {
+            return this.getRecentFiles('-me-', pagination);
+        }
+    }
+    // TODO: remove it from here
+    /**
+     * Gets the contents of one of the well-known aliases in the form of node ID strings.
+     *
+     * @param nodeId ID of the target folder node
+     * @param pagination Specifies how to paginate the results
+     * @returns List of node IDs
+     */
+    getCorrespondingNodeIds(nodeId, pagination = {}) {
+        if (this.isCustomSource(nodeId)) {
+            return this.loadFolderByNodeId(nodeId, pagination).pipe(map((result) => result.list.entries.map((node) => this.getIdFromEntry(node, nodeId))));
+        }
+        else if (nodeId) {
+            // cases when nodeId is '-my-', '-root-' or '-shared-'
+            return from(this.nodesApi.getNode(nodeId).then((node) => [node.entry.id]));
+        }
+        return of([]);
+    }
+    /**
+     * Chooses the correct ID for a node entry.
+     *
+     * @param node Node object
+     * @param nodeId ID of the node object
+     * @returns ID value
+     */
+    getIdFromEntry(node, nodeId) {
+        if (nodeId === '-sharedlinks-') {
+            return node.entry.nodeId;
+        }
+        else if (nodeId === '-sites-' || nodeId === '-mysites-') {
+            return node.entry.guid;
+        }
+        else if (nodeId === '-favorites-') {
+            return node.entry.targetGuid;
+        }
+        else {
+            return node.entry.id;
+        }
+    }
+    /**
+     * Does the well-known alias have a corresponding node ID?
+     *
+     * @param nodeId Node to check
+     * @returns True if the alias has a corresponding node ID, false otherwise
+     */
+    hasCorrespondingNodeIds(nodeId) {
+        return this.isCustomSource(nodeId) || this.isSupportedSource(nodeId);
+    }
+    getIncludesFields(includeFields) {
+        return ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter((element, index, array) => index === array.indexOf(element));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomResourcesService, deps: [{ token: i1.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomResourcesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomResourcesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.AlfrescoApiService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-resources.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/services/custom-resources.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 { PaginationModel } from '@alfresco/adf-core';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport {\n    DeletedNodesPaging,\n    SearchRequest,\n    SharedLinkPaging,\n    FavoritePaging,\n    SiteMemberPaging,\n    SiteRolePaging,\n    PeopleApi,\n    SitesApi,\n    SearchApi,\n    FavoritesApi,\n    SharedlinksApi,\n    TrashcanApi,\n    NodesApi,\n    SitePaging,\n    ResultSetPaging,\n    SEARCH_LANGUAGE\n} from '@alfresco/js-api';\nimport { Injectable } from '@angular/core';\nimport { Observable, from, of } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nconst CREATE_PERMISSION: string = 'create';\n\n@Injectable({ providedIn: 'root' })\nexport class CustomResourcesService {\n    private _peopleApi: PeopleApi;\n    get peopleApi(): PeopleApi {\n        this._peopleApi = this._peopleApi ?? new PeopleApi(this.apiService.getInstance());\n        return this._peopleApi;\n    }\n\n    private _sitesApi: SitesApi;\n    get sitesApi(): SitesApi {\n        this._sitesApi = this._sitesApi ?? new SitesApi(this.apiService.getInstance());\n        return this._sitesApi;\n    }\n\n    private _trashcanApi: TrashcanApi;\n    get trashcanApi(): TrashcanApi {\n        this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.apiService.getInstance());\n        return this._trashcanApi;\n    }\n\n    private _searchApi: SearchApi;\n    get searchApi(): SearchApi {\n        this._searchApi = this._searchApi ?? new SearchApi(this.apiService.getInstance());\n        return this._searchApi;\n    }\n\n    private _sharedLinksApi: SharedlinksApi;\n    get sharedLinksApi(): SharedlinksApi {\n        this._sharedLinksApi = this._sharedLinksApi ?? new SharedlinksApi(this.apiService.getInstance());\n        return this._sharedLinksApi;\n    }\n\n    private _favoritesApi: FavoritesApi;\n    get favoritesApi(): FavoritesApi {\n        this._favoritesApi = this._favoritesApi ?? new FavoritesApi(this.apiService.getInstance());\n        return this._favoritesApi;\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    constructor(private apiService: AlfrescoApiService) {}\n\n    /**\n     * Gets files recently accessed by a user.\n     *\n     * @param personId ID of the user\n     * @param pagination Specifies how to paginate the results\n     * @param filters Specifies additional filters to apply (joined with **AND**)\n     * @returns List of nodes for the recently used files\n     */\n    getRecentFiles(personId: string, pagination: PaginationModel, filters?: string[]): Observable<ResultSetPaging> {\n        const defaultFilter = [\n            'TYPE:\"content\"',\n            '-PATH:\"//cm:wiki/*\"',\n            '-TYPE:\"app:filelink\"',\n            '-TYPE:\"cm:thumbnail\"',\n            '-TYPE:\"cm:failedThumbnail\"',\n            '-TYPE:\"cm:rating\"',\n            '-TYPE:\"dl:dataList\"',\n            '-TYPE:\"dl:todoList\"',\n            '-TYPE:\"dl:issue\"',\n            '-TYPE:\"dl:contact\"',\n            '-TYPE:\"dl:eventAgenda\"',\n            '-TYPE:\"dl:event\"',\n            '-TYPE:\"dl:task\"',\n            '-TYPE:\"dl:simpletask\"',\n            '-TYPE:\"dl:meetingAgenda\"',\n            '-TYPE:\"dl:location\"',\n            '-TYPE:\"fm:topic\"',\n            '-TYPE:\"fm:post\"',\n            '-TYPE:\"ia:calendarEvent\"',\n            '-TYPE:\"lnk:link\"'\n        ];\n\n        return new Observable((observer) => {\n            this.peopleApi.getPerson(personId).then(\n                (person) => {\n                    const username = person.entry.id;\n                    const filterQueries = [\n                        { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },\n                        { query: `cm:modifier:'${username}' OR cm:creator:'${username}'` },\n                        { query: defaultFilter.join(' AND ') }\n                    ];\n\n                    if (filters && filters.length > 0) {\n                        filterQueries.push({\n                            query: filters.join()\n                        });\n                    }\n\n                    const query: SearchRequest = {\n                        query: {\n                            query: '*',\n                            language: SEARCH_LANGUAGE.AFTS\n                        },\n                        filterQueries,\n                        include: ['path', 'properties', 'allowableOperations', 'aspectNames'],\n                        sort: [\n                            {\n                                type: 'FIELD',\n                                field: 'cm:modified',\n                                ascending: false\n                            }\n                        ],\n                        paging: {\n                            maxItems: pagination.maxItems,\n                            skipCount: pagination.skipCount\n                        }\n                    };\n\n                    return this.searchApi.search(query).then(\n                        (searchResult) => {\n                            observer.next(searchResult);\n                            observer.complete();\n                        },\n                        (err) => {\n                            observer.error(err);\n                            observer.complete();\n                        }\n                    );\n                },\n                (err) => {\n                    observer.error(err);\n                    observer.complete();\n                }\n            );\n        });\n    }\n\n    /**\n     * Gets favorite files for the current user.\n     *\n     * @param pagination Specifies how to paginate the results\n     * @param includeFields List of data field names to include in the results\n     * @param where A string to restrict the returned objects by using a predicate\n     * @returns List of favorite files\n     */\n    loadFavorites(pagination: PaginationModel, includeFields: string[] = [], where?: string): Observable<FavoritePaging> {\n        const includeFieldsRequest = this.getIncludesFields(includeFields);\n        const defaultPredicate = '(EXISTS(target/file) OR EXISTS(target/folder))';\n\n        const options = {\n            maxItems: pagination.maxItems,\n            skipCount: pagination.skipCount,\n            where: where ? `${where} AND ${defaultPredicate}` : defaultPredicate,\n            include: includeFieldsRequest\n        };\n\n        return new Observable((observer) => {\n            this.favoritesApi.listFavorites('-me-', options).then(\n                (result) => {\n                    const page: FavoritePaging = {\n                        list: {\n                            entries: result.list.entries.map(({ entry }: any) => {\n                                const target = entry.target.file || entry.target.folder;\n                                target.properties = {\n                                    ...(target.properties || {\n                                        'cm:title': entry.title || target.title,\n                                        'cm:description': entry.description || target.description\n                                    }),\n                                    ...(entry.properties || {})\n                                };\n                                target.aspectNames = entry?.aspectNames ?? [];\n                                target.allowableOperations = entry?.allowableOperations ?? [];\n\n                                return {\n                                    entry: target\n                                };\n                            }),\n                            pagination: result.list.pagination\n                        }\n                    };\n\n                    observer.next(page);\n                    observer.complete();\n                },\n                (err) => {\n                    observer.error(err);\n                    observer.complete();\n                }\n            );\n        });\n    }\n\n    /**\n     * Gets sites that the current user is a member of.\n     *\n     * @param pagination Specifies how to paginate the results\n     * @param where A string to restrict the returned objects by using a predicate\n     * @returns List of sites\n     */\n    loadMemberSites(pagination: PaginationModel, where?: string): Observable<SiteMemberPaging> {\n        const options = {\n            include: ['properties'],\n            maxItems: pagination.maxItems,\n            skipCount: pagination.skipCount,\n            where\n        };\n\n        return new Observable((observer) => {\n            this.sitesApi.listSiteMembershipsForPerson('-me-', options).then(\n                (result: SiteRolePaging) => {\n                    const page: SiteMemberPaging = new SiteMemberPaging({\n                        list: {\n                            entries: result.list.entries.map(({ entry: { site } }: any) => {\n                                site.allowableOperations = site.allowableOperations ? site.allowableOperations : [CREATE_PERMISSION];\n                                site.name = site.name || site.title;\n                                return {\n                                    entry: site\n                                };\n                            }),\n                            pagination: result.list.pagination\n                        }\n                    });\n\n                    observer.next(page);\n                    observer.complete();\n                },\n                (err) => {\n                    observer.error(err);\n                    observer.complete();\n                }\n            );\n        });\n    }\n\n    /**\n     * Gets all sites in the repository.\n     *\n     * @param pagination Specifies how to paginate the results\n     * @param where A string to restrict the returned objects by using a predicate\n     * @returns List of sites\n     */\n    loadSites(pagination: PaginationModel, where?: string): Observable<SitePaging> {\n        const options = {\n            include: ['properties', 'aspectNames'],\n            maxItems: pagination.maxItems,\n            skipCount: pagination.skipCount,\n            where\n        };\n\n        return new Observable((observer) => {\n            this.sitesApi.listSites(options).then(\n                (page) => {\n                    page.list.entries.map(({ entry }: any) => {\n                        entry.name = entry.name || entry.title;\n                        return { entry };\n                    });\n                    observer.next(page);\n                    observer.complete();\n                },\n                (err) => {\n                    observer.error(err);\n                    observer.complete();\n                }\n            );\n        });\n    }\n\n    /**\n     * Gets all items currently in the trash.\n     *\n     * @param pagination Specifies how to paginate the results\n     * @param includeFields List of data field names to include in the results\n     * @returns List of deleted items\n     */\n    loadTrashcan(pagination: PaginationModel, includeFields: string[] = []): Observable<DeletedNodesPaging> {\n        const includeFieldsRequest = this.getIncludesFields(includeFields);\n\n        const options = {\n            include: includeFieldsRequest,\n            maxItems: pagination.maxItems,\n            skipCount: pagination.skipCount\n        };\n\n        return from(this.trashcanApi.listDeletedNodes(options));\n    }\n\n    /**\n     * Gets shared links for the current user.\n     *\n     * @param pagination Specifies how to paginate the results\n     * @param includeFields List of data field names to include in the results\n     * @param where A string to restrict the returned objects by using a predicate\n     * @returns List of shared links\n     */\n    loadSharedLinks(pagination: PaginationModel, includeFields: string[] = [], where?: string): Observable<SharedLinkPaging> {\n        const includeFieldsRequest = this.getIncludesFields(includeFields);\n\n        const options = {\n            include: includeFieldsRequest,\n            maxItems: pagination.maxItems,\n            skipCount: pagination.skipCount,\n            where\n        };\n\n        return from(this.sharedLinksApi.listSharedLinks(options));\n    }\n\n    /**\n     * Is the folder ID one of the well-known aliases?\n     *\n     * @param folderId Folder ID name to check\n     * @returns True if the ID is a well-known name, false otherwise\n     */\n    isCustomSource(folderId: string): boolean {\n        let isCustomSources = false;\n        const sources = ['-trashcan-', '-sharedlinks-', '-sites-', '-mysites-', '-favorites-', '-recent-'];\n\n        if (sources.indexOf(folderId) > -1) {\n            isCustomSources = true;\n        }\n\n        return isCustomSources;\n    }\n\n    /**\n     * Is the folder ID a \"-my\", \"-root-\", or \"-shared-\" alias?\n     *\n     * @param folderId Folder ID name to check\n     * @returns True if the ID is one of the supported sources, false otherwise\n     */\n    isSupportedSource(folderId: string): boolean {\n        let isSupportedSources = false;\n        const sources = ['-my-', '-root-', '-shared-'];\n\n        if (sources.indexOf(folderId) > -1) {\n            isSupportedSources = true;\n        }\n\n        return isSupportedSources;\n    }\n\n    /**\n     * Gets a folder's contents.\n     *\n     * @param nodeId ID of the target folder node\n     * @param pagination Specifies how to paginate the results\n     * @param includeFields List of data field names to include in the results\n     * @param where  Filters the Node list using the *where* condition of the REST API (for example, isFolder=true). See the REST API documentation for more information.\n     * @returns List of items contained in the folder\n     */\n    loadFolderByNodeId(nodeId: string, pagination: PaginationModel, includeFields: string[] = [], where?: string): any {\n        if (nodeId === '-trashcan-') {\n            return this.loadTrashcan(pagination, includeFields);\n        } else if (nodeId === '-sharedlinks-') {\n            return this.loadSharedLinks(pagination, includeFields, where);\n        } else if (nodeId === '-sites-') {\n            return this.loadSites(pagination, where);\n        } else if (nodeId === '-mysites-') {\n            return this.loadMemberSites(pagination, where);\n        } else if (nodeId === '-favorites-') {\n            return this.loadFavorites(pagination, includeFields, where);\n        } else if (nodeId === '-recent-') {\n            return this.getRecentFiles('-me-', pagination);\n        }\n    }\n\n    // TODO: remove it from here\n\n    /**\n     * Gets the contents of one of the well-known aliases in the form of node ID strings.\n     *\n     * @param nodeId ID of the target folder node\n     * @param pagination Specifies how to paginate the results\n     * @returns List of node IDs\n     */\n    getCorrespondingNodeIds(nodeId: string, pagination: PaginationModel = {}): Observable<string[]> {\n        if (this.isCustomSource(nodeId)) {\n            return this.loadFolderByNodeId(nodeId, pagination).pipe(\n                map((result: any): string[] => result.list.entries.map((node: any): string => this.getIdFromEntry(node, nodeId)))\n            );\n        } else if (nodeId) {\n            // cases when nodeId is '-my-', '-root-' or '-shared-'\n            return from(this.nodesApi.getNode(nodeId).then((node) => [node.entry.id]));\n        }\n\n        return of([]);\n    }\n\n    /**\n     * Chooses the correct ID for a node entry.\n     *\n     * @param node Node object\n     * @param nodeId ID of the node object\n     * @returns ID value\n     */\n    getIdFromEntry(node: any, nodeId: string): string {\n        if (nodeId === '-sharedlinks-') {\n            return node.entry.nodeId;\n        } else if (nodeId === '-sites-' || nodeId === '-mysites-') {\n            return node.entry.guid;\n        } else if (nodeId === '-favorites-') {\n            return node.entry.targetGuid;\n        } else {\n            return node.entry.id;\n        }\n    }\n\n    /**\n     * Does the well-known alias have a corresponding node ID?\n     *\n     * @param nodeId Node to check\n     * @returns True if the alias has a corresponding node ID, false otherwise\n     */\n    hasCorrespondingNodeIds(nodeId: string): boolean {\n        return this.isCustomSource(nodeId) || this.isSupportedSource(nodeId);\n    }\n\n    private getIncludesFields(includeFields: string[]): string[] {\n        return ['path', 'properties', 'allowableOperations', 'permissions', 'aspectNames', ...includeFields].filter(\n            (element, index, array) => index === array.indexOf(element)\n        );\n    }\n}\n"]}

package/esm2022/lib/document-list/services/document-actions.service.mjs

@@ -0,0 +1,142 @@
+/*!
+ * @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 { ContentService } from '../../common/services/content.service';
+import { Injectable } from '@angular/core';
+import { Subject, throwError, of } from 'rxjs';
+import { PermissionModel } from '../models/permissions.model';
+import { DocumentListService } from './document-list.service';
+import { NodeActionsService } from './node-actions.service';
+import { ContentNodeDialogService } from '../../content-node-selector/content-node-dialog.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./node-actions.service";
+import * as i2 from "../../content-node-selector/content-node-dialog.service";
+import * as i3 from "@alfresco/adf-core";
+import * as i4 from "./document-list.service";
+import * as i5 from "../../common/services/content.service";
+export class DocumentActionsService {
+    constructor(nodeActionsService, contentNodeDialogService, translation, documentListService, contentService) {
+        this.nodeActionsService = nodeActionsService;
+        this.contentNodeDialogService = contentNodeDialogService;
+        this.translation = translation;
+        this.documentListService = documentListService;
+        this.contentService = contentService;
+        this.permissionEvent = new Subject();
+        this.error = new Subject();
+        this.success = new Subject();
+        this.handlers = {};
+        this.setupActionHandlers();
+    }
+    /**
+     * Gets the handler for an action.
+     *
+     * @param key Identifier of the action
+     * @returns The handler for the action
+     */
+    getHandler(key) {
+        if (key) {
+            const lKey = key.toLowerCase();
+            return this.handlers[lKey] || null;
+        }
+        return null;
+    }
+    /**
+     * Sets a new handler for an action.
+     *
+     * @param key Identifier of the action
+     * @param handler Handler for the action
+     * @returns False if the key was an empty/null string, true otherwise
+     */
+    setHandler(key, handler) {
+        if (key) {
+            const lKey = key.toLowerCase();
+            this.handlers[lKey] = handler;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if actions can be executed for an item.
+     *
+     * @param nodeEntry Item to receive an action
+     * @returns True if the action can be executed on this item, false otherwise
+     */
+    canExecuteAction(nodeEntry) {
+        return this.documentListService && nodeEntry && nodeEntry.entry.isFile === true;
+    }
+    setupActionHandlers() {
+        this.handlers['copy'] = this.copyNode.bind(this);
+        this.handlers['move'] = this.moveNode.bind(this);
+        this.handlers['delete'] = this.deleteNode.bind(this);
+        this.handlers['download'] = this.downloadNode.bind(this);
+        this.handlers['lock'] = this.lockNode.bind(this);
+    }
+    lockNode(node) {
+        return this.contentNodeDialogService.openLockNodeDialog(node.entry);
+    }
+    downloadNode(obj) {
+        this.nodeActionsService.downloadNode(obj);
+    }
+    copyNode(node, _target, permission) {
+        const actionObservable = this.nodeActionsService.copyContent(node.entry, permission);
+        this.prepareHandlers(actionObservable);
+        return actionObservable;
+    }
+    moveNode(node, _target, permission) {
+        const actionObservable = this.nodeActionsService.moveContent(node.entry, permission);
+        this.prepareHandlers(actionObservable);
+        return actionObservable;
+    }
+    prepareHandlers(actionObservable) {
+        actionObservable.subscribe((fileOperationMessage) => {
+            this.success.next(fileOperationMessage);
+        }, this.error.next.bind(this.error));
+    }
+    deleteNode(node, _target, permission) {
+        if (this.canExecuteAction(node)) {
+            if (this.contentService.hasAllowableOperations(node.entry, permission)) {
+                const handlerObservable = this.documentListService.deleteNode(node.entry.id);
+                handlerObservable.subscribe(() => {
+                    const message = this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: node.entry.name });
+                    this.success.next(message);
+                }, () => {
+                    const message = this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: node.entry.name });
+                    this.error.next(message);
+                });
+                return handlerObservable;
+            }
+            else {
+                this.permissionEvent.next(new PermissionModel({
+                    type: 'content',
+                    action: 'delete',
+                    permission
+                }));
+                return throwError(new Error('No permission to delete'));
+            }
+        }
+        return of();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentActionsService, deps: [{ token: i1.NodeActionsService }, { token: i2.ContentNodeDialogService }, { token: i3.TranslationService }, { token: i4.DocumentListService }, { token: i5.ContentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentActionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentActionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.NodeActionsService }, { type: i2.ContentNodeDialogService }, { type: i3.TranslationService }, { type: i4.DocumentListService }, { type: i5.ContentService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-actions.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/services/document-actions.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 { TranslationService } from '@alfresco/adf-core';\nimport { ContentService } from '../../common/services/content.service';\nimport { Injectable } from '@angular/core';\nimport { NodeEntry } from '@alfresco/js-api';\nimport { Observable, Subject, throwError, of } from 'rxjs';\nimport { ContentActionHandler } from '../models/content-action.model';\nimport { PermissionModel } from '../models/permissions.model';\nimport { DocumentListService } from './document-list.service';\nimport { NodeActionsService } from './node-actions.service';\nimport { ContentNodeDialogService } from '../../content-node-selector/content-node-dialog.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class DocumentActionsService {\n    permissionEvent = new Subject<PermissionModel>();\n    error = new Subject<Error>();\n    success = new Subject<string>();\n\n    private handlers: { [id: string]: ContentActionHandler } = {};\n\n    constructor(\n        private nodeActionsService: NodeActionsService,\n        private contentNodeDialogService: ContentNodeDialogService,\n        private translation: TranslationService,\n        private documentListService?: DocumentListService,\n        private contentService?: ContentService\n    ) {\n        this.setupActionHandlers();\n    }\n\n    /**\n     * Gets the handler for an action.\n     *\n     * @param key Identifier of the action\n     * @returns The handler for the action\n     */\n    getHandler(key: string): ContentActionHandler {\n        if (key) {\n            const lKey = key.toLowerCase();\n            return this.handlers[lKey] || null;\n        }\n        return null;\n    }\n\n    /**\n     * Sets a new handler for an action.\n     *\n     * @param key Identifier of the action\n     * @param handler Handler for the action\n     * @returns False if the key was an empty/null string, true otherwise\n     */\n    setHandler(key: string, handler: ContentActionHandler): boolean {\n        if (key) {\n            const lKey = key.toLowerCase();\n            this.handlers[lKey] = handler;\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Checks if actions can be executed for an item.\n     *\n     * @param nodeEntry Item to receive an action\n     * @returns True if the action can be executed on this item, false otherwise\n     */\n    canExecuteAction(nodeEntry: NodeEntry): boolean {\n        return this.documentListService && nodeEntry && nodeEntry.entry.isFile === true;\n    }\n\n    private setupActionHandlers() {\n        this.handlers['copy'] = this.copyNode.bind(this);\n        this.handlers['move'] = this.moveNode.bind(this);\n        this.handlers['delete'] = this.deleteNode.bind(this);\n        this.handlers['download'] = this.downloadNode.bind(this);\n        this.handlers['lock'] = this.lockNode.bind(this);\n    }\n\n    private lockNode(node: NodeEntry) {\n        return this.contentNodeDialogService.openLockNodeDialog(node.entry);\n    }\n\n    private downloadNode(obj: NodeEntry) {\n        this.nodeActionsService.downloadNode(obj);\n    }\n\n    private copyNode(node: NodeEntry, _target?: any, permission?: string) {\n        const actionObservable = this.nodeActionsService.copyContent(node.entry, permission);\n        this.prepareHandlers(actionObservable);\n        return actionObservable;\n    }\n\n    private moveNode(node: NodeEntry, _target?: any, permission?: string) {\n        const actionObservable = this.nodeActionsService.moveContent(node.entry, permission);\n        this.prepareHandlers(actionObservable);\n        return actionObservable;\n    }\n\n    private prepareHandlers(actionObservable: Subject<string>): void {\n        actionObservable.subscribe((fileOperationMessage) => {\n            this.success.next(fileOperationMessage);\n        }, this.error.next.bind(this.error));\n    }\n\n    private deleteNode(node: NodeEntry, _target?: any, permission?: string): Observable<any> {\n        if (this.canExecuteAction(node)) {\n            if (this.contentService.hasAllowableOperations(node.entry, permission)) {\n                const handlerObservable = this.documentListService.deleteNode(node.entry.id);\n                handlerObservable.subscribe(\n                    () => {\n                        const message = this.translation.instant('CORE.DELETE_NODE.SINGULAR', { name: node.entry.name });\n                        this.success.next(message);\n                    },\n                    () => {\n                        const message = this.translation.instant('CORE.DELETE_NODE.ERROR_SINGULAR', { name: node.entry.name });\n                        this.error.next(message);\n                    }\n                );\n                return handlerObservable;\n            } else {\n                this.permissionEvent.next(\n                    new PermissionModel({\n                        type: 'content',\n                        action: 'delete',\n                        permission\n                    })\n                );\n                return throwError(new Error('No permission to delete'));\n            }\n        }\n\n        return of();\n    }\n}\n"]}