nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/components/correspondence-relation/components/versions/versions.component.js

@@ -0,0 +1,119 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/viewer-files.service";
+import * as i2 from "../../../../core/services/translation/translation.service";
+import * as i3 from "../../../documents/services/documents.service";
+import * as i4 from "@angular/material/list";
+import * as i5 from "../../../../shared/components/item-list/item-list.component";
+import * as i6 from "@angular/material/progress-spinner";
+import * as i7 from "../../../../shared/components/no-data/no-data.component";
+import * as i8 from "@angular/common";
+import * as i9 from "../../../../directive/permissions/permissions.directive";
+import * as i10 from "@ngx-translate/core";
+import * as i11 from "../../../../pipes/localized-date.pipe";
+/**
+ * A component that views document versions
+ * @title
+ * Viewer Versions
+ *
+ * @example
+ *
+ * <cts-versions
+ *   [file]="file"
+ *   [actions]="menu_actions"
+ *   (handleActions)="handleActionOnVersion($event)"
+ * ></cts-versions>
+ */
+export class VersionsComponent {
+    constructor(viewerFilesService, trnaslationService, documentsApi) {
+        this.viewerFilesService = viewerFilesService;
+        this.trnaslationService = trnaslationService;
+        this.documentsApi = documentsApi;
+        this.currentTranslation = 'viewer.current';
+        this.originTranslation = 'viewer.origin';
+        this.historyTranslation = 'viewer.history';
+        this.showUserCard = false; // flage to show user cards
+        this.handleActions = new EventEmitter();
+        this.versions = [];
+        this.isArabic = false;
+        this.fetching = false;
+    }
+    ngOnChanges(changes) {
+        if (changes.file && changes.file.currentValue &&
+            changes.file.previousValue) {
+            this.getVersions();
+        }
+    }
+    ngOnInit() {
+        this.langSubscription = this.trnaslationService.isArabic$.subscribe(res => {
+            this.isArabic = res;
+        });
+        this.getVersions();
+    }
+    getVersion(version) {
+        let majVer = version.properties.major_version ? version.properties.major_version : (version.properties['uid:major_version'] ? version.properties['uid:major_version'] : 0);
+        let minVer = version.properties.minor_version ? version.properties.minor_version : (version.properties['uid:minor_version'] ? version.properties['uid:minor_version'] : 0);
+        return `${majVer}.${minVer}`;
+    }
+    getVersions() {
+        this.fetching = true;
+        this.documentsApi.getVersions(this.file.uid).subscribe((data) => {
+            this.versions = data.entries.reverse();
+            this.fetching = false;
+            // this.versions.shift();
+            this.fetching = false;
+        }, err => {
+            this.fetching = false;
+        });
+    }
+    showVersion(version) {
+        this.viewerFilesService.updateViewer.next(version);
+    }
+    getFileSize(version) {
+        let file = version.properties['file:content'] || version.properties.content;
+        if (file && file.length) {
+            let length = +file.length;
+            if (length < 1000000) {
+                // trnasfer to KB
+                return (length / 1000).toFixed(2) + 'KB';
+            }
+            else {
+                // transafer to MB
+                return (length / (1000000)).toFixed(2) + 'MB';
+            }
+        }
+    }
+    handleAction(event) {
+        this.handleActions.emit(event);
+    }
+    ngOnDestroy() {
+        this.langSubscription ? this.langSubscription.unsubscribe() : null;
+    }
+}
+VersionsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VersionsComponent, deps: [{ token: i1.ViewerFilesService }, { token: i2.TranslationService }, { token: i3.DocumentsService }], target: i0.ɵɵFactoryTarget.Component });
+VersionsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VersionsComponent, selector: "cts-versions", inputs: { selectedVersion: "selectedVersion", file: "file", actions: "actions", currentTranslation: "currentTranslation", originTranslation: "originTranslation", historyTranslation: "historyTranslation", showUserCard: "showUserCard" }, outputs: { handleActions: "handleActions" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"flex flex-col\">\r\n<div class=\"viewer-attachments\">\r\n  <div class=\"subheader\">\r\n    <div> {{ currentTranslation | translate }}</div>\r\n\r\n  </div>\r\n  <div class=\"attachments-list\">\r\n    <mat-list>\r\n      <div class=\"mat-list-items\">\r\n        <cts-item-list [item]=\"file\" [title]=\"file.title\" [iconname]=\"'description'\" [moreclasses]=\"'text-danger'\"\r\n          [actions]=\"actions\" (itemClicked)=\"showVersion(file)\" (actionclicked)=\"handleAction($event)\">\r\n          <div class=\"description\">\r\n            <div class=\"file-size\">\r\n              {{ getFileSize(file)}}\r\n             </div>\r\n            {{getVersion(file)}}\r\n            -\r\n            {{ file.lastModified | localizedDate : '' : (isArabic? 'ar-AR' : 'en-US') }}\r\n          </div>\r\n        </cts-item-list>\r\n      </div>\r\n    </mat-list>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"viewer-attachments original-section\" *ngIf=\"versions.length > 0\" >\r\n  <div class=\"subheader\">\r\n    <div>{{ originTranslation | translate }}</div>\r\n  </div>\r\n  <div class=\"attachments-list\">\r\n    <mat-list>\r\n      <div class=\"mat-list-items\">\r\n        <cts-item-list [item]=\"versions[versions.length -1]\" [title]=\"versions[versions.length -1].title\"\r\n          [iconname]=\"'description'\" [moreclasses]=\"'text-danger'\" [actions]=\"actions\"\r\n          (itemClicked)=\"showVersion(versions[versions.length -1])\" (actionclicked)=\"handleAction($event)\">\r\n\r\n        </cts-item-list>\r\n      </div>\r\n    </mat-list>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"viewer-attachments\" [ngClass]=\"{'viewer-attachment-with-user-card' : showUserCard}\" *permission=\"{name: 'viewVersions', entity: file}\">\r\n  <div class=\"subheader\">\r\n    <div> {{ historyTranslation | translate }}</div>\r\n\r\n  </div>\r\n  <div class=\"attachments-list\" *ngIf=\"versions.length > 0\">\r\n    <ng-container>\r\n     <mat-list>\r\n        <div class=\"mat-list-items\" *ngFor=\"let version of versions ;let cnt = count; let i = index\">\r\n          <cts-item-list [item]=\"version\" [title]=\"version.title + '-' + getVersion(version)\" [iconname]=\"'description'\"\r\n            [moreclasses]=\"'text-danger'\" (itemClicked)=\"showVersion(version)\" [actions]=\"actions\" (actionclicked)=\"handleAction($event)\">\r\n            <div class=\"description\">\r\n              <div class=\"file-size\">\r\n                {{ getFileSize(version)}}\r\n               </div>\r\n              {{getVersion(version)}}\r\n              -\r\n              {{ version.lastModified | localizedDate : '' : (isArabic? 'ar-AR' : 'en-US') }}\r\n              <span class=\"version-contributor font-weight-bold\">\r\n\r\n                {{\r\n                version.properties.lastContributor.id === 'system' ?\r\n                ('SYSTEM_ADMIN' | translate) : (\r\n                  isArabic ? (version.properties.lastContributor.fullNameAr ? version.properties.lastContributor.fullNameAr : (version.properties.lastContributor.properties.firstName + \" \" + version.properties.lastContributor.properties.lastName)) : \r\n                  ( version.properties.lastContributor.properties.firstName + \" \" + version.properties.lastContributor.properties.lastName)\r\n                )\r\n                }}\r\n                <div class=\"contributor-card-details\" (click)=\"$event.stopPropagation()\" *ngIf=\"showUserCard\">\r\n                  <div class=\"user-img\">\r\n                      <img class=\"user-avatar\" [src]=\"version.properties.lastContributor.avatar\">\r\n                  </div>\r\n                  <div class=\"user-details\">\r\n                      <div class=\"user-name\">{{isArabic  ? version.properties.lastContributor.fullNameAr : version.properties.lastContributor.fullName}}</div>\r\n                      <div class=\"user-position\">{{(isArabic && version.properties.lastContributor.jobGradeAr) ? version.properties.lastContributor.jobGradeAr : (version.properties.lastContributor.jobGrade ? version.properties.lastContributor.jobGrade : '--')}}</div>\r\n                  </div>\r\n              </div>\r\n              </span>\r\n            </div>\r\n          </cts-item-list>\r\n        </div>\r\n      </mat-list>\r\n    </ng-container>\r\n  </div>\r\n  <div class=\"version-loading\" *ngIf=\"fetching\">\r\n    <mat-spinner color=\"warn\" [diameter]=\"25\"></mat-spinner>\r\n  </div>\r\n  <div  *ngIf=\"(!fetching && versions.length === 0)\">\r\n    <cts-no-data></cts-no-data>\r\n  </div>\r\n</div>\r\n</div>\r\n<ng-template #noEntry>\r\n\r\n</ng-template>", styles: [".viewer-attachments .attachments-list .version-contributor{position:relative}.viewer-attachments .attachments-list .version-contributor .contributor-card-details{position:absolute;z-index:99999;display:none;min-width:250px;padding:28px 16px;align-items:center;grid-gap:8px;gap:8px;border-radius:4px;background:#FFF;cursor:default;box-shadow:0 -1px 4px #1c34541a,0 1px 4px -1px #1c345426}.viewer-attachments .attachments-list .version-contributor .contributor-card-details .user-img img{width:40px;height:40px;min-width:40px;border-radius:48px;border:1px solid var(--Outline-Card, #DCDCE4)}.viewer-attachments .attachments-list .version-contributor .contributor-card-details .user-details{text-align:start}.viewer-attachments .attachments-list .version-contributor .contributor-card-details .user-details .user-name{color:#234990;font-size:14px;font-family:\"semiBoldPoppins\";font-weight:bold}.viewer-attachments .attachments-list .version-contributor .contributor-card-details .user-details .user-position{color:#5d6481;font-size:12px}.viewer-attachments .attachments-list .version-contributor:hover .contributor-card-details{display:flex}.viewer-attachments .attachments-list .mat-list-items .description .file-size{display:none}.viewer-attachments .version-loading{display:flex;justify-content:center;padding:10px 0}\n"], components: [{ type: i4.MatList, selector: "mat-list, mat-action-list", inputs: ["disableRipple", "disabled"], exportAs: ["matList"] }, { type: i5.ItemListComponent, selector: "cts-item-list", inputs: ["item", "iconname", "title", "actions", "isselected", "moreclasses"], outputs: ["itemClicked", "actionclicked"] }, { type: i6.MatSpinner, selector: "mat-spinner", inputs: ["color"] }, { type: i7.NoDataComponent, selector: "cts-no-data", inputs: ["message", "border", "img"] }], directives: [{ type: i8.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i9.PermissionsDirective, selector: "[permission]", inputs: ["permission"] }, { type: i8.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i8.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i10.TranslatePipe, "localizedDate": i11.LocalizedDatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VersionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-versions',
+                    templateUrl: './versions.component.html',
+                    styleUrls: ['./versions.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ViewerFilesService }, { type: i2.TranslationService }, { type: i3.DocumentsService }]; }, propDecorators: { selectedVersion: [{
+                type: Input
+            }], file: [{
+                type: Input
+            }], actions: [{
+                type: Input
+            }], currentTranslation: [{
+                type: Input
+            }], originTranslation: [{
+                type: Input
+            }], historyTranslation: [{
+                type: Input
+            }], showUserCard: [{
+                type: Input
+            }], handleActions: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"versions.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/versions/versions.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/versions/versions.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, OnChanges, OnInit, SimpleChanges, EventEmitter, OnDestroy } from '@angular/core';\r\nimport { DocumentsService } from '../../../documents/services/documents.service';\r\nimport { ViewerFilesService } from '../../services/viewer-files.service';\r\nimport { TranslationService } from '../../../../core/services/translation/translation.service';\r\nimport { Subscription } from 'rxjs';\r\n\r\n\r\n/**\r\n * A component that views document versions\r\n * @title\r\n * Viewer Versions\r\n *\r\n * @example\r\n *\r\n * <cts-versions\r\n *   [file]=\"file\"\r\n *   [actions]=\"menu_actions\"\r\n *   (handleActions)=\"handleActionOnVersion($event)\"\r\n * ></cts-versions>\r\n */\r\n@Component({\r\n  selector: 'cts-versions',\r\n  templateUrl: './versions.component.html',\r\n  styleUrls: ['./versions.component.scss']\r\n})\r\nexport class VersionsComponent implements OnInit, OnChanges , OnDestroy {\r\n  /** Current selected version (in viewer) */\r\n  @Input()\r\n  selectedVersion;\r\n  /** Document object */\r\n  @Input()\r\n  file;\r\n/** Actions on Version */\r\n  @Input()\r\n  actions?: string[];\r\n  @Input()\r\n  currentTranslation = 'viewer.current';\r\n  @Input()\r\n  originTranslation = 'viewer.origin';\r\n  @Input()\r\n  historyTranslation = 'viewer.history';\r\n  @Input() showUserCard = false; // flage to show user cards\r\n  @Output()\r\n  handleActions = new EventEmitter();\r\n  versions = [];\r\n  isArabic = false;\r\n  langSubscription : Subscription;\r\n  fetching = false;\r\n  constructor(\r\n    private viewerFilesService: ViewerFilesService,\r\n    private trnaslationService : TranslationService,\r\n    private documentsApi: DocumentsService\r\n\r\n  ) { }\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes.file && changes.file.currentValue &&\r\n      changes.file.previousValue) {\r\n      this.getVersions();\r\n    }\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.langSubscription =  this.trnaslationService.isArabic$.subscribe(res => {\r\n      this.isArabic = res;\r\n    })\r\n    this.getVersions();\r\n  }\r\n\r\n  getVersion(version) {\r\n    let majVer = version.properties.major_version ? version.properties.major_version : ( version.properties['uid:major_version'] ?  version.properties['uid:major_version'] : 0);\r\n    let minVer = version.properties.minor_version ? version.properties.minor_version : ( version.properties['uid:minor_version'] ?  version.properties['uid:minor_version'] : 0);\r\n    return `${majVer}.${minVer}`;\r\n  }\r\n  getVersions() {\r\n    this.fetching = true;\r\n    this.documentsApi.getVersions(this.file.uid).subscribe((data) => {\r\n      this.versions = data.entries.reverse();\r\n      this.fetching = false;\r\n      // this.versions.shift();\r\n      this.fetching = false;\r\n\r\n    }, err => {\r\n      this.fetching = false;\r\n    });\r\n  }\r\n\r\n  showVersion(version) {\r\n    this.viewerFilesService.updateViewer.next(version);\r\n  }\r\n\r\n  getFileSize(version){\r\n    let file = version.properties['file:content'] || version.properties.content;\r\n    if(file && file.length){\r\n      let length = +file.length;\r\n      if(length < 1000000){\r\n        // trnasfer to KB\r\n        return (length/1000).toFixed(2) + 'KB'\r\n      }else{\r\n        // transafer to MB\r\n        return (length/(1000000)).toFixed(2) + 'MB'\r\n      }\r\n    }\r\n  }\r\n\r\n  handleAction(event) {\r\n    this.handleActions.emit(event)\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.langSubscription ? this.langSubscription.unsubscribe() : null;\r\n  }\r\n}\r\n","<div class=\"flex flex-col\">\r\n<div class=\"viewer-attachments\">\r\n  <div class=\"subheader\">\r\n    <div> {{ currentTranslation | translate }}</div>\r\n\r\n  </div>\r\n  <div class=\"attachments-list\">\r\n    <mat-list>\r\n      <div class=\"mat-list-items\">\r\n        <cts-item-list [item]=\"file\" [title]=\"file.title\" [iconname]=\"'description'\" [moreclasses]=\"'text-danger'\"\r\n          [actions]=\"actions\" (itemClicked)=\"showVersion(file)\" (actionclicked)=\"handleAction($event)\">\r\n          <div class=\"description\">\r\n            <div class=\"file-size\">\r\n              {{ getFileSize(file)}}\r\n             </div>\r\n            {{getVersion(file)}}\r\n            -\r\n            {{ file.lastModified | localizedDate : '' : (isArabic? 'ar-AR' : 'en-US') }}\r\n          </div>\r\n        </cts-item-list>\r\n      </div>\r\n    </mat-list>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"viewer-attachments original-section\" *ngIf=\"versions.length > 0\" >\r\n  <div class=\"subheader\">\r\n    <div>{{ originTranslation | translate }}</div>\r\n  </div>\r\n  <div class=\"attachments-list\">\r\n    <mat-list>\r\n      <div class=\"mat-list-items\">\r\n        <cts-item-list [item]=\"versions[versions.length -1]\" [title]=\"versions[versions.length -1].title\"\r\n          [iconname]=\"'description'\" [moreclasses]=\"'text-danger'\" [actions]=\"actions\"\r\n          (itemClicked)=\"showVersion(versions[versions.length -1])\" (actionclicked)=\"handleAction($event)\">\r\n\r\n        </cts-item-list>\r\n      </div>\r\n    </mat-list>\r\n  </div>\r\n</div>\r\n\r\n<div class=\"viewer-attachments\" [ngClass]=\"{'viewer-attachment-with-user-card' : showUserCard}\" *permission=\"{name: 'viewVersions', entity: file}\">\r\n  <div class=\"subheader\">\r\n    <div> {{ historyTranslation | translate }}</div>\r\n\r\n  </div>\r\n  <div class=\"attachments-list\" *ngIf=\"versions.length > 0\">\r\n    <ng-container>\r\n     <mat-list>\r\n        <div class=\"mat-list-items\" *ngFor=\"let version of versions ;let cnt = count; let i = index\">\r\n          <cts-item-list [item]=\"version\" [title]=\"version.title + '-' + getVersion(version)\" [iconname]=\"'description'\"\r\n            [moreclasses]=\"'text-danger'\" (itemClicked)=\"showVersion(version)\" [actions]=\"actions\" (actionclicked)=\"handleAction($event)\">\r\n            <div class=\"description\">\r\n              <div class=\"file-size\">\r\n                {{ getFileSize(version)}}\r\n               </div>\r\n              {{getVersion(version)}}\r\n              -\r\n              {{ version.lastModified | localizedDate : '' : (isArabic? 'ar-AR' : 'en-US') }}\r\n              <span class=\"version-contributor font-weight-bold\">\r\n\r\n                {{\r\n                version.properties.lastContributor.id === 'system' ?\r\n                ('SYSTEM_ADMIN' | translate) : (\r\n                  isArabic ? (version.properties.lastContributor.fullNameAr ? version.properties.lastContributor.fullNameAr : (version.properties.lastContributor.properties.firstName + \" \" + version.properties.lastContributor.properties.lastName)) : \r\n                  ( version.properties.lastContributor.properties.firstName + \" \" + version.properties.lastContributor.properties.lastName)\r\n                )\r\n                }}\r\n                <div class=\"contributor-card-details\" (click)=\"$event.stopPropagation()\" *ngIf=\"showUserCard\">\r\n                  <div class=\"user-img\">\r\n                      <img class=\"user-avatar\" [src]=\"version.properties.lastContributor.avatar\">\r\n                  </div>\r\n                  <div class=\"user-details\">\r\n                      <div class=\"user-name\">{{isArabic  ? version.properties.lastContributor.fullNameAr : version.properties.lastContributor.fullName}}</div>\r\n                      <div class=\"user-position\">{{(isArabic && version.properties.lastContributor.jobGradeAr) ? version.properties.lastContributor.jobGradeAr : (version.properties.lastContributor.jobGrade ? version.properties.lastContributor.jobGrade : '--')}}</div>\r\n                  </div>\r\n              </div>\r\n              </span>\r\n            </div>\r\n          </cts-item-list>\r\n        </div>\r\n      </mat-list>\r\n    </ng-container>\r\n  </div>\r\n  <div class=\"version-loading\" *ngIf=\"fetching\">\r\n    <mat-spinner color=\"warn\" [diameter]=\"25\"></mat-spinner>\r\n  </div>\r\n  <div  *ngIf=\"(!fetching && versions.length === 0)\">\r\n    <cts-no-data></cts-no-data>\r\n  </div>\r\n</div>\r\n</div>\r\n<ng-template #noEntry>\r\n\r\n</ng-template>"]}

