@yuuvis/client-core 0.6.5

package/esm2022/lib/service/upload/upload.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBsb2FkLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMveXV1dmlzL2NsaWVudC1jb3JlL3NyYy9saWIvc2VydmljZS91cGxvYWQvdXBsb2FkLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG4vKipcbiAqIEludHJlZmljZSBmb3IgcHJvdmlkaW5nIGFuIHVwbG9hZGluZyBzdGF0dXMgb2YgYW4gb2JqZWN0XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUHJvZ3Jlc3NTdGF0dXMge1xuICBpdGVtczogUHJvZ3Jlc3NTdGF0dXNJdGVtW107XG4gIGVycjogbnVtYmVyO1xufVxuLyoqXG4gKiBJcyBwYXJ0IG9mIHRoZSBgUHJvZ3Jlc3NTdGF0dXNgIGludGVyZmFjZVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFByb2dyZXNzU3RhdHVzSXRlbSB7XG4gIGlkOiBzdHJpbmc7XG4gIGZpbGVuYW1lOiBzdHJpbmc7XG4gIHByb2dyZXNzOiBPYnNlcnZhYmxlPG51bWJlcj47XG4gIHN1YnNjcmlwdGlvbjogU3Vic2NyaXB0aW9uO1xuICByZXN1bHQ/OiBVcGxvYWRSZXN1bHRbXTtcbiAgZXJyPzoge1xuICAgIGNvZGU6IG51bWJlcjtcbiAgICBtZXNzYWdlOiBzdHJpbmc7XG4gIH07XG59XG4vKipcbiAqIGlzIGEgcGFydCBvZiBgQ3JlYXRlZE9iamVjdGAgaW50ZXJmYWNlXG4gKi9cbmludGVyZmFjZSBDb250ZW50U3RyZWFtIHtcbiAgY29udGVudFN0cmVhbUlkOiBzdHJpbmc7XG4gIHJlcG9zaXRvcnlJZDogc3RyaW5nO1xuICBkaWdlc3Q6IHN0cmluZztcbiAgZmlsZU5hbWU6IHN0cmluZztcbiAgYXJjaGl2ZVBhdGg6IHN0cmluZztcbiAgbGVuZ3RoOiBudW1iZXI7XG4gIG1pbWVUeXBlOiBzdHJpbmc7XG59XG4vKipcbiAqIEludGVyZmFjZSBwcm92aWRuZyBwcm9wZXJ0aWVzIG9mIHVwbG9hZGVkIG9iamVjdCB0eXBlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVXBsb2FkUmVzdWx0IHtcbiAgb2JqZWN0SWQ6IHN0cmluZyB8IHN0cmluZ1tdO1xuICBjb250ZW50U3RyZWFtSWQ6IHN0cmluZztcbiAgZmlsZW5hbWU6IHN0cmluZztcbiAgbGFiZWw/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogSW50ZXJmYWNlIHRoYXQgd2FzIHVzZWQgYnkgdXBsb2FkIHNlcnZpY2VcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDcmVhdGVkT2JqZWN0IHtcbiAgYm9keT86IHtcbiAgICBvYmplY3RzOiB7XG4gICAgICBwcm9wZXJ0aWVzOiBhbnk7XG4gICAgICBjb250ZW50U3RyZWFtcz86IENvbnRlbnRTdHJlYW1bXTtcbiAgICB9W107XG4gIH07XG59XG4iXX0=

package/esm2022/lib/service/upload/upload.service.mjs

