@yuuvis/client-core 0.6.5

package/esm2022/lib/service/dms/dms.service.mjs

@@ -0,0 +1,440 @@
+import { inject, Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { delay, map, switchMap, tap } from 'rxjs/operators';
+import { DmsObject } from '../../model/dms-object.model';
+import { Utils } from '../../util/utils';
+import { ApiBase } from '../backend/api.enum';
+import { BackendService } from '../backend/backend.service';
+import { EventService } from '../event/event.service';
+import { YuvEventType } from '../event/events';
+import { SearchService } from '../search/search.service';
+import { BaseObjectTypeField, ContentStreamField, SystemResult } from '../system/system.enum';
+import { UploadService } from '../upload/upload.service';
+import { Sort } from '../../util/utils.helper.enum';
+import * as i0 from "@angular/core";
+/**
+ * Service for working with dms objects: create them, delete, etc.
+ */
+export class DmsService {
+    #searchService = inject(SearchService);
+    #backend = inject(BackendService);
+    #eventService = inject(EventService);
+    #uploadService = inject(UploadService);
+    // general trigger operator to handle all dms events
+    triggerEvent(event, id, silent = false) {
+        return (stream) => stream.pipe(
+        // update does not return permissions, so we need to re-load the whole dms object
+        // TODO: Remove once permissions are provided
+        switchMap((res) => (!id ? of(res) : this.getDmsObject(id))), 
+        // TODO: enable once permissions are provided
+        // map((res) => this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0])),
+        tap((res) => !silent && this.#eventService.trigger(event, res)));
+    }
+    // general trigger operator to handle all dms events
+    #triggerEvents(event, ids, silent = false) {
+        return (stream) => stream.pipe(
+        // update does not return permissions, so we need to re-load the whole dms object
+        // TODO: Remove once permissions are provided
+        switchMap((res) => (!ids ? of(res) : this.getDmsObjects(ids))), 
+        // TODO: enable once permissions are provided
+        // map((_res: any[]) => _res.map((res, i) => res?._error ? { ...res, id: ids?[i] } : this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0]))),
+        map((_res) => _res.map((res, i) => (res?._error && ids ? { ...res, id: ids[i] } : res))), tap((res) => !silent && res.forEach((o) => o && this.#eventService.trigger(event, o))));
+    }
+    /**
+     * Create new dms object(s). Providing an array of files here instead of one will create
+     * a new dms object for every file. In this case indexdata will shared across all files.
+     * @param objectTypeId The ID of the object type to be created
+     * @param indexdata Indexdata for the new object(s)
+     * @param files File(s) to create dms objects content(s) with
+     * @param label A label that will show up in the upload overlay dialog while uploading
+     *
+     * @returns Array of IDs of the objects that have been created
+     */
+    createDmsObject(objectTypeId, indexdata, files, label, silent = false) {
+        const url = `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects`;
+        const data = indexdata;
+        data[BaseObjectTypeField.OBJECT_TYPE_ID] = objectTypeId;
+        const upload = files.length ? this.#uploadService.uploadMultipart(url, files, data, label, silent) : this.#uploadService.createDocument(url, data);
+        return upload
+            .pipe(map((res) => res.map((r) => r.properties[BaseObjectTypeField.OBJECT_ID].value)), 
+        // TODO: Replace by proper solution
+        // Right now there is a gap between when the object was
+        // created and when it is indexed. So delaying here will
+        // give backend time to get its stuff together.
+        delay(1000))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_CREATED, '', silent));
+    }
+    /**
+     * Delete a dms object.
+     * @param id ID of the object to be deleted
+     */
+    deleteDmsObject(id, silent = false) {
+        const url = `/dms/objects/${id}`;
+        return this.#backend
+            .delete(url, ApiBase.apiWeb)
+            .pipe(map(() => ({ id })))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_DELETED, '', silent));
+    }
+    /**
+     * Restore older version of a dms object.
+     * @param id ID of the object to be restored
+     * @param version version of the object to be restored
+     */
+    restoreDmsObject(id, version, silent = false) {
+        const url = `/dms/objects/${id}/versions/${version}/actions/restore?waitForSearchConsistency=true&restoreParentId=false`;
+        return this.#backend.post(url, {}, ApiBase.apiWeb).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Upload (add/replace) content to a dms object.
+     * @param objectId ID of the dms object to upload the file to
+     * @param file The file to be uploaded
+     */
+    uploadContent(objectId, file) {
+        return this.#uploadService.upload(this.getContentPath(objectId), file).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, objectId));
+    }
+    /**
+     * Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     */
+    getContentPath(objectId, version) {
+        return `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects/${objectId}/contents/file${version ? '?version=' + version : ''}`;
+    }
+    /**
+     * Original API Path of dms object content file.
+     * @param objectId ID of the dms object
+     * @param version version number of the dms object
+     * @param rendition should return rendition path of the dms object
+     */
+    getFullContentPath(objectId, version, rendition = false) {
+        return `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}${version ? '/versions/' + version : ''}/contents/${rendition ? 'renditions/pdf' : 'file'}`;
+    }
+    getSlideURI(objectId, mimeType) {
+        const supportedMimeTypes = ['*/*'];
+        let supported = false;
+        if (mimeType) {
+            // check if mime type supports slides
+            supportedMimeTypes.forEach((p) => (supported = supported || Utils.patternToRegExp(p).test(mimeType)));
+        }
+        return !mimeType || supported ? `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}/contents/renditions/slide` : undefined;
+    }
+    /**
+     * Downloads the content of dms objects.
+     *
+     * @param DmsObject[] dmsObjects Array of dms objects to be downloaded
+     * @param withVersion should download specific version of the object
+     */
+    downloadContent(objects, withVersion) {
+        objects.forEach((object, i) => setTimeout(() => {
+            const uri = `${this.getContentPath(object?.id, withVersion ? object?.version : undefined)}`;
+            this.#backend.download(uri);
+        }, Utils.isSafari() ? i * 1000 : 0 // Safari does not allow multi download
+        ));
+    }
+    /**
+     * Fetch a dms object.
+     * @param id ID of the object to be retrieved
+     * @param version Desired version of the object
+     */
+    getDmsObject(id, version, silent = false, requestOptions) {
+        return this.#backend
+            .get(`/dms/objects/${id}${version ? '/versions/' + version : ''}`, undefined, requestOptions)
+            .pipe(map((res) => {
+            const item = this.#searchService.toSearchResult(res).items[0];
+            return this.#searchResultToDmsObject(item);
+        }))
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_LOADED, '', silent));
+    }
+    /**
+     * Updates a tag on a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    setDmsObjectTag(id, tag, value, silent = false) {
+        return this.#backend
+            .post(`/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`, {}, ApiBase.core)
+            .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Deletes a tag from a dms object.
+     * @param id The ID of the object
+     * @param tag The tag to be deleted
+     */
+    deleteDmsObjectTag(id, tag, silent = false) {
+        return this.#backend.delete(`/dms/objects/${id}/tags/${tag}`, ApiBase.core).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Update indexdata of a dms object.
+     * @param id ID of the object to apply the data to
+     * @param data Indexdata to be applied
+     * @param silent flag to trigger DMS_OBJECT_UPDATED event
+     */
+    updateDmsObject(id, data, silent = false) {
+        return this.#backend.patch(`/dms/objects/${id}`, data).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));
+    }
+    /**
+     * Updates given objects.
+     * @param objects the objects to updated
+     */
+    updateDmsObjects(objects, silent = false) {
+        return this.#backend
+            .patch(`/dms/objects`, {
+            patches: objects.map((o) => ({
+                id: o.id,
+                data: o.data
+            }))
+        })
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_UPDATED, objects.map((o) => o.id), silent));
+    }
+    /**
+     * Updates a tag on a dms object.
+     * @param ids List of IDs of objects
+     * @param tag The tag to be updated
+     * @param value The tags new value
+     */
+    updateDmsObjectsTag(ids, tag, value, silent = false) {
+        return this.batchUpdateTag(ids, tag, value).pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_UPDATED, ids, silent));
+    }
+    /**
+     * Moves given objects to a different folder.
+     * @param folderId the id of the new parent folder
+     * @param objects objects to be moved
+     * @param options options for the move operation
+     */
+    moveDmsObjects(targetFolderId, objects, options) {
+        return this.updateDmsObjects(objects.map((o) => ({ id: o.id, data: { [BaseObjectTypeField.PARENT_ID]: targetFolderId } }), true)).pipe(tap((res) => !options?.silent && this.#eventService.trigger(YuvEventType.DMS_OBJECTS_MOVED, res)));
+    }
+    /**
+     * Copy given objects to a different folder. The objects will be copied with their indexdata referencing
+     * the existing content of the source object.
+     * @param targetFolderId The ID of the target folder
+     * @param objects The objects to be copied
+     * @param options options for the copy operation
+     */
+    copyDmsObjects(targetFolderId, objects, options) {
+        const excludeProperties = [
+            BaseObjectTypeField.OBJECT_ID,
+            BaseObjectTypeField.CREATED_BY,
+            BaseObjectTypeField.CREATION_DATE,
+            BaseObjectTypeField.MODIFIED_BY,
+            BaseObjectTypeField.MODIFICATION_DATE,
+            BaseObjectTypeField.VERSION_NUMBER,
+            BaseObjectTypeField.TRACE_ID,
+            BaseObjectTypeField.PARENT_OBJECT_TYPE_ID,
+            BaseObjectTypeField.PARENT_VERSION_NUMBER
+        ];
+        const mappedObjects = objects.map((o) => {
+            o.data[BaseObjectTypeField.PARENT_ID] = targetFolderId;
+            // Remove properties that are not allowed to be copied.
+            // This also includes content stream fields bundled into the objects data field.
+            // Properties ending with '_title' are also excluded as they are enrichment values
+            // provided by API-Web.
+            Object.keys(o.data)
+                .filter((key) => key.endsWith('_title') || excludeProperties.includes(key) || Object.values(ContentStreamField).includes(key))
+                .forEach((key) => Reflect.deleteProperty(o.data, key));
+            // map filtered data field to data format required by the Core-API
+            const properties = Object.keys(o.data).reduce((acc, key) => {
+                acc[key] = { value: o.data[key] };
+                return acc;
+            }, {});
+            return {
+                properties: properties,
+                objectTypeId: o.objectTypeId,
+                ...(o.content
+                    ? {
+                        contentStreams: [o.content]
+                    }
+                    : {})
+            };
+        });
+        const query = options
+            ? Object.keys(options)
+                .map((key) => `${key}=${options[key]}`)
+                .join('&')
+            : '';
+        return this.#backend.post(`/dms/objects?${query}}`, { objects: mappedObjects }, ApiBase.core);
+    }
+    /**
+     * Get a bunch of dms objects.
+     * @param ids List of IDs of objects to be retrieved
+     */
+    getDmsObjects(ids, silent = false) {
+        return this.batchGet(ids)
+            .pipe(map((_res) => _res.map((res, i) => (res?._error ? { ...res, id: ids[i] } : this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])))))
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_LOADED, undefined, silent));
+    }
+    /**
+     * Delete a bunch of dms objects.
+     * @param ids List of IDs of objects to be deleted
+     * @param options Options for the delete operation
+     * @returns Array of delete results.
+     */
+    deleteDmsObjects(objects, options) {
+        const queryParams = options
+            ? `?${Object.keys(options)
+                .filter((k) => ['waitForSearchConsistency', 'greedy'].includes(k))
+                .map((k) => `${k}=${options[k]}`)
+                .join('&')}`
+            : '';
+        return this.#backend
+            .delete(`/dms/objects${queryParams}`, ApiBase.core, {
+            body: {
+                objects: objects.map((o) => ({
+                    properties: typeof o === 'string'
+                        ? {
+                            'system:objectId': {
+                                value: o
+                            }
+                        }
+                        : {
+                            'system:objectId': { value: o.id },
+                            subject: { value: o.subject }
+                        }
+                }))
+            }
+        })
+            .pipe(map((res) => res?.objects?.map((r) => {
+            const v = r.options?.[SystemResult.DELETE];
+            return {
+                id: r.properties?.[BaseObjectTypeField.OBJECT_ID]?.value,
+                properties: r.properties,
+                ...(v?.httpStatusCode >= 400 ? { _error: { status: v.httpStatusCode, message: v.message } } : {})
+            };
+        })))
+            .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_DELETED, undefined, options?.silent));
+    }
+    /**
+     * Fetch a dms object versions.
+     * @param id ID of the object to be retrieved
+     */
+    getDmsObjectVersions(id) {
+        return this.#backend.get('/dms/objects/' + id + '/versions').pipe(map((res) => {
+            const items = this.#searchService.toSearchResult(res).items || [];
+            return items.map((item) => this.#searchResultToDmsObject(item));
+        }), map((res) => res.sort(Utils.sortValues('version', Sort.DESC))));
+    }
+    getDmsObjectVersion(id, version) {
+        return this.#backend
+            .get(`/dms/objects/${id}/versions/${version}`)
+            .pipe(map((res) => this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])));
+    }
+    coreApiResponseToDmsObject(res) {
+        return this.#searchResultToDmsObject({
+            objectTypeId: res.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value,
+            fields: new Map(Object.entries(res.properties)),
+            content: res.contentStreams?.[0]
+        });
+    }
+    #searchResultToDmsObject(resItem) {
+        return new DmsObject(resItem);
+    }
+    batchUpdateTag(ids, tag, value) {
+        return this.#backend.batch(ids.map((id) => ({
+            method: 'POST',
+            uri: `/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`,
+            base: ApiBase.core,
+            body: {}
+        })));
+    }
+    batchDeleteTag(ids, tag) {
+        return this.#backend.batch(ids.map((id) => ({
+            method: 'DELETE',
+            uri: `/dms/objects/${id}/tags/${tag}`,
+            base: ApiBase.core
+        })));
+    }
+    batchDelete(ids) {
+        return this.#backend.batch(ids.map((id) => ({ method: 'DELETE', uri: `/dms/objects/${id}` })));
+    }
+    batchGet(ids) {
+        return this.#backend.batch(ids.map((id) => ({ method: 'GET', uri: `/dms/objects/${id}` })));
+    }
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse) {
+        const resultListItems = [];
+        const objectTypes = [];
+        searchResponse.objects.forEach((o) => {
+            const fields = new Map();
+            // process properties section of result
+            Object.keys(o.properties).forEach((key) => {
+                let value = o.properties[key].value;
+                if (o.properties[key].clvalue) {
+                    // table fields will have a clientValue too ...
+                    value = o.properties[key].clvalue;
+                    // ... and also may contain values that need to be resolved
+                    if (o.properties[key].resolvedValues) {
+                        value.forEach((v) => {
+                            Object.keys(v).forEach((k) => {
+                                const resValue = Array.isArray(v[k]) ? v[k].map((i) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];
+                                if (resValue) {
+                                    v[`${k}_title`] = resValue;
+                                }
+                            });
+                        });
+                    }
+                }
+                fields.set(key, value);
+                if (o.properties[key].title) {
+                    fields.set(key + '_title', o.properties[key].title);
+                }
+            });
+            // process contentStreams section of result if available.
+            // Objects that don't have files attached won't have this section
+            let content;
+            if (o.contentStreams && o.contentStreams.length > 0) {
+                // we assume that each result object only has ONE file attached, altough
+                // this is an array and there may be more
+                const contentStream = o.contentStreams[0];
+                // also add contentstream related fields to the result fields
+                fields.set(ContentStreamField.LENGTH, contentStream.length);
+                fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);
+                fields.set(ContentStreamField.FILENAME, contentStream.fileName);
+                fields.set(ContentStreamField.ID, contentStream.contentStreamId);
+                fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);
+                fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);
+                fields.set(ContentStreamField.DIGEST, contentStream.digest);
+                fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);
+                content = {
+                    contentStreamId: contentStream.contentStreamId,
+                    repositoryId: contentStream.repositoryId,
+                    range: contentStream.range,
+                    digest: contentStream.digest,
+                    archivePath: contentStream.archivePath,
+                    fileName: contentStream.fileName,
+                    mimeType: contentStream.mimeType,
+                    size: contentStream.length
+                };
+            }
+            const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;
+            if (objectTypes.indexOf(objectTypeId) === -1) {
+                objectTypes.push(objectTypeId);
+            }
+            resultListItems.push({
+                objectTypeId,
+                content,
+                fields,
+                permissions: o.permissions
+            });
+        });
+        const result = {
+            hasMoreItems: searchResponse.hasMoreItems,
+            totalNumItems: searchResponse.totalNumItems,
+            items: resultListItems,
+            objectTypes
+        };
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DmsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dms.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/dms/dms.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport { catchError, delay, map, switchMap, tap } from 'rxjs/operators';\nimport { DmsObject } from '../../model/dms-object.model';\nimport { Utils } from '../../util/utils';\nimport { ApiBase } from '../backend/api.enum';\nimport { HttpOptions } from '../backend/backend.interface';\nimport { BackendService } from '../backend/backend.service';\nimport { EventService } from '../event/event.service';\nimport { YuvEventType } from '../event/events';\nimport { SearchService } from '../search/search.service';\nimport { SearchResponse, SearchResult, SearchResultContent, SearchResultItem } from '../search/search.service.interface';\nimport { BaseObjectTypeField, ContentStreamField, SystemResult } from '../system/system.enum';\nimport { SystemService } from '../system/system.service';\nimport { UploadService } from '../upload/upload.service';\nimport {\n  CoreApiObject,\n  CoreApiObjectProperty,\n  CoreApiResponse,\n  ObjectCopyOptions,\n  ObjectDeleteOptions,\n  ObjectDeleteResult,\n  ObjectMoveOptions\n} from './dms.service.interface';\nimport { Sort } from '../../util/utils.helper.enum';\n/**\n * Service for working with dms objects: create them, delete, etc.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class DmsService {\n  #searchService = inject(SearchService);\n  #backend = inject(BackendService);\n  #eventService = inject(EventService);\n  #uploadService = inject(UploadService);\n\n  // general trigger operator to handle all dms events\n  private triggerEvent(event: YuvEventType, id?: string, silent = false) {\n    return (stream: any): Observable<any> =>\n      stream.pipe(\n        // update does not return permissions, so we need to re-load the whole dms object\n        // TODO: Remove once permissions are provided\n        switchMap((res) => (!id ? of(res) : this.getDmsObject(id))),\n        // TODO: enable once permissions are provided\n        // map((res) => this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0])),\n        tap((res: any) => !silent && this.#eventService.trigger(event, res))\n      );\n  }\n\n  // general trigger operator to handle all dms events\n  #triggerEvents(event: YuvEventType, ids?: string[], silent = false) {\n    return (stream: any): Observable<any> =>\n      stream.pipe(\n        // update does not return permissions, so we need to re-load the whole dms object\n        // TODO: Remove once permissions are provided\n        switchMap((res) => (!ids ? of(res) : this.getDmsObjects(ids))),\n        // TODO: enable once permissions are provided\n        // map((_res: any[]) => _res.map((res, i) => res?._error ? { ...res, id: ids?[i] } : this.searchResultToDmsObject(this.searchService.toSearchResult(res).items[0]))),\n        map((_res: any[]) => _res.map((res, i) => (res?._error && ids ? { ...res, id: ids[i] } : res))),\n        tap((res: any) => !silent && res.forEach((o: any) => o && this.#eventService.trigger(event, o)))\n      );\n  }\n\n  /**\n   * Create new dms object(s). Providing an array of files here instead of one will create\n   * a new dms object for every file. In this case indexdata will shared across all files.\n   * @param objectTypeId The ID of the object type to be created\n   * @param indexdata Indexdata for the new object(s)\n   * @param files File(s) to create dms objects content(s) with\n   * @param label A label that will show up in the upload overlay dialog while uploading\n   *\n   * @returns Array of IDs of the objects that have been created\n   */\n  createDmsObject(objectTypeId: string, indexdata: any, files: File[], label?: string, silent = false): Observable<string[]> {\n    const url = `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects`;\n    const data = indexdata;\n    data[BaseObjectTypeField.OBJECT_TYPE_ID] = objectTypeId;\n\n    const upload = files.length ? this.#uploadService.uploadMultipart(url, files, data, label, silent) : this.#uploadService.createDocument(url, data);\n\n    return upload\n      .pipe(\n        map((res) => res.map((r: any) => r.properties[BaseObjectTypeField.OBJECT_ID].value)),\n        // TODO: Replace by proper solution\n        // Right now there is a gap between when the object was\n        // created and when it is indexed. So delaying here will\n        // give backend time to get its stuff together.\n        delay(1000)\n      )\n      .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_CREATED, '', silent));\n  }\n\n  /**\n   * Delete a dms object.\n   * @param id ID of the object to be deleted\n   */\n  deleteDmsObject(id: string, silent = false): Observable<any> {\n    const url = `/dms/objects/${id}`;\n    return this.#backend\n      .delete(url, ApiBase.apiWeb)\n      .pipe(map(() => ({ id })))\n      .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_DELETED, '', silent));\n  }\n\n  /**\n   * Restore older version of a dms object.\n   * @param id ID of the object to be restored\n   * @param version version of the object to be restored\n   */\n  restoreDmsObject(id: string, version: number, silent = false): Observable<any> {\n    const url = `/dms/objects/${id}/versions/${version}/actions/restore?waitForSearchConsistency=true&restoreParentId=false`;\n    return this.#backend.post(url, {}, ApiBase.apiWeb).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));\n  }\n\n  /**\n   * Upload (add/replace) content to a dms object.\n   * @param objectId ID of the dms object to upload the file to\n   * @param file The file to be uploaded\n   */\n  uploadContent(objectId: string, file: File): Observable<any> {\n    return this.#uploadService.upload(this.getContentPath(objectId), file).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, objectId));\n  }\n\n  /**\n   * Path of dms object content file.\n   * @param objectId ID of the dms object\n   * @param version version number of the dms object\n   */\n  getContentPath(objectId: string, version?: number) {\n    return `${this.#backend.getApiBase(ApiBase.apiWeb)}/dms/objects/${objectId}/contents/file${version ? '?version=' + version : ''}`;\n  }\n\n  /**\n   * Original API Path of dms object content file.\n   * @param objectId ID of the dms object\n   * @param version version number of the dms object\n   * @param rendition should return rendition path of the dms object\n   */\n  getFullContentPath(objectId: string, version?: number, rendition = false) {\n    return `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}${version ? '/versions/' + version : ''}/contents/${\n      rendition ? 'renditions/pdf' : 'file'\n    }`;\n  }\n\n  getSlideURI(objectId: string, mimeType?: string): string | undefined {\n    const supportedMimeTypes = ['*/*'];\n    let supported = false;\n    if (mimeType) {\n      // check if mime type supports slides\n      supportedMimeTypes.forEach((p) => (supported = supported || Utils.patternToRegExp(p).test(mimeType)));\n    }\n    return !mimeType || supported ? `${this.#backend.getApiBase(ApiBase.core, true)}/dms/objects/${objectId}/contents/renditions/slide` : undefined;\n  }\n\n  /**\n   * Downloads the content of dms objects.\n   *\n   * @param DmsObject[] dmsObjects Array of dms objects to be downloaded\n   * @param withVersion should download specific version of the object\n   */\n  downloadContent(objects: DmsObject[], withVersion?: boolean) {\n    objects.forEach((object, i) =>\n      setTimeout(\n        () => {\n          const uri = `${this.getContentPath(object?.id, withVersion ? object?.version : undefined)}`;\n          this.#backend.download(uri);\n        },\n        Utils.isSafari() ? i * 1000 : 0 // Safari does not allow multi download\n      )\n    );\n  }\n\n  /**\n   * Fetch a dms object.\n   * @param id ID of the object to be retrieved\n   * @param version Desired version of the object\n   */\n  getDmsObject(id: string, version?: number, silent = false, requestOptions?: HttpOptions | undefined): Observable<DmsObject> {\n    return this.#backend\n      .get(`/dms/objects/${id}${version ? '/versions/' + version : ''}`, undefined, requestOptions)\n      .pipe(\n        map((res) => {\n          const item: SearchResultItem = this.#searchService.toSearchResult(res).items[0];\n          return this.#searchResultToDmsObject(item);\n        })\n      )\n      .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_LOADED, '', silent));\n  }\n\n  /**\n   * Updates a tag on a dms object.\n   * @param id The ID of the object\n   * @param tag The tag to be updated\n   * @param value The tags new value\n   */\n  setDmsObjectTag(id: string, tag: string, value: any, silent = false): Observable<any> {\n    return this.#backend\n      .post(`/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`, {}, ApiBase.core)\n      .pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));\n  }\n\n  /**\n   * Deletes a tag from a dms object.\n   * @param id The ID of the object\n   * @param tag The tag to be deleted\n   */\n  deleteDmsObjectTag(id: string, tag: string, silent = false): Observable<any> {\n    return this.#backend.delete(`/dms/objects/${id}/tags/${tag}`, ApiBase.core).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));\n  }\n\n  /**\n   * Update indexdata of a dms object.\n   * @param id ID of the object to apply the data to\n   * @param data Indexdata to be applied\n   * @param silent flag to trigger DMS_OBJECT_UPDATED event\n   */\n  updateDmsObject(id: string, data: any, silent = false): Observable<DmsObject> {\n    return this.#backend.patch(`/dms/objects/${id}`, data).pipe(this.triggerEvent(YuvEventType.DMS_OBJECT_UPDATED, id, silent));\n  }\n\n  /**\n   * Updates given objects.\n   * @param objects the objects to updated\n   */\n  updateDmsObjects(objects: { id: string; data: { [key: string]: any } }[], silent = false): Observable<DmsObject[]> {\n    return this.#backend\n      .patch(`/dms/objects`, {\n        patches: objects.map((o) => ({\n          id: o.id,\n          data: o.data\n        }))\n      })\n      .pipe(\n        this.#triggerEvents(\n          YuvEventType.DMS_OBJECT_UPDATED,\n          objects.map((o) => o.id),\n          silent\n        )\n      );\n  }\n\n  /**\n   * Updates a tag on a dms object.\n   * @param ids List of IDs of objects\n   * @param tag The tag to be updated\n   * @param value The tags new value\n   */\n  updateDmsObjectsTag(ids: string[], tag: string, value: any, silent = false): Observable<any> {\n    return this.batchUpdateTag(ids, tag, value).pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_UPDATED, ids, silent));\n  }\n\n  /**\n   * Moves given objects to a different folder.\n   * @param folderId the id of the new parent folder\n   * @param objects objects to be moved\n   * @param options options for the move operation\n   */\n  moveDmsObjects(targetFolderId: string | null, objects: DmsObject[], options?: ObjectMoveOptions): Observable<any> {\n    return this.updateDmsObjects(objects.map((o) => ({ id: o.id, data: { [BaseObjectTypeField.PARENT_ID]: targetFolderId } }), true)).pipe(\n      tap((res) => !options?.silent && this.#eventService.trigger(YuvEventType.DMS_OBJECTS_MOVED, res))\n    );\n  }\n\n  /**\n   * Copy given objects to a different folder. The objects will be copied with their indexdata referencing\n   * the existing content of the source object.\n   * @param targetFolderId The ID of the target folder\n   * @param objects The objects to be copied\n   * @param options options for the copy operation\n   */\n  copyDmsObjects(targetFolderId: string | null, objects: DmsObject[], options?: ObjectCopyOptions): Observable<CoreApiResponse> {\n    const excludeProperties = [\n      BaseObjectTypeField.OBJECT_ID,\n      BaseObjectTypeField.CREATED_BY,\n      BaseObjectTypeField.CREATION_DATE,\n      BaseObjectTypeField.MODIFIED_BY,\n      BaseObjectTypeField.MODIFICATION_DATE,\n      BaseObjectTypeField.VERSION_NUMBER,\n      BaseObjectTypeField.TRACE_ID,\n      BaseObjectTypeField.PARENT_OBJECT_TYPE_ID,\n      BaseObjectTypeField.PARENT_VERSION_NUMBER\n    ];\n\n    const mappedObjects: CoreApiObject[] = objects.map((o) => {\n      o.data[BaseObjectTypeField.PARENT_ID] = targetFolderId;\n\n      // Remove properties that are not allowed to be copied.\n      // This also includes content stream fields bundled into the objects data field.\n      // Properties ending with '_title' are also excluded as they are enrichment values\n      // provided by API-Web.\n      Object.keys(o.data)\n        .filter((key) => key.endsWith('_title') || excludeProperties.includes(key) || Object.values(ContentStreamField).includes(key))\n        .forEach((key) => Reflect.deleteProperty(o.data, key));\n\n      // map filtered data field to data format required by the Core-API\n      const properties = Object.keys(o.data).reduce(\n        (acc, key) => {\n          acc[key] = { value: o.data[key] };\n          return acc;\n        },\n        {} as Record<string, CoreApiObjectProperty>\n      );\n\n      return {\n        properties: properties,\n        objectTypeId: o.objectTypeId,\n        ...(o.content\n          ? {\n              contentStreams: [o.content]\n            }\n          : {})\n      } as CoreApiObject;\n    });\n\n    const query = options\n      ? Object.keys(options)\n          .map((key: string) => `${key}=${(options as any)[key]}`)\n          .join('&')\n      : '';\n    return this.#backend.post(`/dms/objects?${query}}`, { objects: mappedObjects }, ApiBase.core);\n  }\n\n  /**\n   * Get a bunch of dms objects.\n   * @param ids List of IDs of objects to be retrieved\n   */\n  getDmsObjects(ids: string[], silent = false): Observable<DmsObject[]> {\n    return this.batchGet(ids)\n      .pipe(\n        map((_res: any[]) =>\n          _res.map((res, i) => (res?._error ? { ...res, id: ids[i] } : this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])))\n        )\n      )\n      .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_LOADED, undefined, silent));\n  }\n\n  /**\n   * Delete a bunch of dms objects.\n   * @param ids List of IDs of objects to be deleted\n   * @param options Options for the delete operation\n   * @returns Array of delete results.\n   */\n  deleteDmsObjects(\n    objects: string[] | { id: string; subject: string }[],\n\n    options?: ObjectDeleteOptions\n  ): Observable<ObjectDeleteResult[]> {\n    const queryParams = options\n      ? `?${Object.keys(options)\n          .filter((k) => ['waitForSearchConsistency', 'greedy'].includes(k))\n          .map((k) => `${k}=${(options as any)[k]}`)\n          .join('&')}`\n      : '';\n\n    return this.#backend\n      .delete(`/dms/objects${queryParams}`, ApiBase.core, {\n        body: {\n          objects: objects.map((o) => ({\n            properties:\n              typeof o === 'string'\n                ? {\n                    'system:objectId': {\n                      value: o\n                    }\n                  }\n                : {\n                    'system:objectId': { value: o.id },\n                    subject: { value: o.subject }\n                  }\n          }))\n        }\n      })\n      .pipe(\n        map((res) =>\n          res?.objects?.map((r: any) => {\n            const v = r.options?.[SystemResult.DELETE];\n            return {\n              id: r.properties?.[BaseObjectTypeField.OBJECT_ID]?.value,\n              properties: r.properties,\n              ...(v?.httpStatusCode >= 400 ? { _error: { status: v.httpStatusCode, message: v.message } } : {})\n            };\n          })\n        )\n      )\n      .pipe(this.#triggerEvents(YuvEventType.DMS_OBJECT_DELETED, undefined, options?.silent));\n  }\n\n  /**\n   * Fetch a dms object versions.\n   * @param id ID of the object to be retrieved\n   */\n  getDmsObjectVersions(id: string): Observable<DmsObject[]> {\n    return this.#backend.get('/dms/objects/' + id + '/versions').pipe(\n      map((res) => {\n        const items: SearchResultItem[] = this.#searchService.toSearchResult(res).items || [];\n        return items.map((item) => this.#searchResultToDmsObject(item));\n      }),\n      map((res) => res.sort(Utils.sortValues('version', Sort.DESC)))\n    );\n  }\n\n  getDmsObjectVersion(id: string, version: number): Observable<DmsObject> {\n    return this.#backend\n      .get(`/dms/objects/${id}/versions/${version}`)\n      .pipe(map((res) => this.#searchResultToDmsObject(this.#searchService.toSearchResult(res).items[0])));\n  }\n\n  coreApiResponseToDmsObject(res: CoreApiResponse): DmsObject {\n    return this.#searchResultToDmsObject({\n      objectTypeId: res.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value as string,\n      fields: new Map(Object.entries(res.properties)),\n      content: res.contentStreams?.[0]\n    });\n  }\n\n  #searchResultToDmsObject(resItem: SearchResultItem): DmsObject {\n    return new DmsObject(resItem);\n  }\n\n  batchUpdateTag(ids: string[], tag: string, value: any) {\n    return this.#backend.batch(\n      ids.map((id) => ({\n        method: 'POST',\n        uri: `/dms/objects/tags/${tag}/state/${value}?query=SELECT * FROM system:object WHERE system:objectId='${id}'`,\n        base: ApiBase.core,\n        body: {}\n      }))\n    );\n  }\n\n  batchDeleteTag(ids: string[], tag: string) {\n    return this.#backend.batch(\n      ids.map((id) => ({\n        method: 'DELETE',\n        uri: `/dms/objects/${id}/tags/${tag}`,\n        base: ApiBase.core\n      }))\n    );\n  }\n\n  batchDelete(ids: string[]) {\n    return this.#backend.batch(ids.map((id) => ({ method: 'DELETE', uri: `/dms/objects/${id}` })));\n  }\n\n  batchGet(ids: string[]) {\n    return this.#backend.batch(ids.map((id) => ({ method: 'GET', uri: `/dms/objects/${id}` })));\n  }\n\n  /**\n   * Map search result from the backend to applications SearchResult object\n   * @param searchResponse The backend response\n   */\n  toSearchResult(searchResponse: SearchResponse): SearchResult {\n    const resultListItems: SearchResultItem[] = [];\n    const objectTypes: string[] = [];\n\n    searchResponse.objects.forEach((o: any) => {\n      const fields = new Map();\n      // process properties section of result\n      Object.keys(o.properties).forEach((key: string) => {\n        let value = o.properties[key].value;\n        if (o.properties[key].clvalue) {\n          // table fields will have a clientValue too ...\n          value = o.properties[key].clvalue;\n          // ... and also may contain values that need to be resolved\n          if (o.properties[key].resolvedValues) {\n            value.forEach((v: any) => {\n              Object.keys(v).forEach((k) => {\n                const resValue = Array.isArray(v[k]) ? v[k].map((i: any) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];\n                if (resValue) {\n                  v[`${k}_title`] = resValue;\n                }\n              });\n            });\n          }\n        }\n\n        fields.set(key, value);\n        if (o.properties[key].title) {\n          fields.set(key + '_title', o.properties[key].title);\n        }\n      });\n\n      // process contentStreams section of result if available.\n      // Objects that don't have files attached won't have this section\n      let content: SearchResultContent | undefined;\n      if (o.contentStreams && o.contentStreams.length > 0) {\n        // we assume that each result object only has ONE file attached, altough\n        // this is an array and there may be more\n        const contentStream = o.contentStreams[0];\n        // also add contentstream related fields to the result fields\n        fields.set(ContentStreamField.LENGTH, contentStream.length);\n        fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);\n        fields.set(ContentStreamField.FILENAME, contentStream.fileName);\n        fields.set(ContentStreamField.ID, contentStream.contentStreamId);\n        fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);\n        fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);\n        fields.set(ContentStreamField.DIGEST, contentStream.digest);\n        fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);\n\n        content = {\n          contentStreamId: contentStream.contentStreamId,\n          repositoryId: contentStream.repositoryId,\n          range: contentStream.range,\n          digest: contentStream.digest,\n          archivePath: contentStream.archivePath,\n          fileName: contentStream.fileName,\n          mimeType: contentStream.mimeType,\n          size: contentStream.length\n        };\n      }\n\n      const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;\n      if (objectTypes.indexOf(objectTypeId) === -1) {\n        objectTypes.push(objectTypeId);\n      }\n\n      resultListItems.push({\n        objectTypeId,\n        content,\n        fields,\n        permissions: o.permissions\n      });\n    });\n\n    const result: SearchResult = {\n      hasMoreItems: searchResponse.hasMoreItems,\n      totalNumItems: searchResponse.totalNumItems,\n      items: resultListItems,\n      objectTypes\n    };\n    return result;\n  }\n}\n"]}

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

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

package/esm2022/lib/service/event/event.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Service for providing triggered events
+ */
+export class EventService {
+    constructor() {
+        this.#eventSource = new Subject();
+        this.event$ = this.#eventSource.asObservable();
+    }
+    #eventSource;
+    /**
+     * Trigger an global event
+     * @param type Type/key of the event
+     * @param data Data to be send along with the event
+     */
+    trigger(type, data) {
+        this.#eventSource.next({ type, data });
+    }
+    /**
+     * Listen on a triggered event
+     * @param types Type/key of the event
+     */
+    on(...types) {
+        return this.event$.pipe(filter((event) => event && !!types.find((t) => t === event.type)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/event/events.mjs

@@ -0,0 +1,14 @@
+/**
+ * Events emitted by parts of the application
+ */
+export var YuvEventType;
+(function (YuvEventType) {
+    YuvEventType["LOGOUT"] = "yuv.user.logout";
+    YuvEventType["CLIENT_LOCALE_CHANGED"] = "yuv.user.locale.client.changed";
+    YuvEventType["DMS_OBJECT_LOADED"] = "yuv.dms.object.loaded";
+    YuvEventType["DMS_OBJECT_CREATED"] = "yuv.dms.object.created";
+    YuvEventType["DMS_OBJECT_DELETED"] = "yuv.dms.object.deleted";
+    YuvEventType["DMS_OBJECT_UPDATED"] = "yuv.dms.object.updated";
+    YuvEventType["DMS_OBJECTS_MOVED"] = "yuv.dms.objects.moved";
+})(YuvEventType || (YuvEventType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy95dXV2aXMvY2xpZW50LWNvcmUvc3JjL2xpYi9zZXJ2aWNlL2V2ZW50L2V2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLFlBUVg7QUFSRCxXQUFZLFlBQVk7SUFDdEIsMENBQTBCLENBQUE7SUFDMUIsd0VBQXdELENBQUE7SUFDeEQsMkRBQTJDLENBQUE7SUFDM0MsNkRBQTZDLENBQUE7SUFDN0MsNkRBQTZDLENBQUE7SUFDN0MsNkRBQTZDLENBQUE7SUFDN0MsMkRBQTJDLENBQUE7QUFDN0MsQ0FBQyxFQVJXLFlBQVksS0FBWixZQUFZLFFBUXZCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFdmVudHMgZW1pdHRlZCBieSBwYXJ0cyBvZiB0aGUgYXBwbGljYXRpb25cbiAqL1xuZXhwb3J0IGVudW0gWXV2RXZlbnRUeXBlIHtcbiAgTE9HT1VUID0gJ3l1di51c2VyLmxvZ291dCcsXG4gIENMSUVOVF9MT0NBTEVfQ0hBTkdFRCA9ICd5dXYudXNlci5sb2NhbGUuY2xpZW50LmNoYW5nZWQnLFxuICBETVNfT0JKRUNUX0xPQURFRCA9ICd5dXYuZG1zLm9iamVjdC5sb2FkZWQnLFxuICBETVNfT0JKRUNUX0NSRUFURUQgPSAneXV2LmRtcy5vYmplY3QuY3JlYXRlZCcsXG4gIERNU19PQkpFQ1RfREVMRVRFRCA9ICd5dXYuZG1zLm9iamVjdC5kZWxldGVkJyxcbiAgRE1TX09CSkVDVF9VUERBVEVEID0gJ3l1di5kbXMub2JqZWN0LnVwZGF0ZWQnLFxuICBETVNfT0JKRUNUU19NT1ZFRCA9ICd5dXYuZG1zLm9iamVjdHMubW92ZWQnXG59XG4iXX0=

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

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