nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/shared-services/file-manager.service.ts

@@ -0,0 +1,1529 @@
+import { HttpClient } from "@angular/common/http";
+import { EventEmitter, Inject, Injectable, OnDestroy } from "@angular/core";
+import { FileManagerAdapter } from "./file-manager.adapter";
+import { saveAs } from "file-saver";
+import {
+  combineLatest,
+  EMPTY,
+  forkJoin,
+  from,
+  Observable,
+  of,
+  Subject,
+  Subscriber,
+  Subscription,
+} from "rxjs";
+import {
+  catchError,
+  delay,
+  expand,
+  first,
+  map,
+  mergeMap,
+  switchMap,
+  tap,
+  toArray,
+} from "rxjs/operators";
+import { MainfolderService } from "./mainfolder.service";
+import { CallApiService } from "../core/services/callApi/call-api.service";
+import { AdapterService } from "../core/adapters/adapter.service";
+import { NuxeoService } from "../core/services/nuxeo/nuxeo.service";
+import { AppConfigService } from "../configuration/app-config.service";
+import { EvaluatorsService } from "../directive/permissions/evaluators.service";
+import { CustomToastrService } from "../components/custom-toastr/services/custom-toastr.service";
+import { TranslationService } from "../core/services/translation/translation.service";
+import { ConfirmationDialogComponent } from "../components/confirmation-dialog/confirmation-dialog/confirmation-dialog.component";
+import { MatDialog } from "@angular/material/dialog";
+import { Router } from "@angular/router";
+import { RecentlyViewedService } from "./recently-viewed.service";
+import { FileManagerPaginationConfig, FileManagerPaginationData, FolderishType, PaginationPayload } from "../components/file-manger/models";
+
+@Injectable({
+  providedIn: "root",
+})
+export class FileManagerService implements OnDestroy {
+  pageProvider: any;
+  headers: any;
+  fields: any;
+  allFilesConfig;
+  selectedFolderId;
+  onRefreshingFileManger = new Subject<any>();
+  onRefreshClipboard = new EventEmitter();
+  permissionsList = [
+    "canDelete",
+    "canCreate",
+    "canDownload",
+    "canUpdate",
+    "canPublish",
+    "canPublishFolders",
+    "canGet",
+    "canCopy",
+    "canCopyFile",
+    "canDeleteFromSourceParent",
+    "canRenameToSourceParent",
+    "setSynchronize",
+    "setUnSynchronize",
+    "canAddToQuickAccess",
+    "canShare",
+    "canRename",
+    "canMove",
+    "canMoveFile",
+    "lockOwnerIfLocked",
+    "notSecretFile",
+    "isUserSubscriberToFile",
+    "canSubscribe",
+    "isWorkSpaceRootFile",
+    "isDepartmentRootFile",
+    "canAddToClipboard",
+    "canCopyToDestination",
+    "isArchieveDocument",
+  ];
+  userPermittedTypes: any[] = [];
+  userPermittedTypesTotalSize = -1;
+  userPermittedFilesOnly: any[] = [];
+  sharedFiles;
+  isArabic = false;
+  langSubscription: Subscription;
+  clipboardPermissionList = ["canCopy", "canMove"];
+  customEvent = new EventEmitter<any>();
+
+  static PaginationConfig: { enable: boolean; pageSize: number } = {
+    enable: false,
+    pageSize: 50,
+  };
+
+  constructor(
+    private callApi: CallApiService,
+    private adapter: AdapterService,
+    @Inject("environment") private environment,
+    private fileManagerAdapter: FileManagerAdapter,
+    private appConfService: AppConfigService,
+    private nuxeoService: NuxeoService,
+    private permissionEvaluatorService: EvaluatorsService,
+    private mainFolderService: MainfolderService,
+    private http: HttpClient,
+    private translationService: TranslationService,
+    private toaster: CustomToastrService,
+    private dialog: MatDialog,
+    private router: Router,
+    private recentlyViewedService: RecentlyViewedService
+  ) {
+    this.setMyTableConfiguration();
+    this.langSubscription = this.translationService.isArabic$.subscribe(
+      (res) => {
+        this.isArabic = res;
+        this.userPermittedTypes = this.sortingTypes(this.userPermittedTypes);
+        this.userPermittedFilesOnly = this.sortingTypes(
+          this.userPermittedFilesOnly
+        );
+      }
+    );
+  }
+  ngOnDestroy(): void {
+    this.langSubscription ? this.langSubscription.unsubscribe() : null;
+  }
+  setMyTableConfiguration() {
+    this.allFilesConfig = this.appConfService.myConfiguration.tables.allFiles;
+    this.headers = this.allFilesConfig.headers;
+    this.fields = this.allFilesConfig.fields;
+    this.pageProvider = this.allFilesConfig.pageProvider;
+
+    FileManagerPaginationConfig.Enable =
+      this.appConfService.myConfiguration.fileManger?.pagination?.enable ||
+      FileManagerPaginationConfig.Enable;
+    FileManagerPaginationConfig.PageSize =
+      this.appConfService.myConfiguration.fileManger?.pagination?.pageSize ||
+      FileManagerPaginationConfig.PageSize;
+    FileManagerPaginationConfig.DelayFoldersRequests =
+      this.appConfService.myConfiguration.fileManger?.pagination
+        ?.delayFoldersRequests ||
+      FileManagerPaginationConfig.DelayFoldersRequests;
+    FileManagerPaginationConfig.MaxFoldersRequestCount =
+      this.appConfService.myConfiguration.fileManger?.pagination
+        ?.maxFoldersRequestCount ||
+      FileManagerPaginationConfig.MaxFoldersRequestCount;
+  }
+
+  // return accepted types for certain id
+  getClipboardAcceptedTypes(id) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        .headers({
+          properties: "*",
+          "X-NXenrichers-document": "accepted_children",
+        })
+        .fetch(id)
+    ).pipe(
+      map((data: any) => {
+        delete data._nuxeo;
+        delete data._repository;
+        return data;
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getClipboardDocuments(docIds, sortObj?: any): Observable<any> {
+    return this.callApi
+      .query(
+        {
+          pageProvider: "Documents_InList_PP",
+          currentPageIndex: 0,
+          offset: 0,
+          pageSize: 15,
+          system_uuid: JSON.stringify(docIds),
+          sortBy: sortObj ? sortObj.sortBy : "",
+          sortOrder: sortObj ? sortObj.sortOrder : "",
+        },
+        {
+          headers: {
+            "X-NXproperties": "dublincore,file,dmsfolder,generaldocument",
+            "enrichers-document": "thumbnail,permissions",
+          },
+        }
+      )
+      .pipe(
+        mergeMap((data: any) =>
+          from(data.entries).pipe(
+            mergeMap(
+              // this updates related to clipboard feature
+              (item: any) => {
+                item["isFile"] = this.checkIfDocumentIsFile(item);
+                item["isSelected"] = false;
+                const permissionsCalls: Array<Promise<boolean>> =
+                  this.clipboardPermissionList.map((permission) => {
+                    return this.permissionEvaluatorService.evaluateRule(
+                      permission,
+                      { entity: item }
+                    );
+                  });
+                return combineLatest(permissionsCalls);
+              },
+              (original: any, detail) => {
+                this.clipboardPermissionList.forEach((value, index) => {
+                  original[value] = detail[index];
+                });
+              }
+            ),
+            toArray(),
+            map((entry) => [...data.entries])
+          )
+        ),
+        catchError((err) => {
+          throw err;
+        })
+      );
+  }
+
+  sortingTypes(types) {
+    if (this.isArabic) {
+      types = types.sort((item1, item2) => {
+        if (item1["arabicTitle"] > item2["arabicTitle"]) return 1;
+        if (item1["arabicTitle"] < item2["arabicTitle"]) return -1;
+        return 0;
+      });
+    } else {
+      types = types.sort((item1, item2) => {
+        if (item1["title"] > item2["title"]) return 1;
+        if (item1["title"] < item2["title"]) return -1;
+        return 0;
+      });
+    }
+    return types;
+  }
+
+  CreateLoanRequest(input, context, params = {}): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_LoanRequest_Create_Records", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .input(input)
+        .params(params)
+        .context(context)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  CreateTransferRequest(input, context, params = {}): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_TransferRequest_Create_Records", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .input(input)
+        .params(params)
+        .context(context)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  subscribe_OR_unSubscribeToItem(item, isUserSubscriberToFile) {
+    let ToDo = "";
+    let confirmDialogMessage = "";
+    let successMessage = "";
+    let failMessage = "";
+    let confirmButtonText = "";
+    if (isUserSubscriberToFile) {
+      ToDo = "unsubscribe";
+      successMessage = "unsubscribe_To_Item_success";
+      failMessage = "unsubscribe_To_Item_fail";
+      confirmButtonText = "unSubscribe";
+      confirmDialogMessage = "unsubscribeToDocument";
+    } else {
+      ToDo = "subscribe";
+      successMessage = "subscribe_To_Item_success";
+      failMessage = "subscribe_To_Item_fail";
+      confirmDialogMessage = "subscribeToDocument";
+      confirmButtonText = "subscribe";
+    }
+    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+      width: "510px",
+      data: {
+        title: this.translationService.instant("confirmDialog.confirm"),
+        message: this.translationService.instant(
+          `confirmDialog.${confirmDialogMessage}`
+        ),
+        confirmButton: `BUTTONS.${confirmButtonText}`,
+        cancelButton: "BUTTONS.Cancel",
+      },
+      disableClose: true,
+    });
+    return dialogRef.afterClosed().pipe(
+      switchMap((result) => {
+        if (result) {
+          return this.subscribeOrUnsubscribeUserToItem(item.uid, ToDo);
+        } else {
+          return of(false);
+        }
+      })
+    );
+    // const dialogRef = this.fuseConfirmationService.open(
+    //     {
+    //         dismissible: true,
+    //         title: this.translationService.instant("confirmDialog.confirm"),
+    //         message: this.translationService.instant(`confirmDialog.${confirmDialogMessage}`),
+    //         actions: {
+    //             confirm: {
+    //                 show: true,
+    //                 label: this.translationService.instant(`BUTTONS.${confirmButtonText}`),
+    //                 color: "warn"
+    //             },
+    //             cancel: {
+    //                 show: true,
+    //                 label: this.translationService.instant("BUTTONS.Cancel"),
+    //             }
+    //         }
+    //     }
+    // );
+  }
+
+  openFile(Data, fileId, dynaimcFormType?: "", searchString: string = "") {
+    this.recentlyViewedService.setIdsInLocalStorage(fileId);
+    if (Data) {
+      if (Data.includes("image")) {
+        //open image viewer
+        this.router.navigate(
+          [{ outlets: { viewer: ["view", "image", fileId] } }],
+          {
+            queryParams: {
+              location: this.router.url,
+              formType: dynaimcFormType,
+              searchString: searchString,
+            },
+          }
+        );
+      } else if (Data.includes("video")) {
+        this.router.navigate(
+          [{ outlets: { viewer: ["view", "video", fileId] } }],
+          {
+            queryParams: {
+              location: this.router.url,
+              formType: dynaimcFormType,
+              searchString: searchString,
+            },
+          }
+        );
+      } else {
+        this.router.navigate(
+          [{ outlets: { viewer: ["view", "file", fileId] } }],
+          {
+            queryParams: {
+              location: this.router.url,
+              formType: dynaimcFormType,
+              searchString: searchString,
+            },
+          }
+        );
+      }
+      this.registerAuditLog(fileId, "preview");
+    }
+  }
+
+  registerAuditLog(docId, eventType) {
+    this.nuxeoService.nuxeoClient
+      .operation("AC_AU_RegisterAuditLog")
+      .params({
+        event: eventType,
+      })
+      .input(docId)
+      .execute();
+  }
+
+  subscribeOrUnsubscribeUserToItem(itemId, ToDo) {
+    let api = "";
+    if (ToDo === "subscribe") {
+      api = "Document.Subscribe";
+    } else if (ToDo === "unsubscribe") {
+      api = "Document.Unsubscribe";
+    }
+    return from(
+      this.nuxeoService.nuxeoClient.operation(api).input(itemId).execute()
+    );
+  }
+
+  getUserAcceptedTypes(contentTypee?) {
+    if (
+      this.userPermittedTypes.length === 0 ||
+      this.userPermittedTypesTotalSize === -1 ||
+      this.userPermittedTypesTotalSize > this.userPermittedTypes.length ||
+      contentTypee
+    ) {
+      this.userPermittedTypes = [];
+      return new Observable<any[]>((op) => {
+        let offset = 0,
+          pageSize = 1000;
+
+        this.fetchUserPermittedTypesRecursively(
+          offset,
+          pageSize,
+          op,
+          contentTypee
+        );
+      });
+    } else {
+      return of(this.userPermittedTypes);
+    }
+  }
+  fetchUserPermittedTypesRecursively(
+    offset,
+    pageSize,
+    op: Subscriber<any[]>,
+    contentTypee?
+  ): void {
+    let data: any[] = [];
+    let singlEntry;
+    this.callApi
+      .query(
+        {
+          pageProvider: "PP_DocumentTypee",
+          offset: "" + offset,
+          pageSize: "" + pageSize,
+          documenttypee_contentTypee: contentTypee,
+        },
+        {
+          headers: { properties: "*" },
+        }
+      )
+      .pipe(
+        map((res) => {
+          this.userPermittedTypesTotalSize = res?.totalSize;
+          res?.entries.map((entry) => {
+            singlEntry = this.adapter.adaptIn(entry, this.fields);
+            singlEntry.properties["path"] = entry.path;
+            data.push(singlEntry.properties);
+            if (singlEntry.properties.contentTypee === "File") {
+              // construct aaray of document file type only to use it in document form builder page
+              this.userPermittedFilesOnly.push(singlEntry.properties);
+            }
+          });
+          this.userPermittedTypes.push(...data);
+
+          return this.userPermittedTypes;
+        })
+      )
+      .subscribe(
+        (result) => {
+          if (
+            this.userPermittedTypesTotalSize > this.userPermittedTypes.length
+          ) {
+            return this.fetchUserPermittedTypesRecursively(
+              this.userPermittedTypes.length,
+              pageSize,
+              op
+            );
+          } else {
+            // when finish fetching data start sorting it
+            this.userPermittedTypes = this.sortingTypes(
+              this.userPermittedTypes
+            );
+            this.userPermittedFilesOnly = this.sortingTypes(
+              this.userPermittedFilesOnly
+            );
+          }
+          return op.next(this.userPermittedTypes);
+        },
+        (error) => {
+          console.error(error);
+          return op.error(error);
+        }
+      );
+  }
+  refreshUserAcceptedTypes() {
+    this.userPermittedTypes = [];
+    this.getUserAcceptedTypes().subscribe((res) => {});
+  }
+
+  checkIfDocumentIsFile(document) {
+    if (
+      document.facets.length > 0 &&
+      document.facets.indexOf("Folderish") === -1
+    ) {
+      return "File";
+    } else {
+      return "Folder";
+    }
+  }
+
+  /*
+  Todo : 
+    we should take only payload (object) later
+    we should make aggregations configurable
+    getChildren + getChildrenForSharedDocumentRoot + refreshData 
+  */
+  getChildren(id, payload: PaginationPayload = null, loadFolders = true) {
+    if (!FileManagerPaginationConfig.Enable) payload = null;
+
+    let params = {
+      system_parentId: id,
+      system_isTrashed: false,
+      pageSize: payload ? FileManagerPaginationConfig.PageSize : 500,
+      currentPageIndex: payload?.currentPageIndex || 0,
+    };
+
+    const observable =
+      id == "root"
+        ? of(
+            this.mainFolderService.get_fileManagerObj_FromLocalStorage(
+              "fileManagerObj"
+            )
+          )
+        : id === "workSpaceRoot"
+        ? of(
+            this.mainFolderService.get_fileManagerObj_FromLocalStorage(
+              "workSpaceFileMangerObj"
+            )
+          )
+        : this.callApi.query(
+            {
+              pageProvider: this.pageProvider,
+              ...params,
+            },
+            {
+              headers: this.headers,
+            }
+          );
+
+    return forkJoin([
+      observable,
+      loadFolders ? this.getFolders(id) : of([]),
+    ]).pipe(
+      mergeMap(([response, folders]) => {
+        let paginationData: FileManagerPaginationData<any> | null = null;
+        if (payload) {
+          paginationData = this.#initPagination(response);
+          paginationData.data = folders;
+        }
+
+        return of(response).pipe(
+          map((data: any) =>
+            data.entries.map((item) => this.adapter.adaptIn(item, this.fields))
+          ),
+          map((entries: any) =>
+            entries.map((item) => this.fileManagerAdapter.adapt(item))
+          ),
+          tap((entries: any) =>
+            entries.forEach((item) => (item.isReady = true))
+          ),
+          mergeMap((entries: any) =>
+            from(entries).pipe(
+              mergeMap(
+                (item: any) => {
+                  const permissionsCalls: Array<Promise<boolean>> =
+                    this.permissionsList.map((permission) => {
+                      return this.permissionEvaluatorService.evaluateRule(
+                        permission,
+                        { entity: item.entity }
+                      );
+                    });
+                  return combineLatest(permissionsCalls);
+                },
+                (original: any, detail) => {
+                  this.permissionsList.forEach((value, index) => {
+                    original[value] = detail[index];
+                  });
+                }
+              ),
+              toArray(),
+              map(() => {
+                if (paginationData) {
+                  paginationData.data = [
+                    ...new Map(
+                      [...(paginationData.data || []), ...entries].map(
+                        (item) => [item.id, item]
+                      )
+                    ).values(),
+                  ];
+                  return paginationData;
+                } else {
+                  return [...entries];
+                }
+              })
+            )
+          ),
+          catchError((err) => {
+            throw err;
+          })
+        );
+      })
+    );
+  }
+
+  getChildrenForSharedDocumentRoot(
+    id,
+    payload: PaginationPayload = null,
+    loadFolders = true
+  ) {
+    if (!FileManagerPaginationConfig.Enable) payload = null;
+
+    let sortObj = {
+      sortBy: "dc:title",
+      sortOrder: "asc",
+      pageSize: payload ? FileManagerPaginationConfig.PageSize : 500,
+      currentPageIndex: payload?.currentPageIndex || 0,
+    };
+    const observable = from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_Document_GetSharesWithMe")
+        .params({
+          ...sortObj,
+        })
+        .execute({
+          headers: {
+            properties: "*",
+            "enrichers-document":
+              "breadcrumb, hasFolderishChild, favorites, thumbnail, collections",
+            "X-NXenrichers-document": "tags,permissions",
+            "fetch-document":
+              "lock,dc:creator, dc:lastContributor, sharedInfo:sharedList",
+          },
+        })
+    );
+
+    return forkJoin([
+      observable,
+      loadFolders ? this.getFolders(id) : of([]),
+    ]).pipe(
+      mergeMap((response: any) => {
+        const paginationData: FileManagerPaginationData<any> | null = payload
+          ? this.#initPagination(response)
+          : null;
+        return of(response).pipe(
+          map((data: any) => {
+            data.entries.map((item) => this.adapter.adaptIn(item, this.fields));
+            this.sharedFiles = data;
+            return data.entries;
+          }),
+          map((entries: any) =>
+            entries.map((item) => this.fileManagerAdapter.adapt(item))
+          ),
+          tap((entries: any) =>
+            entries.forEach((item) => (item.isReady = true))
+          ),
+          mergeMap((entries: any) =>
+            from(entries).pipe(
+              mergeMap(
+                (item: any) => {
+                  const permissionsCalls: Array<Promise<boolean>> =
+                    this.permissionsList.map((permission) => {
+                      return this.permissionEvaluatorService.evaluateRule(
+                        permission,
+                        { entity: item.entity }
+                      );
+                    });
+                  return combineLatest(permissionsCalls);
+                },
+                (original: any, detail) => {
+                  this.permissionsList.forEach((value, index) => {
+                    original[value] = detail[index];
+                  });
+                }
+              ),
+              toArray(),
+              map(() => {
+                if (paginationData) {
+                  paginationData.data = [
+                    ...new Map(
+                      [...(paginationData.data || []), ...entries].map(
+                        (item) => [item.id, item]
+                      )
+                    ).values(),
+                  ];
+                  return paginationData;
+                } else {
+                  return [...entries];
+                }
+              })
+            )
+          ),
+          catchError((err) => {
+            throw err;
+          })
+        );
+      })
+    );
+  }
+
+  refreshData(id, payload: PaginationPayload = null, loadFolders = true) {
+    if (!FileManagerPaginationConfig.Enable) payload = null;
+
+    let params = {
+      system_parentId: id,
+      system_isTrashed: false,
+      offset: 0,
+      pageSize: payload ? FileManagerPaginationConfig.PageSize : 500,
+      currentPageIndex: payload?.currentPageIndex || 0,
+    };
+
+    const customPageProvider = "PP_Document_Content_DB";
+    const observable =
+      id == "root"
+        ? this.mainFolderService.save_fileManagerObj_ToLocalStorage(
+            "AC_UA_GetFileManagerID"
+          )
+        : id == "workSpaceRoot"
+        ? this.mainFolderService.save_fileManagerObj_ToLocalStorage(
+            "AC_UA_GetDepartmentWorkspaces"
+          )
+        : this.callApi.query(
+            {
+              pageProvider: customPageProvider,
+              ...params,
+            },
+            {
+              headers: this.headers,
+            }
+          );
+
+    return forkJoin([
+      observable,
+      loadFolders ? this.getFolders(id, customPageProvider) : of([]),
+    ]).pipe(
+      mergeMap(([response, folders]) => {
+        let paginationData: FileManagerPaginationData<any> | null = null;
+        if (payload) {
+          paginationData = this.#initPagination(response);
+          paginationData.data = folders;
+        }
+
+        return of(response).pipe(
+          map((data: any) =>
+            data.entries.map((item) => this.adapter.adaptIn(item, this.fields))
+          ),
+          map((entries: any) =>
+            entries.map((item) => this.fileManagerAdapter.adapt(item))
+          ),
+          tap((entries: any) =>
+            entries.forEach((item) => (item.isReady = true))
+          ),
+          mergeMap((entries: any) =>
+            from(entries).pipe(
+              mergeMap(
+                (item: any) => {
+                  const permissionsCalls: Array<Promise<boolean>> =
+                    this.permissionsList.map((permission) => {
+                      return this.permissionEvaluatorService.evaluateRule(
+                        permission,
+                        { entity: item.entity }
+                      );
+                    });
+                  return combineLatest(permissionsCalls);
+                },
+                (original: any, detail) => {
+                  this.permissionsList.forEach((value, index) => {
+                    original[value] = detail[index];
+                  });
+                }
+              ),
+              toArray(),
+              map(() => {
+                if (paginationData) {
+                  paginationData.data = [
+                    ...new Map(
+                      [...(paginationData.data || []), ...entries].map(
+                        (item) => [item.id, item]
+                      )
+                    ).values(),
+                  ];
+                  return paginationData;
+                } else {
+                  return [...entries];
+                }
+              })
+            )
+          ),
+          catchError((err) => {
+            throw err;
+          })
+        );
+      })
+    );
+  }
+
+  getFolders(id, pageProvider: string = this.pageProvider) {
+    if (
+      !FileManagerPaginationConfig.Enable ||
+      ["root", "workSpaceRoot"].includes(id)
+    ) {
+      return of(null);
+    }
+
+    let params = {
+      system_parentId: id,
+      system_isTrashed: false,
+      pageSize: 10000,
+      currentPageIndex: 0,
+      AncestorDocument_superDocumentTypee: 0,
+    };
+
+    return this.callApi
+      .query(
+        {
+          pageProvider,
+          ...params,
+        },
+        {
+          headers: {
+            "enrichers-document": "hasFolderishChild",
+          },
+        }
+      )
+      .pipe(
+        mergeMap((response) => {
+          return of(response).pipe(
+            map((data: any) =>
+              data.entries.map((item) =>
+                this.adapter.adaptIn(item, this.fields)
+              )
+            ),
+            map((entries: any) =>
+              entries.map((item) => this.fileManagerAdapter.adapt(item))
+            ),
+            mergeMap((entries: any) =>
+              from(entries).pipe(
+                mergeMap(
+                  (item: any) => {
+                    const permissionsCalls: Array<Promise<boolean>> =
+                      this.permissionsList.map((permission) => {
+                        return this.permissionEvaluatorService.evaluateRule(
+                          permission,
+                          { entity: item.entity }
+                        );
+                      });
+                    return combineLatest(permissionsCalls);
+                  },
+                  (original: any, detail) => {
+                    this.permissionsList.forEach((value, index) => {
+                      original[value] = detail[index];
+                    });
+                  }
+                ),
+                toArray(),
+                map(() => {
+                  return [...entries];
+                })
+              )
+            ),
+            catchError((err) => {
+              throw err;
+            })
+          );
+        })
+      );
+  }
+
+  getMapedFolder(uid: string) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        .headers(this.headers)
+        .fetch(uid)
+    )
+      .pipe(
+        map((data: any) => {
+          return data;
+        }),
+        catchError((err) => {
+          throw err;
+        })
+      )
+      .pipe(
+        map((data: any) => this.adapter.adaptIn(data, this.fields)),
+        map((data: any) => this.fileManagerAdapter.adapt(data)),
+        tap((data: any) => (data.isReady = true)),
+        mergeMap((data: any) =>
+          Array.isArray(data)
+            ? from(data)
+            : of(data).pipe(
+                mergeMap((item: any) => {
+                  const permissionsCalls: Array<Observable<boolean>> =
+                    this.permissionsList.map((permission) => {
+                      return from(
+                        this.permissionEvaluatorService.evaluateRule(
+                          permission,
+                          { entity: item.entity }
+                        )
+                      );
+                    });
+                  return combineLatest(permissionsCalls).pipe(
+                    map((detail) => {
+                      const result = { ...item };
+                      this.permissionsList.forEach((value, index) => {
+                        result[value] = detail[index];
+                      });
+                      return result;
+                    })
+                  );
+                })
+              )
+        ),
+        catchError((err) => {
+          throw err;
+        })
+      );
+  }
+
+  createFolder(params, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.DynamicRegister", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          ...params,
+        })
+        .input(id)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  createDirectory(params, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.Create", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          type: "Folder",
+          name: params.title,
+          properties: this.adapter.adaptOut(params, this.fields),
+        })
+        .input(id)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  UpdateFolder(params, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.Update", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          ...params,
+        })
+        .input(id)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  deleteFolder(folderId) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.Trash", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .input(`docs:${folderId}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  addToCollection(id, collectionId): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.AddToCollection", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          collection: collectionId,
+        })
+        .input(`docs:${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  renameFolder(body, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_Document_Rename", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          name: body.title,
+        })
+        .input(id)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  createFile(payload, id, customApi?): Observable<any> {
+    let api = customApi ? customApi : "Document.DynamicRegister";
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(api, {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          ...payload.params,
+        })
+        .input(id)
+        .execute()
+    ).pipe(
+      catchError((error) =>
+        of({ status: "failed", originFile: payload.originFile })
+      )
+    );
+  }
+
+  createNewCollection(name): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Collection.Create", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          name: name,
+          description: "New Collection Test",
+        })
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  copyTo(destination, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.Copy", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          target: destination.id,
+          name: destination.name,
+        })
+        .input(`docs:${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  moveTo(destination, id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.Move", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          target: destination.id,
+        })
+        .input(`docs:${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getCollectionSuggestion(term): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Collection.Suggestion", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          currentPageIndex: "0",
+          pageSize: "10",
+          searchTerm: term,
+        })
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getCollectionFromPP(searchTerm) {
+    return this.callApi.query(
+      {
+        pageProvider: "PP_DMS_User_Collections",
+        queryParams: `%${searchTerm}%`,
+        sortBy: "dc:modified",
+        sortOrder: "desc",
+        currentPageIndex: 0,
+        offset: 0,
+        pageSize: 40,
+      },
+      {
+        headers: {
+          "X-NXproperties": "*",
+        },
+      }
+    );
+  }
+
+  setSync(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("NuxeoDrive.SetSynchronization", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({ enable: true })
+        .input(`${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  unSetSync(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("NuxeoDrive.SetSynchronization", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({ enable: false })
+        .input(`${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  addToFavorites(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.AddToFavorites", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({})
+        .input(`docs:${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  defineNewPerson(title, titleEn, ids: any) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.DefineNewPerson", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({
+          title_ar: title,
+          title_en: titleEn,
+        })
+        .input(`docs:${ids}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  addToQuickAccess(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_Collection_AddDocumentToQuickAccess", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({})
+        .input(`${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  removeFromQuickAccess(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("AC_UA_Collection_RemoveDocumentFromQuickAccess", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({})
+        .input(`${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  removeFromFavorites(id): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation("Document.RemoveFromFavorites", {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({})
+        .input(`docs:${id}`)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getFolder(uid) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        .headers({
+          properties: "*",
+          "enrichers-document": "hasFolderishChild, favorites, breadcrumb",
+          "X-NXenrichers-document": "permissions",
+        })
+        .fetch(uid)
+    ).pipe(
+      map((data: any) => {
+        return data;
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getLogs(id, pageIndex = 0, pageSize = 5) {
+    const path = "id/" + id + "/@audit";
+    return from(
+      this.nuxeoService.nuxeoClient
+        .request(path)
+        .queryParams({
+          currentPageIndex: pageIndex,
+          pageSize: pageSize,
+        })
+        .get({
+          headers: {
+            properties: "*",
+          },
+        })
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getFileSchemas(type) {
+    return from(
+      this.nuxeoService.nuxeoClient.request(`config/types/${type}`).get({
+        headers: {
+          "fetch.schema": "fields",
+        },
+      })
+    ).pipe(
+      map((data: any) => {
+        if (data.schemas) {
+          return data.schemas;
+        } else {
+          return [];
+        }
+      })
+    );
+  }
+
+  downloadAsZip(selectedItems, fileTitle) {
+    let location: any = "";
+    this.toaster.show(
+      "notification",
+      "TOASTER.SUCCESS",
+      "TOASTER.preparingDownloadAsZip",
+      {
+        timeOut: 2500,
+      }
+    );
+    let title = fileTitle ? fileTitle : `selection-${Date.now()}`;
+    title =
+      title.indexOf(".") > -1 ? title.substring(0, title.indexOf(".")) : title;
+    const endpoint = `${this.environment.nuxeo}/api/v1/automation/Blob.BulkDownload/@async`;
+    return this.http
+      .post<any>(
+        endpoint,
+        {
+          params: {
+            filename: "selection.zip",
+          },
+          input: `docs:${selectedItems}`,
+        },
+        {
+          observe: "response",
+        }
+      )
+      .pipe(
+        switchMap((res) => {
+          location = res.headers.get("location");
+          return this.http.get(location, {
+            responseType: "blob",
+          });
+        })
+      )
+      .pipe(
+        expand((res) =>
+          res.type === "application/json"
+            ? this.http
+                .get(location, {
+                  responseType: "blob",
+                })
+                .pipe(delay(5000))
+            : EMPTY
+        )
+      )
+      .subscribe((res) => {
+        if (res.type === "application/zip") {
+          this.toaster.show(
+            "notification",
+            "TOASTER.SUCCESS",
+            "TOASTER.DownloadAsZip",
+            {
+              timeOut: 1000,
+            }
+          );
+          let binaryData: any[] = [];
+          binaryData.push(res);
+          let blob = new Blob(binaryData, { type: res.type });
+          saveAs(blob, `${title}.zip`);
+        }
+      });
+  }
+
+  // getTreeNodeChildren = (parent) => {
+  //   let params = {
+  //     queryParams: parent ? parent : '',
+  //     pageSize: 50,
+  //   };
+  //   // don't refresh all table in case of sorting only
+  //   return this.callApi.query(
+  //     {
+  //       pageProvider: 'tree_children',
+  //       ...params,
+  //     },
+  //     {
+  //       headers: {
+  //         properties: '*',
+  //         'enrichers-document': 'hasFolderishChild',
+  //         'X-NXenrichers-document': 'permissions',
+  //       },
+  //     }
+  //   )
+
+  // };
+
+  parseNodeChildren = (observable, pageConfigurations, parent = true) => {
+    return observable
+      .pipe(
+        map((data: any) =>
+          data.entries.map((item) => this.adapter.adaptIn(item, this.fields))
+        ),
+        map((entries: any) =>
+          entries.map((item) =>
+            this.fileManagerAdapter.treeViewAdapt(
+              item,
+              parent,
+              pageConfigurations
+            )
+          )
+        ),
+        mergeMap((entries: any) =>
+          from(entries).pipe(
+            mergeMap(
+              (item: any) => {
+                const permissionsCalls: Array<Promise<boolean>> =
+                  this.permissionsList.map((permission) => {
+                    return this.permissionEvaluatorService.evaluateRule(
+                      permission,
+                      { entity: item.entity }
+                    );
+                  });
+                return combineLatest(permissionsCalls);
+              },
+              (original: any, detail) => {
+                this.permissionsList.forEach((value, index) => {
+                  original[value] = detail[index];
+                });
+              }
+            ),
+            toArray(),
+            map((entry) => [...entries])
+          )
+        ),
+        catchError((err) => {
+          throw err;
+        }),
+        first()
+      )
+      .toPromise();
+  };
+
+  createTreeNodeChildren(parent) {
+    let params = {
+      queryParams: parent,
+      pageSize: 50,
+    };
+    // don't refresh all table in case of sorting only
+    return this.callApi
+      .query(
+        {
+          pageProvider: "tree_children",
+          ...params,
+        },
+        {
+          headers: {
+            properties: "*",
+            "enrichers-document": "hasFolderishChild",
+            "X-NXenrichers-document": "permissions",
+          },
+        }
+      )
+      .pipe(
+        map((data: any) =>
+          data.entries.map((item) => this.adapter.adaptIn(item, this.fields))
+        ),
+        map((entries: any) =>
+          entries.map((item) => this.fileManagerAdapter.treeViewAdapt(item))
+        ),
+        mergeMap((entries: any) =>
+          from(entries).pipe(
+            mergeMap(
+              (item: any) => {
+                const permissionsCalls: Array<Promise<boolean>> =
+                  this.permissionsList.map((permission) => {
+                    return this.permissionEvaluatorService.evaluateRule(
+                      permission,
+                      { entity: item.entity }
+                    );
+                  });
+                return combineLatest(permissionsCalls);
+              },
+              (original: any, detail) => {
+                this.permissionsList.forEach((value, index) => {
+                  original[value] = detail[index];
+                });
+              }
+            ),
+            toArray(),
+            map((entry) => [...entries])
+          )
+        ),
+        catchError((err) => {
+          throw err;
+        }),
+        first()
+      )
+      .toPromise();
+  }
+
+  #initPagination(response: any): FileManagerPaginationData<any> {
+    const buckets =
+      response.aggregations?.AncestorDocument_superDocumentTypee_agg?.buckets;
+    return {
+      isPaginable: response.isPaginable,
+      resultsCount: response.resultsCount,
+      pageSize: response.pageSize,
+      maxPageSize: response.maxPageSize,
+      resultsCountLimit: response.resultsCountLimit,
+      currentPageSize: response.currentPageSize,
+      currentPageIndex: response.currentPageIndex,
+      currentPageOffset: response.currentPageOffset,
+      numberOfPages: response.numberOfPages,
+      isPreviousPageAvailable: response.isPreviousPageAvailable,
+      isNextPageAvailable: response.isNextPageAvailable,
+      isLastPageAvailable: response.isLastPageAvailable,
+      isSortable: response.isSortable,
+      hasError: response.hasError,
+      errorMessage: response.errorMessage,
+      totalSize: response.totalSize,
+      pageIndex: response.pageIndex,
+      pageCount: response.pageCount,
+      foldersCount:
+        buckets?.find((q) => q.key == FolderishType.Folder)?.docCount || 0,
+      filesCount:
+        buckets?.find((q) => q.key == FolderishType.File)?.docCount || 0,
+      data: [],
+    };
+  }
+}