package/esm2015/lib/components/correspondence-relation/correspondence-relation.module.js

@@ -0,0 +1,119 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { CorrespondenceRelationListComponent } from "./components/correspondence-relation-list/correspondence-relation-list.component";
+import { CorrespondenceRelationComponent } from "./components/correspondence-relation/correspondence-relation.component";
+import { CorrespondenceRelationCreateFormComponent } from "./components/correspondence-relation-create-form/correspondence-relation-create-form.component";
+import { DynamicFormModule } from "../dynamic-form/dynamic-form.module";
+import { TranslateModule } from "@ngx-translate/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { MatDialogModule } from "@angular/material/dialog";
+import { DynamicSearchModule } from "../dynamic-search/dynamic-search.module";
+import { AutocompleteLibModule } from "angular-ng-autocomplete";
+import { MatIconModule } from "@angular/material/icon";
+import { NgSelectModule } from "@ng-select/ng-select";
+import { SelectModule } from "../select/select.module";
+import { LayoutModule } from "@angular/cdk/layout";
+import { MatChipsModule } from "@angular/material/chips";
+import { MatMenuModule } from "@angular/material/menu";
+import { MatListModule } from "@angular/material/list";
+import { MatExpansionModule } from "@angular/material/expansion";
+import { LibrarySharedModule } from "../../shared/libraryShared.module";
+import { CorrespondenceRelationReplyComponent } from "./components/correspondence-relation-reply/correspondence-relation-reply.component";
+import { DirectiveModule } from "../../directive/directive.module";
+import { VersionsComponent } from "./components/versions/versions.component";
+import { PipesModule } from "../../pipes/pipes.module";
+import { NuxeoDialogModule } from "../../shared/components/nuxeo-dialog/nuxeo-dialog.module";
+import { MatProgressSpinnerModule } from "@angular/material/progress-spinner";
+import * as i0 from "@angular/core";
+/** @ignore */
+export class CorrespondenceRelationModule {
+}
+CorrespondenceRelationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CorrespondenceRelationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationModule, declarations: [CorrespondenceRelationListComponent,
+        CorrespondenceRelationComponent,
+        CorrespondenceRelationCreateFormComponent,
+        CorrespondenceRelationReplyComponent,
+        VersionsComponent], imports: [CommonModule,
+        DynamicFormModule,
+        TranslateModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatDialogModule,
+        DynamicSearchModule,
+        MatIconModule,
+        NgSelectModule,
+        SelectModule,
+        AutocompleteLibModule,
+        LayoutModule,
+        MatChipsModule,
+        MatMenuModule,
+        MatListModule,
+        MatIconModule,
+        MatExpansionModule,
+        LibrarySharedModule,
+        DirectiveModule,
+        PipesModule,
+        NuxeoDialogModule,
+        MatProgressSpinnerModule], exports: [CorrespondenceRelationComponent, VersionsComponent] });
+CorrespondenceRelationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationModule, imports: [[
+            CommonModule,
+            DynamicFormModule,
+            TranslateModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MatDialogModule,
+            DynamicSearchModule,
+            MatIconModule,
+            NgSelectModule,
+            SelectModule,
+            AutocompleteLibModule,
+            LayoutModule,
+            MatChipsModule,
+            MatMenuModule,
+            MatListModule,
+            MatIconModule,
+            MatExpansionModule,
+            LibrarySharedModule,
+            DirectiveModule,
+            PipesModule,
+            NuxeoDialogModule,
+            MatProgressSpinnerModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        CorrespondenceRelationListComponent,
+                        CorrespondenceRelationComponent,
+                        CorrespondenceRelationCreateFormComponent,
+                        CorrespondenceRelationReplyComponent,
+                        VersionsComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        DynamicFormModule,
+                        TranslateModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatDialogModule,
+                        DynamicSearchModule,
+                        MatIconModule,
+                        NgSelectModule,
+                        SelectModule,
+                        AutocompleteLibModule,
+                        LayoutModule,
+                        MatChipsModule,
+                        MatMenuModule,
+                        MatListModule,
+                        MatIconModule,
+                        MatExpansionModule,
+                        LibrarySharedModule,
+                        DirectiveModule,
+                        PipesModule,
+                        NuxeoDialogModule,
+                        MatProgressSpinnerModule,
+                    ],
+                    exports: [CorrespondenceRelationComponent, VersionsComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/correspondence-relation/services/correspondence-realation.service.js

@@ -0,0 +1,165 @@
+import { Inject, Injectable } from '@angular/core';
+import { from, ReplaySubject } from 'rxjs';
+import { catchError, map } 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/callApi/call-api.service";
+export class CorrespondenceRelationService {
+    constructor(nuxeoService, configService, callApi, environment) {
+        var _a, _b, _c;
+        this.nuxeoService = nuxeoService;
+        this.configService = configService;
+        this.callApi = callApi;
+        this.environment = environment;
+        this.getUpdatedRelation = new ReplaySubject();
+        this.relationConstants =
+            (_a = this.configService.myConfiguration['files']) === null || _a === void 0 ? void 0 : _a['correspondenceRelation'];
+        this.incomingConstant =
+            (_c = (_b = this.configService) === null || _b === void 0 ? void 0 : _b.myConfiguration.correspondance) === null || _c === void 0 ? void 0 : _c.incoming;
+    }
+    get_Correspondence_Relation(corr_id, pageprovider, context = {}) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(pageprovider, {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context(context)
+            .input(corr_id)
+            .execute({
+            headers: {
+                properties: '*'
+            }
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    get_Correspondence_Reply_Relation(corr_id) {
+        return this.get_Correspondence_Relation(corr_id, this.relationConstants['Operations']['get_reply_relation'], { relationName: 'reply' });
+    }
+    get_Correspondence_Reply_Relation_Reverse(corr_id) {
+        return this.get_Correspondence_Relation(corr_id, this.relationConstants['Operations']['get_reply_relation_reverse']);
+    }
+    get_Correspondence_Relation_WithoutReply(corr_id) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(this.relationConstants['Operations']['get_without_reply_both_direction'], {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({})
+            .input(corr_id)
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    create_Named_Relation(corr_id, relationname, targets) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(this.relationConstants['Operations']['create_named_relation'], {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({
+            relationName: relationname,
+            targets: targets
+        })
+            .input(corr_id)
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    Delete_Named_Relation(corr_id, relationname, target) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(this.relationConstants['Operations']['delete_named_relation'], {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({
+            relationName: relationname,
+            target: target
+        })
+            .input(corr_id)
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    search(val, query = '', type) {
+        let params = Object.assign({ pageProvider: type == 'relationFile'
+                ? 'PP_Correspondence_RelationSeach'
+                : 'PP_Correspondences_Elastic', currentPageIndex: 0, offset: 0, pageSize: 20, system_fulltext: val + '*' }, query);
+        if (this.nuxeoService.nuxeoClient.user.properties.tenantId) {
+            params['queryParams'] = `${this.nuxeoService.nuxeoClient.user.properties.tenantId}`;
+        }
+        return this.callApi
+            .query(params, {
+            headers: { 'X-NXproperties': 'Correspondence' }
+        })
+            .pipe(map((data) => {
+            let results = [];
+            data.entries.map((item) => {
+                results.push({
+                    //  title: item.title,
+                    title: item.properties['corr:referenceNumber'] !== null
+                        ? item.properties['corr:referenceNumber'] +
+                            ' - ' +
+                            item.properties['corr:subject']
+                        : item.properties['corr:subject'],
+                    id: item.uid,
+                    filter: item.title,
+                    number: item.properties['corr:referenceNumber'],
+                    subject: item.properties['corr:subject']
+                });
+            });
+            return results;
+        }));
+    }
+    // get relations with the updated api
+    getCorrespondeceRelation(id) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_CorrespondenceRelation_Get', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({
+            relationName: 'reply'
+        })
+            .input(id)
+            .execute({
+            headers: {
+                properties: '*'
+            }
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    // get revers relations with the updated api
+    getCorrespondeceRelationRevers(id) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_CorrespondenceRelation_GetReverse', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({
+            relationName: 'reply'
+        })
+            .input(id)
+            .execute({
+            headers: {
+                properties: '*'
+            }
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+}
+CorrespondenceRelationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationService, deps: [{ token: i1.NuxeoService }, { token: i2.AppConfigService }, { token: i3.CallApiService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+CorrespondenceRelationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: CorrespondenceRelationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: i2.AppConfigService }, { type: i3.CallApiService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-realation.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/services/correspondence-realation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { from, Observable, ReplaySubject } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../configuration/app-config.service';\r\nimport { AdapterService } from '../../../core/adapters/adapter.service';\r\nimport { CallApiService } from '../../../core/services/callApi/call-api.service';\r\nimport { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class CorrespondenceRelationService {\r\n\trelationConstants: any;\r\n\tpublic getUpdatedRelation = new ReplaySubject();\r\n\tincomingConstant;\r\n\tconstructor(\r\n\t\tprivate nuxeoService: NuxeoService,\r\n\t\tprivate configService: AppConfigService,\r\n\t\tprivate callApi: CallApiService,\r\n\t\t@Inject('environment') private environment\r\n\t) {\r\n\t\tthis.relationConstants =\r\n\t\t\tthis.configService.myConfiguration['files']?.['correspondenceRelation'];\r\n\t\tthis.incomingConstant =\r\n\t\t\tthis.configService?.myConfiguration.correspondance?.incoming;\r\n\t}\r\n\r\n\tget_Correspondence_Relation(corr_id, pageprovider, context = {}) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation(pageprovider, {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.context(context)\r\n\t\t\t\t.input(corr_id)\r\n\t\t\t\t.execute({\r\n\t\t\t\t\theaders: {\r\n\t\t\t\t\t\tproperties: '*'\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tget_Correspondence_Reply_Relation(corr_id): Observable<any> {\r\n\t\treturn this.get_Correspondence_Relation(\r\n\t\t\tcorr_id,\r\n\t\t\tthis.relationConstants['Operations']['get_reply_relation'],\r\n\t\t\t{ relationName: 'reply' }\r\n\t\t);\r\n\t}\r\n\r\n\tget_Correspondence_Reply_Relation_Reverse(corr_id): Observable<any> {\r\n\t\treturn this.get_Correspondence_Relation(\r\n\t\t\tcorr_id,\r\n\t\t\tthis.relationConstants['Operations']['get_reply_relation_reverse']\r\n\t\t);\r\n\t}\r\n\r\n\tget_Correspondence_Relation_WithoutReply(corr_id): Observable<any> {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation(\r\n\t\t\t\t\tthis.relationConstants['Operations'][\r\n\t\t\t\t\t\t'get_without_reply_both_direction'\r\n\t\t\t\t\t],\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t\t}\r\n\t\t\t\t)\r\n\t\t\t\t.context({})\r\n\t\t\t\t.input(corr_id)\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tcreate_Named_Relation(\r\n\t\tcorr_id: string,\r\n\t\trelationname: string,\r\n\t\ttargets: any[]\r\n\t): Observable<any> {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation(\r\n\t\t\t\t\tthis.relationConstants['Operations']['create_named_relation'],\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t\t}\r\n\t\t\t\t)\r\n\t\t\t\t.context({\r\n\t\t\t\t\trelationName: relationname,\r\n\t\t\t\t\ttargets: targets\r\n\t\t\t\t})\r\n\t\t\t\t.input(corr_id)\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tDelete_Named_Relation(\r\n\t\tcorr_id: string,\r\n\t\trelationname: string,\r\n\t\ttarget: string\r\n\t): Observable<any> {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation(\r\n\t\t\t\t\tthis.relationConstants['Operations']['delete_named_relation'],\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t\t}\r\n\t\t\t\t)\r\n\t\t\t\t.context({\r\n\t\t\t\t\trelationName: relationname,\r\n\t\t\t\t\ttarget: target\r\n\t\t\t\t})\r\n\t\t\t\t.input(corr_id)\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tsearch(val: string, query: any = '', type?): Observable<any> {\r\n\t\tlet params = {\r\n\t\t\tpageProvider:\r\n\t\t\t\ttype == 'relationFile'\r\n\t\t\t\t\t? 'PP_Correspondence_RelationSeach'\r\n\t\t\t\t\t: 'PP_Correspondences_Elastic',\r\n\t\t\tcurrentPageIndex: 0,\r\n\t\t\toffset: 0,\r\n\t\t\tpageSize: 20,\r\n\t\t\tsystem_fulltext: val + '*',\r\n\t\t\t...query\r\n\t\t};\r\n\t\tif (this.nuxeoService.nuxeoClient.user.properties.tenantId) {\r\n\t\t\tparams[\r\n\t\t\t\t'queryParams'\r\n\t\t\t] = `${this.nuxeoService.nuxeoClient.user.properties.tenantId}`;\r\n\t\t}\r\n\t\treturn this.callApi\r\n\t\t\t.query(params, {\r\n\t\t\t\theaders: { 'X-NXproperties': 'Correspondence' }\r\n\t\t\t})\r\n\t\t\t.pipe(\r\n\t\t\t\tmap((data) => {\r\n\t\t\t\t\tlet results = [];\r\n\t\t\t\t\tdata.entries.map((item) => {\r\n\t\t\t\t\t\tresults.push({\r\n\t\t\t\t\t\t\t//  title: item.title,\r\n\t\t\t\t\t\t\ttitle:\r\n\t\t\t\t\t\t\t\titem.properties['corr:referenceNumber'] !== null\r\n\t\t\t\t\t\t\t\t\t? item.properties['corr:referenceNumber'] +\r\n\t\t\t\t\t\t\t\t\t  ' - ' +\r\n\t\t\t\t\t\t\t\t\t  item.properties['corr:subject']\r\n\t\t\t\t\t\t\t\t\t: item.properties['corr:subject'],\r\n\t\t\t\t\t\t\tid: item.uid,\r\n\t\t\t\t\t\t\tfilter: item.title,\r\n\t\t\t\t\t\t\tnumber: item.properties['corr:referenceNumber'],\r\n\t\t\t\t\t\t\tsubject: item.properties['corr:subject']\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t});\r\n\t\t\t\t\treturn results;\r\n\t\t\t\t})\r\n\t\t\t);\r\n\t}\r\n\r\n\t// get relations with the updated api\r\n\tgetCorrespondeceRelation(id) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation('AC_UA_CorrespondenceRelation_Get', {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.context({\r\n\t\t\t\t\trelationName: 'reply'\r\n\t\t\t\t})\r\n\t\t\t\t.input(id)\r\n\t\t\t\t.execute({\r\n\t\t\t\t\theaders: {\r\n\t\t\t\t\t\tproperties: '*'\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\t// get revers relations with the updated api\r\n\tgetCorrespondeceRelationRevers(id) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation('AC_UA_CorrespondenceRelation_GetReverse', {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.context({\r\n\t\t\t\t\trelationName: 'reply'\r\n\t\t\t\t})\r\n\t\t\t\t.input(id)\r\n\t\t\t\t.execute({\r\n\t\t\t\t\theaders: {\r\n\t\t\t\t\t\tproperties: '*'\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/correspondence-relation/services/viewer-files.service.js

@@ -0,0 +1,54 @@
+import { EventEmitter, Inject } from '@angular/core';
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../configuration/app-config.service";
+import * as i2 from "../../../core/adapters/adapter.service";
+import * as i3 from "../../../core/services/nuxeo/nuxeo.service";
+export class ViewerFilesService {
+    constructor(configService, adapter, nuxeoService, environment) {
+        this.configService = configService;
+        this.adapter = adapter;
+        this.nuxeoService = nuxeoService;
+        this.environment = environment;
+        this.selectedFileId = new EventEmitter();
+        this.updateViewer = new EventEmitter();
+        this.incomingConstant =
+            this.configService.myConfiguration['correspondance']['incoming'];
+    }
+    createAttach(attachment, correspondenceId) {
+        console.log(attachment);
+        // console.log(
+        //   this.adapter.adaptOut(attachment, this.incomingConstant.attachments)
+        // );
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_Correspondence_Attach_Create', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .input(correspondenceId)
+            .context({
+            attachment: this.adapter.adaptOut(attachment, this.incomingConstant.attachments),
+        })
+            .execute({
+            headers: {
+                'X-Batch-No-Drop': true // prevent deleting the batch if api using this batch fails
+            }
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+}
+ViewerFilesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewerFilesService, deps: [{ token: i1.AppConfigService }, { token: i2.AdapterService }, { token: i3.NuxeoService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewerFilesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewerFilesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewerFilesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AppConfigService }, { type: i2.AdapterService }, { type: i3.NuxeoService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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