nuxeo-development-framework 3.0.9 → 3.1.2

package/src/lib/components/dynamic-view/list-viewer/list-viewer.component.spec.ts

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

package/src/lib/components/dynamic-view/list-viewer/list-viewer.component.ts

@@ -0,0 +1,27 @@
+import { Component, Input, OnInit } from '@angular/core';
+
+/**
+ * A component to display a list of users
+ * @title
+ * List Viewer
+ */
+@Component({
+  selector: 'cts-list-viewer',
+  templateUrl: './list-viewer.component.html',
+  styleUrls: ['./list-viewer.component.scss']
+})
+export class ListViewerComponent implements OnInit {
+  /** label to be shown  */
+  @Input() label = '';
+  /** list of CC user */
+  @Input() data = [];
+  /** Further info required */
+  @Input() vertical = false;
+  show = false;
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

package/src/lib/components/file-manger/components/add-to-collection/add-to-collection.component.html

@@ -0,0 +1,34 @@
+<dx-popup class="popUpParent" [rtlEnabled]="rtlEnabled" id="photo-popup" [width]="500" [height]="200"
+    (onShown)="loadItems()" closeOnOutsideClick="true" title="{{ 'FILE_MANAGER.ADD_TO_COLLECTION' | translate }}"
+    [(visible)]="visible">
+    <div *dxTemplate="let data of 'content'">
+        <form (submit)="onFormCollectionSubmit($event)">
+            <dx-form class="collection-form-wrapper" #createForm [formData]="formData" [disabled]="loading">
+                <dxi-item editorType="dxTextBox">
+                    <ng-select [items]="items$ | async" bindLabel="displayLabel" [addTag]="true"
+                        addTagText="Add collection" [multiple]="false" [hideSelected]="true" [minTermLength]="0"
+                        [loading]="tagsLoading" typeToSearchText="search" [typeahead]="tagsInput$"
+                        [(ngModel)]="selectedTags" required placeholder="{{
+                        'VOCABULARY.SELECT_ITEM' | translate
+                    }}" name="selectedItem" (change)="emitSelection($event)">
+                    </ng-select>
+                </dxi-item>
+                <dxi-item itemType="button">
+                    <dxo-button-options width="30%" type="danger" [useSubmitBehavior]="true"
+                        [template]="'addToCollectionTemplate'">
+                    </dxo-button-options>
+                </dxi-item>
+                <ng-container *dxTemplate="let item of 'addToCollectionTemplate'">
+                    <span class="dx-button-text">
+                        <ng-container *ngIf="loading; else notLoading">
+                            <dx-load-indicator width="24px" height="24px" [visible]="true"></dx-load-indicator>
+                        </ng-container>
+                        <ng-template #notLoading>{{
+                            "FILE_MANAGER.ADD" | translate
+                            }}</ng-template>
+                    </span>
+                </ng-container>
+            </dx-form>
+        </form>
+    </div>
+</dx-popup>

package/src/lib/components/file-manger/components/add-to-collection/add-to-collection.component.spec.ts

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

package/src/lib/components/file-manger/components/add-to-collection/add-to-collection.component.ts