@@ -0,0 +1,228 @@
+import { HttpClient, HttpEventType, HttpRequest, HttpResponse } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, ReplaySubject, Subject, throwError } from 'rxjs';
+import { catchError, filter, map, scan, tap } from 'rxjs/operators';
+import { Utils } from '../../util/utils';
+import { BackendService } from '../backend/backend.service';
+import { Logger } from '../logger/logger';
+import { BaseObjectTypeField } from '../system/system.enum';
+import * as i0 from "@angular/core";
+const transformResponse = () => map((res) => (res && res.body ? res.body.objects.map((val) => val) : null));
+/**
+ * Service for providing upload of different object types into a client.
+ */
+export class UploadService {
+    constructor() {
+        this.#backend = inject(BackendService);
+        this.#http = inject(HttpClient);
+        this.#logger = inject(Logger);
+        this.#status = { err: 0, items: [] };
+        this.#statusSource = new ReplaySubject();
+        this.status$ = this.#statusSource.pipe(scan((acc, newVal) => ({ ...acc, ...newVal }), this.#status));
+        this.#uploadStatus = new BehaviorSubject(null);
+        this.uploadStatus$ = this.#uploadStatus.asObservable();
+    }
+    #backend;
+    #http;
+    #logger;
+    #status;
+    #statusSource;
+    #uploadStatus;
+    /**
+     * Upload a file.
+     * @param url The URL to upload the file to
+     * @param file The file to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    upload(url, file, label, silent) {
+        return this.#executeUpload(url, file, label || file.name, silent);
+    }
+    /**
+     * Upload files using multipart upload.
+     * @param url The URL to upload the files to
+     * @param files The files to be uploaded
+     * @param data Data to be send along with the files
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    uploadMultipart(url, files, data, label, silent) {
+        return this.#executeMultipartUpload(url, files, label || 'Upload', data, silent);
+    }
+    createDocument(url, data) {
+        const formData = this.#createFormData({ data });
+        const request = this.#createHttpRequest(url, { formData }, false);
+        return this.#http.request(request).pipe(filter((obj) => obj && obj.body), transformResponse(), catchError((err) => throwError(() => err)));
+    }
+    /**
+     * Cancels an upload request and removes it from the list of files being uploaded.
+     * @param id ID of the UploadItem to be canceled
+     */
+    cancelItem(id) {
+        if (id) {
+            const match = this.#status.items.find((i) => i.id === id);
+            if (match) {
+                match.subscription.unsubscribe();
+                this.#status.items = this.#status.items.filter((i) => i.id !== id);
+            }
+        }
+        else {
+            this.#status.items.forEach((element) => element.subscription.unsubscribe());
+            this.#status.items = [];
+        }
+        this.#status.err = this.#status.items.filter((i) => i.err).length;
+        this.#statusSource.next(this.#status);
+    }
+    /**
+     * Prepares Formdata for multipart upload.
+     * @param from contains form and or file
+     */
+    #createFormData({ file, data }) {
+        const formData = new FormData();
+        (file || []).forEach((f) => formData.append('files', f, f.name));
+        data ? formData.append('data', new Blob([JSON.stringify(data)], { type: 'application/json' })) : null;
+        return formData;
+    }
+    /**
+     * Prepares Http Request.
+     * @param url The URL to upload the file to
+     * @param content formdata or single file
+     * @param reportProgress Request should report upload progress
+     * @param method Request method
+     */
+    #createHttpRequest(url, content, reportProgress, method = 'POST') {
+        const { formData, file } = content;
+        // add request param to bypass the serviceworker
+        url += `${url.indexOf('?') === -1 ? '?' : '&'}ngsw-bypass=1`;
+        let headers = this.#backend.getAuthHeaders();
+        if (file) {
+            headers = headers.set('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(file.name)}`);
+        }
+        return new HttpRequest(method, url, file || formData, { headers, reportProgress });
+    }
+    /**
+     * Prepares single file POST upload.
+     * @param url The URL to upload the file to
+     * @param file The file to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    #executeUpload(url, file, label, silent = false) {
+        const request = this.#createHttpRequest(url, { file }, true);
+        return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());
+    }
+    /**
+     * Prepare multipart upload.
+     * @param url The URL to upload the file to
+     * @param file Array of files to be uploaded
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     * @param data Data to be send along with the files
+     */
+    #executeMultipartUpload(url, file, label, data, silent = false) {
+        const formData = this.#createFormData({ file, data });
+        const request = this.#createHttpRequest(url, { formData }, true);
+        return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());
+    }
+    #generateResult(result) {
+        const objects = result.body?.objects;
+        if (objects && objects.length > 1) {
+            const data = objects[0];
+            // const bp = this.#system.getBaseProperties();
+            // const label = data.properties[bp.title] ? data.properties[bp.title].value : '...';
+            // TODO: Get the label from somewhere
+            const label = '...';
+            return [
+                {
+                    objectId: objects.map((val) => val.properties[BaseObjectTypeField.OBJECT_ID].value),
+                    contentStreamId: data.contentStreams[0]?.contentStreamId,
+                    filename: data.contentStreams[0]?.fileName,
+                    label: `(${objects.length}) ${label}`
+                }
+            ];
+        }
+        else {
+            return result.body.objects.map((o) => ({
+                objectId: o.properties[BaseObjectTypeField.OBJECT_ID].value,
+                contentStreamId: o.contentStreams[0]?.contentStreamId,
+                filename: o.contentStreams[0]?.fileName,
+                // label: o.properties[bp.title] ? o.properties[bp.title].value : o.contentStreams![0]?.fileName
+                // TODO: Get the label from somewhere
+                label: o.contentStreams[0]?.fileName
+            }));
+        }
+    }
+    #createProgressStatus(event, progress, id) {
+        if (event.type === HttpEventType.UploadProgress) {
+            const percentDone = Math.round((100 * event.loaded) / event.total);
+            progress.next(percentDone);
+        }
+        else if (event instanceof HttpResponse) {
+            progress.complete();
+            // add upload response
+            // this.status.items = this.status.items.filter(s => s.id !== id);
+            const idx = this.#status.items.findIndex((s) => s.id === id);
+            if (idx !== -1) {
+                this.#status.items[idx].result = this.#generateResult(event);
+                this.#statusSource.next(this.#status);
+            }
+        }
+    }
+    #createUploadError(err, progress, id) {
+        const statusItem = this.#status.items.find((s) => s.id === id);
+        statusItem.err = {
+            code: err.status,
+            message: err.error ? err.error.errorMessage : err.message
+        };
+        this.#logger.error('upload failed', statusItem);
+        this.#status.err++;
+        this.#statusSource.next(this.#status);
+        progress.next(0);
+        return throwError(() => new Error(err.message));
+    }
+    /**
+     * Actually starts the upload process.
+     * @param request Request to be executed
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     */
+    #startUploadWithFile(request, label) {
+        return new Observable((o) => {
+            const id = Utils.uuid();
+            const progress = new Subject();
+            let result;
+            // Create a subscription from the http request that will be applied to the upload
+            // status item in order to be able to cancel the request later on.
+            this.#uploadStatus.next(false);
+            const subscription = this.#http
+                .request(request)
+                .pipe(catchError((err) => this.#createUploadError(err, progress, id)), tap((event) => this.#createProgressStatus(event, progress, id)))
+                // actual return value of this function
+                .subscribe({
+                next: (res) => (res.status ? (result = res) : null),
+                error: (err) => {
+                    o.error(err);
+                    this.#uploadStatus.next(true);
+                    o.complete();
+                },
+                complete: () => {
+                    o.next(result);
+                    this.#uploadStatus.next(true);
+                    o.complete();
+                }
+            });
+            this.#status.items.push({
+                id,
+                filename: label,
+                progress: progress.asObservable(),
+                subscription,
+                err: undefined
+            });
+            this.#statusSource.next(this.#status);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/upload/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpEvent, HttpEventType, HttpRequest, HttpResponse } from '@angular/common/http';\nimport { inject, Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, ReplaySubject, Subject, throwError } from 'rxjs';\nimport { catchError, filter, map, scan, tap } from 'rxjs/operators';\nimport { Utils } from '../../util/utils';\nimport { BackendService } from '../backend/backend.service';\nimport { Logger } from '../logger/logger';\nimport { BaseObjectTypeField } from '../system/system.enum';\nimport { CreatedObject, ProgressStatus, UploadResult } from './upload.interface';\n\nconst transformResponse = () => map((res: CreatedObject) => (res && res.body ? res.body.objects.map((val) => val) : null));\n\n/**\n * Service for providing upload of different object types into a client.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class UploadService {\n  readonly #backend = inject(BackendService);\n  readonly #http = inject(HttpClient);\n  readonly #logger = inject(Logger);\n\n  #status: ProgressStatus = { err: 0, items: [] };\n  #statusSource = new ReplaySubject<ProgressStatus>();\n  status$: Observable<ProgressStatus> = this.#statusSource.pipe(scan((acc: ProgressStatus, newVal) => ({ ...acc, ...newVal }), this.#status));\n  #uploadStatus = new BehaviorSubject<boolean | null>(null);\n  uploadStatus$: Observable<boolean | null> = this.#uploadStatus.asObservable();\n\n  /**\n   * Upload a file.\n   * @param url The URL to upload the file to\n   * @param file The file to be uploaded\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   */\n  upload(url: string, file: File, label?: string, silent?: boolean): Observable<any> {\n    return this.#executeUpload(url, file, label || file.name, silent);\n  }\n\n  /**\n   * Upload files using multipart upload.\n   * @param url The URL to upload the files to\n   * @param files The files to be uploaded\n   * @param data Data to be send along with the files\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   */\n  uploadMultipart(url: string, files: File[], data?: any, label?: string, silent?: boolean): Observable<any> {\n    return this.#executeMultipartUpload(url, files, label || 'Upload', data, silent);\n  }\n\n  createDocument(url: string, data: any): Observable<any> {\n    const formData: FormData = this.#createFormData({ data });\n    const request = this.#createHttpRequest(url, { formData }, false);\n    return this.#http.request(request).pipe(\n      filter((obj: any) => obj && obj.body),\n      transformResponse(),\n      catchError((err) => throwError(() => err))\n    );\n  }\n\n  /**\n   * Cancels an upload request and removes it from the list of files being uploaded.\n   * @param id ID of the UploadItem to be canceled\n   */\n  cancelItem(id?: string) {\n    if (id) {\n      const match = this.#status.items.find((i) => i.id === id);\n      if (match) {\n        match.subscription.unsubscribe();\n        this.#status.items = this.#status.items.filter((i) => i.id !== id);\n      }\n    } else {\n      this.#status.items.forEach((element) => element.subscription.unsubscribe());\n      this.#status.items = [];\n    }\n    this.#status.err = this.#status.items.filter((i) => i.err).length;\n    this.#statusSource.next(this.#status);\n  }\n\n  /**\n   * Prepares Formdata for multipart upload.\n   * @param from contains form and or file\n   */\n  #createFormData({ file, data }: { data?: any; file?: File[] }): FormData {\n    const formData: FormData = new FormData();\n    (file || []).forEach((f) => formData.append('files', f, f.name));\n    data ? formData.append('data', new Blob([JSON.stringify(data)], { type: 'application/json' })) : null;\n    return formData;\n  }\n\n  /**\n   * Prepares Http Request.\n   * @param url The URL to upload the file to\n   * @param content formdata or single file\n   * @param reportProgress Request should report upload progress\n   * @param method Request method\n   */\n  #createHttpRequest(url: string, content: Partial<{ formData: FormData; file: File }>, reportProgress: boolean, method = 'POST'): HttpRequest<any> {\n    const { formData, file } = content;\n    // add request param to bypass the serviceworker\n    url += `${url.indexOf('?') === -1 ? '?' : '&'}ngsw-bypass=1`;\n\n    let headers = this.#backend.getAuthHeaders();\n    if (file) {\n      headers = headers.set('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(file.name)}`);\n    }\n\n    return new HttpRequest(method, url, file || formData, { headers, reportProgress });\n  }\n\n  /**\n   * Prepares single file POST upload.\n   * @param url The URL to upload the file to\n   * @param file The file to be uploaded\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   */\n  #executeUpload(url: string, file: File, label: string, silent = false): Observable<any> {\n    const request = this.#createHttpRequest(url, { file }, true);\n    return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());\n  }\n\n  /**\n   * Prepare multipart upload.\n   * @param url The URL to upload the file to\n   * @param file Array of files to be uploaded\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   * @param data Data to be send along with the files\n   */\n  #executeMultipartUpload(url: string, file: File[], label: string, data?: any, silent = false): Observable<any> {\n    const formData: FormData = this.#createFormData({ file, data });\n    const request = this.#createHttpRequest(url, { formData }, true);\n    return silent ? this.#http.request(request) : this.#startUploadWithFile(request, label).pipe(transformResponse());\n  }\n\n  #generateResult(result: CreatedObject): UploadResult[] {\n    const objects = result.body?.objects;\n    if (objects && objects.length > 1) {\n      const data = objects[0];\n      // const bp = this.#system.getBaseProperties();\n      // const label = data.properties[bp.title] ? data.properties[bp.title].value : '...';\n      // TODO: Get the label from somewhere\n      const label = '...';\n      return [\n        {\n          objectId: objects.map((val: any) => val.properties[BaseObjectTypeField.OBJECT_ID].value),\n          contentStreamId: data.contentStreams![0]?.contentStreamId,\n          filename: data.contentStreams![0]?.fileName,\n          label: `(${objects.length}) ${label}`\n        }\n      ];\n    } else {\n      return result.body!.objects.map((o) => ({\n        objectId: o.properties[BaseObjectTypeField.OBJECT_ID].value,\n        contentStreamId: o.contentStreams![0]?.contentStreamId,\n        filename: o.contentStreams![0]?.fileName,\n        // label: o.properties[bp.title] ? o.properties[bp.title].value : o.contentStreams![0]?.fileName\n        // TODO: Get the label from somewhere\n        label: o.contentStreams![0]?.fileName\n      }));\n    }\n  }\n\n  #createProgressStatus(event: any, progress: Subject<number>, id: string) {\n    if (event.type === HttpEventType.UploadProgress) {\n      const percentDone = Math.round((100 * event.loaded) / event.total);\n      progress.next(percentDone);\n    } else if (event instanceof HttpResponse) {\n      progress.complete();\n      // add upload response\n      // this.status.items = this.status.items.filter(s => s.id !== id);\n      const idx = this.#status.items.findIndex((s) => s.id === id);\n      if (idx !== -1) {\n        this.#status.items[idx].result = this.#generateResult(event);\n        this.#statusSource.next(this.#status);\n      }\n    }\n  }\n\n  #createUploadError(err: HttpErrorResponse, progress: Subject<number>, id: string): Observable<HttpErrorResponse> {\n    const statusItem = this.#status.items.find((s) => s.id === id);\n    statusItem!.err = {\n      code: err.status,\n      message: err.error ? err.error.errorMessage : err.message\n    };\n    this.#logger.error('upload failed', statusItem);\n    this.#status.err++;\n    this.#statusSource.next(this.#status);\n    progress.next(0);\n    return throwError(() => new Error(err.message));\n  }\n\n  /**\n   * Actually starts the upload process.\n   * @param request Request to be executed\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   */\n  #startUploadWithFile(request: any, label: string): Observable<CreatedObject> {\n    return new Observable((o: any) => {\n      const id = Utils.uuid();\n      const progress = new Subject<number>();\n      let result: any;\n      // Create a subscription from the http request that will be applied to the upload\n      // status item in order to be able to cancel the request later on.\n      this.#uploadStatus.next(false);\n      const subscription = this.#http\n        .request(request)\n        .pipe(\n          catchError((err: HttpErrorResponse) => this.#createUploadError(err, progress, id)),\n          tap((event: HttpErrorResponse | HttpEvent<unknown>) => this.#createProgressStatus(event, progress, id))\n        )\n        // actual return value of this function\n        .subscribe({\n          next: (res: any) => (res.status ? (result = res) : null),\n          error: (err) => {\n            o.error(err);\n            this.#uploadStatus.next(true);\n            o.complete();\n          },\n          complete: () => {\n            o.next(result);\n            this.#uploadStatus.next(true);\n            o.complete();\n          }\n        });\n\n      this.#status.items.push({\n        id,\n        filename: label,\n        progress: progress.asObservable(),\n        subscription,\n        err: undefined\n      });\n      this.#statusSource.next(this.#status);\n    });\n  }\n}\n"]}

package/esm2022/lib/service/user/user.service.mjs

@@ -0,0 +1,211 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, forkJoin, of } from 'rxjs';
+import { catchError, map, switchMap, tap } from 'rxjs/operators';
+import { YuvUser } from '../../model/yuv-user.model';
+import { OidcService } from '../auth/oidc.service';
+import { BackendService } from '../backend/backend.service';
+import { Direction } from '../config/config.interface';
+import { ConfigService } from '../config/config.service';
+import { EventService } from '../event/event.service';
+import { YuvEventType } from '../event/events';
+import { Logger } from '../logger/logger';
+import { AdministrationRoles } from '../system/system.enum';
+import { SystemService } from '../system/system.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../backend/backend.service";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "../logger/logger";
+import * as i4 from "../system/system.service";
+import * as i5 from "../auth/oidc.service";
+import * as i6 from "../event/event.service";
+import * as i7 from "../config/config.service";
+/**
+ * Service providing user account configurations.
+ */
+export class UserService {
+    // #GLOBAL_SETTINGS = '/users/globalsettings/';
+    #USERS_SETTINGS;
+    #DEFAULT_SETTINGS;
+    #SETTINGS_SECTION_OBJECTCONFIG;
+    #user;
+    #userSource;
+    /**
+     * @ignore
+     */
+    constructor(backend, translate, logger, system, oidc, eventService, config) {
+        this.backend = backend;
+        this.translate = translate;
+        this.logger = logger;
+        this.system = system;
+        this.oidc = oidc;
+        this.eventService = eventService;
+        this.config = config;
+        // #GLOBAL_SETTINGS = '/users/globalsettings/';
+        this.#USERS_SETTINGS = '/users/settings/';
+        this.#DEFAULT_SETTINGS = '/users/settings';
+        this.#SETTINGS_SECTION_OBJECTCONFIG = 'object-config';
+        this.#userSource = new BehaviorSubject(this.#user);
+        this.user$ = this.#userSource.asObservable();
+        this.globalSettings = new Map();
+        this.canCreateObjects = false;
+    }
+    getUiDirection(iso) {
+        // languages that are read right to left
+        const rtlLanguages = ['ar', 'arc', 'dv', 'fa', 'ha', 'he', 'khw', 'ks', 'ku', 'ps', 'ur', 'yi'];
+        return rtlLanguages.indexOf(iso) === -1 ? Direction.LTR : Direction.RTL;
+    }
+    /**
+     * Set a new current user
+     * @param user The user to be set as current user
+     */
+    setCurrentUser(user) {
+        this.#user = user;
+        this.changeClientLocale('', false);
+        this.#userSource.next(this.#user);
+    }
+    getCurrentUser() {
+        return this.#user;
+    }
+    get hasAdminRole() {
+        return this.#user?.authorities?.includes(AdministrationRoles.ADMIN) || false;
+    }
+    get hasSystemRole() {
+        return this.#user?.authorities?.includes(AdministrationRoles.SYSTEM) || false;
+    }
+    get hasAdministrationRoles() {
+        return this.hasAdminRole || this.hasSystemRole;
+    }
+    get hasManageSettingsRole() {
+        const customRole = this.config.get('core.permissions.manageSettingsRole');
+        const manageSettingsRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(manageSettingsRole) || false;
+    }
+    get isAdvancedUser() {
+        const customRole = this.config.get('core.permissions.advancedUserRole');
+        const advancedUserRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(advancedUserRole) || false;
+    }
+    get isRetentionManager() {
+        const customRole = this.config.get('core.permissions.retentionManagerRole');
+        const retenetionManagerRole = customRole || AdministrationRoles.MANAGE_SETTINGS;
+        return this.#user?.authorities?.includes(retenetionManagerRole) || false;
+    }
+    /**
+     * Change the users client locale
+     * @param iso ISO locale string to be set as new client locale
+     */
+    changeClientLocale(iso, persist = true) {
+        if (this.#user) {
+            const languages = this.config.getClientLocales().map((lang) => lang.iso);
+            iso = iso || this.#user.getClientLocale(this.config.getDefaultClientLocale());
+            if (!languages.includes(iso)) {
+                iso = this.config.getDefaultClientLocale();
+            }
+            this.logger.debug("Changed client locale to '" + iso + "'");
+            this.backend.setHeader('Accept-Language', iso);
+            this.#user.uiDirection = this.getUiDirection(iso);
+            this.#user.userSettings.locale = iso;
+            if (this.translate.currentLang !== iso || this.system.authData?.language !== iso) {
+                const ob = persist
+                    ? forkJoin([
+                        this.translate.use(iso),
+                        this.system.updateLocalizations(iso),
+                        this.saveUserSettings(this.#user.userSettings).pipe(tap(() => {
+                            // this.#userSource.next(this.#user);
+                            this.logger.debug('Loading system definitions i18n resources for new locale.');
+                        }))
+                    ])
+                    : this.translate.use(iso);
+                ob.subscribe(() => this.eventService.trigger(YuvEventType.CLIENT_LOCALE_CHANGED, iso));
+            }
+        }
+    }
+    saveUserSettings(settings) {
+        if (this.#user) {
+            console.log(this.#user.userSettings);
+            this.#user.userSettings = { ...this.#user.userSettings, ...settings };
+            return this.backend.post(this.#DEFAULT_SETTINGS, this.#user.userSettings).pipe(tap(() => this.#userSource.next(this.#user)));
+        }
+        else
+            return of(null);
+    }
+    fetchUserSettings() {
+        return this.backend.get('/dms/permissions').pipe(catchError((e) => of(undefined)), switchMap((res) => {
+            this.setUserPermissions(res);
+            return this.backend.get(this.#DEFAULT_SETTINGS);
+        }));
+    }
+    setUserPermissions(res) {
+        this.userPermissions = {
+            create: this.mapPermissions('CREATE', res),
+            write: this.mapPermissions('WRITE', res),
+            read: this.mapPermissions('READ', res),
+            delete: this.mapPermissions('DELETE', res)
+        };
+        const sp = {
+            createableObjectTypes: [
+                ...this.userPermissions.create.folderTypes,
+                ...this.userPermissions.create.objectTypes,
+                ...this.userPermissions.create.secondaryObjectTypes
+            ],
+            searchableObjectTypes: [
+                ...this.userPermissions.read.folderTypes,
+                ...this.userPermissions.read.objectTypes,
+                ...this.userPermissions.read.secondaryObjectTypes
+            ]
+        };
+        this.system.setPermissions(sp);
+        this.canCreateObjects = sp.createableObjectTypes.length > 0;
+    }
+    mapPermissions(section, apiResponse) {
+        const res = apiResponse[section] || {};
+        return {
+            folderTypes: res['folderTypeIds'] || [],
+            objectTypes: res['objectTypeIds'] || [],
+            secondaryObjectTypes: res['secondaryObjectTypeIds'] || []
+        };
+    }
+    /**
+     * Search for a user based on a search term
+     * @param term Search term
+     * @param excludeMe whether or not to exclude myself from the result list
+     * @param roles narrow down the search results by certain roles
+     */
+    queryUser(term, excludeMe, roles) {
+        let params = new HttpParams().set('search', term).set('excludeMe', `${!!excludeMe}`);
+        roles?.length && roles.map((r) => (params = params.append(`roles`, r)));
+        return this.backend.get(`/idm/users?${params}`).pipe(map((users) => (!users ? [] : users.map((u) => new YuvUser(u)))));
+    }
+    getUserById(id) {
+        return this.backend.get(`/idm/users/${id}`).pipe(map((user) => new YuvUser(user, this.#user.userSettings)));
+    }
+    logout(redirRoute) {
+        if (this.backend.authUsesOpenIdConnect()) {
+            this.oidc.logout();
+        }
+        else {
+            const redir = redirRoute ? `?redir=${redirRoute}` : '';
+            window.location.href = `${this.backend.getApiBase('logout')}${redir}`;
+        }
+    }
+    getSettings(section) {
+        return this.#user ? this.backend.get(this.#USERS_SETTINGS + encodeURIComponent(section)) : of(null);
+    }
+    saveObjectConfig(objectConfigs) {
+        return this.backend.post(this.#USERS_SETTINGS + encodeURIComponent(this.#SETTINGS_SECTION_OBJECTCONFIG), objectConfigs);
+    }
+    loadObjectConfig() {
+        return this.getSettings(this.#SETTINGS_SECTION_OBJECTCONFIG).pipe(catchError(() => of(undefined)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, deps: [{ token: i1.BackendService }, { token: i2.TranslateService }, { token: i3.Logger }, { token: i4.SystemService }, { token: i5.OidcService }, { token: i6.EventService }, { token: i7.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.BackendService }, { type: i2.TranslateService }, { type: i3.Logger }, { type: i4.SystemService }, { type: i5.OidcService }, { type: i6.EventService }, { type: i7.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/user/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { BehaviorSubject, forkJoin, Observable, of } from 'rxjs';\nimport { catchError, map, switchMap, tap } from 'rxjs/operators';\nimport { UserSettings, YuvUser } from '../../model/yuv-user.model';\nimport { OidcService } from '../auth/oidc.service';\nimport { BackendService } from '../backend/backend.service';\nimport { Direction } from '../config/config.interface';\nimport { ConfigService } from '../config/config.service';\nimport { EventService } from '../event/event.service';\nimport { YuvEventType } from '../event/events';\nimport { Logger } from '../logger/logger';\nimport { AdministrationRoles } from '../system/system.enum';\nimport { UserPermissions, UserPermissionsSection } from '../system/system.interface';\nimport { SystemService } from '../system/system.service';\nimport { StoredObjectConfig } from '../object-config/object-config.interface';\n\n/**\n * Service providing user account configurations.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class UserService {\n  // #GLOBAL_SETTINGS = '/users/globalsettings/';\n  #USERS_SETTINGS = '/users/settings/';\n  #DEFAULT_SETTINGS = '/users/settings';\n\n  #SETTINGS_SECTION_OBJECTCONFIG = 'object-config';\n\n  #user?: YuvUser;\n  #userSource = new BehaviorSubject<YuvUser | undefined>(this.#user);\n  user$: Observable<YuvUser | undefined> = this.#userSource.asObservable();\n\n  globalSettings = new Map();\n  userPermissions?: UserPermissions;\n\n  /**\n   * @ignore\n   */\n  constructor(\n    private backend: BackendService,\n    private translate: TranslateService,\n    private logger: Logger,\n    private system: SystemService,\n    private oidc: OidcService,\n    private eventService: EventService,\n    private config: ConfigService\n  ) {}\n\n  private getUiDirection(iso: string): string {\n    // languages that are read right to left\n    const rtlLanguages = ['ar', 'arc', 'dv', 'fa', 'ha', 'he', 'khw', 'ks', 'ku', 'ps', 'ur', 'yi'];\n    return rtlLanguages.indexOf(iso) === -1 ? Direction.LTR : Direction.RTL;\n  }\n\n  /**\n   * Set a new current user\n   * @param user The user to be set as current user\n   */\n  public setCurrentUser(user: YuvUser) {\n    this.#user = user;\n    this.changeClientLocale('', false);\n    this.#userSource.next(this.#user);\n  }\n\n  getCurrentUser(): YuvUser {\n    return this.#user!;\n  }\n\n  get hasAdminRole(): boolean {\n    return this.#user?.authorities?.includes(AdministrationRoles.ADMIN) || false;\n  }\n\n  get hasSystemRole(): boolean {\n    return this.#user?.authorities?.includes(AdministrationRoles.SYSTEM) || false;\n  }\n\n  get hasAdministrationRoles(): boolean {\n    return this.hasAdminRole || this.hasSystemRole;\n  }\n\n  get hasManageSettingsRole(): boolean {\n    const customRole = this.config.get('core.permissions.manageSettingsRole');\n    const manageSettingsRole = customRole || AdministrationRoles.MANAGE_SETTINGS;\n    return this.#user?.authorities?.includes(manageSettingsRole) || false;\n  }\n\n  get isAdvancedUser(): boolean {\n    const customRole = this.config.get('core.permissions.advancedUserRole');\n    const advancedUserRole = customRole || AdministrationRoles.MANAGE_SETTINGS;\n    return this.#user?.authorities?.includes(advancedUserRole) || false;\n  }\n\n  get isRetentionManager(): boolean {\n    const customRole = this.config.get('core.permissions.retentionManagerRole');\n    const retenetionManagerRole = customRole || AdministrationRoles.MANAGE_SETTINGS;\n    return this.#user?.authorities?.includes(retenetionManagerRole) || false;\n  }\n\n  canCreateObjects = false;\n\n  /**\n   * Change the users client locale\n   * @param iso ISO locale string to be set as new client locale\n   */\n  changeClientLocale(iso: string, persist = true): void {\n    if (this.#user) {\n      const languages = this.config.getClientLocales().map((lang) => lang.iso);\n      iso = iso || this.#user.getClientLocale(this.config.getDefaultClientLocale());\n      if (!languages.includes(iso)) {\n        iso = this.config.getDefaultClientLocale();\n      }\n      this.logger.debug(\"Changed client locale to '\" + iso + \"'\");\n      this.backend.setHeader('Accept-Language', iso);\n      this.#user.uiDirection = this.getUiDirection(iso);\n      this.#user.userSettings.locale = iso;\n      if (this.translate.currentLang !== iso || this.system.authData?.language !== iso) {\n        const ob = persist\n          ? forkJoin([\n              this.translate.use(iso),\n              this.system.updateLocalizations(iso),\n              this.saveUserSettings(this.#user.userSettings).pipe(\n                tap(() => {\n                  // this.#userSource.next(this.#user);\n                  this.logger.debug('Loading system definitions i18n resources for new locale.');\n                })\n              )\n            ])\n          : this.translate.use(iso);\n        ob.subscribe(() => this.eventService.trigger(YuvEventType.CLIENT_LOCALE_CHANGED, iso));\n      }\n    }\n  }\n\n  saveUserSettings(settings: Partial<UserSettings>): Observable<any> {\n    if (this.#user) {\n      console.log(this.#user.userSettings);\n\n      this.#user.userSettings = { ...this.#user.userSettings, ...settings };\n      return this.backend.post(this.#DEFAULT_SETTINGS, this.#user.userSettings).pipe(tap(() => this.#userSource.next(this.#user)));\n    } else return of(null);\n  }\n\n  fetchUserSettings(): Observable<UserSettings> {\n    return this.backend.get('/dms/permissions').pipe(\n      catchError((e) => of(undefined)),\n      switchMap((res) => {\n        this.setUserPermissions(res);\n        return this.backend.get(this.#DEFAULT_SETTINGS);\n      })\n    );\n  }\n\n  private setUserPermissions(res: any): void {\n    this.userPermissions = {\n      create: this.mapPermissions('CREATE', res),\n      write: this.mapPermissions('WRITE', res),\n      read: this.mapPermissions('READ', res),\n      delete: this.mapPermissions('DELETE', res)\n    };\n    const sp = {\n      createableObjectTypes: [\n        ...this.userPermissions.create.folderTypes,\n        ...this.userPermissions.create.objectTypes,\n        ...this.userPermissions.create.secondaryObjectTypes\n      ],\n      searchableObjectTypes: [\n        ...this.userPermissions.read.folderTypes,\n        ...this.userPermissions.read.objectTypes,\n        ...this.userPermissions.read.secondaryObjectTypes\n      ]\n    };\n    this.system.setPermissions(sp);\n    this.canCreateObjects = sp.createableObjectTypes.length > 0;\n  }\n\n  private mapPermissions(section: 'CREATE' | 'READ' | 'WRITE' | 'DELETE', apiResponse: any): UserPermissionsSection {\n    const res = apiResponse[section] || {};\n    return {\n      folderTypes: res['folderTypeIds'] || [],\n      objectTypes: res['objectTypeIds'] || [],\n      secondaryObjectTypes: res['secondaryObjectTypeIds'] || []\n    };\n  }\n\n  /**\n   * Search for a user based on a search term\n   * @param term Search term\n   * @param excludeMe whether or not to exclude myself from the result list\n   * @param roles narrow down the search results by certain roles\n   */\n  queryUser(term: string, excludeMe?: boolean, roles?: string[]): Observable<YuvUser[]> {\n    let params = new HttpParams().set('search', term).set('excludeMe', `${!!excludeMe}`);\n    roles?.length && roles.map((r) => (params = params.append(`roles`, r)));\n    return this.backend.get(`/idm/users?${params}`).pipe(map((users) => (!users ? [] : users.map((u: any) => new YuvUser(u)))));\n  }\n\n  getUserById(id: string): Observable<YuvUser> {\n    return this.backend.get(`/idm/users/${id}`).pipe(map((user) => new YuvUser(user, this.#user!.userSettings)));\n  }\n\n  logout(redirRoute?: string): void {\n    if (this.backend.authUsesOpenIdConnect()) {\n      this.oidc.logout();\n    } else {\n      const redir = redirRoute ? `?redir=${redirRoute}` : '';\n      (window as any).location.href = `${this.backend.getApiBase('logout')}${redir}`;\n    }\n  }\n\n  getSettings(section: string): Observable<any> {\n    return this.#user ? this.backend.get(this.#USERS_SETTINGS + encodeURIComponent(section)) : of(null);\n  }\n\n  saveObjectConfig(objectConfigs: StoredObjectConfig): Observable<any> {\n    return this.backend.post(this.#USERS_SETTINGS + encodeURIComponent(this.#SETTINGS_SECTION_OBJECTCONFIG), objectConfigs);\n  }\n\n  loadObjectConfig(): Observable<StoredObjectConfig | undefined> {\n    return this.getSettings(this.#SETTINGS_SECTION_OBJECTCONFIG).pipe(\n      catchError(() => of(undefined)),\n    );\n  }\n}\n"]}

package/esm2022/lib/util/utils.helper.enum.mjs

@@ -0,0 +1,15 @@
+export var Sort;
+(function (Sort) {
+    Sort["ASC"] = "asc";
+    Sort["DESC"] = "desc";
+})(Sort || (Sort = {}));
+export var ClassificationPrefix;
+(function (ClassificationPrefix) {
+    ClassificationPrefix["EMAIL"] = "mailto:";
+    ClassificationPrefix["EMAIL_ICON"] = "envelope";
+    ClassificationPrefix["PHONE"] = "tel:";
+    ClassificationPrefix["PHONE_ICON"] = "phone";
+    ClassificationPrefix["URL"] = "";
+    ClassificationPrefix["URL_ICON"] = "globe";
+})(ClassificationPrefix || (ClassificationPrefix = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuaGVscGVyLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtY29yZS9zcmMvbGliL3V0aWwvdXRpbHMuaGVscGVyLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksSUFHWDtBQUhELFdBQVksSUFBSTtJQUNkLG1CQUFXLENBQUE7SUFDWCxxQkFBYSxDQUFBO0FBQ2YsQ0FBQyxFQUhXLElBQUksS0FBSixJQUFJLFFBR2Y7QUFFRCxNQUFNLENBQU4sSUFBWSxvQkFPWDtBQVBELFdBQVksb0JBQW9CO0lBQzlCLHlDQUFpQixDQUFBO0lBQ2pCLCtDQUF1QixDQUFBO0lBQ3ZCLHNDQUFjLENBQUE7SUFDZCw0Q0FBb0IsQ0FBQTtJQUNwQixnQ0FBUSxDQUFBO0lBQ1IsMENBQWtCLENBQUE7QUFDcEIsQ0FBQyxFQVBXLG9CQUFvQixLQUFwQixvQkFBb0IsUUFPL0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBTb3J0IHtcbiAgQVNDID0gJ2FzYycsXG4gIERFU0MgPSAnZGVzYydcbn1cblxuZXhwb3J0IGVudW0gQ2xhc3NpZmljYXRpb25QcmVmaXgge1xuICBFTUFJTCA9ICdtYWlsdG86JyxcbiAgRU1BSUxfSUNPTiA9ICdlbnZlbG9wZScsXG4gIFBIT05FID0gJ3RlbDonLFxuICBQSE9ORV9JQ09OID0gJ3Bob25lJyxcbiAgVVJMID0gJycsXG4gIFVSTF9JQ09OID0gJ2dsb2JlJ1xufVxuXG5leHBvcnQgdHlwZSBGb3JtYXR0ZWRNYWlsVG8gPSBzdHJpbmcgfCBzdHJpbmdbXTtcbiJdfQ==