@alfresco/aca-content 4.0.0 → 4.1.0

package/esm2020/folder-rules/services/folder-rules.service.mjs

@@ -0,0 +1,193 @@
+/*!
+ * Copyright © 2005-2023 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 { Injectable } from '@angular/core';
+import { AlfrescoApiService } from '@alfresco/adf-core';
+import { BehaviorSubject, from } from 'rxjs';
+import { finalize, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class FolderRulesService {
+    constructor(apiService) {
+        this.apiService = apiService;
+        this.selectedRuleSource = new BehaviorSubject(null);
+        this.deletedRuleIdSource = new BehaviorSubject(null);
+        this.selectedRule$ = this.selectedRuleSource.asObservable();
+        this.deletedRuleId$ = this.deletedRuleIdSource.asObservable();
+    }
+    static get emptyCompositeCondition() {
+        return {
+            inverted: false,
+            booleanMode: 'and',
+            compositeConditions: [],
+            simpleConditions: []
+        };
+    }
+    static get emptyRuleOptions() {
+        return {
+            isEnabled: true,
+            isInheritable: false,
+            isAsynchronous: false,
+            errorScript: ''
+        };
+    }
+    static get emptyRule() {
+        return {
+            id: '',
+            name: '',
+            description: '',
+            isShared: false,
+            triggers: ['inbound'],
+            conditions: FolderRulesService.emptyCompositeCondition,
+            actions: [],
+            ...FolderRulesService.emptyRuleOptions
+        };
+    }
+    static get emptyRuleForForm() {
+        const value = {
+            ...FolderRulesService.emptyRule,
+            options: FolderRulesService.emptyRuleOptions
+        };
+        Object.keys(value.options).forEach((key) => {
+            delete value[key];
+        });
+        return value;
+    }
+    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.getInstance().contentPrivateClient.callApi(path, httpMethod, ...params);
+    }
+    getRules(owningFolderId, ruleSetId, skipCount = 0) {
+        return from(this.callApi(`/nodes/${owningFolderId}/rule-sets/${ruleSetId}/rules?skipCount=${skipCount}&maxItems=${FolderRulesService.MAX_RULES_PER_GET}`, 'GET')).pipe(map((res) => ({
+            rules: this.formatRules(res),
+            hasMoreRules: !!res?.list?.pagination?.hasMoreItems
+        })));
+    }
+    loadRules(ruleSet, skipCount = ruleSet.rules.length, selectRule = null) {
+        if (ruleSet && !ruleSet.loadingRules) {
+            ruleSet.loadingRules = true;
+            this.getRules(ruleSet.owningFolder.id, ruleSet.id, skipCount)
+                .pipe(finalize(() => {
+                ruleSet.loadingRules = false;
+            }))
+                .subscribe((res) => {
+                ruleSet.hasMoreRules = res.hasMoreRules;
+                ruleSet.rules.splice(skipCount);
+                ruleSet.rules.push(...res.rules);
+                this.selectRuleInRuleSet(ruleSet, selectRule);
+            });
+        }
+    }
+    async createRule(nodeId, rule, ruleSetId = '-default-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules`, 'POST', { ...rule });
+        return this.formatRule(response.entry);
+    }
+    async updateRule(nodeId, ruleId, rule, ruleSetId = '-default-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'PUT', { ...rule });
+        return this.formatRule(response.entry);
+    }
+    deleteRule(nodeId, ruleId, ruleSetId = '-default-') {
+        from(this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'DELETE')).subscribe(() => {
+            this.deletedRuleIdSource.next(ruleId);
+        }, (error) => {
+            this.deletedRuleIdSource.next(error);
+        });
+    }
+    async getRuleSettings(nodeId, key = '-isInheritanceEnabled-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'GET');
+        return response.entry;
+    }
+    async updateRuleSettings(nodeId, key, body) {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'PUT', { ...body });
+        return response.entry;
+    }
+    formatRules(res) {
+        return [...res.list.entries.map((entry) => this.formatRule(entry.entry))];
+    }
+    formatRule(obj) {
+        return {
+            id: obj.id,
+            name: obj.name ?? FolderRulesService.emptyRule.name,
+            description: obj.description ?? FolderRulesService.emptyRule.description,
+            isEnabled: obj.isEnabled ?? FolderRulesService.emptyRule.isEnabled,
+            isInheritable: obj.isInheritable ?? FolderRulesService.emptyRule.isInheritable,
+            isAsynchronous: obj.isAsynchronous ?? FolderRulesService.emptyRule.isAsynchronous,
+            errorScript: obj.errorScript ?? FolderRulesService.emptyRule.errorScript,
+            isShared: obj.isShared ?? FolderRulesService.emptyRule.isShared,
+            triggers: obj.triggers ?? FolderRulesService.emptyRule.triggers,
+            conditions: this.formatCompositeCondition(obj.conditions ?? { ...FolderRulesService.emptyRule.conditions }),
+            actions: obj.actions ?? FolderRulesService.emptyRule.actions
+        };
+    }
+    formatCompositeCondition(obj) {
+        return {
+            inverted: obj.inverted ?? false,
+            booleanMode: obj.booleanMode ?? 'and',
+            compositeConditions: (obj.compositeConditions || []).map((condition) => this.formatCompositeCondition(condition)),
+            simpleConditions: this.parseSimpleCondition(obj.simpleConditions)
+        };
+    }
+    parseSimpleCondition(arr) {
+        if (arr) {
+            if (arr.every((element) => element === null)) {
+                return [];
+            }
+            return arr.map((condition) => this.formatSimpleCondition(condition));
+        }
+        else {
+            return [];
+        }
+    }
+    formatSimpleCondition(obj) {
+        return {
+            field: obj.field || 'cm:name',
+            comparator: obj.comparator || 'equals',
+            parameter: obj.parameter || ''
+        };
+    }
+    selectRule(rule) {
+        this.selectedRuleSource.next(rule);
+    }
+    selectRuleInRuleSet(ruleSet, selectRule = null) {
+        if (selectRule === 'first') {
+            this.selectRule(ruleSet.rules[0]);
+        }
+        else if (selectRule === 'last') {
+            this.selectRule(ruleSet.rules[ruleSet.rules.length - 1]);
+        }
+        else if (selectRule) {
+            this.selectRule(selectRule);
+        }
+    }
+}
+FolderRulesService.MAX_RULES_PER_GET = 100;
+FolderRulesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FolderRulesService, deps: [{ token: i1.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+FolderRulesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FolderRulesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: FolderRulesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AlfrescoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"folder-rules.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/folder-rules/src/services/folder-rules.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2023 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 { Injectable } from '@angular/core';\nimport { AlfrescoApiService } from '@alfresco/adf-core';\nimport { BehaviorSubject, from, Observable } from 'rxjs';\nimport { finalize, map } from 'rxjs/operators';\nimport { Rule, RuleForForm, RuleOptions, RuleSettings } from '../model/rule.model';\nimport { RuleCompositeCondition } from '../model/rule-composite-condition.model';\nimport { RuleSimpleCondition } from '../model/rule-simple-condition.model';\nimport { RuleSet } from '../model/rule-set.model';\n\ninterface GetRulesResult {\n  rules: Rule[];\n  hasMoreRules: boolean;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FolderRulesService {\n  public static MAX_RULES_PER_GET = 100;\n\n  public static get emptyCompositeCondition(): RuleCompositeCondition {\n    return {\n      inverted: false,\n      booleanMode: 'and',\n      compositeConditions: [],\n      simpleConditions: []\n    };\n  }\n\n  public static get emptyRuleOptions(): RuleOptions {\n    return {\n      isEnabled: true,\n      isInheritable: false,\n      isAsynchronous: false,\n      errorScript: ''\n    };\n  }\n\n  public static get emptyRule(): Rule {\n    return {\n      id: '',\n      name: '',\n      description: '',\n      isShared: false,\n      triggers: ['inbound'],\n      conditions: FolderRulesService.emptyCompositeCondition,\n      actions: [],\n      ...FolderRulesService.emptyRuleOptions\n    };\n  }\n\n  public static get emptyRuleForForm(): RuleForForm {\n    const value = {\n      ...FolderRulesService.emptyRule,\n      options: FolderRulesService.emptyRuleOptions\n    };\n    Object.keys(value.options).forEach((key: string) => {\n      delete value[key];\n    });\n    return value;\n  }\n\n  private selectedRuleSource = new BehaviorSubject<Rule>(null);\n  private deletedRuleIdSource = new BehaviorSubject<string>(null);\n\n  selectedRule$ = this.selectedRuleSource.asObservable();\n  deletedRuleId$: Observable<string> = this.deletedRuleIdSource.asObservable();\n\n  constructor(private apiService: AlfrescoApiService) {}\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.getInstance().contentPrivateClient.callApi(path, httpMethod, ...params);\n  }\n\n  getRules(owningFolderId: string, ruleSetId: string, skipCount = 0): Observable<GetRulesResult> {\n    return from(\n      this.callApi(\n        `/nodes/${owningFolderId}/rule-sets/${ruleSetId}/rules?skipCount=${skipCount}&maxItems=${FolderRulesService.MAX_RULES_PER_GET}`,\n        'GET'\n      )\n    ).pipe(\n      map((res) => ({\n        rules: this.formatRules(res),\n        hasMoreRules: !!res?.list?.pagination?.hasMoreItems\n      }))\n    );\n  }\n\n  loadRules(ruleSet: RuleSet, skipCount = ruleSet.rules.length, selectRule: 'first' | 'last' | Rule = null) {\n    if (ruleSet && !ruleSet.loadingRules) {\n      ruleSet.loadingRules = true;\n      this.getRules(ruleSet.owningFolder.id, ruleSet.id, skipCount)\n        .pipe(\n          finalize(() => {\n            ruleSet.loadingRules = false;\n          })\n        )\n        .subscribe((res: GetRulesResult) => {\n          ruleSet.hasMoreRules = res.hasMoreRules;\n          ruleSet.rules.splice(skipCount);\n          ruleSet.rules.push(...res.rules);\n          this.selectRuleInRuleSet(ruleSet, selectRule);\n        });\n    }\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 this.formatRule(response.entry);\n  }\n\n  async updateRule(nodeId: string, ruleId: string, rule: Rule, ruleSetId: string = '-default-'): Promise<Rule> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'PUT', { ...rule });\n    return this.formatRule(response.entry);\n  }\n\n  deleteRule(nodeId: string, ruleId: string, ruleSetId: string = '-default-') {\n    from(this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'DELETE')).subscribe(\n      () => {\n        this.deletedRuleIdSource.next(ruleId);\n      },\n      (error) => {\n        this.deletedRuleIdSource.next(error);\n      }\n    );\n  }\n\n  async getRuleSettings(nodeId: string, key: string = '-isInheritanceEnabled-'): Promise<RuleSettings> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'GET');\n    return response.entry;\n  }\n\n  async updateRuleSettings(nodeId: string, key: string, body: RuleSettings): Promise<RuleSettings> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'PUT', { ...body });\n    return response.entry;\n  }\n\n  private formatRules(res): Rule[] {\n    return [...res.list.entries.map((entry) => this.formatRule(entry.entry))];\n  }\n\n  private formatRule(obj): Rule {\n    return {\n      id: obj.id,\n      name: obj.name ?? FolderRulesService.emptyRule.name,\n      description: obj.description ?? FolderRulesService.emptyRule.description,\n      isEnabled: obj.isEnabled ?? FolderRulesService.emptyRule.isEnabled,\n      isInheritable: obj.isInheritable ?? FolderRulesService.emptyRule.isInheritable,\n      isAsynchronous: obj.isAsynchronous ?? FolderRulesService.emptyRule.isAsynchronous,\n      errorScript: obj.errorScript ?? FolderRulesService.emptyRule.errorScript,\n      isShared: obj.isShared ?? FolderRulesService.emptyRule.isShared,\n      triggers: obj.triggers ?? FolderRulesService.emptyRule.triggers,\n      conditions: this.formatCompositeCondition(obj.conditions ?? { ...FolderRulesService.emptyRule.conditions }),\n      actions: obj.actions ?? FolderRulesService.emptyRule.actions\n    };\n  }\n\n  private formatCompositeCondition(obj): RuleCompositeCondition {\n    return {\n      inverted: obj.inverted ?? false,\n      booleanMode: obj.booleanMode ?? 'and',\n      compositeConditions: (obj.compositeConditions || []).map((condition) => this.formatCompositeCondition(condition)),\n      simpleConditions: this.parseSimpleCondition(obj.simpleConditions)\n    };\n  }\n\n  private parseSimpleCondition(arr) {\n    if (arr) {\n      if (arr.every((element) => element === null)) {\n        return [];\n      }\n      return arr.map((condition) => this.formatSimpleCondition(condition));\n    } else {\n      return [];\n    }\n  }\n\n  private formatSimpleCondition(obj): RuleSimpleCondition {\n    return {\n      field: obj.field || 'cm:name',\n      comparator: obj.comparator || 'equals',\n      parameter: obj.parameter || ''\n    };\n  }\n\n  selectRule(rule: Rule) {\n    this.selectedRuleSource.next(rule);\n  }\n\n  selectRuleInRuleSet(ruleSet: RuleSet, selectRule: 'first' | 'last' | Rule = null) {\n    if (selectRule === 'first') {\n      this.selectRule(ruleSet.rules[0]);\n    } else if (selectRule === 'last') {\n      this.selectRule(ruleSet.rules[ruleSet.rules.length - 1]);\n    } else if (selectRule) {\n      this.selectRule(selectRule);\n    }\n  }\n}\n"]}