nuxeo-development-framework 6.0.1 → 6.0.3

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

@@ -3,6 +3,7 @@ import { MatDialogConfig } from "@angular/material/dialog";
 import { take } from "rxjs/operators";
 import { ConfirmCallerDialogComponent } from "../../../confirm-caller/confirm-caller.dialog";
 import { CorrespondenceRelationCreateFormComponent } from "../correspondence-relation-create-form/correspondence-relation-create-form.component";
+import { GeneralNotificationPopupComponent } from '../../../../shared/components/general-notification-popup/general-notification-popup.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/dialog";
 import * as i2 from "../../services/correspondence-realation.service";
@@ -95,8 +96,22 @@ export class CorrespondenceRelationComponent {
         }
     }
     view_Corres(relation) {
-        let url = window.location.href;
-        window.open(url.replace(this.corr_id, relation.uid), "_blank");
+        if (relation.uid) {
+            let url = window.location.href;
+            window.open(url.replace(this.corr_id, relation.uid), "_blank");
+        }
+        else {
+            this.openGeneralNotificationPopup();
+        }
+    }
+    openGeneralNotificationPopup() {
+        this.dialog
+            .open(GeneralNotificationPopupComponent, {
+            width: '500px',
+            panelClass: 'updated-design-dialog'
+        })
+            .afterClosed()
+            .pipe(take(1));
     }
     showCorrespondenceInViewer(corres_id) {
         this.documentsApi.getDocument(corres_id).subscribe((file) => {
@@ -145,4 +160,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], correspondance: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-relation.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation/correspondence-relation.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation/correspondence-relation.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit } from \"@angular/core\";\r\nimport { MatDialog, MatDialogConfig } from \"@angular/material/dialog\";\r\nimport { CustomToastrService } from \"../../../custom-toastr/services/custom-toastr.service\";\r\nimport { CorrespondenceRelationService } from \"../../services/correspondence-realation.service\";\r\nimport { take } from \"rxjs/operators\";\r\nimport { ConfirmCallerDialogComponent } from \"../../../confirm-caller/confirm-caller.dialog\";\r\nimport { CorrespondenceRelationCreateFormComponent } from \"../correspondence-relation-create-form/correspondence-relation-create-form.component\";\r\nimport { DocumentsService } from \"../../../documents/services/documents.service\";\r\nimport { ViewerFilesService } from \"../../services/viewer-files.service\";\r\nimport { UserPreferencesService } from \"../../../../core/services/user/user-preferences.service\";\r\nimport { NuxeoService } from \"../../../../core/services/nuxeo/nuxeo.service\";\r\n@Component({\r\n  selector: \"cts-correspondence-relation\",\r\n  templateUrl: \"./correspondence-relation.component.html\",\r\n  styleUrls: [\"./correspondence-relation.component.scss\"],\r\n})\r\nexport class CorrespondenceRelationComponent implements OnInit {\r\n  @Input()\r\n  corr_id;\r\n  /** Correspondance */\r\n  @Input()\r\n  correspondance;\r\n  relations_list: any;\r\n  reload: boolean = false;\r\n  constructor(\r\n    public dialog: MatDialog,\r\n    private corrrelationsvc: CorrespondenceRelationService,\r\n    private toastr: CustomToastrService,\r\n    private viewerFilesService: ViewerFilesService,\r\n    private documentsApi: DocumentsService,\r\n    private userPreference: UserPreferencesService,\r\n    public nuxeoService: NuxeoService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.getallrelated();\r\n    this.corrrelationsvc.getUpdatedRelation.subscribe((res) => {\r\n      this.getallrelated();\r\n    });\r\n  }\r\n\r\n  openDialog() {\r\n    let data = {};\r\n    if (this.relations_list)\r\n      data = {\r\n        exist_relations_list: this.relations_list.value,\r\n        correspondance: this.correspondance,\r\n        corr_id: this.corr_id,\r\n      };\r\n    else data = { exist_relations_list: [] };\r\n    const dialogConfig = new MatDialogConfig();\r\n    dialogConfig.data = data;\r\n    dialogConfig.direction =\r\n      this.userPreference.locale === \"ar\" ? \"rtl\" : \"ltr\";\r\n    dialogConfig.panelClass = \"custom-dialog-container\";\r\n    dialogConfig.width = \"50%\";\r\n    dialogConfig.disableClose = true;\r\n    const dialogRef = this.dialog.open(\r\n      CorrespondenceRelationCreateFormComponent,\r\n      dialogConfig\r\n    );\r\n\r\n    dialogRef.afterClosed().subscribe((result) => {\r\n      if (result) {\r\n        this.reload = true;\r\n        // this.corrrelationsvc\r\n        //   .create_Named_Relation(this.corr_id, result.relationname, result.docs)\r\n        //   .subscribe(\r\n        //     (data) => {\r\n        //       this.reload = true;\r\n        //       this.corrrelationsvc.getUpdatedRelation.next();\r\n        //       this.toastr.show(\r\n        //         'success',\r\n        //         'success',\r\n        //         'Realation Successfuly added'\r\n        //       );\r\n        //     },\r\n        //     (err) => {\r\n        //       this.toastr.show('error', 'error',\r\n        //         err.ret.message ?\r\n        //           `errors.${err.ret.code}`\r\n        //           : 'genericError');\r\n        //     }\r\n        //   );\r\n      }\r\n    });\r\n  }\r\n\r\n  getallrelated() {\r\n    this.corrrelationsvc\r\n      .get_Correspondence_Relation_WithoutReply(this.corr_id)\r\n      .subscribe((results) => {\r\n        this.relations_list = results;\r\n      });\r\n  }\r\n\r\n  handleActions(event) {\r\n    if (event.action === \"view\") {\r\n      this.view_Corres(event.item);\r\n    } else if (event.action === \"delete\") {\r\n      this.deleteRelation(event.item);\r\n    } else if (event.action === \"show\") {\r\n      this.showCorrespondenceInViewer(event.item.uid);\r\n    }\r\n  }\r\n\r\n  view_Corres(relation) {\r\n    let url = window.location.href;\r\n    window.open(url.replace(this.corr_id, relation.uid), \"_blank\");\r\n  }\r\n\r\n  showCorrespondenceInViewer(corres_id) {\r\n    this.documentsApi.getDocument(corres_id).subscribe((file) => {\r\n      this.viewerFilesService.updateViewer.next(file);\r\n    });\r\n  }\r\n  openConfirmDialog(functionToPerform, title, msg) {\r\n    return this.dialog\r\n      .open(ConfirmCallerDialogComponent, {\r\n        width: \"400px\",\r\n        panelClass: \"relation-confirm-dialog\",\r\n        data: {\r\n          call: functionToPerform,\r\n          title: \"genericConfirm\",\r\n          toastrTitle: title,\r\n          toastrMsg: msg,\r\n        },\r\n      })\r\n      .afterClosed()\r\n      .pipe(take(1));\r\n  }\r\n  deleteRelation(relateddoc) {\r\n    let functionToPerform = () => {\r\n      return this.corrrelationsvc.Delete_Named_Relation(\r\n        this.corr_id,\r\n        relateddoc.relationId,\r\n        relateddoc.uid\r\n      );\r\n    };\r\n    let title = \"\";\r\n    let msg = \"\";\r\n    this.openConfirmDialog(\r\n      functionToPerform,\r\n      \"Success\",\r\n      \"correspondence-relation.deleted_success\"\r\n    ).subscribe((data) => {\r\n      if (data) {\r\n        this.corrrelationsvc.getUpdatedRelation.next();\r\n      }\r\n    });\r\n  }\r\n}\r\n","<div class=\"relations-container\">\r\n  <div  class=\"mb-3 relations-reply\">\r\n    <div class=\"subheader\">\r\n      <div>{{ \"correspondence-relation.reply_relation\" | translate }}</div>\r\n    </div>\r\n    <cts-correspondence-relation-reply\r\n      [correspondence_id]=\"corr_id\"\r\n      (actionclicked)=\"handleActions($event)\"\r\n    ></cts-correspondence-relation-reply>\r\n  </div>\r\n\r\n  <div class=\"mb-2 relations-listing\">\r\n    <div class=\"subheader\">\r\n      <div>{{ \"correspondence-relation.title\" | translate }}</div>\r\n      <div class=\"\" *permission=\"{\r\n        name: 'AddRelatedCorrespondence',\r\n        entity: correspondance , user: nuxeoService.nuxeoClient.user\r\n      }\" (click)=\"openDialog()\"><mat-icon>add</mat-icon></div>\r\n    </div>\r\n    <cts-correspondence-relation-list\r\n      [correspondence_id]=\"corr_id\"\r\n      [reload]=\"reload\"\r\n    ></cts-correspondence-relation-list>\r\n  </div>\r\n\r\n\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-relation.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation/correspondence-relation.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation/correspondence-relation.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit } from \"@angular/core\";\r\nimport { MatDialog, MatDialogConfig } from \"@angular/material/dialog\";\r\nimport { CustomToastrService } from \"../../../custom-toastr/services/custom-toastr.service\";\r\nimport { CorrespondenceRelationService } from \"../../services/correspondence-realation.service\";\r\nimport { take } from \"rxjs/operators\";\r\nimport { ConfirmCallerDialogComponent } from \"../../../confirm-caller/confirm-caller.dialog\";\r\nimport { CorrespondenceRelationCreateFormComponent } from \"../correspondence-relation-create-form/correspondence-relation-create-form.component\";\r\nimport { DocumentsService } from \"../../../documents/services/documents.service\";\r\nimport { ViewerFilesService } from \"../../services/viewer-files.service\";\r\nimport { UserPreferencesService } from \"../../../../core/services/user/user-preferences.service\";\r\nimport { NuxeoService } from \"../../../../core/services/nuxeo/nuxeo.service\";\r\nimport { GeneralNotificationPopupComponent } from '../../../../shared/components/general-notification-popup/general-notification-popup.component';\r\n@Component({\r\n  selector: \"cts-correspondence-relation\",\r\n  templateUrl: \"./correspondence-relation.component.html\",\r\n  styleUrls: [\"./correspondence-relation.component.scss\"],\r\n})\r\nexport class CorrespondenceRelationComponent implements OnInit {\r\n  @Input()\r\n  corr_id;\r\n  /** Correspondance */\r\n  @Input()\r\n  correspondance;\r\n  relations_list: any;\r\n  reload: boolean = false;\r\n  constructor(\r\n    public dialog: MatDialog,\r\n    private corrrelationsvc: CorrespondenceRelationService,\r\n    private toastr: CustomToastrService,\r\n    private viewerFilesService: ViewerFilesService,\r\n    private documentsApi: DocumentsService,\r\n    private userPreference: UserPreferencesService,\r\n    public nuxeoService: NuxeoService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.getallrelated();\r\n    this.corrrelationsvc.getUpdatedRelation.subscribe((res) => {\r\n      this.getallrelated();\r\n    });\r\n  }\r\n\r\n  openDialog() {\r\n    let data = {};\r\n    if (this.relations_list)\r\n      data = {\r\n        exist_relations_list: this.relations_list.value,\r\n        correspondance: this.correspondance,\r\n        corr_id: this.corr_id,\r\n      };\r\n    else data = { exist_relations_list: [] };\r\n    const dialogConfig = new MatDialogConfig();\r\n    dialogConfig.data = data;\r\n    dialogConfig.direction =\r\n      this.userPreference.locale === \"ar\" ? \"rtl\" : \"ltr\";\r\n    dialogConfig.panelClass = \"custom-dialog-container\";\r\n    dialogConfig.width = \"50%\";\r\n    dialogConfig.disableClose = true;\r\n    const dialogRef = this.dialog.open(\r\n      CorrespondenceRelationCreateFormComponent,\r\n      dialogConfig\r\n    );\r\n\r\n    dialogRef.afterClosed().subscribe((result) => {\r\n      if (result) {\r\n        this.reload = true;\r\n        // this.corrrelationsvc\r\n        //   .create_Named_Relation(this.corr_id, result.relationname, result.docs)\r\n        //   .subscribe(\r\n        //     (data) => {\r\n        //       this.reload = true;\r\n        //       this.corrrelationsvc.getUpdatedRelation.next();\r\n        //       this.toastr.show(\r\n        //         'success',\r\n        //         'success',\r\n        //         'Realation Successfuly added'\r\n        //       );\r\n        //     },\r\n        //     (err) => {\r\n        //       this.toastr.show('error', 'error',\r\n        //         err.ret.message ?\r\n        //           `errors.${err.ret.code}`\r\n        //           : 'genericError');\r\n        //     }\r\n        //   );\r\n      }\r\n    });\r\n  }\r\n\r\n  getallrelated() {\r\n    this.corrrelationsvc\r\n      .get_Correspondence_Relation_WithoutReply(this.corr_id)\r\n      .subscribe((results) => {\r\n        this.relations_list = results;\r\n      });\r\n  }\r\n\r\n  handleActions(event) {\r\n    if (event.action === \"view\") {\r\n      this.view_Corres(event.item);\r\n    } else if (event.action === \"delete\") {\r\n      this.deleteRelation(event.item);\r\n    } else if (event.action === \"show\") {\r\n      this.showCorrespondenceInViewer(event.item.uid);\r\n    }\r\n  }\r\n\r\n  view_Corres(relation) {\r\n    if(relation.uid){\r\n      let url = window.location.href;\r\n      window.open(url.replace(this.corr_id, relation.uid), \"_blank\");\r\n    }else{\r\n      this.openGeneralNotificationPopup();\r\n    }\r\n  }\r\n\r\n    openGeneralNotificationPopup(){\r\n      this.dialog\r\n        .open(GeneralNotificationPopupComponent, {\r\n          width: '500px',\r\n          panelClass: 'updated-design-dialog'\r\n        })\r\n        .afterClosed()\r\n        .pipe(take(1));\r\n    }\r\n\r\n  showCorrespondenceInViewer(corres_id) {\r\n    this.documentsApi.getDocument(corres_id).subscribe((file) => {\r\n      this.viewerFilesService.updateViewer.next(file);\r\n    });\r\n  }\r\n  openConfirmDialog(functionToPerform, title, msg) {\r\n    return this.dialog\r\n      .open(ConfirmCallerDialogComponent, {\r\n        width: \"400px\",\r\n        panelClass: \"relation-confirm-dialog\",\r\n        data: {\r\n          call: functionToPerform,\r\n          title: \"genericConfirm\",\r\n          toastrTitle: title,\r\n          toastrMsg: msg,\r\n        },\r\n      })\r\n      .afterClosed()\r\n      .pipe(take(1));\r\n  }\r\n  deleteRelation(relateddoc) {\r\n    let functionToPerform = () => {\r\n      return this.corrrelationsvc.Delete_Named_Relation(\r\n        this.corr_id,\r\n        relateddoc.relationId,\r\n        relateddoc.uid\r\n      );\r\n    };\r\n    let title = \"\";\r\n    let msg = \"\";\r\n    this.openConfirmDialog(\r\n      functionToPerform,\r\n      \"Success\",\r\n      \"correspondence-relation.deleted_success\"\r\n    ).subscribe((data) => {\r\n      if (data) {\r\n        this.corrrelationsvc.getUpdatedRelation.next();\r\n      }\r\n    });\r\n  }\r\n}\r\n","<div class=\"relations-container\">\r\n  <div  class=\"mb-3 relations-reply\">\r\n    <div class=\"subheader\">\r\n      <div>{{ \"correspondence-relation.reply_relation\" | translate }}</div>\r\n    </div>\r\n    <cts-correspondence-relation-reply\r\n      [correspondence_id]=\"corr_id\"\r\n      (actionclicked)=\"handleActions($event)\"\r\n    ></cts-correspondence-relation-reply>\r\n  </div>\r\n\r\n  <div class=\"mb-2 relations-listing\">\r\n    <div class=\"subheader\">\r\n      <div>{{ \"correspondence-relation.title\" | translate }}</div>\r\n      <div class=\"\" *permission=\"{\r\n        name: 'AddRelatedCorrespondence',\r\n        entity: correspondance , user: nuxeoService.nuxeoClient.user\r\n      }\" (click)=\"openDialog()\"><mat-icon>add</mat-icon></div>\r\n    </div>\r\n    <cts-correspondence-relation-list\r\n      [correspondence_id]=\"corr_id\"\r\n      [reload]=\"reload\"\r\n    ></cts-correspondence-relation-list>\r\n  </div>\r\n\r\n\r\n</div>\r\n"]}

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

