@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/api/file-actions.mjs

@@ -0,0 +1,166 @@
+/*!
+ * 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 * as fs from 'fs';
+import { ApiClientFactory } from './api-client-factory';
+import { Utils, waitForApi } from '../utils';
+import { ResultSetPaging } from '@alfresco/js-api';
+export class FileActionsApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new FileActionsApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async uploadFile(fileLocation, fileName, parentFolderId) {
+        const file = fs.createReadStream(fileLocation);
+        return this.apiService.upload.uploadFile(file, '', parentFolderId, null, {
+            name: fileName,
+            nodeType: 'cm:content',
+            renditions: 'doclib'
+        });
+    }
+    async uploadFileWithRename(fileLocation, newName, parentId = '-my-', title = '', description = '') {
+        const file = fs.createReadStream(fileLocation);
+        const nodeProps = {
+            properties: {
+                'cm:title': title,
+                'cm:description': description
+            }
+        };
+        const opts = {
+            name: newName,
+            nodeType: 'cm:content'
+        };
+        try {
+            return this.apiService.upload.uploadFile(file, '', parentId, nodeProps, opts);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    async lockNodes(nodeIds, lockType = 'ALLOW_OWNER_CHANGES') {
+        try {
+            for (const nodeId of nodeIds) {
+                await this.apiService.nodes.lockNode(nodeId, { type: lockType });
+            }
+        }
+        catch { }
+    }
+    async getNodeById(id) {
+        try {
+            return this.apiService.nodes.getNode(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getNodeProperty(nodeId, property) {
+        try {
+            const node = await this.getNodeById(nodeId);
+            return node.entry.properties?.[property] || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async getLockType(nodeId) {
+        try {
+            const lockType = await this.getNodeProperty(nodeId, 'cm:lockType');
+            return lockType || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async isFileLockedWriteWithRetry(nodeId, expect) {
+        const data = {
+            expect: expect,
+            retry: 5
+        };
+        let isLocked = false;
+        try {
+            const locked = async () => {
+                isLocked = (await this.getLockType(nodeId)) === 'WRITE_LOCK';
+                if (isLocked !== data.expect) {
+                    return Promise.reject(isLocked);
+                }
+                else {
+                    return Promise.resolve(isLocked);
+                }
+            };
+            return Utils.retryCall(locked, data.retry);
+        }
+        catch { }
+        return isLocked;
+    }
+    async queryNodesNames(searchTerm) {
+        const data = {
+            query: {
+                query: `cm:name:\"${searchTerm}*\"`,
+                language: 'afts'
+            },
+            filterQueries: [{ query: `+TYPE:'cm:folder' OR +TYPE:'cm:content'` }]
+        };
+        try {
+            return this.apiService.search.search(data);
+        }
+        catch {
+            return new ResultSetPaging();
+        }
+    }
+    async waitForNodes(searchTerm, data) {
+        const predicate = (totalItems) => totalItems === data.expect;
+        const apiCall = async () => {
+            try {
+                return (await this.queryNodesNames(searchTerm)).list.pagination.totalItems;
+            }
+            catch (error) {
+                return 0;
+            }
+        };
+        try {
+            await waitForApi(apiCall, predicate, 30, 2500);
+        }
+        catch (error) {
+            console.error(`Error: ${error}`);
+        }
+    }
+    async updateNodeContent(nodeId, content, majorVersion = true, comment, newName) {
+        try {
+            const opts = {
+                majorVersion: majorVersion,
+                comment: comment,
+                name: newName
+            };
+            return this.apiService.nodes.updateNodeContent(nodeId, content, opts);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.updateNodeContent.name}`, error);
+            return Promise.reject(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-actions.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/file-actions.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 * as fs from 'fs';\nimport { ApiClientFactory } from './api-client-factory';\nimport { Utils, waitForApi } from '../utils';\nimport { NodeBodyCreate, NodeEntry, ResultSetPaging } from '@alfresco/js-api';\n\nexport class FileActionsApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n\n  static async initialize(userName: string, password?: string): Promise<FileActionsApi> {\n    const classObj = new FileActionsApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  async uploadFile(fileLocation: string, fileName: string, parentFolderId: string): Promise<NodeEntry> {\n    const file = fs.createReadStream(fileLocation);\n    return this.apiService.upload.uploadFile(file, '', parentFolderId, null, {\n      name: fileName,\n      nodeType: 'cm:content',\n      renditions: 'doclib'\n    });\n  }\n\n  async uploadFileWithRename(\n    fileLocation: string,\n    newName: string,\n    parentId: string = '-my-',\n    title: string = '',\n    description: string = ''\n  ): Promise<NodeEntry> {\n    const file = fs.createReadStream(fileLocation);\n    const nodeProps = {\n      properties: {\n        'cm:title': title,\n        'cm:description': description\n      }\n    } as NodeBodyCreate;\n\n    const opts = {\n      name: newName,\n      nodeType: 'cm:content'\n    };\n\n    try {\n      return this.apiService.upload.uploadFile(file, '', parentId, nodeProps, opts);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n  }\n\n  async lockNodes(nodeIds: string[], lockType: string = 'ALLOW_OWNER_CHANGES'): Promise<void> {\n    try {\n      for (const nodeId of nodeIds) {\n        await this.apiService.nodes.lockNode(nodeId, { type: lockType });\n      }\n    } catch {}\n  }\n\n  async getNodeById(id: string): Promise<NodeEntry | null> {\n    try {\n      return this.apiService.nodes.getNode(id);\n    } catch {\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 {\n      return '';\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 {\n      return '';\n    }\n  }\n\n  async isFileLockedWriteWithRetry(nodeId: string, expect: boolean): Promise<boolean> {\n    const data = {\n      expect: expect,\n      retry: 5\n    };\n    let isLocked = false;\n    try {\n      const locked = async () => {\n        isLocked = (await this.getLockType(nodeId)) === 'WRITE_LOCK';\n        if (isLocked !== data.expect) {\n          return Promise.reject(isLocked);\n        } else {\n          return Promise.resolve(isLocked);\n        }\n      };\n      return Utils.retryCall(locked, data.retry);\n    } catch {}\n    return isLocked;\n  }\n\n  private async queryNodesNames(searchTerm: string): Promise<ResultSetPaging> {\n    const data = {\n      query: {\n        query: `cm:name:\\\"${searchTerm}*\\\"`,\n        language: 'afts'\n      },\n      filterQueries: [{ query: `+TYPE:'cm:folder' OR +TYPE:'cm:content'` }]\n    };\n\n    try {\n      return this.apiService.search.search(data);\n    } catch {\n      return new ResultSetPaging();\n    }\n  }\n\n  async waitForNodes(searchTerm: string, data: { expect: number }): Promise<void> {\n    const predicate = (totalItems: number) => totalItems === data.expect;\n\n    const apiCall = async () => {\n      try {\n        return (await this.queryNodesNames(searchTerm)).list.pagination.totalItems;\n      } catch (error) {\n        return 0;\n      }\n    };\n\n    try {\n      await waitForApi(apiCall, predicate, 30, 2500);\n    } catch (error) {\n      console.error(`Error: ${error}`);\n    }\n  }\n\n  async updateNodeContent(nodeId: string, content: string, majorVersion: boolean = true, comment?: string, newName?: string): Promise<NodeEntry> {\n    try {\n      const opts: { [key: string]: string | boolean } = {\n        majorVersion: majorVersion,\n        comment: comment,\n        name: newName\n      };\n      return this.apiService.nodes.updateNodeContent(nodeId, content, opts);\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.updateNodeContent.name}`, error);\n      return Promise.reject(error);\n    }\n  }\n}\n"]}

package/esm2020/api/index.mjs

@@ -0,0 +1,38 @@
+/*!
+ * 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 * from './rules-api';
+export * from './api-client-factory';
+export * from './file-actions';
+export * from './shared-links-api';
+export * from './favorites-api';
+export * from './people-api-models';
+export * from './nodes-api';
+export * from './sites-api';
+export * from './node-content-tree';
+export * from './search-api';
+export * from './trashcan-api';
+export * from './queries-api';
+export * from './categories-api';
+export * from './tags-api';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/node-content-tree.mjs

@@ -0,0 +1,67 @@
+/*!
+ * 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/>.
+ */
+const NODE_TYPE_FILE = 'cm:content';
+const NODE_TYPE_FOLDER = 'cm:folder';
+const NODE_TITLE = 'cm:title';
+const NODE_DESCRIPTION = 'cm:description';
+export function flattenNodeContentTree(content, relativePath = '/') {
+    const { name, files, folders, title, description } = content;
+    const aspectNames = ['cm:versionable'];
+    let data = [];
+    const properties = {
+        [NODE_TITLE]: title,
+        [NODE_DESCRIPTION]: description
+    };
+    if (name) {
+        data = data.concat([
+            {
+                nodeType: NODE_TYPE_FOLDER,
+                name,
+                relativePath,
+                properties
+            }
+        ]);
+        relativePath = relativePath === '/' ? `/${name}` : `${relativePath}/${name}`;
+    }
+    if (folders) {
+        const foldersData = folders
+            .map((folder) => {
+            const folderData = typeof folder === 'string' ? { name: folder } : folder;
+            return flattenNodeContentTree(folderData, relativePath);
+        })
+            .reduce((nodesData, folderData) => nodesData.concat(folderData), []);
+        data = data.concat(foldersData);
+    }
+    if (files) {
+        const filesData = files.map((filename) => ({
+            nodeType: NODE_TYPE_FILE,
+            name: filename,
+            relativePath,
+            aspectNames
+        }));
+        data = data.concat(filesData);
+    }
+    return data;
+}
+//# sourceMappingURL=data:application/json;base64,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