@alfresco/adf-content-services
Version:
Alfresco ADF content services
251 lines • 31.9 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 { UserPreferencesService } from '@alfresco/adf-core';
import { NodesApi, TrashcanApi } from '@alfresco/js-api';
import { Injectable } from '@angular/core';
import { from, Subject, throwError } from 'rxjs';
import { catchError, map } from 'rxjs/operators';
import { NodeMetadata } from '../models/node-metadata.model';
import { AlfrescoApiService } from '../../services/alfresco-api.service';
import * as i0 from "@angular/core";
import * as i1 from "../../services/alfresco-api.service";
import * as i2 from "@alfresco/adf-core";
export class NodesApiService {
get trashcanApi() {
this._trashcanApi = this._trashcanApi ?? new TrashcanApi(this.apiService.getInstance());
return this._trashcanApi;
}
get nodesApi() {
this._nodesApi = this._nodesApi ?? new NodesApi(this.apiService.getInstance());
return this._nodesApi;
}
constructor(apiService, preferences) {
this.apiService = apiService;
this.preferences = preferences;
/**
* Publish/subscribe to events related to node updates.
*/
this.nodeUpdated = new Subject();
}
getEntryFromEntity(entity) {
return entity.entry;
}
/**
* Gets the stored information about a node.
*
* @param nodeId ID of the target node
* @param options Optional parameters supported by JS-API
* @returns Node information
*/
getNode(nodeId, options = {}) {
const defaults = {
include: ['path', 'properties', 'allowableOperations', 'permissions']
};
const queryOptions = Object.assign(defaults, options);
return from(this.nodesApi.getNode(nodeId, queryOptions)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
}
/**
* Gets the items contained in a folder node.
*
* @param nodeId ID of the target node
* @param options Optional parameters supported by JS-API
* @returns List of child items from the folder
*/
getNodeChildren(nodeId, options = {}) {
const defaults = {
maxItems: this.preferences.paginationSize,
skipCount: 0,
include: ['path', 'properties', 'allowableOperations', 'permissions']
};
const queryOptions = Object.assign(defaults, options);
return from(this.nodesApi.listNodeChildren(nodeId, queryOptions)).pipe(catchError((err) => throwError(err)));
}
/**
* Creates a new document node inside a folder.
*
* @param parentNodeId ID of the parent folder node
* @param nodeBody Data for the new node
* @param options Optional parameters supported by JS-API
* @returns Details of the new node
*/
createNode(parentNodeId, nodeBody, options = {}) {
return from(this.nodesApi.createNode(parentNodeId, nodeBody, options)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
}
/**
* Creates a new folder node inside a parent folder.
*
* @param parentNodeId ID of the parent folder node
* @param nodeBody Data for the new folder
* @param options Optional parameters supported by JS-API
* @returns Details of the new folder
*/
createFolder(parentNodeId, nodeBody, options = {}) {
const body = Object.assign({ nodeType: 'cm:folder' }, nodeBody);
return this.createNode(parentNodeId, body, options);
}
/**
* Updates the information about a node.
*
* @param nodeId ID of the target node
* @param nodeBody New data for the node
* @param options Optional parameters supported by JS-API
* @returns Updated node information
*/
updateNode(nodeId, nodeBody, options = {}) {
const defaults = {
include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']
};
const queryOptions = Object.assign(defaults, options);
return from(this.nodesApi.updateNode(nodeId, nodeBody, queryOptions)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
}
/**
* Moves a node to the trashcan.
*
* @param nodeId ID of the target node
* @param options Optional parameters supported by JS-API
* @returns Empty result that notifies when the deletion is complete
*/
deleteNode(nodeId, options = {}) {
return from(this.nodesApi.deleteNode(nodeId, options)).pipe(catchError((err) => throwError(err)));
}
/**
* Restores a node previously moved to the trashcan.
*
* @param nodeId ID of the node to restore
* @returns Details of the restored node
*/
restoreNode(nodeId) {
return from(this.trashcanApi.restoreDeletedNode(nodeId)).pipe(map(this.getEntryFromEntity), catchError((err) => throwError(err)));
}
/**
* Get the metadata and the nodeType for a nodeId cleaned by the prefix.
*
* @param nodeId ID of the target node
* @returns Node metadata
*/
getNodeMetadata(nodeId) {
return from(this.nodesApi.getNode(nodeId)).pipe(map(this.cleanMetadataFromSemicolon));
}
/**
* Gets the list of holds assigned to the node.
*
* @param nodeId ID of the target node
* @param options Optional parameters supported by JS-API
* @param options.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**
* @returns List of assigned holds Observable<Hold[]>
*/
getNodeAssignedHolds(nodeId, options) {
const queryOptions = Object.assign({ where: `(assocType='rma:frozenContent')` }, options);
return from(this.nodesApi.listParents(nodeId, queryOptions)).pipe(map(({ list }) => list.entries?.map(({ entry }) => ({
id: entry.id,
name: entry.name
}))));
}
/**
* Gets content for the given node.
*
* @param nodeId ID of the target node
* @returns Content data
*/
getNodeContent(nodeId) {
return from(this.nodesApi.getNodeContent(nodeId)).pipe(catchError((err) => throwError(err)));
}
/**
* Create a new Node inside `-root-` folder
*
* @param name Node name
* @param nodeType Node type
* @param properties Node body properties
* @param path Path to the node
* @returns The created node
*/
createNodeInsideRoot(name, nodeType, properties, path) {
const body = {
name,
nodeType,
properties,
relativePath: path
};
return from(this.nodesApi.createNode('-root-', body, {}));
}
/**
* Create a new Node from form metadata.
*
* @param nodeType Node type
* @param nameSpace Namespace for properties
* @param data Property data to store in the node under namespace
* @param path Path to the node
* @param name Node name
* @returns The created node
*/
createNodeMetadata(nodeType, nameSpace, data, path, name) {
const properties = {};
for (const key in data) {
if (data[key]) {
properties[nameSpace + ':' + key] = data[key];
}
}
return this.createNodeInsideRoot(name || this.randomNodeName(), nodeType, properties, path);
}
/**
* Initiate a new request to calculate folder size.
*
* @param nodeId Node Id
* @returns The job id which can be used to track request status
*/
initiateFolderSizeCalculation(nodeId) {
return from(this.nodesApi.initiateFolderSizeCalculation(nodeId));
}
/**
* Gets the size of a folder.
*
* @param nodeId Node Id
* @param jobId Job Id
* @returns Folder details
*/
getFolderSizeInfo(nodeId, jobId) {
return from(this.nodesApi.getFolderSizeInfo(nodeId, jobId));
}
randomNodeName() {
return `node_${Date.now()}`;
}
cleanMetadataFromSemicolon(nodeEntry) {
const metadata = {};
if (nodeEntry?.entry.properties) {
for (const key in nodeEntry.entry.properties) {
if (key) {
if (key.indexOf(':') !== -1) {
metadata[key.split(':')[1]] = nodeEntry.entry.properties[key];
}
else {
metadata[key] = nodeEntry.entry.properties[key];
}
}
}
}
return new NodeMetadata(metadata, nodeEntry.entry.nodeType);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NodesApiService, deps: [{ token: i1.AlfrescoApiService }, { token: i2.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NodesApiService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: NodesApiService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.AlfrescoApiService }, { type: i2.UserPreferencesService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes-api.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/common/services/nodes-api.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 { UserPreferencesService } from '@alfresco/adf-core';\nimport {\n    ContentPagingQuery,\n    Node,\n    NodeAssignedHold,\n    NodeEntry,\n    NodePaging,\n    NodesApi,\n    NodesIncludeQuery,\n    TrashcanApi,\n    SizeDetailsEntry,\n    JobIdBodyEntry\n} from '@alfresco/js-api';\nimport { Injectable } from '@angular/core';\nimport { from, Observable, Subject, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { NodeMetadata } from '../models/node-metadata.model';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class NodesApiService {\n    /**\n     * Publish/subscribe to events related to node updates.\n     */\n    nodeUpdated = new Subject<Node>();\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 _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, private preferences: UserPreferencesService) {}\n\n    private getEntryFromEntity(entity: NodeEntry): Node {\n        return entity.entry;\n    }\n\n    /**\n     * Gets the stored information about a node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns Node information\n     */\n    getNode(nodeId: string, options: any = {}): Observable<Node> {\n        const defaults = {\n            include: ['path', 'properties', 'allowableOperations', 'permissions']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.getNode(nodeId, queryOptions)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Gets the items contained in a folder node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns List of child items from the folder\n     */\n    getNodeChildren(nodeId: string, options: any = {}): Observable<NodePaging> {\n        const defaults = {\n            maxItems: this.preferences.paginationSize,\n            skipCount: 0,\n            include: ['path', 'properties', 'allowableOperations', 'permissions']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.listNodeChildren(nodeId, queryOptions)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Creates a new document node inside a folder.\n     *\n     * @param parentNodeId ID of the parent folder node\n     * @param nodeBody Data for the new node\n     * @param options Optional parameters supported by JS-API\n     * @returns Details of the new node\n     */\n    createNode(parentNodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        return from(this.nodesApi.createNode(parentNodeId, nodeBody, options)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Creates a new folder node inside a parent folder.\n     *\n     * @param parentNodeId ID of the parent folder node\n     * @param nodeBody Data for the new folder\n     * @param options Optional parameters supported by JS-API\n     * @returns Details of the new folder\n     */\n    createFolder(parentNodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        const body = Object.assign({ nodeType: 'cm:folder' }, nodeBody);\n        return this.createNode(parentNodeId, body, options);\n    }\n\n    /**\n     * Updates the information about a node.\n     *\n     * @param nodeId ID of the target node\n     * @param nodeBody New data for the node\n     * @param options Optional parameters supported by JS-API\n     * @returns Updated node information\n     */\n    updateNode(nodeId: string, nodeBody: any, options: any = {}): Observable<Node> {\n        const defaults = {\n            include: ['path', 'properties', 'allowableOperations', 'permissions', 'definition']\n        };\n        const queryOptions = Object.assign(defaults, options);\n\n        return from(this.nodesApi.updateNode(nodeId, nodeBody, queryOptions)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Moves a node to the trashcan.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @returns Empty result that notifies when the deletion is complete\n     */\n    deleteNode(nodeId: string, options: any = {}): Observable<any> {\n        return from(this.nodesApi.deleteNode(nodeId, options)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Restores a node previously moved to the trashcan.\n     *\n     * @param nodeId ID of the node to restore\n     * @returns Details of the restored node\n     */\n    restoreNode(nodeId: string): Observable<Node> {\n        return from(this.trashcanApi.restoreDeletedNode(nodeId)).pipe(\n            map(this.getEntryFromEntity),\n            catchError((err) => throwError(err))\n        );\n    }\n\n    /**\n     * Get the metadata and the nodeType for a nodeId cleaned by the prefix.\n     *\n     * @param nodeId ID of the target node\n     * @returns Node metadata\n     */\n    getNodeMetadata(nodeId: string): Observable<NodeMetadata> {\n        return from(this.nodesApi.getNode(nodeId)).pipe(map(this.cleanMetadataFromSemicolon));\n    }\n\n    /**\n     * Gets the list of holds assigned to the node.\n     *\n     * @param nodeId ID of the target node\n     * @param options Optional parameters supported by JS-API\n     * @param options.includeSource Also include **source** (in addition to **entries**) with folder information on **nodeId**\n     * @returns List of assigned holds Observable<Hold[]>\n     */\n    getNodeAssignedHolds(\n        nodeId: string,\n        options?: {\n            includeSource?: boolean;\n        } & NodesIncludeQuery &\n            ContentPagingQuery\n    ): Observable<NodeAssignedHold[]> {\n        const queryOptions = Object.assign({ where: `(assocType='rma:frozenContent')` }, options);\n\n        return from(this.nodesApi.listParents(nodeId, queryOptions)).pipe(\n            map(({ list }) =>\n                list.entries?.map(({ entry }) => ({\n                    id: entry.id,\n                    name: entry.name\n                }))\n            )\n        );\n    }\n\n    /**\n     * Gets content for the given node.\n     *\n     * @param nodeId ID of the target node\n     * @returns Content data\n     */\n    getNodeContent(nodeId: string): Observable<any> {\n        return from(this.nodesApi.getNodeContent(nodeId)).pipe(catchError((err) => throwError(err)));\n    }\n\n    /**\n     * Create a new Node inside `-root-` folder\n     *\n     * @param name Node name\n     * @param nodeType Node type\n     * @param properties Node body properties\n     * @param path Path to the node\n     * @returns The created node\n     */\n    createNodeInsideRoot(name: string, nodeType: string, properties: any, path: string): Observable<NodeEntry> {\n        const body = {\n            name,\n            nodeType,\n            properties,\n            relativePath: path\n        };\n        return from(this.nodesApi.createNode('-root-', body, {}));\n    }\n\n    /**\n     * Create a new Node from form metadata.\n     *\n     * @param nodeType Node type\n     * @param nameSpace Namespace for properties\n     * @param data Property data to store in the node under namespace\n     * @param path Path to the node\n     * @param name Node name\n     * @returns The created node\n     */\n    createNodeMetadata(nodeType: string, nameSpace: any, data: any, path: string, name?: string): Observable<NodeEntry> {\n        const properties = {};\n        for (const key in data) {\n            if (data[key]) {\n                properties[nameSpace + ':' + key] = data[key];\n            }\n        }\n\n        return this.createNodeInsideRoot(name || this.randomNodeName(), nodeType, properties, path);\n    }\n\n    /**\n     * Initiate a new request to calculate folder size.\n     *\n     * @param nodeId Node Id\n     * @returns The job id which can be used to track request status\n     */\n    initiateFolderSizeCalculation(nodeId: string): Observable<JobIdBodyEntry> {\n        return from(this.nodesApi.initiateFolderSizeCalculation(nodeId));\n    }\n\n    /**\n     * Gets the size of a folder.\n     *\n     * @param nodeId Node Id\n     * @param jobId Job Id\n     * @returns Folder details\n     */\n    getFolderSizeInfo(nodeId: string, jobId: string): Observable<SizeDetailsEntry> {\n        return from(this.nodesApi.getFolderSizeInfo(nodeId, jobId));\n    }\n\n    private randomNodeName(): string {\n        return `node_${Date.now()}`;\n    }\n\n    private cleanMetadataFromSemicolon(nodeEntry: NodeEntry): NodeMetadata {\n        const metadata = {};\n\n        if (nodeEntry?.entry.properties) {\n            for (const key in nodeEntry.entry.properties) {\n                if (key) {\n                    if (key.indexOf(':') !== -1) {\n                        metadata[key.split(':')[1]] = nodeEntry.entry.properties[key];\n                    } else {\n                        metadata[key] = nodeEntry.entry.properties[key];\n                    }\n                }\n            }\n        }\n\n        return new NodeMetadata(metadata, nodeEntry.entry.nodeType);\n    }\n}\n"]}