nuxeo-development-framework 3.0.9 → 3.1.2

package/src/lib/components/documents/components/document-scan/document-scan.service.ts

@@ -0,0 +1,26 @@
+import { Injectable, Output , EventEmitter } from '@angular/core';
+import { DocumentsService } from '../../services/documents.service';
+import { map } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentScanService {
+
+  fileChange = new EventEmitter();
+  uploadStart = new EventEmitter();
+  onMinimizing = new EventEmitter();
+
+  storedFile;
+  constructor(private documentsService : DocumentsService) { }
+
+  uploadBatch(fileToUpload){
+    return this.documentsService.uploadBatch([fileToUpload]).pipe(map((batch) => {
+      batch.forEach(doc => {
+        this.fileChange.emit(doc);
+        this.uploadStart.emit(false)
+      });
+      return batch
+    }));
+  }
+}

package/src/lib/components/documents/components/document-upload/document-upload.component.html

@@ -0,0 +1,19 @@
+<input type="file" class="hidden" #fileInput [accept]="allowedTypes" [multiple]="multiple"
+  (change)="uploadDocument($event.target.files)">
+<div #template [ngClass]="{'hidden': template.childNodes.length == 0}" (click)="triggerUpload()"
+  class="upload-container">
+  <ng-content></ng-content>
+</div>
+<div *ngIf="template.childNodes.length == 0" class="default-upload" (click)="triggerUpload()">
+  <div class="upload-section" style="color:#465573;">
+    <mat-icon class="upload-icon">upload</mat-icon>
+    <h3 class="upload-title">
+      {{'documents.uploadDocuments'| translate }}</h3>
+    <p class="upload-desc">
+      {{'documents.maxSize'| translate }} {{maxSize | FileSize}}</p>
+  </div>
+  <div>
+    <mat-icon class="m-2" style="color:#465573;">file_copy</mat-icon>
+  </div>
+</div>
+<mat-progress-bar mode="indeterminate" *ngIf="uploading"></mat-progress-bar>

package/src/lib/components/documents/components/document-upload/document-upload.component.scss

@@ -0,0 +1,49 @@
+@import "../../../../assets/scss/myApp.scss";
+.upload-container {
+  display: flex;
+  flex: 1;
+  justify-content: space-between;
+  cursor: pointer;
+  width: 100%;
+  height: 100%;
+}
+.default-upload {
+  display: flex;
+  padding: 8px 16px;
+  flex: 1;
+  justify-content: space-between;
+  background: $purple-200;
+  cursor: pointer;
+}
+.upload-section {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  justify-content: space-between;
+}
+.upload-icon {
+  margin: 0 8px;
+}
+.upload-title {
+  font-size: $text-base;
+  border-color: $gray-500;
+  border-left: 1px solid;
+  padding-left: 8px;
+  margin: 0px;
+}
+.rtl .upload-title {
+  border-left: 0px;
+  border-right: 1px solid;
+  padding-left: 0px;
+  padding-right: 8px;
+}
+.upload-desc {
+  font-size: $text-sm;
+  padding-left: 8px;
+  opacity: 0.6;
+  margin: 0px;
+}
+.rtl .upload-desc {
+  padding-left: 0px;
+  padding-right: 8px;
+}

package/src/lib/components/documents/components/document-upload/document-upload.component.ts

