@alfresco/aca-playwright-shared 5.1.1-10706961491

package/esm2020/api/rules-api.mjs

@@ -0,0 +1,251 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ApiClientFactory } from './api-client-factory';
+import * as crypto from 'crypto';
+export class RulesApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new RulesApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    callApi(path, httpMethod, body = {}) {
+        // APIs used by this service are still private and not yet available for public use
+        const params = [{}, {}, {}, {}, body, ['application/json'], ['application/json']];
+        return this.apiService.alfrescoApi.contentPrivateClient.callApi(path, httpMethod, ...params);
+    }
+    async createRule(nodeId, rule, ruleSetId = '-default-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules`, 'POST', { ...rule });
+        return response.entry;
+    }
+    async createRandomRule(folderId, ruleName) {
+        const randomActionsIndex = crypto.randomInt(0, ActionTypes.actions.length);
+        const randomAction = ActionTypes.actions[randomActionsIndex];
+        return this.createRule(folderId, {
+            name: ruleName,
+            isEnabled: true,
+            actions: [randomAction]
+        });
+    }
+    async createRandomRuleWithMultipleConditions(folderId, ruleName, numOfConditions) {
+        if (numOfConditions > ConditionsTypes.conditions.length) {
+            numOfConditions = ConditionsTypes.conditions.length;
+        }
+        const randomActionsIndex = crypto.randomInt(0, ActionTypes.actions.length);
+        const randomAction = ActionTypes.actions[randomActionsIndex];
+        const conditionsArray = [];
+        for (let i = 0; i < numOfConditions; i++) {
+            const randomIndex = crypto.randomInt(0, ConditionsTypes.conditions.length);
+            const randomCondition = ConditionsTypes.conditions[randomIndex];
+            conditionsArray.push(randomCondition);
+        }
+        return this.createRule(folderId, {
+            name: ruleName,
+            isEnabled: true,
+            actions: [randomAction],
+            conditions: {
+                inverted: false,
+                booleanMode: 'and',
+                compositeConditions: conditionsArray
+            }
+        });
+    }
+    async createRandomRuleWithMultipleActions(folderId, ruleName, numOfActions) {
+        if (numOfActions > ActionTypes.actions.length) {
+            numOfActions = ActionTypes.actions.length;
+        }
+        const actionsArray = [];
+        for (let i = 0; i < numOfActions; i++) {
+            const randomIndex = crypto.randomInt(0, ActionTypes.actions.length);
+            const randomAction = ActionTypes.actions[randomIndex];
+            actionsArray.push(randomAction);
+        }
+        return this.createRule(folderId, {
+            name: ruleName,
+            isEnabled: true,
+            actions: actionsArray
+        });
+    }
+    async createRandomComplexRule(folderId, ruleName, numOfConditions, numOfActions, ruleDescription) {
+        if (numOfConditions > ConditionsTypes.conditions.length) {
+            numOfConditions = ConditionsTypes.conditions.length;
+        }
+        const conditionsArray = [];
+        for (let i = 0; i < numOfConditions; i++) {
+            const randomIndex = crypto.randomInt(0, ConditionsTypes.conditions.length);
+            const randomCondition = ConditionsTypes.conditions[randomIndex];
+            conditionsArray.push(randomCondition);
+        }
+        if (numOfActions > ActionTypes.actions.length) {
+            numOfActions = ActionTypes.actions.length;
+        }
+        const actionsArray = [];
+        for (let i = 0; i < numOfActions; i++) {
+            const randomIndex = crypto.randomInt(0, ActionTypes.actions.length);
+            const randomAction = ActionTypes.actions[randomIndex];
+            actionsArray.push(randomAction);
+        }
+        return this.createRule(folderId, {
+            name: ruleName,
+            description: ruleDescription,
+            isEnabled: true,
+            actions: actionsArray,
+            conditions: {
+                inverted: false,
+                booleanMode: 'and',
+                compositeConditions: conditionsArray
+            }
+        });
+    }
+    async createRuleWithRandomAspects(folderId, ruleName) {
+        return this.createRule(folderId, {
+            name: ruleName,
+            isEnabled: true,
+            actions: [
+                {
+                    actionDefinitionId: 'add-features',
+                    params: {
+                        'aspect-name': 'sc:controlsAreClearance'
+                    }
+                },
+                {
+                    actionDefinitionId: 'add-features',
+                    params: {
+                        'aspect-name': 'sfdc:objectModel'
+                    }
+                },
+                {
+                    actionDefinitionId: 'add-features',
+                    params: {
+                        'aspect-name': 'sfdc:folder'
+                    }
+                }
+            ]
+        });
+    }
+    async createRuleWithDestinationFolder(folderId, ruleName, actionType, destinationFolderId) {
+        return this.createRule(folderId, {
+            name: ruleName,
+            isEnabled: true,
+            actions: [
+                {
+                    actionDefinitionId: actionType,
+                    params: {
+                        'destination-folder': destinationFolderId
+                    }
+                }
+            ]
+        });
+    }
+}
+export class ActionTypes {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+ActionTypes.ADDFEATURES = new ActionTypes('ADDFEATURES', {
+    actionDefinitionId: 'add-features',
+    params: { 'aspect-name': 'cm:thumbnailed' }
+});
+ActionTypes.CHECKIN = new ActionTypes('CHECKIN', {
+    actionDefinitionId: 'check-in',
+    params: {
+        description: 'test',
+        minorChange: true
+    }
+});
+ActionTypes.SPECIALISETYPE = new ActionTypes('SPECIALISETYPE', {
+    actionDefinitionId: 'specialise-type',
+    params: { 'type-name': 'sys:base' }
+});
+ActionTypes.RECORDABLEVERSION = new ActionTypes('RECORDABLEVERSION', {
+    actionDefinitionId: 'recordable-version-config',
+    params: { version: 'ALL' }
+});
+ActionTypes.SETPROPERTYVALUE = new ActionTypes('SETPROPERTYVALUE', {
+    actionDefinitionId: 'set-property-value',
+    params: { property: 'dl:ganttPercentComplete', value: 'test' }
+});
+ActionTypes.actions = [
+    ActionTypes.ADDFEATURES.value,
+    ActionTypes.CHECKIN.value,
+    ActionTypes.RECORDABLEVERSION.value,
+    ActionTypes.SPECIALISETYPE.value,
+    ActionTypes.SETPROPERTYVALUE.value
+];
+export class ConditionsTypes {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+ConditionsTypes.MIMETYPE = new ConditionsTypes('MIMETYPE', {
+    inverted: false,
+    booleanMode: 'and',
+    simpleConditions: [
+        {
+            field: 'mimetype',
+            comparator: 'equals',
+            parameter: 'video/3gpp'
+        }
+    ]
+});
+ConditionsTypes.CMNAME = new ConditionsTypes('CM:NAME', {
+    inverted: false,
+    booleanMode: 'and',
+    simpleConditions: [
+        {
+            field: 'cm:name',
+            comparator: 'equals',
+            parameter: 'testname'
+        }
+    ]
+});
+ConditionsTypes.SIZE = new ConditionsTypes('SIZE', {
+    inverted: false,
+    booleanMode: 'and',
+    simpleConditions: [
+        {
+            field: 'size',
+            comparator: 'equals',
+            parameter: '345'
+        }
+    ]
+});
+ConditionsTypes.TAG = new ConditionsTypes('TAG', {
+    inverted: false,
+    booleanMode: 'and',
+    simpleConditions: [
+        {
+            field: 'tag',
+            comparator: 'equals',
+            parameter: 'testtag'
+        }
+    ]
+});
+ConditionsTypes.conditions = [ConditionsTypes.MIMETYPE.value, ConditionsTypes.CMNAME.value, ConditionsTypes.SIZE.value, ConditionsTypes.TAG.value];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rules-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/rules-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ApiClientFactory } from './api-client-factory';\nimport { AcaFolderRulesModule } from '@alfresco/aca-content/folder-rules';\nimport * as crypto from 'crypto';\n\nexport class RulesApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n\n  static async initialize(userName: string, password?: string): Promise<RulesApi> {\n    const classObj = new RulesApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  private callApi(path: string, httpMethod: string, body: object = {}): Promise<any> {\n    // APIs used by this service are still private and not yet available for public use\n    const params = [{}, {}, {}, {}, body, ['application/json'], ['application/json']];\n    return this.apiService.alfrescoApi.contentPrivateClient.callApi(path, httpMethod, ...params);\n  }\n\n  async createRule(nodeId: string, rule: Partial<Rule>, ruleSetId: string = '-default-'): Promise<Rule> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules`, 'POST', { ...rule });\n    return response.entry;\n  }\n\n  async createRandomRule(folderId: string, ruleName: string): Promise<Rule> {\n    const randomActionsIndex = crypto.randomInt(0, ActionTypes.actions.length);\n    const randomAction = ActionTypes.actions[randomActionsIndex];\n    return this.createRule(folderId, {\n      name: ruleName,\n      isEnabled: true,\n      actions: [randomAction]\n    });\n  }\n\n  async createRandomRuleWithMultipleConditions(folderId: string, ruleName: string, numOfConditions: number): Promise<Rule> {\n    if (numOfConditions > ConditionsTypes.conditions.length) {\n      numOfConditions = ConditionsTypes.conditions.length;\n    }\n    const randomActionsIndex = crypto.randomInt(0, ActionTypes.actions.length);\n    const randomAction = ActionTypes.actions[randomActionsIndex];\n    const conditionsArray = [];\n    for (let i = 0; i < numOfConditions; i++) {\n      const randomIndex = crypto.randomInt(0, ConditionsTypes.conditions.length);\n      const randomCondition = ConditionsTypes.conditions[randomIndex];\n      conditionsArray.push(randomCondition);\n    }\n    return this.createRule(folderId, {\n      name: ruleName,\n      isEnabled: true,\n      actions: [randomAction],\n      conditions: {\n        inverted: false,\n        booleanMode: 'and',\n        compositeConditions: conditionsArray\n      }\n    });\n  }\n\n  async createRandomRuleWithMultipleActions(folderId: string, ruleName: string, numOfActions: number): Promise<Rule> {\n    if (numOfActions > ActionTypes.actions.length) {\n      numOfActions = ActionTypes.actions.length;\n    }\n    const actionsArray = [];\n    for (let i = 0; i < numOfActions; i++) {\n      const randomIndex = crypto.randomInt(0, ActionTypes.actions.length);\n      const randomAction = ActionTypes.actions[randomIndex];\n      actionsArray.push(randomAction);\n    }\n    return this.createRule(folderId, {\n      name: ruleName,\n      isEnabled: true,\n      actions: actionsArray\n    });\n  }\n\n  async createRandomComplexRule(\n    folderId: string,\n    ruleName: string,\n    numOfConditions: number,\n    numOfActions: number,\n    ruleDescription?: string\n  ): Promise<Rule> {\n    if (numOfConditions > ConditionsTypes.conditions.length) {\n      numOfConditions = ConditionsTypes.conditions.length;\n    }\n    const conditionsArray = [];\n    for (let i = 0; i < numOfConditions; i++) {\n      const randomIndex = crypto.randomInt(0, ConditionsTypes.conditions.length);\n      const randomCondition = ConditionsTypes.conditions[randomIndex];\n      conditionsArray.push(randomCondition);\n    }\n    if (numOfActions > ActionTypes.actions.length) {\n      numOfActions = ActionTypes.actions.length;\n    }\n    const actionsArray = [];\n    for (let i = 0; i < numOfActions; i++) {\n      const randomIndex = crypto.randomInt(0, ActionTypes.actions.length);\n      const randomAction = ActionTypes.actions[randomIndex];\n      actionsArray.push(randomAction);\n    }\n    return this.createRule(folderId, {\n      name: ruleName,\n      description: ruleDescription,\n      isEnabled: true,\n      actions: actionsArray,\n      conditions: {\n        inverted: false,\n        booleanMode: 'and',\n        compositeConditions: conditionsArray\n      }\n    });\n  }\n\n  async createRuleWithRandomAspects(folderId: string, ruleName: string): Promise<Rule> {\n    return this.createRule(folderId, {\n      name: ruleName,\n      isEnabled: true,\n      actions: [\n        {\n          actionDefinitionId: 'add-features',\n          params: {\n            'aspect-name': 'sc:controlsAreClearance'\n          }\n        },\n        {\n          actionDefinitionId: 'add-features',\n          params: {\n            'aspect-name': 'sfdc:objectModel'\n          }\n        },\n        {\n          actionDefinitionId: 'add-features',\n          params: {\n            'aspect-name': 'sfdc:folder'\n          }\n        }\n      ]\n    });\n  }\n\n  async createRuleWithDestinationFolder(\n    folderId: string,\n    ruleName: string,\n    actionType: 'move' | 'copy' | 'import',\n    destinationFolderId: string\n  ): Promise<Rule> {\n    return this.createRule(folderId, {\n      name: ruleName,\n      isEnabled: true,\n      actions: [\n        {\n          actionDefinitionId: actionType,\n          params: {\n            'destination-folder': destinationFolderId\n          }\n        }\n      ]\n    });\n  }\n}\n\ntype RuleTrigger = 'inbound' | 'update' | 'outbound';\n\nexport interface Rule {\n  id: string;\n  name: string;\n  description: string;\n  isEnabled: boolean;\n  isInheritable: boolean;\n  isAsynchronous: boolean;\n  errorScript: string;\n  isShared: boolean;\n  triggers: RuleTrigger[];\n  conditions: AcaFolderRulesModule;\n  actions: RuleAction[];\n}\n\nexport interface RuleAction {\n  actionDefinitionId: string;\n  params?: { [key: string]: unknown };\n}\n\nexport class ActionTypes {\n  static readonly ADDFEATURES = new ActionTypes('ADDFEATURES', {\n    actionDefinitionId: 'add-features',\n    params: { 'aspect-name': 'cm:thumbnailed' }\n  });\n  static readonly CHECKIN = new ActionTypes('CHECKIN', {\n    actionDefinitionId: 'check-in',\n    params: {\n      description: 'test',\n      minorChange: true\n    }\n  });\n  static readonly SPECIALISETYPE = new ActionTypes('SPECIALISETYPE', {\n    actionDefinitionId: 'specialise-type',\n    params: { 'type-name': 'sys:base' }\n  });\n  static readonly RECORDABLEVERSION = new ActionTypes('RECORDABLEVERSION', {\n    actionDefinitionId: 'recordable-version-config',\n    params: { version: 'ALL' }\n  });\n  static readonly SETPROPERTYVALUE = new ActionTypes('SETPROPERTYVALUE', {\n    actionDefinitionId: 'set-property-value',\n    params: { property: 'dl:ganttPercentComplete', value: 'test' }\n  });\n  static readonly actions = [\n    ActionTypes.ADDFEATURES.value,\n    ActionTypes.CHECKIN.value,\n    ActionTypes.RECORDABLEVERSION.value,\n    ActionTypes.SPECIALISETYPE.value,\n    ActionTypes.SETPROPERTYVALUE.value\n  ];\n  constructor(public key: string, public value: RuleAction) {}\n}\n\nexport class ConditionsTypes {\n  static readonly MIMETYPE = new ConditionsTypes('MIMETYPE', {\n    inverted: false,\n    booleanMode: 'and',\n    simpleConditions: [\n      {\n        field: 'mimetype',\n        comparator: 'equals',\n        parameter: 'video/3gpp'\n      }\n    ]\n  });\n  static readonly CMNAME = new ConditionsTypes('CM:NAME', {\n    inverted: false,\n    booleanMode: 'and',\n    simpleConditions: [\n      {\n        field: 'cm:name',\n        comparator: 'equals',\n        parameter: 'testname'\n      }\n    ]\n  });\n  static readonly SIZE = new ConditionsTypes('SIZE', {\n    inverted: false,\n    booleanMode: 'and',\n    simpleConditions: [\n      {\n        field: 'size',\n        comparator: 'equals',\n        parameter: '345'\n      }\n    ]\n  });\n  static readonly TAG = new ConditionsTypes('TAG', {\n    inverted: false,\n    booleanMode: 'and',\n    simpleConditions: [\n      {\n        field: 'tag',\n        comparator: 'equals',\n        parameter: 'testtag'\n      }\n    ]\n  });\n  static readonly conditions = [ConditionsTypes.MIMETYPE.value, ConditionsTypes.CMNAME.value, ConditionsTypes.SIZE.value, ConditionsTypes.TAG.value];\n  constructor(public key: string, public value: AcaFolderRulesModule) {}\n}\n"]}

package/esm2020/api/search-api.mjs

@@ -0,0 +1,74 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ApiClientFactory } from './api-client-factory';
+import { Utils } from '../utils';
+import { ResultSetPaging } from '@alfresco/js-api';
+export class SearchPageApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new SearchPageApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async querySearchFiles(username) {
+        const data = {
+            query: {
+                query: '*',
+                language: 'afts'
+            },
+            filterQueries: [
+                { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },
+                { query: `cm:modifier:${username} OR cm:creator:${username}` },
+                { query: `TYPE:"content" AND -TYPE:"app:filelink" AND -TYPE:"fm:post"` }
+            ]
+        };
+        try {
+            return this.apiService.search.search(data);
+        }
+        catch {
+            return new ResultSetPaging();
+        }
+    }
+    async getTotalItems(username) {
+        return (await this.querySearchFiles(username)).list.pagination.totalItems;
+    }
+    async waitForApi(username, data) {
+        try {
+            const searchFiles = async () => {
+                const totalItems = await this.getTotalItems(username);
+                if (totalItems !== data.expect) {
+                    return Promise.reject(totalItems);
+                }
+                else {
+                    return Promise.resolve(totalItems);
+                }
+            };
+            return Utils.retryCall(searchFiles);
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/api/shared-links-api.mjs

@@ -0,0 +1,136 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { ApiClientFactory } from './api-client-factory';
+import { SharedLinkPaging } from '@alfresco/js-api';
+import { Utils } from '../utils';
+export class SharedLinksApi {
+    constructor() {
+        this.apiService = new ApiClientFactory();
+    }
+    static async initialize(userName, password) {
+        const classObj = new SharedLinksApi();
+        await classObj.apiService.setUpAcaBackend(userName, password);
+        return classObj;
+    }
+    async shareFileById(id, expireDate) {
+        try {
+            const data = {
+                nodeId: id,
+                expiresAt: expireDate
+            };
+            return this.apiService.share.createSharedLink(data);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async shareFilesByIds(ids, expireDate) {
+        const sharedLinks = [];
+        try {
+            if (ids && ids.length > 0) {
+                for (const id of ids) {
+                    const sharedLink = await this.shareFileById(id, expireDate);
+                    sharedLinks.push(sharedLink);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`SharedLinksApi shareFilesByIds : catch : `, error);
+        }
+        return sharedLinks;
+    }
+    async getSharedLinks(maxItems = 250) {
+        try {
+            const opts = {
+                maxItems
+            };
+            return this.apiService.share.listSharedLinks(opts);
+        }
+        catch (error) {
+            console.error(`SharedLinksApi getSharedLinks : catch : `, error);
+            return new SharedLinkPaging();
+        }
+    }
+    async waitForFilesToBeShared(filesIds) {
+        try {
+            const sharedFile = async () => {
+                const sharedFiles = (await this.getSharedLinks()).list.entries.map((link) => link.entry.nodeId);
+                const foundItems = filesIds.every((id) => sharedFiles.includes(id));
+                if (foundItems) {
+                    return Promise.resolve(foundItems);
+                }
+                else {
+                    return Promise.reject(foundItems);
+                }
+            };
+            return Utils.retryCall(sharedFile);
+        }
+        catch (error) {
+            console.error(`SharedLinksApi waitForFilesToBeShared :  catch : ${error}`);
+            console.error(`\tWait timeout reached waiting for files to be shared`);
+        }
+    }
+    async getSharedIdOfNode(fileId) {
+        try {
+            const sharedLinksEntries = (await this.getSharedLinks())?.list.entries;
+            const found = sharedLinksEntries.find((sharedLink) => sharedLink.entry.nodeId === fileId);
+            return found?.entry.id;
+        }
+        catch (error) {
+            console.error(`SharedLinksApi getSharedIdOfNode : catch : `, error);
+            return null;
+        }
+    }
+    async unshareFileById(fileId) {
+        try {
+            const sharedId = await this.getSharedIdOfNode(fileId);
+            return this.apiService.share.deleteSharedLink(sharedId);
+        }
+        catch (error) {
+            console.error(`SharedLinksApi unshareFileById : catch : `, error);
+        }
+    }
+    async waitForFilesToNotBeShared(filesIds) {
+        try {
+            const sharedFile = async () => {
+                const sharedFiles = (await this.getSharedLinks()).list.entries.map((link) => link.entry.nodeId);
+                const foundItems = filesIds.some((id) => {
+                    return sharedFiles.includes(id);
+                });
+                if (foundItems) {
+                    return Promise.reject(foundItems);
+                }
+                else {
+                    return Promise.resolve(foundItems);
+                }
+            };
+            return Utils.retryCall(sharedFile);
+        }
+        catch (error) {
+            console.error(`SharedLinksApi waitForFilesToNotBeShared :  catch : ${error}`);
+            console.error(`\tWait timeout reached waiting for files to no longer be shared`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-links-api.js","sourceRoot":"","sources":["../../../../../projects/aca-playwright-shared/src/api/shared-links-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { ApiClientFactory } from './api-client-factory';\nimport { SharedLinkEntry, SharedLinkPaging } from '@alfresco/js-api';\nimport { Utils } from '../utils';\n\nexport class SharedLinksApi {\n  private apiService: ApiClientFactory;\n\n  constructor() {\n    this.apiService = new ApiClientFactory();\n  }\n  static async initialize(userName: string, password?: string): Promise<SharedLinksApi> {\n    const classObj = new SharedLinksApi();\n    await classObj.apiService.setUpAcaBackend(userName, password);\n    return classObj;\n  }\n\n  async shareFileById(id: string, expireDate?: Date): Promise<SharedLinkEntry | null> {\n    try {\n      const data = {\n        nodeId: id,\n        expiresAt: expireDate\n      };\n      return this.apiService.share.createSharedLink(data);\n    } catch (error) {\n      return null;\n    }\n  }\n\n  async shareFilesByIds(ids: string[], expireDate?: Date): Promise<SharedLinkEntry[]> {\n    const sharedLinks: SharedLinkEntry[] = [];\n    try {\n      if (ids && ids.length > 0) {\n        for (const id of ids) {\n          const sharedLink = await this.shareFileById(id, expireDate);\n          sharedLinks.push(sharedLink);\n        }\n      }\n    } catch (error) {\n      console.error(`SharedLinksApi shareFilesByIds : catch : `, error);\n    }\n    return sharedLinks;\n  }\n\n  private async getSharedLinks(maxItems: number = 250): Promise<SharedLinkPaging> {\n    try {\n      const opts = {\n        maxItems\n      };\n      return this.apiService.share.listSharedLinks(opts);\n    } catch (error) {\n      console.error(`SharedLinksApi getSharedLinks : catch : `, error);\n      return new SharedLinkPaging();\n    }\n  }\n\n  async waitForFilesToBeShared(filesIds: string[]): Promise<void> {\n    try {\n      const sharedFile = async () => {\n        const sharedFiles = (await this.getSharedLinks()).list.entries.map((link) => link.entry.nodeId);\n        const foundItems = filesIds.every((id) => sharedFiles.includes(id));\n        if (foundItems) {\n          return Promise.resolve(foundItems);\n        } else {\n          return Promise.reject(foundItems);\n        }\n      };\n\n      return Utils.retryCall(sharedFile);\n    } catch (error) {\n      console.error(`SharedLinksApi waitForFilesToBeShared :  catch : ${error}`);\n      console.error(`\\tWait timeout reached waiting for files to be shared`);\n    }\n  }\n\n  private async getSharedIdOfNode(fileId: string): Promise<string> {\n    try {\n      const sharedLinksEntries = (await this.getSharedLinks())?.list.entries;\n      const found = sharedLinksEntries.find((sharedLink) => sharedLink.entry.nodeId === fileId);\n      return found?.entry.id;\n    } catch (error) {\n      console.error(`SharedLinksApi getSharedIdOfNode : catch : `, error);\n      return null;\n    }\n  }\n\n  async unshareFileById(fileId: string): Promise<void> {\n    try {\n      const sharedId = await this.getSharedIdOfNode(fileId);\n      return this.apiService.share.deleteSharedLink(sharedId);\n    } catch (error) {\n      console.error(`SharedLinksApi unshareFileById : catch : `, error);\n    }\n  }\n\n  async waitForFilesToNotBeShared(filesIds: string[]): Promise<any> {\n    try {\n      const sharedFile = async () => {\n        const sharedFiles = (await this.getSharedLinks()).list.entries.map((link) => link.entry.nodeId);\n\n        const foundItems = filesIds.some((id) => {\n          return sharedFiles.includes(id);\n        });\n\n        if (foundItems) {\n          return Promise.reject(foundItems);\n        } else {\n          return Promise.resolve(foundItems);\n        }\n      };\n\n      return Utils.retryCall(sharedFile);\n    } catch (error) {\n      console.error(`SharedLinksApi waitForFilesToNotBeShared :  catch : ${error}`);\n      console.error(`\\tWait timeout reached waiting for files to no longer be shared`);\n    }\n  }\n}\n"]}