nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/components/documents/services/documents.service.ts

@@ -0,0 +1,354 @@
+import { EventEmitter, 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 { DocumentsConstants } from '../constants/documents';
+
+/** @ignore */
+@Injectable({
+  providedIn: 'root',
+})
+export class DocumentsService {
+  value = new ReplaySubject(1);
+  public getupdatedDocument = new EventEmitter();
+
+  reFetch = new Subject<boolean>();
+  incomingConstant;
+  constructor(
+    private nuxeoService: NuxeoService,
+    private documentsAdapter: AdapterService,
+    private configService: AppConfigService, @Inject('environment') private environment
+  ) {
+    // 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({
+          ...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: any) => {
+        // 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 = {}): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient.repository().query(
+        {
+          pageProvider:
+            DocumentsConstants.pageProvider.documentAttachmentsWithAggregation
+              .name,
+          ...params,
+        },
+        {
+          headers:
+            DocumentsConstants.pageProvider.documentAttachmentsWithAggregation
+              .headers,
+        }
+      )
+    ).pipe(
+      map((data: any) => {
+        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({
+          ...DocumentsConstants.pageProvider.committee.headers,
+          'fetch-document': 'lock,comm:committeeId,comm:meetingId',
+        })
+        .update(doc, params)
+    ).pipe(
+      map((data: any) => {
+        return this.documentsAdapter.adaptIn(data, DocumentsConstants.fields);
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+  createVersion(docId, version = 'major', customApi? , customParams?): Observable<any> {
+    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'): Observable<any> {
+    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): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(DocumentsConstants.operations.getVersions)
+        .input(docId)
+        .params()
+        .execute({
+          headers: DocumentsConstants.pageProvider.committee.headers,
+        })
+    ).pipe(
+      map((data: any) => {
+        data.entries.map((item) =>
+          this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments)
+        );
+        return data;
+      }),
+      catchError((err) => {
+        console.log(err);
+        throw err;
+      })
+    );
+  }
+  lockDocument(docId, mode): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(DocumentsConstants.operations.lock)
+        .input(docId)
+        .params({
+          mode: mode,
+        })
+        .execute({
+          headers: {
+            ...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): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(DocumentsConstants.operations.unlock)
+        .input(docId)
+        .params()
+        .execute({
+          headers: {
+            ...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): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(DocumentsConstants.operations.lockMemo)
+        .input(docId)
+        .params()
+        .execute({
+          headers: {
+            ...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): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(DocumentsConstants.operations.unlockMemo)
+        .input(docId)
+        .params()
+        .execute({
+          headers: {
+            ...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: any) {
+    return from(this.nuxeoService.nuxeoClient.repository().delete(path)).pipe(
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+
+  uploadBatch(files): Observable<any> {
+    return combineLatest([
+      ...files.map((file) => {
+        const nuxeoBlob = this.nuxeoService.createBlob(file);
+        return from(
+          this.nuxeoService.nuxeoClient.batchUpload().upload(nuxeoBlob)
+        );
+      }),
+    ]).pipe(
+      map((uploadedFiles: any) => {
+        files.forEach((file, i) => {
+          uploadedFiles[i].title = file.name;
+        });
+        return uploadedFiles;
+      })
+    );
+  }
+  createDoc(uploadedFile, path, params, docParams = {}) {
+    const doc = {
+      'entity-type': 'document',
+      name: uploadedFile.title,
+      type: 'file',
+      ...docParams,
+      properties: {
+        title: uploadedFile.title,
+        content: uploadedFile.blob,
+        ...params,
+      },
+    };
+
+    const repo = this.nuxeoService.nuxeoClient.repository();
+    return from(
+      repo.create(`${path}`, {
+        ...doc,
+        properties: this.documentsAdapter.adaptOut(
+          doc.properties,
+          DocumentsConstants.fields
+        ),
+      })
+    );
+  }
+  uploadDocument(file, path, params, docParams = {}): Observable<any> {
+    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 = {}): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        // .enricher('document', 'acls')
+        .query(
+          {
+            pageProvider: DocumentsConstants.pageProvider[provider].name,
+            // ct_attachment_docRefId: ancestorId,
+            CtsCommon_correspondence: ancestorId,
+            ...params,
+          },
+          {
+            headers: DocumentsConstants.pageProvider[provider].headers,
+          }
+        )
+    ).pipe(
+      map((data: any) => {
+        data.entries.map((item) =>
+          this.documentsAdapter.adaptIn(item, this.incomingConstant.attachments)
+        );
+        return data;
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+}

package/src/lib/components/dynamic-chart/dynamic-chart/dynamic-chart.component.html

@@ -0,0 +1,26 @@
+<div class="card-continer" *ngIf="card; else test">
+  <div class="chart-card-header">
+    <div class="chart-card-title">{{ cardTitle | translate }}</div>
+    <button class="chart-card-button" (click)="previewCorrespondences()">
+      {{ "report.Preview" | translate }}
+    </button>
+  </div>
+  <ng-container *ngIf="isFetching">
+    <cts-spinner></cts-spinner>
+  </ng-container>
+  <div class="stat" [style.height.px]="height">
+    <div [hidden]="data.data?.length == 0 || data.length == 0">
+      <canvas #revenueLineChart [height]="height" [width]="width"></canvas>
+    </div>
+    <div class="no-stats" *ngIf="data.data?.length == 0 || data.length == 0">
+      <span>{{ "STATS.noData" | translate }}</span>
+    </div>
+  </div>
+</div>
+
+<ng-template #test>
+  <div class="stat">
+    <canvas #revenueLineChart [height]="height" [width]="width"></canvas>
+  </div>
+</ng-template>
+

package/src/lib/components/dynamic-chart/dynamic-chart/dynamic-chart.component.scss

@@ -0,0 +1,35 @@
+@import "../../../assets/scss/myApp.scss";
+.no-stats {
+  width: 100%;
+  height: 100%;
+  display: grid;
+  place-items: center;
+}
+.card-continer {
+  background: $white;
+  border-radius: 5px;
+  width: 100%;
+  padding: 16px 20px;
+  box-shadow: 0px 1px 1px #00000017;
+  .chart-card-header {
+    .chart-card-title {
+      font-weight: 500;
+    }
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    .chart-card-button {
+      all: unset;
+      background: #3341551a;
+      color: $gray-500;
+      padding: 6px 18px;
+      border-radius: 24px;
+      font-size: 16px;
+      cursor: pointer;
+      &:hover {
+        background: $gray-300;
+        color: $white;
+      }
+    }
+  }
+}

package/src/lib/components/dynamic-chart/dynamic-chart/dynamic-chart.component.spec.ts

@@ -0,0 +1,25 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { DynamicChartComponent } from './dynamic-chart.component';
+
+describe('DynamicChartComponent', () => {
+  let component: DynamicChartComponent;
+  let fixture: ComponentFixture<DynamicChartComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ DynamicChartComponent ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(DynamicChartComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});