nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/components/documents/documents.module.js

@@ -0,0 +1,123 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { RouterModule } from '@angular/router';
+import { TranslateModule } from '@ngx-translate/core';
+import { DirectiveModule } from '../../directive/directive.module';
+import { PipesModule } from '../../pipes/pipes.module';
+import { CardModule } from '../card/card.module';
+import { ConfirmCallerModule } from '../confirm-caller/confirm-caller.module';
+import { PaginationModule } from '../pagination/pagination.module';
+import { DocumentsListComponent } from './components/document-list/documents-list.component';
+import { ScanComponent } from './components/document-scan/document-scan.component';
+import { DocumentUploadComponent } from './components/document-upload/document-upload.component';
+import { DocumentsComponent } from './components/documents/documents.component';
+import { AttachmentsListComponent } from './components/attachments-list/attachments-list.component';
+import { DynamicFormModule } from '../dynamic-form/dynamic-form.module';
+import { AttachmentsPageProviderComponent } from './components/attachments-page-provider/attachments-page-provider.component';
+import { LibrarySharedModule } from '../../shared/libraryShared.module';
+import * as i0 from "@angular/core";
+/**
+ * @title
+ * Documents Module
+ */
+export class DocumentsModule {
+}
+DocumentsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DocumentsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsModule, declarations: [DocumentsComponent,
+        DocumentsListComponent,
+        DocumentUploadComponent,
+        ScanComponent,
+        AttachmentsListComponent,
+        AttachmentsPageProviderComponent], imports: [MatButtonModule,
+        CommonModule,
+        TranslateModule,
+        PaginationModule,
+        ConfirmCallerModule,
+        RouterModule,
+        MatProgressBarModule,
+        MatProgressSpinnerModule,
+        MatIconModule,
+        MatDialogModule,
+        DirectiveModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatInputModule,
+        PipesModule,
+        CardModule,
+        DynamicFormModule,
+        LibrarySharedModule], exports: [DocumentsComponent,
+        DocumentsListComponent,
+        DocumentUploadComponent,
+        ScanComponent,
+        AttachmentsListComponent,
+        AttachmentsPageProviderComponent] });
+DocumentsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsModule, providers: [], imports: [[
+            MatButtonModule,
+            CommonModule,
+            TranslateModule,
+            PaginationModule,
+            ConfirmCallerModule,
+            RouterModule,
+            MatProgressBarModule,
+            MatProgressSpinnerModule,
+            MatIconModule,
+            MatDialogModule,
+            DirectiveModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatInputModule,
+            PipesModule,
+            CardModule,
+            DynamicFormModule,
+            LibrarySharedModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        DocumentsComponent,
+                        DocumentsListComponent,
+                        DocumentUploadComponent,
+                        ScanComponent,
+                        AttachmentsListComponent,
+                        AttachmentsPageProviderComponent
+                    ],
+                    imports: [
+                        MatButtonModule,
+                        CommonModule,
+                        TranslateModule,
+                        PaginationModule,
+                        ConfirmCallerModule,
+                        RouterModule,
+                        MatProgressBarModule,
+                        MatProgressSpinnerModule,
+                        MatIconModule,
+                        MatDialogModule,
+                        DirectiveModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatInputModule,
+                        PipesModule,
+                        CardModule,
+                        DynamicFormModule,
+                        LibrarySharedModule
+                    ],
+                    exports: [
+                        DocumentsComponent,
+                        DocumentsListComponent,
+                        DocumentUploadComponent,
+                        ScanComponent,
+                        AttachmentsListComponent,
+                        AttachmentsPageProviderComponent
+                    ],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnRzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvZG9jdW1lbnRzL2RvY3VtZW50cy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM5RSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNuRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQzlFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBQzdGLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUNuRixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUNqRyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUNoRixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwwREFBMEQsQ0FBQztBQUNwRyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN4RSxPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSw0RUFBNEUsQ0FBQztBQUM5SCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQzs7QUFFeEU7OztHQUdHO0FBd0NILE1BQU0sT0FBTyxlQUFlOzs2R0FBZixlQUFlOzhHQUFmLGVBQWUsaUJBckN4QixrQkFBa0I7UUFDbEIsc0JBQXNCO1FBQ3RCLHVCQUF1QjtRQUN2QixhQUFhO1FBQ2Isd0JBQXdCO1FBQ3hCLGdDQUFnQyxhQUdoQyxlQUFlO1FBQ2YsWUFBWTtRQUNaLGVBQWU7UUFDZixnQkFBZ0I7UUFDaEIsbUJBQW1CO1FBQ25CLFlBQVk7UUFDWixvQkFBb0I7UUFDcEIsd0JBQXdCO1FBQ3hCLGFBQWE7UUFDYixlQUFlO1FBQ2YsZUFBZTtRQUNmLFdBQVc7UUFDWCxtQkFBbUI7UUFDbkIsY0FBYztRQUNkLFdBQVc7UUFDWCxVQUFVO1FBQ1YsaUJBQWlCO1FBQ2pCLG1CQUFtQixhQUduQixrQkFBa0I7UUFDbEIsc0JBQXNCO1FBQ3RCLHVCQUF1QjtRQUN2QixhQUFhO1FBQ2Isd0JBQXdCO1FBQ3hCLGdDQUFnQzs4R0FJdkIsZUFBZSxhQUZmLEVBQUUsWUE1Qko7WUFDUCxlQUFlO1lBQ2YsWUFBWTtZQUNaLGVBQWU7WUFDZixnQkFBZ0I7WUFDaEIsbUJBQW1CO1lBQ25CLFlBQVk7WUFDWixvQkFBb0I7WUFDcEIsd0JBQXdCO1lBQ3hCLGFBQWE7WUFDYixlQUFlO1lBQ2YsZUFBZTtZQUNmLFdBQVc7WUFDWCxtQkFBbUI7WUFDbkIsY0FBYztZQUNkLFdBQVc7WUFDWCxVQUFVO1lBQ1YsaUJBQWlCO1lBQ2pCLG1CQUFtQjtTQUNwQjs0RkFXVSxlQUFlO2tCQXZDM0IsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUU7d0JBQ1osa0JBQWtCO3dCQUNsQixzQkFBc0I7d0JBQ3RCLHVCQUF1Qjt3QkFDdkIsYUFBYTt3QkFDYix3QkFBd0I7d0JBQ3hCLGdDQUFnQztxQkFDakM7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLGVBQWU7d0JBQ2YsWUFBWTt3QkFDWixlQUFlO3dCQUNmLGdCQUFnQjt3QkFDaEIsbUJBQW1CO3dCQUNuQixZQUFZO3dCQUNaLG9CQUFvQjt3QkFDcEIsd0JBQXdCO3dCQUN4QixhQUFhO3dCQUNiLGVBQWU7d0JBQ2YsZUFBZTt3QkFDZixXQUFXO3dCQUNYLG1CQUFtQjt3QkFDbkIsY0FBYzt3QkFDZCxXQUFXO3dCQUNYLFVBQVU7d0JBQ1YsaUJBQWlCO3dCQUNqQixtQkFBbUI7cUJBQ3BCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxrQkFBa0I7d0JBQ2xCLHNCQUFzQjt3QkFDdEIsdUJBQXVCO3dCQUN2QixhQUFhO3dCQUNiLHdCQUF3Qjt3QkFDeEIsZ0NBQWdDO3FCQUNqQztvQkFDRCxTQUFTLEVBQUUsRUFBRTtpQkFDZCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEZvcm1zTW9kdWxlLCBSZWFjdGl2ZUZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBNYXRCdXR0b25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9idXR0b24nO1xyXG5pbXBvcnQgeyBNYXREaWFsb2dNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaWFsb2cnO1xyXG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XHJcbmltcG9ydCB7IE1hdElucHV0TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaW5wdXQnO1xyXG5pbXBvcnQgeyBNYXRQcm9ncmVzc0Jhck1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3Byb2dyZXNzLWJhcic7XHJcbmltcG9ydCB7IE1hdFByb2dyZXNzU3Bpbm5lck1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3Byb2dyZXNzLXNwaW5uZXInO1xyXG5pbXBvcnQgeyBSb3V0ZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xyXG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcclxuaW1wb3J0IHsgRGlyZWN0aXZlTW9kdWxlIH0gZnJvbSAnLi4vLi4vZGlyZWN0aXZlL2RpcmVjdGl2ZS5tb2R1bGUnO1xyXG5pbXBvcnQgeyBQaXBlc01vZHVsZSB9IGZyb20gJy4uLy4uL3BpcGVzL3BpcGVzLm1vZHVsZSc7XHJcbmltcG9ydCB7IENhcmRNb2R1bGUgfSBmcm9tICcuLi9jYXJkL2NhcmQubW9kdWxlJztcclxuaW1wb3J0IHsgQ29uZmlybUNhbGxlck1vZHVsZSB9IGZyb20gJy4uL2NvbmZpcm0tY2FsbGVyL2NvbmZpcm0tY2FsbGVyLm1vZHVsZSc7XHJcbmltcG9ydCB7IFBhZ2luYXRpb25Nb2R1bGUgfSBmcm9tICcuLi9wYWdpbmF0aW9uL3BhZ2luYXRpb24ubW9kdWxlJztcclxuaW1wb3J0IHsgRG9jdW1lbnRzTGlzdENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9kb2N1bWVudC1saXN0L2RvY3VtZW50cy1saXN0LmNvbXBvbmVudCc7XHJcbmltcG9ydCB7IFNjYW5Db21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvZG9jdW1lbnQtc2Nhbi9kb2N1bWVudC1zY2FuLmNvbXBvbmVudCc7XHJcbmltcG9ydCB7IERvY3VtZW50VXBsb2FkQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL2RvY3VtZW50LXVwbG9hZC9kb2N1bWVudC11cGxvYWQuY29tcG9uZW50JztcclxuaW1wb3J0IHsgRG9jdW1lbnRzQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL2RvY3VtZW50cy9kb2N1bWVudHMuY29tcG9uZW50JztcclxuaW1wb3J0IHsgQXR0YWNobWVudHNMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL2F0dGFjaG1lbnRzLWxpc3QvYXR0YWNobWVudHMtbGlzdC5jb21wb25lbnQnO1xyXG5pbXBvcnQgeyBEeW5hbWljRm9ybU1vZHVsZSB9IGZyb20gJy4uL2R5bmFtaWMtZm9ybS9keW5hbWljLWZvcm0ubW9kdWxlJztcclxuaW1wb3J0IHsgQXR0YWNobWVudHNQYWdlUHJvdmlkZXJDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvYXR0YWNobWVudHMtcGFnZS1wcm92aWRlci9hdHRhY2htZW50cy1wYWdlLXByb3ZpZGVyLmNvbXBvbmVudCc7XHJcbmltcG9ydCB7IExpYnJhcnlTaGFyZWRNb2R1bGUgfSBmcm9tICcuLi8uLi9zaGFyZWQvbGlicmFyeVNoYXJlZC5tb2R1bGUnO1xyXG5cclxuLyoqXHJcbiAqIEB0aXRsZVxyXG4gKiBEb2N1bWVudHMgTW9kdWxlXHJcbiAqL1xyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW1xyXG4gICAgRG9jdW1lbnRzQ29tcG9uZW50LFxyXG4gICAgRG9jdW1lbnRzTGlzdENvbXBvbmVudCxcclxuICAgIERvY3VtZW50VXBsb2FkQ29tcG9uZW50LFxyXG4gICAgU2NhbkNvbXBvbmVudCxcclxuICAgIEF0dGFjaG1lbnRzTGlzdENvbXBvbmVudCxcclxuICAgIEF0dGFjaG1lbnRzUGFnZVByb3ZpZGVyQ29tcG9uZW50XHJcbiAgXSxcclxuICBpbXBvcnRzOiBbXHJcbiAgICBNYXRCdXR0b25Nb2R1bGUsXHJcbiAgICBDb21tb25Nb2R1bGUsXHJcbiAgICBUcmFuc2xhdGVNb2R1bGUsXHJcbiAgICBQYWdpbmF0aW9uTW9kdWxlLFxyXG4gICAgQ29uZmlybUNhbGxlck1vZHVsZSxcclxuICAgIFJvdXRlck1vZHVsZSxcclxuICAgIE1hdFByb2dyZXNzQmFyTW9kdWxlLFxyXG4gICAgTWF0UHJvZ3Jlc3NTcGlubmVyTW9kdWxlLFxyXG4gICAgTWF0SWNvbk1vZHVsZSxcclxuICAgIE1hdERpYWxvZ01vZHVsZSxcclxuICAgIERpcmVjdGl2ZU1vZHVsZSxcclxuICAgIEZvcm1zTW9kdWxlLFxyXG4gICAgUmVhY3RpdmVGb3Jtc01vZHVsZSxcclxuICAgIE1hdElucHV0TW9kdWxlLFxyXG4gICAgUGlwZXNNb2R1bGUsXHJcbiAgICBDYXJkTW9kdWxlLFxyXG4gICAgRHluYW1pY0Zvcm1Nb2R1bGUsXHJcbiAgICBMaWJyYXJ5U2hhcmVkTW9kdWxlXHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBEb2N1bWVudHNDb21wb25lbnQsXHJcbiAgICBEb2N1bWVudHNMaXN0Q29tcG9uZW50LFxyXG4gICAgRG9jdW1lbnRVcGxvYWRDb21wb25lbnQsXHJcbiAgICBTY2FuQ29tcG9uZW50LFxyXG4gICAgQXR0YWNobWVudHNMaXN0Q29tcG9uZW50LFxyXG4gICAgQXR0YWNobWVudHNQYWdlUHJvdmlkZXJDb21wb25lbnRcclxuICBdLFxyXG4gIHByb3ZpZGVyczogW10sXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBEb2N1bWVudHNNb2R1bGUgeyB9XHJcbiJdfQ==

package/esm2015/lib/components/documents/services/document-templates.service.js

@@ -0,0 +1,115 @@
+import { Inject, Injectable } from '@angular/core';
+import { from, ReplaySubject, Subject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { DocumentTemplatesConstants } from '../constants/document-templates';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/services/nuxeo/nuxeo.service";
+import * as i2 from "../../../core/adapters/adapter.service";
+import * as i3 from "@angular/common/http";
+export class DocumentTemplatesService {
+    // templatesRootPath = '';
+    constructor(nuxeoService, documentsAdapter, httpClient, environment) {
+        this.nuxeoService = nuxeoService;
+        this.documentsAdapter = documentsAdapter;
+        this.httpClient = httpClient;
+        this.environment = environment;
+        this.value = new ReplaySubject(1);
+        this.reFetch = new Subject();
+    }
+    informValue(value) {
+        const arr = [];
+        arr.push(value);
+        this.value.next(value);
+    }
+    getDocumentTemplate(uid) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers(Object.assign(Object.assign({}, DocumentTemplatesConstants.pageProvider.documentTemplates.headers), { 'X-NXfetch-document': 'lock,dc:creator', 'X-NXenrichers-document': 'tags' }))
+            .fetch(uid)).pipe(map((data) => {
+            return this.documentsAdapter.adaptIn(data, DocumentTemplatesConstants.fields);
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    getDocumentTemplatesWithAggregation(params = {}) {
+        if (!params) {
+            params = {};
+        }
+        if (!params[DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamName]) {
+            params[DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamName]
+                = DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamDefaultValue;
+        }
+        return from(this.nuxeoService.nuxeoClient.repository().query(Object.assign({ pageProvider: DocumentTemplatesConstants.pageProvider.documentTemplates.name }, params), {
+            headers: DocumentTemplatesConstants.pageProvider.documentTemplates.headers,
+        })).pipe(map((data) => {
+            data.entries.map((item) => this.documentsAdapter.adaptIn(item, DocumentTemplatesConstants.fields));
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    parseTemplate(templateId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentTemplatesConstants.operations.parse, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(templateId)
+            .params({})
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    renderTemplate(templateId) {
+        return this.httpClient.post(`${this.environment.nuxeo}${this.environment.customAutomation}/${DocumentTemplatesConstants.operations.render}`, { input: templateId }, { responseType: 'blob' }).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    mergeAndParseTemplate(templateId, mergeDocumentId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentTemplatesConstants.operations.mergeAndParse, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(templateId)
+            .params({})
+            .context({
+            mergeDocumentId
+        })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    mergeAndRenderTemplate(templateId, mergeDocumentId) {
+        return this.httpClient.post(`${this.environment.nuxeo}${this.environment.customAutomation}/${DocumentTemplatesConstants.operations.mergeAndRender}`, { input: templateId, context: { mergeDocumentId } }, { responseType: 'blob' }).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    reflectTemplateToCorrespondence(correspondenceId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentTemplatesConstants.operations.reflectTemplateToCorrespondence, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(correspondenceId)
+            .params({})
+            .context({})
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+}
+DocumentTemplatesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesService, deps: [{ token: i1.NuxeoService }, { token: i2.AdapterService }, { token: i3.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentTemplatesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentTemplatesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: i2.AdapterService }, { type: i3.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-templates.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/documents/services/document-templates.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { combineLatest, from, Observable, ReplaySubject, Subject } from 'rxjs';\r\nimport { catchError, map, switchMap } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../configuration/app-config.service';\r\nimport { AdapterService } from '../../../core/adapters/adapter.service';\r\nimport { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';\r\nimport {DocumentTemplatesConstants} from '../constants/document-templates';\r\nimport {DocumentsConstants} from '../constants/documents';\r\nimport {HttpClient} from '@angular/common/http';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DocumentTemplatesService {\r\n  value = new ReplaySubject(1);\r\n  reFetch = new Subject<boolean>();\r\n  // templatesRootPath = '';\r\n  constructor(\r\n    private nuxeoService: NuxeoService,\r\n    private documentsAdapter: AdapterService,\r\n    private httpClient: HttpClient,\r\n    @Inject('environment') private environment\r\n  ) {\r\n  }\r\n\r\n  informValue(value): void {\r\n    const arr = [];\r\n    arr.push(value);\r\n    this.value.next(value);\r\n  }\r\n  getDocumentTemplate(uid): Observable<any>  {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          ...DocumentTemplatesConstants.pageProvider.documentTemplates.headers,\r\n          'X-NXfetch-document': 'lock,dc:creator',\r\n          'X-NXenrichers-document': 'tags',\r\n        })\r\n        .fetch(uid)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        return this.documentsAdapter.adaptIn(data, DocumentTemplatesConstants.fields);\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  getDocumentTemplatesWithAggregation(params = {}): Observable<any> {\r\n    if (!params) {\r\n      params = {};\r\n    }\r\n    if (!params[DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamName]) {\r\n      params[DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamName]\r\n        = DocumentTemplatesConstants.pageProvider.documentTemplates.constants.systemPathParamDefaultValue;\r\n    }\r\n    return from(\r\n      this.nuxeoService.nuxeoClient.repository().query(\r\n        {\r\n          pageProvider:\r\n          DocumentTemplatesConstants.pageProvider.documentTemplates.name,\r\n          ...params,\r\n        },\r\n        {\r\n          headers:\r\n          DocumentTemplatesConstants.pageProvider.documentTemplates.headers,\r\n        }\r\n      )\r\n    ).pipe(\r\n      map((data: any) => {\r\n        data.entries.map((item) =>\r\n          this.documentsAdapter.adaptIn(item, DocumentTemplatesConstants.fields)\r\n        );\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  parseTemplate(templateId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentTemplatesConstants.operations.parse, {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(templateId)\r\n        .params({})\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  renderTemplate(templateId): Observable<any> {\r\n    return this.httpClient.post(`${this.environment.nuxeo}${this.environment.customAutomation}/${DocumentTemplatesConstants.operations.render}`,\r\n      {input: templateId}, {responseType: 'blob'}\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  mergeAndParseTemplate(templateId, mergeDocumentId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentTemplatesConstants.operations.mergeAndParse, {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(templateId)\r\n        .params({})\r\n        .context({\r\n          mergeDocumentId\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  mergeAndRenderTemplate(templateId, mergeDocumentId): Observable<any> {\r\n    return this.httpClient.post(`${this.environment.nuxeo}${this.environment.customAutomation}/${DocumentTemplatesConstants.operations.mergeAndRender}`,\r\n      {input: templateId, context: {mergeDocumentId}}, {responseType: 'blob'}\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  reflectTemplateToCorrespondence(correspondenceId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentTemplatesConstants.operations.reflectTemplateToCorrespondence, {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(correspondenceId)\r\n        .params({})\r\n        .context({\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/documents/services/documents.service.js

@@ -0,0 +1,246 @@
+import { EventEmitter, Inject, Injectable } from '@angular/core';
+import { combineLatest, from, ReplaySubject, Subject } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+import { DocumentsConstants } from '../constants/documents';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/services/nuxeo/nuxeo.service";
+import * as i2 from "../../../core/adapters/adapter.service";
+import * as i3 from "../../../configuration/app-config.service";
+/** @ignore */
+export class DocumentsService {
+    constructor(nuxeoService, documentsAdapter, configService, environment) {
+        this.nuxeoService = nuxeoService;
+        this.documentsAdapter = documentsAdapter;
+        this.configService = configService;
+        this.environment = environment;
+        this.value = new ReplaySubject(1);
+        this.getupdatedDocument = new EventEmitter();
+        this.reFetch = new Subject();
+        // setTimeout(() => {
+        this.incomingConstant =
+            this.configService.myConfiguration['correspondance']['incoming'];
+        // }, 2000);
+    }
+    informValue(value) {
+        let arr = [];
+        arr.push(value);
+        this.value.next(value);
+    }
+    getDocument(uid, headers) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers(Object.assign(Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'X-NXfetch-document': 'lock,dc:creator,corr:cc,cts_common:department,corr:owner', 'X-NXenrichers-document': 'tags,permissions' }), headers))
+            .fetch(uid)).pipe(map((data) => {
+            // i commented this since i am adapting in data coming inside the page not here
+            // return this.documentsAdapter.adaptIn(data, DocumentsConstants.fields);
+            delete data._nuxeo;
+            delete data._repository;
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    getDocumentAttachmentsWithAggregation(params = {}) {
+        return from(this.nuxeoService.nuxeoClient.repository().query(Object.assign({ pageProvider: DocumentsConstants.pageProvider.documentAttachmentsWithAggregation
+                .name }, params), {
+            headers: DocumentsConstants.pageProvider.documentAttachmentsWithAggregation
+                .headers,
+        })).pipe(map((data) => {
+            data.entries.map((item) => this.documentsAdapter.adaptIn(item, DocumentsConstants.fields));
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    updateDocument(doc, params = {}) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers(Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'fetch-document': 'lock,comm:committeeId,comm:meetingId' }))
+            .update(doc, params)).pipe(map((data) => {
+            return this.documentsAdapter.adaptIn(data, DocumentsConstants.fields);
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    createVersion(docId, version = 'major', customApi, customParams) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(customApi ? customApi : DocumentsConstants.operations.createVersion, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(docId)
+            .params(customParams ? customParams : { version, })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    createMemoVersion(docId, version = 'major') {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.createMemoVersion, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(docId)
+            .params({
+            version,
+        })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    getVersions(docId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.getVersions)
+            .input(docId)
+            .params()
+            .execute({
+            headers: DocumentsConstants.pageProvider.committee.headers,
+        })).pipe(map((data) => {
+            data.entries.map((item) => this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments));
+            return data;
+        }), catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    lockDocument(docId, mode) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.lock)
+            .input(docId)
+            .params({
+            mode: mode,
+        })
+            .execute({
+            headers: Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'X-NXfetch-document': 'lock,dc:creator,corr:owner,cts_common:department', 'X-NXenrichers-document': 'tags' }),
+        })).pipe(map((item) => {
+            return item;
+            //remove adapte since it is cousing conflicts when emiting out side and readapting again outside
+            // this.documentsAdapter.adaptIn(item, DocumentsConstants.fields)
+        }), catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    unlockDocument(docId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.unlock)
+            .input(docId)
+            .params()
+            .execute({
+            headers: Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'X-NXfetch-document': 'lock,dc:creator', 'X-NXenrichers-document': 'tags' }),
+        })).pipe(map((item) => {
+            return item;
+            //remove adapte since it is cousing conflicts when emiting out side and readapting again outside
+            // this.documentsAdapter.adaptIn(item, DocumentsConstants.fields)
+        }), catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    lockMemoDocument(docId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.lockMemo)
+            .input(docId)
+            .params()
+            .execute({
+            headers: Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'X-NXfetch-document': 'lock,dc:creator', 'X-NXenrichers-document': 'tags' }),
+        })).pipe(map(item => { return item; }), catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    unlockMemoDocument(docId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(DocumentsConstants.operations.unlockMemo)
+            .input(docId)
+            .params()
+            .execute({
+            headers: Object.assign(Object.assign({}, DocumentsConstants.pageProvider.committee.headers), { 'X-NXfetch-document': 'lock,dc:creator', 'X-NXenrichers-document': 'tags' }),
+        })).pipe(map(item => { return item; }), catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    deleteDocument(path) {
+        return from(this.nuxeoService.nuxeoClient.repository().delete(path)).pipe(catchError((err) => {
+            throw err;
+        }));
+    }
+    uploadBatch(files, extraHeaders = {}) {
+        return combineLatest([
+            ...files.map((file, idx) => {
+                const nuxeoBlob = this.nuxeoService.createBlob(file);
+                const fileName = file.name;
+                const batch = this.nuxeoService.nuxeoClient.batchUpload();
+                if (Object.keys(extraHeaders).length != 0) {
+                    // Custom upload with headers
+                    const getBatchId = () => {
+                        return this.nuxeoService.nuxeoClient._http({
+                            method: 'POST',
+                            url: `${this.environment.nuxeo}/api/v1/upload`,
+                        }).then((res) => res.batchId);
+                    };
+                    return from(getBatchId().then((batchId) => {
+                        const opts = {
+                            json: false,
+                            method: 'POST',
+                            url: `${this.environment.nuxeo}/api/v1/upload/${batchId}/${idx}`,
+                            body: nuxeoBlob.content,
+                            headers: Object.assign(Object.assign({}, extraHeaders), { 'Cache-Control': 'no-cache', 'X-File-Name': encodeURIComponent(nuxeoBlob.name), 'X-File-Size': nuxeoBlob.size, 'X-File-Type': nuxeoBlob.mimeType, 'Content-Length': nuxeoBlob.size, 'X-Batch-No-Drop': true }),
+                        };
+                        return this.nuxeoService.nuxeoClient._http(opts);
+                    }));
+                }
+                else {
+                    return from(this.nuxeoService.nuxeoClient.batchUpload().upload(nuxeoBlob));
+                }
+            })
+        ]).pipe(map((uploadedFiles) => {
+            files.forEach((file, i) => {
+                uploadedFiles[i].title = file.name;
+            });
+            return uploadedFiles;
+        }));
+    }
+    createDoc(uploadedFile, path, params, docParams = {}) {
+        const doc = Object.assign(Object.assign({ 'entity-type': 'document', name: uploadedFile.title, type: 'file' }, docParams), { properties: Object.assign({ title: uploadedFile.title, content: uploadedFile.blob }, params) });
+        const repo = this.nuxeoService.nuxeoClient.repository();
+        return from(repo.create(`${path}`, Object.assign(Object.assign({}, doc), { properties: this.documentsAdapter.adaptOut(doc.properties, DocumentsConstants.fields) })));
+    }
+    uploadDocument(file, path, params, docParams = {}) {
+        return this.uploadBatch(file).pipe(switchMap((uploadedFile) => {
+            return this.createDoc(uploadedFile, path, params, docParams).pipe(map((createdDocument) => createdDocument), catchError((err) => {
+                throw err;
+            }));
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    getDocuments(ancestorId, provider, params = {}) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            // .enricher('document', 'acls')
+            .query(Object.assign({ pageProvider: DocumentsConstants.pageProvider[provider].name, 
+            // ct_attachment_docRefId: ancestorId,
+            CtsCommon_correspondence: ancestorId }, params), {
+            headers: DocumentsConstants.pageProvider[provider].headers,
+        })).pipe(map((data) => {
+            data.entries.map((item) => this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments));
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+}
+DocumentsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsService, deps: [{ token: i1.NuxeoService }, { token: i2.AdapterService }, { token: i3.AppConfigService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+DocumentsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DocumentsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: i2.AdapterService }, { type: i3.AppConfigService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documents.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/documents/services/documents.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Inject, Injectable } from '@angular/core';\r\nimport { combineLatest, from, Observable, ReplaySubject, Subject } from 'rxjs';\r\nimport { catchError, map, switchMap } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../configuration/app-config.service';\r\nimport { AdapterService } from '../../../core/adapters/adapter.service';\r\nimport { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';\r\nimport { DocumentsConstants } from '../constants/documents';\r\n\r\n/** @ignore */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DocumentsService {\r\n  value = new ReplaySubject(1);\r\n  public getupdatedDocument = new EventEmitter();\r\n\r\n  reFetch = new Subject<boolean>();\r\n  incomingConstant;\r\n  constructor(\r\n    private nuxeoService: NuxeoService,\r\n    private documentsAdapter: AdapterService,\r\n    private configService: AppConfigService, @Inject('environment') private environment\r\n  ) {\r\n    // setTimeout(() => {\r\n    this.incomingConstant =\r\n      this.configService.myConfiguration['correspondance']['incoming'];\r\n    // }, 2000);\r\n  }\r\n\r\n  informValue(value) {\r\n    let arr = [];\r\n    arr.push(value);\r\n    this.value.next(value);\r\n  }\r\n  getDocument(uid, headers?) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          ...DocumentsConstants.pageProvider.committee.headers,\r\n          'X-NXfetch-document': 'lock,dc:creator,corr:cc,cts_common:department,corr:owner',\r\n          'X-NXenrichers-document': 'tags,permissions',\r\n          ...headers\r\n        })\r\n        .fetch(uid)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        // i commented this since i am adapting in data coming inside the page not here\r\n        // return this.documentsAdapter.adaptIn(data, DocumentsConstants.fields);\r\n        delete data._nuxeo;\r\n        delete data._repository;\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  getDocumentAttachmentsWithAggregation(params = {}): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient.repository().query(\r\n        {\r\n          pageProvider:\r\n            DocumentsConstants.pageProvider.documentAttachmentsWithAggregation\r\n              .name,\r\n          ...params,\r\n        },\r\n        {\r\n          headers:\r\n            DocumentsConstants.pageProvider.documentAttachmentsWithAggregation\r\n              .headers,\r\n        }\r\n      )\r\n    ).pipe(\r\n      map((data: any) => {\r\n        data.entries.map((item) =>\r\n          this.documentsAdapter.adaptIn(item, DocumentsConstants.fields)\r\n        );\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  updateDocument(doc, params = {}) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          ...DocumentsConstants.pageProvider.committee.headers,\r\n          'fetch-document': 'lock,comm:committeeId,comm:meetingId',\r\n        })\r\n        .update(doc, params)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        return this.documentsAdapter.adaptIn(data, DocumentsConstants.fields);\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  createVersion(docId, version = 'major', customApi?, customParams?): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(customApi ? customApi : DocumentsConstants.operations.createVersion, {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(docId)\r\n        .params(customParams ? customParams : { version, })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  createMemoVersion(docId, version = 'major'): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.createMemoVersion, {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .input(docId)\r\n        .params({\r\n          version,\r\n        })\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  getVersions(docId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.getVersions)\r\n        .input(docId)\r\n        .params()\r\n        .execute({\r\n          headers: DocumentsConstants.pageProvider.committee.headers,\r\n        })\r\n    ).pipe(\r\n      map((data: any) => {\r\n        data.entries.map((item) =>\r\n          this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments)\r\n        );\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  lockDocument(docId, mode): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.lock)\r\n        .input(docId)\r\n        .params({\r\n          mode: mode,\r\n        })\r\n        .execute({\r\n          headers: {\r\n            ...DocumentsConstants.pageProvider.committee.headers,\r\n            'X-NXfetch-document': 'lock,dc:creator,corr:owner,cts_common:department',\r\n            'X-NXenrichers-document': 'tags',\r\n          },\r\n        })\r\n    ).pipe(\r\n      map((item) => {\r\n        return item\r\n        //remove adapte since it is cousing conflicts when emiting out side and readapting again outside\r\n        // this.documentsAdapter.adaptIn(item, DocumentsConstants.fields)\r\n      }\r\n      ),\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  unlockDocument(docId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.unlock)\r\n        .input(docId)\r\n        .params()\r\n        .execute({\r\n          headers: {\r\n            ...DocumentsConstants.pageProvider.committee.headers,\r\n            'X-NXfetch-document': 'lock,dc:creator',\r\n            'X-NXenrichers-document': 'tags',\r\n          },\r\n        })\r\n    ).pipe(\r\n      map((item) => {\r\n        return item;\r\n        //remove adapte since it is cousing conflicts when emiting out side and readapting again outside\r\n        // this.documentsAdapter.adaptIn(item, DocumentsConstants.fields)\r\n      }\r\n      ),\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  lockMemoDocument(docId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.lockMemo)\r\n        .input(docId)\r\n        .params()\r\n        .execute({\r\n          headers: {\r\n            ...DocumentsConstants.pageProvider.committee.headers,\r\n            'X-NXfetch-document': 'lock,dc:creator',\r\n            'X-NXenrichers-document': 'tags',\r\n          },\r\n        })\r\n    ).pipe(\r\n      map(item => { return item }),\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  unlockMemoDocument(docId): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation(DocumentsConstants.operations.unlockMemo)\r\n        .input(docId)\r\n        .params()\r\n        .execute({\r\n          headers: {\r\n            ...DocumentsConstants.pageProvider.committee.headers,\r\n            'X-NXfetch-document': 'lock,dc:creator',\r\n            'X-NXenrichers-document': 'tags',\r\n          },\r\n        })\r\n    ).pipe(\r\n      map(item => { return item }),\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  deleteDocument(path: any) {\r\n    return from(this.nuxeoService.nuxeoClient.repository().delete(path)).pipe(\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  uploadBatch(files, extraHeaders = {}): Observable<any> {\r\n    return combineLatest([\r\n      ...files.map((file,idx) => {\r\n        const nuxeoBlob = this.nuxeoService.createBlob(file);\r\n        const fileName = file.name;\r\n        const batch = this.nuxeoService.nuxeoClient.batchUpload();\r\n        if (Object.keys(extraHeaders).length != 0) {\r\n          // Custom upload with headers\r\n          \r\n          const getBatchId = () => {\r\n            return this.nuxeoService.nuxeoClient._http({\r\n              method: 'POST',\r\n              url: `${this.environment.nuxeo}/api/v1/upload`,\r\n            }).then((res: any) => res.batchId);\r\n          };\r\n          \r\n          return from(\r\n            getBatchId().then((batchId) => {\r\n              const opts = {\r\n                json: false,\r\n                method: 'POST',\r\n                url: `${this.environment.nuxeo}/api/v1/upload/${batchId}/${idx}`,\r\n                body: nuxeoBlob.content,\r\n                headers: {\r\n                  ...extraHeaders,\r\n                  'Cache-Control': 'no-cache',\r\n                  'X-File-Name': encodeURIComponent(nuxeoBlob.name),\r\n                  'X-File-Size': nuxeoBlob.size,\r\n                  'X-File-Type': nuxeoBlob.mimeType,\r\n                  'Content-Length': nuxeoBlob.size,\r\n                  'X-Batch-No-Drop': true,\r\n                },\r\n              };\r\n              return this.nuxeoService.nuxeoClient._http(opts);\r\n            })\r\n          );\r\n        } else {\r\n          return from(\r\n            this.nuxeoService.nuxeoClient.batchUpload().upload(nuxeoBlob)\r\n          );\r\n        }\r\n      })\r\n    ]).pipe(\r\n      map((uploadedFiles: any[]) => {\r\n        files.forEach((file, i) => {\r\n          uploadedFiles[i].title = file.name;\r\n        });\r\n        return uploadedFiles;\r\n      })\r\n    );\r\n  }\r\n\r\n  createDoc(uploadedFile, path, params, docParams = {}) {\r\n    const doc = {\r\n      'entity-type': 'document',\r\n      name: uploadedFile.title,\r\n      type: 'file',\r\n      ...docParams,\r\n      properties: {\r\n        title: uploadedFile.title,\r\n        content: uploadedFile.blob,\r\n        ...params,\r\n      },\r\n    };\r\n\r\n    const repo = this.nuxeoService.nuxeoClient.repository();\r\n    return from(\r\n      repo.create(`${path}`, {\r\n        ...doc,\r\n        properties: this.documentsAdapter.adaptOut(\r\n          doc.properties,\r\n          DocumentsConstants.fields\r\n        ),\r\n      })\r\n    );\r\n  }\r\n  uploadDocument(file, path, params, docParams = {}): Observable<any> {\r\n    return this.uploadBatch(file).pipe(\r\n      switchMap((uploadedFile) => {\r\n        return this.createDoc(uploadedFile, path, params, docParams).pipe(\r\n          map((createdDocument) => createdDocument),\r\n          catchError((err) => {\r\n            throw err;\r\n          })\r\n        );\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  getDocuments(ancestorId, provider, params = {}): Observable<any> {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        // .enricher('document', 'acls')\r\n        .query(\r\n          {\r\n            pageProvider: DocumentsConstants.pageProvider[provider].name,\r\n            // ct_attachment_docRefId: ancestorId,\r\n            CtsCommon_correspondence: ancestorId,\r\n            ...params,\r\n          },\r\n          {\r\n            headers: DocumentsConstants.pageProvider[provider].headers,\r\n          }\r\n        )\r\n    ).pipe(\r\n      map((data: any) => {\r\n        data.entries.map((item) =>\r\n          this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments)\r\n        );\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}