nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/shared-services/global-admin.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { GlobalAdminService } from './global-admin.service';
+
+describe('GlobalAdminService', () => {
+  let service: GlobalAdminService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(GlobalAdminService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/shared-services/global-admin.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { EvaluatorsService } from '../directive/permissions/evaluators.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GlobalAdminService {
+  isGlobalAdmin = false;
+  activeTenant = null;
+  constructor(private evaluatorService : EvaluatorsService) { }
+
+  checkIfGlobalAdmin(){
+   return this.evaluatorService.evaluateRule('isGlobalAdmin')
+  }
+}

package/src/lib/shared-services/global-pdftron.service.ts

@@ -0,0 +1,51 @@
+import { Injectable,Inject } from '@angular/core';
+import { APP_BASE_HREF } from '@angular/common';
+import WebViewer, { CoreControls } from '@pdftron/webviewer';
+
+@Injectable({ providedIn: 'root' })
+export class GlobalPdfTron {
+    instance;
+    saveOptions;
+    constructor(@Inject(APP_BASE_HREF) private baseHref: string) {
+        this.init();
+    }
+
+
+    exportLinearizedPDF(file) {
+        return new Promise((resolve, reject) => {
+            this.instance.loadDocument(
+                file
+            );
+            this.instance.docViewer.on('documentLoaded', async () => {
+                const doc = this.instance.docViewer.getDocument();
+                const data = await doc.getFileData({
+                    flags: this.saveOptions.LINEARIZED,
+                    downloadType: 'pdf'
+                });
+                const arr = new Uint8Array(data);
+                const blob = new Blob([arr], { type: 'application/pdf' })
+                const newFile = new File([blob], file.name, { type: 'application/pdf' })
+                resolve(newFile);
+            });
+        });
+
+
+    }
+    init() {
+        if (!document.getElementById('global-pdftron')) {
+            const div = document.createElement('div');
+            div.style.display = 'none';
+            div.id = 'global-pdftron';
+            document.body.appendChild(div);
+        }
+        WebViewer(
+            {
+                path: this.baseHref + '/assets/pdftrons',
+            },
+            document.getElementById('global-pdftron'),
+        ).then((instance) => {
+            this.saveOptions = instance.CoreControls.SaveOptions;
+            this.instance = instance;
+        });
+    }
+}

package/src/lib/shared-services/mainfolder.service.ts

@@ -0,0 +1,227 @@
+import { Injectable } from '@angular/core';
+import { from, Observable, of } from 'rxjs';
+import { catchError, switchMap, take, tap } from 'rxjs/operators';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { UserPreferencesService } from '../core/services/user/user-preferences.service';
+import { AppConfigService } from '../configuration/app-config.service';
+
+@Injectable({
+    providedIn: 'root',
+})
+
+export class MainfolderService {
+    fileManager_mainFolderId;
+    category_mainFolderId;
+    fileManagerObj: any;
+    myFilesManagerObj: any;
+    ArchiveManagerObj: any;
+    categoryObj: any;
+    localStoragKeys;
+    constructor(
+        private nuxeoService: NuxeoService,
+        private appConfigService : AppConfigService,
+        private userPreference: UserPreferencesService
+    ) { 
+        this.appConfigService.configLoaded.pipe(take(1)).subscribe(res => {
+            this.localStoragKeys = this.appConfigService.myConfiguration.localStorageKey
+        });
+    }
+
+    fetchfileManager_mainFolderId(apiName? , failIfEmptyRes = true): Observable<any> {
+        return from(
+            this.nuxeoService.nuxeoClient
+                .operation(apiName ? apiName : 'AC_UA_GetFileManagerID')
+                .execute({
+                    headers: {
+                        properties: 'file, dublincore, creator, driveroot, departmentspace',
+                        'fetch-document': 'dc:creator, dc:lastContributor',
+                        'enrichers-document':
+                            'hasFolderishChild, favorites, thumbnail, quickAccess,breadcrumb',
+                        'X-NXenrichers-document': 'tags,permissions',
+                    },
+                })
+        ).pipe(
+            tap((res: any) => {
+                // fail if res,entries was empty and we are making this check since there is cases we need to return empty response and not failsing like files in dgda
+                if(failIfEmptyRes){
+                    if (!res?.entries?.length) {
+                        throw Error('Main Folder - empty response');
+                    }
+                }
+            }),
+            catchError((err) => {
+                console.error(err);
+                return of(false);
+            })
+        );
+    }
+
+    fetchMyFilesManager_mainFolderId(): Observable<any> {
+        return from(
+            this.nuxeoService.nuxeoClient
+                .operation('AC_UA_PersonalSpace_GetOrCreate')
+                .execute()
+        ).pipe(
+            tap((res: any) => {
+                console.log('res', res);
+            }),
+            catchError((err) => {
+                console.error(err);
+                return of(false);
+            })
+        );
+    }
+    fetchArchiveManager_mainFolderId(): Observable<any> {
+        return from(
+            this.nuxeoService.nuxeoClient
+                .operation('AC_UA_GetSpaceID')
+                .execute()
+        ).pipe(
+            tap((res: any) => {
+                console.log('res', res);
+            }),
+            catchError((err) => {
+                console.error(err);
+                return of(false);
+            })
+        );
+    }
+
+    fetchcategory_mainFolderId(api: string): Observable<any> {
+        return from(
+            this.nuxeoService.nuxeoClient
+                .operation(api)
+                .execute()
+        ).pipe(
+            tap((res: any) => {
+                // if (!res?.entries?.length) {
+                //     throw Error('Category Folder - empty response');
+                // }
+            }),
+            catchError((err) => {
+                console.error(err);
+                return of(false);
+            })
+        );
+    }
+
+    save_fileManagerObj_ToLocalStorage(apiName = 'AC_UA_GetFileManagerID' , failIfEmptyRes = true): Observable<any> {
+        /*return this.userPreference.hasItem('fileManagerObj') && !reset
+             ? of(true):*/
+        return this.fetchfileManager_mainFolderId(apiName , failIfEmptyRes).pipe(
+            tap((res) => {
+                console.log('res: ', res);
+                if (res) {
+                    if(res.entries){
+                        this.fileManagerObj = {
+                            entries: res.entries.map((item) => {
+                                delete item._baseOptions;
+                                delete item._dirtyProperties;
+                                delete item._nuxeo;
+                                delete item._repository;
+                                return item;
+                            }),
+                        };
+                    }else{
+                        this.fileManagerObj = {}
+                    }
+
+                    this.userPreference.set(
+                        apiName ? this.localStoragKeys[apiName] : 'fileManagerObj',
+                        JSON.stringify(this.fileManagerObj)
+                    );
+                }
+            }),
+            switchMap(value => of(this.get_fileManagerObj_FromLocalStorage(apiName ? this.localStoragKeys[apiName] : 'fileManagerObj')))
+        );
+    }
+
+    save_myfilesManagerObj_ToLocalStorage(): Observable<any> {
+        return this.userPreference.hasItem('myFilesManagerObj')
+            ? of(true)
+            : this.fetchMyFilesManager_mainFolderId().pipe(
+                tap((res) => {
+                    console.log('res: ' + res);
+                    if (res) {
+                        this.myFilesManagerObj = {
+                            id: res.uid,
+                            path: res.path,
+                        };
+
+                        this.userPreference.set(
+                            'myFilesManagerObj',
+                            JSON.stringify(this.myFilesManagerObj)
+                        );
+                    }
+                })
+            );
+    }
+
+    save_ArchiveManagerObject_ToLocalStorage(): Observable<any> {
+        return this.userPreference.hasItem('ArchiveManagerObj')
+            ? of(true)
+            : this.fetchArchiveManager_mainFolderId().pipe(
+                tap((res) => {
+                    console.log('res: ' + res);
+                    if (res) {
+                        this.ArchiveManagerObj = {
+                            id: res.uid,
+                            path: res.path,
+                        };
+
+                        this.userPreference.set(
+                            'ArchiveManagerObj',
+                            JSON.stringify(this.ArchiveManagerObj)
+                        );
+                    }
+                })
+            );
+    }
+
+    save_categoryObj_ToLocalStorage(key = 'categoryObj', api = 'AC_UA_GetNCARCategoryID'): Observable<any> {
+        return this.userPreference.hasItem(key)
+            ? of(true)
+            : this.fetchcategory_mainFolderId(api).pipe(
+                tap((res) => {
+                    if (res) {
+                        this.categoryObj = {
+                            id: res.uid,
+                            path: res.path,
+                        };
+
+                        this.userPreference.set(
+                            key,
+                            JSON.stringify(this.categoryObj)
+                        );
+                    }
+                })
+            );
+    }
+
+    get_fileManagerObj_FromLocalStorage(key?) {
+        if (this.userPreference.hasItem( key ? key : 'fileManagerObj')) {
+            return JSON.parse(this.userPreference.get(key ? key : 'fileManagerObj'));
+        }
+        return null;
+    }
+
+    get_myFilesManagerObj_FromLocalStorage() {
+        if (this.userPreference.hasItem('myFilesManagerObj')) {
+            return JSON.parse(this.userPreference.get('myFilesManagerObj'));
+        }
+        return null;
+    }
+    get_ArchiveManagerObj_FromLocalStorage() {
+        if (this.userPreference.hasItem('ArchiveManagerObj')) {
+            return JSON.parse(this.userPreference.get('ArchiveManagerObj'));
+        }
+        return null;
+    }
+
+    get_categoryObj_FromLocalStorage(key = 'categoryObj') {
+        if (this.userPreference.hasItem(key)) {
+            return JSON.parse(this.userPreference.get(key));
+        }
+        return null;
+    }
+}

package/src/lib/shared-services/publishing-document.service.ts

@@ -0,0 +1,242 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, from, Observable } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { CallApiService } from '../core/services/callApi/call-api.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PublishingDocumentService {
+
+
+  newPublished = new BehaviorSubject<boolean>(false);
+  constructor(private nuxeoService: NuxeoService,
+    @Inject('environment') private environment,
+    private callApiService: CallApiService) {
+
+  }
+
+  getSectionById(docIds): Observable<any> {
+    return this.callApiService.query(
+      {
+        pageProvider: 'Documents_InList_PP',
+        pageSize: 1000,
+        system_uuid: JSON.stringify(docIds),
+      },
+      {
+        headers: {
+          "X-NXproperties": "*",
+        }
+      }
+    );
+  }
+  getSectionByTitle(titles): Observable<any> {
+    return this.callApiService.query(
+      {
+        pageProvider: 'Documents_InList_PP',
+        pageSize: 1000,
+        system_primaryType: "OSDepartment",
+        dublincore_title: JSON.stringify(titles),
+      },
+      {
+        headers: {
+          "X-NXproperties": "*",
+        }
+      }
+    );
+  }
+
+  getPublishingSections(pageNumber?, pageSize?, sortObj?) {
+    return from(this.nuxeoService.nuxeoClient
+      .operation('Repository.PageProvider', {
+        url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+      })
+      .params({
+        "documentSchemas": ["*"],
+        page: pageNumber ? pageNumber : 0,
+        currentPageIndex: pageNumber ? pageNumber : 0,
+        offset: 0,
+        pageSize: pageSize ? pageSize : 0,
+        sortBy: sortObj?.sortBy,
+        sortOrder: sortObj?.sortOrder,
+        "pageProviderName": "publish_space_suggestion",
+        "providerName": "publish_space_suggestion",
+        "repository": "default",
+        "searchTerm": "",
+      })
+      .context()
+      .execute({
+        headers: {
+          'X-NXproperties': '*',
+          'enrichers-document': 'acls',
+          "fetch-document": "dc:creator"
+        },
+      })
+    ).pipe(
+      catchError((err) => {
+        console.log(err);
+        throw err;
+      }))
+  }
+
+  unPublishDocument(docId) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('Document.Delete', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .input(docId)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  publishDocument(docId, params) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('AC_UA_Puplish_Documents', {
+          url: `${this.environment.nuxeo}/api/v1/custom-automation`,
+        })
+        .params()
+        .input(docId)
+        .context({
+          ...params
+        })
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  getPublishedPlaces(uid) {
+    return this.callApiService.query(
+      {
+        pageProvider: 'nxql_search',
+        currentPageIndex: 0,
+        pageSize: 40,
+        offset: 0,
+        queryParams: `SELECT * FROM Document WHERE ecm:isProxy = 1 AND ecm:isTrashed = 0 AND (rend:sourceVersionableId = "${uid}" OR ecm:proxyVersionableId = "${uid}")`,
+        sortBy: 'dc:modified,uid:major_version,uid:minor_version',
+        sortOrder: 'desc,desc,desc'
+      },
+      {
+        headers: {
+          'enrichers-document': 'breadcrumb',
+          properties: "dublincore,common,uid,rendition,file"
+        }
+      }
+    );
+  }
+
+  getVersionToPublishDialog(uid) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .request(`search/execute`)
+        .queryParams({
+          currentPageIndex: 0,
+          pageSize: 100,
+          offset: 0,
+          query: `SELECT * FROM Document WHERE ecm:versionVersionableId = "${uid}" AND ecm:isVersion = 1`,
+          sortBy: 'uid:major_version,uid:minor_version',
+          sortOrder: 'desc,desc'
+        })
+        .get({
+          headers: {
+            properties: '*'
+          }
+        })
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  /*getProxyDocument(docId) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('Proxy.GetSourceDocument', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .input(docId)
+        .execute({
+          headers: {
+            properties: '*'
+          }
+        })
+    ).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }*/
+  buildVersionNum(element) {
+    return parseFloat(`${element.properties['uid:major_version']}.${element.properties['uid:minor_version']}`)
+  }
+  createPublishDepartmentSection(section) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('AC_UA_Section_Create', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .context({ section })
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        //console.log(err);
+        throw err;
+      })
+    );
+  }
+  Add_Permission_PublishDepartmentSection(sectionName, depList, uid) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('AC_UA_Section_Add_Permission', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .context({
+          "permission": "Read",
+          "usersAndGroups": sectionName,
+          "departmentList": depList
+
+        })
+        .input(uid)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        //console.log(err);
+        throw err;
+      })
+    );
+  }
+  updatePublishDepartmentSection(section, uid) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('AC_UA_Section_Update', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .context({ section })
+        .input(uid)
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        //console.log(err);
+        throw err;
+      })
+    );
+  }
+  deleteSection(uid) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('AC_UA_Section_Delete')
+        .input(uid)
+        .execute()
+    );
+  }
+}

