@alfresco/aca-playwright-shared 6.0.0-11236390868 → 6.0.0-11250328592

package/esm2020/api/api-client-factory.mjs

@@ -0,0 +1,111 @@
+/*!
+ * 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 { AdminTenantsApi, AdminUsersApi, AlfrescoApi, GroupsApi, NodesApi, PeopleApi, QueriesApi, SearchApi, SecurityGroupsApi, SecurityMarksApi, SitesApi, UploadApi, SharedlinksApi, FavoritesApi, TrashcanApi, CommentsApi, CategoriesApi, TagsApi } from '@alfresco/js-api';
+import { users } from '../base-config';
+import { Person } from './people-api-models';
+const { BASE_URL } = process.env;
+const config = {
+    authType: 'BASIC',
+    hostBpm: BASE_URL,
+    hostEcm: BASE_URL,
+    provider: 'ECM',
+    contextRoot: 'alfresco'
+};
+export class ApiClientFactory {
+    constructor() {
+        this.alfrescoApi = new AlfrescoApi(config);
+    }
+    async setUpAcaBackend(userName, password) {
+        await this.login(userName, password);
+        this.sites = new SitesApi(this.alfrescoApi);
+        this.upload = new UploadApi(this.alfrescoApi);
+        this.nodes = new NodesApi(this.alfrescoApi);
+        this.people = new PeopleApi(this.alfrescoApi);
+        this.adminUsers = new AdminUsersApi(this.alfrescoApi);
+        this.adminTenant = new AdminTenantsApi(this.alfrescoApi);
+        this.groups = new GroupsApi(this.alfrescoApi);
+        this.queries = new QueriesApi(this.alfrescoApi);
+        this.search = new SearchApi(this.alfrescoApi);
+        this.securityGroupsApi = new SecurityGroupsApi(this.alfrescoApi);
+        this.securityMarksApi = new SecurityMarksApi(this.alfrescoApi);
+        this.share = new SharedlinksApi(this.alfrescoApi);
+        this.favorites = new FavoritesApi(this.alfrescoApi);
+        this.trashCan = new TrashcanApi(this.alfrescoApi);
+        this.commentsApi = new CommentsApi(this.alfrescoApi);
+        this.queriesApi = new QueriesApi(this.alfrescoApi);
+        this.categoriesApi = new CategoriesApi(this.alfrescoApi);
+        this.tagsApi = new TagsApi(this.alfrescoApi);
+        return this;
+    }
+    async tearDown() {
+        await this.alfrescoApi.logout();
+        return this;
+    }
+    async login(userName, password) {
+        const predefinedUserKey = Object.keys(users).find((user) => user === userName || users[user].username === userName);
+        const userToLog = predefinedUserKey ? users[predefinedUserKey] : undefined;
+        let e;
+        const user = userToLog?.username ?? userName;
+        const userPassword = userToLog?.password ?? password;
+        try {
+            e = await this.alfrescoApi.login(user, userPassword);
+        }
+        catch (error) {
+            console.error(`[API Client Factory] Log in user ${user} failed ${e}`);
+            throw error;
+        }
+    }
+    async loginUser(user) {
+        let e;
+        try {
+            e = await this.alfrescoApi.login(user.username, user.password);
+        }
+        catch (error) {
+            console.error(`[API Client Factory] Log in user ${user.username} failed ${e}`);
+            throw error;
+        }
+    }
+    async createUser(user) {
+        const person = new Person(user);
+        const peopleApi = new PeopleApi(this.alfrescoApi);
+        try {
+            return peopleApi.createPerson(person);
+        }
+        catch (error) {
+            console.error('[API Client Factory] createUser failed : ', error);
+            return null;
+        }
+    }
+    async changePassword(username, newPassword) {
+        const peopleApi = new PeopleApi(this.alfrescoApi);
+        try {
+            return peopleApi.updatePerson(username, { password: newPassword });
+        }
+        catch (error) {
+            console.error('[API Client Factory] changePassword failed : ', error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client-factory.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/api-client-factory.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 {\n  AdminTenantsApi,\n  AdminUsersApi,\n  AlfrescoApi,\n  ContentClient,\n  GroupsApi,\n  NodesApi,\n  PeopleApi,\n  QueriesApi,\n  SearchApi,\n  SecurityGroupsApi,\n  SecurityMarksApi,\n  SitesApi,\n  UploadApi,\n  SharedlinksApi,\n  FavoritesApi,\n  TrashcanApi,\n  PersonEntry,\n  CommentsApi,\n  CategoriesApi,\n  TagsApi\n} from '@alfresco/js-api';\nimport { users } from '../base-config';\nimport { Person, PersonModel } from './people-api-models';\n\nexport interface AcaBackend {\n  sites: SitesApi;\n  upload: UploadApi;\n  nodes: NodesApi;\n  share: SharedlinksApi;\n  favorites: FavoritesApi;\n  trashCan: TrashcanApi;\n\n  tearDown(): Promise<any>;\n}\n\nconst { BASE_URL } = process.env;\n\nconst config = {\n  authType: 'BASIC',\n  hostBpm: BASE_URL,\n  hostEcm: BASE_URL,\n  provider: 'ECM',\n  contextRoot: 'alfresco'\n};\n\nexport class ApiClientFactory {\n  public alfrescoApi: AlfrescoApi;\n  public sites: SitesApi;\n  public upload: UploadApi;\n  public nodes: NodesApi;\n  public people: PeopleApi;\n  public adminUsers: AdminUsersApi;\n  public adminTenant: AdminTenantsApi;\n  public groups: GroupsApi;\n  public queries: QueriesApi;\n  public search: SearchApi;\n  public securityGroupsApi: SecurityGroupsApi;\n  public securityMarksApi: SecurityMarksApi;\n  public contentClient: ContentClient;\n  public share: SharedlinksApi;\n  public favorites: FavoritesApi;\n  public trashCan: TrashcanApi;\n  public commentsApi: CommentsApi;\n  public queriesApi: QueriesApi;\n  public categoriesApi: CategoriesApi;\n  public tagsApi: TagsApi;\n  constructor() {\n    this.alfrescoApi = new AlfrescoApi(config);\n  }\n\n  public async setUpAcaBackend(userName: string, password?: string): Promise<AcaBackend> {\n    await this.login(userName, password);\n\n    this.sites = new SitesApi(this.alfrescoApi);\n    this.upload = new UploadApi(this.alfrescoApi);\n    this.nodes = new NodesApi(this.alfrescoApi);\n    this.people = new PeopleApi(this.alfrescoApi);\n    this.adminUsers = new AdminUsersApi(this.alfrescoApi);\n    this.adminTenant = new AdminTenantsApi(this.alfrescoApi);\n    this.groups = new GroupsApi(this.alfrescoApi);\n    this.queries = new QueriesApi(this.alfrescoApi);\n    this.search = new SearchApi(this.alfrescoApi);\n    this.securityGroupsApi = new SecurityGroupsApi(this.alfrescoApi);\n    this.securityMarksApi = new SecurityMarksApi(this.alfrescoApi);\n    this.share = new SharedlinksApi(this.alfrescoApi);\n    this.favorites = new FavoritesApi(this.alfrescoApi);\n    this.trashCan = new TrashcanApi(this.alfrescoApi);\n    this.commentsApi = new CommentsApi(this.alfrescoApi);\n    this.queriesApi = new QueriesApi(this.alfrescoApi);\n    this.categoriesApi = new CategoriesApi(this.alfrescoApi);\n    this.tagsApi = new TagsApi(this.alfrescoApi);\n\n    return this;\n  }\n\n  async tearDown(): Promise<ApiClientFactory> {\n    await this.alfrescoApi.logout();\n    return this;\n  }\n\n  async login(userName: string, password?: string) {\n    const predefinedUserKey = Object.keys(users).find((user) => user === userName || users[user].username === userName);\n    const userToLog = predefinedUserKey ? users[predefinedUserKey] : undefined;\n    let e: any;\n\n    const user = userToLog?.username ?? userName;\n    const userPassword = userToLog?.password ?? password;\n    try {\n      e = await this.alfrescoApi.login(user, userPassword);\n    } catch (error) {\n      console.error(`[API Client Factory] Log in user ${user} failed ${e}`);\n      throw error;\n    }\n  }\n\n  async loginUser(user: PersonModel) {\n    let e: any;\n    try {\n      e = await this.alfrescoApi.login(user.username, user.password);\n    } catch (error) {\n      console.error(`[API Client Factory] Log in user ${user.username} failed ${e}`);\n      throw error;\n    }\n  }\n\n  async createUser(user: PersonModel): Promise<PersonEntry> {\n    const person = new Person(user);\n    const peopleApi = new PeopleApi(this.alfrescoApi);\n\n    try {\n      return peopleApi.createPerson(person);\n    } catch (error) {\n      console.error('[API Client Factory] createUser failed : ', error);\n      return null;\n    }\n  }\n\n  async changePassword(username: string, newPassword: string): Promise<PersonEntry> {\n    const peopleApi = new PeopleApi(this.alfrescoApi);\n\n    try {\n      return peopleApi.updatePerson(username, { password: newPassword });\n    } catch (error) {\n      console.error('[API Client Factory] changePassword failed : ', error);\n      return null;\n    }\n  }\n}\n"]}

package/esm2020/api/categories-api.mjs

@@ -0,0 +1,65 @@
+/*!
+ * 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';
+export class CategoriesApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new CategoriesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createCategory(categoryId, categoryBodyCreate, opts) {
+        try {
+            return this.apiService.categoriesApi.createSubcategories(categoryId, categoryBodyCreate, opts);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async deleteCategory(categoryId) {
+        if (categoryId === null) {
+            console.error('categoryId is null, skipping deletion');
+            return;
+        }
+        try {
+            await this.apiService.categoriesApi.deleteCategory(categoryId);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteCategory.name}: ${error}`);
+        }
+    }
+    async linkNodeToCategory(nodeId, categoryLinkBodyCreate, opts) {
+        try {
+            return this.apiService.categoriesApi.linkNodeToCategory(nodeId, categoryLinkBodyCreate, opts);
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.linkNodeToCategory.name}: ${error}`);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/favorites-api.mjs

@@ -0,0 +1,129 @@
+/*!
+ * 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 { FavoritePaging } from '@alfresco/js-api';
+import { Utils } from '../utils';
+export class FavoritesPageApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new FavoritesPageApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async addFavoriteById(nodeType, id) {
+        const guid = nodeType === 'site' ? (await this.apiService.sites.getSite(id)).entry.guid : id;
+        const data = {
+            target: {
+                [nodeType]: {
+                    guid: guid
+                }
+            }
+        };
+        return this.apiService.favorites.createFavorite('-me-', data);
+    }
+    async addFavoritesByIds(nodeType, ids) {
+        const favorites = [];
+        try {
+            if (ids && ids.length > 0) {
+                for (const id of ids) {
+                    const favorite = await this.addFavoriteById(nodeType, id);
+                    favorites.push(favorite);
+                }
+            }
+        }
+        catch { }
+        return favorites;
+    }
+    async getFavorites(username) {
+        try {
+            return this.apiService.favorites.listFavorites(username);
+        }
+        catch {
+            return new FavoritePaging();
+        }
+    }
+    async isFavorite(username, nodeId) {
+        try {
+            return JSON.stringify((await this.getFavorites(username)).list.entries).includes(nodeId);
+        }
+        catch {
+            return false;
+        }
+    }
+    async isFavoriteWithRetry(username, nodeId, data) {
+        let isFavorite = false;
+        try {
+            const favorite = async () => {
+                isFavorite = await this.isFavorite(username, nodeId);
+                if (isFavorite !== data.expect) {
+                    return Promise.reject(isFavorite);
+                }
+                else {
+                    return Promise.resolve(isFavorite);
+                }
+            };
+            return Utils.retryCall(favorite);
+        }
+        catch (error) { }
+        return isFavorite;
+    }
+    async getFavoritesTotalItems(username) {
+        try {
+            return (await this.apiService.favorites.listFavorites(username)).list.pagination.totalItems;
+        }
+        catch {
+            return -1;
+        }
+    }
+    async waitForApi(username, data) {
+        try {
+            const favoriteFiles = async () => {
+                const totalItems = await this.getFavoritesTotalItems(username);
+                if (totalItems !== data.expect) {
+                    return Promise.reject(totalItems);
+                }
+                else {
+                    return Promise.resolve(totalItems);
+                }
+            };
+            return Utils.retryCall(favoriteFiles);
+        }
+        catch { }
+    }
+    async removeFavoritesByIds(username, ids) {
+        try {
+            if (ids && ids.length > 0) {
+                for (const id of ids) {
+                    await this.apiService.favorites.deleteFavorite(username, id);
+                }
+            }
+        }
+        catch (error) {
+            console.error('FavoritesApi: removeFavoritesByIds failed ', error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"favorites-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/favorites-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 { FavoriteEntry, FavoritePaging } from '@alfresco/js-api';\nimport { Utils } from '../utils';\n\nexport class FavoritesPageApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n  static async initialize(userName: string, password?: string): Promise<FavoritesPageApi> {\n    const classObj = new FavoritesPageApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n  async addFavoriteById(nodeType: 'file' | 'folder' | 'site', id: string): Promise<FavoriteEntry> {\n    const guid = nodeType === 'site' ? (await this.apiService.sites.getSite(id)).entry.guid : id;\n    const data = {\n      target: {\n        [nodeType]: {\n          guid: guid\n        }\n      }\n    };\n    return this.apiService.favorites.createFavorite('-me-', data);\n  }\n\n  async addFavoritesByIds(nodeType: 'file' | 'folder' | 'site', ids: string[]): Promise<FavoriteEntry[]> {\n    const favorites: FavoriteEntry[] = [];\n    try {\n      if (ids && ids.length > 0) {\n        for (const id of ids) {\n          const favorite = await this.addFavoriteById(nodeType, id);\n          favorites.push(favorite);\n        }\n      }\n    } catch {}\n    return favorites;\n  }\n\n  private async getFavorites(username: string): Promise<FavoritePaging> {\n    try {\n      return this.apiService.favorites.listFavorites(username);\n    } catch {\n      return new FavoritePaging();\n    }\n  }\n\n  async isFavorite(username: string, nodeId: string): Promise<boolean> {\n    try {\n      return JSON.stringify((await this.getFavorites(username)).list.entries).includes(nodeId);\n    } catch {\n      return false;\n    }\n  }\n\n  async isFavoriteWithRetry(username: string, nodeId: string, data: { expect: boolean }): Promise<boolean> {\n    let isFavorite = false;\n    try {\n      const favorite = async () => {\n        isFavorite = await this.isFavorite(username, nodeId);\n        if (isFavorite !== data.expect) {\n          return Promise.reject(isFavorite);\n        } else {\n          return Promise.resolve(isFavorite);\n        }\n      };\n      return Utils.retryCall(favorite);\n    } catch (error) {}\n    return isFavorite;\n  }\n\n  async getFavoritesTotalItems(username: string): Promise<number> {\n    try {\n      return (await this.apiService.favorites.listFavorites(username)).list.pagination.totalItems;\n    } catch {\n      return -1;\n    }\n  }\n\n  async waitForApi(username: string, data: { expect: number }) {\n    try {\n      const favoriteFiles = async () => {\n        const totalItems = await this.getFavoritesTotalItems(username);\n        if (totalItems !== data.expect) {\n          return Promise.reject(totalItems);\n        } else {\n          return Promise.resolve(totalItems);\n        }\n      };\n      return Utils.retryCall(favoriteFiles);\n    } catch {}\n  }\n\n  async removeFavoritesByIds(username: string, ids: string[]): Promise<void> {\n    try {\n      if (ids && ids.length > 0) {\n        for (const id of ids) {\n          await this.apiService.favorites.deleteFavorite(username, id);\n        }\n      }\n    } catch (error) {\n      console.error('FavoritesApi: removeFavoritesByIds failed ', error);\n    }\n  }\n}\n"]}

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"]}