nuxeo-development-framework 3.1.6 → 3.1.8

package/esm2015/lib/shared-services/global-pdftron.service.js

@@ -0,0 +1,46 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import WebViewer from '@pdftron/webviewer';
+import * as i0 from "@angular/core";
+export class GlobalPdfTron {
+    constructor() {
+        this.init();
+    }
+    exportLinearizedPDF(file) {
+        return new Promise((resolve, reject) => {
+            this.instance.loadDocument(file);
+            this.instance.docViewer.on('documentLoaded', () => __awaiter(this, void 0, void 0, function* () {
+                const doc = this.instance.docViewer.getDocument();
+                const data = yield 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: '/dms/assets/pdftrons',
+        }, document.getElementById('global-pdftron')).then((instance) => {
+            this.saveOptions = instance.CoreControls.SaveOptions;
+            this.instance = instance;
+        });
+    }
+}
+GlobalPdfTron.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: GlobalPdfTron, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GlobalPdfTron.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: GlobalPdfTron, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: GlobalPdfTron, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared-services/mainfolder.service.js

@@ -0,0 +1,162 @@
+import { Injectable } from '@angular/core';
+import { from, of } from 'rxjs';
+import { catchError, switchMap, take, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../Core/services/nuxeo/nuxeo.service";
+import * as i2 from "../configuration/app-config.service";
+import * as i3 from "../Core/services/user/user-preferences.service";
+export class MainfolderService {
+    constructor(nuxeoService, appConfigService, userPreference) {
+        this.nuxeoService = nuxeoService;
+        this.appConfigService = appConfigService;
+        this.userPreference = userPreference;
+        this.appConfigService.configLoaded.pipe(take(1)).subscribe(res => {
+            this.localStoragKeys = this.appConfigService.myConfiguration.localStorageKey;
+        });
+    }
+    fetchfileManager_mainFolderId(apiName) {
+        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) => {
+            var _a;
+            if (!((_a = res === null || res === void 0 ? void 0 : res.entries) === null || _a === void 0 ? void 0 : _a.length)) {
+                throw Error('Main Folder - empty response');
+            }
+        }), catchError((err) => {
+            console.error(err);
+            return of(false);
+        }));
+    }
+    fetchMyFilesManager_mainFolderId() {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_PersonalSpace_GetOrCreate')
+            .execute()).pipe(tap((res) => {
+            console.log('res', res);
+        }), catchError((err) => {
+            console.error(err);
+            return of(false);
+        }));
+    }
+    fetchArchiveManager_mainFolderId() {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_GetSpaceID')
+            .execute()).pipe(tap((res) => {
+            console.log('res', res);
+        }), catchError((err) => {
+            console.error(err);
+            return of(false);
+        }));
+    }
+    fetchcategory_mainFolderId() {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_GetNCARCategoryID')
+            .execute()).pipe(tap((res) => {
+            // 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') {
+        /*return this.userPreference.hasItem('fileManagerObj') && !reset
+             ? of(true):*/
+        return this.fetchfileManager_mainFolderId(apiName).pipe(tap((res) => {
+            console.log('res: ', res);
+            if (res) {
+                this.fileManagerObj = {
+                    entries: res.entries.map((item) => {
+                        delete item._baseOptions;
+                        delete item._dirtyProperties;
+                        delete item._nuxeo;
+                        delete item._repository;
+                        return item;
+                    }),
+                };
+                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() {
+        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() {
+        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() {
+        return this.userPreference.hasItem('categoryObj')
+            ? of(true)
+            : this.fetchcategory_mainFolderId().pipe(tap((res) => {
+                if (res) {
+                    this.categoryObj = {
+                        id: res.uid,
+                        path: res.path,
+                    };
+                    this.userPreference.set('categoryObj', 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() {
+        if (this.userPreference.hasItem('categoryObj')) {
+            return JSON.parse(this.userPreference.get('categoryObj'));
+        }
+        return null;
+    }
+}
+MainfolderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: MainfolderService, deps: [{ token: i1.NuxeoService }, { token: i2.AppConfigService }, { token: i3.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable });
+MainfolderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: MainfolderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: MainfolderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: i2.AppConfigService }, { type: i3.UserPreferencesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mainfolder.service.js","sourceRoot":"","sources":["../../../../../projects/nuxeo-development-framework/src/lib/shared-services/mainfolder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { from, Observable, of } from 'rxjs';\r\nimport { catchError, switchMap, take, tap } from 'rxjs/operators';\r\nimport { NuxeoService } from '../Core/services/nuxeo/nuxeo.service';\r\nimport { UserPreferencesService } from '../Core/services/user/user-preferences.service';\r\nimport { AppConfigService } from '../configuration/app-config.service';\r\n\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\n\r\nexport class MainfolderService {\r\n    fileManager_mainFolderId;\r\n    category_mainFolderId;\r\n    fileManagerObj: any;\r\n    myFilesManagerObj: any;\r\n    ArchiveManagerObj: any;\r\n    categoryObj: any;\r\n    localStoragKeys;\r\n    constructor(\r\n        private nuxeoService: NuxeoService,\r\n        private appConfigService : AppConfigService,\r\n        private userPreference: UserPreferencesService\r\n    ) { \r\n        this.appConfigService.configLoaded.pipe(take(1)).subscribe(res => {\r\n            this.localStoragKeys = this.appConfigService.myConfiguration.localStorageKey\r\n        });\r\n    }\r\n\r\n    fetchfileManager_mainFolderId(apiName?): Observable<any> {\r\n        return from(\r\n            this.nuxeoService.nuxeoClient\r\n                .operation(apiName ? apiName : 'AC_UA_GetFileManagerID')\r\n                .execute({\r\n                    headers: {\r\n                        properties: 'file, dublincore, creator, driveroot, departmentspace',\r\n                        'fetch-document': 'dc:creator, dc:lastContributor',\r\n                        'enrichers-document':\r\n                            'hasFolderishChild, favorites, thumbnail, quickAccess,breadcrumb',\r\n                        'X-NXenrichers-document': 'tags,permissions',\r\n                    },\r\n                })\r\n        ).pipe(\r\n            tap((res: any) => {\r\n                if (!res?.entries?.length) {\r\n                    throw Error('Main Folder - empty response');\r\n                }\r\n            }),\r\n            catchError((err) => {\r\n                console.error(err);\r\n                return of(false);\r\n            })\r\n        );\r\n    }\r\n\r\n    fetchMyFilesManager_mainFolderId(): Observable<any> {\r\n        return from(\r\n            this.nuxeoService.nuxeoClient\r\n                .operation('AC_UA_PersonalSpace_GetOrCreate')\r\n                .execute()\r\n        ).pipe(\r\n            tap((res: any) => {\r\n                console.log('res', res);\r\n            }),\r\n            catchError((err) => {\r\n                console.error(err);\r\n                return of(false);\r\n            })\r\n        );\r\n    }\r\n    fetchArchiveManager_mainFolderId(): Observable<any> {\r\n        return from(\r\n            this.nuxeoService.nuxeoClient\r\n                .operation('AC_UA_GetSpaceID')\r\n                .execute()\r\n        ).pipe(\r\n            tap((res: any) => {\r\n                console.log('res', res);\r\n            }),\r\n            catchError((err) => {\r\n                console.error(err);\r\n                return of(false);\r\n            })\r\n        );\r\n    }\r\n\r\n    fetchcategory_mainFolderId(): Observable<any> {\r\n        return from(\r\n            this.nuxeoService.nuxeoClient\r\n                .operation('AC_UA_GetNCARCategoryID')\r\n                .execute()\r\n        ).pipe(\r\n            tap((res: any) => {\r\n                // if (!res?.entries?.length) {\r\n                //     throw Error('Category Folder - empty response');\r\n                // }\r\n            }),\r\n            catchError((err) => {\r\n                console.error(err);\r\n                return of(false);\r\n            })\r\n        );\r\n    }\r\n\r\n    save_fileManagerObj_ToLocalStorage(apiName = 'AC_UA_GetFileManagerID'): Observable<any> {\r\n        /*return this.userPreference.hasItem('fileManagerObj') && !reset\r\n             ? of(true):*/\r\n        return this.fetchfileManager_mainFolderId(apiName).pipe(\r\n            tap((res) => {\r\n                console.log('res: ', res);\r\n                if (res) {\r\n                    this.fileManagerObj = {\r\n                        entries: res.entries.map((item) => {\r\n                            delete item._baseOptions;\r\n                            delete item._dirtyProperties;\r\n                            delete item._nuxeo;\r\n                            delete item._repository;\r\n                            return item;\r\n                        }),\r\n                    };\r\n\r\n                    this.userPreference.set(\r\n                        apiName ? this.localStoragKeys[apiName] : 'fileManagerObj',\r\n                        JSON.stringify(this.fileManagerObj)\r\n                    );\r\n                }\r\n            }),\r\n            switchMap(value => of(this.get_fileManagerObj_FromLocalStorage(apiName ? this.localStoragKeys[apiName] : 'fileManagerObj')))\r\n        );\r\n    }\r\n\r\n    save_myfilesManagerObj_ToLocalStorage(): Observable<any> {\r\n        return this.userPreference.hasItem('myFilesManagerObj')\r\n            ? of(true)\r\n            : this.fetchMyFilesManager_mainFolderId().pipe(\r\n                tap((res) => {\r\n                    console.log('res: ' + res);\r\n                    if (res) {\r\n                        this.myFilesManagerObj = {\r\n                            id: res.uid,\r\n                            path: res.path,\r\n                        };\r\n\r\n                        this.userPreference.set(\r\n                            'myFilesManagerObj',\r\n                            JSON.stringify(this.myFilesManagerObj)\r\n                        );\r\n                    }\r\n                })\r\n            );\r\n    }\r\n\r\n    save_ArchiveManagerObject_ToLocalStorage(): Observable<any> {\r\n        return this.userPreference.hasItem('ArchiveManagerObj')\r\n            ? of(true)\r\n            : this.fetchArchiveManager_mainFolderId().pipe(\r\n                tap((res) => {\r\n                    console.log('res: ' + res);\r\n                    if (res) {\r\n                        this.ArchiveManagerObj = {\r\n                            id: res.uid,\r\n                            path: res.path,\r\n                        };\r\n\r\n                        this.userPreference.set(\r\n                            'ArchiveManagerObj',\r\n                            JSON.stringify(this.ArchiveManagerObj)\r\n                        );\r\n                    }\r\n                })\r\n            );\r\n    }\r\n\r\n    save_categoryObj_ToLocalStorage(): Observable<any> {\r\n        return this.userPreference.hasItem('categoryObj')\r\n            ? of(true)\r\n            : this.fetchcategory_mainFolderId().pipe(\r\n                tap((res) => {\r\n                    if (res) {\r\n                        this.categoryObj = {\r\n                            id: res.uid,\r\n                            path: res.path,\r\n                        };\r\n\r\n                        this.userPreference.set(\r\n                            'categoryObj',\r\n                            JSON.stringify(this.categoryObj)\r\n                        );\r\n                    }\r\n                })\r\n            );\r\n    }\r\n\r\n    get_fileManagerObj_FromLocalStorage(key?) {\r\n        if (this.userPreference.hasItem( key ? key : 'fileManagerObj')) {\r\n            return JSON.parse(this.userPreference.get(key ? key : 'fileManagerObj'));\r\n        }\r\n        return null;\r\n    }\r\n\r\n    get_myFilesManagerObj_FromLocalStorage() {\r\n        if (this.userPreference.hasItem('myFilesManagerObj')) {\r\n            return JSON.parse(this.userPreference.get('myFilesManagerObj'));\r\n        }\r\n        return null;\r\n    }\r\n    get_ArchiveManagerObj_FromLocalStorage() {\r\n        if (this.userPreference.hasItem('ArchiveManagerObj')) {\r\n            return JSON.parse(this.userPreference.get('ArchiveManagerObj'));\r\n        }\r\n        return null;\r\n    }\r\n\r\n    get_categoryObj_FromLocalStorage() {\r\n        if (this.userPreference.hasItem('categoryObj')) {\r\n            return JSON.parse(this.userPreference.get('categoryObj'));\r\n        }\r\n        return null;\r\n    }\r\n}\r\n"]}

package/esm2015/lib/shared-services/publishing-document.service.js

@@ -0,0 +1,202 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, from } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../Core/services/nuxeo/nuxeo.service";
+import * as i2 from "../Core/services/callApi/call-api.service";
+export class PublishingDocumentService {
+    constructor(nuxeoService, environment, callApiService) {
+        this.nuxeoService = nuxeoService;
+        this.environment = environment;
+        this.callApiService = callApiService;
+        this.newPublished = new BehaviorSubject(false);
+    }
+    getSectionById(docIds) {
+        return this.callApiService.query({
+            pageProvider: 'Documents_InList_PP',
+            pageSize: 1000,
+            system_uuid: JSON.stringify(docIds),
+        }, {
+            headers: {
+                "X-NXproperties": "*",
+            }
+        });
+    }
+    getSectionByTitle(titles) {
+        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 === null || sortObj === void 0 ? void 0 : sortObj.sortBy,
+            sortOrder: sortObj === null || sortObj === void 0 ? void 0 : 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(Object.assign({}, 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());
+    }
+}
+PublishingDocumentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: PublishingDocumentService, deps: [{ token: i1.NuxeoService }, { token: 'environment' }, { token: i2.CallApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+PublishingDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: PublishingDocumentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: PublishingDocumentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.CallApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publishing-document.service.js","sourceRoot":"","sources":["../../../../../projects/nuxeo-development-framework/src/lib/shared-services/publishing-document.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { BehaviorSubject, from, Observable } from 'rxjs';\r\nimport { catchError } from 'rxjs/operators';\r\nimport { NuxeoService } from '../Core/services/nuxeo/nuxeo.service';\r\nimport { CallApiService } from '../Core/services/callApi/call-api.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PublishingDocumentService {\r\n\r\n\r\n  newPublished = new BehaviorSubject<boolean>(false);\r\n  constructor(private nuxeoService: NuxeoService,\r\n    @Inject('environment') private environment,\r\n    private callApiService: CallApiService) {\r\n\r\n  }\r\n\r\n  getSectionById(docIds): Observable<any> {\r\n    return this.callApiService.query(\r\n      {\r\n        pageProvider: 'Documents_InList_PP',\r\n        pageSize: 1000,\r\n        system_uuid: JSON.stringify(docIds),\r\n      },\r\n      {\r\n        headers: {\r\n          \"X-NXproperties\": \"*\",\r\n        }\r\n      }\r\n    );\r\n  }\r\n  getSectionByTitle(titles): Observable<any> {\r\n    return this.callApiService.query(\r\n      {\r\n        pageProvider: 'Documents_InList_PP',\r\n        pageSize: 1000,\r\n        system_primaryType: \"OSDepartment\",\r\n        dublincore_title: JSON.stringify(titles),\r\n      },\r\n      {\r\n        headers: {\r\n          \"X-NXproperties\": \"*\",\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  getPublishingSections(pageNumber?, pageSize?, sortObj?) {\r\n    return from(this.nuxeoService.nuxeoClient\r\n      .operation('Repository.PageProvider', {\r\n        url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n      })\r\n      .params({\r\n        \"documentSchemas\": [\"*\"],\r\n        page: pageNumber ? pageNumber : 0,\r\n        currentPageIndex: pageNumber ? pageNumber : 0,\r\n        offset: 0,\r\n        pageSize: pageSize ? pageSize : 0,\r\n        sortBy: sortObj?.sortBy,\r\n        sortOrder: sortObj?.sortOrder,\r\n        \"pageProviderName\": \"publish_space_suggestion\",\r\n        \"providerName\": \"publish_space_suggestion\",\r\n        \"repository\": \"default\",\r\n        \"searchTerm\": \"\",\r\n      })\r\n      .context()\r\n      .execute({\r\n        headers: {\r\n          'X-NXproperties': '*',\r\n          'enrichers-document': 'acls',\r\n          \"fetch-document\": \"dc:creator\"\r\n        },\r\n      })\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      }))\r\n  }\r\n\r\n  unPublishDocument(docId) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('Document.Delete', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(docId)\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  publishDocument(docId, params) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('AC_UA_Puplish_Documents', {\r\n          url: `${this.environment.nuxeo}/api/v1/custom-automation`,\r\n        })\r\n        .params()\r\n        .input(docId)\r\n        .context({\r\n          ...params\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  getPublishedPlaces(uid) {\r\n    return this.callApiService.query(\r\n      {\r\n        pageProvider: 'nxql_search',\r\n        currentPageIndex: 0,\r\n        pageSize: 40,\r\n        offset: 0,\r\n        queryParams: `SELECT * FROM Document WHERE ecm:isProxy = 1 AND ecm:isTrashed = 0 AND (rend:sourceVersionableId = \"${uid}\" OR ecm:proxyVersionableId = \"${uid}\")`,\r\n        sortBy: 'dc:modified,uid:major_version,uid:minor_version',\r\n        sortOrder: 'desc,desc,desc'\r\n      },\r\n      {\r\n        headers: {\r\n          'enrichers-document': 'breadcrumb',\r\n          properties: \"dublincore,common,uid,rendition,file\"\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  getVersionToPublishDialog(uid) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .request(`search/execute`)\r\n        .queryParams({\r\n          currentPageIndex: 0,\r\n          pageSize: 100,\r\n          offset: 0,\r\n          query: `SELECT * FROM Document WHERE ecm:versionVersionableId = \"${uid}\" AND ecm:isVersion = 1`,\r\n          sortBy: 'uid:major_version,uid:minor_version',\r\n          sortOrder: 'desc,desc'\r\n        })\r\n        .get({\r\n          headers: {\r\n            properties: '*'\r\n          }\r\n        })\r\n    ).pipe(\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  /*getProxyDocument(docId) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('Proxy.GetSourceDocument', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(docId)\r\n        .execute({\r\n          headers: {\r\n            properties: '*'\r\n          }\r\n        })\r\n    ).pipe(\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }*/\r\n  buildVersionNum(element) {\r\n    return parseFloat(`${element.properties['uid:major_version']}.${element.properties['uid:minor_version']}`)\r\n  }\r\n  createPublishDepartmentSection(section) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('AC_UA_Section_Create', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .context({ section })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        //console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  Add_Permission_PublishDepartmentSection(sectionName, depList, uid) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('AC_UA_Section_Add_Permission', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .context({\r\n          \"permission\": \"Read\",\r\n          \"usersAndGroups\": sectionName,\r\n          \"departmentList\": depList\r\n\r\n        })\r\n        .input(uid)\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        //console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  updatePublishDepartmentSection(section, uid) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('AC_UA_Section_Update', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .context({ section })\r\n        .input(uid)\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        //console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  deleteSection(uid) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation('AC_UA_Section_Delete')\r\n        .input(uid)\r\n        .execute()\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2015/lib/shared-services/recently-viewed.service.js

@@ -0,0 +1,57 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../Core/services/user/user-preferences.service";
+import * as i2 from "../Core/services/callApi/call-api.service";
+export class RecentlyViewedService {
+    constructor(userPreference, callApiService) {
+        this.userPreference = userPreference;
+        this.callApiService = callApiService;
+        this.itemAdded = new EventEmitter();
+        this.recentViewedDocsIds = [];
+        this.getIdsFromLocalStorage();
+    }
+    getIdsFromLocalStorage() {
+        this.recentViewedDocsIds = JSON.parse(this.userPreference.get('recentlyViewedDocsIds') || '[]');
+        return this.recentViewedDocsIds;
+    }
+    setIdsInLocalStorage(Id) {
+        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) {
+        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"
+            }
+        });
+    }
+}
+RecentlyViewedService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RecentlyViewedService, deps: [{ token: i1.UserPreferencesService }, { token: i2.CallApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+RecentlyViewedService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RecentlyViewedService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: RecentlyViewedService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UserPreferencesService }, { type: i2.CallApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjZW50bHktdmlld2VkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9zaGFyZWQtc2VydmljZXMvcmVjZW50bHktdmlld2VkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7QUFRekQsTUFBTSxPQUFPLHFCQUFxQjtJQUdoQyxZQUFvQixjQUFzQyxFQUNoRCxjQUE4QjtRQURwQixtQkFBYyxHQUFkLGNBQWMsQ0FBd0I7UUFDaEQsbUJBQWMsR0FBZCxjQUFjLENBQWdCO1FBSHhDLGNBQVMsR0FBRyxJQUFJLFlBQVksRUFBRSxDQUFDO1FBQy9CLHdCQUFtQixHQUFDLEVBQUUsQ0FBQztRQUdyQixJQUFJLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBR0Ysc0JBQXNCO1FBQ3BCLElBQUksQ0FBQyxtQkFBbUIsR0FBRSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLHVCQUF1QixDQUFDLElBQUssSUFBSSxDQUFDLENBQUM7UUFDaEcsT0FBTyxJQUFJLENBQUMsbUJBQW1CLENBQUM7SUFDbEMsQ0FBQztJQUVELG9CQUFvQixDQUFDLEVBQVU7UUFDN0IsSUFBSSxJQUFJLENBQUMsbUJBQW1CLENBQUMsTUFBTSxHQUFHLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLEVBQUU7WUFDbEYsSUFBSSxDQUFDLG1CQUFtQixDQUFDLEdBQUcsRUFBRSxDQUFDO1NBQ2hDO2FBQU0sSUFBSSxJQUFJLENBQUMsbUJBQW1CLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFO1lBQ2hELElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsS0FBSyxFQUFFLEVBQUU7Z0JBQ2xELElBQUksT0FBTyxJQUFJLEVBQUU7b0JBQUUsSUFBSSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDL0QsQ0FBQyxDQUFDLENBQUM7U0FDSjtRQUNELElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDckMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsdUJBQXVCLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO1FBQzNGLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDeEIsQ0FBQztJQUNELHFCQUFxQixDQUFDLE1BQU0sRUFBQyxPQUFZO1FBQ3ZDLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQzlCO1lBQ0UsWUFBWSxFQUFFLHFCQUFxQjtZQUNuQyxnQkFBZ0IsRUFBRSxDQUFDO1lBQ25CLE1BQU0sRUFBRSxDQUFDO1lBQ1QsUUFBUSxFQUFFLEVBQUU7WUFDWixXQUFXLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUM7WUFDbkMsTUFBTSxFQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDeEMsU0FBUyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUU7U0FDOUMsRUFDRDtZQUNFLE9BQU8sRUFBRTtnQkFDUCxnQkFBZ0IsRUFBRSxHQUFHO2dCQUNyQixvQkFBb0IsRUFBRSxXQUFXO2dCQUNqQyxnQkFBZ0IsRUFBRSxvQkFBb0I7YUFDdkM7U0FDRixDQUNGLENBQUM7SUFDSixDQUFDOztrSEE3Q1UscUJBQXFCO3NIQUFyQixxQkFBcUIsY0FGcEIsTUFBTTsyRkFFUCxxQkFBcUI7a0JBSGpDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgVXNlclByZWZlcmVuY2VzU2VydmljZSB9IGZyb20gJy4uL0NvcmUvc2VydmljZXMvdXNlci91c2VyLXByZWZlcmVuY2VzLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBDYWxsQXBpU2VydmljZSB9IGZyb20gJy4uL0NvcmUvc2VydmljZXMvY2FsbEFwaS9jYWxsLWFwaS5zZXJ2aWNlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIFJlY2VudGx5Vmlld2VkU2VydmljZSB7XHJcbiAgaXRlbUFkZGVkID0gbmV3IEV2ZW50RW1pdHRlcigpO1xyXG4gIHJlY2VudFZpZXdlZERvY3NJZHM9W107XHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSB1c2VyUHJlZmVyZW5jZTogVXNlclByZWZlcmVuY2VzU2VydmljZSxcclxuICAgIHByaXZhdGUgY2FsbEFwaVNlcnZpY2U6IENhbGxBcGlTZXJ2aWNlKSB7XHJcbiAgICB0aGlzLmdldElkc0Zyb21Mb2NhbFN0b3JhZ2UoKTtcclxuICAgfVxyXG4gIFxyXG5cclxuICBnZXRJZHNGcm9tTG9jYWxTdG9yYWdlKCkge1xyXG4gICAgdGhpcy5yZWNlbnRWaWV3ZWREb2NzSWRzID1KU09OLnBhcnNlKHRoaXMudXNlclByZWZlcmVuY2UuZ2V0KCdyZWNlbnRseVZpZXdlZERvY3NJZHMnKSAgfHwgJ1tdJyk7XHJcbiAgICByZXR1cm4gdGhpcy5yZWNlbnRWaWV3ZWREb2NzSWRzO1xyXG4gIH1cclxuXHJcbiAgc2V0SWRzSW5Mb2NhbFN0b3JhZ2UoSWQ6IHN0cmluZykge1xyXG4gICAgaWYgKHRoaXMucmVjZW50Vmlld2VkRG9jc0lkcy5sZW5ndGggPiAxNCAmJiAhdGhpcy5yZWNlbnRWaWV3ZWREb2NzSWRzLmluY2x1ZGVzKElkKSkge1xyXG4gICAgICB0aGlzLnJlY2VudFZpZXdlZERvY3NJZHMucG9wKCk7XHJcbiAgICB9IGVsc2UgaWYgKHRoaXMucmVjZW50Vmlld2VkRG9jc0lkcy5pbmNsdWRlcyhJZCkpIHtcclxuICAgICAgdGhpcy5yZWNlbnRWaWV3ZWREb2NzSWRzLmZvckVhY2goKGVsZW1lbnQsIGluZGV4KSA9PiB7XHJcbiAgICAgICAgaWYgKGVsZW1lbnQgPT0gSWQpIHRoaXMucmVjZW50Vmlld2VkRG9jc0lkcy5zcGxpY2UoaW5kZXgsIDEpO1xyXG4gICAgICB9KTtcclxuICAgIH1cclxuICAgIHRoaXMucmVjZW50Vmlld2VkRG9jc0lkcy51bnNoaWZ0KElkKTtcclxuICAgIHRoaXMudXNlclByZWZlcmVuY2Uuc2V0KFwicmVjZW50bHlWaWV3ZWREb2NzSWRzXCIsIEpTT04uc3RyaW5naWZ5KHRoaXMucmVjZW50Vmlld2VkRG9jc0lkcykpO1xyXG4gICAgdGhpcy5pdGVtQWRkZWQuZW1pdCgpO1xyXG4gIH1cclxuICBnZXRSZWNlbnRseVZpZXdlZERvY3MoZG9jSWRzLHNvcnRPYmo/OmFueSk6IE9ic2VydmFibGU8YW55PiB7XHJcbiAgICByZXR1cm4gdGhpcy5jYWxsQXBpU2VydmljZS5xdWVyeShcclxuICAgICAge1xyXG4gICAgICAgIHBhZ2VQcm92aWRlcjogJ0RvY3VtZW50c19Jbkxpc3RfUFAnLFxyXG4gICAgICAgIGN1cnJlbnRQYWdlSW5kZXg6IDAsXHJcbiAgICAgICAgb2Zmc2V0OiAwLFxyXG4gICAgICAgIHBhZ2VTaXplOiAxNSxcclxuICAgICAgICBzeXN0ZW1fdXVpZDogSlNPTi5zdHJpbmdpZnkoZG9jSWRzKSxcclxuICAgICAgICBzb3J0Qnk6ICAoc29ydE9iaikgPyBzb3J0T2JqLnNvcnRCeSA6ICcnLFxyXG4gICAgICAgIHNvcnRPcmRlcjogKHNvcnRPYmopID8gc29ydE9iai5zb3J0T3JkZXIgOiAnJ1xyXG4gICAgICB9LFxyXG4gICAgICB7XHJcbiAgICAgICAgaGVhZGVyczoge1xyXG4gICAgICAgICAgXCJYLU5YcHJvcGVydGllc1wiOiBcIipcIixcclxuICAgICAgICAgIFwiZW5yaWNoZXJzLWRvY3VtZW50XCI6IFwidGh1bWJuYWlsXCIsXHJcbiAgICAgICAgICBcImZldGNoLWRvY3VtZW50XCI6IFwiZGM6bGFzdENvbnRyaWJ1dG9yXCJcclxuICAgICAgICB9XHJcbiAgICAgIH1cclxuICAgICk7XHJcbiAgfVxyXG59XHJcbiJdfQ==