@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/page-objects/components/base.component.mjs

@@ -0,0 +1,69 @@
+/*!
+ * 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 { PlaywrightBase } from '../playwright-base';
+import { timeouts } from '../../utils';
+export class BaseComponent extends PlaywrightBase {
+    constructor(page, rootElement) {
+        super(page);
+        this.overlayElement = this.page.locator('.cdk-overlay-backdrop-showing');
+        this.progressBar = this.page.locator('mat-progress-bar');
+        this.rootElement = rootElement;
+    }
+    /**
+     * Method which should be used across the repository, while creating
+     * reference to elements, which are in root element of component.
+     *
+     * @param cssLocator css selector as String. Need to be in the tree under the root element
+     * @param options if you want to localize it by text, then provide an optional hasText
+     * @returns Locator object
+     */
+    getChild(cssLocator, options) {
+        return this.page.locator(`${this.rootElement} ${cssLocator}`, options);
+    }
+    async closeAdditionalOverlayElementIfVisible() {
+        if (await this.overlayElement.isVisible()) {
+            await this.page.keyboard.press('Escape');
+            await this.overlayElement.waitFor({ state: 'detached', timeout: timeouts.medium });
+        }
+    }
+    async spinnerWaitForReload() {
+        try {
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'attached', timeout: timeouts.medium });
+            await this.page.locator('mat-progress-spinner').waitFor({ state: 'detached', timeout: timeouts.normal });
+        }
+        catch (e) {
+            this.logger.info('Spinner was not present');
+        }
+    }
+    async progressBarWaitForReload() {
+        try {
+            await this.progressBar.waitFor({ state: 'visible', timeout: timeouts.medium });
+            await this.progressBar.waitFor({ state: 'hidden', timeout: timeouts.normal });
+        }
+        catch (e) {
+            this.logger.info('Progress bar was not present');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/page-objects/components/breadcrumb/breadcrumb.component.mjs

@@ -0,0 +1,46 @@
+/*!
+ * 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 class Breadcrumb extends BaseComponent {
+    constructor(page) {
+        super(page, Breadcrumb.rootElement);
+        this.items = this.getChild('.adf-breadcrumb-item');
+        this.currentItem = this.getChild('.adf-breadcrumb-item-current');
+        this.getItemByTitle = (name) => this.getChild(`.adf-breadcrumb-item[title=${name}]`);
+    }
+    async getAllItems() {
+        const itemElements = await this.page.$$('adf-breadcrumb .adf-breadcrumb-item');
+        const itemTexts = await Promise.all(itemElements.map(async (elem) => {
+            const text = await elem.innerText();
+            return text.split('\nchevron_right')[0];
+        }));
+        return itemTexts;
+    }
+    async clickItem(name) {
+        const elem = this.getChild(`.adf-breadcrumb-item[title=${name}]`);
+        await elem.click();
+    }
+}
+Breadcrumb.rootElement = 'adf-breadcrumb';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/page-objects/components/conditions.component.mjs

@@ -0,0 +1,75 @@
+/*!
+ * 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 { ManageRulesDialogComponent } from './manageRules/manage-rules-dialog.component';
+export var Field;
+(function (Field) {
+    Field["Name"] = "Name";
+    Field["Size"] = "Size";
+    Field["Mimetype"] = "Mimetype";
+    Field["Encoding"] = "Encoding";
+    Field["HasCategory"] = "Has category";
+    Field["HasTag"] = "Has tag";
+    Field["HasAspect"] = "Has aspect";
+})(Field || (Field = {}));
+export var Comparator;
+(function (Comparator) {
+    Comparator["Equals"] = "(=) Equals";
+    Comparator["Contains"] = "Contains";
+    Comparator["StartsWith"] = "Starts with";
+    Comparator["EndsWith"] = "Ends with";
+})(Comparator || (Comparator = {}));
+export class ConditionComponent extends ManageRulesDialogComponent {
+    constructor() {
+        super(...arguments);
+        this.getOptionLocator = (optionName) => this.page.locator(`.cdk-overlay-pane .mat-mdc-option span`, { hasText: optionName });
+    }
+    async selectField(fields, index) {
+        await this.fieldDropDown.nth(index).click();
+        const option = this.getOptionLocator(fields);
+        await option.click();
+    }
+    async selectComparator(comparators, index) {
+        await this.comparatorDropDown.nth(index).click();
+        const option = this.getOptionLocator(comparators);
+        await option.click();
+    }
+    async addCondition(fields, value, index, comparators) {
+        await this.addConditionButton.first().click();
+        await this.selectField(fields, index);
+        if (comparators) {
+            await this.selectComparator(comparators, index);
+        }
+        await this.valueField.nth(index).fill(value);
+    }
+    async addConditionGroup(fields, value, index, comparators) {
+        await this.addConditionGroupButton.last().click();
+        await this.addConditionButton.nth(index).click();
+        await this.selectField(fields, index);
+        if (comparators) {
+            await this.selectComparator(comparators, index);
+        }
+        await this.valueField.nth(index).fill(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,327 @@
+/*!
+ * 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';
+export class DataTableComponent extends BaseComponent {
+    constructor(page, rootElement = DataTableComponent.rootElement) {
+        super(page, rootElement);
+        this.contextMenuActions = new MatMenuComponent(this.page);
+        this.pagination = new PaginationComponent(this.page);
+        this.body = this.getChild('.adf-datatable-body');
+        this.getEmptyFolderLocator = this.getChild('.adf-empty-folder');
+        this.getEmptyContentTitleLocator = this.getChild('adf-empty-content .adf-empty-content__title');
+        this.getEmptyContentSubTitleLocator = this.getChild('adf-empty-content .adf-empty-content__subtitle');
+        this.getSelectedRow = this.getChild('.adf-datatable-row.adf-is-selected');
+        this.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`);
+        this.columnHeaders = this.getChild('.adf-datatable-row .adf-datatable-cell-header .adf-datatable-cell-value');
+        this.emptyList = this.getChild('div.adf-no-content-container');
+        this.emptyListTitle = this.getChild('.adf-empty-content__title');
+        this.emptyListSubtitle = this.getChild('.adf-empty-content__subtitle');
+        this.emptySearchText = this.getChild('.empty-search__text');
+        this.emptyListTest = this.getChild('adf-custom-empty-content-template');
+        this.paginationButton = this.page.locator('.adf-pagination__block button').nth(0);
+        this.paginationOptions = this.page.locator('#cdk-overlay-0 button');
+        this.sitesVisibility = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="Visibility"]');
+        this.sitesName = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="Name"]');
+        this.sitesRole = this.page.locator('.adf-datatable-body [data-automation-id*="datatable-row"] [aria-label="My Role"]');
+        this.lockOwner = this.page.locator('.aca-locked-by--name');
+        this.uncheckedCheckbox = this.page.locator('.mat-mdc-checkbox');
+        this.checkedCheckbox = this.page.locator('.mat-mdc-checkbox-checked');
+        /** Locator for row (or rows) */
+        this.getRowLocator = this.page.getByRole('rowgroup').nth(1).locator('adf-datatable-row');
+        /** Locator to get "No results found" message */
+        this.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.
+         */
+        this.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.
+         */
+        this.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.
+         */
+        this.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.
+         */
+        this.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.
+         */
+        this.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
+         */
+        this.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
+         */
+        this.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
+         */
+        this.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
+         */
+        this.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
+         */
+        this.getCheckboxForElement = (item) => this.getRowByName(item).locator('.mat-mdc-checkbox');
+        this.getColumnHeaderByTitleLocator = (headerTitle) => this.getChild('[role="columnheader"]', { hasText: headerTitle });
+        this.getSearchResultLinkByName = (name) => this.getChild('.aca-search-results-row span[role="link"]', { hasText: name });
+        this.getColumnValuesByName = (name) => this.getChild(`div[title="${name}"] span`);
+        this.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).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();
+    }
+}
+DataTableComponent.rootElement = 'adf-datatable';
+//# 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\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).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"]}