package/src/lib/shared-services/recently-viewed.service.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { UserPreferencesService } from '../core/services/user/user-preferences.service';
+import { CallApiService } from '../core/services/callApi/call-api.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RecentlyViewedService {
+  itemAdded = new EventEmitter();
+  recentViewedDocsIds=[];
+  constructor(private userPreference: UserPreferencesService,
+    private callApiService: CallApiService) {
+    this.getIdsFromLocalStorage();
+   }
+  
+
+  getIdsFromLocalStorage() {
+    this.recentViewedDocsIds =JSON.parse(this.userPreference.get('recentlyViewedDocsIds')  || '[]');
+    return this.recentViewedDocsIds;
+  }
+
+  setIdsInLocalStorage(Id: string) {
+    if (this.recentViewedDocsIds.length > 14 && !this.recentViewedDocsIds.includes(Id)) {
+      this.recentViewedDocsIds.pop();
+    } else if (this.recentViewedDocsIds.includes(Id)) {
+      this.recentViewedDocsIds.forEach((element, index) => {
+        if (element == Id) this.recentViewedDocsIds.splice(index, 1);
+      });
+    }
+    this.recentViewedDocsIds.unshift(Id);
+    this.userPreference.set("recentlyViewedDocsIds", JSON.stringify(this.recentViewedDocsIds));
+    this.itemAdded.emit();
+  }
+  getRecentlyViewedDocs(docIds,sortObj?:any): Observable<any> {
+    return this.callApiService.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": "*",
+          "enrichers-document": "thumbnail",
+          "fetch-document": "dc:lastContributor"
+        }
+      }
+    );
+  }
+}