nuxeo-development-framework 3.1.1 → 3.1.2

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

@@ -0,0 +1,1073 @@
+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, 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';
+
+@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'];
+  userPermittedTypes: any[] = [];
+  userPermittedTypesTotalSize = -1;
+  userPermittedFilesOnly: any[] = [];
+  sharedFiles;
+  isArabic = false;
+  langSubscription: Subscription;
+  clipboardPermissionList = ['canCopy', 'canMove'];
+  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;
+
+  }
+
+  // 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'
+    }
+  }
+
+  getChildren(id) {
+    let params = {
+      system_parentId: id,
+      system_isTrashed: false,
+      pageSize: 500
+    };
+    return (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,
+        }
+      ))
+      .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(entry => ([...entries])))),
+        // tap(ent => console.log(ent)),
+        catchError((err) => {
+          throw err;
+        })
+      )
+  }
+
+  getChildrenForSharedDocumentRoot(id) {
+    let sortObj = {
+      "sortBy": "dc:title",
+      "sortOrder": "asc",
+      "pageSize": 500
+    };
+    return 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"
+          },
+        })
+    )
+      .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))),
+        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])))),
+        // tap(ent => console.log(ent)),
+        catchError((err) => {
+          throw err;
+        })
+      )
+  }
+
+  refreshData(id) {
+    let params = {
+      system_parentId: id,
+      system_isTrashed: false,
+      offset: 0,
+      currentPageIndex: 0,
+      pageSize: 500,
+    };
+    return (id == 'root' ? this.mainFolderService.save_fileManagerObj_ToLocalStorage('AC_UA_GetFileManagerID') : 
+    id == 'workSpaceRoot' ? this.mainFolderService.save_fileManagerObj_ToLocalStorage('AC_UA_GetDepartmentWorkspaces') : this.callApi
+      .query(
+        {
+          pageProvider: 'PP_Document_Content_DB',
+          ...params,
+        },
+        {
+          headers: this.headers,
+        }
+      ))
+      .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(entry => ([...entries])))),
+        // tap(ent => console.log(ent)),
+        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): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('Document.DynamicRegister', {
+          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();
+  }
+}