@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/api/nodes-api.mjs

@@ -0,0 +1,427 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ApiClientFactory } from './api-client-factory';
+import { flattenNodeContentTree } from './node-content-tree';
+export class NodesApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new NodesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createFolder(name, parentId = '-my-', title = '', description = '', author = '', aspectNames = null) {
+        try {
+            return this.createNode('cm:folder', name, parentId, title, description, null, author, null, aspectNames);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFolder.name}`, error);
+            return null;
+        }
+    }
+    async createFile(name, parentId = '-my-', title = '', description = '', author = '', majorVersion = true, aspectNames = null) {
+        try {
+            return this.createNode('cm:content', name, parentId, title, description, null, author, majorVersion, aspectNames);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFile.name}`, error);
+            return null;
+        }
+    }
+    async createFiles(names, relativePath = '/') {
+        try {
+            return this.createContent({ files: names }, relativePath);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFiles.name}: ${error}`);
+            return null;
+        }
+    }
+    async createFolders(names, relativePath = '/') {
+        try {
+            return this.createContent({ folders: names }, relativePath);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFolders.name}: ${error}`);
+            return null;
+        }
+    }
+    async deleteDeletedNode(name) {
+        try {
+            await this.apiService.trashCan.deleteDeletedNode(name);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteDeletedNode.name}: ${error}`);
+        }
+    }
+    async createNode(nodeType, name, parentId = '-my-', title = '', description = '', imageProps = null, author = '', majorVersion = true, aspectNames = null) {
+        if (!aspectNames) {
+            aspectNames = ['cm:versionable']; // workaround for REPO-4772
+        }
+        const nodeBody = {
+            name,
+            nodeType,
+            relativePath: '/',
+            properties: {
+                'cm:title': title,
+                'cm:description': description,
+                'cm:author': author
+            },
+            aspectNames
+        };
+        if (imageProps) {
+            nodeBody.properties = Object.assign(nodeBody.properties, imageProps);
+        }
+        try {
+            return this.apiService.nodes.createNode(parentId, nodeBody, {
+                majorVersion
+            });
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createNode.name}`, error);
+            return null;
+        }
+    }
+    async renameNode(nodeId, newName) {
+        try {
+            return this.apiService.nodes.updateNode(nodeId, { name: newName });
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.renameNode.name}`, error);
+            return null;
+        }
+    }
+    /**
+     * Delete multiple nodes.
+     * @param nodeIds The list of node IDs to delete.
+     * @param permanent Delete permanently, without moving to the trashcan? (default: true)
+     */
+    async deleteNodes(nodeIds, permanent = true) {
+        try {
+            await this.apiService.nodes.deleteNodes(nodeIds, { permanent });
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteNodes.name}`, error);
+        }
+    }
+    /**
+     * Delete all nodes of the currently logged in user
+     * @param userNodeId The id of User node, all child nodes of "userNodeId" will be gathered as a list and deleted ( e.g.: "-my-" - User Homes folder)
+     */
+    async deleteCurrentUserNodes() {
+        try {
+            const userNodes = (await this.getNodeChildren('-my-')).list.entries;
+            const userNodesIds = userNodes.map((nodeChild) => nodeChild.entry.id);
+            await this.deleteNodes(userNodesIds);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteCurrentUserNodes.name}`, error);
+        }
+    }
+    async lockNodes(nodeIds, lockType = 'ALLOW_OWNER_CHANGES') {
+        try {
+            for (const nodeId of nodeIds) {
+                await this.apiService.nodes.lockNode(nodeId, { type: lockType });
+            }
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.lockNodes.name}`, error);
+        }
+    }
+    async unlockNodes(nodeIds) {
+        try {
+            for (const nodeId of nodeIds) {
+                await this.apiService.nodes.unlockNode(nodeId);
+            }
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.unlockNodes.name}`, error);
+        }
+    }
+    async createContent(content, relativePath = '/') {
+        try {
+            return this.apiService.nodes.createNode('-my-', flattenNodeContentTree(content, relativePath));
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createContent.name}`, error);
+            return null;
+        }
+    }
+    async getNodeById(id) {
+        try {
+            return this.apiService.nodes.getNode(id);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.getNodeById.name}`, error);
+            return null;
+        }
+    }
+    async getNodeIdFromParent(name, parentId) {
+        try {
+            const children = (await this.getNodeChildren(parentId)).list.entries;
+            return children.find((elem) => elem.entry.name === name).entry.id || '';
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.getNodeIdFromParent.name}`, error);
+            return '';
+        }
+    }
+    async getNodeChildren(nodeId) {
+        try {
+            const opts = {
+                include: ['properties']
+            };
+            return this.apiService.nodes.listNodeChildren(nodeId, opts);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.getNodeChildren.name}`, error);
+            return null;
+        }
+    }
+    async deleteNodeById(id, permanent = true) {
+        try {
+            await this.apiService.nodes.deleteNode(id, { permanent });
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteNodeById.name}`, error);
+        }
+    }
+    async cleanupNodeTemplatesItems(nodeNames) {
+        try {
+            const templatesFolderId = await this.getNodeTemplatesFolderId();
+            for (const nodeName of nodeNames) {
+                const nodeId = await this.getNodeIdFromParent(nodeName, templatesFolderId);
+                await this.deleteNodeById(nodeId);
+            }
+        }
+        catch (error) {
+            console.error('Admin Actions - cleanupNodeTemplatesItems failed : ', error);
+        }
+    }
+    async cleanupSpaceTemplatesItems(nodeNames) {
+        try {
+            const spaceTemplatesNodeId = await this.getSpaceTemplatesFolderId();
+            for (const nodeName of nodeNames) {
+                const nodeId = await this.getNodeIdFromParent(nodeName, spaceTemplatesNodeId);
+                await this.deleteNodeById(nodeId);
+            }
+        }
+        catch (error) {
+            console.error('Admin Actions - cleanupSpaceTemplatesFolder failed : ', error);
+        }
+    }
+    async getNodeTemplatesFolderId() {
+        try {
+            return this.getNodeIdFromParent('Node Templates', await this.getDataDictionaryId());
+        }
+        catch (error) {
+            console.error('Admin Actions - getNodeTemplatesFolderId failed : ', error);
+            return '';
+        }
+    }
+    async getSpaceTemplatesFolderId() {
+        try {
+            return this.getNodeIdFromParent('Space Templates', await this.getDataDictionaryId());
+        }
+        catch (error) {
+            console.error('Admin Actions - getSpaceTemplatesFolderId failed : ', error);
+            return '';
+        }
+    }
+    async getDataDictionaryId() {
+        return this.getNodeIdFromParent('Data Dictionary', '-root-').catch((error) => {
+            console.error('Admin Actions - getDataDictionaryId failed : ', error);
+            return '';
+        });
+    }
+    async setGranularPermission(nodeId, inheritPermissions = false, username, role) {
+        const data = {
+            permissions: {
+                isInheritanceEnabled: inheritPermissions,
+                locallySet: [
+                    {
+                        authorityId: username,
+                        name: role
+                    }
+                ]
+            }
+        };
+        try {
+            return this.apiService.nodes.updateNode(nodeId, data);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.setGranularPermission.name}`, error);
+            return null;
+        }
+    }
+    async removeUserAccessOnNodeTemplate(nodeName) {
+        try {
+            const templatesRootFolderId = await this.getNodeTemplatesFolderId();
+            const nodeId = await this.getNodeIdFromParent(nodeName, templatesRootFolderId);
+            return this.setInheritPermissions(nodeId, false);
+        }
+        catch (error) {
+            console.error('Admin Actions - removeUserAccessOnNodeTemplate failed : ', error);
+            return null;
+        }
+    }
+    async removeUserAccessOnSpaceTemplate(nodeName) {
+        try {
+            const templatesRootFolderId = await this.getSpaceTemplatesFolderId();
+            const nodeId = await this.getNodeIdFromParent(nodeName, templatesRootFolderId);
+            return this.setInheritPermissions(nodeId, false);
+        }
+        catch (error) {
+            console.error('Admin Actions - removeUserAccessOnSpaceTemplate failed : ', error);
+            return null;
+        }
+    }
+    async setInheritPermissions(nodeId, inheritPermissions) {
+        const data = {
+            permissions: {
+                isInheritanceEnabled: inheritPermissions
+            }
+        };
+        try {
+            return this.apiService.nodes.updateNode(nodeId, data);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.setInheritPermissions.name}`, error);
+            return null;
+        }
+    }
+    async addAspects(nodeId, aspectNames) {
+        try {
+            return this.apiService.nodes.updateNode(nodeId, { aspectNames });
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.addAspects.name}`, error);
+            return null;
+        }
+    }
+    async createFileLink(originalNodeId, destinationId) {
+        const name = (await this.getNodeById(originalNodeId)).entry.name;
+        const nodeBody = {
+            name: `Link to ${name}.url`,
+            nodeType: 'app:filelink',
+            properties: {
+                'cm:destination': originalNodeId
+            }
+        };
+        try {
+            const link = await this.apiService.nodes.createNode(destinationId, nodeBody);
+            await this.addAspects(originalNodeId, ['app:linked']);
+            return link;
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFileLink.name}`, error);
+            return null;
+        }
+    }
+    async createFolderLink(originalNodeId, destinationId) {
+        const name = (await this.getNodeById(originalNodeId)).entry.name;
+        const nodeBody = {
+            name: `Link to ${name}.url`,
+            nodeType: 'app:folderlink',
+            properties: {
+                'cm:title': `Link to ${name}.url`,
+                'cm:destination': originalNodeId,
+                'cm:description': `Link to ${name}.url`,
+                'app:icon': 'space-icon-link'
+            }
+        };
+        try {
+            const link = await this.apiService.nodes.createNode(destinationId, nodeBody);
+            await this.addAspects(originalNodeId, ['app:linked']);
+            return link;
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.createFolderLink.name}`, error);
+            return null;
+        }
+    }
+    async createLinkToFileName(originalFileName, originalFileParentId, destinationParentId) {
+        destinationParentId ?? (destinationParentId = originalFileParentId);
+        try {
+            const nodeId = await this.getNodeIdFromParent(originalFileName, originalFileParentId);
+            return this.createFileLink(nodeId, destinationParentId);
+        }
+        catch (error) {
+            console.error('Admin Actions - createLinkToFileName failed : ', error);
+            return null;
+        }
+    }
+    async createLinkToFolderName(originalFolderName, originalFolderParentId, destinationParentId) {
+        destinationParentId ?? (destinationParentId = originalFolderParentId);
+        try {
+            const nodeId = await this.getNodeIdFromParent(originalFolderName, originalFolderParentId);
+            return this.createFolderLink(nodeId, destinationParentId);
+        }
+        catch (error) {
+            console.error('Admin Actions - createLinkToFolderName failed : ', error);
+            return null;
+        }
+    }
+    async getNodeProperty(nodeId, property) {
+        try {
+            const node = await this.getNodeById(nodeId);
+            return node.entry.properties?.[property] || '';
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.getNodeProperty.name}`, error);
+            return '';
+        }
+    }
+    async isFileShared(nodeId) {
+        try {
+            const sharedId = await this.getNodeProperty(nodeId, 'qshare:sharedId');
+            return sharedId !== '';
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.isFileShared.name}`, error);
+            return null;
+        }
+    }
+    async getLockType(nodeId) {
+        try {
+            const lockType = await this.getNodeProperty(nodeId, 'cm:lockType');
+            return lockType || '';
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.getLockType.name}`, error);
+            return '';
+        }
+    }
+    async isFileLockedWrite(nodeId) {
+        try {
+            return (await this.getLockType(nodeId)) === 'WRITE_LOCK';
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.isFileLockedWrite.name}`, error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/nodes-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ApiClientFactory } from './api-client-factory';\nimport { NodeChildAssociationPaging, NodeEntry, NodePaging } from '@alfresco/js-api';\nimport { NodeContentTree, flattenNodeContentTree } from './node-content-tree';\n\nexport class NodesApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n\n  static async initialize(userName: string, password?: string): Promise<NodesApi> {\n    const classObj = new NodesApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  async createFolder(\n    name: string,\n    parentId: string = '-my-',\n    title: string = '',\n    description: string = '',\n    author: string = '',\n    aspectNames: string[] = null\n  ): Promise<NodeEntry | null> {\n    try {\n      return this.createNode('cm:folder', name, parentId, title, description, null, author, null, aspectNames);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFolder.name}`, error);\n      return null;\n    }\n  }\n\n  async createFile(\n    name: string,\n    parentId: string = '-my-',\n    title: string = '',\n    description: string = '',\n    author: string = '',\n    majorVersion: boolean = true,\n    aspectNames: string[] = null\n  ): Promise<NodeEntry> {\n    try {\n      return this.createNode('cm:content', name, parentId, title, description, null, author, majorVersion, aspectNames);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFile.name}`, error);\n      return null;\n    }\n  }\n\n  async createFiles(names: string[], relativePath = '/'): Promise<NodePaging> {\n    try {\n      return this.createContent({ files: names }, relativePath);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFiles.name}: ${error}`);\n      return null;\n    }\n  }\n\n  async createFolders(names: string[], relativePath = '/'): Promise<NodePaging> {\n    try {\n      return this.createContent({ folders: names }, relativePath);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFolders.name}: ${error}`);\n      return null;\n    }\n  }\n\n  async deleteDeletedNode(name: string): Promise<void> {\n    try {\n      await this.apiService.trashCan.deleteDeletedNode(name);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteDeletedNode.name}: ${error}`);\n    }\n  }\n\n  private async createNode(\n    nodeType: string,\n    name: string,\n    parentId: string = '-my-',\n    title: string = '',\n    description: string = '',\n    imageProps: any = null,\n    author: string = '',\n    majorVersion: boolean = true,\n    aspectNames: string[] = null\n  ): Promise<NodeEntry | null> {\n    if (!aspectNames) {\n      aspectNames = ['cm:versionable']; // workaround for REPO-4772\n    }\n    const nodeBody = {\n      name,\n      nodeType,\n      relativePath: '/',\n      properties: {\n        'cm:title': title,\n        'cm:description': description,\n        'cm:author': author\n      },\n      aspectNames\n    };\n    if (imageProps) {\n      nodeBody.properties = Object.assign(nodeBody.properties, imageProps);\n    }\n\n    try {\n      return this.apiService.nodes.createNode(parentId, nodeBody, {\n        majorVersion\n      });\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createNode.name}`, error);\n      return null;\n    }\n  }\n\n  async renameNode(nodeId: string, newName: string): Promise<NodeEntry | null> {\n    try {\n      return this.apiService.nodes.updateNode(nodeId, { name: newName });\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.renameNode.name}`, error);\n      return null;\n    }\n  }\n\n  /**\n   * Delete multiple nodes.\n   * @param nodeIds The list of node IDs to delete.\n   * @param permanent Delete permanently, without moving to the trashcan? (default: true)\n   */\n  async deleteNodes(nodeIds: string[], permanent: boolean = true): Promise<any> {\n    try {\n      await this.apiService.nodes.deleteNodes(nodeIds, { permanent });\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteNodes.name}`, error);\n    }\n  }\n\n  /**\n   * Delete all nodes of the currently logged in user\n   * @param userNodeId The id of User node, all child nodes of \"userNodeId\" will be gathered as a list and deleted ( e.g.: \"-my-\" - User Homes folder)\n   */\n  async deleteCurrentUserNodes(): Promise<void> {\n    try {\n      const userNodes = (await this.getNodeChildren('-my-')).list.entries;\n      const userNodesIds = userNodes.map((nodeChild) => nodeChild.entry.id);\n      await this.deleteNodes(userNodesIds);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteCurrentUserNodes.name}`, error);\n    }\n  }\n\n  async lockNodes(nodeIds: string[], lockType: string = 'ALLOW_OWNER_CHANGES') {\n    try {\n      for (const nodeId of nodeIds) {\n        await this.apiService.nodes.lockNode(nodeId, { type: lockType });\n      }\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.lockNodes.name}`, error);\n    }\n  }\n\n  async unlockNodes(nodeIds: string[]) {\n    try {\n      for (const nodeId of nodeIds) {\n        await this.apiService.nodes.unlockNode(nodeId);\n      }\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.unlockNodes.name}`, error);\n    }\n  }\n\n  async createContent(content: NodeContentTree, relativePath: string = '/'): Promise<NodePaging> {\n    try {\n      return this.apiService.nodes.createNode('-my-', flattenNodeContentTree(content, relativePath) as any);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createContent.name}`, error);\n      return null;\n    }\n  }\n\n  async getNodeById(id: string): Promise<NodeEntry | null> {\n    try {\n      return this.apiService.nodes.getNode(id);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.getNodeById.name}`, error);\n      return null;\n    }\n  }\n\n  async getNodeIdFromParent(name: string, parentId: string): Promise<string> {\n    try {\n      const children = (await this.getNodeChildren(parentId)).list.entries;\n      return children.find((elem) => elem.entry.name === name).entry.id || '';\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.getNodeIdFromParent.name}`, error);\n      return '';\n    }\n  }\n\n  private async getNodeChildren(nodeId: string): Promise<NodeChildAssociationPaging | null> {\n    try {\n      const opts = {\n        include: ['properties']\n      };\n      return this.apiService.nodes.listNodeChildren(nodeId, opts);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.getNodeChildren.name}`, error);\n      return null;\n    }\n  }\n\n  async deleteNodeById(id: string, permanent: boolean = true): Promise<void> {\n    try {\n      await this.apiService.nodes.deleteNode(id, { permanent });\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteNodeById.name}`, error);\n    }\n  }\n\n  async cleanupNodeTemplatesItems(nodeNames: string[]): Promise<void> {\n    try {\n      const templatesFolderId = await this.getNodeTemplatesFolderId();\n      for (const nodeName of nodeNames) {\n        const nodeId = await this.getNodeIdFromParent(nodeName, templatesFolderId);\n        await this.deleteNodeById(nodeId);\n      }\n    } catch (error) {\n      console.error('Admin Actions - cleanupNodeTemplatesItems failed : ', error);\n    }\n  }\n\n  async cleanupSpaceTemplatesItems(nodeNames: string[]): Promise<void> {\n    try {\n      const spaceTemplatesNodeId = await this.getSpaceTemplatesFolderId();\n      for (const nodeName of nodeNames) {\n        const nodeId = await this.getNodeIdFromParent(nodeName, spaceTemplatesNodeId);\n        await this.deleteNodeById(nodeId);\n      }\n    } catch (error) {\n      console.error('Admin Actions - cleanupSpaceTemplatesFolder failed : ', error);\n    }\n  }\n\n  async getNodeTemplatesFolderId(): Promise<string> {\n    try {\n      return this.getNodeIdFromParent('Node Templates', await this.getDataDictionaryId());\n    } catch (error) {\n      console.error('Admin Actions - getNodeTemplatesFolderId failed : ', error);\n      return '';\n    }\n  }\n\n  async getSpaceTemplatesFolderId(): Promise<string> {\n    try {\n      return this.getNodeIdFromParent('Space Templates', await this.getDataDictionaryId());\n    } catch (error) {\n      console.error('Admin Actions - getSpaceTemplatesFolderId failed : ', error);\n      return '';\n    }\n  }\n\n  private async getDataDictionaryId(): Promise<string> {\n    return this.getNodeIdFromParent('Data Dictionary', '-root-').catch((error) => {\n      console.error('Admin Actions - getDataDictionaryId failed : ', error);\n      return '';\n    });\n  }\n\n  async setGranularPermission(nodeId: string, inheritPermissions: boolean = false, username: string, role: string): Promise<NodeEntry | null> {\n    const data = {\n      permissions: {\n        isInheritanceEnabled: inheritPermissions,\n        locallySet: [\n          {\n            authorityId: username,\n            name: role\n          }\n        ]\n      }\n    };\n\n    try {\n      return this.apiService.nodes.updateNode(nodeId, data);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.setGranularPermission.name}`, error);\n      return null;\n    }\n  }\n\n  async removeUserAccessOnNodeTemplate(nodeName: string): Promise<NodeEntry> {\n    try {\n      const templatesRootFolderId = await this.getNodeTemplatesFolderId();\n      const nodeId: string = await this.getNodeIdFromParent(nodeName, templatesRootFolderId);\n\n      return this.setInheritPermissions(nodeId, false);\n    } catch (error) {\n      console.error('Admin Actions - removeUserAccessOnNodeTemplate failed : ', error);\n      return null;\n    }\n  }\n\n  async removeUserAccessOnSpaceTemplate(nodeName: string): Promise<NodeEntry> {\n    try {\n      const templatesRootFolderId = await this.getSpaceTemplatesFolderId();\n      const nodeId: string = await this.getNodeIdFromParent(nodeName, templatesRootFolderId);\n\n      return this.setInheritPermissions(nodeId, false);\n    } catch (error) {\n      console.error('Admin Actions - removeUserAccessOnSpaceTemplate failed : ', error);\n      return null;\n    }\n  }\n\n  async setInheritPermissions(nodeId: string, inheritPermissions: boolean): Promise<NodeEntry | null> {\n    const data = {\n      permissions: {\n        isInheritanceEnabled: inheritPermissions\n      }\n    };\n\n    try {\n      return this.apiService.nodes.updateNode(nodeId, data);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.setInheritPermissions.name}`, error);\n      return null;\n    }\n  }\n\n  private async addAspects(nodeId: string, aspectNames: string[]): Promise<NodeEntry> {\n    try {\n      return this.apiService.nodes.updateNode(nodeId, { aspectNames });\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.addAspects.name}`, error);\n      return null;\n    }\n  }\n\n  async createFileLink(originalNodeId: string, destinationId: string): Promise<NodeEntry | null> {\n    const name = (await this.getNodeById(originalNodeId)).entry.name;\n    const nodeBody = {\n      name: `Link to ${name}.url`,\n      nodeType: 'app:filelink',\n      properties: {\n        'cm:destination': originalNodeId\n      }\n    };\n\n    try {\n      const link = await this.apiService.nodes.createNode(destinationId, nodeBody);\n      await this.addAspects(originalNodeId, ['app:linked']);\n      return link;\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFileLink.name}`, error);\n      return null;\n    }\n  }\n\n  async createFolderLink(originalNodeId: string, destinationId: string): Promise<NodeEntry | null> {\n    const name = (await this.getNodeById(originalNodeId)).entry.name;\n    const nodeBody = {\n      name: `Link to ${name}.url`,\n      nodeType: 'app:folderlink',\n      properties: {\n        'cm:title': `Link to ${name}.url`,\n        'cm:destination': originalNodeId,\n        'cm:description': `Link to ${name}.url`,\n        'app:icon': 'space-icon-link'\n      }\n    };\n\n    try {\n      const link = await this.apiService.nodes.createNode(destinationId, nodeBody);\n      await this.addAspects(originalNodeId, ['app:linked']);\n      return link;\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.createFolderLink.name}`, error);\n      return null;\n    }\n  }\n\n  async createLinkToFileName(originalFileName: string, originalFileParentId: string, destinationParentId?: string): Promise<NodeEntry> {\n    destinationParentId ??= originalFileParentId;\n\n    try {\n      const nodeId = await this.getNodeIdFromParent(originalFileName, originalFileParentId);\n\n      return this.createFileLink(nodeId, destinationParentId);\n    } catch (error) {\n      console.error('Admin Actions - createLinkToFileName failed : ', error);\n      return null;\n    }\n  }\n\n  async createLinkToFolderName(originalFolderName: string, originalFolderParentId: string, destinationParentId?: string): Promise<NodeEntry> {\n    destinationParentId ??= originalFolderParentId;\n\n    try {\n      const nodeId = await this.getNodeIdFromParent(originalFolderName, originalFolderParentId);\n      return this.createFolderLink(nodeId, destinationParentId);\n    } catch (error) {\n      console.error('Admin Actions - createLinkToFolderName failed : ', error);\n      return null;\n    }\n  }\n\n  async getNodeProperty(nodeId: string, property: string): Promise<string> {\n    try {\n      const node = await this.getNodeById(nodeId);\n      return node.entry.properties?.[property] || '';\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.getNodeProperty.name}`, error);\n      return '';\n    }\n  }\n\n  async isFileShared(nodeId: string): Promise<boolean> {\n    try {\n      const sharedId = await this.getNodeProperty(nodeId, 'qshare:sharedId');\n      return sharedId !== '';\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.isFileShared.name}`, error);\n      return null;\n    }\n  }\n\n  private async getLockType(nodeId: string): Promise<string> {\n    try {\n      const lockType = await this.getNodeProperty(nodeId, 'cm:lockType');\n      return lockType || '';\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.getLockType.name}`, error);\n      return '';\n    }\n  }\n\n  async isFileLockedWrite(nodeId: string): Promise<boolean> {\n    try {\n      return (await this.getLockType(nodeId)) === 'WRITE_LOCK';\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.isFileLockedWrite.name}`, error);\n      return null;\n    }\n  }\n}\n"]}

package/esm2020/api/people-api-models.mjs

@@ -0,0 +1,34 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+export class Person {
+    constructor(user) {
+        this.id = user.username;
+        this.password = user.password || user.username;
+        this.firstName = user.firstName || user.username;
+        this.lastName = user.lastName || user.username;
+        this.email = user.email || `${user.username}@alfresco.com`;
+        this.enabled = user.enabled || true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/queries-api.mjs

@@ -0,0 +1,69 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Utils } from '../utils';
+import { ApiClientFactory } from './api-client-factory';
+export class QueriesApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new QueriesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async waitForSites(searchTerm, data) {
+        try {
+            const sites = async () => {
+                const totalItems = await this.findSitesTotalItems(searchTerm);
+                if (totalItems !== data.expect) {
+                    return Promise.reject(totalItems);
+                }
+                else {
+                    return Promise.resolve(totalItems);
+                }
+            };
+            return Utils.retryCall(sites);
+        }
+        catch (error) {
+            console.error(`QueriesApi waitForSites : catch : `);
+            console.error(`\tExpected: ${data.expect} items, but found ${error}`);
+            return null;
+        }
+    }
+    async findSitesTotalItems(searchTerm) {
+        try {
+            const opts = {
+                term: searchTerm,
+                fields: ['title']
+            };
+            const sites = await this.apiService.queries.findSites(searchTerm, opts);
+            return sites.list.pagination.totalItems;
+        }
+        catch (error) {
+            console.error(`QueriesApi findSitesTotalItems : catch :`, error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllcy1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtcGxheXdyaWdodC1zaGFyZWQvc3JjL2FwaS9xdWVyaWVzLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUdILE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDakMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFeEQsTUFBTSxPQUFPLFVBQVU7SUFHckI7UUFDRSxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksZ0JBQWdCLEVBQUUsQ0FBQztJQUMzQyxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsUUFBZ0IsRUFBRSxRQUFpQjtRQUN6RCxNQUFNLFFBQVEsR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQ2xDLE1BQU0sUUFBUSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQzlELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7SUFFRCxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQWtCLEVBQUUsSUFBd0I7UUFDN0QsSUFBSTtZQUNGLE1BQU0sS0FBSyxHQUFHLEtBQUssSUFBSSxFQUFFO2dCQUN2QixNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFDOUQsSUFBSSxVQUFVLEtBQUssSUFBSSxDQUFDLE1BQU0sRUFBRTtvQkFDOUIsT0FBTyxPQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDO2lCQUNuQztxQkFBTTtvQkFDTCxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7aUJBQ3BDO1lBQ0gsQ0FBQyxDQUFDO1lBRUYsT0FBTyxLQUFLLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQy9CO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxPQUFPLENBQUMsS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7WUFDcEQsT0FBTyxDQUFDLEtBQUssQ0FBQyxlQUFlLElBQUksQ0FBQyxNQUFNLHFCQUFxQixLQUFLLEVBQUUsQ0FBQyxDQUFDO1lBQ3RFLE9BQU8sSUFBSSxDQUFDO1NBQ2I7SUFDSCxDQUFDO0lBRU8sS0FBSyxDQUFDLG1CQUFtQixDQUFDLFVBQWtCO1FBQ2xELElBQUk7WUFDRixNQUFNLElBQUksR0FBYztnQkFDdEIsSUFBSSxFQUFFLFVBQVU7Z0JBQ2hCLE1BQU0sRUFBRSxDQUFDLE9BQU8sQ0FBQzthQUNsQixDQUFDO1lBRUYsTUFBTSxLQUFLLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ3hFLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDO1NBQ3pDO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxPQUFPLENBQUMsS0FBSyxDQUFDLDBDQUEwQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ2pFLE9BQU8sSUFBSSxDQUFDO1NBQ2I7SUFDSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgRmluZFF1ZXJ5IH0gZnJvbSAnQGFsZnJlc2NvL2pzLWFwaSc7XG5pbXBvcnQgeyBVdGlscyB9IGZyb20gJy4uL3V0aWxzJztcbmltcG9ydCB7IEFwaUNsaWVudEZhY3RvcnkgfSBmcm9tICcuL2FwaS1jbGllbnQtZmFjdG9yeSc7XG5cbmV4cG9ydCBjbGFzcyBRdWVyaWVzQXBpIHtcbiAgcHJpdmF0ZSBhcGlTZXJ2aWNlOiBBcGlDbGllbnRGYWN0b3J5O1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuYXBpU2VydmljZSA9IG5ldyBBcGlDbGllbnRGYWN0b3J5KCk7XG4gIH1cblxuICBzdGF0aWMgYXN5bmMgaW5pdGlhbGl6ZSh1c2VyTmFtZTogc3RyaW5nLCBwYXNzd29yZD86IHN0cmluZyk6IFByb21pc2U8UXVlcmllc0FwaT4ge1xuICAgIGNvbnN0IGNsYXNzT2JqID0gbmV3IFF1ZXJpZXNBcGkoKTtcbiAgICBhd2FpdCBjbGFzc09iai5hcGlTZXJ2aWNlLnNldFVwQWNhQmFja2VuZCh1c2VyTmFtZSwgcGFzc3dvcmQpO1xuICAgIHJldHVybiBjbGFzc09iajtcbiAgfVxuXG4gIGFzeW5jIHdhaXRGb3JTaXRlcyhzZWFyY2hUZXJtOiBzdHJpbmcsIGRhdGE6IHsgZXhwZWN0OiBudW1iZXIgfSk6IFByb21pc2U8bnVtYmVyPiB7XG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IHNpdGVzID0gYXN5bmMgKCkgPT4ge1xuICAgICAgICBjb25zdCB0b3RhbEl0ZW1zID0gYXdhaXQgdGhpcy5maW5kU2l0ZXNUb3RhbEl0ZW1zKHNlYXJjaFRlcm0pO1xuICAgICAgICBpZiAodG90YWxJdGVtcyAhPT0gZGF0YS5leHBlY3QpIHtcbiAgICAgICAgICByZXR1cm4gUHJvbWlzZS5yZWplY3QodG90YWxJdGVtcyk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSh0b3RhbEl0ZW1zKTtcbiAgICAgICAgfVxuICAgICAgfTtcblxuICAgICAgcmV0dXJuIFV0aWxzLnJldHJ5Q2FsbChzaXRlcyk7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoYFF1ZXJpZXNBcGkgd2FpdEZvclNpdGVzIDogY2F0Y2ggOiBgKTtcbiAgICAgIGNvbnNvbGUuZXJyb3IoYFxcdEV4cGVjdGVkOiAke2RhdGEuZXhwZWN0fSBpdGVtcywgYnV0IGZvdW5kICR7ZXJyb3J9YCk7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG4gIH1cblxuICBwcml2YXRlIGFzeW5jIGZpbmRTaXRlc1RvdGFsSXRlbXMoc2VhcmNoVGVybTogc3RyaW5nKTogUHJvbWlzZTxudW1iZXI+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3Qgb3B0czogRmluZFF1ZXJ5ID0ge1xuICAgICAgICB0ZXJtOiBzZWFyY2hUZXJtLFxuICAgICAgICBmaWVsZHM6IFsndGl0bGUnXVxuICAgICAgfTtcblxuICAgICAgY29uc3Qgc2l0ZXMgPSBhd2FpdCB0aGlzLmFwaVNlcnZpY2UucXVlcmllcy5maW5kU2l0ZXMoc2VhcmNoVGVybSwgb3B0cyk7XG4gICAgICByZXR1cm4gc2l0ZXMubGlzdC5wYWdpbmF0aW9uLnRvdGFsSXRlbXM7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoYFF1ZXJpZXNBcGkgZmluZFNpdGVzVG90YWxJdGVtcyA6IGNhdGNoIDpgLCBlcnJvcik7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG4gIH1cbn1cbiJdfQ==