@@ -0,0 +1,168 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';
+import { DocumentsService } from '../../services/documents.service';
+
+/**
+ * Document upload is a reusable API integrated upload button component,
+ * that can be configured to suit the needs of required implementation,
+ * it is possible to upload batch and create a document, or just upload a batch and
+ * consume it any other way.
+ *
+ * @title
+ * Document Upload
+ *
+ * @example
+ *
+ * <app-document-upload
+ *   [allowedTypes]="'application/pdf'"
+ *   [createDocument]="false"
+ *   (uploadSuccess)="onUploadSuccess($event)"
+ *   (uploadError)="onUploadError($event)"
+ * >
+ *   <button> UPLOAD FILE </button>
+ * </app-document-upload>
+ */
+@Component({
+  selector: 'app-document-upload',
+  templateUrl: './document-upload.component.html',
+  styleUrls: ['./document-upload.component.scss'],
+  encapsulation: ViewEncapsulation.None
+})
+export class DocumentUploadComponent {
+  /** Allowed Upload Types */
+  @Input()
+  allowedTypes = 'application/pdf,application/vnd.ms-powerpoint,application/vnd.openxmlformats-officedocument.presentationml.presentation';
+  /** Params to be sent with properties when creating a document */
+  @Input()
+  params = {};
+  /** Path in witch a document will be created */
+  @Input()
+  path;
+  /** Max allowed upload size */
+  @Input()
+  maxSize = 1145728;
+  /** Params to be sent with body when creating a document */
+  @Input()
+  docParams = {};
+  /** Can upload multiple files at once */
+  @Input()
+  multiple = false;
+  /** should create document after batch upload */
+  @Input()
+  createDocument = true;
+  /** Max allowed number of files size */
+  @Input()
+  allowedMaxNumberOfFiles = 10;
+  /** Event emitted on document upload success, it will have document or batch object based on configuration */
+  @Output()
+  uploadSuccess = new EventEmitter();
+  /** Event emitted when an error occurs while attempting upload */
+  @Output()
+  uploadError = new EventEmitter();
+  uploading = false;
+  @ViewChild('fileInput') fileInput;
+
+  constructor(
+    private documentsApi: DocumentsService,
+    private customToastrService: CustomToastrService
+  ) { }
+
+  triggerUpload(): void {
+    this.fileInput.nativeElement.click();
+  }
+
+  isSizeChecked(file) {
+    if (file.size <= this.maxSize) {
+      return true;
+    }
+    else
+      this.customToastrService.show(
+        'error',
+        'error',
+        'ERRORS.SIZE',
+        {},
+        `${(this.maxSize / (1024 * 1024)).toFixed(2)}MB` 
+      );
+    this.uploadError.next('errors.size');
+    return false;
+  }
+
+  isTypeChecked(file) {
+    let arr = this.allowedTypes.split(',');
+    if (arr.indexOf(file.type) > -1)
+      return true
+    else {
+      this.customToastrService.show(
+        'error',
+        'error',
+        'ERRORS.TYPE',
+        {},
+        this.allowedTypes.replace(/image|application/gi, '').replace(/[/]/g, '').toUpperCase()
+      );
+      this.uploadError.next('errors.type');
+      return false;
+    }
+  }
+
+  isMaxNumberOfFiles(selectedFiles) {
+    if (selectedFiles.length <= this.allowedMaxNumberOfFiles)
+      return true
+    else {
+      this.customToastrService.show(
+        'error',
+        'error',
+        'ERRORS.MAX_NUMBER_OF_FILES',
+        {},
+        this.allowedMaxNumberOfFiles
+      );
+      this.uploadError.next('errors.maxNumberOfFiles');
+      return false;
+    }
+  }
+
+  uploadDocument(files): void {
+    let selectedFiles = Object.keys(files).map(key => files[key]);
+    selectedFiles = selectedFiles.filter(file => {
+      if (this.isMaxNumberOfFiles(selectedFiles)) {
+        if (this.isSizeChecked(file) && this.isTypeChecked(file)) {
+          return file;
+        }
+      }
+    });
+    if (selectedFiles.length) {
+      this.uploading = true;
+
+      this.documentsApi.uploadBatch(selectedFiles)
+        .subscribe((files) => {
+          if (this.createDocument) {
+            combineLatest([
+              ...files.map((file) => this.documentsApi.createDoc(file, this.path, this.params, this.docParams))
+            ]).subscribe(docs => {
+              docs.forEach(doc => {
+                this.uploadSuccess.next(doc);
+              });
+              this.uploading = false;
+              this.fileInput.nativeElement.value = '';
+            });
+          } else {
+            files.forEach(doc => {
+              this.uploadSuccess.next(doc);
+            });
+            this.uploading = false;
+            this.fileInput.nativeElement.value = '';
+          }
+
+
+        }, (err) => {
+          this.uploadError.next(err);
+          this.uploading = false;
+          this.fileInput.nativeElement.value = '';
+        });
+    }
+
+  }
+
+
+
+}

package/src/lib/components/documents/components/documents/documents.component.html

@@ -0,0 +1,16 @@
+<app-card>
+  <h3 class="title text-lg font-bold">
+    {{ "documents.title" | translate }}
+  </h3>
+
+
+  <div class="body">
+    <app-document-upload [multiple]="multiple" *appHasRole="canUploadRoles" [docParams]="{type:documentConstants.documentTypes.attachment}"
+      [path]="this.path" [params]="this.params" (uploadSuccess)="onSuccess($event)" (uploadError)="onError($event)">
+    </app-document-upload>
+    <app-documents-list [quickFilters]="quickFilters" [notifier]="notifier" [ancestorId]="ancestorId"
+      [provider]="provider" (deleteSuccess)="onDelete($event)">
+    </app-documents-list>
+
+  </div>
+</app-card>

