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

package/esm2022/api/rules-api.mjs

@@ -0,0 +1,258 @@
+/*!
+ * 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 {
+    apiService;
+    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
+                    }
+                }
+            ]
+        });
+    }
+}
+class ActionTypes {
+    key;
+    value;
+    static ADDFEATURES = new ActionTypes('ADDFEATURES', {
+        actionDefinitionId: 'add-features',
+        params: { 'aspect-name': 'cm:thumbnailed' }
+    });
+    static CHECKIN = new ActionTypes('CHECKIN', {
+        actionDefinitionId: 'check-in',
+        params: {
+            description: 'test',
+            minorChange: true
+        }
+    });
+    static SPECIALISETYPE = new ActionTypes('SPECIALISETYPE', {
+        actionDefinitionId: 'specialise-type',
+        params: { 'type-name': 'sys:base' }
+    });
+    static RECORDABLEVERSION = new ActionTypes('RECORDABLEVERSION', {
+        actionDefinitionId: 'recordable-version-config',
+        params: { version: 'ALL' }
+    });
+    static SETPROPERTYVALUE = new ActionTypes('SETPROPERTYVALUE', {
+        actionDefinitionId: 'set-property-value',
+        params: { property: 'dl:ganttPercentComplete', value: 'test' }
+    });
+    static actions = [
+        ActionTypes.ADDFEATURES.value,
+        ActionTypes.CHECKIN.value,
+        ActionTypes.RECORDABLEVERSION.value,
+        ActionTypes.SPECIALISETYPE.value,
+        ActionTypes.SETPROPERTYVALUE.value
+    ];
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+export { ActionTypes };
+class ConditionsTypes {
+    key;
+    value;
+    static MIMETYPE = new ConditionsTypes('MIMETYPE', {
+        inverted: false,
+        booleanMode: 'and',
+        simpleConditions: [
+            {
+                field: 'mimetype',
+                comparator: 'equals',
+                parameter: 'video/3gpp'
+            }
+        ]
+    });
+    static CMNAME = new ConditionsTypes('CM:NAME', {
+        inverted: false,
+        booleanMode: 'and',
+        simpleConditions: [
+            {
+                field: 'cm:name',
+                comparator: 'equals',
+                parameter: 'testname'
+            }
+        ]
+    });
+    static SIZE = new ConditionsTypes('SIZE', {
+        inverted: false,
+        booleanMode: 'and',
+        simpleConditions: [
+            {
+                field: 'size',
+                comparator: 'equals',
+                parameter: '345'
+            }
+        ]
+    });
+    static TAG = new ConditionsTypes('TAG', {
+        inverted: false,
+        booleanMode: 'and',
+        simpleConditions: [
+            {
+                field: 'tag',
+                comparator: 'equals',
+                parameter: 'testtag'
+            }
+        ]
+    });
+    static conditions = [ConditionsTypes.MIMETYPE.value, ConditionsTypes.CMNAME.value, ConditionsTypes.SIZE.value, ConditionsTypes.TAG.value];
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+export { ConditionsTypes };
+//# 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/esm2022/api/search-api.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 { ApiClientFactory } from './api-client-factory';
+import { Utils } from '../utils';
+import { ResultSetPaging } from '@alfresco/js-api';
+export class SearchPageApi {
+    apiService;
+    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/esm2022/api/shared-links-api.mjs

@@ -0,0 +1,137 @@
+/*!
+ * 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 {
+    apiService;
+    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"]}