@@ -0,0 +1,139 @@
+import { Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges, ViewChild } from '@angular/core';
+import { DxFormComponent } from 'devextreme-angular';
+import { concat, Observable, of, Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, switchMap, catchError, tap, map } from 'rxjs/operators';
+import { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';
+import { FileManagerService } from '../../../../shared-services/file-manager.service';
+
+@Component({
+  selector: 'app-add-to-collection',
+  templateUrl: './add-to-collection.component.html',
+  styleUrls: ['./add-to-collection.component.scss']
+})
+export class AddToCollectionComponent implements OnInit {
+  @ViewChild(DxFormComponent, { static: false }) form: DxFormComponent;
+  @Input()
+  set visible(value: any) {
+    if (this._visible === value) {
+      return;
+    }
+    this._visible = value;
+    this.visibleChange.emit(this._visible);
+  }
+  get visible() {
+    return this._visible;
+  }
+  @Output()
+  visibleChange = new EventEmitter<any>();
+  @Input()
+  rtlEnabled = false;
+  @Input()
+  selectedItems: any;
+
+  loading = false;
+  isSelected: boolean = true;
+  collectionid: any;
+  selectedTags: any;
+  items$: Observable<any[]>;
+  tagsInput$ = new Subject<string>();
+  tagsLoading = false;
+  _visible = false;
+  constructor(
+    private fileManagerService: FileManagerService,
+    protected customToastrService: CustomToastrService
+
+  ) { }
+
+  ngOnInit(): void {
+  }
+
+  emitSelection(event) {
+    if (this.isSelected) {
+      this.fileManagerService
+        .createNewCollection(event.displayLabel)
+        .subscribe((res) => {
+          this.collectionid = res.uid;
+        });
+    } else this.collectionid = event.id;
+  }
+
+  loadItems() {
+    let searchterm = '';
+    this.isSelected = false;
+    let mycategories = [];
+    this.items$ = concat(
+      this.fileManagerService.getCollectionFromPP(searchterm).pipe(switchMap((res:any)=> {
+        res.entries.map(entry => {
+                mycategories.push({
+                    displayLabel : entry.title,
+                    id : entry.uid,
+                    path: entry.path,
+                    icon :entry.properties['common:icon']
+                })
+        })
+        return of(mycategories);
+    })) , // default items
+      this.tagsInput$.pipe(
+        debounceTime(200),
+        distinctUntilChanged(),
+        tap(() => (this.tagsLoading = true)),
+        switchMap((searchterm) => {
+          // if (searchterm && searchterm.length) {
+            return this.fileManagerService
+              .getCollectionFromPP(searchterm)
+              .pipe(
+                catchError(() => of([])), // empty list on error
+                switchMap((searchCat) => {
+                  let myInerCateg = [];
+                  this.tagsLoading = false;
+                  this.isSelected = true;
+                  searchCat.entries.map(entry => {
+                    myInerCateg.push({
+                        displayLabel : entry.title,
+                        id : entry.uid,
+                        path: entry.path,
+                        icon :entry.properties['common:icon']
+                    })
+                })
+                return of(myInerCateg);
+                })
+              );
+          // } else {
+          //   this.tagsLoading = false;
+          //   this.isSelected = true;
+          //   return of();
+          // }
+        })
+      )
+    );
+  }
+
+  async onFormCollectionSubmit(e) {
+    e.preventDefault();
+    this.loading = true;
+    this.fileManagerService
+      .addToCollection(this.selectedItems, this.collectionid)
+      .subscribe(
+        (res) => {
+          this.loading = false;
+          this.form.instance.resetValues();
+          this.selectedTags = null;
+          this.visible = false;
+          this.customToastrService.show(
+            'success',
+            'TOASTER.SUCCESS',
+            'TOASTER.DOCUMENT_ADDED_TO_COLLECTION'
+          );
+        },
+        (err) => {
+          this.loading = false;
+          this.customToastrService.show(
+            'error',
+            'TOASTER.ERROR',
+            'TOASTER.DOCUMENT_ADDED_TO_COLLECTION_ERROR'
+          );
+        }
+      );
+  }
+
+}

package/src/lib/components/file-manger/components/clipboard/clipboard.component.html

@@ -0,0 +1,88 @@
+<div class="clipboard-side-section relative">
+
+    <div class="p-3 h-full">
+        <div class="clipboard-header flex justify-between items-center border-b-2">
+            <span class="flex text-gray-500 font-bold items-center">
+                <span class="text-4xl bi bi-clipboard"></span>
+                <span class="mx-2 text-xl">{{'clipboard' | translate}}</span>
+            </span>
+            <mat-icon class="close-icon text-gray-500 cursor-pointer" (click)="closeClipboard()"
+                [matTooltip]="'BUTTONS.CLOSE' | translate">close</mat-icon>
+        </div>
+        <!-- <div class="h-full font-bold d-flex justify-center items-center" *ngIf="clipboardLoading">
+            {{ "loading" | translate }}
+        </div> -->
+        <div class="w-full h-px bg-gray-200 mb-3" *ngIf="clipboardLoading">
+            <mat-progress-bar mode="indeterminate"></mat-progress-bar>
+        </div>
+        <div class="clipboard-content flex flex-col justify-between items-between">
+            <div class="h-full flex justify-center items-center text-gray-500"
+                *ngIf="clipboardDocments.length === 0">{{'no_clipboard_items' | translate}}</div>
+
+            <div class="px-2 h-5/6 overflow-y-auto" *ngIf="clipboardDocments.length > 0">
+                <div class="border-b-2" *ngFor="let document of clipboardDocments">
+                    <div class="py-1 w-82 flex  items-center justify-between">
+                        <div class="flex items-center w-5/6">
+                            <mat-checkbox [(ngModel)]="document.isSelected" (change)="checking()"> </mat-checkbox>
+                            <div class="flex w-full">
+                                <!-- <title-with-icon class="w-1/6 -my-1.5" [context]="document"
+                                    [showTitle]="false"></title-with-icon> -->
+                            <app-display-suitable-icon class="mx-1" [data]="document" [size]="'40px'"></app-display-suitable-icon>
+
+                                <!--  -->
+                                <div *ngIf="document.isFile === 'File'"
+                                    class="justify-center flex flex-col flex-1 flex-grow-0 w-5/6">
+                                    <div class="text-base text-gray-500 font-bold truncate"
+                                        [title]="document.properties?.['file:content']?.['name']"
+                                        [alt]="document.properties?.['file:content']?.['name']">
+                                        {{document['title']}}
+                                    </div>
+                                    <div class="text-gray-500 text-sm text-nowrap">
+                                        {{((document.properties?.['file:content']?.['length']) / (1024 *
+                                        1024)).toFixed(2) }}
+                                        MB
+                                    </div>
+                                </div>
+                                <div class="
+                                     d-flex
+                                     items-center
+                                     text-base text-gray-500
+                                     font-bold
+                                 " *ngIf="document.isFile === 'Folder'">
+                                    {{ document?.title }}
+                                </div>
+                            </div>
+                        </div>
+                        <span [matTooltip]="'BUTTONS.REMOVE_CLIPBOARD' | translate"
+                            class="cursor-pointer w-5 h-5 rounded-full border-2 flex justify-center items-center border-gray-500 "
+                            (click)="deletefromClipboard(document)">
+                            <span class="text-gray-500 bi bi-x text-lg flex items-center"></span>
+                        </span>
+                    </div>
+                    <div class="text-md text-gray-500 text-center my-2">
+                        <span *ngIf="document.canCopyToTarget && !document.canMoveToTarget">{{'can_copy_only' |
+                            translate}}</span>
+                        <span *ngIf="!document.canCopyToTarget && document.canMoveToTarget">{{'can_move_only' |
+                            translate}}</span>
+                        <span *ngIf="document.canCopyToTarget && document.canMoveToTarget">{{'can_copy_and_move' |
+                            translate}}</span>
+                        <span
+                            *ngIf="!document.canCopyToTarget && !document.canMoveToTarget">{{'can_not_copy_and_move'
+                            | translate}}</span>
+                    </div>
+                </div>
+
+            </div>
+            <div class="h-1/6 flex w-full justify-center items-center">
+                <button class="submission-button mx-2" [disabled]="!enableCopy"
+                    (click)="copyFromInsideClipboard()">{{'BUTTONS.COPY' | translate}}</button>
+                <button class="submission-button mx-2" [disabled]="!enableMove"
+                    (click)="moveFromInsideClipboard()">{{'BUTTONS.MOVE' | translate}}</button>
+            </div>
+        </div>
+    </div>
+
+    <div class="bg-transparent absolute top-0 bottom-0 left-0 right-0 " *ngIf="clipboardLoading">
+
+    </div>
+</div>

package/src/lib/components/file-manger/components/clipboard/clipboard.component.scss

@@ -0,0 +1,17 @@
+.clipboard-side-section {
+    width: 0px;
+    overflow-x: hidden;
+    height: 91vh;
+    background-color: white;
+    overflow: hidden;
+    border: 1px solid lightgray;
+    z-index: 999;
+    transition: 100ms ease-in-out;
+    border-bottom: none;
+    .clipboard-header{
+        height: 60px;
+    }
+    .clipboard-content{
+        height: calc(100% - 60px);
+    }
+}

package/src/lib/components/file-manger/components/clipboard/clipboard.component.spec.ts

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

package/src/lib/components/file-manger/components/clipboard/clipboard.component.ts

@@ -0,0 +1,279 @@
+import { Component, EventEmitter, Input, OnDestroy, OnInit, Output, ViewEncapsulation } from '@angular/core';
+import { FileManagerService } from '../../../../shared-services/file-manager.service';
+import { UserService } from '../../../../shared-services/user.service';
+import { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';
+import { UserPreferencesService } from '../../../../Core/services/user/user-preferences.service';
+import { Subscription } from 'rxjs';
+
+@Component({
+  selector: 'lib-clipboard',
+  templateUrl: './clipboard.component.html',
+  styleUrls: ['./clipboard.component.scss'],
+  encapsulation: ViewEncapsulation.None
+})
+export class ClipboardComponent implements OnInit, OnDestroy {
+
+  @Output() onClipboardClose = new EventEmitter();
+  @Output() onRefreshFolderTree = new EventEmitter();
+
+  @Input() clipboardItems = []; // array of id to items in clipboard
+  @Input() myCurrecntFolderData;
+  @Input() preventedGroups = [];
+  @Input() directory;
+
+  clipboardDocments = []; // array of documents with full details of items in clipboard
+  enableCopy = false;
+  enableMove = false;
+  clipboardLoading = false;
+  documentSelectedInClipboard = [];
+  myTargetFolderAcceptedChildrens;
+  refreshClipSubscription: Subscription;
+  constructor(private fileManagerService: FileManagerService,
+    private userService: UserService,
+    private customToastrService: CustomToastrService,
+    private userPreferenceService: UserPreferencesService) { }
+
+  ngOnInit(): void {
+    this.refreshClipSubscription = this.fileManagerService.onRefreshClipboard.subscribe(res => {
+      this.openClipboard();
+    })
+    this.openClipboard();
+  }
+
+  ngOnDestroy(): void {
+    this.refreshClipSubscription ? this.refreshClipSubscription.unsubscribe() : null;
+  }
+  closeClipboard() {
+    this.onClipboardClose.emit();
+    this.clipboardDocments = [];
+  }
+
+  openClipboard() {
+    this.enableCopy = false;
+    this.enableMove = false;
+    this.clipboardLoading = true;
+    if (this.myCurrecntFolderData.entity.properties['dmsfolder:documentTypeCode'] && this.myCurrecntFolderData.entity.properties['dmsfolder:documentTypeCode'] !== '08112021') {
+      // get accepted childerns for my current folder
+      // if (this.subtypesService.storedSubtypes[this.myCurrecntFolderData.entity.uid]) {
+      //     this.myTargetFolderAcceptedChildrens = this.subtypesService.storedSubtypes[this.myCurrecntFolderData.entity.uid];
+      // } else {
+      this.fileManagerService.getClipboardAcceptedTypes(this.myCurrecntFolderData.entity.uid).subscribe(res => {
+        this.myTargetFolderAcceptedChildrens = res;
+      }, error => {
+        this.clipboardLoading = false;
+        this.clipboardDocments = [];
+      })
+      // }
+    }
+    if (this.clipboardItems.length > 0) {
+      this.fileManagerService.getClipboardDocuments(this.clipboardItems).subscribe(res => {
+        res.map(document => {
+          document['canCopyToTarget'] = (this.canPerformActionInsideTarget(document) && this.checkIfNotTheSameParent(document) && document.canCopy);
+          document['canMoveToTarget'] = (this.canPerformActionInsideTarget(document) && this.checkIfNotTheSameParent(document) && document.canMove)
+        })
+        this.clipboardDocments = res;
+        console.log(this.clipboardDocments);
+        this.clipboardLoading = false;
+      })
+    } else {
+      this.clipboardDocments = [];
+      this.clipboardLoading = false;
+    }
+  }
+
+  // prevent copying or moving the file to its same place since it is prevented 
+  // prevent copying or moving the folder inside it self
+  checkIfNotTheSameParent(document) {
+    // let directory = this.getCurrentDirectory();
+    if (document.parentRef !== this.directory.dataItem.id && document.uid !== this.directory.dataItem.id) {
+      return true
+    } else {
+      return false
+    }
+  }
+
+  deletefromClipboard(document) {
+    let myindex = -1;
+    this.clipboardItems.map((id, index) => {
+      if (document.uid === id) {
+        myindex = index
+      }
+    })
+    this.clipboardItems.splice(myindex, 1);
+    this.customToastrService.show('success', 'TOASTER.SUCCESS', "TOASTER.removed_from_clipboard");
+    // let directory = this.getCurrentDirectory();
+    // let id =
+    //     directory.dataItem === undefined
+    //         ? this.mainFolder
+    //         : this.getCurrentFolderId(directory);
+    // this.reinitializeFolderTree(id, directory);
+    this.onRefreshFolderTree.emit();
+    this.openClipboard();
+    this.userPreferenceService.set('clipboardItems', JSON.stringify(this.clipboardItems));
+  }
+
+  // function to check if i can perform action on that target folder or not 
+  canPerformActionInsideTarget(document) {
+    //check if target is 'other' type folder or dms folder
+    if (this.myCurrecntFolderData.entity.properties['dmsfolder:documentTypeCode'] === '08112021' && !this.checkIfInPreventedGroups(this.myCurrecntFolderData.entity.path)) {
+      // if my folder is from type others and not in prevented groups
+      return true
+    } else if (this.myCurrecntFolderData.entity.properties['dmsfolder:documentTypeCode'] && this.myCurrecntFolderData.entity.properties['dmsfolder:documentTypeCode'] !== '08112021') {
+      //if my folder has code and was not other type folder then check for accepted chilrdrn for that folder to contain this file type
+      if (document.isFile === 'File') {
+        if (this.myTargetFolderAcceptedChildrens.contextParameters &&
+          this.myTargetFolderAcceptedChildrens.contextParameters.accepted_children && Array.isArray(this.myTargetFolderAcceptedChildrens.contextParameters.accepted_children) &&
+          this.myTargetFolderAcceptedChildrens.contextParameters.accepted_children.indexOf(document.properties['gdoc:documentTypeCode']) > -1) {
+          return true;
+        } else {
+          return false
+        }
+      } else {
+        if (this.myTargetFolderAcceptedChildrens.contextParameters &&
+          this.myTargetFolderAcceptedChildrens.contextParameters.accepted_children && Array.isArray(this.myTargetFolderAcceptedChildrens.contextParameters.accepted_children) &&
+          this.myTargetFolderAcceptedChildrens.contextParameters?.accepted_children.indexOf(document.properties['dmsfolder:documentTypeCode']) > -1) {
+          return true;
+        } else {
+          return false
+        }
+      }
+    } else {
+      // prevent action to this target 
+      return false
+    }
+
+  }
+
+  // function to check if this path not belong to group that is prevented from creating folder of type others
+  checkIfInPreventedGroups(path) {
+    // if in prevented froup rturn true else return false
+    console.log(path);
+    let myDepartment = this.userService.getUserDepartmentFromPath(path);
+    let exist = this.preventedGroups.indexOf(myDepartment) > -1 ? true : false;
+    return exist;
+  }
+
+  copyFromInsideClipboard() {
+    let clipboardSelectedItems = [];
+    let clipboardSelectedItemsLength = 0;
+    // seperate selected items in seperate array 
+    this.clipboardDocments.map((doc, index) => {
+      // can't copy file in the same place it exist and can't copy folder inside it self 
+      if (doc.isSelected && doc.parentRef !== this.directory.dataItem.id && doc.uid !== this.directory.dataItem.id) {
+        clipboardSelectedItems.push(doc.uid)
+      }
+    })
+
+    if (clipboardSelectedItems.length > 0) {
+      this.clipboardLoading = true;
+      //    this.currentPath = '';
+      this.fileManagerService
+        .copyTo({ id: this.directory.dataItem.id, name: this.directory.dataItem.name }, clipboardSelectedItems.toString())
+        .subscribe(
+          (res) => {
+            // remove selected items from clipboard after action is done
+            this.removeItemsAfterActionDone(clipboardSelectedItems);
+            this.clipboardLoading = false;
+            this.onClipboardClose.emit();
+            this.onRefreshFolderTree.emit();
+            this.customToastrService.show(
+              'success',
+              'TOASTER.SUCCESS',
+              'TOASTER.DOCUMENT_COPIED'
+            );
+          },
+          (err) => {
+            this.clipboardLoading = false;
+            this.customToastrService.show(
+              'error',
+              'TOASTER.ERROR',
+              'TOASTER.DOCUMENT_COPIED_ERROR'
+            );
+          }
+        );
+    } else {
+      this.customToastrService.show(
+        'error',
+        'TOASTER.ERROR',
+        'TOASTER.DOCUMENT_COPIED_DESTINATION_ERROR'
+      );
+    }
+
+  }
+
+  moveFromInsideClipboard() {
+    let clipboardSelectedItems = [];
+    let clipboardSelectedItemsLength = 0;
+    // seperate selected items in seperate array 
+    this.clipboardDocments.map((doc, index) => {
+      // can't move file in the same place it exist and can't move folder inside it self 
+      if (doc.isSelected && doc.parentRef !== this.directory.dataItem.id && doc.uid !== this.directory.dataItem.id) {
+        clipboardSelectedItems.push(doc.uid)
+      }
+    })
+
+    if (clipboardSelectedItems.length > 0) {
+      this.clipboardLoading = true;
+      this.fileManagerService
+        .moveTo({ id: this.directory.dataItem.id, name: this.directory.dataItem.name }, clipboardSelectedItems.toString())
+        .subscribe(
+          (res) => {
+            // remove selected items from clipboard after action is done
+            this.removeItemsAfterActionDone(clipboardSelectedItems);
+            this.clipboardLoading = false;
+            this.onClipboardClose.emit();
+            this.onRefreshFolderTree.emit();
+            this.customToastrService.show(
+              'success',
+              'TOASTER.SUCCESS',
+              'TOASTER.DOCUMENT_MOVED'
+            );
+          },
+          (err) => {
+            this.clipboardLoading = false;
+            this.customToastrService.show(
+              'error',
+              'TOASTER.ERROR',
+              'TOASTER.DOCUMENT_MOVED_ERROR'
+            );
+          }
+        );
+    } else
+      this.customToastrService.show(
+        'error',
+        'TOASTER.ERROR',
+        'TOASTER.DOCUMENT_MOVED_DESTINATION_ERROR'
+      );
+  }
+
+  removeItemsAfterActionDone(selectedItems) {
+    this.clipboardItems = this.clipboardItems.filter(function (el) {
+      return !selectedItems.includes(el);
+    });
+    this.userPreferenceService.set('clipboardItems', JSON.stringify(this.clipboardItems));
+  }
+
+  checking() {
+    this.enableCopy = false;
+    this.enableMove = false;
+    this.documentSelectedInClipboard = [];
+    // console.log(this.clipboardDocments);
+    this.clipboardDocments.map(document => {
+      // wokring with only selected documents 
+      if (document.isSelected === true) {
+        // document['canCopyToTarget'] = (this.canPerformActionInsideTarget(document) && document.canCopy);
+        // document['canMoveToTarget'] = (this.canPerformActionInsideTarget(document) && document.canMove)
+        this.documentSelectedInClipboard.push(document)
+      }
+    })
+    if (this.documentSelectedInClipboard.length > 0) {
+      this.enableCopy = this.documentSelectedInClipboard.every(item => {
+        return item.canCopyToTarget === true;
+      })
+      this.enableMove = this.documentSelectedInClipboard.every(item => {
+        return item.canMoveToTarget === true;
+      })
+    }
+    console.log(this.documentSelectedInClipboard)
+  }
+}