@alfresco/aca-playwright-shared 5.1.1 → 6.0.0-11114941325

package/esm2022/page-objects/pages/search.page.mjs

@@ -0,0 +1,79 @@
+/*!
+ * 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 { BasePage } from './base.page';
+import { DataTableComponent, MatMenuComponent, ViewerComponent, SearchInputComponent, SearchOverlayComponent, SidenavComponent, SearchSortingPicker, SearchFilters, SearchFiltersTags, SearchFiltersCategories, SearchFiltersDate, SearchFiltersLocation, SearchFiltersLogic, SearchFiltersProperties } from '../components';
+import { AcaHeader } from '../components/aca-header.component';
+import { AdfConfirmDialogComponent, AdfFolderDialogComponent, UploadNewVersionDialog, ManageVersionsDialog } from '../components/dialogs';
+class SearchPage extends BasePage {
+    static pageUrl = 'search';
+    constructor(page) {
+        super(page, SearchPage.pageUrl);
+    }
+    acaHeader = new AcaHeader(this.page);
+    matMenu = new MatMenuComponent(this.page);
+    folderDialog = new AdfFolderDialogComponent(this.page);
+    dataTable = new DataTableComponent(this.page);
+    viewer = new ViewerComponent(this.page);
+    searchInput = new SearchInputComponent(this.page);
+    searchOverlay = new SearchOverlayComponent(this.page);
+    searchSortingPicker = new SearchSortingPicker(this.page);
+    searchFilters = new SearchFilters(this.page);
+    searchFiltersTags = new SearchFiltersTags(this.page);
+    searchFiltersCategories = new SearchFiltersCategories(this.page);
+    searchFiltersDate = new SearchFiltersDate(this.page);
+    searchFiltersLocation = new SearchFiltersLocation(this.page);
+    searchFiltersProperties = new SearchFiltersProperties(this.page);
+    searchFiltersLogic = new SearchFiltersLogic(this.page);
+    sidenav = new SidenavComponent(this.page);
+    confirmDialogComponent = new AdfConfirmDialogComponent(this.page);
+    uploadNewVersionDialog = new UploadNewVersionDialog(this.page);
+    manageVersionsDialog = new ManageVersionsDialog(this.page);
+    async searchWithin(searchText, searchType) {
+        await this.acaHeader.searchButton.click();
+        await this.clickSearchButton();
+        switch (searchType) {
+            case 'files':
+                await this.searchOverlay.checkOnlyFiles();
+                break;
+            case 'folders':
+                await this.searchOverlay.checkOnlyFolders();
+                break;
+            case 'filesAndFolders':
+                await this.searchOverlay.checkFilesAndFolders();
+                break;
+            case 'libraries':
+                await this.searchOverlay.checkLibraries();
+                break;
+            default:
+                break;
+        }
+        await this.searchOverlay.searchFor(searchText);
+        await this.dataTable.progressBarWaitForReload();
+    }
+    async clickSearchButton() {
+        await this.searchInput.searchButton.click({ force: true });
+    }
+}
+export { SearchPage };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.page.js","sourceRoot":"","sources":["../../../../../../projects/aca-playwright-shared/src/page-objects/pages/search.page.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 } from '@playwright/test';\nimport { BasePage } from './base.page';\nimport {\n  DataTableComponent,\n  MatMenuComponent,\n  ViewerComponent,\n  SearchInputComponent,\n  SearchOverlayComponent,\n  SidenavComponent,\n  SearchSortingPicker,\n  SearchFilters,\n  SearchFiltersTags,\n  SearchFiltersCategories,\n  SearchFiltersDate,\n  SearchFiltersLocation,\n  SearchFiltersLogic,\n  SearchFiltersProperties\n} from '../components';\nimport { AcaHeader } from '../components/aca-header.component';\nimport { AdfConfirmDialogComponent, AdfFolderDialogComponent, UploadNewVersionDialog, ManageVersionsDialog } from '../components/dialogs';\n\nexport type SearchType = 'files' | 'folders' | 'filesAndFolders' | 'libraries';\n\nexport class SearchPage extends BasePage {\n  private static pageUrl = 'search';\n\n  constructor(page: Page) {\n    super(page, SearchPage.pageUrl);\n  }\n\n  public acaHeader = new AcaHeader(this.page);\n  public matMenu = new MatMenuComponent(this.page);\n  public folderDialog = new AdfFolderDialogComponent(this.page);\n  public dataTable = new DataTableComponent(this.page);\n  public viewer = new ViewerComponent(this.page);\n  public searchInput = new SearchInputComponent(this.page);\n  public searchOverlay = new SearchOverlayComponent(this.page);\n  public searchSortingPicker = new SearchSortingPicker(this.page);\n  public searchFilters = new SearchFilters(this.page);\n  public searchFiltersTags = new SearchFiltersTags(this.page);\n  public searchFiltersCategories = new SearchFiltersCategories(this.page);\n  public searchFiltersDate = new SearchFiltersDate(this.page);\n  public searchFiltersLocation = new SearchFiltersLocation(this.page);\n  public searchFiltersProperties = new SearchFiltersProperties(this.page);\n  public searchFiltersLogic = new SearchFiltersLogic(this.page);\n  public sidenav = new SidenavComponent(this.page);\n  public confirmDialogComponent = new AdfConfirmDialogComponent(this.page);\n  public uploadNewVersionDialog = new UploadNewVersionDialog(this.page);\n  public manageVersionsDialog = new ManageVersionsDialog(this.page);\n\n  async searchWithin(searchText: string, searchType: SearchType): Promise<void> {\n    await this.acaHeader.searchButton.click();\n    await this.clickSearchButton();\n    switch (searchType) {\n      case 'files':\n        await this.searchOverlay.checkOnlyFiles();\n        break;\n      case 'folders':\n        await this.searchOverlay.checkOnlyFolders();\n        break;\n      case 'filesAndFolders':\n        await this.searchOverlay.checkFilesAndFolders();\n        break;\n      case 'libraries':\n        await this.searchOverlay.checkLibraries();\n        break;\n      default:\n        break;\n    }\n    await this.searchOverlay.searchFor(searchText);\n    await this.dataTable.progressBarWaitForReload();\n  }\n\n  async clickSearchButton() {\n    await this.searchInput.searchButton.click({ force: true });\n  }\n}\n"]}

package/esm2022/page-objects/pages/shared.page.mjs

@@ -0,0 +1,45 @@
+/*!
+ * 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 { BasePage } from './base.page';
+import { DataTableComponent, MatMenuComponent, ViewerComponent, SidenavComponent, Breadcrumb, AdfInfoDrawerComponent } from '../components';
+import { AcaHeader } from '../components/aca-header.component';
+import { AdfFolderDialogComponent, ViewerOverlayDialogComponent, ManageVersionsDialog } from '../components/dialogs';
+class SharedPage extends BasePage {
+    static pageUrl = 'shared';
+    constructor(page) {
+        super(page, SharedPage.pageUrl);
+    }
+    acaHeader = new AcaHeader(this.page);
+    matMenu = new MatMenuComponent(this.page);
+    folderDialog = new AdfFolderDialogComponent(this.page);
+    dataTable = new DataTableComponent(this.page);
+    viewer = new ViewerComponent(this.page);
+    viewerDialog = new ViewerOverlayDialogComponent(this.page);
+    sidenav = new SidenavComponent(this.page);
+    breadcrumb = new Breadcrumb(this.page);
+    infoDrawer = new AdfInfoDrawerComponent(this.page);
+    manageVersionsDialog = new ManageVersionsDialog(this.page);
+}
+export { SharedPage };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/pages/trash.page.mjs

@@ -0,0 +1,45 @@
+/*!
+ * 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 { BasePage } from './base.page';
+import { DataTableComponent, MatMenuComponent, ViewerComponent, SidenavComponent, Breadcrumb, PaginationComponent } from '../components';
+import { AcaHeader } from '../components/aca-header.component';
+import { AdfFolderDialogComponent, ViewerOverlayDialogComponent, AdfDeleteTrashComponent } from '../components/dialogs';
+class TrashPage extends BasePage {
+    static pageUrl = 'trashcan';
+    constructor(page) {
+        super(page, TrashPage.pageUrl);
+    }
+    acaHeader = new AcaHeader(this.page);
+    matMenu = new MatMenuComponent(this.page);
+    folderDialog = new AdfFolderDialogComponent(this.page);
+    dataTable = new DataTableComponent(this.page);
+    viewer = new ViewerComponent(this.page);
+    viewerDialog = new ViewerOverlayDialogComponent(this.page);
+    sidenav = new SidenavComponent(this.page);
+    breadcrumb = new Breadcrumb(this.page);
+    pagination = new PaginationComponent(this.page);
+    deleteDialog = new AdfDeleteTrashComponent(this.page);
+}
+export { TrashPage };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/page-objects/playwright-base.mjs

@@ -0,0 +1,33 @@
+/*!
+ * 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 { GenericLogger } from '../utils';
+export class PlaywrightBase {
+    page;
+    logger;
+    constructor(page) {
+        this.page = page;
+        this.logger = new GenericLogger(process.env.PLAYWRIGHT_CUSTOM_LOG_LEVEL);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/logger.mjs

@@ -0,0 +1,71 @@
+/*!
+ * 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/>.
+ */
+/* eslint-disable @typescript-eslint/naming-convention */
+export const infoColor = '\x1b[36m%s\x1b[0m';
+export const logColor = '\x1b[35m%s\x1b[0m';
+export const warnColor = '\x1b[33m%s\x1b[0m';
+export const errorColor = '\x1b[31m%s\x1b[0m';
+class LogLevelsEnum extends Number {
+    static TRACE = 5;
+    static DEBUG = 4;
+    static INFO = 3;
+    static WARN = 2;
+    static ERROR = 1;
+    static SILENT = 0;
+}
+export { LogLevelsEnum };
+export const logLevels = [
+    { level: LogLevelsEnum.TRACE, name: 'TRACE' },
+    { level: LogLevelsEnum.DEBUG, name: 'DEBUG' },
+    { level: LogLevelsEnum.INFO, name: 'INFO' },
+    { level: LogLevelsEnum.WARN, name: 'WARN' },
+    { level: LogLevelsEnum.ERROR, name: 'ERROR' },
+    { level: LogLevelsEnum.SILENT, name: 'SILENT' }
+];
+/* eslint-disable no-console */
+export class GenericLogger {
+    level;
+    constructor(logLevel) {
+        this.level = logLevels.find(({ name }) => name === logLevel)?.level || LogLevelsEnum.ERROR;
+    }
+    info(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.INFO) {
+            console.log(infoColor, messages.join(''));
+        }
+    }
+    log(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.TRACE) {
+            console.log(logColor, messages.join(''));
+        }
+    }
+    warn(...messages) {
+        if (Number(this.level) >= LogLevelsEnum.WARN) {
+            console.log(warnColor, messages.join(''));
+        }
+    }
+    error(...messages) {
+        console.log(errorColor, messages.join(''));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/utils.mjs

@@ -0,0 +1,145 @@
+/*!
+ * 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/>.
+ */
+const crypto = require('crypto');
+import * as path from 'path';
+import { format, subDays, subMonths, endOfMonth } from 'date-fns';
+import StreamZip from 'node-stream-zip';
+class Utils {
+    static string257Long = 'x'.repeat(257);
+    static string513Long = 'x'.repeat(513);
+    static random() {
+        return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();
+    }
+    static retryCall(fn, retry = 30, delay = 1500) {
+        const pause = (duration) => new Promise((res) => setTimeout(res, duration));
+        const run = (retries) => {
+            return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));
+        };
+        return run(retry);
+    }
+    static formatDate(date) {
+        return new Date(date).toLocaleDateString('en-US');
+    }
+    /**
+     * Method used to login user with navigation. Also waits for the page to load after login
+     *
+     * @param loginPage page context passed from the test
+     * @param username username string
+     * @param password password string
+     * @param errorMessage error message string if the login fails
+     *
+     */
+    static async tryLoginUser(loginPage, username, password, errorMessage = 'Error ') {
+        try {
+            await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    /**
+     * Method used to delete nodes and sites from user's account
+     *
+     * @param nodesApi nodesApi initialized with user credentials passed from the test
+     * @param trashcanApi trashcanApi initialized with user credentials passed from the test
+     * @param errorMessage error message string if the deleting sites/nodes fails
+     * @param sitesApi sitesApi initialized with user credentials passed from the test
+     * @param sitesToDelete array of sites' ids
+     *
+     */
+    static async deleteNodesSitesEmptyTrashcan(nodesApi, trashcanApi, errorMessage = 'Error ', sitesApi, sitesToDelete) {
+        try {
+            await nodesApi?.deleteCurrentUserNodes();
+            await trashcanApi?.emptyTrashcan();
+            if (sitesToDelete?.length > 0) {
+                await sitesApi?.deleteSites(sitesToDelete);
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async uploadFileNewVersion(personalFilesPage, fileFromOS) {
+        const fileInput = await personalFilesPage.page.$('#app-upload-file-version');
+        await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));
+    }
+    static async reloadPageIfRowNotVisible(pageContext, nodeName, errorMessage = 'reloadPageIfRowNotVisible Error ') {
+        try {
+            if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static async reloadPageIfDatatableEmpty(pageContext, errorMessage = 'reloadPageIfDatatableEmpty Error ') {
+        try {
+            if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {
+                await pageContext.page.reload({ waitUntil: 'load' });
+            }
+        }
+        catch (error) {
+            console.error(`${errorMessage}: ${error}`);
+        }
+    }
+    static getCurrentAndPreviousDay(currentDate = new Date()) {
+        let formattedDate;
+        let formattedDate2;
+        const formatDate = (date) => {
+            return format(date, 'dd-MMM-yy').toUpperCase();
+        };
+        if (currentDate.getDate() === 1) {
+            const lastDayOfPreviousMonth = endOfMonth(subMonths(currentDate, 1));
+            formattedDate = formatDate(lastDayOfPreviousMonth);
+            formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));
+        }
+        else {
+            formattedDate = formatDate(currentDate);
+            formattedDate2 = formatDate(subDays(currentDate, 1));
+        }
+        return { currentDate: formattedDate, previousDate: formattedDate2 };
+    }
+    static async verifyZipFileContent(filePath, fileOrFolderName) {
+        const zip = new StreamZip({
+            file: filePath,
+            storeEntries: true
+        });
+        return new Promise((resolve) => {
+            zip.on('ready', () => {
+                const entries = zip.entries();
+                const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);
+                zip.close();
+                resolve(found);
+            });
+        });
+    }
+    static isFileOrFolderInEntries(entries, fileOrFolderName) {
+        return fileOrFolderName.some((name) => {
+            return Object.keys(entries).some((entry) => entry.includes(name));
+        });
+    }
+}
+export { Utils };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/utils/utils.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\nconst crypto = require('crypto');\nimport * as path from 'path';\nimport { LoginPage, MyLibrariesPage, PersonalFilesPage, FavoritesLibrariesPage, SearchPage, SharedPage, TrashPage } from '../page-objects';\nimport { format, subDays, subMonths, endOfMonth } from 'date-fns';\nimport StreamZip from 'node-stream-zip';\nimport { NodesApi, SitesApi, TrashcanApi } from '../api';\n\nexport class Utils {\n  static string257Long = 'x'.repeat(257);\n  static string513Long = 'x'.repeat(513);\n\n  static random(): string {\n    return crypto.getRandomValues(new Uint32Array(1))[0].toString(36).substring(0, 5).toLowerCase();\n  }\n\n  static retryCall(fn: () => Promise<any>, retry: number = 30, delay: number = 1500): Promise<any> {\n    const pause = (duration: number) => new Promise((res) => setTimeout(res, duration));\n\n    const run = (retries: number): Promise<any> => {\n      return fn().catch((err) => (retries > 1 ? pause(delay).then(() => run(retries - 1)) : Promise.reject(err)));\n    };\n\n    return run(retry);\n  }\n\n  static formatDate(date: string): string {\n    return new Date(date).toLocaleDateString('en-US');\n  }\n\n  /**\n   * Method used to login user with navigation. Also waits for the page to load after login\n   *\n   * @param loginPage page context passed from the test\n   * @param username username string\n   * @param password password string\n   * @param errorMessage error message string if the login fails\n   *\n   */\n  static async tryLoginUser(loginPage: LoginPage, username: string, password: string, errorMessage = 'Error '): Promise<void> {\n    try {\n      await loginPage.loginUser({ username, password }, { withNavigation: true, waitForLoading: true });\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  /**\n   * Method used to delete nodes and sites from user's account\n   *\n   * @param nodesApi nodesApi initialized with user credentials passed from the test\n   * @param trashcanApi trashcanApi initialized with user credentials passed from the test\n   * @param errorMessage error message string if the deleting sites/nodes fails\n   * @param sitesApi sitesApi initialized with user credentials passed from the test\n   * @param sitesToDelete array of sites' ids\n   *\n   */\n  static async deleteNodesSitesEmptyTrashcan(\n    nodesApi?: NodesApi,\n    trashcanApi?: TrashcanApi,\n    errorMessage = 'Error ',\n    sitesApi?: SitesApi,\n    sitesToDelete?: string[]\n  ): Promise<void> {\n    try {\n      await nodesApi?.deleteCurrentUserNodes();\n      await trashcanApi?.emptyTrashcan();\n      if (sitesToDelete?.length > 0) {\n        await sitesApi?.deleteSites(sitesToDelete);\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async uploadFileNewVersion(personalFilesPage: PersonalFilesPage, fileFromOS: string): Promise<void> {\n    const fileInput = await personalFilesPage.page.$('#app-upload-file-version');\n    await fileInput.setInputFiles(path.join(__dirname, `../resources/test-files/${fileFromOS}.docx`));\n  }\n\n  static async reloadPageIfRowNotVisible(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage,\n    nodeName: string,\n    errorMessage = 'reloadPageIfRowNotVisible Error '\n  ): Promise<void> {\n    try {\n      if (!(await pageContext.dataTable.getRowByName(nodeName).isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static async reloadPageIfDatatableEmpty(\n    pageContext: PersonalFilesPage | MyLibrariesPage | FavoritesLibrariesPage | SearchPage | SharedPage | TrashPage,\n    errorMessage = 'reloadPageIfDatatableEmpty Error '\n  ): Promise<void> {\n    try {\n      if ((await pageContext.dataTable.getEmptyFolderLocator.isVisible()) || (await pageContext.dataTable.emptyListTitle.isVisible())) {\n        await pageContext.page.reload({ waitUntil: 'load' });\n      }\n    } catch (error) {\n      console.error(`${errorMessage}: ${error}`);\n    }\n  }\n\n  static getCurrentAndPreviousDay(currentDate = new Date()): { currentDate: string; previousDate: string } {\n    let formattedDate: string;\n    let formattedDate2: string;\n\n    const formatDate = (date: Date): string => {\n      return format(date, 'dd-MMM-yy').toUpperCase();\n    };\n\n    if (currentDate.getDate() === 1) {\n      const lastDayOfPreviousMonth: Date = endOfMonth(subMonths(currentDate, 1));\n      formattedDate = formatDate(lastDayOfPreviousMonth);\n      formattedDate2 = formatDate(subDays(lastDayOfPreviousMonth, 1));\n    } else {\n      formattedDate = formatDate(currentDate);\n      formattedDate2 = formatDate(subDays(currentDate, 1));\n    }\n\n    return { currentDate: formattedDate, previousDate: formattedDate2 };\n  }\n\n  static async verifyZipFileContent(filePath: string, fileOrFolderName: string[]): Promise<boolean> {\n    const zip = new StreamZip({\n      file: filePath,\n      storeEntries: true\n    });\n\n    return new Promise<boolean>((resolve) => {\n      zip.on('ready', () => {\n        const entries = zip.entries();\n        const found = this.isFileOrFolderInEntries(entries, fileOrFolderName);\n        zip.close();\n        resolve(found);\n      });\n    });\n  }\n\n  private static isFileOrFolderInEntries(entries: { [name: string]: StreamZip.ZipEntry }, fileOrFolderName: string[]): boolean {\n    return fileOrFolderName.some((name) => {\n      return Object.keys(entries).some((entry) => entry.includes(name));\n    });\n  }\n}\n"]}