@alfresco/aca-playwright-shared 5.1.1 → 5.2.0

package/esm2022/page-objects/components/dataTable/data-table.component.mjs

@@ -0,0 +1,343 @@
+/*!
+ * 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';
+import { MatMenuComponent } from './mat-menu.component';
+import { PaginationActionsType, PaginationComponent } from '../pagination.component';
+import { timeouts } from '../../../utils';
+class DataTableComponent extends BaseComponent {
+    static rootElement = 'adf-datatable';
+    contextMenuActions = new MatMenuComponent(this.page);
+    constructor(page, rootElement = DataTableComponent.rootElement) {
+        super(page, rootElement);
+    }
+    pagination = new PaginationComponent(this.page);
+    body = this.getChild('.adf-datatable-body');
+    getEmptyFolderLocator = this.getChild('.adf-empty-folder');
+    getEmptyContentTitleLocator = this.getChild('adf-empty-content .adf-empty-content__title');
+    getEmptyContentSubTitleLocator = this.getChild('adf-empty-content .adf-empty-content__subtitle');
+    getSelectedRow = this.getChild('.adf-datatable-row.adf-is-selected');
+    sortedColumnHeader = this.getChild(`.adf-datatable__header--sorted-asc .adf-datatable-cell-header-content .adf-datatable-cell-value,
+                                      .adf-datatable__header--sorted-desc .adf-datatable-cell-header-content .adf-datatable-cell-value`);
+    columnHeaders = this.getChild('.adf-datatable-row .adf-datatable-cell-header .adf-datatable-cell-value');
+    emptyList = this.getChild('div.adf-no-content-container');
+    emptyListTitle = this.getChild('.adf-empty-content__title');
+    emptyListSubtitle = this.getChild('.adf-empty-content__subtitle');
+    emptySearchText = this.getChild('.empty-search__text');
+    emptyListTest = this.getChild('adf-custom-empty-content-template');
+    paginationButton = this.page.locator('.adf-pagination__block button').nth(0);
+    paginationOptions = this.page.locator('#cdk-overlay-0 button');
+    sitesVisibility = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="Visibility"]');
+    sitesName = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="Name"]');
+    sitesRole = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="My Role"]');
+    lockOwner = this.page.locator('.aca-locked-by--name');
+    uncheckedCheckbox = this.page.locator('.mat-mdc-checkbox');
+    checkedCheckbox = this.page.locator('.mat-mdc-checkbox-checked');
+    highlightedText = '.aca-highlight';
+    searchFileName = '.search-file-name';
+    searchFileDescription = '[data-automation-id="search-results-entry-description"]';
+    searchFileContent = '.aca-result-content';
+    /** Locator for row (or rows) */
+    getRowLocator = this.page.getByRole('rowgroup').nth(1).locator('adf-datatable-row');
+    /** Locator to get "No results found" message */
+    getNoResultsFoundMessage = this.getChild('adf-custom-empty-content-template', { hasText: 'No results found' });
+    /**
+     * Method used in cases where we want to check that some record is visible in the datatable. It will consider whole row
+     *
+     * @returns reference to cell element which contains text.
+     */
+    getRowByName = (name) => this.getChild(`adf-datatable-row`, { hasText: name.toString() });
+    /**
+     * Method used in cases where we want to check that some record is visible in the datatable.
+     * But we want to check it by column header title and value of this column.
+     *
+     * @returns reference to cell element which contains text.
+     */
+    getRowByColumnTitleAndItsCellValue = (columnTitle, cellValue) => this.page.locator(`//div[contains(@title, '${columnTitle}')]//span[contains(text(), '${cellValue}')]/ancestor::adf-datatable-row`);
+    /**
+     * Method used in cases where we want to retrieve a row from the datatable based on its numerical order within the array.
+     *
+     * @returns reference to cell element which contains text.
+     */
+    getNthRow = (orderNum) => this.getRowLocator.nth(orderNum);
+    /**
+     * Method used in cases where user have possibility to navigate "inside" the element (it's clickable and has link attribute).
+     * Perform action .click() to navigate inside it
+     *
+     * @returns reference to cell element which contains link.
+     */
+    getCellLinkByName = (name) => this.getChild('.adf-cell-value span[role="link"]', { hasText: name });
+    /**
+     * Method used in cases where we want to localize the element by [aria-label]
+     *
+     * @returns reference to cell element.
+     */
+    getByAriaLabelTitle = (title) => this.getChild(`[aria-label="${title}"]`);
+    /**
+     * Method used in cases where we want to get the button (hamburger menu) for row element
+     *
+     * @returns reference to menu placed in row localized by the name
+     */
+    getActionsButtonByName = (name) => this.getRowByName(name).locator('mat-icon', { hasText: new RegExp(`^\\s*more_vert\\s*$`, 'g') });
+    /**
+     * Method used in cases where we want to get the edit button and there is no hamburger menu
+     *
+     * @returns reference to edit button placed in row localized by the name
+     */
+    getEditButtonByName = (name) => this.getRowByName(name).locator('button#editButton');
+    /**
+     * Method used in cases where we want to get the button and there is no hamburger menu
+     *
+     * @returns reference to button placed in row localized by the name
+     */
+    getButtonByNameForSpecificRow = (elementTitleInRow, buttonTitle) => this.getRowByName(elementTitleInRow).locator('button', { hasText: buttonTitle });
+    /**
+     * Method used in cases where you want to get some specific cell (by column name) for row which contains some name/title/etc.
+     *
+     * @returns reference to cell element
+     */
+    getCellByColumnNameAndRowItem = (item, columnName) => this.getRowByName(item).locator(`[title="${columnName}"]`);
+    /**
+     * Method used in cases where we want to get the checkbox for row element
+     *
+     * @returns reference to checkbox placed in row localized by the name
+     */
+    getCheckboxForElement = (item) => this.getRowByName(item).locator('.mat-mdc-checkbox');
+    getColumnHeaderByTitleLocator = (headerTitle) => this.getChild('[role="columnheader"]', { hasText: headerTitle });
+    getSearchResultLinkByName = (name) => this.getChild('.aca-search-results-row span[role="link"]', { hasText: name });
+    getColumnValuesByName = (name) => this.getChild(`div[title="${name}"] span`);
+    getColumnHeaderByName = (headerTitle) => this.getChild('.adf-datatable-row .adf-datatable-cell-header .adf-datatable-cell-value', { hasText: headerTitle });
+    async sortBy(label, order) {
+        const sortColumn = await this.getSortedColumnHeaderText();
+        let sortOrder = await this.getSortingOrder();
+        if (sortColumn !== label) {
+            await this.getColumnHeaderByName(label).hover();
+            await this.getColumnHeaderByName(label).click({ force: true });
+            sortOrder = await this.getSortingOrder();
+        }
+        if (sortOrder !== order) {
+            await this.getChild('span[class*="adf-datatable__header--sorted"]').click();
+        }
+    }
+    /**
+     * This method is used when we want to perform right mouse click on the dataTable row and perform some action
+     *
+     * @param name of the data table element with which we want to click
+     * @param action provide which action you want to perform
+     */
+    async performActionFromExpandableMenu(name, action) {
+        await this.goThroughPagesLookingForRowWithName(name);
+        const actionButtonLocator = await this.getActionLocatorFromExpandableMenu(name, action);
+        await actionButtonLocator.click();
+        await this.spinnerWaitForReload();
+    }
+    /**
+     * Click action from the expandable kebab menu for the element in datatable
+     *
+     * @param name title of the record you would like to proceed
+     * @param action provide button title for the action
+     * @param subAction if the action is in sub menu, then provide it here
+     */
+    async performActionForElement(name, action, subAction) {
+        await this.getActionsButtonByName(name).click();
+        await this.contextMenuActions.getButtonByText(action).click();
+        if (subAction) {
+            await this.contextMenuActions.getButtonByText(subAction).click();
+        }
+    }
+    /**
+     * This method is used when we want to perform double click on the dataTable row to open a file or folder
+     *
+     * @param name of the data table element with which we want to double click
+     */
+    async performClickFolderOrFileToOpen(name) {
+        await this.getCellLinkByName(name).click();
+        await this.spinnerWaitForReload();
+    }
+    async isItemPresent(name) {
+        await this.goThroughPagesLookingForRowWithName(name);
+        return this.getRowByName(name).isVisible();
+    }
+    async getActionLocatorFromExpandableMenu(name, action) {
+        await this.getRowByName(name).click({ button: 'right' });
+        return this.contextMenuActions.getButtonByText(action);
+    }
+    async performActionInExpandableMenu(name, action) {
+        await this.getRowByName(name).click({ button: 'right' });
+        await this.contextMenuActions.getButtonByText(action).click();
+    }
+    async goThroughPagesLookingForRowWithName(name) {
+        await this.spinnerWaitForReload();
+        if (await this.getRowByName(name).isVisible()) {
+            return null;
+        }
+        if (await this.pagination.currentPageLocator.isVisible()) {
+            if ((await this.pagination.currentPageLocator.textContent()) === ' of 1 ') {
+                return null;
+            }
+        }
+        if (await this.pagination.totalPageLocator.isVisible()) {
+            const maxPages = (await this.pagination.totalPageLocator?.textContent())?.match(/\d/)[0];
+            for (let page = 1; page <= Number(maxPages); page++) {
+                if (await this.getRowByName(name).isVisible()) {
+                    break;
+                }
+                if (await this.pagination.getArrowLocatorFor(PaginationActionsType.NextPageSelector).isEnabled()) {
+                    await this.pagination.getArrowLocatorFor(PaginationActionsType.NextPageSelector).click();
+                }
+                await this.spinnerWaitForReload();
+            }
+        }
+    }
+    async selectItems(...names) {
+        for (const name of names) {
+            const isSelected = await this.isRowSelected(name);
+            if (!isSelected) {
+                const row = this.getRowByName(name);
+                await row.hover();
+                await row.locator(this.uncheckedCheckbox).click();
+                await row.locator(this.checkedCheckbox).waitFor({ state: 'attached' });
+            }
+        }
+    }
+    async isRowSelected(itemName) {
+        const row = this.getRowByName(itemName);
+        return row.locator(this.checkedCheckbox).isVisible();
+    }
+    async getColumnHeaders() {
+        const columnNameLocator = this.columnHeaders;
+        await this.columnHeaders.nth(0).waitFor({ state: 'attached' });
+        return columnNameLocator.allTextContents();
+    }
+    async getSortedColumnHeaderText() {
+        return this.sortedColumnHeader.innerText();
+    }
+    getItemLocationEl(name) {
+        return this.getRowByName(name).locator('.aca-location-link');
+    }
+    async getItemLocationText(name) {
+        await this.getItemLocationEl(name).locator('a').waitFor({ state: 'attached' });
+        return this.getItemLocationEl(name).innerText();
+    }
+    async getItemLocationTooltip(name) {
+        const location = this.getItemLocationEl(name);
+        await location.hover();
+        return location.locator('a').getAttribute('title', { timeout: timeouts.normal });
+    }
+    async clickItemLocation(name) {
+        await this.getItemLocationEl(name).click();
+    }
+    async getSortingOrder() {
+        const str = await this.sortedColumnHeader.locator('../..').getAttribute('class');
+        if (str.includes('asc')) {
+            return 'asc';
+        }
+        else if (str.includes('desc')) {
+            return 'desc';
+        }
+        return 'none';
+    }
+    async getRowAllInnerTexts(name) {
+        return (await this.getRowByName(name).locator('span').allInnerTexts()).toString();
+    }
+    async getFirstElementDetail(name) {
+        const firstNode = this.getColumnValuesByName(name).first();
+        return firstNode.innerText();
+    }
+    async isEmpty() {
+        return this.emptyList.isVisible();
+    }
+    async getEmptyStateTitle() {
+        return (await this.isEmpty()) ? this.emptyListTitle.innerText() : '';
+    }
+    async getEmptyStateSubtitle() {
+        return (await this.isEmpty()) ? this.emptyListSubtitle.innerText() : '';
+    }
+    async getEmptyListText() {
+        return (await this.isEmpty()) ? this.emptyListTest.innerText() : '';
+    }
+    async getRowsCount() {
+        return this.getRowLocator.count();
+    }
+    async rightClickOnItem(itemName) {
+        await this.getCellByColumnNameAndRowItem(itemName, 'Name').click({ button: 'right' });
+    }
+    async setPaginationTo50() {
+        await this.paginationButton.click();
+        await this.paginationOptions.getByText('50').click();
+    }
+    /**
+     * Method used to create objects from names and visibility of sites from datatable
+     *
+     * @returns an object with sites' names and their corresponding visibility values
+     */
+    async getSitesNameAndVisibility() {
+        const rowsCount = await this.sitesName.count();
+        const sitesInfo = {};
+        for (let i = 0; i < rowsCount; i++) {
+            let siteVisibilityText = await this.sitesVisibility.nth(i).textContent();
+            let siteNameText = await this.sitesName.nth(i).textContent();
+            siteVisibilityText = siteVisibilityText.trim().toUpperCase();
+            siteNameText = siteNameText.trim();
+            sitesInfo[siteNameText] = siteVisibilityText;
+        }
+        return sitesInfo;
+    }
+    /**
+     * Method used to create objects from names and roles of sites from datatable
+     *
+     * @returns an object with sites' names and their corresponding role values
+     */
+    async getSitesNameAndRole() {
+        const rowsCount = await this.sitesName.count();
+        const sitesInfo = {};
+        for (let i = 0; i < rowsCount; i++) {
+            let siteNameText = await this.sitesName.nth(i).textContent();
+            let siteRoleText = await this.sitesRole.nth(i).textContent();
+            siteNameText = siteNameText.trim();
+            siteRoleText = siteRoleText.trim();
+            sitesInfo[siteNameText] = siteRoleText;
+        }
+        return sitesInfo;
+    }
+    async hasLockIcon(itemName) {
+        const row = this.getRowByName(itemName);
+        return row.locator('img[src*="lock"]').isVisible();
+    }
+    async getLockOwner(itemName) {
+        const row = this.getRowByName(itemName);
+        return row.locator(this.lockOwner).innerText();
+    }
+    async hasHighlightedText(location) {
+        switch (location) {
+            case 'name':
+                return this.page.locator(this.searchFileName).locator(this.highlightedText).isVisible();
+            case 'description':
+                return this.page.locator(this.searchFileDescription).locator(this.highlightedText).isVisible();
+            case 'content':
+                return this.page.locator(this.searchFileContent).locator(this.highlightedText).isVisible();
+        }
+    }
+}
+export { DataTableComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-playwright-shared/src/page-objects/components/dataTable/data-table.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';\nimport { MatMenuComponent } from './mat-menu.component';\nimport { PaginationActionsType, PaginationComponent } from '../pagination.component';\nimport { timeouts } from '../../../utils';\n\nexport class DataTableComponent extends BaseComponent {\n  private static rootElement = 'adf-datatable';\n  contextMenuActions = new MatMenuComponent(this.page);\n\n  constructor(page: Page, rootElement = DataTableComponent.rootElement) {\n    super(page, rootElement);\n  }\n\n  public pagination = new PaginationComponent(this.page);\n  body = this.getChild('.adf-datatable-body');\n  getEmptyFolderLocator = this.getChild('.adf-empty-folder');\n  getEmptyContentTitleLocator = this.getChild('adf-empty-content .adf-empty-content__title');\n  getEmptyContentSubTitleLocator = this.getChild('adf-empty-content .adf-empty-content__subtitle');\n  getSelectedRow = this.getChild('.adf-datatable-row.adf-is-selected');\n  sortedColumnHeader = this.getChild(`.adf-datatable__header--sorted-asc .adf-datatable-cell-header-content .adf-datatable-cell-value,\n                                      .adf-datatable__header--sorted-desc .adf-datatable-cell-header-content .adf-datatable-cell-value`);\n  columnHeaders = this.getChild('.adf-datatable-row .adf-datatable-cell-header .adf-datatable-cell-value');\n  emptyList = this.getChild('div.adf-no-content-container');\n  emptyListTitle = this.getChild('.adf-empty-content__title');\n  emptyListSubtitle = this.getChild('.adf-empty-content__subtitle');\n  emptySearchText = this.getChild('.empty-search__text');\n  emptyListTest = this.getChild('adf-custom-empty-content-template');\n  paginationButton = this.page.locator('.adf-pagination__block button').nth(0);\n  paginationOptions = this.page.locator('#cdk-overlay-0 button');\n  sitesVisibility = this.page.locator('.adf-datatable-body [data-automation-id*=\"datatable-row\"] [aria-label=\"Visibility\"]');\n  sitesName = this.page.locator('.adf-datatable-body [data-automation-id*=\"datatable-row\"] [aria-label=\"Name\"]');\n  sitesRole = this.page.locator('.adf-datatable-body [data-automation-id*=\"datatable-row\"] [aria-label=\"My Role\"]');\n  lockOwner = this.page.locator('.aca-locked-by--name');\n  uncheckedCheckbox = this.page.locator('.mat-mdc-checkbox');\n  checkedCheckbox = this.page.locator('.mat-mdc-checkbox-checked');\n  highlightedText = '.aca-highlight';\n  searchFileName = '.search-file-name';\n  searchFileDescription = '[data-automation-id=\"search-results-entry-description\"]';\n  searchFileContent = '.aca-result-content';\n\n  /** Locator for row (or rows) */\n  getRowLocator = this.page.getByRole('rowgroup').nth(1).locator('adf-datatable-row');\n\n  /** Locator to get \"No results found\" message */\n  getNoResultsFoundMessage = this.getChild('adf-custom-empty-content-template', { hasText: 'No results found' });\n\n  /**\n   * Method used in cases where we want to check that some record is visible in the datatable. It will consider whole row\n   *\n   * @returns reference to cell element which contains text.\n   */\n  getRowByName = (name: string | number): Locator => this.getChild(`adf-datatable-row`, { hasText: name.toString() });\n\n  /**\n   * Method used in cases where we want to check that some record is visible in the datatable.\n   * But we want to check it by column header title and value of this column.\n   *\n   * @returns reference to cell element which contains text.\n   */\n  getRowByColumnTitleAndItsCellValue = (columnTitle: string, cellValue: string | number): Locator =>\n    this.page.locator(`//div[contains(@title, '${columnTitle}')]//span[contains(text(), '${cellValue}')]/ancestor::adf-datatable-row`);\n\n  /**\n   * Method used in cases where we want to retrieve a row from the datatable based on its numerical order within the array.\n   *\n   * @returns reference to cell element which contains text.\n   */\n  getNthRow = (orderNum: number): Locator => this.getRowLocator.nth(orderNum);\n\n  /**\n   * Method used in cases where user have possibility to navigate \"inside\" the element (it's clickable and has link attribute).\n   * Perform action .click() to navigate inside it\n   *\n   * @returns reference to cell element which contains link.\n   */\n  getCellLinkByName = (name: string): Locator => this.getChild('.adf-cell-value span[role=\"link\"]', { hasText: name });\n\n  /**\n   * Method used in cases where we want to localize the element by [aria-label]\n   *\n   * @returns reference to cell element.\n   */\n  getByAriaLabelTitle = (title: string): Locator => this.getChild(`[aria-label=\"${title}\"]`);\n\n  /**\n   * Method used in cases where we want to get the button (hamburger menu) for row element\n   *\n   * @returns reference to menu placed in row localized by the name\n   */\n  getActionsButtonByName = (name: string): Locator =>\n    this.getRowByName(name).locator('mat-icon', { hasText: new RegExp(`^\\\\s*more_vert\\\\s*$`, 'g') });\n\n  /**\n   * Method used in cases where we want to get the edit button and there is no hamburger menu\n   *\n   * @returns reference to edit button placed in row localized by the name\n   */\n  getEditButtonByName = (name: string): Locator => this.getRowByName(name).locator('button#editButton');\n\n  /**\n   * Method used in cases where we want to get the button and there is no hamburger menu\n   *\n   * @returns reference to button placed in row localized by the name\n   */\n  getButtonByNameForSpecificRow = (elementTitleInRow: string, buttonTitle: string): Locator =>\n    this.getRowByName(elementTitleInRow).locator('button', { hasText: buttonTitle });\n\n  /**\n   * Method used in cases where you want to get some specific cell (by column name) for row which contains some name/title/etc.\n   *\n   * @returns reference to cell element\n   */\n  getCellByColumnNameAndRowItem = (item: string | number, columnName: string): Locator => this.getRowByName(item).locator(`[title=\"${columnName}\"]`);\n\n  /**\n   * Method used in cases where we want to get the checkbox for row element\n   *\n   * @returns reference to checkbox placed in row localized by the name\n   */\n  getCheckboxForElement = (item: string): Locator => this.getRowByName(item).locator('.mat-mdc-checkbox');\n\n  getColumnHeaderByTitleLocator = (headerTitle: string): Locator => this.getChild('[role=\"columnheader\"]', { hasText: headerTitle });\n\n  getSearchResultLinkByName = (name: string): Locator => this.getChild('.aca-search-results-row span[role=\"link\"]', { hasText: name });\n\n  getColumnValuesByName = (name: string): Locator => this.getChild(`div[title=\"${name}\"] span`);\n\n  getColumnHeaderByName = (headerTitle: string): Locator =>\n    this.getChild('.adf-datatable-row .adf-datatable-cell-header .adf-datatable-cell-value', { hasText: headerTitle });\n\n  async sortBy(label: string, order: 'asc' | 'desc'): Promise<void> {\n    const sortColumn = await this.getSortedColumnHeaderText();\n    let sortOrder = await this.getSortingOrder();\n    if (sortColumn !== label) {\n      await this.getColumnHeaderByName(label).hover();\n      await this.getColumnHeaderByName(label).click({ force: true });\n      sortOrder = await this.getSortingOrder();\n    }\n    if (sortOrder !== order) {\n      await this.getChild('span[class*=\"adf-datatable__header--sorted\"]').click();\n    }\n  }\n\n  /**\n   * This method is used when we want to perform right mouse click on the dataTable row and perform some action\n   *\n   * @param name of the data table element with which we want to click\n   * @param action provide which action you want to perform\n   */\n  async performActionFromExpandableMenu(name: string | number, action: string): Promise<void> {\n    await this.goThroughPagesLookingForRowWithName(name);\n    const actionButtonLocator = await this.getActionLocatorFromExpandableMenu(name, action);\n    await actionButtonLocator.click();\n    await this.spinnerWaitForReload();\n  }\n\n  /**\n   * Click action from the expandable kebab menu for the element in datatable\n   *\n   * @param name title of the record you would like to proceed\n   * @param action provide button title for the action\n   * @param subAction if the action is in sub menu, then provide it here\n   */\n  async performActionForElement(name: string, action: string, subAction?: string): Promise<void> {\n    await this.getActionsButtonByName(name).click();\n    await this.contextMenuActions.getButtonByText(action).click();\n\n    if (subAction) {\n      await this.contextMenuActions.getButtonByText(subAction).click();\n    }\n  }\n\n  /**\n   * This method is used when we want to perform double click on the dataTable row to open a file or folder\n   *\n   * @param name of the data table element with which we want to double click\n   */\n  async performClickFolderOrFileToOpen(name: string): Promise<void> {\n    await this.getCellLinkByName(name).click();\n    await this.spinnerWaitForReload();\n  }\n\n  async isItemPresent(name: string): Promise<boolean> {\n    await this.goThroughPagesLookingForRowWithName(name);\n    return this.getRowByName(name).isVisible();\n  }\n\n  async getActionLocatorFromExpandableMenu(name: string | number, action: string): Promise<Locator> {\n    await this.getRowByName(name).click({ button: 'right' });\n    return this.contextMenuActions.getButtonByText(action);\n  }\n\n  async performActionInExpandableMenu(name: string | number, action: string): Promise<void> {\n    await this.getRowByName(name).click({ button: 'right' });\n    await this.contextMenuActions.getButtonByText(action).click();\n  }\n\n  async goThroughPagesLookingForRowWithName(name: string | number): Promise<void> {\n    await this.spinnerWaitForReload();\n    if (await this.getRowByName(name).isVisible()) {\n      return null;\n    }\n\n    if (await this.pagination.currentPageLocator.isVisible()) {\n      if ((await this.pagination.currentPageLocator.textContent()) === ' of 1 ') {\n        return null;\n      }\n    }\n    if (await this.pagination.totalPageLocator.isVisible()) {\n      const maxPages = (await this.pagination.totalPageLocator?.textContent())?.match(/\\d/)[0];\n      for (let page = 1; page <= Number(maxPages); page++) {\n        if (await this.getRowByName(name).isVisible()) {\n          break;\n        }\n        if (await this.pagination.getArrowLocatorFor(PaginationActionsType.NextPageSelector).isEnabled()) {\n          await this.pagination.getArrowLocatorFor(PaginationActionsType.NextPageSelector).click();\n        }\n        await this.spinnerWaitForReload();\n      }\n    }\n  }\n\n  async selectItems(...names: string[]): Promise<void> {\n    for (const name of names) {\n      const isSelected = await this.isRowSelected(name);\n      if (!isSelected) {\n        const row = this.getRowByName(name);\n        await row.hover();\n        await row.locator(this.uncheckedCheckbox).click();\n        await row.locator(this.checkedCheckbox).waitFor({ state: 'attached' });\n      }\n    }\n  }\n\n  async isRowSelected(itemName: string): Promise<boolean> {\n    const row = this.getRowByName(itemName);\n    return row.locator(this.checkedCheckbox).isVisible();\n  }\n\n  async getColumnHeaders(): Promise<Array<string>> {\n    const columnNameLocator = this.columnHeaders;\n    await this.columnHeaders.nth(0).waitFor({ state: 'attached' });\n    return columnNameLocator.allTextContents();\n  }\n\n  async getSortedColumnHeaderText(): Promise<string> {\n    return this.sortedColumnHeader.innerText();\n  }\n\n  private getItemLocationEl(name: string): Locator {\n    return this.getRowByName(name).locator('.aca-location-link');\n  }\n\n  async getItemLocationText(name: string): Promise<string> {\n    await this.getItemLocationEl(name).locator('a').waitFor({ state: 'attached' });\n    return this.getItemLocationEl(name).innerText();\n  }\n\n  async getItemLocationTooltip(name: string): Promise<string> {\n    const location = this.getItemLocationEl(name);\n    await location.hover();\n    return location.locator('a').getAttribute('title', { timeout: timeouts.normal });\n  }\n\n  async clickItemLocation(name: string): Promise<void> {\n    await this.getItemLocationEl(name).click();\n  }\n\n  async getSortingOrder(): Promise<string> {\n    const str = await this.sortedColumnHeader.locator('../..').getAttribute('class');\n    if (str.includes('asc')) {\n      return 'asc';\n    } else if (str.includes('desc')) {\n      return 'desc';\n    }\n    return 'none';\n  }\n\n  async getRowAllInnerTexts(name: string): Promise<string> {\n    return (await this.getRowByName(name).locator('span').allInnerTexts()).toString();\n  }\n\n  async getFirstElementDetail(name: string): Promise<string> {\n    const firstNode = this.getColumnValuesByName(name).first();\n    return firstNode.innerText();\n  }\n\n  async isEmpty(): Promise<boolean> {\n    return this.emptyList.isVisible();\n  }\n\n  async getEmptyStateTitle(): Promise<string> {\n    return (await this.isEmpty()) ? this.emptyListTitle.innerText() : '';\n  }\n\n  async getEmptyStateSubtitle(): Promise<string> {\n    return (await this.isEmpty()) ? this.emptyListSubtitle.innerText() : '';\n  }\n\n  async getEmptyListText(): Promise<string> {\n    return (await this.isEmpty()) ? this.emptyListTest.innerText() : '';\n  }\n\n  async getRowsCount(): Promise<number> {\n    return this.getRowLocator.count();\n  }\n\n  async rightClickOnItem(itemName: string): Promise<void> {\n    await this.getCellByColumnNameAndRowItem(itemName, 'Name').click({ button: 'right' });\n  }\n\n  async setPaginationTo50(): Promise<void> {\n    await this.paginationButton.click();\n    await this.paginationOptions.getByText('50').click();\n  }\n\n  /**\n   * Method used to create objects from names and visibility of sites from datatable\n   *\n   * @returns an object with sites' names and their corresponding visibility values\n   */\n  async getSitesNameAndVisibility(): Promise<{ [siteName: string]: string }> {\n    const rowsCount = await this.sitesName.count();\n    const sitesInfo: { [siteName: string]: string } = {};\n    for (let i = 0; i < rowsCount; i++) {\n      let siteVisibilityText = await this.sitesVisibility.nth(i).textContent();\n      let siteNameText = await this.sitesName.nth(i).textContent();\n      siteVisibilityText = siteVisibilityText.trim().toUpperCase();\n      siteNameText = siteNameText.trim();\n      sitesInfo[siteNameText] = siteVisibilityText;\n    }\n    return sitesInfo;\n  }\n\n  /**\n   * Method used to create objects from names and roles of sites from datatable\n   *\n   * @returns an object with sites' names and their corresponding role values\n   */\n  async getSitesNameAndRole(): Promise<{ [siteName: string]: string }> {\n    const rowsCount = await this.sitesName.count();\n    const sitesInfo: { [siteName: string]: string } = {};\n    for (let i = 0; i < rowsCount; i++) {\n      let siteNameText = await this.sitesName.nth(i).textContent();\n      let siteRoleText = await this.sitesRole.nth(i).textContent();\n      siteNameText = siteNameText.trim();\n      siteRoleText = siteRoleText.trim();\n      sitesInfo[siteNameText] = siteRoleText;\n    }\n    return sitesInfo;\n  }\n\n  async hasLockIcon(itemName: string): Promise<boolean> {\n    const row = this.getRowByName(itemName);\n    return row.locator('img[src*=\"lock\"]').isVisible();\n  }\n\n  async getLockOwner(itemName: string): Promise<string> {\n    const row = this.getRowByName(itemName);\n    return row.locator(this.lockOwner).innerText();\n  }\n\n  async hasHighlightedText(location: 'name' | 'description' | 'content'): Promise<boolean> {\n    switch (location) {\n      case 'name':\n        return this.page.locator(this.searchFileName).locator(this.highlightedText).isVisible();\n      case 'description':\n        return this.page.locator(this.searchFileDescription).locator(this.highlightedText).isVisible();\n      case 'content':\n        return this.page.locator(this.searchFileContent).locator(this.highlightedText).isVisible();\n    }\n  }\n}\n"]}

package/esm2022/page-objects/components/dataTable/mat-menu.component.mjs

@@ -0,0 +1,67 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { expect } from '@playwright/test';
+import { BaseComponent } from '../base.component';
+class MatMenuComponent extends BaseComponent {
+    static rootElement = '.mat-mdc-menu-content';
+    constructor(page) {
+        super(page, MatMenuComponent.rootElement);
+    }
+    getMenuItemsLocator = this.getChild('button');
+    getMenuItemTextLocator = this.getChild('[data-automation-id="menu-item-title"]');
+    createFolder = this.getChild('[id="app.create.folder"]');
+    createFolderFromTemplate = this.getChild('[id="app.create.folderFromTemplate"]');
+    createFileFromTemplate = this.getChild('[id="app.create.fileFromTemplate"]');
+    createLibrary = this.getChild('[id="app.create.library"]');
+    getButtonByText = (text) => this.getChild('button', { hasText: text });
+    getMenuItemFromHeaderMenu = (text) => this.page.getByRole('menuitem', { name: text, exact: true });
+    async clickMenuItem(menuItem) {
+        const menuElement = this.getButtonByText(menuItem);
+        await menuElement.click();
+        await menuElement.waitFor({ state: 'detached' });
+    }
+    async clickMenuItemFromHeaderMenu(menuItem) {
+        const menuElement = this.getMenuItemFromHeaderMenu(menuItem);
+        await menuElement.click();
+        await menuElement.waitFor({ state: 'detached' });
+    }
+    async isMenuItemVisible(menuItem) {
+        const menuElement = this.getButtonByText(menuItem);
+        await menuElement.waitFor({ state: 'attached' });
+        return menuElement.isVisible();
+    }
+    async verifyActualMoreActions(expectedToolbarMore) {
+        await this.page.locator('.mat-mdc-menu-content').waitFor({ state: 'attached' });
+        const menus = await this.page.$$('.mat-mdc-menu-content .mat-mdc-menu-item');
+        const actualMoreActions = await Promise.all(menus.map(async (button) => {
+            const title = await (await button.$('.mat-mdc-menu-item-text span')).innerText();
+            return title || '';
+        }));
+        for (const action of expectedToolbarMore) {
+            expect(actualMoreActions.includes(action), `Expected to contain ${action} ${actualMoreActions}`).toBe(true);
+        }
+    }
+}
+export { MatMenuComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020/page-objects/components/dialogs/manage-versions-dialog.component.mjs → esm2022/page-objects/components/dataTable/toolbar.component.mjs}

@@ -22,14 +22,19 @@
  * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
  */
 import { BaseComponent } from '../base.component';
-export class ManageVersionsDialog extends BaseComponent {
-    async viewFileVersion(version) {
-        const versionActionsButton = this.page.locator(`[id="adf-version-list-action-menu-button-${version}"]`);
-        await versionActionsButton.click();
-    }
+class ToolbarComponent extends BaseComponent {
+    static rootElement = 'adf-toolbar';
+    createRuleButton = this.getChild('[data-automation-id="manage-rules-create-button"]');
+    linkRulesButton = this.getChild('[data-automation-id="manage-rules-link-button"]');
     constructor(page) {
-        super(page, ManageVersionsDialog.rootElement);
+        super(page, ToolbarComponent.rootElement);
+    }
+    async clickCreateRuleButton() {
+        await this.createRuleButton.click();
+    }
+    async clickLinkRulesButton() {
+        await this.linkRulesButton.click();
     }
 }
-ManageVersionsDialog.rootElement = '.adf-new-version-uploader-dialog';
-//# sourceMappingURL=data:application/json;base64,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
+export { ToolbarComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/components/datetime-picker/datetime-picker.component.mjs

@@ -0,0 +1,53 @@
+/*!
+ * 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';
+class DateTimePicker extends BaseComponent {
+    static rootElement = '.mat-calendar';
+    calendar = this.getChild('.mat-datepicker-popup');
+    dayPicker = this.getChild('mat-month-view');
+    nextMonthBtn = this.getChild('.mat-calendar-next-button');
+    rootElemLocator = this.page.locator('.mat-datepicker-popup');
+    constructor(page) {
+        super(page, DateTimePicker.rootElement);
+    }
+    async isCalendarOpen() {
+        const element = this.rootElemLocator;
+        return element.isVisible();
+    }
+    async pickDateTime() {
+        const today = new Date();
+        const nextAvailableDay = new Date();
+        nextAvailableDay.setDate(today.getDate() + 2);
+        if (nextAvailableDay.getMonth() !== today.getMonth()) {
+            await this.nextMonthBtn.click();
+        }
+        await this.selectDay(nextAvailableDay.getDate());
+    }
+    async selectDay(day) {
+        const firstActiveDayElem = this.dayPicker.locator(`text=${day}`).first();
+        await firstActiveDayElem.click();
+    }
+}
+export { DateTimePicker };
+//# sourceMappingURL=data:application/json;base64,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