@alfresco/aca-playwright-shared 5.1.1-10706961491

package/base-config/global-variables.d.ts

@@ -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 declare const testEmailDomain: string;
+export declare const users: {
+    hruser: {
+        username: string;
+        password: string;
+    };
+    admin: {
+        username: string;
+        password: string;
+    };
+};

package/base-config/global.setup.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * 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 { FullConfig } from '@playwright/test';
+import { CustomConfig } from '../models';
+declare function globalSetup(config: FullConfig<CustomConfig>): Promise<void>;
+export default globalSetup;

package/base-config/index.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * 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 './global.setup';
+export * from './playwright.config';
+export * from './global-variables';

package/base-config/playwright.config.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * 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 { PlaywrightTestConfig } from '@playwright/test';
+export declare const getGlobalConfig: PlaywrightTestConfig;

package/base-config/report-portal.config.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * 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 { ReporterDescription } from '@playwright/test';
+export declare const getReportPortalConfig: () => {
+    endpoint: string;
+    apiKey: string;
+    project: string;
+    launch: string;
+    includeTestSteps: boolean;
+    restClientConfig: {
+        timeout: number;
+    };
+    attributes: {
+        key: string;
+        value: string;
+    }[];
+    description: string;
+};
+export declare const getReporter: () => ReporterDescription[];

package/esm2020/alfresco-aca-playwright-shared.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxmcmVzY28tYWNhLXBsYXl3cmlnaHQtc2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNhLXBsYXl3cmlnaHQtc2hhcmVkL3NyYy9hbGZyZXNjby1hY2EtcGxheXdyaWdodC1zaGFyZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAiB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,OAAO,gBAAgB;IAG3B;QACE,IAAI,CAAC,UAAU,GAAG,IAAI,gBAAgB,EAAE,CAAC;IAC3C,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,QAAgB,EAAE,QAAiB;QACzD,MAAM,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC9D,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,KAAK,CAAC,eAAe,CAAC,QAAoC,EAAE,EAAU;QACpE,MAAM,IAAI,GAAG,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7F,MAAM,IAAI,GAAG;YACX,MAAM,EAAE;gBACN,CAAC,QAAQ,CAAC,EAAE;oBACV,IAAI,EAAE,IAAI;iBACX;aACF;SACF,CAAC;QACF,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAChE,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,QAAoC,EAAE,GAAa;QACzE,MAAM,SAAS,GAAoB,EAAE,CAAC;QACtC,IAAI;YACF,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzB,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;oBACpB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;oBAC1D,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBAC1B;aACF;SACF;QAAC,MAAM,GAAE;QACV,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,YAAY,CAAC,QAAgB;QACzC,IAAI;YACF,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;SAC1D;QAAC,MAAM;YACN,OAAO,IAAI,cAAc,EAAE,CAAC;SAC7B;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,QAAgB,EAAE,MAAc;QAC/C,IAAI;YACF,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SAC1F;QAAC,MAAM;YACN,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,QAAgB,EAAE,MAAc,EAAE,IAAyB;QACnF,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,IAAI;YACF,MAAM,QAAQ,GAAG,KAAK,IAAI,EAAE;gBAC1B,UAAU,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBACrD,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM,EAAE;oBAC9B,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;iBACnC;qBAAM;oBACL,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;iBACpC;YACH,CAAC,CAAC;YACF,OAAO,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;SAClC;QAAC,OAAO,KAAK,EAAE,GAAE;QAClB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,sBAAsB,CAAC,QAAgB;QAC3C,IAAI;YACF,OAAO,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;SAC7F;QAAC,MAAM;YACN,OAAO,CAAC,CAAC,CAAC;SACX;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,QAAgB,EAAE,IAAwB;QACzD,IAAI;YACF,MAAM,aAAa,GAAG,KAAK,IAAI,EAAE;gBAC/B,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;gBAC/D,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM,EAAE;oBAC9B,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;iBACnC;qBAAM;oBACL,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;iBACpC;YACH,CAAC,CAAC;YACF,OAAO,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;SACvC;QAAC,MAAM,GAAE;IACZ,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,QAAgB,EAAE,GAAa;QACxD,IAAI;YACF,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzB,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;oBACpB,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;iBAC9D;aACF;SACF;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,CAAC,KAAK,CAAC,4CAA4C,EAAE,KAAK,CAAC,CAAC;SACpE;IACH,CAAC;CACF","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"]}