package/src/lib/components/documents/components/documents/documents.component.ts

@@ -0,0 +1,49 @@
+import { Component, EventEmitter, Input } from '@angular/core';
+import { delay, take } from 'rxjs/operators';
+import { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';
+import { DocumentsConstants } from '../../constants/documents';
+
+/** @ignore */
+@Component({
+  selector: 'app-documents',
+  templateUrl: './documents.component.html',
+  styleUrls: ['./documents.component.scss'],
+})
+export class DocumentsComponent {
+  @Input()
+  ancestorId;
+  @Input()
+  quickFilters;
+  @Input()
+  params = {};
+  @Input()
+  provider;
+  @Input()
+  path;
+  @Input()
+  canUploadRoles = null;
+  @Input()
+  multiple = false;
+  @Input()
+  maxSize = 3145728;
+  items = [];
+  isFetching = false;
+  uploading = false;
+  notifier = new EventEmitter();
+  documentConstants = DocumentsConstants;
+  constructor(private toastr: CustomToastrService) { }
+
+  onError(error): void {
+    this.toastr.show('error', 'error',
+      error.ret.message ?
+        `errors.${error.ret.code}`
+        : 'genericError');
+  }
+  onSuccess(files): void {
+    this.toastr.show('success', 'success', 'documents.addSuccess');
+    this.notifier.next();
+  }
+  onDelete(event): void {
+    this.toastr.show('success', 'success', 'documents.deleteSuccess');
+  }
+}

package/src/lib/components/documents/constants/document-templates.ts

@@ -0,0 +1,32 @@
+export class DocumentTemplatesConstants {
+  public static pageProvider = {
+    documentTemplates: {
+      name: 'PP_CTDocumentTemplates',
+      headers: {
+        'X-NXproperties': '*'
+      },
+      constants: {
+        systemPathParamName: 'system_path',
+        systemPathParamDefaultValue: '/default-domain/workspaces/CTS/CTS Templates',
+      }
+    },
+  };
+  public static operations = {
+    parse: 'AC_UA_ParseTemplateDocument',
+    render: 'AC_UA_RenderTemplateDocument',
+    mergeAndParse: 'AC_UA_MergeAndParseTemplateDocument',
+    mergeAndRender: 'AC_UA_MergeAndRenderTemplateDocument',
+    reflectTemplateToCorrespondence: 'AC_UA_ReflectTemplateToCorrespondence'
+  };
+  public static quickFilters = {
+  };
+  public static vocabulary = {editorSidebarVoc: 'VOC_DocumentEditorCorrespondenceFields'};
+  public static fields = {
+    creator: 'dc:creator',
+    content: 'file:content',
+    title: 'dc:title',
+    created: 'dc:created',
+    major_version: 'uid:major_version',
+    minor_version: 'uid:minor_version',
+  };
+}

package/src/lib/components/documents/constants/documents.ts

@@ -0,0 +1,85 @@
+export class DocumentsConstants {
+  public static pageProvider = {
+    meeting: {
+      name: 'PP_Meeting_CTDocuments',
+      headers: { 'X-NXproperties': '*' },
+    },
+    committee: {
+      name: 'PP_Committee_CTDocuments',
+      headers: {
+        'X-NXproperties': '*',
+        'X-NXfetch-document': 'dc:creator,dc:lastContributor,dc:contributors',
+      },
+    },
+    agendaItem: {
+      name: 'PP_AgendaItem_CTDocuments',
+      headers: { 'X-NXproperties': '*' },
+    },
+    meetingAgenda: {
+      name: 'PP_Meeting_AgendaDocuments',
+      headers: { 'X-NXproperties': '*' },
+    },
+    meetingMom: {
+      name: 'PP_Meeting_MoMDocuments',
+      headers: { 'X-NXproperties': '*' },
+    },
+    documentAttachments: {
+      name: 'PP_Document_Attachments',
+      headers: { 'X-NXproperties': '*' },
+    },
+    documentAttachmentsWithAggregation: {
+      name: 'PP_CTAttachment',
+      headers: {
+        'properties': '*',
+        'fetch-document': 'properties',
+        'fetch-aggregate': 'key',
+        'translate-directoryEntry':'label'
+      },
+    },
+    correspondenceAttachments: {
+      name: 'PP_CorrespondenceAttachments',
+      headers: {
+        'properties': '*',
+        'fetch-document': 'properties',
+        'fetch-aggregate': 'key',
+        'translate-directoryEntry':'label'
+      },
+    },
+  };
+  public static documentTypes = {
+    attachment: 'CTAttachment',
+    agendaDocument: 'AgendaDocument',
+    MoMDocument: 'MoMDocument',
+  };
+  public static operations = {
+    createVersion: 'AC_UA_CTS_Version_Create',
+    createMemoVersion : 'AC_UA_Version_Create',
+    getVersions: 'Document.GetVersions',
+    lock: 'AC_UA_Document_Lock',
+    lockMemo: 'Document.Lock',
+    unlock: 'AC_UA_Document_Unlock',
+    unlockMemo: 'Document.Unlock'
+  };
+  public static quickFilters = {
+    resolution: 'Resolution',
+    committee: 'Committee',
+    task: 'Workflow',
+  };
+  public static vocabulary = {};
+  public static fields = {
+    creator: 'dc:creator',
+    content: 'file:content',
+    title: 'dc:title',
+    created: 'dc:created',
+    docRefId: 'ct_attach:docRefId',
+    docRefTypes: 'ct_attach:docRefTypes',
+    committeeName: 'comm:committeeName',
+    meetingId: 'comm:meetingId',
+    committeeId: 'comm:committeeId',
+    committeeCode: 'comm:committeeCode',
+    meetingCode: 'comm:meetingCode',
+    thumbnail: 'thumb:thumbnail',
+    major_version: 'uid:major_version',
+    minor_version: 'uid:minor_version',
+  };
+}

package/src/lib/components/documents/documents.module.ts

@@ -0,0 +1,69 @@
+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';
+
+/**
+ * @title
+ * Documents Module
+ */
+@NgModule({
+  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: [],
+})
+export class DocumentsModule { }

package/src/lib/components/documents/services/document-templates.service.ts

@@ -0,0 +1,155 @@
+import { Inject, Injectable } from '@angular/core';
+import { combineLatest, from, Observable, ReplaySubject, Subject } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+import { AppConfigService } from '../../../configuration/app-config.service';
+import { AdapterService } from '../../../Core/adapters/adapter.service';
+import { NuxeoService } from '../../../Core/services/nuxeo/nuxeo.service';
+import {DocumentTemplatesConstants} from '../constants/document-templates';
+import {DocumentsConstants} from '../constants/documents';
+import {HttpClient} from '@angular/common/http';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class DocumentTemplatesService {
+  value = new ReplaySubject(1);
+  reFetch = new Subject<boolean>();
+  // templatesRootPath = '';
+  constructor(
+    private nuxeoService: NuxeoService,
+    private documentsAdapter: AdapterService,
+    private httpClient: HttpClient,
+    @Inject('environment') private environment
+  ) {
+  }
+
+  informValue(value): void {
+    const arr = [];
+    arr.push(value);
+    this.value.next(value);
+  }
+  getDocumentTemplate(uid): Observable<any>  {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        .headers({
+          ...DocumentTemplatesConstants.pageProvider.documentTemplates.headers,
+          'X-NXfetch-document': 'lock,dc:creator',
+          'X-NXenrichers-document': 'tags',
+        })
+        .fetch(uid)
+    ).pipe(
+      map((data: any) => {
+        return this.documentsAdapter.adaptIn(data, DocumentTemplatesConstants.fields);
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+  getDocumentTemplatesWithAggregation(params = {}): Observable<any> {
+    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(
+        {
+          pageProvider:
+          DocumentTemplatesConstants.pageProvider.documentTemplates.name,
+          ...params,
+        },
+        {
+          headers:
+          DocumentTemplatesConstants.pageProvider.documentTemplates.headers,
+        }
+      )
+    ).pipe(
+      map((data: any) => {
+        data.entries.map((item) =>
+          this.documentsAdapter.adaptIn(item, DocumentTemplatesConstants.fields)
+        );
+        return data;
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+  parseTemplate(templateId): Observable<any> {
+    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): Observable<any> {
+    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): Observable<any> {
+    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): Observable<any> {
+    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): Observable<any> {
+    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;
+      })
+    );
+  }
+}