@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/api/sites-api.mjs

@@ -0,0 +1,156 @@
+/*!
+ * 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 { Site, SiteMemberEntry } from '@alfresco/js-api';
+export class SitesApi {
+    apiService;
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new SitesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createSite(title, visibility, description, siteId) {
+        const site = {
+            title,
+            visibility: visibility || Site.VisibilityEnum.PUBLIC,
+            description: description,
+            id: siteId || title
+        };
+        try {
+            return this.apiService.sites.createSite(site);
+        }
+        catch (error) {
+            console.error(`SitesApi createSite : catch : `, error);
+            return null;
+        }
+    }
+    async getDocLibId(siteId) {
+        try {
+            return (await this.apiService.sites.listSiteContainers(siteId)).list.entries[0].entry.id;
+        }
+        catch (error) {
+            console.error(`SitesApi getDocLibId : catch : `, error);
+            return null;
+        }
+    }
+    /**
+     * Delete multiple sites/libraries.
+     * @param siteIds The list of the site/library IDs to delete.
+     * @param permanent Delete permanently, without moving to the trashcan? (default: true)
+     */
+    async deleteSites(siteIds, permanent = true) {
+        try {
+            if (siteIds && siteIds.length > 0) {
+                for (const siteId of siteIds) {
+                    await this.apiService.sites.deleteSite(siteId, { permanent });
+                }
+            }
+        }
+        catch (error) {
+            console.error(`${this.constructor.name} ${this.deleteSites.name}`, error);
+        }
+    }
+    async updateSiteMember(siteId, userId, role) {
+        const siteRole = {
+            role: role
+        };
+        try {
+            return this.apiService.sites.updateSiteMembership(siteId, userId, siteRole);
+        }
+        catch (error) {
+            console.error(`SitesApi updateSiteMember : catch : `, error);
+            return new SiteMemberEntry();
+        }
+    }
+    async addSiteMember(siteId, userId, role) {
+        const memberBody = {
+            id: userId,
+            role: role
+        };
+        try {
+            return this.apiService.sites.createSiteMembership(siteId, memberBody);
+        }
+        catch (error) {
+            if (error.status === 409) {
+                return this.updateSiteMember(siteId, userId, role);
+            }
+            else {
+                console.error(`SitesApi addSiteMember : catch : `, error);
+                return new SiteMemberEntry();
+            }
+        }
+    }
+    async createSiteMembershipRequestForPerson(personId, siteId) {
+        const body = {
+            id: siteId
+        };
+        try {
+            return this.apiService.sites.createSiteMembershipRequestForPerson(personId, body);
+        }
+        catch (error) {
+            console.error(`SitesApi createSiteMembershipRequestForPerson : catch : `, error);
+            return null;
+        }
+    }
+    async approveSiteMembershipRequest(siteId, inviteeId) {
+        try {
+            return this.apiService.sites.approveSiteMembershipRequest(siteId, inviteeId);
+        }
+        catch (error) {
+            console.error(`SitesApi approveSiteMembershipRequest : catch : `, error);
+            return null;
+        }
+    }
+    async hasMembershipRequest(personId, siteId) {
+        try {
+            const requests = (await this.apiService.sites.listSiteMembershipRequestsForPerson(personId)).list.entries.map((e) => e.entry.id);
+            return requests.includes(siteId);
+        }
+        catch (error) {
+            console.error(`SitesApi hasMembershipRequest : catch : `, error);
+            return null;
+        }
+    }
+    async deleteSiteMember(siteId, userId) {
+        try {
+            return this.apiService.sites.deleteSiteMembership(siteId, userId);
+        }
+        catch (error) {
+            console.error(`SitesApi deleteSiteMember : catch : `, error);
+        }
+    }
+    async getSite(siteId) {
+        try {
+            return this.apiService.sites.getSite(siteId);
+        }
+        catch (error) {
+            console.error(`SitesApi getSite : catch : `, error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sites-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/sites-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 {\n  Site,\n  SiteBodyCreate,\n  SiteEntry,\n  SiteMemberEntry,\n  SiteMembershipBodyCreate,\n  SiteMembershipBodyUpdate,\n  SiteMembershipRequestBodyCreate,\n  SiteMembershipRequestEntry\n} from '@alfresco/js-api';\n\nexport class SitesApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n  static async initialize(userName: string, password?: string): Promise<SitesApi> {\n    const classObj = new SitesApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  async createSite(title: string, visibility?: string, description?: string, siteId?: string): Promise<SiteEntry | null> {\n    const site = {\n      title,\n      visibility: visibility || Site.VisibilityEnum.PUBLIC,\n      description: description,\n      id: siteId || title\n    } as SiteBodyCreate;\n\n    try {\n      return this.apiService.sites.createSite(site);\n    } catch (error) {\n      console.error(`SitesApi createSite : catch : `, error);\n      return null;\n    }\n  }\n\n  async getDocLibId(siteId: string): Promise<string> {\n    try {\n      return (await this.apiService.sites.listSiteContainers(siteId)).list.entries[0].entry.id;\n    } catch (error) {\n      console.error(`SitesApi getDocLibId : catch : `, error);\n      return null;\n    }\n  }\n\n  /**\n   * Delete multiple sites/libraries.\n   * @param siteIds The list of the site/library IDs to delete.\n   * @param permanent Delete permanently, without moving to the trashcan? (default: true)\n   */\n  async deleteSites(siteIds: string[], permanent: boolean = true) {\n    try {\n      if (siteIds && siteIds.length > 0) {\n        for (const siteId of siteIds) {\n          await this.apiService.sites.deleteSite(siteId, { permanent });\n        }\n      }\n    } catch (error) {\n      console.error(`${this.constructor.name} ${this.deleteSites.name}`, error);\n    }\n  }\n\n  async updateSiteMember(siteId: string, userId: string, role: string): Promise<SiteMemberEntry> {\n    const siteRole = {\n      role: role\n    } as SiteMembershipBodyUpdate;\n\n    try {\n      return this.apiService.sites.updateSiteMembership(siteId, userId, siteRole);\n    } catch (error) {\n      console.error(`SitesApi updateSiteMember : catch : `, error);\n      return new SiteMemberEntry();\n    }\n  }\n\n  async addSiteMember(siteId: string, userId: string, role: string): Promise<SiteMemberEntry> {\n    const memberBody = {\n      id: userId,\n      role: role\n    } as SiteMembershipBodyCreate;\n\n    try {\n      return this.apiService.sites.createSiteMembership(siteId, memberBody);\n    } catch (error) {\n      if (error.status === 409) {\n        return this.updateSiteMember(siteId, userId, role);\n      } else {\n        console.error(`SitesApi addSiteMember : catch : `, error);\n        return new SiteMemberEntry();\n      }\n    }\n  }\n\n  async createSiteMembershipRequestForPerson(personId: string, siteId: string): Promise<SiteMembershipRequestEntry> {\n    const body = {\n      id: siteId\n    } as SiteMembershipRequestBodyCreate;\n\n    try {\n      return this.apiService.sites.createSiteMembershipRequestForPerson(personId, body);\n    } catch (error) {\n      console.error(`SitesApi createSiteMembershipRequestForPerson : catch : `, error);\n      return null;\n    }\n  }\n\n  async approveSiteMembershipRequest(siteId: string, inviteeId: string): Promise<SiteMemberEntry> {\n    try {\n      return this.apiService.sites.approveSiteMembershipRequest(siteId, inviteeId);\n    } catch (error) {\n      console.error(`SitesApi approveSiteMembershipRequest : catch : `, error);\n      return null;\n    }\n  }\n\n  async hasMembershipRequest(personId: string, siteId: string): Promise<boolean> {\n    try {\n      const requests = (await this.apiService.sites.listSiteMembershipRequestsForPerson(personId)).list.entries.map((e) => e.entry.id);\n      return requests.includes(siteId);\n    } catch (error) {\n      console.error(`SitesApi hasMembershipRequest : catch : `, error);\n      return null;\n    }\n  }\n\n  async deleteSiteMember(siteId: string, userId: string) {\n    try {\n      return this.apiService.sites.deleteSiteMembership(siteId, userId);\n    } catch (error) {\n      console.error(`SitesApi deleteSiteMember : catch : `, error);\n    }\n  }\n\n  async getSite(siteId: string): Promise<SiteEntry> {\n    try {\n      return this.apiService.sites.getSite(siteId);\n    } catch (error) {\n      console.error(`SitesApi getSite : catch : `, error);\n      return null;\n    }\n  }\n}\n"]}

package/esm2022/api/tags-api.mjs

@@ -0,0 +1,92 @@
+/*!
+ * 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 TagsApi {
+    apiService;
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new TagsApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async createTags(tags) {
+        try {
+            return this.apiService.tagsApi.createTags(tags);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async assignTagToNode(nodeId, tag) {
+        try {
+            return this.apiService.tagsApi.assignTagToNode(nodeId, tag);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async deleteTags(tagIds) {
+        try {
+            for (const tagId of tagIds) {
+                await this.apiService.tagsApi.deleteTag(tagId);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    async listTagsForNode(nodeId) {
+        try {
+            return this.apiService.tagsApi.listTagsForNode(nodeId);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async listTags(params) {
+        try {
+            return this.apiService.tagsApi.listTags(params);
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    }
+    async deleteTagsByTagName(tagName) {
+        try {
+            const response = await this.listTags({ tag: tagName, matching: true });
+            const tagIds = response.list.entries.map((entry) => entry.entry.id);
+            await this.deleteTags(tagIds);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/api/trashcan-api.mjs

@@ -0,0 +1,52 @@
+/*!
+ * 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 TrashcanApi {
+    apiService = new ApiClientFactory();
+    static async initialize(userName, password) {
+        const classObj = new TrashcanApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    /**
+     * Empties the trashcan. Uses multiple batches 1000 nodes each.
+     */
+    async emptyTrashcan() {
+        try {
+            const nodes = await this.apiService.trashCan.listDeletedNodes({
+                maxItems: 1000
+            });
+            if (nodes?.list?.entries?.length > 0) {
+                const ids = nodes.list.entries.map((entries) => entries.entry.id);
+                for (const nodeId of ids) {
+                    await this.apiService.trashCan.deleteDeletedNode(nodeId);
+                }
+            }
+        }
+        catch (error) {
+            console.error('User Actions - emptyTrashcan failed : ', error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/models/user-model.mjs

@@ -30,11 +30,17 @@ function generateRandomCharset(length = 8, charSet) {
     return text;
 }
 export class UserModel {
+    firstName = generateRandomCharset(7, LOWER_CASE_ALPHA);
+    lastName = generateRandomCharset(7, LOWER_CASE_ALPHA);
+    password = generateRandomCharset(7, LOWER_CASE_ALPHA);
+    email;
+    username;
+    idIdentityService;
+    type = 'enterprise';
+    tenantId;
+    company;
+    id;
     constructor(details = {}) {
-        this.firstName = generateRandomCharset(7, LOWER_CASE_ALPHA);
-        this.lastName = generateRandomCharset(7, LOWER_CASE_ALPHA);
-        this.password = generateRandomCharset(7, LOWER_CASE_ALPHA);
-        this.type = 'enterprise';
         const EMAIL_DOMAIN = 'alfresco';
         this.firstName = details.firstName ?? this.firstName;
         this.lastName = details.lastName ?? this.lastName;
@@ -52,4 +58,4 @@ export class UserModel {
         return `${this.firstName ?? ''} ${this.lastName ?? ''}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1wbGF5d3JpZ2h0LXNoYXJlZC9zcmMvbW9kZWxzL3VzZXItbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFFSCxNQUFNLGdCQUFnQixHQUFHLFlBQVksQ0FBQztBQUV0QyxTQUFTLHFCQUFxQixDQUFDLFNBQWlCLENBQUMsRUFBRSxPQUFlO0lBQ2hFLElBQUksSUFBSSxHQUFHLEVBQUUsQ0FBQztJQUVkLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDL0IsSUFBSSxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7S0FDcEU7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUM7QUFFRCxNQUFNLE9BQU8sU0FBUztJQUNwQixTQUFTLEdBQVkscUJBQXFCLENBQUMsQ0FBQyxFQUFFLGdCQUFnQixDQUFDLENBQUM7SUFDaEUsUUFBUSxHQUFZLHFCQUFxQixDQUFDLENBQUMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO0lBQy9ELFFBQVEsR0FBWSxxQkFBcUIsQ0FBQyxDQUFDLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztJQUMvRCxLQUFLLENBQVU7SUFDZixRQUFRLENBQVU7SUFDbEIsaUJBQWlCLENBQVU7SUFDM0IsSUFBSSxHQUFHLFlBQVksQ0FBQztJQUNwQixRQUFRLENBQVU7SUFDbEIsT0FBTyxDQUFVO0lBQ2pCLEVBQUUsQ0FBUztJQUVYLFlBQVksVUFBZSxFQUFFO1FBQzNCLE1BQU0sWUFBWSxHQUFHLFVBQVUsQ0FBQztRQUNoQyxJQUFJLENBQUMsU0FBUyxHQUFHLE9BQU8sQ0FBQyxTQUFTLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUNyRCxJQUFJLENBQUMsUUFBUSxHQUFHLE9BQU8sQ0FBQyxRQUFRLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUVsRCxNQUFNLGFBQWEsR0FBRyxHQUFHLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLFFBQVEsSUFBSSxxQkFBcUIsQ0FBQyxDQUFDLEVBQUUsZ0JBQWdCLENBQUMsRUFBRSxDQUFDO1FBRXhHLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDO1FBQ2xELElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssSUFBSSxHQUFHLGFBQWEsSUFBSSxZQUFZLE1BQU0sQ0FBQztRQUNyRSxJQUFJLENBQUMsUUFBUSxHQUFHLE9BQU8sQ0FBQyxRQUFRLElBQUksYUFBYSxDQUFDO1FBQ2xELElBQUksQ0FBQyxpQkFBaUIsR0FBRyxPQUFPLENBQUMsaUJBQWlCLElBQUksSUFBSSxDQUFDLGlCQUFpQixDQUFDO1FBQzdFLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQ3RDLElBQUksQ0FBQyxRQUFRLEdBQUcsT0FBTyxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDO1FBQ2xELElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLE9BQU8sSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDO1FBQy9DLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDO0lBQ2xDLENBQUM7SUFFRCxJQUFJLFFBQVE7UUFDVixPQUFPLEdBQUcsSUFBSSxDQUFDLFNBQVMsSUFBSSxFQUFFLElBQUksSUFBSSxDQUFDLFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FBQztJQUMxRCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjQgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuY29uc3QgTE9XRVJfQ0FTRV9BTFBIQSA9ICdoZWxsb3dvcmxkJztcblxuZnVuY3Rpb24gZ2VuZXJhdGVSYW5kb21DaGFyc2V0KGxlbmd0aDogbnVtYmVyID0gOCwgY2hhclNldDogc3RyaW5nKTogc3RyaW5nIHtcbiAgbGV0IHRleHQgPSAnJztcblxuICBmb3IgKGxldCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKSB7XG4gICAgdGV4dCArPSBjaGFyU2V0LmNoYXJBdChNYXRoLmZsb29yKE1hdGgucmFuZG9tKCkgKiBjaGFyU2V0Lmxlbmd0aCkpO1xuICB9XG5cbiAgcmV0dXJuIHRleHQ7XG59XG5cbmV4cG9ydCBjbGFzcyBVc2VyTW9kZWwge1xuICBmaXJzdE5hbWU/OiBzdHJpbmcgPSBnZW5lcmF0ZVJhbmRvbUNoYXJzZXQoNywgTE9XRVJfQ0FTRV9BTFBIQSk7XG4gIGxhc3ROYW1lPzogc3RyaW5nID0gZ2VuZXJhdGVSYW5kb21DaGFyc2V0KDcsIExPV0VSX0NBU0VfQUxQSEEpO1xuICBwYXNzd29yZD86IHN0cmluZyA9IGdlbmVyYXRlUmFuZG9tQ2hhcnNldCg3LCBMT1dFUl9DQVNFX0FMUEhBKTtcbiAgZW1haWw/OiBzdHJpbmc7XG4gIHVzZXJuYW1lPzogc3RyaW5nO1xuICBpZElkZW50aXR5U2VydmljZT86IHN0cmluZztcbiAgdHlwZSA9ICdlbnRlcnByaXNlJztcbiAgdGVuYW50SWQ/OiBudW1iZXI7XG4gIGNvbXBhbnk/OiBzdHJpbmc7XG4gIGlkOiBudW1iZXI7XG5cbiAgY29uc3RydWN0b3IoZGV0YWlsczogYW55ID0ge30pIHtcbiAgICBjb25zdCBFTUFJTF9ET01BSU4gPSAnYWxmcmVzY28nO1xuICAgIHRoaXMuZmlyc3ROYW1lID0gZGV0YWlscy5maXJzdE5hbWUgPz8gdGhpcy5maXJzdE5hbWU7XG4gICAgdGhpcy5sYXN0TmFtZSA9IGRldGFpbHMubGFzdE5hbWUgPz8gdGhpcy5sYXN0TmFtZTtcblxuICAgIGNvbnN0IFVTRVJfSURFTlRJRlkgPSBgJHt0aGlzLmZpcnN0TmFtZX0ke3RoaXMubGFzdE5hbWV9LiR7Z2VuZXJhdGVSYW5kb21DaGFyc2V0KDcsIExPV0VSX0NBU0VfQUxQSEEpfWA7XG5cbiAgICB0aGlzLnBhc3N3b3JkID0gZGV0YWlscy5wYXNzd29yZCA/PyB0aGlzLnBhc3N3b3JkO1xuICAgIHRoaXMuZW1haWwgPSBkZXRhaWxzLmVtYWlsID8/IGAke1VTRVJfSURFTlRJRll9QCR7RU1BSUxfRE9NQUlOfS5jb21gO1xuICAgIHRoaXMudXNlcm5hbWUgPSBkZXRhaWxzLnVzZXJuYW1lID8/IFVTRVJfSURFTlRJRlk7XG4gICAgdGhpcy5pZElkZW50aXR5U2VydmljZSA9IGRldGFpbHMuaWRJZGVudGl0eVNlcnZpY2UgPz8gdGhpcy5pZElkZW50aXR5U2VydmljZTtcbiAgICB0aGlzLnR5cGUgPSBkZXRhaWxzLnR5cGUgPz8gdGhpcy50eXBlO1xuICAgIHRoaXMudGVuYW50SWQgPSBkZXRhaWxzLnRlbmFudElkID8/IHRoaXMudGVuYW50SWQ7XG4gICAgdGhpcy5jb21wYW55ID0gZGV0YWlscy5jb21wYW55ID8/IHRoaXMuY29tcGFueTtcbiAgICB0aGlzLmlkID0gZGV0YWlscy5pZCA/PyB0aGlzLmlkO1xuICB9XG5cbiAgZ2V0IGZ1bGxOYW1lKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGAke3RoaXMuZmlyc3ROYW1lID8/ICcnfSAke3RoaXMubGFzdE5hbWUgPz8gJyd9YDtcbiAgfVxufVxuIl19

package/esm2022/page-objects/components/aca-header.component.mjs

@@ -0,0 +1,78 @@
+/*!
+ * 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 { expect } from '@playwright/test';
+import { MatMenuComponent } from './dataTable';
+import { BaseComponent } from './base.component';
+class AcaHeader extends BaseComponent {
+    static rootElement = 'aca-toolbar';
+    moreActionsButton = this.getChild('button[id="app.viewer.toolbar.more"]');
+    toolbarMoreActions = this.getChild('button[id="app.toolbar.more"]');
+    createButton = this.getChild('[id="app.toolbar.create"]');
+    viewDetails = this.getChild('[title="View Details"]');
+    viewButton = this.getChild('button[title="View"]');
+    searchButton = this.getChild('button[id="app.toolbar.search"]');
+    fullScreenButton = this.getChild('button[id="app.viewer.fullscreen"]');
+    shareButton = this.getChild('button[id="share-action-button"]');
+    downloadButtonViewer = this.getChild('button[id="app.viewer.download"]');
+    downloadButton = this.getChild('button[id="app.toolbar.download"]');
+    sharedDownloadButton = this.getChild('button[id="app.viewer.shared.download"]');
+    uploadButton = this.getChild('button[id="app.toolbar.upload"]');
+    uploadFileButton = this.page.locator('button[id="app.create.uploadFile"]');
+    uploadInput = this.page.locator('input[id="app-upload-files"]');
+    uploadNewVersionButton = this.page.locator('#app-upload-file-version');
+    permanentlyDeleteButton = this.getChild('button[id="app.toolbar.purgeDeletedNodes"]');
+    restoreButton = this.getChild('button[id="app.toolbar.restoreDeletedNodes"]');
+    constructor(page) {
+        super(page, AcaHeader.rootElement);
+    }
+    matMenu = new MatMenuComponent(this.page);
+    async clickViewerMoreActions() {
+        await this.moreActionsButton.waitFor({ state: 'attached' });
+        await this.moreActionsButton.click();
+    }
+    async clickMoreActions() {
+        await this.toolbarMoreActions.waitFor({ state: 'attached' });
+        await this.toolbarMoreActions.click();
+    }
+    async clickCreateFolderFromTemplate() {
+        await this.createButton.click();
+        await this.matMenu.createFolderFromTemplate.click();
+    }
+    async verifyToolbarPrimaryActions(expectedToolbarPrimary) {
+        const buttons = await this.page.$$('aca-toolbar button');
+        const actualPrimaryActions = await Promise.all(buttons.map(async (button) => {
+            const title = await button.getAttribute('title');
+            return title || '';
+        }));
+        for (const action of expectedToolbarPrimary) {
+            expect(actualPrimaryActions.includes(action), `Expected to contain ${action}`).toBe(true);
+        }
+    }
+    async clickCreateFileFromTemplate() {
+        await this.createButton.click();
+        await this.matMenu.createFileFromTemplate.click();
+    }
+}
+export { AcaHeader };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aca-header.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/aca-header.component.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 { Page, expect } from '@playwright/test';\nimport { MatMenuComponent } from './dataTable';\nimport { BaseComponent } from './base.component';\n\nexport class AcaHeader extends BaseComponent {\n  private static rootElement = 'aca-toolbar';\n  private moreActionsButton = this.getChild('button[id=\"app.viewer.toolbar.more\"]');\n  private toolbarMoreActions = this.getChild('button[id=\"app.toolbar.more\"]');\n  public createButton = this.getChild('[id=\"app.toolbar.create\"]');\n  public viewDetails = this.getChild('[title=\"View Details\"]');\n  public viewButton = this.getChild('button[title=\"View\"]');\n  public searchButton = this.getChild('button[id=\"app.toolbar.search\"]');\n  public fullScreenButton = this.getChild('button[id=\"app.viewer.fullscreen\"]');\n  public shareButton = this.getChild('button[id=\"share-action-button\"]');\n  public downloadButtonViewer = this.getChild('button[id=\"app.viewer.download\"]');\n  public downloadButton = this.getChild('button[id=\"app.toolbar.download\"]');\n  public sharedDownloadButton = this.getChild('button[id=\"app.viewer.shared.download\"]');\n  public uploadButton = this.getChild('button[id=\"app.toolbar.upload\"]');\n  public uploadFileButton = this.page.locator('button[id=\"app.create.uploadFile\"]');\n  public uploadInput = this.page.locator('input[id=\"app-upload-files\"]');\n  public uploadNewVersionButton = this.page.locator('#app-upload-file-version');\n  public permanentlyDeleteButton = this.getChild('button[id=\"app.toolbar.purgeDeletedNodes\"]');\n  public restoreButton = this.getChild('button[id=\"app.toolbar.restoreDeletedNodes\"]');\n\n  constructor(page: Page) {\n    super(page, AcaHeader.rootElement);\n  }\n  public matMenu = new MatMenuComponent(this.page);\n\n  async clickViewerMoreActions(): Promise<void> {\n    await this.moreActionsButton.waitFor({ state: 'attached' });\n    await this.moreActionsButton.click();\n  }\n\n  async clickMoreActions(): Promise<void> {\n    await this.toolbarMoreActions.waitFor({ state: 'attached' });\n    await this.toolbarMoreActions.click();\n  }\n\n  async clickCreateFolderFromTemplate(): Promise<void> {\n    await this.createButton.click();\n    await this.matMenu.createFolderFromTemplate.click();\n  }\n\n  async verifyToolbarPrimaryActions(expectedToolbarPrimary: string[]): Promise<void> {\n    const buttons = await this.page.$$('aca-toolbar button');\n    const actualPrimaryActions: string[] = await Promise.all(\n      buttons.map(async (button) => {\n        const title = await button.getAttribute('title');\n        return title || '';\n      })\n    );\n\n    for (const action of expectedToolbarPrimary) {\n      expect(actualPrimaryActions.includes(action), `Expected to contain ${action}`).toBe(true);\n    }\n  }\n\n  async clickCreateFileFromTemplate(): Promise<void> {\n    await this.createButton.click();\n    await this.matMenu.createFileFromTemplate.click();\n  }\n}\n"]}

package/esm2022/page-objects/components/actions-dropdown.component.mjs

@@ -0,0 +1,100 @@
+/*!
+ * 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 { BaseComponent } from './base.component';
+export var ActionType;
+(function (ActionType) {
+    ActionType["AddAspect"] = "Add aspect";
+    ActionType["SimpleWorkflow"] = "Add simple workflow";
+    ActionType["IncrementCounter"] = "Increment Counter";
+    ActionType["CheckIn"] = "Check in";
+    ActionType["AutoDeclareOptions"] = "Auto-Declare Options";
+    ActionType["CheckOut"] = "Check out";
+    ActionType["Copy"] = "Copy";
+    ActionType["ExecuteScript"] = "Execute script";
+    ActionType["ExtractCommonMetadataFields"] = "Extract common metadata fields";
+    ActionType["FileAsRecord"] = "File as Record";
+    ActionType["FileVersionAsRecord"] = "File Version as Record";
+    ActionType["HideRecord"] = "Hide Record";
+    ActionType["Import"] = "Import";
+    ActionType["Move"] = "Move";
+    ActionType["RemoveAspect"] = "Remove aspect";
+    ActionType["RequestAIRenditions"] = "Request AI renditions";
+    ActionType["SendEmail"] = "Send email";
+    ActionType["SetPropertyValue"] = "Set property value";
+    ActionType["SpecialiseType"] = "Specialise type";
+    ActionType["TransformAndCopyContent"] = "Transform and copy content";
+    ActionType["TransformAndCopyImage"] = "Transform and copy image";
+})(ActionType || (ActionType = {}));
+class ActionsDropdownComponent extends BaseComponent {
+    static rootElement = 'aca-edit-rule-dialog aca-rule-action-list';
+    getOptionLocator = (optionName) => this.page.locator('.mat-mdc-select-panel .mdc-list-item__primary-text', { hasText: optionName }).first();
+    ruleActionLocator = this.getChild('aca-rule-action');
+    addActionButtonLocator = this.getChild('[data-automation-id="rule-action-list-add-action-button"]');
+    actionDropdownLocator = this.getChild('[data-automation-id="rule-action-select"]');
+    actionAspectNameLocator = '[data-automation-id="header-aspect-name"] .adf-property-field';
+    actionCheckInInputLocator = '[data-automation-id="header-description"] input';
+    actionAutoDeclareLocator = '[data-automation-id="header-version"] mat-select';
+    actionSimpleWorkflowStepInputLocator = '[data-automation-id="header-approve-step"] input';
+    actionSimpleWorkflowApproveFolderLocator = `[data-automation-id="header-approve-folder"] mat-icon`;
+    actionSimpleWorkflowActionChoiceLocator = '[data-automation-id="content-node-selector-actions-choose"]';
+    actionSimpleWorkflowLabelApproveLocator = `[data-automation-id="card-boolean-label-approve-move"]`;
+    actionSimpleWorkflowSRejectStepLocator = '[data-automation-id="header-reject-step"] input';
+    actionSimpleWorkflowRejectFolderLocator = `[data-automation-id="header-reject-folder"] input`;
+    constructor(page) {
+        super(page, ActionsDropdownComponent.rootElement);
+    }
+    async selectAction(action, index) {
+        if (index > 0) {
+            await this.addActionButtonLocator.click();
+        }
+        await this.actionDropdownLocator.nth(index).hover({ timeout: 1000 });
+        await this.actionDropdownLocator.nth(index).click();
+        const option = this.getOptionLocator(action);
+        await option.click();
+    }
+    async dropdownSelection(selectValue, locator, index) {
+        await this.ruleActionLocator.nth(index).locator(locator).click();
+        await this.getOptionLocator(selectValue).nth(0).click();
+    }
+    async insertCheckInActionValues(checkInValue, index) {
+        await this.ruleActionLocator.nth(index).locator(this.actionCheckInInputLocator).fill(checkInValue);
+    }
+    async insertAddAspectActionValues(AspectValue, index) {
+        await this.dropdownSelection(AspectValue, this.actionAspectNameLocator, index);
+    }
+    async insertAutoDeclareOptionsActionValues(autoDeclareOptionsValue, index) {
+        await this.dropdownSelection(autoDeclareOptionsValue, this.actionAutoDeclareLocator, index);
+    }
+    async insertSimpleWorkflowActionValues(stepValue, index) {
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowStepInputLocator).fill(stepValue);
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowApproveFolderLocator).click();
+        await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowLabelApproveLocator).click();
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowSRejectStepLocator).fill(stepValue);
+        await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowRejectFolderLocator).click();
+        await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();
+    }
+}
+export { ActionsDropdownComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"actions-dropdown.component.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/components/actions-dropdown.component.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 { Locator, Page } from '@playwright/test';\nimport { BaseComponent } from './base.component';\n\nexport enum ActionType {\n  AddAspect = 'Add aspect',\n  SimpleWorkflow = 'Add simple workflow',\n  IncrementCounter = 'Increment Counter',\n  CheckIn = 'Check in',\n  AutoDeclareOptions = 'Auto-Declare Options',\n  CheckOut = 'Check out',\n  Copy = 'Copy',\n  ExecuteScript = 'Execute script',\n  ExtractCommonMetadataFields = 'Extract common metadata fields',\n  FileAsRecord = 'File as Record',\n  FileVersionAsRecord = 'File Version as Record',\n  HideRecord = 'Hide Record',\n  Import = 'Import',\n  Move = 'Move',\n  RemoveAspect = 'Remove aspect',\n  RequestAIRenditions = 'Request AI renditions',\n  SendEmail = 'Send email',\n  SetPropertyValue = 'Set property value',\n  SpecialiseType = 'Specialise type',\n  TransformAndCopyContent = 'Transform and copy content',\n  TransformAndCopyImage = 'Transform and copy image'\n}\n\nexport class ActionsDropdownComponent extends BaseComponent {\n  private static rootElement = 'aca-edit-rule-dialog aca-rule-action-list';\n\n  private getOptionLocator = (optionName: string): Locator =>\n    this.page.locator('.mat-mdc-select-panel .mdc-list-item__primary-text', { hasText: optionName }).first();\n  private ruleActionLocator = this.getChild('aca-rule-action');\n  private addActionButtonLocator = this.getChild('[data-automation-id=\"rule-action-list-add-action-button\"]');\n  private actionDropdownLocator = this.getChild('[data-automation-id=\"rule-action-select\"]');\n  private actionAspectNameLocator = '[data-automation-id=\"header-aspect-name\"] .adf-property-field';\n  private actionCheckInInputLocator = '[data-automation-id=\"header-description\"] input';\n  private actionAutoDeclareLocator = '[data-automation-id=\"header-version\"] mat-select';\n  private actionSimpleWorkflowStepInputLocator = '[data-automation-id=\"header-approve-step\"] input';\n  private actionSimpleWorkflowApproveFolderLocator = `[data-automation-id=\"header-approve-folder\"] mat-icon`;\n  private actionSimpleWorkflowActionChoiceLocator = '[data-automation-id=\"content-node-selector-actions-choose\"]';\n  private actionSimpleWorkflowLabelApproveLocator = `[data-automation-id=\"card-boolean-label-approve-move\"]`;\n  private actionSimpleWorkflowSRejectStepLocator = '[data-automation-id=\"header-reject-step\"] input';\n  private actionSimpleWorkflowRejectFolderLocator = `[data-automation-id=\"header-reject-folder\"] input`;\n\n  constructor(page: Page) {\n    super(page, ActionsDropdownComponent.rootElement);\n  }\n\n  async selectAction(action: Partial<ActionType>, index: number): Promise<void> {\n    if (index > 0) {\n      await this.addActionButtonLocator.click();\n    }\n    await this.actionDropdownLocator.nth(index).hover({ timeout: 1000 });\n    await this.actionDropdownLocator.nth(index).click();\n    const option = this.getOptionLocator(action);\n    await option.click();\n  }\n\n  async dropdownSelection(selectValue: string, locator: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(locator).click();\n    await this.getOptionLocator(selectValue).nth(0).click();\n  }\n\n  async insertCheckInActionValues(checkInValue: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(this.actionCheckInInputLocator).fill(checkInValue);\n  }\n\n  async insertAddAspectActionValues(AspectValue: string, index: number): Promise<void> {\n    await this.dropdownSelection(AspectValue, this.actionAspectNameLocator, index);\n  }\n\n  async insertAutoDeclareOptionsActionValues(autoDeclareOptionsValue: string, index: number): Promise<void> {\n    await this.dropdownSelection(autoDeclareOptionsValue, this.actionAutoDeclareLocator, index);\n  }\n\n  async insertSimpleWorkflowActionValues(stepValue: string, index: number): Promise<void> {\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowStepInputLocator).fill(stepValue);\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowApproveFolderLocator).click();\n    await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowLabelApproveLocator).click();\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowSRejectStepLocator).fill(stepValue);\n    await this.ruleActionLocator.nth(index).locator(this.actionSimpleWorkflowRejectFolderLocator).click();\n    await this.page.locator(this.actionSimpleWorkflowActionChoiceLocator).click();\n  }\n}\n"]}