nuxeo-development-framework 0.0.0-watch

package/esm2015/lib/components/dynamic-form/components/dynamic-form-department/constants/department.js

@@ -0,0 +1,13 @@
+export class DepartmentConstants {
+}
+DepartmentConstants.fields = {
+    title: 'dc:title',
+    description: 'dc:description',
+    agencyCode: 'dept:agencyCode',
+    arabicName: 'dept:arabicName',
+    englishName: 'dept:englishName',
+    deptTypee: 'dept:deptTypee',
+    isAllowRecExternal: 'dept:isAllowRecExternal',
+    manager: 'dept:manager',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwYXJ0bWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvZHluYW1pYy1mb3JtL2NvbXBvbmVudHMvZHluYW1pYy1mb3JtLWRlcGFydG1lbnQvY29uc3RhbnRzL2RlcGFydG1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLG1CQUFtQjs7QUFDaEIsMEJBQU0sR0FBRztJQUNyQixLQUFLLEVBQUUsVUFBVTtJQUNqQixXQUFXLEVBQUUsZ0JBQWdCO0lBQzdCLFVBQVUsRUFBRSxpQkFBaUI7SUFDN0IsVUFBVSxFQUFFLGlCQUFpQjtJQUM3QixXQUFXLEVBQUUsa0JBQWtCO0lBQy9CLFNBQVMsRUFBRSxnQkFBZ0I7SUFDM0Isa0JBQWtCLEVBQUUseUJBQXlCO0lBQzdDLE9BQU8sRUFBRSxjQUFjO0NBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgRGVwYXJ0bWVudENvbnN0YW50cyB7XHJcbiAgcHVibGljIHN0YXRpYyBmaWVsZHMgPSB7XHJcbiAgICB0aXRsZTogJ2RjOnRpdGxlJyxcclxuICAgIGRlc2NyaXB0aW9uOiAnZGM6ZGVzY3JpcHRpb24nLFxyXG4gICAgYWdlbmN5Q29kZTogJ2RlcHQ6YWdlbmN5Q29kZScsXHJcbiAgICBhcmFiaWNOYW1lOiAnZGVwdDphcmFiaWNOYW1lJyxcclxuICAgIGVuZ2xpc2hOYW1lOiAnZGVwdDplbmdsaXNoTmFtZScsXHJcbiAgICBkZXB0VHlwZWU6ICdkZXB0OmRlcHRUeXBlZScsXHJcbiAgICBpc0FsbG93UmVjRXh0ZXJuYWw6ICdkZXB0OmlzQWxsb3dSZWNFeHRlcm5hbCcsXHJcbiAgICBtYW5hZ2VyOiAnZGVwdDptYW5hZ2VyJyxcclxuICB9O1xyXG59XHJcbiJdfQ==

package/esm2015/lib/components/dynamic-form/components/dynamic-form-department/dynamic-form-department.component.js

@@ -0,0 +1,230 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, Input, Optional, Output, Self, ViewEncapsulation, } from '@angular/core';
+import { TreeviewItem } from 'ngx-treeview';
+import { first } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../core/services/translation/translation.service";
+import * as i2 from "./services/department-api.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "../dynamic-form-treeview-select/dropdown-treeview-select.component";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@ngx-translate/core";
+/**
+ * A department tree dropdown input already with departments backend,
+ *  that can be used inside reactive or template driven forms
+ * @title
+ * Department tree dropdown
+ * @example
+ *   <app-dynamic-form-department
+ *       label="Field Label"
+ *       placeholder="Placeholder text"
+ *       formControlName="controlName"
+ *     >
+ *   </app-dynamic-form-department>
+ */
+export class DynamicFormDepartmentComponent {
+    constructor(translation, departmentApi, control) {
+        this.translation = translation;
+        this.departmentApi = departmentApi;
+        this.control = control;
+        this.data = [];
+        /** is tree View or dropdown view */
+        this.treeview = false;
+        /** use tree view inside form */
+        this.treeViewAsFormControl = false;
+        /** Can select multiple */
+        this.multiple = false;
+        /** is tree searchable */
+        this.searchable = true;
+        this.defaultSelect = false;
+        this.displayDepTypee = true;
+        this.displayIsAllowRecExternal = true;
+        /** to allow custom paramsto be passed to get departments request from outside the component */
+        this.customParams = {};
+        this.disabled = false;
+        /** emitted when item is selected */
+        this.onSelecting = new EventEmitter();
+        /** emitted when action is clicked */
+        this.actionClicked = new EventEmitter();
+        this.loading = false;
+        this.arabic = false;
+        // function related to value accessor
+        this.propagateChange = () => { };
+        this.validateFn = () => { };
+        this.onTouched = () => {
+            /*Empty*/
+        };
+        this.control.valueAccessor = this;
+    }
+    get invalid() {
+        return this.control ? this.control.invalid : false;
+    }
+    get showError() {
+        if (!this.control) {
+            return false;
+        }
+        const { dirty, touched } = this.control;
+        return this.invalid ? dirty || touched : false;
+    }
+    ngOnInit() {
+        this.languageSubscription = this.translation.isArabic.subscribe((res) => __awaiter(this, void 0, void 0, function* () {
+            this.arabic = res;
+            yield this.getLisOfOptions();
+            this.writeValue(this.selection);
+        }));
+    }
+    ngOnDestroy() {
+        this.languageSubscription ? this.languageSubscription.unsubscribe() : '';
+    }
+    recursiveFill(entries, level = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(entries.map((item) => __awaiter(this, void 0, void 0, function* () {
+                let treeViewObj = this.treeview
+                    ? {
+                        text: this.arabic
+                            ? item.properties
+                                ? item.properties[this.customPrefix ? (this.customPrefix + ':arabicName') : 'dept:arabicName']
+                                : '--'
+                            : item.properties
+                                ? item.properties[this.customPrefix ? (this.customPrefix + ':englishName') : 'dept:englishName']
+                                : '--',
+                        value: Object.assign(Object.assign({}, item), { level }),
+                    }
+                    : {
+                        text: this.arabic
+                            ? item.properties
+                                ? item.properties[this.customPrefix ? (this.customPrefix + ':arabicName') : 'dept:arabicName']
+                                : '--'
+                            : item.properties
+                                ? item.properties[this.customPrefix ? (this.customPrefix + ':englishName') : 'dept:englishName']
+                                : '--',
+                        value: this.multiple ? item.uid : item.title,
+                    };
+                const treeItem = new TreeviewItem(Object.assign(Object.assign(Object.assign({}, treeViewObj), { collapsed: level >= 2 && this.treeview ? true : false }), (this.multiple && { checked: false })));
+                if (item.contextParameters &&
+                    item.contextParameters.children.entries.length) {
+                    if (!this.treeview &&
+                        (level == 2 || (level > 2 && (level + 1) % 3 == 0))) {
+                        const extended = yield this.departmentApi
+                            .getDepartmentNestedTree(item.title, this.pp_departmentNestedTree, this.customParentProperty)
+                            .pipe(first())
+                            .toPromise();
+                        treeItem.children = yield this.recursiveFill(extended.entries, level + 1);
+                    }
+                    else {
+                        treeItem.children = yield this.recursiveFill(item.contextParameters.children.entries, level + 1);
+                    }
+                }
+                return treeItem;
+            })));
+        });
+    }
+    getLisOfOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.departmentApi.getDepartmentTree(this.pp_departmentTree, this.customParams).subscribe((res) => __awaiter(this, void 0, void 0, function* () {
+                this.loading = false;
+                let _data = yield this.recursiveFill(res.entries);
+                if (this.fixedParentNode) {
+                    let fixedNode = new TreeviewItem({
+                        text: this.translation.instant(this.fixedParentNode.text),
+                        value: this.fixedParentNode.value,
+                        children: _data
+                    });
+                    this.data = [fixedNode];
+                }
+                else {
+                    this.data = _data;
+                }
+            }));
+        });
+    }
+    getSelecteditems(selectedItems) {
+        this.propagateChange(selectedItems);
+        this.onSelecting.emit(selectedItems);
+    }
+    writeValue(value) {
+        // if (value) { // removed to allow to reset value of tree
+        this.selection = value;
+        // }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    validate(c) {
+        return this.validateFn(c);
+    }
+    isRequired() {
+        if (!this.control || !this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return validator && validator.required;
+    }
+    hasErrors() {
+        return this.showError;
+    }
+    // onPlusClicked(e) {
+    //   this.plusClicked.next(e);
+    // }
+    onAction(e) {
+        this.actionClicked.emit(e);
+    }
+}
+DynamicFormDepartmentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormDepartmentComponent, deps: [{ token: i1.TranslationService }, { token: i2.DepartmentApiService }, { token: i3.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormDepartmentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFormDepartmentComponent, selector: "app-dynamic-form-department", inputs: { treeview: "treeview", treeViewAsFormControl: "treeViewAsFormControl", placeholder: "placeholder", multiple: "multiple", searchable: "searchable", label: "label", defaultSelect: "defaultSelect", displayDepTypee: "displayDepTypee", displayIsAllowRecExternal: "displayIsAllowRecExternal", pp_departmentNestedTree: "pp_departmentNestedTree", pp_departmentTree: "pp_departmentTree", customPrefix: "customPrefix", useCustomAddEditAction: "useCustomAddEditAction", customParentProperty: "customParentProperty", customParams: "customParams", disabled: "disabled", fixedParentNode: "fixedParentNode" }, outputs: { onSelecting: "onSelecting", actionClicked: "actionClicked" }, ngImport: i0, template: "<ng-container *ngIf=\"label\">\r\n  <div>\r\n    <label class=\"select-label\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n    >\r\n  </div>\r\n</ng-container>\r\n<app-dynamic-form-treeview-select\r\n  [treeview]=\"treeview\"\r\n  [treeViewAsFormControl]=\"treeViewAsFormControl\"\r\n  [defaultSelect]=\"defaultSelect\"\r\n  [multiple]=\"multiple\"\r\n  [items]=\"data\"\r\n  [placeholder]=\"placeholder\"\r\n  [displayDepTypee]=\"displayDepTypee\"\r\n  [displayIsAllowRecExternal]=\"displayIsAllowRecExternal\"\r\n  [pp_departmentNestedTree]=\"pp_departmentNestedTree\"\r\n  [useCustomAddEditAction]=\"useCustomAddEditAction\"\r\n  [customPrefix]=\"customPrefix\"\r\n  [customParentProperty]=\"customParentProperty\"\r\n  (valueChange)=\"getSelecteditems($event)\"\r\n  [(value)]=\"selection\"\r\n  (actionClicked)=\"onAction($event)\"\r\n  [disabled]=\"disabled\"\r\n  class=\"dropdown-wrapper\"\r\n  [ngClass]=\"{'input-filled' : selection && selection.length > 0 }\"\r\n>\r\n</app-dynamic-form-treeview-select>\r\n<mat-error\r\n  [attr.data-automation-id]=\"'card-textitem-error-'\"\r\n  class=\"app-textitem-editable-error\"\r\n  *ngIf=\"hasErrors()\"\r\n>\r\n  <ul>\r\n    <li *ngIf=\"control.errors.required\">\r\n      {{ \"VALIDATORS.REQUIRED\" | translate }}\r\n    </li>\r\n  </ul>\r\n</mat-error>\r\n", styles: ["app-dynamic-form-department .dropdown{border:1px solid #ccc!important;border-radius:5px!important}app-dynamic-form-department .input-filled .dropdown{border-color:#1a96c6!important}\n"], components: [{ type: i4.TreeviewSelectComponent, selector: "app-dynamic-form-treeview-select", inputs: ["treeview", "treeViewAsFormControl", "config", "items", "value", "multiple", "defaultSelect", "pp_departmentNestedTree", "useCustomAddEditAction", "customPrefix", "customParentProperty", "placeholder", "defaultSelection", "displayDepTypee", "disabled", "displayIsAllowRecExternal"], outputs: ["valueChange", "plusClicked", "actionClicked"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i6.MatError, selector: "mat-error", inputs: ["id"] }], pipes: { "translate": i7.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormDepartmentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-dynamic-form-department',
+                    templateUrl: './dynamic-form-department.component.html',
+                    styleUrls: ['./dynamic-form-department.component.scss'],
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslationService }, { type: i2.DepartmentApiService }, { type: i3.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { treeview: [{
+                type: Input
+            }], treeViewAsFormControl: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], defaultSelect: [{
+                type: Input
+            }], displayDepTypee: [{
+                type: Input
+            }], displayIsAllowRecExternal: [{
+                type: Input
+            }], pp_departmentNestedTree: [{
+                type: Input
+            }], pp_departmentTree: [{
+                type: Input
+            }], customPrefix: [{
+                type: Input
+            }], useCustomAddEditAction: [{
+                type: Input
+            }], customParentProperty: [{
+                type: Input
+            }], customParams: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], fixedParentNode: [{
+                type: Input
+            }], onSelecting: [{
+                type: Output
+            }], actionClicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-department.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-department/dynamic-form-department.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-department/dynamic-form-department.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Optional,\r\n  Output,\r\n  Self,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport {\r\n  AbstractControl,\r\n  ControlValueAccessor,\r\n  FormControl,\r\n  NgControl,\r\n} from '@angular/forms';\r\nimport { TreeviewItem } from 'ngx-treeview';\r\nimport { Observable, Subscription } from 'rxjs';\r\nimport { first } from 'rxjs/operators';\r\nimport { TranslationService } from '../../../../core/services/translation/translation.service';\r\nimport { DepartmentApiService } from './services/department-api.service';\r\n\r\n/**\r\n * A department tree dropdown input already with departments backend,\r\n *  that can be used inside reactive or template driven forms\r\n * @title\r\n * Department tree dropdown\r\n * @example\r\n *   <app-dynamic-form-department\r\n *       label=\"Field Label\"\r\n *       placeholder=\"Placeholder text\"\r\n *       formControlName=\"controlName\"\r\n *     >\r\n *   </app-dynamic-form-department>\r\n */\r\n@Component({\r\n  selector: 'app-dynamic-form-department',\r\n  templateUrl: './dynamic-form-department.component.html',\r\n  styleUrls: ['./dynamic-form-department.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class DynamicFormDepartmentComponent\r\n  implements ControlValueAccessor, OnInit, OnDestroy {\r\n  data = [];\r\n  /** is tree View or dropdown view */\r\n  @Input() treeview = false;\r\n  /** use tree view inside form */\r\n  @Input()\r\n  treeViewAsFormControl = false;\r\n  /** Placeholder text */\r\n  @Input() placeholder;\r\n  /** Can select multiple */\r\n  @Input() multiple = false;\r\n  /** is tree searchable */\r\n  @Input() searchable = true;\r\n  /** Input Field label */\r\n  @Input() label;\r\n  @Input() defaultSelect = false;\r\n  @Input() displayDepTypee = true;\r\n  @Input() displayIsAllowRecExternal = true;\r\n\r\n  /** custom page provider to get department nested tree from it can be passed from outside or not passed and use the defulte value */\r\n  @Input() pp_departmentNestedTree;\r\n  /** custom page provider to get department tree from it can be passed from outside or not passed and use the defulte value */\r\n  @Input() pp_departmentTree;\r\n  /** custom prefix to be used for adapting data coming from api */\r\n  @Input() customPrefix;\r\n  /** to allow custom action to be performed outside the component */\r\n  @Input() useCustomAddEditAction;\r\n  /** to allow custom parent property name  to be paassed from outside the component */\r\n  @Input() customParentProperty;\r\n  /** to allow custom paramsto be passed to get departments request from outside the component */\r\n  @Input() customParams = {};\r\n\r\n  @Input() disabled = false;\r\n\r\n  @Input() fixedParentNode: { text: string, value: string };\r\n  /** emitted when item is selected */\r\n  @Output() onSelecting = new EventEmitter();\r\n  /** emitted when action is clicked */\r\n  @Output() actionClicked = new EventEmitter();\r\n  loading = false;\r\n  selection;\r\n  arabic = false;\r\n  languageSubscription: Subscription;\r\n  // function related to value accessor\r\n  propagateChange: any = () => { };\r\n  validateFn: any = () => { };\r\n  public onTouched: any = () => {\r\n    /*Empty*/\r\n  };\r\n  public get invalid(): boolean {\r\n    return this.control ? this.control.invalid : false;\r\n  }\r\n\r\n  public get showError(): boolean {\r\n    if (!this.control) {\r\n      return false;\r\n    }\r\n\r\n    const { dirty, touched } = this.control;\r\n\r\n    return this.invalid ? dirty || touched : false;\r\n  }\r\n  constructor(\r\n    private translation: TranslationService,\r\n    private departmentApi: DepartmentApiService,\r\n    @Self() @Optional() public control: NgControl\r\n  ) {\r\n    this.control.valueAccessor = this;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.languageSubscription = this.translation.isArabic.subscribe(\r\n      async (res) => {\r\n        this.arabic = res;\r\n        await this.getLisOfOptions();\r\n        this.writeValue(this.selection);\r\n      }\r\n    );\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.languageSubscription ? this.languageSubscription.unsubscribe() : '';\r\n  }\r\n\r\n  async recursiveFill(entries, level = 0): Promise<any> {\r\n    return await Promise.all(\r\n      entries.map(async (item: any) => {\r\n        let treeViewObj = this.treeview\r\n          ? {\r\n            text: this.arabic\r\n              ? item.properties\r\n                ? item.properties[this.customPrefix ? (this.customPrefix + ':arabicName') : 'dept:arabicName']\r\n                : '--'\r\n              : item.properties\r\n                ? item.properties[this.customPrefix ? (this.customPrefix + ':englishName') : 'dept:englishName']\r\n                : '--',\r\n            value: { ...item, level },\r\n          }\r\n          : {\r\n            text: this.arabic\r\n              ? item.properties\r\n                ? item.properties[this.customPrefix ? (this.customPrefix + ':arabicName') : 'dept:arabicName']\r\n                : '--'\r\n              : item.properties\r\n                ? item.properties[this.customPrefix ? (this.customPrefix + ':englishName') : 'dept:englishName']\r\n                : '--',\r\n            value: this.multiple ? item.uid : item.title,\r\n          };\r\n\r\n        const treeItem = new TreeviewItem({\r\n          ...treeViewObj,\r\n          collapsed: level >= 2 && this.treeview ? true : false,\r\n          ...(this.multiple && { checked: false }),\r\n        });\r\n        if (\r\n          item.contextParameters &&\r\n          item.contextParameters.children.entries.length\r\n        ) {\r\n          if (\r\n            !this.treeview &&\r\n            (level == 2 || (level > 2 && (level + 1) % 3 == 0))\r\n          ) {\r\n            const extended = await this.departmentApi\r\n              .getDepartmentNestedTree(item.title, this.pp_departmentNestedTree, this.customParentProperty)\r\n              .pipe(first())\r\n              .toPromise();\r\n            treeItem.children = await this.recursiveFill(\r\n              extended.entries,\r\n              level + 1\r\n            );\r\n          } else {\r\n            treeItem.children = await this.recursiveFill(\r\n              item.contextParameters.children.entries,\r\n              level + 1\r\n            );\r\n          }\r\n        }\r\n        return treeItem;\r\n      })\r\n    );\r\n  }\r\n\r\n  async getLisOfOptions() {\r\n    this.departmentApi.getDepartmentTree(this.pp_departmentTree, this.customParams).subscribe(async (res) => {\r\n      this.loading = false;\r\n      let _data = await this.recursiveFill(res.entries);\r\n      if (this.fixedParentNode) {\r\n        let fixedNode = new TreeviewItem({\r\n          text: this.translation.instant(this.fixedParentNode.text),\r\n          value: this.fixedParentNode.value,\r\n          children: _data\r\n        })\r\n        this.data = [fixedNode];\r\n      } else {\r\n        this.data = _data;\r\n      }\r\n    });\r\n  }\r\n\r\n  getSelecteditems(selectedItems): void {\r\n    this.propagateChange(selectedItems);\r\n    this.onSelecting.emit(selectedItems);\r\n  }\r\n\r\n  writeValue(value): void {\r\n    // if (value) { // removed to allow to reset value of tree\r\n    this.selection = value;\r\n    // }\r\n  }\r\n\r\n  registerOnChange(fn): void {\r\n    this.propagateChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  validate(c: FormControl): any {\r\n    return this.validateFn(c);\r\n  }\r\n  isRequired(): boolean {\r\n    if (!this.control || !this.control.control.validator) {\r\n      return false;\r\n    }\r\n\r\n    const validator = this.control.control.validator({} as AbstractControl);\r\n    return validator && validator.required;\r\n  }\r\n  hasErrors(): boolean {\r\n    return this.showError;\r\n  }\r\n  // onPlusClicked(e) {\r\n  //   this.plusClicked.next(e);\r\n  // }\r\n\r\n  onAction(e) {\r\n    this.actionClicked.emit(e);\r\n  }\r\n}\r\n\r\n\r\n// http://35.153.66.52:8080/nuxeo/api/v1/search/pp/PP_Department/execute?pageProvider=PP_Department&currentPageIndex=0&offset=0&pageSize=40&quickFilters=Parent%20Dept\r\n// http://35.153.66.52:8080/nuxeo/api/v1/search/pp/PP_OS_Departments/execute?pageProvider=PP_OS_Departments&currentPageIndex=0&offset=0&pageSize=40&quickFilters=Parent%20Dept","<ng-container *ngIf=\"label\">\r\n  <div>\r\n    <label class=\"select-label\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n    >\r\n  </div>\r\n</ng-container>\r\n<app-dynamic-form-treeview-select\r\n  [treeview]=\"treeview\"\r\n  [treeViewAsFormControl]=\"treeViewAsFormControl\"\r\n  [defaultSelect]=\"defaultSelect\"\r\n  [multiple]=\"multiple\"\r\n  [items]=\"data\"\r\n  [placeholder]=\"placeholder\"\r\n  [displayDepTypee]=\"displayDepTypee\"\r\n  [displayIsAllowRecExternal]=\"displayIsAllowRecExternal\"\r\n  [pp_departmentNestedTree]=\"pp_departmentNestedTree\"\r\n  [useCustomAddEditAction]=\"useCustomAddEditAction\"\r\n  [customPrefix]=\"customPrefix\"\r\n  [customParentProperty]=\"customParentProperty\"\r\n  (valueChange)=\"getSelecteditems($event)\"\r\n  [(value)]=\"selection\"\r\n  (actionClicked)=\"onAction($event)\"\r\n  [disabled]=\"disabled\"\r\n  class=\"dropdown-wrapper\"\r\n  [ngClass]=\"{'input-filled' : selection && selection.length > 0 }\"\r\n>\r\n</app-dynamic-form-treeview-select>\r\n<mat-error\r\n  [attr.data-automation-id]=\"'card-textitem-error-'\"\r\n  class=\"app-textitem-editable-error\"\r\n  *ngIf=\"hasErrors()\"\r\n>\r\n  <ul>\r\n    <li *ngIf=\"control.errors.required\">\r\n      {{ \"VALIDATORS.REQUIRED\" | translate }}\r\n    </li>\r\n  </ul>\r\n</mat-error>\r\n"]}

package/esm2015/lib/components/dynamic-form/components/dynamic-form-department/services/department-api.service.js

@@ -0,0 +1,253 @@
+import { __decorate } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { TreeviewItem } from 'ngx-treeview';
+import { from, Subject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { DepartmentConstants } from '../constants/department';
+import { Cacheable, CacheBuster, LocalStorageStrategy } from 'ts-cacheable';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../core/services/callApi/call-api.service";
+import * as i2 from "../../../../../core/services/translation/translation.service";
+import * as i3 from "../../../../../core/services/nuxeo/nuxeo.service";
+import * as i4 from "../../../../../core/adapters/adapter.service";
+import * as i5 from "../../../../../shared-services/global-admin.service";
+export const departmentCacheBuster$ = new Subject();
+export const minute = 60000;
+/** @ignore */
+export class DepartmentApiService {
+    constructor(CallApiService, translation, nuxeoService, adapter, globalAdminService, environment) {
+        this.CallApiService = CallApiService;
+        this.translation = translation;
+        this.nuxeoService = nuxeoService;
+        this.adapter = adapter;
+        this.globalAdminService = globalAdminService;
+        this.environment = environment;
+        this.translation.isArabic.subscribe((res) => {
+            this.arabic = res;
+        });
+    }
+    getDepartmentTree(customPageProvider, customParams) {
+        let obj = customParams ? customParams : {};
+        let params = Object.assign({ pageProvider: customPageProvider ? customPageProvider : 'PP_Department', currentPageIndex: 0, offset: 0, pageSize: 40, quickFilters: 'Parent Dept' }, obj);
+        if (this.globalAdminService.isGlobalAdmin) {
+            params['queryParams'] = this.globalAdminService.activeTenant;
+        }
+        else if (!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId) {
+            params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId;
+        }
+        return this.CallApiService.query(Object.assign({}, params), {
+            headers: {
+                'X-NXproperties': '*',
+                'enrichers-document': 'children',
+                depth: 'max',
+            },
+        });
+    }
+    getDepartmentDetails(code, customPageProvider) {
+        let params = {
+            pageProvider: customPageProvider ? customPageProvider : 'PP_Department_With_ElasticSearch',
+            currentPageIndex: 0,
+            offset: 0,
+            pageSize: 40,
+            dublincore_title: code,
+        };
+        if (this.globalAdminService.isGlobalAdmin) {
+            params['queryParams'] = this.globalAdminService.activeTenant;
+        }
+        else if (!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId) {
+            params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId;
+        }
+        return this.CallApiService.query(Object.assign({}, params), {
+            headers: {
+                'X-NXproperties': '*',
+                'enrichers-document': 'children',
+                depth: 'max',
+            },
+        });
+    }
+    getDepartmentNestedTree(code, customPageProvider, customParentCodeProperty) {
+        let params = {};
+        customParentCodeProperty ? (params[customParentCodeProperty] = code) : (params = { 'department_parentDepartmentCode': code });
+        if (this.globalAdminService.isGlobalAdmin) {
+            params['queryParams'] = this.globalAdminService.activeTenant;
+        }
+        else if (!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId) {
+            params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId;
+        }
+        return this.CallApiService.query(Object.assign({ pageProvider: customPageProvider ? customPageProvider : 'PP_Department', currentPageIndex: 0, offset: 0, pageSize: 40 }, params), {
+            headers: {
+                'X-NXproperties': '*',
+                'enrichers-document': 'children',
+                depth: 'max',
+            },
+        });
+    }
+    getDepartment(uid, fields) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers({
+            'X-NXproperties': '*',
+        })
+            .fetch(uid)).pipe(map((data) => {
+            return this.adapter.adaptIn(data, fields ? fields : DepartmentConstants.fields);
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    // testing
+    createDepartment(Department, parentId, customOperation, fields) {
+        let context = { department: this.adapter.adaptOut(Department, fields ? fields : DepartmentConstants.fields) };
+        if (this.globalAdminService.isGlobalAdmin) {
+            context['tenantId'] = this.globalAdminService.activeTenant;
+        }
+        return from(this.nuxeoService.nuxeoClient
+            .operation(customOperation ? customOperation : 'AC_UA_Depatrment_Create', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(parentId)
+            .context(Object.assign({}, context))
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    createDepartmentInRoot(Department, customOperation) {
+        let context = {
+            department: this.adapter.adaptOut(Department, DepartmentConstants.fields)
+        };
+        if (this.globalAdminService.isGlobalAdmin) {
+            context['tenantId'] = this.globalAdminService.activeTenant;
+        }
+        return from(this.nuxeoService.nuxeoClient
+            .operation(customOperation ? customOperation : 'AC_UA_Depatrment_Create_InRoot', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .context(Object.assign({}, context))
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    updateDepartment(Department, departmentId, customOperation, fields) {
+        let context = {
+            department: this.adapter.adaptOut(Department, fields ? fields : DepartmentConstants.fields)
+        };
+        if (this.globalAdminService.isGlobalAdmin) {
+            context['tenantId'] = this.globalAdminService.activeTenant;
+        }
+        return from(this.nuxeoService.nuxeoClient
+            .operation(customOperation ? customOperation : 'AC_UA_Department_Update', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(departmentId)
+            .context(Object.assign({}, context))
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    recursiveFill(entries, level = 0, treeview = true, collapsed = true, customPrefix) {
+        return entries.map((item) => {
+            let treeViewObj = treeview
+                ? {
+                    text: this.arabic
+                        ? item.properties
+                            ? item.properties[customPrefix ? (customPrefix + ':arabicName') : 'dept:arabicName']
+                            : '--'
+                        : item.properties
+                            ? item.properties[customPrefix ? (customPrefix + ':englishName') : 'dept:englishName']
+                            : '--',
+                    value: Object.assign(Object.assign({}, item), { level }),
+                }
+                : {
+                    text: this.arabic
+                        ? item.properties
+                            ? item.properties[customPrefix ? (customPrefix + ':arabicName') : 'dept:arabicName']
+                            : '--'
+                        : item.properties
+                            ? item.properties[customPrefix ? (customPrefix + ':englishName') : 'dept:englishName']
+                            : '--',
+                    value: item.title,
+                };
+            const treeItem = new TreeviewItem(Object.assign(Object.assign({}, treeViewObj), { collapsed: level >= 2 && collapsed ? true : false }));
+            if (item.contextParameters &&
+                item.contextParameters.children.entries.length) {
+                treeItem.children = this.recursiveFill(item.contextParameters.children.entries, level + 1, undefined, undefined, customPrefix);
+            }
+            return treeItem;
+        });
+    }
+    getFullDepartmentTree(customPageProvider, customParams) {
+        let obj = customParams ? customParams : {};
+        let params = Object.assign({ pageProvider: customPageProvider ? customPageProvider : 'PP_Department', currentPageIndex: 0, offset: 0, pageSize: 40, quickFilters: 'Parent Dept' }, obj);
+        if (this.globalAdminService.isGlobalAdmin) {
+            params['queryParams'] = this.globalAdminService.activeTenant;
+        }
+        else if (!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId) {
+            params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId;
+        }
+        return this.CallApiService.query(Object.assign({}, params), {
+            headers: {
+                'X-NXproperties': '*',
+                'enrichers-document': 'children',
+                depth: 'max',
+            },
+        });
+    }
+}
+DepartmentApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentApiService, deps: [{ token: i1.CallApiService }, { token: i2.TranslationService }, { token: i3.NuxeoService }, { token: i4.AdapterService }, { token: i5.GlobalAdminService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+DepartmentApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentApiService, providedIn: 'root' });
+__decorate([
+    Cacheable({
+        cacheBusterObserver: departmentCacheBuster$,
+        storageStrategy: LocalStorageStrategy,
+        maxAge: 60 * minute,
+    })
+], DepartmentApiService.prototype, "getDepartmentTree", null);
+__decorate([
+    Cacheable({
+        maxCacheCount: 200,
+        storageStrategy: LocalStorageStrategy,
+        cacheBusterObserver: departmentCacheBuster$,
+        maxAge: 120 * minute,
+    })
+], DepartmentApiService.prototype, "getDepartmentDetails", null);
+__decorate([
+    Cacheable({
+        maxCacheCount: 200,
+        cacheBusterObserver: departmentCacheBuster$,
+        storageStrategy: LocalStorageStrategy,
+        maxAge: 60 * minute,
+    })
+], DepartmentApiService.prototype, "getDepartmentNestedTree", null);
+__decorate([
+    CacheBuster({
+        cacheBusterNotifier: departmentCacheBuster$,
+    })
+], DepartmentApiService.prototype, "createDepartment", null);
+__decorate([
+    CacheBuster({
+        cacheBusterNotifier: departmentCacheBuster$,
+    })
+], DepartmentApiService.prototype, "createDepartmentInRoot", null);
+__decorate([
+    CacheBuster({
+        cacheBusterNotifier: departmentCacheBuster$,
+    })
+], DepartmentApiService.prototype, "updateDepartment", null);
+__decorate([
+    Cacheable({
+        cacheBusterObserver: departmentCacheBuster$,
+        storageStrategy: LocalStorageStrategy
+    })
+], DepartmentApiService.prototype, "getFullDepartmentTree", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CallApiService }, { type: i2.TranslationService }, { type: i3.NuxeoService }, { type: i4.AdapterService }, { type: i5.GlobalAdminService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; }, propDecorators: { getDepartmentTree: [], getDepartmentDetails: [], getDepartmentNestedTree: [], createDepartment: [], createDepartmentInRoot: [], updateDepartment: [], getFullDepartmentTree: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"department-api.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-department/services/department-api.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAgB,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAKjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;;;;;;;AAE5E,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,OAAO,EAAQ,CAAC;AAC1D,MAAM,CAAC,MAAM,MAAM,GAAG,KAAK,CAAC;AAC5B,cAAc;AAKd,MAAM,OAAO,oBAAoB;IAE/B,YACU,cAA8B,EAC9B,WAA+B,EAC/B,YAA0B,EAC1B,OAAuB,EACvB,kBAAuC,EAChB,WAAW;QALlC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,gBAAW,GAAX,WAAW,CAAoB;QAC/B,iBAAY,GAAZ,YAAY,CAAc;QAC1B,YAAO,GAAP,OAAO,CAAgB;QACvB,uBAAkB,GAAlB,kBAAkB,CAAqB;QAChB,gBAAW,GAAX,WAAW,CAAA;QAE1C,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1C,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC;IAQD,iBAAiB,CAAC,kBAAmB,EAAC,YAAa;QACjD,IAAI,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3C,IAAI,MAAM,mBACR,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe,EACvE,gBAAgB,EAAE,CAAC,EACnB,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,EAAE,EACZ,YAAY,EAAE,aAAa,IACxB,GAAG,CACP,CAAA;QACD,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC7D;aAAK,IAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAC;YACxG,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAA;SAC/E;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,mBAEzB,MAAM,GAEX;YACE,OAAO,EAAE;gBACP,gBAAgB,EAAE,GAAG;gBACrB,oBAAoB,EAAE,UAAU;gBAChC,KAAK,EAAE,KAAK;aACb;SACF,CACF,CAAC;IACJ,CAAC;IAQD,oBAAoB,CAAC,IAAI,EAAG,kBAAmB;QAC7C,IAAI,MAAM,GAAG;YACX,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAA,CAAC,CAAC,kCAAkC;YACzF,gBAAgB,EAAE,CAAC;YACnB,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,EAAE;YACZ,gBAAgB,EAAE,IAAI;SACvB,CAAA;QACD,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC7D;aAAK,IAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAC;YACxG,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAA;SAC/E;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,mBAEzB,MAAM,GAEX;YACE,OAAO,EAAE;gBACP,gBAAgB,EAAE,GAAG;gBACrB,oBAAoB,EAAE,UAAU;gBAChC,KAAK,EAAE,KAAK;aACb;SACF,CACF,CAAC;IACJ,CAAC;IAQD,uBAAuB,CAAC,IAAI,EAAG,kBAAmB,EAAG,wBAAyB;QAC5E,IAAI,MAAM,GAAG,EAAE,CAAC;QACf,wBAAwB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC,GAAG,IAAI,CAAC,CAAE,CAAC,CAAC,CAAC,MAAM,GAAG,EAAC,iCAAiC,EAAE,IAAI,EAAC,CAAC,CAAA;QAC5H,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACxC,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC7D;aAAK,IAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAC;YACxG,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAA;SAC/E;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,iBAE5B,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe,EACvE,gBAAgB,EAAE,CAAC,EACnB,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,EAAE,IACT,MAAM,GAEX;YACE,OAAO,EAAE;gBACP,gBAAgB,EAAE,GAAG;gBACrB,oBAAoB,EAAE,UAAU;gBAChC,KAAK,EAAE,KAAK;aACb;SACF,CACF,CAAC;IACJ,CAAC;IAED,aAAa,CAAC,GAAG,EAAG,MAAO;QACzB,OAAO,IAAI,CACT,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,UAAU,EAAE;aACZ,OAAO,CAAC;YACP,gBAAgB,EAAE,GAAG;SACtB,CAAC;aACD,KAAK,CAAC,GAAG,CAAC,CACd,CAAC,IAAI,CACJ,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAClF,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,UAAU;IAIV,gBAAgB,CAAC,UAAU,EAAE,QAAQ,EAAG,eAAgB,EAAG,MAAO;QAChE,IAAI,OAAO,GAAE,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAC9C,UAAU,EACV,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAC7C,EAAC,CAAC;QACH,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC3D;QAED,OAAO,IAAI,CACT,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,SAAS,CAAE,eAAe,CAAC,CAAC,CAAC,eAAe,CAAA,CAAC,CAAC,yBAAyB,EAAG;YACzE,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE;SACrE,CAAC;aACD,KAAK,CAAC,QAAQ,CAAC;aACf,OAAO,mBACH,OAAO,EACV;aACD,OAAO,EAAE,CACb,CAAC,IAAI,CACJ,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAKD,sBAAsB,CAAC,UAAU,EAAG,eAAgB;QAClD,IAAI,OAAO,GAAG;YACZ,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAC/B,UAAU,EACV,mBAAmB,CAAC,MAAM,CAC3B;SACF,CAAA;QACD,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC3D;QACD,OAAO,IAAI,CACT,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,gCAAgC,EAAE;YAC/E,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE;SACrE,CAAC;aACD,OAAO,mBACH,OAAO,EACV;aACD,OAAO,EAAE,CACb,CAAC,IAAI,CACJ,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAKD,gBAAgB,CAAC,UAAU,EAAE,YAAY,EAAG,eAAgB,EAAG,MAAO;QACpE,IAAI,OAAO,GAAG;YACZ,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAC/B,UAAU,EACV,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAC7C;SACF,CAAA;QACD,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC3D;QACD,OAAO,IAAI,CACT,IAAI,CAAC,YAAY,CAAC,WAAW;aAC1B,SAAS,CAAE,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,yBAAyB,EAAG;YAC1E,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE;SACrE,CAAC;aACD,KAAK,CAAC,YAAY,CAAC;aACnB,OAAO,mBACH,OAAO,EACV;aACD,OAAO,EAAE,CACb,CAAC,IAAI,CACJ,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,aAAa,CACX,OAAO,EACP,KAAK,GAAG,CAAC,EACT,QAAQ,GAAG,IAAI,EACf,SAAS,GAAG,IAAI,EAChB,YAAa;QAEb,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YAC1B,IAAI,WAAW,GAAG,QAAQ;gBACxB,CAAC,CAAC;oBACE,IAAI,EAAE,IAAI,CAAC,MAAM;wBACf,CAAC,CAAC,IAAI,CAAC,UAAU;4BACf,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;4BACpF,CAAC,CAAC,IAAI;wBACR,CAAC,CAAC,IAAI,CAAC,UAAU;4BACjB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC;4BACtF,CAAC,CAAC,IAAI;oBACR,KAAK,kCAAO,IAAI,KAAE,KAAK,GAAE;iBAC1B;gBACH,CAAC,CAAC;oBACE,IAAI,EAAE,IAAI,CAAC,MAAM;wBACf,CAAC,CAAC,IAAI,CAAC,UAAU;4BACf,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;4BACpF,CAAC,CAAC,IAAI;wBACR,CAAC,CAAC,IAAI,CAAC,UAAU;4BACjB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC;4BACtF,CAAC,CAAC,IAAI;oBACR,KAAK,EAAE,IAAI,CAAC,KAAK;iBAClB,CAAC;YACN,MAAM,QAAQ,GAAG,IAAI,YAAY,iCAC5B,WAAW,KACd,SAAS,EAAE,KAAK,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IACjD,CAAC;YACH,IACE,IAAI,CAAC,iBAAiB;gBACtB,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAC9C;gBACA,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,aAAa,CACpC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,EACvC,KAAK,GAAG,CAAC,EACT,SAAS,EACT,SAAS,EACT,YAAY,CACb,CAAC;aACH;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAOD,qBAAqB,CAAC,kBAAmB,EAAC,YAAa;QACrD,IAAI,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3C,IAAI,MAAM,mBACR,YAAY,EAAE,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe,EACvE,gBAAgB,EAAE,CAAC,EACnB,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,EAAE,EACZ,YAAY,EAAE,aAAa,IACxB,GAAG,CACP,CAAA;QACD,IAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAC;YACvC,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAA;SAC7D;aAAK,IAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAC;YACxG,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAA;SAC/E;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,mBAEzB,MAAM,GAEX;YACE,OAAO,EAAE;gBACP,gBAAgB,EAAE,GAAG;gBACrB,oBAAoB,EAAE,UAAU;gBAChC,KAAK,EAAE,KAAK;aACb;SACF,CACF,CAAC;IACJ,CAAC;;kHAlTU,oBAAoB,8KAQrB,aAAa;sHARZ,oBAAoB,cAFnB,MAAM;AAuBlB;IANC,SAAS,CAAC;QACT,mBAAmB,EAAE,sBAAsB;QAC3C,eAAe,EAAE,oBAAoB;QACrC,MAAM,EAAE,EAAE,GAAG,MAAM;KACpB,CAAC;6DA6BD;AAQD;IANC,SAAS,CAAC;QACT,aAAa,EAAE,GAAG;QAClB,eAAe,EAAE,oBAAoB;QACrC,mBAAmB,EAAE,sBAAsB;QAC3C,MAAM,EAAE,GAAG,GAAG,MAAM;KACrB,CAAC;gEA0BD;AAQD;IANC,SAAS,CAAC;QACT,aAAa,EAAE,GAAG;QAClB,mBAAmB,EAAE,sBAAsB;QAC3C,eAAe,EAAE,oBAAoB;QACrC,MAAM,EAAE,EAAE,GAAG,MAAM;KACpB,CAAC;mEAyBD;AAwBD;IAHC,WAAW,CAAC;QACX,mBAAmB,EAAE,sBAAsB;KAC5C,CAAC;4DA0BD;AAKD;IAHC,WAAW,CAAC;QACX,mBAAmB,EAAE,sBAAsB;KAC5C,CAAC;kEA0BD;AAKD;IAHC,WAAW,CAAC;QACX,mBAAmB,EAAE,sBAAsB;KAC5C,CAAC;4DA2BD;AAwDD;IALC,SAAS,CAAC;QACT,mBAAmB,EAAE,sBAAsB;QAC3C,eAAe,EAAE,oBAAoB;KACtC,CAAC;iEA6BD;4FAlTU,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BASI,MAAM;2BAAC,aAAa;4CAavB,iBAAiB,MAmCjB,oBAAoB,MAiCpB,uBAAuB,MAgDvB,gBAAgB,MA8BhB,sBAAsB,MA8BtB,gBAAgB,MAkFhB,qBAAqB","sourcesContent":["import { EventEmitter, Inject, Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { TreeviewItem } from 'ngx-treeview';\r\nimport { from, Observable, Subject } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { AdapterService } from '../../../../../core/adapters/adapter.service';\r\nimport { CallApiService } from '../../../../../core/services/callApi/call-api.service';\r\nimport { NuxeoService } from '../../../../../core/services/nuxeo/nuxeo.service';\r\nimport { TranslationService } from '../../../../../core/services/translation/translation.service';\r\nimport { DepartmentConstants } from '../constants/department';\r\nimport { Cacheable, CacheBuster, LocalStorageStrategy } from 'ts-cacheable';\r\nimport { GlobalAdminService } from '../../../../../shared-services/global-admin.service';\r\nexport const departmentCacheBuster$ = new Subject<void>();\r\nexport const minute = 60000;\r\n/** @ignore */\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DepartmentApiService {\r\n  arabic;\r\n  constructor(\r\n    private CallApiService: CallApiService,\r\n    private translation: TranslationService,\r\n    private nuxeoService: NuxeoService,\r\n    private adapter: AdapterService, \r\n    private globalAdminService : GlobalAdminService,\r\n    @Inject('environment') private environment\r\n  ) {\r\n    this.translation.isArabic.subscribe((res) => {\r\n      this.arabic = res;\r\n    });\r\n  }\r\n\r\n  @Cacheable({\r\n    cacheBusterObserver: departmentCacheBuster$,\r\n    storageStrategy: LocalStorageStrategy,\r\n    maxAge: 60 * minute,\r\n  })\r\n  \r\n  getDepartmentTree(customPageProvider?,customParams?): Observable<any> {\r\n    let obj = customParams ? customParams : {};\r\n    let params = {\r\n      pageProvider: customPageProvider ? customPageProvider : 'PP_Department',\r\n      currentPageIndex: 0,\r\n      offset: 0,\r\n      pageSize: 40,\r\n      quickFilters: 'Parent Dept',\r\n      ...obj\r\n    }\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      params['queryParams'] = this.globalAdminService.activeTenant\r\n    }else if(!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId){\r\n      params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId\r\n    }\r\n    return this.CallApiService.query(\r\n      {\r\n        ...params\r\n      },\r\n      {\r\n        headers: {\r\n          'X-NXproperties': '*',\r\n          'enrichers-document': 'children',\r\n          depth: 'max',\r\n        },\r\n      }\r\n    );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 200,\r\n    storageStrategy: LocalStorageStrategy,\r\n    cacheBusterObserver: departmentCacheBuster$,\r\n    maxAge: 120 * minute,\r\n  })\r\n  getDepartmentDetails(code , customPageProvider?){\r\n    let params = {\r\n      pageProvider: customPageProvider ? customPageProvider: 'PP_Department_With_ElasticSearch',\r\n      currentPageIndex: 0,\r\n      offset: 0,\r\n      pageSize: 40,\r\n      dublincore_title: code,\r\n    }\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      params['queryParams'] = this.globalAdminService.activeTenant\r\n    }else if(!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId){\r\n      params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId\r\n    }\r\n    return this.CallApiService.query(\r\n      {\r\n        ...params\r\n      },\r\n      {\r\n        headers: {\r\n          'X-NXproperties': '*',\r\n          'enrichers-document': 'children',\r\n          depth: 'max',\r\n        },\r\n      }\r\n    );\r\n  }\r\n\r\n  @Cacheable({\r\n    maxCacheCount: 200,\r\n    cacheBusterObserver: departmentCacheBuster$,\r\n    storageStrategy: LocalStorageStrategy,\r\n    maxAge: 60 * minute,\r\n  })\r\n  getDepartmentNestedTree(code , customPageProvider? , customParentCodeProperty?): Observable<any> {\r\n    let params = {};\r\n     customParentCodeProperty ? (params[customParentCodeProperty] = code)  : (params = {'department_parentDepartmentCode': code})\r\n     if(this.globalAdminService.isGlobalAdmin){\r\n      params['queryParams'] = this.globalAdminService.activeTenant\r\n    }else if(!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId){\r\n      params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId\r\n    }\r\n    return this.CallApiService.query(\r\n      {\r\n        pageProvider: customPageProvider ? customPageProvider : 'PP_Department',\r\n        currentPageIndex: 0,\r\n        offset: 0,\r\n        pageSize: 40,\r\n        ...params\r\n      },\r\n      {\r\n        headers: {\r\n          'X-NXproperties': '*',\r\n          'enrichers-document': 'children',\r\n          depth: 'max',\r\n        },\r\n      }\r\n    );\r\n  }\r\n\r\n  getDepartment(uid , fields?) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          'X-NXproperties': '*',\r\n        })\r\n        .fetch(uid)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        return this.adapter.adaptIn(data, fields ? fields : DepartmentConstants.fields);\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  // testing\r\n  @CacheBuster({\r\n    cacheBusterNotifier: departmentCacheBuster$,\r\n  })\r\n  createDepartment(Department, parentId , customOperation? , fields?) {\r\n    let context ={ department: this.adapter.adaptOut(\r\n      Department,\r\n      fields ? fields : DepartmentConstants.fields\r\n    )};\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      context['tenantId'] = this.globalAdminService.activeTenant\r\n    }\r\n\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation( customOperation ? customOperation: 'AC_UA_Depatrment_Create' , {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(parentId)\r\n        .context({\r\n          ...context\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  @CacheBuster({\r\n    cacheBusterNotifier: departmentCacheBuster$,\r\n  })\r\n  createDepartmentInRoot(Department , customOperation?) {\r\n    let context = {\r\n      department: this.adapter.adaptOut(\r\n        Department,\r\n        DepartmentConstants.fields\r\n      )\r\n    }\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      context['tenantId'] = this.globalAdminService.activeTenant\r\n    }\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(customOperation ? customOperation : 'AC_UA_Depatrment_Create_InRoot', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .context({\r\n          ...context\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  @CacheBuster({\r\n    cacheBusterNotifier: departmentCacheBuster$,\r\n  })\r\n  updateDepartment(Department, departmentId , customOperation? , fields?) {\r\n    let context = {\r\n      department: this.adapter.adaptOut(\r\n        Department,\r\n        fields ? fields : DepartmentConstants.fields\r\n      )\r\n    }\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      context['tenantId'] = this.globalAdminService.activeTenant\r\n    }\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation( customOperation ? customOperation : 'AC_UA_Department_Update' , {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(departmentId)\r\n        .context({\r\n          ...context\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  recursiveFill(\r\n    entries,\r\n    level = 0,\r\n    treeview = true,\r\n    collapsed = true,\r\n    customPrefix?\r\n  ): TreeviewItem[] {\r\n    return entries.map((item) => {\r\n      let treeViewObj = treeview\r\n        ? {\r\n            text: this.arabic\r\n              ? item.properties\r\n                ? item.properties[customPrefix ? (customPrefix + ':arabicName') : 'dept:arabicName']\r\n                : '--'\r\n              : item.properties\r\n              ? item.properties[customPrefix ? (customPrefix + ':englishName') : 'dept:englishName']\r\n              : '--',\r\n            value: { ...item, level },\r\n          }\r\n        : {\r\n            text: this.arabic\r\n              ? item.properties\r\n                ? item.properties[customPrefix ? (customPrefix + ':arabicName') : 'dept:arabicName']\r\n                : '--'\r\n              : item.properties\r\n              ? item.properties[customPrefix ? (customPrefix + ':englishName') : 'dept:englishName']\r\n              : '--',\r\n            value: item.title,\r\n          };\r\n      const treeItem = new TreeviewItem({\r\n        ...treeViewObj,\r\n        collapsed: level >= 2 && collapsed ? true : false,\r\n      });\r\n      if (\r\n        item.contextParameters &&\r\n        item.contextParameters.children.entries.length\r\n      ) {\r\n        treeItem.children = this.recursiveFill(\r\n          item.contextParameters.children.entries,\r\n          level + 1,\r\n          undefined,\r\n          undefined,\r\n          customPrefix\r\n        );\r\n      }\r\n      return treeItem;\r\n    });\r\n  }\r\n\r\n  @Cacheable({\r\n    cacheBusterObserver: departmentCacheBuster$,\r\n    storageStrategy: LocalStorageStrategy\r\n  })\r\n  \r\n  getFullDepartmentTree(customPageProvider?,customParams?): Observable<any> {\r\n    let obj = customParams ? customParams : {};\r\n    let params = {\r\n      pageProvider: customPageProvider ? customPageProvider : 'PP_Department',\r\n      currentPageIndex: 0,\r\n      offset: 0,\r\n      pageSize: 40,\r\n      quickFilters: 'Parent Dept',\r\n      ...obj\r\n    }\r\n    if(this.globalAdminService.isGlobalAdmin){\r\n      params['queryParams'] = this.globalAdminService.activeTenant\r\n    }else if(!this.globalAdminService.isGlobalAdmin && this.nuxeoService.nuxeoClient.user.properties.tenantId){\r\n      params['queryParams'] = this.nuxeoService.nuxeoClient.user.properties.tenantId\r\n    }\r\n    return this.CallApiService.query(\r\n      {\r\n        ...params\r\n      },\r\n      {\r\n        headers: {\r\n          'X-NXproperties': '*',\r\n          'enrichers-document': 'children',\r\n          depth: 'max',\r\n        },\r\n      }\r\n    );\r\n  }\r\n}\r\n"]}