@yuuvis/app-drive 0.7.3

package/esm2022/lib/services/drive/drive.service.mjs

@@ -0,0 +1,437 @@
+import { Injectable, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { NavigationStart, Router } from '@angular/router';
+import { patchState, signalState } from '@ngrx/signals';
+import { BackendService, BaseObjectTypeField, ClipboardService, ContentStreamField, DmsService, EventService, SearchService, SystemType, YuvEventType } from '@yuuvis/client-core';
+import { ActionsService, BASE_ACTION } from '@yuuvis/client-framework/actions';
+import { YvcOverlayService } from '@yuuvis/components/overlay';
+import { Subject, catchError, filter, forkJoin, map, of, switchMap, tap } from 'rxjs';
+import { ACTION_CONTEXT, APP_ID, APP_SCHEMA, FS_PROPERTIES, FS_SOTS } from '../../drive.schema';
+import { DRIVE_APP_BREADCRUMB_MAX_DEPTH } from '../tokens';
+import { DRIVE_ACTION_MODE, DRIVE_EVENT, DRIVE_ROOT_FOLDER_ID } from './drive.interface';
+import { ResolveNameConflictsComponent } from './resolve-name-conflicts/resolve-name-conflicts.component';
+import { mapSearchResult } from './versions/versions.mapping';
+import * as i0 from "@angular/core";
+export class DriveService {
+    #actionsService;
+    #eventService;
+    #router;
+    #dmsService;
+    #searchService;
+    #overlay;
+    #backend;
+    #clipboardService;
+    #eventSource;
+    #defaultSort;
+    constructor() {
+        this.#actionsService = inject(ActionsService);
+        this.#eventService = inject(EventService);
+        this.#router = inject(Router);
+        this.#dmsService = inject(DmsService);
+        this.#searchService = inject(SearchService);
+        this.#overlay = inject(YvcOverlayService);
+        this.#backend = inject(BackendService);
+        this.#clipboardService = inject(ClipboardService);
+        this.MAX_DEPTH = inject(DRIVE_APP_BREADCRUMB_MAX_DEPTH);
+        this.breadcrumbCache = new Map();
+        this.#eventSource = new Subject();
+        this.events$ = this.#eventSource.asObservable();
+        this.#defaultSort = {
+            property: FS_PROPERTIES.name,
+            order: 'asc'
+        };
+        this.initialState = {
+            currentFolder: null,
+            query: null,
+            queryTitle: null,
+            selection: [],
+            actions: [],
+            busy: false,
+            sort: this.#defaultSort,
+            breadcrumb: {
+                loading: false,
+                partial: false,
+                items: [],
+                folder: null
+            },
+            versions: {
+                versionsList: [],
+                selectedVersion: null
+            },
+            selectedDmsObject: null
+        };
+        this.state$ = signalState(this.initialState);
+        this.breadcrumbFolderPreview = this.state$.breadcrumb.folder;
+        this._busyTaskCount = 0;
+        this._defaultRibbonActions = [];
+        this.#router.events
+            .pipe(takeUntilDestroyed(), filter((e) => this.state$.selection().length > 0 && e instanceof NavigationStart))
+            // clear selection on route chnages
+            .subscribe({ next: () => this.setSelection([]) });
+        this.#eventService.on(YuvEventType.DMS_OBJECT_UPDATED).subscribe((e) => {
+            // check if current selection contains the updated object
+            const dmsObject = e.data;
+            const selection = this.state$.selection();
+            const matchIdx = selection.findIndex((o) => o.id === dmsObject.id);
+            if (matchIdx !== -1) {
+                // update the object in the selection
+                selection[matchIdx] = dmsObject;
+                patchState(this.state$, { selection: [...selection] });
+            }
+        });
+        this.#eventService
+            .on(YuvEventType.DMS_OBJECT_DELETED, YuvEventType.DMS_OBJECT_CREATED, YuvEventType.DMS_OBJECTS_MOVED)
+            .subscribe(() => this.emitEvent(DRIVE_EVENT.refresh));
+    }
+    #mapedCurrentFolder() {
+        return this.state$.currentFolder() === DRIVE_ROOT_FOLDER_ID ? null : this.state$.currentFolder();
+    }
+    emitEvent(evt) {
+        this.#eventSource.next(evt);
+    }
+    setBusy(busy) {
+        if (busy)
+            this._busyTaskCount++;
+        else if (this._busyTaskCount > 0)
+            this._busyTaskCount--;
+        patchState(this.state$, { busy: this._busyTaskCount !== 0 });
+    }
+    setSelection(o) {
+        patchState(this.state$, { selection: o });
+        this._getActions();
+    }
+    updateQuery(query, queryTitle = null) {
+        patchState(this.state$, {
+            query: this.applyFolderListSearchConditions(query),
+            queryTitle: queryTitle
+        });
+    }
+    setSort(property, order) {
+        const stateQuery = this.state$.query();
+        if (stateQuery) {
+            const clonedQueryState = structuredClone(stateQuery);
+            // TODO: remove if folders should stay on top
+            clonedQueryState.sort = [];
+            const sort = property ? { property, order } : { ...this.#defaultSort, order };
+            patchState(this.state$, { query: clonedQueryState, sort });
+            this.applyFolderListSearchConditions(clonedQueryState, !property);
+        }
+    }
+    updateCurrentFolder(currentFolderID) {
+        patchState(this.state$, { currentFolder: currentFolderID || null });
+    }
+    #copyToFolder(objects, folderId, options, validateNames = true) {
+        return validateNames
+            ? this.validateNames(objects.filter((o) => o.sots.includes(FS_SOTS.object)).map((f) => f.data[FS_PROPERTIES.name]), folderId).pipe(switchMap((res) => {
+                if (res.existingFileNames?.length || res.invalidFileNames?.length) {
+                    this.#resolveNameConflicts({
+                        existingFileNames: res.existingFileNames,
+                        invalidFileNames: res.invalidFileNames,
+                        mode: 'copy',
+                        items: objects
+                    });
+                    return of([]);
+                }
+                else
+                    return this.#dmsService.copyDmsObjects(folderId, objects, options);
+            }))
+            : this.#dmsService.copyDmsObjects(folderId, objects, options);
+    }
+    #moveToFolder(objects, folderId, options, validateNames = true) {
+        return validateNames
+            ? this.validateNames(objects.filter((o) => o.sots.includes(FS_SOTS.object)).map((f) => f.data[FS_PROPERTIES.name]), folderId).pipe(switchMap((res) => {
+                if (res.existingFileNames?.length || res.invalidFileNames?.length) {
+                    console.log('VALIDATION: ', { res });
+                    this.#resolveNameConflicts({
+                        existingFileNames: res.existingFileNames,
+                        invalidFileNames: res.invalidFileNames,
+                        mode: 'move',
+                        items: objects
+                    });
+                    return of([]);
+                }
+                else
+                    return this.#dmsService.moveDmsObjects(folderId, objects, options);
+            }))
+            : this.#dmsService.moveDmsObjects(folderId, objects, options);
+    }
+    copyToCurrentFolder(objects, validateNames = true) {
+        const options = { waitForSearchConsistency: true };
+        return this.#copyToFolder(objects, this.#mapedCurrentFolder(), options, validateNames);
+    }
+    moveToCurrentFolder(objects, validateNames = true) {
+        const options = { waitForSearchConsistency: true };
+        return this.#moveToFolder(objects, this.#mapedCurrentFolder(), options, validateNames);
+    }
+    #resolveNameConflicts(payload) {
+        this.#overlay.open(ResolveNameConflictsComponent, payload, {
+            maxWidth: '400px'
+        });
+    }
+    pasteFromClipboard(destinationObject) {
+        const cd = this.#clipboardService.getClipboardData(APP_ID);
+        const destination = destinationObject?.isFolder ? destinationObject.id : this.#mapedCurrentFolder();
+        return (cd && cd.objects && cd.objects.length > 0
+            ? cd?.mode === DRIVE_ACTION_MODE.CUT
+                ? this.#moveToFolder(cd.objects || [], destination, { waitForSearchConsistency: true }, true)
+                : cd?.mode === DRIVE_ACTION_MODE.COPY
+                    ? this.#copyToFolder(cd.objects || [], destination, { waitForSearchConsistency: true }, true)
+                    : of(null)
+            : of(null)).pipe(tap((res) => {
+            res && this.emitEvent(DRIVE_EVENT.refresh);
+            this.#clipboardService.clear();
+        }));
+    }
+    checkNamesAndUpload(files, data) {
+        return this.validateNames(files.map((f) => f.name), this.#mapedCurrentFolder()).pipe(switchMap((res) => {
+            if (res.existingFileNames?.length || res.invalidFileNames?.length) {
+                const resPayload = {
+                    existingFileNames: res.existingFileNames,
+                    invalidFileNames: res.invalidFileNames,
+                    mode: 'upload',
+                    items: files,
+                    data
+                };
+                this.#overlay.open(ResolveNameConflictsComponent, resPayload);
+                return of([]);
+            }
+            else
+                return this.upload(files, data);
+        }));
+    }
+    uploadContent(objectId, file) {
+        return this.#dmsService.uploadContent(objectId, file);
+    }
+    /**
+     * Uploads files to the current folder
+     * @param files files to be uploaded
+     * @param data additional data to be applied to the object
+     */
+    upload(files, data) {
+        return forkJoin(files.map((file) => {
+            const uploadData = data || {};
+            // apply filesystem SOT
+            const sots = uploadData[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] || [];
+            uploadData[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, FS_SOTS.object];
+            // setup the name to be the filename
+            uploadData[FS_PROPERTIES.name] = file.name;
+            const cf = this.#mapedCurrentFolder();
+            if (cf && cf !== DRIVE_ROOT_FOLDER_ID)
+                uploadData[BaseObjectTypeField.PARENT_ID] = cf;
+            return this.#dmsService.createDmsObject(SystemType.DOCUMENT, uploadData, [file], file.name).pipe(map((res) => ({ id: res[0] })), catchError((e) => of({ error: this.#mapCreateError(e) })));
+        }));
+    }
+    createFolder(name) {
+        const parentID = this.#mapedCurrentFolder();
+        const data = {};
+        data[FS_PROPERTIES.name] = name;
+        // apply filesystem SOT
+        data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [FS_SOTS.object];
+        if (parentID && parentID !== DRIVE_ROOT_FOLDER_ID)
+            data[BaseObjectTypeField.PARENT_ID] = parentID;
+        return this.#dmsService.createDmsObject(APP_SCHEMA.types.folder.objectType || '', data, []).pipe(map((res) => ({ id: res[0] })), catchError((e) => of({ error: this.#mapCreateError(e) })));
+    }
+    #mapCreateError(e) {
+        let error = 'default';
+        const ec = e.error.serviceErrorCode;
+        if (ec === 99999) {
+            const iec = e.error.innerError?.serviceErrorCode;
+            if (iec === 11000)
+                error = 'nameExists';
+        }
+        return error;
+    }
+    /**
+     * Checks for existing names and invalid characters
+     * @param name The name to be checked
+     * @param parentId The parent folder (will be 'root' if not provided)
+     * @returns already existing names
+     */
+    validateNames(names, parentId) {
+        console.log({ names, parentId });
+        if (parentId === DRIVE_ROOT_FOLDER_ID)
+            parentId = undefined;
+        const dvp = {
+            app: 'osdrive',
+            fileNames: names,
+            targetFolderId: parentId || undefined
+        };
+        return this.#backend.post('/dms/objects/validate', dvp).pipe(catchError((res) => of(res.error)));
+    }
+    getDefaultRibbonActions() {
+        if (!this._defaultRibbonActions.length) {
+            //[BASE_ACTION.download, BASE_ACTION.delete, 'app.drive.action.rename', BASE_ACTION.copy, BASE_ACTION.cut]
+            Object.values({ ...BASE_ACTION, rename: 'app.drive.action.rename' }).forEach((id) => {
+                const a = this.#actionsService.getActionById(id, ACTION_CONTEXT);
+                if (a)
+                    this._defaultRibbonActions.push(a);
+            });
+        }
+        return this._defaultRibbonActions;
+    }
+    _getActions() {
+        this.setBusy(true);
+        this.#actionsService
+            .getActions(this.state$.selection(), {
+            context: ACTION_CONTEXT
+        })
+            .subscribe((actions) => {
+            patchState(this.state$, { actions });
+        })
+            .add(() => this.setBusy(false));
+    }
+    /**
+     * Apply search conditions regarding folder listings
+     * @param q
+     */
+    applyFolderListSearchConditions(q, addBaseTypeId = true) {
+        // folders first
+        if (!q.sort)
+            q.sort = [];
+        addBaseTypeId &&
+            q.sort.push({
+                field: BaseObjectTypeField.BASE_TYPE_ID,
+                order: 'desc'
+            });
+        q = this.applyBasicSearchConditions(q);
+        return q;
+    }
+    applyBasicSearchConditions(q) {
+        q.fields = [
+            BaseObjectTypeField.OBJECT_ID,
+            BaseObjectTypeField.MODIFICATION_DATE,
+            BaseObjectTypeField.MODIFIED_BY,
+            ContentStreamField.FILENAME,
+            ContentStreamField.MIME_TYPE,
+            ContentStreamField.ID,
+            ContentStreamField.LENGTH
+        ];
+        if (!q.types || !q.types.includes(FS_SOTS.object))
+            q.types = [...(q.types || []), FS_SOTS.object];
+        // q.sortOptions.push(new SortOption(BaseObjectTypeField.BASE_TYPE_ID, 'desc'));
+        const sort = this.state$.sort() || this.#defaultSort;
+        if (!q.sort)
+            q.sort = [];
+        q.sort.push({
+            field: sort.property,
+            order: sort.order
+        });
+        q.includePermissions = true;
+        // new SortOption(sort.property, sort.order));
+        return q;
+    }
+    resolveFilesState(id) {
+        return this.getFolderHierarchy(id);
+    }
+    getFolderHierarchy(folderId) {
+        patchState(this.state$, {
+            breadcrumb: {
+                ...this.initialState.breadcrumb,
+                loading: true
+            }
+        });
+        return folderId === DRIVE_ROOT_FOLDER_ID
+            ? of([])
+            : this.#fetchFolder(folderId, 0, this.MAX_DEPTH).pipe(tap((res) => {
+                let items = [];
+                if (res.items.length > 0) {
+                    items = [...items, ...res.items];
+                }
+                patchState(this.state$, {
+                    breadcrumb: {
+                        ...this.initialState.breadcrumb,
+                        partial: res.partial,
+                        loading: false,
+                        items
+                    }
+                });
+            }), map((res) => res.items));
+    }
+    #fetchFolder(folderId, depth, maxDepth) {
+        if (depth >= maxDepth)
+            return of({ partial: true, items: [] });
+        const cachedFolder = this.breadcrumbCache.get(folderId);
+        if (cachedFolder) {
+            return cachedFolder.parentId
+                ? this.#fetchFolder(cachedFolder.parentId, depth + 1, maxDepth).pipe(map((parentFolders) => ({
+                    partial: parentFolders.partial,
+                    items: [...parentFolders.items, { name: cachedFolder.name, id: cachedFolder.id }]
+                })))
+                : of({
+                    partial: false,
+                    items: [{ name: cachedFolder.name, id: cachedFolder.id }]
+                });
+        }
+        return this.#dmsService.getDmsObject(folderId).pipe(map((folder) => {
+            const currentFolder = {
+                name: folder.data[FS_PROPERTIES.name],
+                id: folder.data[BaseObjectTypeField.OBJECT_ID],
+                parentId: folder.parentId
+            };
+            // this.breadcrumbCache.set(folder.id, currentFolder);
+            return currentFolder;
+        }), switchMap((folder) => {
+            if (!folder.parentId) {
+                return of({
+                    partial: false,
+                    items: [{ name: folder.name, id: folder.id }]
+                });
+            }
+            return this.#fetchFolder(folder.parentId, depth + 1, maxDepth).pipe(map((parentFolders) => ({
+                partial: parentFolders.partial,
+                items: [...parentFolders.items, { name: folder.name, id: folder.id }]
+            })));
+        }));
+    }
+    getVersions(id) {
+        patchState(this.state$, { busy: true });
+        return this.#dmsService.getDmsObjectVersions(id).pipe(tap((versions) => {
+            patchState(this.state$, {
+                busy: false,
+                versions: {
+                    versionsList: mapSearchResult(versions),
+                    selectedVersion: this.state$.versions().selectedVersion
+                }
+            });
+        }));
+    }
+    getSelectedDmsObject(id) {
+        return this.#dmsService.getDmsObject(id).pipe(tap((dmsObject) => patchState(this.state$, {
+            selectedDmsObject: dmsObject,
+            versions: {
+                versionsList: this.state$.versions.versionsList(),
+                selectedVersion: [dmsObject]
+            }
+        })));
+    }
+    setSelectedVersion(version) {
+        this.setBusy(true);
+        return this.#dmsService.getDmsObjectVersion(version.dmsObject.id, version.dmsObject.version).pipe(tap((res) => patchState(this.state$, {
+            versions: {
+                versionsList: this.state$.versions.versionsList(),
+                selectedVersion: [res]
+            }
+        })), tap(() => this.setBusy(false)));
+    }
+    setNewVersion(version) {
+        patchState(this.state$, { busy: true });
+        const selectedVersion = this.state$.versions.selectedVersion();
+        if (selectedVersion) {
+            const versionNumber = version ?? selectedVersion[0].version;
+            return this.#dmsService.restoreDmsObject(selectedVersion[0].id, versionNumber).pipe(switchMap((object) => this.getVersions(object.id)));
+        }
+        return of(null);
+    }
+    clearVersions() {
+        patchState(this.state$, { versions: this.initialState.versions });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DriveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DriveService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DriveService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drive.service.js","sourceRoot":"","sources":["../../../../../../../../libs/apps/drive/src/lib/services/drive/drive.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { NavigationStart, Router } from '@angular/router';\nimport { patchState, signalState } from '@ngrx/signals';\nimport {\n  BackendService,\n  BaseObjectTypeField,\n  ClipboardService,\n  ContentStreamField,\n  DmsObject,\n  DmsService,\n  EventService,\n  SearchQuery,\n  SearchService,\n  SystemType,\n  YuvEvent,\n  YuvEventType\n} from '@yuuvis/client-core';\nimport { Action, ActionsService, BASE_ACTION } from '@yuuvis/client-framework/actions';\nimport { YvcOverlayService } from '@yuuvis/components/overlay';\nimport { Observable, Subject, catchError, filter, forkJoin, map, of, switchMap, tap } from 'rxjs';\nimport { ACTION_CONTEXT, APP_ID, APP_SCHEMA, FS_PROPERTIES, FS_SOTS } from '../../drive.schema';\nimport { DRIVE_APP_BREADCRUMB_MAX_DEPTH } from '../tokens';\nimport {\n  BreadCrumb,\n  CreateError,\n  CreateResult,\n  DRIVE_ACTION_MODE,\n  DRIVE_EVENT,\n  DRIVE_ROOT_FOLDER_ID,\n  DriveState,\n  DriveValidatePayload,\n  DriveValidateResponse\n} from './drive.interface';\nimport { ResolveNameConflictsComponent } from './resolve-name-conflicts/resolve-name-conflicts.component';\nimport { ResolveNameConflictsPayload } from './resolve-name-conflicts/resolve-name-conflicts.interface';\nimport { mapSearchResult } from './versions/versions.mapping';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DriveService {\n  readonly #actionsService = inject(ActionsService);\n  readonly #eventService = inject(EventService);\n  readonly #router = inject(Router);\n  readonly #dmsService = inject(DmsService);\n  readonly #searchService = inject(SearchService);\n  readonly #overlay = inject(YvcOverlayService);\n  readonly #backend = inject(BackendService);\n  readonly #clipboardService = inject(ClipboardService);\n\n  private readonly MAX_DEPTH: number = inject(DRIVE_APP_BREADCRUMB_MAX_DEPTH);\n  private breadcrumbCache = new Map<string, { name: string; id: string; parentId: string | null }>();\n\n  #eventSource = new Subject<string>();\n  readonly events$: Observable<string> = this.#eventSource.asObservable();\n\n  readonly #defaultSort: {\n    property: string;\n    order: 'asc' | 'desc';\n  } = {\n    property: FS_PROPERTIES.name,\n    order: 'asc'\n  };\n\n  readonly initialState: DriveState = {\n    currentFolder: null,\n    query: null,\n    queryTitle: null,\n    selection: [],\n    actions: [],\n    busy: false,\n    sort: this.#defaultSort,\n    breadcrumb: {\n      loading: false,\n      partial: false,\n      items: [],\n      folder: null\n    },\n    versions: {\n      versionsList: [],\n      selectedVersion: null\n    },\n    selectedDmsObject: null\n  };\n\n  readonly state$ = signalState<DriveState>(this.initialState);\n  readonly breadcrumbFolderPreview = this.state$.breadcrumb.folder;\n  private _busyTaskCount = 0;\n  private _defaultRibbonActions: Action[] = [];\n  lastRouteURL?: string;\n\n  constructor() {\n    this.#router.events\n      .pipe(\n        takeUntilDestroyed(),\n        filter((e) => this.state$.selection().length > 0 && e instanceof NavigationStart)\n      )\n      // clear selection on route chnages\n      .subscribe({ next: () => this.setSelection([]) });\n\n    this.#eventService.on(YuvEventType.DMS_OBJECT_UPDATED).subscribe((e: YuvEvent) => {\n      // check if current selection contains the updated object\n      const dmsObject = e.data as DmsObject;\n      const selection = this.state$.selection();\n      const matchIdx = selection.findIndex((o) => o.id === dmsObject.id);\n      if (matchIdx !== -1) {\n        // update the object in the selection\n        selection[matchIdx] = dmsObject;\n        patchState(this.state$, { selection: [...selection] });\n      }\n    });\n\n    this.#eventService\n      .on(YuvEventType.DMS_OBJECT_DELETED, YuvEventType.DMS_OBJECT_CREATED, YuvEventType.DMS_OBJECTS_MOVED)\n      .subscribe(() => this.emitEvent(DRIVE_EVENT.refresh));\n  }\n\n  #mapedCurrentFolder() {\n    return this.state$.currentFolder() === DRIVE_ROOT_FOLDER_ID ? null : this.state$.currentFolder();\n  }\n\n  emitEvent(evt: string) {\n    this.#eventSource.next(evt);\n  }\n\n  setBusy(busy: boolean) {\n    if (busy) this._busyTaskCount++;\n    else if (this._busyTaskCount > 0) this._busyTaskCount--;\n    patchState(this.state$, { busy: this._busyTaskCount !== 0 });\n  }\n\n  setSelection(o: DmsObject[]) {\n    patchState(this.state$, { selection: o });\n    this._getActions();\n  }\n\n  updateQuery(query: SearchQuery, queryTitle: string | null = null) {\n    patchState(this.state$, {\n      query: this.applyFolderListSearchConditions(query),\n      queryTitle: queryTitle\n    });\n  }\n\n  setSort(property: string, order: 'asc' | 'desc') {\n    const stateQuery = this.state$.query();\n    if (stateQuery) {\n      const clonedQueryState = structuredClone(stateQuery);\n\n      // TODO: remove if folders should stay on top\n      clonedQueryState.sort = [];\n\n      const sort = property ? { property, order } : { ...this.#defaultSort, order };\n\n      patchState(this.state$, { query: clonedQueryState, sort });\n      this.applyFolderListSearchConditions(clonedQueryState, !property);\n    }\n  }\n\n  updateCurrentFolder(currentFolderID: string | null | undefined) {\n    patchState(this.state$, { currentFolder: currentFolderID || null });\n  }\n\n  #copyToFolder(objects: DmsObject[], folderId: string | null, options: { waitForSearchConsistency: boolean }, validateNames = true): Observable<any> {\n    return validateNames\n      ? this.validateNames(\n          objects.filter((o) => o.sots.includes(FS_SOTS.object)).map((f) => f.data[FS_PROPERTIES.name] as string),\n          folderId\n        ).pipe(\n          switchMap((res: DriveValidateResponse) => {\n            if (res.existingFileNames?.length || res.invalidFileNames?.length) {\n              this.#resolveNameConflicts({\n                existingFileNames: res.existingFileNames,\n                invalidFileNames: res.invalidFileNames,\n                mode: 'copy',\n                items: objects\n              });\n              return of([]);\n            } else return this.#dmsService.copyDmsObjects(folderId, objects, options);\n          })\n        )\n      : this.#dmsService.copyDmsObjects(folderId, objects, options);\n  }\n\n  #moveToFolder(objects: DmsObject[], folderId: string | null, options: { waitForSearchConsistency: boolean }, validateNames = true): Observable<any> {\n    return validateNames\n      ? this.validateNames(\n          objects.filter((o) => o.sots.includes(FS_SOTS.object)).map((f) => f.data[FS_PROPERTIES.name] as string),\n          folderId\n        ).pipe(\n          switchMap((res: DriveValidateResponse) => {\n            if (res.existingFileNames?.length || res.invalidFileNames?.length) {\n              console.log('VALIDATION: ', { res });\n              this.#resolveNameConflicts({\n                existingFileNames: res.existingFileNames,\n                invalidFileNames: res.invalidFileNames,\n                mode: 'move',\n                items: objects\n              });\n              return of([]);\n            } else return this.#dmsService.moveDmsObjects(folderId, objects, options);\n          })\n        )\n      : this.#dmsService.moveDmsObjects(folderId, objects, options);\n  }\n\n  copyToCurrentFolder(objects: DmsObject[], validateNames = true): Observable<any> {\n    const options = { waitForSearchConsistency: true };\n    return this.#copyToFolder(objects, this.#mapedCurrentFolder(), options, validateNames);\n  }\n\n  moveToCurrentFolder(objects: DmsObject[], validateNames = true): Observable<any> {\n    const options = { waitForSearchConsistency: true };\n    return this.#moveToFolder(objects, this.#mapedCurrentFolder(), options, validateNames);\n  }\n\n  #resolveNameConflicts(payload: ResolveNameConflictsPayload) {\n    this.#overlay.open(ResolveNameConflictsComponent, payload, {\n      maxWidth: '400px'\n    });\n  }\n\n  pasteFromClipboard(destinationObject?: DmsObject): Observable<any> {\n    const cd = this.#clipboardService.getClipboardData(APP_ID);\n    const destination = destinationObject?.isFolder ? destinationObject.id : this.#mapedCurrentFolder();\n    return (\n      cd && cd.objects && cd.objects.length > 0\n        ? cd?.mode === DRIVE_ACTION_MODE.CUT\n          ? this.#moveToFolder(cd.objects || [], destination, { waitForSearchConsistency: true }, true)\n          : cd?.mode === DRIVE_ACTION_MODE.COPY\n            ? this.#copyToFolder(cd.objects || [], destination, { waitForSearchConsistency: true }, true)\n            : of(null)\n        : of(null)\n    ).pipe(\n      tap((res) => {\n        res && this.emitEvent(DRIVE_EVENT.refresh);\n        this.#clipboardService.clear();\n      })\n    );\n  }\n\n  checkNamesAndUpload(files: File[], data?: Record<string, unknown>): Observable<CreateResult[]> {\n    return this.validateNames(\n      files.map((f) => f.name),\n      this.#mapedCurrentFolder()\n    ).pipe(\n      switchMap((res: DriveValidateResponse) => {\n        if (res.existingFileNames?.length || res.invalidFileNames?.length) {\n          const resPayload: ResolveNameConflictsPayload = {\n            existingFileNames: res.existingFileNames,\n            invalidFileNames: res.invalidFileNames,\n            mode: 'upload',\n            items: files,\n            data\n          };\n          this.#overlay.open(ResolveNameConflictsComponent, resPayload);\n          return of([]);\n        } else return this.upload(files, data);\n      })\n    );\n  }\n\n  uploadContent(objectId: string, file: File): Observable<CreateResult[]> {\n    return this.#dmsService.uploadContent(objectId, file);\n  }\n\n  /**\n   * Uploads files to the current folder\n   * @param files files to be uploaded\n   * @param data additional data to be applied to the object\n   */\n  upload(files: File[], data?: Record<string, unknown>): Observable<CreateResult[]> {\n    return forkJoin(\n      files.map((file: File) => {\n        const uploadData: Record<string, any> = data || {};\n        // apply filesystem SOT\n        const sots = uploadData[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] || [];\n        uploadData[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [...sots, FS_SOTS.object];\n        // setup the name to be the filename\n        uploadData[FS_PROPERTIES.name] = file.name;\n        const cf = this.#mapedCurrentFolder();\n        if (cf && cf !== DRIVE_ROOT_FOLDER_ID) uploadData[BaseObjectTypeField.PARENT_ID] = cf;\n        return this.#dmsService.createDmsObject(SystemType.DOCUMENT, uploadData, [file], file.name).pipe(\n          map((res) => ({ id: res[0] })),\n          catchError((e: HttpErrorResponse) => of({ error: this.#mapCreateError(e) }))\n        );\n      })\n    );\n  }\n\n  createFolder(name: string): Observable<CreateResult> {\n    const parentID = this.#mapedCurrentFolder();\n    const data: Record<string, any> = {};\n    data[FS_PROPERTIES.name] = name;\n    // apply filesystem SOT\n    data[BaseObjectTypeField.SECONDARY_OBJECT_TYPE_IDS] = [FS_SOTS.object];\n    if (parentID && parentID !== DRIVE_ROOT_FOLDER_ID) data[BaseObjectTypeField.PARENT_ID] = parentID;\n    return this.#dmsService.createDmsObject(APP_SCHEMA.types.folder.objectType || '', data, []).pipe(\n      map((res) => ({ id: res[0] })),\n      catchError((e: HttpErrorResponse) => of({ error: this.#mapCreateError(e) }))\n    );\n  }\n\n  #mapCreateError(e: HttpErrorResponse): CreateError {\n    let error: CreateError = 'default';\n    const ec = e.error.serviceErrorCode;\n    if (ec === 99999) {\n      const iec = e.error.innerError?.serviceErrorCode;\n      if (iec === 11000) error = 'nameExists';\n    }\n    return error;\n  }\n\n  /**\n   * Checks for existing names and invalid characters\n   * @param name The name to be checked\n   * @param parentId The parent folder (will be 'root' if not provided)\n   * @returns already existing names\n   */\n  validateNames(names: string[], parentId?: string | null): Observable<DriveValidateResponse> {\n    console.log({ names, parentId });\n\n    if (parentId === DRIVE_ROOT_FOLDER_ID) parentId = undefined;\n    const dvp: DriveValidatePayload = {\n      app: 'osdrive',\n      fileNames: names,\n      targetFolderId: parentId || undefined\n    };\n    return this.#backend.post('/dms/objects/validate', dvp).pipe(catchError((res: HttpErrorResponse) => of(res.error)));\n  }\n\n  getDefaultRibbonActions() {\n    if (!this._defaultRibbonActions.length) {\n      //[BASE_ACTION.download, BASE_ACTION.delete, 'app.drive.action.rename', BASE_ACTION.copy, BASE_ACTION.cut]\n      Object.values({ ...BASE_ACTION, rename: 'app.drive.action.rename' }).forEach((id) => {\n        const a = this.#actionsService.getActionById(id, ACTION_CONTEXT);\n        if (a) this._defaultRibbonActions.push(a);\n      });\n    }\n    return this._defaultRibbonActions;\n  }\n\n  private _getActions() {\n    this.setBusy(true);\n    this.#actionsService\n      .getActions(this.state$.selection(), {\n        context: ACTION_CONTEXT\n      })\n      .subscribe((actions: Action[]) => {\n        patchState(this.state$, { actions });\n      })\n      .add(() => this.setBusy(false));\n  }\n\n  /**\n   * Apply search conditions regarding folder listings\n   * @param q\n   */\n  applyFolderListSearchConditions(q: SearchQuery, addBaseTypeId = true): SearchQuery {\n    // folders first\n    if (!q.sort) q.sort = [];\n    addBaseTypeId &&\n      q.sort.push({\n        field: BaseObjectTypeField.BASE_TYPE_ID,\n        order: 'desc'\n      });\n    q = this.applyBasicSearchConditions(q);\n\n    return q;\n  }\n\n  applyBasicSearchConditions(q: SearchQuery): SearchQuery {\n    q.fields = [\n      BaseObjectTypeField.OBJECT_ID,\n      BaseObjectTypeField.MODIFICATION_DATE,\n      BaseObjectTypeField.MODIFIED_BY,\n      ContentStreamField.FILENAME,\n      ContentStreamField.MIME_TYPE,\n      ContentStreamField.ID,\n      ContentStreamField.LENGTH\n    ];\n    if (!q.types || !q.types.includes(FS_SOTS.object)) q.types = [...(q.types || []), FS_SOTS.object];\n    // q.sortOptions.push(new SortOption(BaseObjectTypeField.BASE_TYPE_ID, 'desc'));\n    const sort = this.state$.sort() || this.#defaultSort;\n    if (!q.sort) q.sort = [];\n    q.sort.push({\n      field: sort.property,\n      order: sort.order\n    });\n    q.includePermissions = true;\n    // new SortOption(sort.property, sort.order));\n    return q;\n  }\n\n  resolveFilesState(id: string) {\n    return this.getFolderHierarchy(id);\n  }\n\n  getFolderHierarchy(folderId: string): Observable<BreadCrumb[]> {\n    patchState(this.state$, {\n      breadcrumb: {\n        ...this.initialState.breadcrumb,\n        loading: true\n      }\n    });\n\n    return folderId === DRIVE_ROOT_FOLDER_ID\n      ? of([])\n      : this.#fetchFolder(folderId, 0, this.MAX_DEPTH).pipe(\n          tap((res: { partial: boolean; items: BreadCrumb[] }) => {\n            let items: BreadCrumb[] = [];\n            if (res.items.length > 0) {\n              items = [...items, ...res.items];\n            }\n\n            patchState(this.state$, {\n              breadcrumb: {\n                ...this.initialState.breadcrumb,\n                partial: res.partial,\n                loading: false,\n                items\n              }\n            });\n          }),\n          map((res) => res.items)\n        );\n  }\n\n  #fetchFolder(\n    folderId: string,\n    depth: number,\n    maxDepth: number\n  ): Observable<{\n    partial: boolean;\n    items: BreadCrumb[];\n  }> {\n    if (depth >= maxDepth) return of({ partial: true, items: [] });\n    const cachedFolder = this.breadcrumbCache.get(folderId);\n    if (cachedFolder) {\n      return cachedFolder.parentId\n        ? this.#fetchFolder(cachedFolder.parentId, depth + 1, maxDepth).pipe(\n            map((parentFolders) => ({\n              partial: parentFolders.partial,\n              items: [...parentFolders.items, { name: cachedFolder.name, id: cachedFolder.id }]\n            }))\n          )\n        : of({\n            partial: false,\n            items: [{ name: cachedFolder.name, id: cachedFolder.id }]\n          });\n    }\n    return this.#dmsService.getDmsObject(folderId).pipe(\n      map((folder) => {\n        const currentFolder = {\n          name: folder.data[FS_PROPERTIES.name] as string,\n          id: folder.data[BaseObjectTypeField.OBJECT_ID] as string,\n          parentId: folder.parentId\n        };\n        // this.breadcrumbCache.set(folder.id, currentFolder);\n        return currentFolder;\n      }),\n      switchMap((folder) => {\n        if (!folder.parentId) {\n          return of({\n            partial: false,\n            items: [{ name: folder.name, id: folder.id }]\n          });\n        }\n\n        return this.#fetchFolder(folder.parentId, depth + 1, maxDepth).pipe(\n          map((parentFolders) => ({\n            partial: parentFolders.partial,\n            items: [...parentFolders.items, { name: folder.name, id: folder.id }]\n          }))\n        );\n      })\n    );\n  }\n\n  getVersions(id: string): Observable<DmsObject[]> {\n    patchState(this.state$, { busy: true });\n    return this.#dmsService.getDmsObjectVersions(id).pipe(\n      tap((versions) => {\n        patchState(this.state$, {\n          busy: false,\n          versions: {\n            versionsList: mapSearchResult(versions),\n            selectedVersion: this.state$.versions().selectedVersion\n          }\n        });\n      })\n    );\n  }\n\n  getSelectedDmsObject(id: string): Observable<DmsObject> {\n    return this.#dmsService.getDmsObject(id).pipe(\n      tap((dmsObject) =>\n        patchState(this.state$, {\n          selectedDmsObject: dmsObject,\n          versions: {\n            versionsList: this.state$.versions.versionsList(),\n            selectedVersion: [dmsObject]\n          }\n        })\n      )\n    );\n  }\n\n  setSelectedVersion(version: any) {\n    this.setBusy(true);\n    return this.#dmsService.getDmsObjectVersion(version.dmsObject.id, version.dmsObject.version).pipe(\n      tap((res) =>\n        patchState(this.state$, {\n          versions: {\n            versionsList: this.state$.versions.versionsList(),\n            selectedVersion: [res]\n          }\n        })\n      ),\n      tap(() => this.setBusy(false))\n    );\n  }\n\n  setNewVersion(version?: number): Observable<DmsObject[] | null> {\n    patchState(this.state$, { busy: true });\n    const selectedVersion = this.state$.versions.selectedVersion();\n    if (selectedVersion) {\n      const versionNumber: number = version ?? selectedVersion[0].version;\n      return this.#dmsService.restoreDmsObject(selectedVersion[0].id, versionNumber).pipe(switchMap((object: DmsObject) => this.getVersions(object.id)));\n    }\n    return of(null);\n  }\n\n  clearVersions() {\n    patchState(this.state$, { versions: this.initialState.versions });\n  }\n}\n"]}