@@ -1,6 +1,7 @@
 import { Component, Input, ViewEncapsulation } from '@angular/core';
 import { take } from 'rxjs/operators';
 import { ConfirmCallerDialogComponent } from '../../../confirm-caller/confirm-caller.dialog';
+import { GeneralNotificationPopupComponent } from '../../../../shared/components/general-notification-popup/general-notification-popup.component';
 import * as i0 from "@angular/core";
 import * as i1 from "../../services/correspondence-realation.service";
 import * as i2 from "@angular/material/dialog";
@@ -75,14 +76,35 @@ export class CorrespondenceRelationListComponent {
             .pipe(take(1));
     }
     view_Corres(relation) {
-        let url = window.location.href;
-        window.open(url.replace(this.correspondence_id, relation.uid), '_blank');
+        if (relation.uid) {
+            let url = window.location.href;
+            window.open(url.replace(this.correspondence_id, relation.uid), '_blank');
+        }
+        else {
+            // he don't have permission to read this correspo
+            this.openGeneralNotificationPopup();
+        }
     }
     showCorrespondenceInViewer(relation) {
-        this.documentsApi.getDocument(relation.uid).subscribe((file) => {
-            let adaptedFile = this.adapter.adaptIn(Object.assign({}, file), this.relationsvc.incomingConstant['fields']);
-            this.viewerFilesService.updateViewer.next(adaptedFile);
-        });
+        if (relation.uid) {
+            this.documentsApi.getDocument(relation.uid).subscribe((file) => {
+                let adaptedFile = this.adapter.adaptIn(Object.assign({}, file), this.relationsvc.incomingConstant['fields']);
+                this.viewerFilesService.updateViewer.next(adaptedFile);
+            });
+        }
+        else {
+            // he don't have permission to read this correspo
+            this.openGeneralNotificationPopup();
+        }
+    }
+    openGeneralNotificationPopup() {
+        this.dialog
+            .open(GeneralNotificationPopupComponent, {
+            width: '500px',
+            panelClass: 'updated-design-dialog'
+        })
+            .afterClosed()
+            .pipe(take(1));
     }
     handleMenuItemClicked(event) {
         if (event.action === 'view') {
@@ -108,4 +130,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], reload: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-relation-list.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-list/correspondence-relation-list.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-list/correspondence-relation-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, ViewEncapsulation } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { take } from 'rxjs/operators';\r\nimport { AdapterService } from '../../../../core/adapters/adapter.service';\r\nimport { ConfirmCallerDialogComponent } from '../../../confirm-caller/confirm-caller.dialog';\r\nimport { DocumentsService } from '../../../documents/services/documents.service';\r\nimport { ViewerFilesService } from '../../services/viewer-files.service';\r\nimport { CorrespondenceRelationService } from '../../services/correspondence-realation.service';\r\nimport { NuxeoDialogService } from '../../../../shared/components/nuxeo-dialog/services/nuxeo-dialog.service';\r\n\r\n@Component({\r\n\tselector: 'cts-correspondence-relation-list',\r\n\ttemplateUrl: './correspondence-relation-list.component.html',\r\n\tstyleUrls: ['./correspondence-relation-list.component.scss'],\r\n\tencapsulation: ViewEncapsulation.None\r\n})\r\nexport class CorrespondenceRelationListComponent implements OnInit {\r\n\t@Input()\r\n\tcorrespondence_id;\r\n\t@Input()\r\n\treload: boolean = false;\r\n\trelateddoc: any[] = [];\r\n\tmenu_actions = [\r\n\t\t{ title: 'correspondence-relation.view_corr', name: 'view' },\r\n\t\t{ title: 'correspondence-relation.delete', name: 'delete' }\r\n\t];\r\n\tconstructor(\r\n\t\tprivate relationsvc: CorrespondenceRelationService,\r\n\t\tprivate dialog: MatDialog,\r\n\t\tprivate viewerFilesService: ViewerFilesService,\r\n\t\tprivate documentsApi: DocumentsService,\r\n\t\tprivate adapter: AdapterService\r\n\t) {}\r\n\tngOnInit(): void {\r\n\t\tthis.loadData();\r\n\t\tthis.relationsvc.getUpdatedRelation.subscribe((res) => {\r\n\t\t\tthis.loadData();\r\n\t\t});\r\n\t}\r\n\tloadData() {\r\n\t\tthis.relationsvc\r\n\t\t\t.get_Correspondence_Relation_WithoutReply(this.correspondence_id)\r\n\t\t\t.subscribe((result) => {\r\n\t\t\t\tlet resultarray = result.value;\r\n\t\t\t\tlet resultsgrouped = resultarray.reduce((r, a) => {\r\n\t\t\t\t\tr[a.relationId] = [...(r[a.relationId] || []), a];\r\n\t\t\t\t\treturn r;\r\n\t\t\t\t}, {});\r\n\t\t\t\tthis.relateddoc = [];\r\n\t\t\t\tfor (let group of Object.entries(resultsgrouped)) {\r\n\t\t\t\t\tthis.relateddoc.push(group);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t}\r\n\tonDeleteClick(relateddoc) {\r\n\t\tlet functionToPerform = () => {\r\n\t\t\treturn this.relationsvc.Delete_Named_Relation(\r\n\t\t\t\tthis.correspondence_id,\r\n\t\t\t\trelateddoc.relationId,\r\n\t\t\t\trelateddoc.uid\r\n\t\t\t);\r\n\t\t};\r\n\t\tlet title = '';\r\n\t\tlet msg = '';\r\n\t\tthis.openDialog(\r\n\t\t\tfunctionToPerform,\r\n\t\t\t'Success',\r\n\t\t\t'correspondence-relation.deleted_success'\r\n\t\t).subscribe((data) => {\r\n\t\t\tif (data) {\r\n\t\t\t\tthis.relationsvc.getUpdatedRelation.next();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\topenDialog(functionToPerform, title, msg) {\r\n\t\treturn this.dialog\r\n\t\t\t.open(ConfirmCallerDialogComponent, {\r\n\t\t\t\twidth: '400px',\r\n\t\t\t\tpanelClass: 'relation-confirm-dialog',\r\n\t\t\t\tdata: {\r\n\t\t\t\t\tcall: functionToPerform,\r\n\t\t\t\t\ttitle: 'genericConfirm',\r\n\t\t\t\t\ttoastrTitle: title,\r\n\t\t\t\t\ttoastrMsg: msg\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.afterClosed()\r\n\t\t\t.pipe(take(1));\r\n\t}\r\n\r\n\tview_Corres(relation) {\r\n\t\tlet url = window.location.href;\r\n\t\twindow.open(url.replace(this.correspondence_id, relation.uid), '_blank');\r\n\t}\r\n\r\n\tshowCorrespondenceInViewer(relation) {\r\n\t\tthis.documentsApi.getDocument(relation.uid).subscribe((file) => {\r\n\t\t\tlet adaptedFile = this.adapter.adaptIn(\r\n\t\t\t\t{ ...file },\r\n\t\t\t\tthis.relationsvc.incomingConstant['fields']\r\n\t\t\t);\r\n\t\t\tthis.viewerFilesService.updateViewer.next(adaptedFile);\r\n\t\t});\r\n\t}\r\n\r\n\thandleMenuItemClicked(event) {\r\n\t\tif (event.action === 'view') {\r\n\t\t\tthis.view_Corres(event.item);\r\n\t\t} else if (event.action === 'delete') {\r\n\t\t\tthis.onDeleteClick(event.item);\r\n\t\t}\r\n\t}\r\n}\r\n","<div class=\"relations-list\" *ngIf=\"relateddoc.length > 0\">\r\n  <ng-container>\r\n    <div *ngFor=\"let group of relateddoc; first as isFirst\">\r\n      <mat-accordion class=\"example-headers-align\" multi>\r\n        <mat-expansion-panel [expanded]=\"isFirst\">\r\n          <mat-expansion-panel-header>\r\n            <mat-panel-title>\r\n              {{\r\n                \"vocabulary.VOC_CorrespondenceRelationsNames.\" + group[0]\r\n                  | translate\r\n              }}\r\n            </mat-panel-title>\r\n          </mat-expansion-panel-header>\r\n          <ng-template matExpansionPanelContent>\r\n            <mat-list>\r\n              <div class=\"mat-list-items\" *ngFor=\"let item of group[1]\">\r\n                <cts-item-list\r\n                  [item]=\"item\"\r\n                  [title]=\"item.title\"\r\n                  [iconname]=\"'link'\"\r\n                  [actions]=\"menu_actions\"\r\n                  (actionclicked)=\"handleMenuItemClicked($event)\"\r\n                  (itemClicked)=\"showCorrespondenceInViewer(item)\"\r\n                  [moreclasses]=\"'link-relation'\"\r\n                ></cts-item-list>\r\n              </div>\r\n            </mat-list>\r\n          </ng-template>\r\n        </mat-expansion-panel>\r\n      </mat-accordion>\r\n    </div>\r\n  </ng-container>\r\n</div>\r\n<div class=\"nocontent\" *ngIf=\"relateddoc.length === 0\">\r\n  <p>{{ \"correspondence-relation.nocontent\" | translate }}</p>\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-relation-list.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-list/correspondence-relation-list.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-list/correspondence-relation-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, ViewEncapsulation } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { take } from 'rxjs/operators';\r\nimport { AdapterService } from '../../../../core/adapters/adapter.service';\r\nimport { ConfirmCallerDialogComponent } from '../../../confirm-caller/confirm-caller.dialog';\r\nimport { DocumentsService } from '../../../documents/services/documents.service';\r\nimport { ViewerFilesService } from '../../services/viewer-files.service';\r\nimport { CorrespondenceRelationService } from '../../services/correspondence-realation.service';\r\nimport { GeneralNotificationPopupComponent } from '../../../../shared/components/general-notification-popup/general-notification-popup.component';\r\n\r\n@Component({\r\n\tselector: 'cts-correspondence-relation-list',\r\n\ttemplateUrl: './correspondence-relation-list.component.html',\r\n\tstyleUrls: ['./correspondence-relation-list.component.scss'],\r\n\tencapsulation: ViewEncapsulation.None\r\n})\r\nexport class CorrespondenceRelationListComponent implements OnInit {\r\n\t@Input()\r\n\tcorrespondence_id;\r\n\t@Input()\r\n\treload: boolean = false;\r\n\trelateddoc: any[] = [];\r\n\tmenu_actions = [\r\n\t\t{ title: 'correspondence-relation.view_corr', name: 'view' },\r\n\t\t{ title: 'correspondence-relation.delete', name: 'delete' }\r\n\t];\r\n\tconstructor(\r\n\t\tprivate relationsvc: CorrespondenceRelationService,\r\n\t\tprivate dialog: MatDialog,\r\n\t\tprivate viewerFilesService: ViewerFilesService,\r\n\t\tprivate documentsApi: DocumentsService,\r\n\t\tprivate adapter: AdapterService\r\n\t) {}\r\n\tngOnInit(): void {\r\n\t\tthis.loadData();\r\n\t\tthis.relationsvc.getUpdatedRelation.subscribe((res) => {\r\n\t\t\tthis.loadData();\r\n\t\t});\r\n\t}\r\n\tloadData() {\r\n\t\tthis.relationsvc\r\n\t\t\t.get_Correspondence_Relation_WithoutReply(this.correspondence_id)\r\n\t\t\t.subscribe((result) => {\r\n\t\t\t\tlet resultarray = result.value;\r\n\t\t\t\tlet resultsgrouped = resultarray.reduce((r, a) => {\r\n\t\t\t\t\tr[a.relationId] = [...(r[a.relationId] || []), a];\r\n\t\t\t\t\treturn r;\r\n\t\t\t\t}, {});\r\n\t\t\t\tthis.relateddoc = [];\r\n\t\t\t\tfor (let group of Object.entries(resultsgrouped)) {\r\n\t\t\t\t\tthis.relateddoc.push(group);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t}\r\n\tonDeleteClick(relateddoc) {\r\n\t\tlet functionToPerform = () => {\r\n\t\t\treturn this.relationsvc.Delete_Named_Relation(\r\n\t\t\t\tthis.correspondence_id,\r\n\t\t\t\trelateddoc.relationId,\r\n\t\t\t\trelateddoc.uid\r\n\t\t\t);\r\n\t\t};\r\n\t\tlet title = '';\r\n\t\tlet msg = '';\r\n\t\tthis.openDialog(\r\n\t\t\tfunctionToPerform,\r\n\t\t\t'Success',\r\n\t\t\t'correspondence-relation.deleted_success'\r\n\t\t).subscribe((data) => {\r\n\t\t\tif (data) {\r\n\t\t\t\tthis.relationsvc.getUpdatedRelation.next();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\topenDialog(functionToPerform, title, msg) {\r\n\t\treturn this.dialog\r\n\t\t\t.open(ConfirmCallerDialogComponent, {\r\n\t\t\t\twidth: '400px',\r\n\t\t\t\tpanelClass: 'relation-confirm-dialog',\r\n\t\t\t\tdata: {\r\n\t\t\t\t\tcall: functionToPerform,\r\n\t\t\t\t\ttitle: 'genericConfirm',\r\n\t\t\t\t\ttoastrTitle: title,\r\n\t\t\t\t\ttoastrMsg: msg\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.afterClosed()\r\n\t\t\t.pipe(take(1));\r\n\t}\r\n\r\n\tview_Corres(relation) {\r\n\t\tif(relation.uid){\r\n\t\t\tlet url = window.location.href;\r\n\t\t\twindow.open(url.replace(this.correspondence_id, relation.uid), '_blank');\r\n\t\t}else{\r\n\t\t\t// he don't have permission to read this correspo\r\n\t\t\tthis.openGeneralNotificationPopup();\r\n\t\t}\r\n\t}\r\n\r\n\tshowCorrespondenceInViewer(relation) {\r\n\t\tif(relation.uid){\r\n\t\t\tthis.documentsApi.getDocument(relation.uid).subscribe((file) => {\r\n\t\t\t\tlet adaptedFile = this.adapter.adaptIn(\r\n\t\t\t\t\t{ ...file },\r\n\t\t\t\t\tthis.relationsvc.incomingConstant['fields']\r\n\t\t\t\t);\r\n\t\t\t\tthis.viewerFilesService.updateViewer.next(adaptedFile);\r\n\t\t\t});\r\n\t\t}else{\r\n\t\t\t// he don't have permission to read this correspo\r\n\t\t\tthis.openGeneralNotificationPopup();\r\n\t\t}\r\n\t}\r\n\r\n\topenGeneralNotificationPopup(){\r\n\t\tthis.dialog\r\n\t\t\t.open(GeneralNotificationPopupComponent, {\r\n\t\t\t\twidth: '500px',\r\n\t\t\t\tpanelClass: 'updated-design-dialog'\r\n\t\t\t})\r\n\t\t\t.afterClosed()\r\n\t\t\t.pipe(take(1));\r\n\t}\r\n\r\n\thandleMenuItemClicked(event) {\r\n\t\tif (event.action === 'view') {\r\n\t\t\tthis.view_Corres(event.item);\r\n\t\t} else if (event.action === 'delete') {\r\n\t\t\tthis.onDeleteClick(event.item);\r\n\t\t}\r\n\t}\r\n}\r\n","<div class=\"relations-list\" *ngIf=\"relateddoc.length > 0\">\r\n  <ng-container>\r\n    <div *ngFor=\"let group of relateddoc; first as isFirst\">\r\n      <mat-accordion class=\"example-headers-align\" multi>\r\n        <mat-expansion-panel [expanded]=\"isFirst\">\r\n          <mat-expansion-panel-header>\r\n            <mat-panel-title>\r\n              {{\r\n                \"vocabulary.VOC_CorrespondenceRelationsNames.\" + group[0]\r\n                  | translate\r\n              }}\r\n            </mat-panel-title>\r\n          </mat-expansion-panel-header>\r\n          <ng-template matExpansionPanelContent>\r\n            <mat-list>\r\n              <div class=\"mat-list-items\" *ngFor=\"let item of group[1]\">\r\n                <cts-item-list\r\n                  [item]=\"item\"\r\n                  [title]=\"item.title\"\r\n                  [iconname]=\"'link'\"\r\n                  [actions]=\"menu_actions\"\r\n                  (actionclicked)=\"handleMenuItemClicked($event)\"\r\n                  (itemClicked)=\"showCorrespondenceInViewer(item)\"\r\n                  [moreclasses]=\"'link-relation'\"\r\n                ></cts-item-list>\r\n              </div>\r\n            </mat-list>\r\n          </ng-template>\r\n        </mat-expansion-panel>\r\n      </mat-accordion>\r\n    </div>\r\n  </ng-container>\r\n</div>\r\n<div class=\"nocontent\" *ngIf=\"relateddoc.length === 0\">\r\n  <p>{{ \"correspondence-relation.nocontent\" | translate }}</p>\r\n</div>\r\n"]}

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

@@ -19,14 +19,15 @@ export class CorrespondenceRelationReplyComponent {
         this.corres_relationsvc
             .getCorrespondeceRelationRevers(this.correspondence_id)
             .subscribe((res) => {
-            if (res['entries'].length > 0) {
-                res['entries'].map(item => {
+            if ((res['entries'] && res['entries'].length > 0) || (res['value'] && res['value'].length > 0)) {
+                let data = res['entries'] || res['value'];
+                data.map(item => {
                     this.replyrelation.push({
-                        title: item.title,
-                        uid: item.uid,
+                        title: item.title || item.subject,
+                        uid: item.uid || item.id,
                         type: item.type,
-                        filecontent: item.properties['file:content'],
-                        direction: item.properties['corr:direction'],
+                        filecontent: item.properties ? item.properties['file:content'] : item['file:content'],
+                        direction: item.properties ? item.properties['corr:direction'] : item['corr:direction'],
                         iconName: 'arrow_upward',
                         moreclasses: "relation-file-icons"
                     });
@@ -36,13 +37,15 @@ export class CorrespondenceRelationReplyComponent {
         this.corres_relationsvc
             .getCorrespondeceRelation(this.correspondence_id)
             .subscribe((res) => {
-            if (res['entries'].length > 0) {
-                res['entries'].map(item => {
+            if ((res['entries'] && res['entries'].length > 0) || (res['value'] && res['value'].length > 0)) {
+                let data = res['entries'] || res['value'];
+                data.map(item => {
                     this.replyrelation.push({
-                        title: item.title,
-                        uid: item.uid, type: item.type,
-                        filecontent: item.properties['file:content'],
-                        direction: item.properties['corr:direction'],
+                        title: item.title || item.subject,
+                        uid: item.uid || item.id,
+                        type: item.type,
+                        filecontent: item.properties ? item.properties['file:content'] : item['file:content'],
+                        direction: item.properties ? item.properties['corr:direction'] : item['corr:direction'],
                         iconName: 'arrow_downward',
                         moreclasses: "relation-file-icons"
                     });
@@ -66,4 +69,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
             }], actionclicked: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correspondence-relation-reply.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-reply/correspondence-relation-reply.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/correspondence-relation/components/correspondence-relation-reply/correspondence-relation-reply.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;;;;;;;AAUlG,MAAM,OAAO,oCAAoC;IAY/C,YAAoB,kBAAiD;QAAjD,uBAAkB,GAAlB,kBAAkB,CAA+B;QAXrE,kBAAa,GAAU,EAAE,CAAC;QAI1B,kBAAa,GAAG,IAAI,YAAY,EAAE,CAAC;QAMnC,iBAAY,GAAG,CAAC,EAAE,KAAK,EAAE,mCAAmC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IACL,CAAC;IAL1E,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;QAC9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1D,CAAC;IAKD,QAAQ;QACN,IAAI,CAAC,kBAAkB;aACpB,8BAA8B,CAAC,IAAI,CAAC,iBAAiB,CAAC;aACtD,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE;gBAC9F,IAAI,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAA;gBACzC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;oBACd,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB;wBACE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO;wBACjC,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,EAAE;wBACxB,IAAI,EAAE,IAAI,CAAC,IAAI;wBACf,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;wBACrF,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;wBACvF,QAAQ,EAAE,cAAc;wBACxB,WAAW,EAAE,qBAAqB;qBACnC,CACF,CAAA;gBACH,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,kBAAkB;aACpB,wBAAwB,CAAC,IAAI,CAAC,iBAAiB,CAAC;aAChD,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;YACjB,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE;gBAC9F,IAAI,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,CAAA;gBACzC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;oBACd,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB;wBACE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO;wBACjC,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,EAAE;wBACxB,IAAI,EAAE,IAAI,CAAC,IAAI;wBACf,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;wBACrF,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;wBACvF,QAAQ,EAAE,gBAAgB;wBAC1B,WAAW,EAAE,qBAAqB;qBACnC,CACF,CAAA;gBACH,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACP,CAAC;;kIAvDU,oCAAoC;sHAApC,oCAAoC,0KCVjD,qvBAoBA;4FDVa,oCAAoC;kBANhD,SAAS;mBAAC;oBACT,QAAQ,EAAE,mCAAmC;oBAC7C,WAAW,EAAE,gDAAgD;oBAC7D,SAAS,EAAE,CAAC,6EAA6E,CAAC;oBAC1F,aAAa,EAAG,iBAAiB,CAAC,IAAI;iBACvC;oHAIC,iBAAiB;sBADhB,KAAK;gBAGN,aAAa;sBADZ,MAAM","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output, ViewEncapsulation } from '@angular/core';\r\n\r\nimport { CorrespondenceRelationService } from '../../services/correspondence-realation.service';\r\n\r\n@Component({\r\n  selector: 'cts-correspondence-relation-reply',\r\n  templateUrl: './correspondence-relation-reply.component.html',\r\n  styleUrls: ['../correspondence-relation-list/correspondence-relation-list.component.scss'],\r\n  encapsulation : ViewEncapsulation.None\r\n})\r\nexport class CorrespondenceRelationReplyComponent implements OnInit {\r\n  replyrelation: any[] = [];\r\n  @Input()\r\n  correspondence_id: string;\r\n  @Output()\r\n  actionclicked = new EventEmitter();\r\n\r\n  fireAction(item, action = 'show') {\r\n    this.actionclicked.next({ action: action, item: item });\r\n  }\r\n\r\n  menu_actions = [{ title: 'correspondence-relation.view_corr', name: 'view' }];\r\n  constructor(private corres_relationsvc: CorrespondenceRelationService) { }\r\n\r\n  ngOnInit(): void {\r\n    this.corres_relationsvc\r\n      .getCorrespondeceRelationRevers(this.correspondence_id)\r\n      .subscribe((res) => {\r\n        if ((res['entries'] && res['entries'].length > 0) || (res['value'] && res['value'].length > 0)) {\r\n          let data = res['entries'] || res['value']\r\n          data.map(item => {\r\n            this.replyrelation.push(\r\n              {\r\n                title: item.title || item.subject, \r\n                uid: item.uid || item.id, \r\n                type: item.type, \r\n                filecontent: item.properties ? item.properties['file:content'] : item['file:content'], \r\n                direction: item.properties ? item.properties['corr:direction'] : item['corr:direction'], \r\n                iconName: 'arrow_upward', \r\n                moreclasses: \"relation-file-icons\"\r\n              }\r\n            )\r\n          });\r\n        }\r\n      });\r\n    this.corres_relationsvc\r\n      .getCorrespondeceRelation(this.correspondence_id)\r\n      .subscribe((res) => {\r\n        if ((res['entries'] && res['entries'].length > 0) || (res['value'] && res['value'].length > 0)) {\r\n          let data = res['entries'] || res['value']\r\n          data.map(item => {\r\n            this.replyrelation.push(\r\n              {\r\n                title: item.title || item.subject, \r\n                uid: item.uid || item.id, \r\n                type: item.type, \r\n                filecontent: item.properties ? item.properties['file:content'] : item['file:content'], \r\n                direction: item.properties ? item.properties['corr:direction'] : item['corr:direction'], \r\n                iconName: 'arrow_downward', \r\n                moreclasses: \"relation-file-icons\"\r\n              }\r\n            )\r\n          });\r\n        }\r\n      });\r\n  }\r\n\r\n}\r\n","<div class=\"relations-list\" *ngIf=\"replyrelation.length > 0\">\r\n  <ng-container>\r\n    <mat-list>\r\n      <div class=\"mat-list-items\" *ngFor=\"let item of replyrelation\">\r\n        <cts-item-list\r\n          [item]=\"item\"\r\n          [title]=\"item.title\"\r\n          [actions]=\"menu_actions\"\r\n          [iconname]=\"item.iconName\"\r\n          [moreclasses]=\"item.moreclasses\"\r\n          (actionclicked)=\"fireAction(item, 'view')\"\r\n          (itemClicked)=\"fireAction(item)\"\r\n        ></cts-item-list>\r\n      </div>\r\n    </mat-list>\r\n  </ng-container>\r\n</div>\r\n<div class=\"nocontent\" *ngIf=\"replyrelation.length === 0\">\r\n  <p>{{ \"correspondence-relation.nocontentreply\" | translate }}</p>\r\n</div>\r\n"]}

package/esm2015/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.js

@@ -100,7 +100,7 @@ export class DynamicFilterComponent {
     }
 }
 DynamicFilterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFilterComponent, deps: [{ token: i1.TranslationService }], target: i0.ɵɵFactoryTarget.Component });
-DynamicFilterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFilterComponent, selector: "cts-dynamic-filter", inputs: { title: "title", filters: "filters", selections: "selections", id: "id", entityType: "entityType", prefix: "prefix", department: "department", componentType: "componentType", customPageProvider: "customPageProvider", config: "config" }, outputs: { onFilterSelected: "onFilterSelected" }, ngImport: i0, template: "<div class=\"aggregation-container\">\r\n  <div class=\"search-title\">\r\n    {{ prefix + \".\" + title | translate }}\r\n  </div>\r\n  <ng-container *ngIf=\"filters && componentType != 'colorsCodes'\">\r\n    <ng-container *ngFor=\"let group of filters; index as i\">\r\n      <div *ngIf=\"i < 5 || more\" class=\"search-checkbox\">\r\n        <!-- <input\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          type=\"checkbox\"\r\n          (change)=\"onFilterSelect(group.key, $event.target.checked)\"\r\n        /> -->\r\n        <!-- <div class=\"mx-8\">\r\n          <span [ngSwitch]=\"EntityType(group.fetchedKey)\">\r\n            <span *ngSwitchCase=\"'directoryEntry'\">\r\n              {{\r\n                \"vocabulary.\" + group.fetchedKey.directoryName + \".\" + group.key\r\n                  | translate\r\n              }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.fetchedKey.properties.firstName +\r\n                  \" \" +\r\n                  group.fetchedKey.properties.lastName\r\n              }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi>\r\n        </div> -->\r\n        <mat-checkbox\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          (change)=\"onFilterSelect(group.key, $event.checked)\"\r\n        >\r\n          <span [ngSwitch]=\"componentType\" class=\"aggregation-label\">\r\n\r\n            <span *ngSwitchCase=\"'custom-voc'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'vocabulary'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.key === 'system' ? ('SYSTEM_ADMIN' | translate) : (group.fetchedKey.properties.firstName + \" \" + group.fetchedKey.properties.lastName)\r\n              }}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-pp'\">\r\n              <lib-custom-pp-viewer [pageProvider]=\"customPageProvider\" [config]=\"config\" [group]=\"group\"></lib-custom-pp-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-document'\">\r\n              <lib-custom-document-viewer [pageProvider]=\"customPageProvider\" [group]=\"group\"></lib-custom-document-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'department'\">\r\n              <cts-department-viewer\r\n              [noStyle]=\"true\"\r\n              [value]=\"group.key\"\r\n            >\r\n            </cts-department-viewer>\r\n            <!-- {{group.key}} -->\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-department'\">\r\n              {{isArabic ? group.fetchedKey.properties[config.propertyAr] : group.fetchedKey.properties[config.propertyEn]}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'string'\">\r\n              <span>{{group.key}}</span>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi></mat-checkbox\r\n        >\r\n      </div>\r\n    </ng-container>\r\n    <div *ngIf=\"filters.length > 5\" class=\"more\">\r\n      <button class=\"btn-more\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <ng-container *ngIf=\"filters && componentType == 'colorsCodes'\">\r\n    <div class=\"flex flex-wrap colorsContainer\">\r\n      <ng-container *ngFor=\"let group of filters; index as i\">\r\n          <div *ngIf=\"i < 24 || more\" class=\"color-search-checkbox flex items-end justify-start\" [style.backgroundColor]=\"group.key\"\r\n          matTooltip=\"{{'search.colorInOtherPhotos' | translate :{num:group.docCount} }}\" [matTooltipPosition]=\"'above'\" \r\n          (click)=\"onFilterSelect(group.key, (_selections.includes(group.key)) ? false : true)\">\r\n            <span class=\"checkIcon bi bi-check\" *ngIf=\"_selections.includes(group.key)\" [ngStyle]=\"{color: (isWhiteOrClosetToWhite(group.key)) ? 'black': 'white'}\"></span>\r\n          </div>\r\n        \r\n      </ng-container>\r\n    </div>\r\n    <div *ngIf=\"filters.length > 20\" class=\"more\">\r\n      <button class=\"btn-more mt-1\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n\r\n\r\n  \r\n</div>\r\n", styles: [".bi{margin:0!important}.memo-sorting-wrapper{width:265px;margin:0 10px;height:100%;display:flex}.memo-sorting-wrapper .sorting-direction{width:65px;height:40px;background-color:#465573;color:#fff;font-size:20px;display:flex;justify-content:center;align-items:center;cursor:pointer}.memo-sorting-wrapper .memo-sorting-trigger{width:calc(100% - 65px);height:100%;background-color:transparent;border:1px solid lightgrey;display:flex;justify-content:space-between;align-items:center;padding:0 15px;font-size:14px}.memo-sorting-wrapper .memo-sorting-trigger i{font-size:16px;color:gray}.memo-sorting-menu{width:200px}.my-button{border:1px solid #465573;color:#465573;border-radius:5px;background-color:transparent;font-weight:bold;min-width:80px;height:40px}.my-button.reset{border:none}.my-button:hover{color:#fff;background-color:#465573}.my-button:hover.reset{color:#465573;border:1px solid #465573;background-color:#fff}.app-property-value .app-input-wrapper label{color:#646f85;font-size:13px;margin-bottom:5px}.app-property-value .app-input-wrapper label .text-danger{font-size:16px;line-height:14px;margin:0 5px!important}.app-property-value .app-input-wrapper .form-control{border:1px solid #ccc;border-radius:5px;background-color:#8f98aa1a;height:40px}.app-property-value .app-input-wrapper .form-control:disabled{background-color:#e9ecef!important}.app-property-value .app-input-wrapper .form-control:focus{border:1px solid #1a96c6;box-shadow:0 0 4px #79c3c26b!important}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers{list-style:none;padding:0;margin:0;font-size:14px}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers .error{margin-top:5px}.autocomplete-container .input-container input:focus,hijri-gregorian-datepicker .form-group .input-group .form-control:focus,.ng-select.ng-select-focused .ng-select-container{border:1px solid #1a96c6!important;box-shadow:0 0 4px #79c3c26b!important}input::placeholder{font-size:12px}.form-control:focus{box-shadow:none!important}.mat-stepper-horizontal{margin-top:-25px}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header.cdk-program-focused{background-color:transparent}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-icon-selected{background-color:transparent;color:#fff;background-image:linear-gradient(to right,#0dbab5,#1a96c6)}@media only screen and (max-width: 576px){.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-label .mat-step-text-label{white-space:pre-wrap;overflow:visible}}.mat-stepper-horizontal .mat-horizontal-content-container{overflow:visible}@media only screen and (max-width: 768px){.mat-stepper-horizontal .mat-horizontal-content-container{padding:0 0 24px}}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:after,.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:before{display:none}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:before{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);left:0}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:after{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);right:0}.form-wrapper{padding:30px 15px;border:1px solid #dde0e2}.form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.form-wrapper .buttons-wrapper button:hover{opacity:.7}.form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.form-wrapper .upload-wrapper button span{margin:0 10px}.renameFileComponent .form-wrapper{padding:30px 15px;border:none!important}.renameFileComponent .form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.renameFileComponent .form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.renameFileComponent .form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.renameFileComponent .form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.renameFileComponent .form-wrapper .buttons-wrapper button:hover{opacity:.7}.renameFileComponent .form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.renameFileComponent .form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.renameFileComponent .form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.renameFileComponent .form-wrapper .upload-wrapper button span{margin:0 10px}.my-dynamic-viewer{display:flex;align-items:center;font-size:12px;min-height:30px}.my-dynamic-viewer .my-label{font-size:12px;font-weight:500;width:150px;word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-label{width:50%}}.my-dynamic-viewer .my-value{width:calc(100% - 150px);word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-value{width:50%}}.my-dynamic-viewer .direction-img{font-size:14px}.my-dynamic-viewer .direction-img .incoming{display:none}.my-dynamic-viewer .direction-img .outgoing{display:none}.my-dynamic-viewer .direction-img .internal{display:none}.my-dynamic-viewer.draft .my-value{color:#596973}.my-dynamic-viewer.inProgress .my-value{color:#3c3cf0}.my-dynamic-viewer.registered .my-value{color:#4f008c}.my-dynamic-viewer.archived .my-value{color:#fbb62c}.my-dynamic-viewer.closed .my-value{color:#00dca5}.my-dynamic-viewer.approved .my-value{color:#06a57e}.my-dynamic-viewer.assigned .my-value{color:#fd6670}.my-dynamic-viewer.sent .my-value{color:#3c3cf0}.my-dynamic-viewer.published .my-value{color:#00dca5}.my-dynamic-viewer.Outgoing .my-value{display:flex}.my-dynamic-viewer.Outgoing .my-value .direction-img .outgoing{color:#fbb62c;margin:1px 5px;display:flex}.my-dynamic-viewer.Outgoing .my-value .text{margin:0 5px}.my-dynamic-viewer.Internal .my-value{display:flex}.my-dynamic-viewer.Internal .my-value .direction-img .internal{color:#3c3cf0;margin:1px 5px;display:flex}.my-dynamic-viewer.Internal .my-value .text{margin:0 5px}.my-dynamic-viewer.Incoming .my-value{display:flex}.my-dynamic-viewer.Incoming .my-value .direction-img .incoming{color:#00dca5;display:flex}.my-dynamic-viewer.Incoming .my-value .text{margin:-3px 5px 0}.my-dynamic-viewer.vertical{display:block}.my-dynamic-viewer.vertical .my-label{width:auto}.my-dynamic-viewer.vertical .my-value{width:auto}.my-dynamic-viewer.with-out-label{width:100%!important}.mx-8{margin-left:8px;margin-right:8px}.aggregation-container{border-bottom:1px solid #b4bac6;padding-bottom:8px}.aggregation-container .search-title{margin-bottom:6px;margin-top:6px;border-bottom-width:2px;font-weight:700;--tw-text-opacity: 1;color:rgba(70,85,115,var(--tw-text-opacity))}.aggregation-container .search-checkbox{display:flex;align-items:center;margin-bottom:.5rem}.aggregation-container .colorsContainer{overflow:visible;width:max-content;max-width:252px;grid-gap:4px;gap:4px}.aggregation-container .color-search-checkbox{width:28px;height:28px;box-shadow:#00000059 3px 5px 10px;transition:all .2s ease-in-out;cursor:pointer;border-radius:10%/50%}.aggregation-container .color-search-checkbox .checkIcon{width:1rem;height:1rem;min-width:1rem;min-height:1rem;font-size:1rem;line-height:1rem;color:#fff}.aggregation-container .color-search-checkbox:hover{transform:scale(1.3)}.aggregation-container .mat-checkbox-ripple .mat-ripple-element,.aggregation-container .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#33e3b7!important}.aggregation-container .mat-checkbox-ripple .mat-ripple-element{position:fixed;left:inherit;top:inherit;transform:translate(-3px,-3px)!important}.aggregation-container mat-checkbox .mat-checkbox-background{background-color:#d9dce2!important}.aggregation-container mat-checkbox .mat-checkbox-inner-container{transform:scale(1.1)}.aggregation-container .justify-items-center{justify-items:center}.aggregation-container .more{display:flex;justify-content:center}.aggregation-container .btn-more{border-bottom-width:2px;--tw-border-opacity: 1;border-color:rgba(217,220,226,var(--tw-border-opacity));background:none;border:none;margin:0;padding:0;color:#00f}.rtl mat-checkbox .mat-checkbox-inner-container{margin-right:0!important;margin-left:8px!important}\n"], components: [{ type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "id", "labelPosition", "name", "required", "checked", "disabled", "indeterminate", "aria-describedby", "value"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.CutomeVocViewerComponent, selector: "lib-cutome-voc-viewer", inputs: ["type", "group"] }, { type: i4.CustomPpViewerComponent, selector: "lib-custom-pp-viewer", inputs: ["pageProvider", "group", "config"] }, { type: i5.CustomDocumentViewerComponent, selector: "lib-custom-document-viewer", inputs: ["pageProvider", "group"] }, { type: i6.DepartmentViewerComponent, selector: "cts-department-viewer", inputs: ["label", "value", "dropdownId", "vertical", "withOutLabel", "noStyle"] }], directives: [{ type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i7.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i7.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { type: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltipPosition", "matTooltipDisabled", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { type: i7.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], pipes: { "translate": i9.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+DynamicFilterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFilterComponent, selector: "cts-dynamic-filter", inputs: { title: "title", filters: "filters", selections: "selections", id: "id", entityType: "entityType", prefix: "prefix", department: "department", componentType: "componentType", customPageProvider: "customPageProvider", config: "config", aggregation: "aggregation" }, outputs: { onFilterSelected: "onFilterSelected" }, ngImport: i0, template: "<div class=\"aggregation-container\">\r\n  <div class=\"search-title\">\r\n    {{ prefix + \".\" + title | translate }}\r\n  </div>\r\n  <ng-container *ngIf=\"filters && componentType != 'colorsCodes'\">\r\n    <ng-container *ngFor=\"let group of filters; index as i\">\r\n      <div *ngIf=\"i < 5 || more\" class=\"search-checkbox\">\r\n        <!-- <input\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          type=\"checkbox\"\r\n          (change)=\"onFilterSelect(group.key, $event.target.checked)\"\r\n        /> -->\r\n        <!-- <div class=\"mx-8\">\r\n          <span [ngSwitch]=\"EntityType(group.fetchedKey)\">\r\n            <span *ngSwitchCase=\"'directoryEntry'\">\r\n              {{\r\n                \"vocabulary.\" + group.fetchedKey.directoryName + \".\" + group.key\r\n                  | translate\r\n              }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.fetchedKey.properties.firstName +\r\n                  \" \" +\r\n                  group.fetchedKey.properties.lastName\r\n              }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi>\r\n        </div> -->\r\n        <mat-checkbox\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          (change)=\"onFilterSelect(group.key, $event.checked)\"\r\n        >\r\n          <span [ngSwitch]=\"componentType\" class=\"aggregation-label\">\r\n\r\n            <span *ngSwitchCase=\"'custom-voc'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'vocabulary'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.key === 'system' ? ('SYSTEM_ADMIN' | translate) : (group.fetchedKey.properties.firstName + \" \" + group.fetchedKey.properties.lastName)\r\n              }}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'agency'\">\r\n              {{ (aggregation.prefix +  group.key) | translate}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-pp'\">\r\n              <lib-custom-pp-viewer [pageProvider]=\"customPageProvider\" [config]=\"config\" [group]=\"group\"></lib-custom-pp-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-document'\">\r\n              <lib-custom-document-viewer [pageProvider]=\"customPageProvider\" [group]=\"group\"></lib-custom-document-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'department'\">\r\n              <cts-department-viewer\r\n              [noStyle]=\"true\"\r\n              [value]=\"group.key\"\r\n            >\r\n            </cts-department-viewer>\r\n            <!-- {{group.key}} -->\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-department'\">\r\n              {{isArabic ? group.fetchedKey.properties[config.propertyAr] : group.fetchedKey.properties[config.propertyEn]}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'string'\">\r\n              <span>{{group.key}}</span>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi></mat-checkbox\r\n        >\r\n      </div>\r\n    </ng-container>\r\n    <div *ngIf=\"filters.length > 5\" class=\"more\">\r\n      <button class=\"btn-more\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <ng-container *ngIf=\"filters && componentType == 'colorsCodes'\">\r\n    <div class=\"flex flex-wrap colorsContainer\">\r\n      <ng-container *ngFor=\"let group of filters; index as i\">\r\n          <div *ngIf=\"i < 24 || more\" class=\"color-search-checkbox flex items-end justify-start\" [style.backgroundColor]=\"group.key\"\r\n          matTooltip=\"{{'search.colorInOtherPhotos' | translate :{num:group.docCount} }}\" [matTooltipPosition]=\"'above'\" \r\n          (click)=\"onFilterSelect(group.key, (_selections.includes(group.key)) ? false : true)\">\r\n            <span class=\"checkIcon bi bi-check\" *ngIf=\"_selections.includes(group.key)\" [ngStyle]=\"{color: (isWhiteOrClosetToWhite(group.key)) ? 'black': 'white'}\"></span>\r\n          </div>\r\n        \r\n      </ng-container>\r\n    </div>\r\n    <div *ngIf=\"filters.length > 20\" class=\"more\">\r\n      <button class=\"btn-more mt-1\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n\r\n\r\n  \r\n</div>\r\n", styles: [".bi{margin:0!important}.memo-sorting-wrapper{width:265px;margin:0 10px;height:100%;display:flex}.memo-sorting-wrapper .sorting-direction{width:65px;height:40px;background-color:#465573;color:#fff;font-size:20px;display:flex;justify-content:center;align-items:center;cursor:pointer}.memo-sorting-wrapper .memo-sorting-trigger{width:calc(100% - 65px);height:100%;background-color:transparent;border:1px solid lightgrey;display:flex;justify-content:space-between;align-items:center;padding:0 15px;font-size:14px}.memo-sorting-wrapper .memo-sorting-trigger i{font-size:16px;color:gray}.memo-sorting-menu{width:200px}.my-button{border:1px solid #465573;color:#465573;border-radius:5px;background-color:transparent;font-weight:bold;min-width:80px;height:40px}.my-button.reset{border:none}.my-button:hover{color:#fff;background-color:#465573}.my-button:hover.reset{color:#465573;border:1px solid #465573;background-color:#fff}.app-property-value .app-input-wrapper label{color:#646f85;font-size:13px;margin-bottom:5px}.app-property-value .app-input-wrapper label .text-danger{font-size:16px;line-height:14px;margin:0 5px!important}.app-property-value .app-input-wrapper .form-control{border:1px solid #ccc;border-radius:5px;background-color:#8f98aa1a;height:40px}.app-property-value .app-input-wrapper .form-control:disabled{background-color:#e9ecef!important}.app-property-value .app-input-wrapper .form-control:focus{border:1px solid #1a96c6;box-shadow:0 0 4px #79c3c26b!important}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers{list-style:none;padding:0;margin:0;font-size:14px}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers .error{margin-top:5px}.autocomplete-container .input-container input:focus,hijri-gregorian-datepicker .form-group .input-group .form-control:focus,.ng-select.ng-select-focused .ng-select-container{border:1px solid #1a96c6!important;box-shadow:0 0 4px #79c3c26b!important}input::placeholder{font-size:12px}.form-control:focus{box-shadow:none!important}.mat-stepper-horizontal{margin-top:-25px}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header.cdk-program-focused{background-color:transparent}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-icon-selected{background-color:transparent;color:#fff;background-image:linear-gradient(to right,#0dbab5,#1a96c6)}@media only screen and (max-width: 576px){.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-label .mat-step-text-label{white-space:pre-wrap;overflow:visible}}.mat-stepper-horizontal .mat-horizontal-content-container{overflow:visible}@media only screen and (max-width: 768px){.mat-stepper-horizontal .mat-horizontal-content-container{padding:0 0 24px}}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:after,.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:before{display:none}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:before{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);left:0}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:after{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);right:0}.form-wrapper{padding:30px 15px;border:1px solid #dde0e2}.form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.form-wrapper .buttons-wrapper button:hover{opacity:.7}.form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.form-wrapper .upload-wrapper button span{margin:0 10px}.renameFileComponent .form-wrapper{padding:30px 15px;border:none!important}.renameFileComponent .form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.renameFileComponent .form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.renameFileComponent .form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.renameFileComponent .form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.renameFileComponent .form-wrapper .buttons-wrapper button:hover{opacity:.7}.renameFileComponent .form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.renameFileComponent .form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.renameFileComponent .form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.renameFileComponent .form-wrapper .upload-wrapper button span{margin:0 10px}.my-dynamic-viewer{display:flex;align-items:center;font-size:12px;min-height:30px}.my-dynamic-viewer .my-label{font-size:12px;font-weight:500;width:150px;word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-label{width:50%}}.my-dynamic-viewer .my-value{width:calc(100% - 150px);word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-value{width:50%}}.my-dynamic-viewer .direction-img{font-size:14px}.my-dynamic-viewer .direction-img .incoming{display:none}.my-dynamic-viewer .direction-img .outgoing{display:none}.my-dynamic-viewer .direction-img .internal{display:none}.my-dynamic-viewer.draft .my-value{color:#596973}.my-dynamic-viewer.inProgress .my-value{color:#3c3cf0}.my-dynamic-viewer.registered .my-value{color:#4f008c}.my-dynamic-viewer.archived .my-value{color:#fbb62c}.my-dynamic-viewer.closed .my-value{color:#00dca5}.my-dynamic-viewer.approved .my-value{color:#06a57e}.my-dynamic-viewer.assigned .my-value{color:#fd6670}.my-dynamic-viewer.sent .my-value{color:#3c3cf0}.my-dynamic-viewer.published .my-value{color:#00dca5}.my-dynamic-viewer.Outgoing .my-value{display:flex}.my-dynamic-viewer.Outgoing .my-value .direction-img .outgoing{color:#fbb62c;margin:1px 5px;display:flex}.my-dynamic-viewer.Outgoing .my-value .text{margin:0 5px}.my-dynamic-viewer.Internal .my-value{display:flex}.my-dynamic-viewer.Internal .my-value .direction-img .internal{color:#3c3cf0;margin:1px 5px;display:flex}.my-dynamic-viewer.Internal .my-value .text{margin:0 5px}.my-dynamic-viewer.Incoming .my-value{display:flex}.my-dynamic-viewer.Incoming .my-value .direction-img .incoming{color:#00dca5;display:flex}.my-dynamic-viewer.Incoming .my-value .text{margin:-3px 5px 0}.my-dynamic-viewer.vertical{display:block}.my-dynamic-viewer.vertical .my-label{width:auto}.my-dynamic-viewer.vertical .my-value{width:auto}.my-dynamic-viewer.with-out-label{width:100%!important}.mx-8{margin-left:8px;margin-right:8px}.aggregation-container{border-bottom:1px solid #b4bac6;padding-bottom:8px}.aggregation-container .search-title{margin-bottom:6px;margin-top:6px;border-bottom-width:2px;font-weight:700;--tw-text-opacity: 1;color:rgba(70,85,115,var(--tw-text-opacity))}.aggregation-container .search-checkbox{display:flex;align-items:center;margin-bottom:.5rem}.aggregation-container .colorsContainer{overflow:visible;width:max-content;max-width:252px;grid-gap:4px;gap:4px}.aggregation-container .color-search-checkbox{width:28px;height:28px;box-shadow:#00000059 3px 5px 10px;transition:all .2s ease-in-out;cursor:pointer;border-radius:10%/50%}.aggregation-container .color-search-checkbox .checkIcon{width:1rem;height:1rem;min-width:1rem;min-height:1rem;font-size:1rem;line-height:1rem;color:#fff}.aggregation-container .color-search-checkbox:hover{transform:scale(1.3)}.aggregation-container .mat-checkbox-ripple .mat-ripple-element,.aggregation-container .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#33e3b7!important}.aggregation-container .mat-checkbox-ripple .mat-ripple-element{position:fixed;left:inherit;top:inherit;transform:translate(-3px,-3px)!important}.aggregation-container mat-checkbox .mat-checkbox-background{background-color:#d9dce2!important}.aggregation-container mat-checkbox .mat-checkbox-inner-container{transform:scale(1.1)}.aggregation-container .justify-items-center{justify-items:center}.aggregation-container .more{display:flex;justify-content:center}.aggregation-container .btn-more{border-bottom-width:2px;--tw-border-opacity: 1;border-color:rgba(217,220,226,var(--tw-border-opacity));background:none;border:none;margin:0;padding:0;color:#00f}.rtl mat-checkbox .mat-checkbox-inner-container{margin-right:0!important;margin-left:8px!important}\n"], components: [{ type: i2.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex", "aria-label", "aria-labelledby", "id", "labelPosition", "name", "required", "checked", "disabled", "indeterminate", "aria-describedby", "value"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { type: i3.CutomeVocViewerComponent, selector: "lib-cutome-voc-viewer", inputs: ["type", "group"] }, { type: i4.CustomPpViewerComponent, selector: "lib-custom-pp-viewer", inputs: ["pageProvider", "group", "config"] }, { type: i5.CustomDocumentViewerComponent, selector: "lib-custom-document-viewer", inputs: ["pageProvider", "group"] }, { type: i6.DepartmentViewerComponent, selector: "cts-department-viewer", inputs: ["label", "value", "dropdownId", "vertical", "withOutLabel", "noStyle"] }], directives: [{ type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i7.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i7.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { type: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltipPosition", "matTooltipDisabled", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { type: i7.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], pipes: { "translate": i9.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFilterComponent, decorators: [{
             type: Component,
             args: [{
@@ -133,5 +133,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                 type: Input
             }], config: [{
                 type: Input
+            }], aggregation: [{
+                type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-filter.component.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.ts","../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EAEL,MAAM,EACN,iBAAiB,GAClB,MAAM,eAAe,CAAC;;;;;;;;;;;AAIvB;;;;;;;;;;;;;;;;;GAiBG;AAOH,MAAM,OAAO,sBAAsB;IAiCjC,YAAoB,kBAAuC;QAAvC,uBAAkB,GAAlB,kBAAkB,CAAqB;QAhC3D,6BAA6B;QACnB,qBAAgB,GAAG,IAAI,YAAY,EAAE,CAAC;QAGhD,iCAAiC;QAEjC,UAAK,GAAG,EAAE,CAAC;QAiBX,kCAAkC;QAElC,eAAU,GAAY,KAAK,CAAC;QACnB,kBAAa,GAAG,QAAQ,CAAC;QAGlC,SAAI,GAAG,KAAK,CAAC;QACb,aAAQ,GAAG,KAAK,CAAC;IAE6C,CAAC;IAtB/D,iEAAiE;IACjE,IACI,UAAU,CAAC,GAAG;QAChB,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;IACzB,CAAC;IAoBD,QAAQ;QACN,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC9E,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;QACtB,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,cAAc,CAAC,aAAa,EAAE,CAAC;QAC7B,IAAI,CAAC,EAAE;YACL,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACrC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC;gBACzB,MAAM,EAAE;oBACN,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;iBACjD;gBACD,IAAI,EAAE,IAAI,CAAC,UAAU;aACtB,CAAC,CAAC;SACJ;aAAM;YACL,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC/C,OAAO,CAAC,IAAI,aAAa,CAAC;YAC5B,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC;gBACzB,MAAM,EAAE;oBACN,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;iBACjD;gBACD,IAAI,EAAE,IAAI,CAAC,UAAU;aACtB,CAAC,CAAC;SACJ;IACH,CAAC;IAED,UAAU,CAAC,UAAU;QACnB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,MAAM,OAAO,GAAG,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,CAAC;YACtE,IAAI,OAAO,EAAE;gBACX,OAAO,UAAU,CAAC,aAAa,CAAC,CAAC;aAClC;iBAAM;gBACL,OAAO,KAAK,CAAC;aACd;SACF;aAAK;YACJ,OAAO,YAAY,CAAA;SACpB;IACH,CAAC;IACD,sBAAsB,CAAC,SAAS;QAC5B,IAAI,UAAU,GAAG,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,GAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC;QAChD,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,GAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC;QAChD,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,GAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC;QAChD,IAAG,CAAC,GAAG,UAAU,IAAI,CAAC,GAAG,UAAU,IAAI,CAAC,GAAG,UAAU,EAAE;YACnD,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,WAAW;QACT,IAAI,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACnF,CAAC;;oHAvFU,sBAAsB;wGAAtB,sBAAsB,mWCnCnC,khKA0HA;4FDvFa,sBAAsB;kBANlC,SAAS;mBAAC;oBACT,QAAQ,EAAE,oBAAoB;oBAC9B,WAAW,EAAE,iCAAiC;oBAC9C,SAAS,EAAE,CAAC,iCAAiC,CAAC;oBAC9C,aAAa,EAAE,iBAAiB,CAAC,IAAI;iBACtC;yGAGW,gBAAgB;sBAAzB,MAAM;gBAKP,KAAK;sBADJ,KAAK;;QAGN,oBAAoB;QACpB,OAAO;sBAFN,KAAK;gBAKF,UAAU;sBADb,KAAK;gBAMN,EAAE;sBADD,KAAK;gBAGN,UAAU;sBADT,KAAK;gBAIN,MAAM;sBADL,KAAK;gBAIN,UAAU;sBADT,KAAK;gBAEG,aAAa;sBAArB,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBACG,MAAM;sBAAd,KAAK","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { TranslationService } from '../../../core/services/translation/translation.service';\r\n\r\n/**\r\n * Dyanamic filter is a component that leverages Nuxeo Elastic search aggregation buckets data to dynamically\r\n * generate data filtering checkbox groups & emits checkbox selection for consumption\r\n * @title\r\n * Dynamic Filter\r\n *\r\n * @example\r\n *\r\n * <cts-dynamic-filter\r\n *   [entityType]=\"entityType\"\r\n *   [filters]=\"aggregationBuckets\"\r\n *   [id]=\"aggregationId\"\r\n *   [selections]=\"aggregationSelection\"\r\n *   [title]=\"aggregationField\"\r\n *   [prefix]=\"'search'\"\r\n *   (onFilterSelected)=\"FilterSelected($event)\">\r\n * </cts-dynamic-filter>\r\n */\r\n@Component({\r\n  selector: 'cts-dynamic-filter',\r\n  templateUrl: './dynamic-filter.component.html',\r\n  styleUrls: ['./dynamic-filter.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class DynamicFilterComponent implements OnInit {\r\n  /** emits array of filters */\r\n  @Output() onFilterSelected = new EventEmitter();\r\n  public _selections;\r\n\r\n  /** title of the filters group */\r\n  @Input()\r\n  title = '';\r\n  @Input()\r\n  /** filters group */\r\n  filters;\r\n  /** new filters coming from the backend based on the selection */\r\n  @Input()\r\n  set selections(val) {\r\n    this._selections = val;\r\n  }\r\n  /** Aggregation ID */\r\n  @Input()\r\n  id;\r\n  @Input()\r\n  entityType;\r\n  /** static  path for translation passed from out side according to each page translation path */\r\n  @Input()\r\n  prefix;\r\n  /** special type for department */\r\n  @Input()\r\n  department: boolean = false;\r\n  @Input() componentType = 'defult';\r\n  @Input() customPageProvider ;\r\n  @Input() config ;\r\n  more = false;\r\n  isArabic = false;\r\n  translationSubscription : Subscription;\r\n  constructor(private translationService : TranslationService) {}\r\n\r\n  ngOnInit(): void {\r\n    this.translationSubscription = this.translationService.isArabic.subscribe(res => {\r\n      this.isArabic = res;\r\n    })\r\n  }\r\n\r\n  onFilterSelect(committeeName, e) {\r\n    if (e) {\r\n      this._selections.push(committeeName);\r\n      this.onFilterSelected.emit({\r\n        filter: {\r\n          [this.id]: JSON.stringify([...this._selections]),\r\n        },\r\n        type: this.entityType,\r\n      });\r\n    } else {\r\n      this._selections = this._selections.filter((e) => {\r\n        return e != committeeName;\r\n      });\r\n      this.onFilterSelected.emit({\r\n        filter: {\r\n          [this.id]: JSON.stringify([...this._selections]),\r\n        },\r\n        type: this.entityType,\r\n      });\r\n    }\r\n  }\r\n\r\n  EntityType(fetchedKey) {\r\n    if (!this.department) {\r\n      const typeObj = typeof fetchedKey === 'object' && fetchedKey !== null;\r\n      if (typeObj) {\r\n        return fetchedKey['entity-type'];\r\n      } else {\r\n        return false;\r\n      }\r\n    }else {\r\n      return 'department'\r\n    }\r\n  }\r\n  isWhiteOrClosetToWhite(colorCode) {\r\n      let whiteLimit = 200; \r\n      let r = parseInt(\"0x\"+colorCode.substring(1,3));\r\n      let g = parseInt(\"0x\"+colorCode.substring(3,5));\r\n      let b = parseInt(\"0x\"+colorCode.substring(5,7));\r\n      if(r < whiteLimit || b < whiteLimit || g < whiteLimit) {\r\n          return false;\r\n      } \r\n      return true;    \r\n  }\r\n  ngOnDestroy(){\r\n    this.translationSubscription ? this.translationSubscription.unsubscribe() : null;\r\n  }\r\n}\r\n","<div class=\"aggregation-container\">\r\n  <div class=\"search-title\">\r\n    {{ prefix + \".\" + title | translate }}\r\n  </div>\r\n  <ng-container *ngIf=\"filters && componentType != 'colorsCodes'\">\r\n    <ng-container *ngFor=\"let group of filters; index as i\">\r\n      <div *ngIf=\"i < 5 || more\" class=\"search-checkbox\">\r\n        <!-- <input\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          type=\"checkbox\"\r\n          (change)=\"onFilterSelect(group.key, $event.target.checked)\"\r\n        /> -->\r\n        <!-- <div class=\"mx-8\">\r\n          <span [ngSwitch]=\"EntityType(group.fetchedKey)\">\r\n            <span *ngSwitchCase=\"'directoryEntry'\">\r\n              {{\r\n                \"vocabulary.\" + group.fetchedKey.directoryName + \".\" + group.key\r\n                  | translate\r\n              }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.fetchedKey.properties.firstName +\r\n                  \" \" +\r\n                  group.fetchedKey.properties.lastName\r\n              }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi>\r\n        </div> -->\r\n        <mat-checkbox\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          (change)=\"onFilterSelect(group.key, $event.checked)\"\r\n        >\r\n          <span [ngSwitch]=\"componentType\" class=\"aggregation-label\">\r\n\r\n            <span *ngSwitchCase=\"'custom-voc'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'vocabulary'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.key === 'system' ? ('SYSTEM_ADMIN' | translate) : (group.fetchedKey.properties.firstName + \" \" + group.fetchedKey.properties.lastName)\r\n              }}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-pp'\">\r\n              <lib-custom-pp-viewer [pageProvider]=\"customPageProvider\" [config]=\"config\" [group]=\"group\"></lib-custom-pp-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-document'\">\r\n              <lib-custom-document-viewer [pageProvider]=\"customPageProvider\" [group]=\"group\"></lib-custom-document-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'department'\">\r\n              <cts-department-viewer\r\n              [noStyle]=\"true\"\r\n              [value]=\"group.key\"\r\n            >\r\n            </cts-department-viewer>\r\n            <!-- {{group.key}} -->\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-department'\">\r\n              {{isArabic ? group.fetchedKey.properties[config.propertyAr] : group.fetchedKey.properties[config.propertyEn]}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'string'\">\r\n              <span>{{group.key}}</span>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi></mat-checkbox\r\n        >\r\n      </div>\r\n    </ng-container>\r\n    <div *ngIf=\"filters.length > 5\" class=\"more\">\r\n      <button class=\"btn-more\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <ng-container *ngIf=\"filters && componentType == 'colorsCodes'\">\r\n    <div class=\"flex flex-wrap colorsContainer\">\r\n      <ng-container *ngFor=\"let group of filters; index as i\">\r\n          <div *ngIf=\"i < 24 || more\" class=\"color-search-checkbox flex items-end justify-start\" [style.backgroundColor]=\"group.key\"\r\n          matTooltip=\"{{'search.colorInOtherPhotos' | translate :{num:group.docCount} }}\" [matTooltipPosition]=\"'above'\" \r\n          (click)=\"onFilterSelect(group.key, (_selections.includes(group.key)) ? false : true)\">\r\n            <span class=\"checkIcon bi bi-check\" *ngIf=\"_selections.includes(group.key)\" [ngStyle]=\"{color: (isWhiteOrClosetToWhite(group.key)) ? 'black': 'white'}\"></span>\r\n          </div>\r\n        \r\n      </ng-container>\r\n    </div>\r\n    <div *ngIf=\"filters.length > 20\" class=\"more\">\r\n      <button class=\"btn-more mt-1\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n\r\n\r\n  \r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-filter.component.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.ts","../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { TranslationService } from '../../../core/services/translation/translation.service';\r\n\r\n/**\r\n * Dyanamic filter is a component that leverages Nuxeo Elastic search aggregation buckets data to dynamically\r\n * generate data filtering checkbox groups & emits checkbox selection for consumption\r\n * @title\r\n * Dynamic Filter\r\n *\r\n * @example\r\n *\r\n * <cts-dynamic-filter\r\n *   [entityType]=\"entityType\"\r\n *   [filters]=\"aggregationBuckets\"\r\n *   [id]=\"aggregationId\"\r\n *   [selections]=\"aggregationSelection\"\r\n *   [title]=\"aggregationField\"\r\n *   [prefix]=\"'search'\"\r\n *   (onFilterSelected)=\"FilterSelected($event)\">\r\n * </cts-dynamic-filter>\r\n */\r\n@Component({\r\n  selector: 'cts-dynamic-filter',\r\n  templateUrl: './dynamic-filter.component.html',\r\n  styleUrls: ['./dynamic-filter.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class DynamicFilterComponent implements OnInit {\r\n  /** emits array of filters */\r\n  @Output() onFilterSelected = new EventEmitter();\r\n  public _selections;\r\n\r\n  /** title of the filters group */\r\n  @Input()\r\n  title = '';\r\n  @Input()\r\n  /** filters group */\r\n  filters;\r\n  /** new filters coming from the backend based on the selection */\r\n  @Input()\r\n  set selections(val) {\r\n    this._selections = val;\r\n  }\r\n  /** Aggregation ID */\r\n  @Input()\r\n  id;\r\n  @Input()\r\n  entityType;\r\n  /** static  path for translation passed from out side according to each page translation path */\r\n  @Input()\r\n  prefix;\r\n  /** special type for department */\r\n  @Input()\r\n  department: boolean = false;\r\n  @Input() componentType = 'defult';\r\n  @Input() customPageProvider ;\r\n  @Input() config ;\r\n  @Input() aggregation;\r\n  more = false;\r\n  isArabic = false;\r\n  translationSubscription : Subscription;\r\n  constructor(private translationService : TranslationService) {}\r\n\r\n  ngOnInit(): void {\r\n    this.translationSubscription = this.translationService.isArabic.subscribe(res => {\r\n      this.isArabic = res;\r\n    })\r\n  }\r\n\r\n  onFilterSelect(committeeName, e) {\r\n    if (e) {\r\n      this._selections.push(committeeName);\r\n      this.onFilterSelected.emit({\r\n        filter: {\r\n          [this.id]: JSON.stringify([...this._selections]),\r\n        },\r\n        type: this.entityType,\r\n      });\r\n    } else {\r\n      this._selections = this._selections.filter((e) => {\r\n        return e != committeeName;\r\n      });\r\n      this.onFilterSelected.emit({\r\n        filter: {\r\n          [this.id]: JSON.stringify([...this._selections]),\r\n        },\r\n        type: this.entityType,\r\n      });\r\n    }\r\n  }\r\n\r\n  EntityType(fetchedKey) {\r\n    if (!this.department) {\r\n      const typeObj = typeof fetchedKey === 'object' && fetchedKey !== null;\r\n      if (typeObj) {\r\n        return fetchedKey['entity-type'];\r\n      } else {\r\n        return false;\r\n      }\r\n    }else {\r\n      return 'department'\r\n    }\r\n  }\r\n  isWhiteOrClosetToWhite(colorCode) {\r\n      let whiteLimit = 200; \r\n      let r = parseInt(\"0x\"+colorCode.substring(1,3));\r\n      let g = parseInt(\"0x\"+colorCode.substring(3,5));\r\n      let b = parseInt(\"0x\"+colorCode.substring(5,7));\r\n      if(r < whiteLimit || b < whiteLimit || g < whiteLimit) {\r\n          return false;\r\n      } \r\n      return true;    \r\n  }\r\n  ngOnDestroy(){\r\n    this.translationSubscription ? this.translationSubscription.unsubscribe() : null;\r\n  }\r\n}\r\n","<div class=\"aggregation-container\">\r\n  <div class=\"search-title\">\r\n    {{ prefix + \".\" + title | translate }}\r\n  </div>\r\n  <ng-container *ngIf=\"filters && componentType != 'colorsCodes'\">\r\n    <ng-container *ngFor=\"let group of filters; index as i\">\r\n      <div *ngIf=\"i < 5 || more\" class=\"search-checkbox\">\r\n        <!-- <input\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          type=\"checkbox\"\r\n          (change)=\"onFilterSelect(group.key, $event.target.checked)\"\r\n        /> -->\r\n        <!-- <div class=\"mx-8\">\r\n          <span [ngSwitch]=\"EntityType(group.fetchedKey)\">\r\n            <span *ngSwitchCase=\"'directoryEntry'\">\r\n              {{\r\n                \"vocabulary.\" + group.fetchedKey.directoryName + \".\" + group.key\r\n                  | translate\r\n              }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.fetchedKey.properties.firstName +\r\n                  \" \" +\r\n                  group.fetchedKey.properties.lastName\r\n              }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi>\r\n        </div> -->\r\n        <mat-checkbox\r\n          [checked]=\"_selections.includes(group.key)\"\r\n          (change)=\"onFilterSelect(group.key, $event.checked)\"\r\n        >\r\n          <span [ngSwitch]=\"componentType\" class=\"aggregation-label\">\r\n\r\n            <span *ngSwitchCase=\"'custom-voc'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'vocabulary'\">\r\n              <lib-cutome-voc-viewer [type]=\"componentType\" [group]=\"group\"></lib-cutome-voc-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'user'\">\r\n              {{\r\n                group.key === 'system' ? ('SYSTEM_ADMIN' | translate) : (group.fetchedKey.properties.firstName + \" \" + group.fetchedKey.properties.lastName)\r\n              }}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'agency'\">\r\n              {{ (aggregation.prefix +  group.key) | translate}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-pp'\">\r\n              <lib-custom-pp-viewer [pageProvider]=\"customPageProvider\" [config]=\"config\" [group]=\"group\"></lib-custom-pp-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-document'\">\r\n              <lib-custom-document-viewer [pageProvider]=\"customPageProvider\" [group]=\"group\"></lib-custom-document-viewer>\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'department'\">\r\n              <cts-department-viewer\r\n              [noStyle]=\"true\"\r\n              [value]=\"group.key\"\r\n            >\r\n            </cts-department-viewer>\r\n            <!-- {{group.key}} -->\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'custom-department'\">\r\n              {{isArabic ? group.fetchedKey.properties[config.propertyAr] : group.fetchedKey.properties[config.propertyEn]}}\r\n            </span>\r\n\r\n            <span *ngSwitchCase=\"'string'\">\r\n              <span>{{group.key}}</span>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ prefix + \".\" + \"buckets.\" + group.key | translate }}\r\n            </span>\r\n          </span>\r\n          <bdi>({{ group.docCount }})</bdi></mat-checkbox\r\n        >\r\n      </div>\r\n    </ng-container>\r\n    <div *ngIf=\"filters.length > 5\" class=\"more\">\r\n      <button class=\"btn-more\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <ng-container *ngIf=\"filters && componentType == 'colorsCodes'\">\r\n    <div class=\"flex flex-wrap colorsContainer\">\r\n      <ng-container *ngFor=\"let group of filters; index as i\">\r\n          <div *ngIf=\"i < 24 || more\" class=\"color-search-checkbox flex items-end justify-start\" [style.backgroundColor]=\"group.key\"\r\n          matTooltip=\"{{'search.colorInOtherPhotos' | translate :{num:group.docCount} }}\" [matTooltipPosition]=\"'above'\" \r\n          (click)=\"onFilterSelect(group.key, (_selections.includes(group.key)) ? false : true)\">\r\n            <span class=\"checkIcon bi bi-check\" *ngIf=\"_selections.includes(group.key)\" [ngStyle]=\"{color: (isWhiteOrClosetToWhite(group.key)) ? 'black': 'white'}\"></span>\r\n          </div>\r\n        \r\n      </ng-container>\r\n    </div>\r\n    <div *ngIf=\"filters.length > 20\" class=\"more\">\r\n      <button class=\"btn-more mt-1\" (click)=\"more = !more\">\r\n        {{\r\n          more\r\n            ? (prefix + \".\" + \"viewless\" | translate)\r\n            : (prefix + \".\" + \"viewmore\" | translate)\r\n        }}\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n\r\n\r\n\r\n  \r\n</div>\r\n"]}