@eo-sdk/client 10.0.0-beta.4 → 10.0.0-rc.1

package/fesm2020/eo-sdk-client-projects-eo-sdk-core.mjs

@@ -1,15 +1,20 @@
-import * as i2 from '@ngx-translate/core';
+import * as i1 from '@ngx-translate/core';
 import { TranslateModule, TranslateLoader, MissingTranslationHandler } from '@ngx-translate/core';
 export { TranslateLoader, TranslateModule, TranslateService } from '@ngx-translate/core';
-import * as i0 from '@angular/core';
-import { InjectionToken, Inject, Injectable, NgModule, APP_INITIALIZER, Optional, SkipSelf } from '@angular/core';
 import * as i1$1 from '@angular/common/http';
 import { HttpErrorResponse, HttpHeaders, HttpResponse, HTTP_INTERCEPTORS, HttpClient, HttpClientModule } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { InjectionToken, Inject, Injectable, NgModule, APP_INITIALIZER, Optional, SkipSelf } from '@angular/core';
+import * as i1$3 from 'ngx-toastr';
+import { ToastrModule } from 'ngx-toastr';
 import { __decorate, __param } from 'tslib';
-import { forkJoin, of, EMPTY, throwError, Subject, Observable, ReplaySubject, BehaviorSubject, timer, interval } from 'rxjs';
-import { map, catchError, filter, debounceTime, switchMap, first, tap, finalize, shareReplay, expand, skipWhile, mergeMap, takeUntil } from 'rxjs/operators';
-import * as i6 from '@angular/common';
-import { registerLocaleData, DatePipe } from '@angular/common';
+import { EMPTY, throwError, Subject, of, forkJoin, Observable, ReplaySubject, BehaviorSubject, timer, interval } from 'rxjs';
+import { filter, map, tap, finalize, shareReplay, debounceTime, switchMap, first, catchError, expand, skipWhile, mergeMap, takeUntil } from 'rxjs/operators';
+import { DatePipe, registerLocaleData } from '@angular/common';
+import moment from 'moment';
+import * as _ from 'lodash';
+import * as FileSaver from 'file-saver';
+import * as i1$2 from '@ngx-pwa/local-storage';
 import localeDeCh from '@angular/common/locales/de-CH';
 import localeExtraDeCh from '@angular/common/locales/extra/de-CH';
 import localeDe from '@angular/common/locales/de';
@@ -70,13 +75,6 @@ import localeId from '@angular/common/locales/id';
 import localeExtraId from '@angular/common/locales/extra/id';
 import localeMs from '@angular/common/locales/ms';
 import localeExtraMs from '@angular/common/locales/extra/ms';
-import * as momentImported from 'moment';
-import momentImported__default from 'moment';
-import * as i1 from '@ngx-pwa/local-storage';
-import * as FileSaver from 'file-saver';
-import * as _ from 'lodash';
-import * as i1$2 from 'ngx-toastr';
-import { ToastrModule } from 'ngx-toastr';
 
 // @see: http://stackoverflow.com/questions/37611549/how-to-pass-parameters-rendered-from-backend-to-angular2-bootstrap-method#answer-40379803
 /**
@@ -104,92 +102,6 @@ CoreConfig = __decorate([
     __param(0, Inject(CUSTOM_CONFIG))
 ], CoreConfig);
 
-/**
- * @ignore
- * APP_INITIALIZER function
- */
-function init_module(coreInit) {
-    // Need to set to a const before returning due to:
-    // @see: https://github.com/angular/angular/issues/14485
-    const fnc = () => coreInit.initialize();
-    return fnc;
-}
-
-/**
- * @ignore
- * Handles missing translations
- */
-class EoxMissingTranslationHandler {
-    /**
-     *
-     * @param MissingTranslationHandlerParams params
-     * @returns string
-     */
-    handle(params) {
-        return '!missing key: ' + params.key;
-    }
-}
-
-/**
- * @ignore
- * Loader that fetches translations based on the configured locations
- */
-let EoxTranslateJsonLoader = class EoxTranslateJsonLoader {
-    constructor(http, config) {
-        this.http = http;
-        this.config = config;
-        registerLocaleData(localeDe, 'de', localeExtraDe); // German
-        registerLocaleData(localeAr, 'ar', localeExtraAr); // Arabic
-        registerLocaleData(localeEs, 'es', localeExtraEs); // Spanish
-        registerLocaleData(localePt, 'pt', localeExtraPt); // Portuguese
-        registerLocaleData(localeFr, 'fr', localeExtraFr); // French
-        registerLocaleData(localeZh, 'zh', localeExtraZh); // Chinese
-        registerLocaleData(localeLv, 'lv', localeExtraLv); // Latvian
-        registerLocaleData(localeRu, 'ru', localeExtraRu); // Russian
-        registerLocaleData(localeIt, 'it', localeExtraIt); // Italian
-        registerLocaleData(localeNl, 'nl', localeExtraNl); // Dutch
-        registerLocaleData(localeSk, 'sk', localeExtraSk); // Slovak
-        registerLocaleData(localePl, 'pl', localeExtraPl); // Polish
-        registerLocaleData(localeUk, 'uk', localeExtraUk); // Ukrainian
-        registerLocaleData(localeJa, 'ja', localeExtraJa); // Japanese
-        registerLocaleData(localeKo, 'ko', localeExtraKo); // Korean
-        registerLocaleData(localeHi, 'hi', localeExtraHi); // Hindi
-        registerLocaleData(localeBn, 'bn', localeExtraBn); // Bengalese
-        registerLocaleData(localeDeCh, 'de-CH', localeExtraDeCh); // German (switzerland)
-        registerLocaleData(localeZhHant, 'zh-Hant', localeExtraZhHant); // Chinese (traditional)
-        registerLocaleData(localeTh, 'th', localeExtraTh); // Thai
-        registerLocaleData(localeVi, 'vi', localeExtraVi); // Vietnamese
-        registerLocaleData(localeEnGb, 'en-GB', localeExtraEnGb); // English (Great-Britain)
-        registerLocaleData(localeHe, 'he', localeExtraHe); // Hebrew
-        registerLocaleData(localeFi, 'fi', localeExtraFi); // Finish
-        registerLocaleData(localeDa, 'da', localeExtraDa); // Danish
-        registerLocaleData(localeSe, 'se', localeExtraSe); // Swedish
-        registerLocaleData(localeNb, 'nb', localeExtraNb); // Norwegian Bokmål
-        registerLocaleData(localeNn, 'nn', localeExtraNn); // Norwegian Nynorsk
-        registerLocaleData(localeId, 'id', localeExtraId); // Indonesian
-        registerLocaleData(localeMs, 'ms', localeExtraMs); // Malay
-    }
-    /**
-     *
-     * @param string lang
-     * @returns Observable<Object>
-     */
-    getTranslation(lang) {
-        return forkJoin(this.config.translations.map(folder => this.loadTranslationFile(folder, lang))).pipe(map((res) => res.reduce((acc, x) => Object.assign(acc, x), {})));
-    }
-    loadTranslationFile(folder, lang) {
-        return this.http.get(`${folder}${lang}.json`).pipe(catchError((e) => {
-            // ISO codes with more than 2 characters are sub-languages like de-CH.
-            // If there is no translation file for that sub-language we'll try to load
-            // the file for the base language (in this case de).
-            return lang.length > 2 ? this.loadTranslationFile(folder, lang.substring(0, 2)) : of({});
-        }));
-    }
-};
-EoxTranslateJsonLoader = __decorate([
-    __param(1, Inject(CORE_CONFIG))
-], EoxTranslateJsonLoader);
-
 /**
  * Set up the default logger.
  * The default logger doesn't actually log anything;
@@ -1083,7 +995,7 @@ class Utils {
      * @returns
      */
     static getTimezoneOffset() {
-        return momentImported__default().format('Z');
+        return moment().format('Z');
     }
     static formatMailTo(value, isEmail) {
         if (isEmail && !!value) {
@@ -1311,14 +1223,26 @@ class Config {
         return this.cfg['agent'];
     }
 }
-Config.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Config, deps: [{ token: i2.TranslateService }, { token: EventService }], target: i0.ɵɵFactoryTarget.Injectable });
+Config.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Config, deps: [{ token: i1.TranslateService }, { token: EventService }], target: i0.ɵɵFactoryTarget.Injectable });
 Config.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Config, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Config, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i2.TranslateService }, { type: EventService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: EventService }]; } });
+
+class EnvironmentEnaio {
+    static isWebEnvironment() {
+        return !EnvironmentEnaio.isDesktopEnvironment() && !EnvironmentEnaio.isMobileEnvironment();
+    }
+    static isMobileEnvironment() {
+        return window.hasOwnProperty('cordova');
+    }
+    static isDesktopEnvironment() {
+        return window.hasOwnProperty('process') && window['process'].versions.hasOwnProperty('electron');
+    }
+}
 
 class EoUser {
     /**
@@ -1406,124 +1330,6 @@ class EoUser {
     }
 }
 
-class EnvironmentEnaio {
-    static isWebEnvironment() {
-        return !EnvironmentEnaio.isDesktopEnvironment() && !EnvironmentEnaio.isMobileEnvironment();
-    }
-    static isMobileEnvironment() {
-        return window.hasOwnProperty('cordova');
-    }
-    static isDesktopEnvironment() {
-        return window.hasOwnProperty('process') && window['process'].versions.hasOwnProperty('electron');
-    }
-}
-
-/**
- * The apps central caching service. It will provide the app with an easy to use cache that
- * is aware of the platform it is running on. So it abstracts the platform-specific implementations
- * of a cache from the application.
- */
-class AppCacheService {
-    constructor(storage, storageMap) {
-        this.storage = storage;
-        this.storageMap = storageMap;
-        /**
-         * Key for storing system definition
-         */
-        this.SYSTEM_DEFINITION = 'eo.framework.cache.systemdefinition';
-        /**
-         * Key for storing system definition
-         */
-        this.HOSTS = 'eo.framework.cache.hosts';
-        /**
-         * Key for storing location history
-         */
-        this.LOCATION_HISTORY = 'eo.framework.cache.locations.history';
-        this.itemsMap = new Map();
-        // IndexedDB issue after update - refresh function (transform all wrapped items)
-        window['_ngStorageRefresh'] = () => this.getStorage().subscribe(storage => this.setStorage(storage).subscribe() && console.log(storage));
-    }
-    /**
-     * Writes an item to the storage.
-     * @param key The item's key
-     * @param value The value to be stored
-     * @param debounce The debounce time (default: 500) to reduce identical storage calls
-     * @returns Resolves true if setting the item succeeded, false otherwise
-     */
-    setItem(key, value, debounce = 500) {
-        if (!debounce) {
-            return this.storage.setItem(key, value);
-        }
-        else {
-            if (!this.itemsMap.has(key)) {
-                const subject = new Subject();
-                subject.pipe(debounceTime(debounce), switchMap(val => this.storage.setItem(key, val))).subscribe();
-                this.itemsMap.set(key, subject);
-            }
-            this.itemsMap.get(key).next(value);
-            return of(true);
-        }
-    }
-    /**
-     * Get a stored item by its key.
-     * @param key The item's key
-     * @returns The item's value if the key exists, null otherwise
-     */
-    getItem(key) {
-        return this.storage.getItem(key)
-            .pipe(map((item) => {
-            // IndexedDB issue after update (transform wrapped items)
-            return Object.keys(item || {}).join() === 'value' ? item.value : item;
-        }));
-    }
-    /**
-     * Removes an item from the storage.
-     * @param key The item's key
-     * @returns Resolves true if removing the item succeeded, false otherwise
-     */
-    removeItem(key) {
-        return this.storage.removeItem(key);
-    }
-    /**
-     * Deletes all items from local storage
-     * @param filter optional - Delete all keys that pass through filter
-     * @returns Resolves true if clearing all items succeeded, false otherwise
-     */
-    clear(filter) {
-        return filter
-            ? this.getStorageKeys().pipe(switchMap((keys) => {
-                const list = keys.filter((k) => filter(k)).map((k) => this.removeItem(k));
-                return list.length ? forkJoin(list).pipe(map(() => true)) : of(true);
-            }))
-            : this.storage.clear();
-    }
-    getStorageKeys() {
-        return new Observable((observer) => {
-            const keys = [];
-            this.storageMap.keys().subscribe({
-                next: (key) => keys.push(key),
-                complete: () => observer.next(keys)
-            });
-        }).pipe(first());
-    }
-    getStorage() {
-        return this.getStorageKeys().pipe(switchMap((keys) => keys.length
-            ? forkJoin(Utils.arrayToObject(keys, (o) => o, (k) => this.getItem(k)))
-            : of({})));
-    }
-    setStorage(options) {
-        return forkJoin(Object.keys(options || {}).map((k) => this.setItem(k, options[k])));
-    }
-}
-AppCacheService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, deps: [{ token: i1.LocalStorage }, { token: i1.StorageMap }], target: i0.ɵɵFactoryTarget.Injectable });
-AppCacheService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.LocalStorage }, { type: i1.StorageMap }]; } });
-
 /**
  * Wrapper for Cloud Services through Auth Service
  */
@@ -1681,60 +1487,43 @@ var ClipboardAction;
 })(ClipboardAction || (ClipboardAction = {}));
 
 /**
- * Handles the systems capabilities. Capabilities are settings that enable/disable certain client features.
+ * Representation of an object type. Object types are defined with the system definition and describe
+ * different kind of objects that allowed to be created.
  */
-class CapabilitiesService {
+class ObjectType {
     /**
-     * @ignore
+     * Creates a new instance
+     * @param json The JSON object received from the backend. This will be used to construct the new object type instance
      */
-    constructor() {
+    constructor(json) {
+        this.id = json.id;
+        this.implements = json.implements ? json.implements : [];
+        this.isFolder = json.folder;
+        this.isContextFolder = json.iscontextfolder;
+        this.isAbstract = json.abstract;
+        this.iconId = json.icon ? json.icon.id : null;
+        this.maxFiles = json.maxfiles;
+        this.minFiles = json.minfiles;
+        this.name = json.name;
+        this.qname = json.qname;
+        this.label = json.label;
+        this.description = json.description;
+        this.group = json.group ? json.group.label : "";
+        this.elements = json.elements;
+        this.allowedcontexttypes = json.allowedcontexttypes
+            ? json.allowedcontexttypes
+            : [];
+        this.supertypes = json.supertypes ? json.supertypes.map(t => t.name) : [];
+        this.shareable = json.shareable;
+        this.parenttypes = this.getParentTypes(json.allowedlocations);
     }
-    /**
-     * Sets the capabilities based on a given object set by auth.service
-     *
-     * @param userCapabilities Object containing capabilities properties
-     * @param useSingleSingOn Whether or not to set up single signon on capability
-     * @returns The newly created capabilities object
-     */
-    setCapabilities(userCapabilities, useSingleSingOn) {
-        this.capabilities = {
-            bpm: userCapabilities.bpm,
-            favorites: userCapabilities.favorites,
-            followup: userCapabilities.followup,
-            subscription: userCapabilities.subscription,
-            intray: userCapabilities.intray,
-            storedqueries: userCapabilities.storedqueries,
-            recyclebin: userCapabilities.recyclebin,
-            inbox: userCapabilities.bpm || userCapabilities.followup || userCapabilities.subscription,
-            notifications: userCapabilities.followup || userCapabilities.subscription,
-            template: userCapabilities.template,
-            sso: useSingleSingOn || false
-        };
-        return this.capabilities;
-    }
-    /**
-     * Getter for the Capabilities
-     */
-    getCapabilities() {
-        return this.capabilities;
-    }
-    /**
-     * Check if Capability is present
-     * @param capability Capability to check for
-     * @returns True if the capability is set, false otherwise
-     */
-    hasCapability(capability) {
-        return this.capabilities[capability];
+    getParentTypes(allowedlocations) {
+        if (allowedlocations) {
+            return allowedlocations.parenttypes.map(types => types.name);
+        }
+        return [];
     }
 }
-CapabilitiesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CapabilitiesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return []; } });
 
 // @ts-ignore
 /**
@@ -2083,887 +1872,1003 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
                 }] }, { type: Logger }, { type: Config }]; } });
 
 /**
- * @ignore
- */
-const moment$1 = momentImported;
-/**
- * Items emitted by the inbox service
- */
-class InboxItem {
-    /**
-     * Creates a new instance
-     * @param json The JSON object received from the backend. This will be used to construct the new inbox item instance
-     */
-    constructor(json) {
-        // todo: jsut use Object assign when backend changes are done
-        // Object.assign(this, json);
-        this.id = json.inboxentryid;
-        this.title = json.title;
-        this.description = json.description;
-        this.type = json.type;
-        this.sourceId = json.source ? json.source.id : null;
-        this.iconId = json.target && json.target.icon ? json.target.icon.id : null;
-        this.accepted = json.accepted;
-        this.isdeputy = json.isdeputy;
-        this.duetime = json.duetime;
-        this.received = json.receivetime;
-        this.target = json.target;
-    }
-    /**
-     * Determines whether or not the inbox item is overdue
-     * @returns True when inbox item is overdue, false otherwise
-     */
-    isOverdue() {
-        return this.duetime && moment$1(this.duetime).isBefore(moment$1());
-    }
-}
-InboxItem.TYPE_BPM = 'BPM';
-InboxItem.TYPE_RESUBMISSION = 'RESUBMISSION';
-InboxItem.TYPE_SUBSCRIPTION = 'SUBSCRIPTION';
-
-/**
- * InboxService handles interaction with the inbox service on the backend side.
+ * The apps central caching service. It will provide the app with an easy to use cache that
+ * is aware of the platform it is running on. So it abstracts the platform-specific implementations
+ * of a cache from the application.
  */
-class InboxService {
-    constructor(backend) {
-        this.backend = backend;
-        // backends maximum page size
-        this.MAX_PAGE_SIZE = 1000;
-        this.inboxStateSource = new ReplaySubject(1);
-        this.inboxState$ = this.inboxStateSource.asObservable();
-        this.inboxItemsSource = new ReplaySubject(1);
-        this.inboxItemsGridData$ = this.inboxItemsSource.asObservable();
-        this.inboxItems$ = this.inboxItemsGridData$.pipe(this.backend.gridDataFilter);
+class AppCacheService {
+    constructor(storage, storageMap) {
+        this.storage = storage;
+        this.storageMap = storageMap;
+        /**
+         * Key for storing system definition
+         */
+        this.SYSTEM_DEFINITION = 'eo.framework.cache.systemdefinition';
+        /**
+         * Key for storing system definition
+         */
+        this.HOSTS = 'eo.framework.cache.hosts';
+        /**
+         * Key for storing location history
+         */
+        this.LOCATION_HISTORY = 'eo.framework.cache.locations.history';
+        this.itemsMap = new Map();
+        // IndexedDB issue after update - refresh function (transform all wrapped items)
+        window['_ngStorageRefresh'] = () => this.getStorage().subscribe(storage => this.setStorage(storage).subscribe() && console.log(storage));
     }
     /**
-     * Fetches inbox items from the backend.
-     *
-     * @returns Observable of inbox items.
+     * Writes an item to the storage.
+     * @param key The item's key
+     * @param value The value to be stored
+     * @param debounce The debounce time (default: 500) to reduce identical storage calls
+     * @returns Resolves true if setting the item succeeded, false otherwise
      */
-    getItems() {
-        return this.getAllPages()
-            .pipe(map(res => res.map(item => new InboxItem(item))), tap(res => {
-            this.inboxItems = res;
-            this.inboxItemsSource.next(this.inboxItems);
-        }), catchError(Utils.throw(() => this.inboxItemsSource.next([]))));
-    }
-    getAllPages() {
-        let items = [];
-        return this.getPage().pipe(expand(res => {
-            return !res.last ? this.getPage(res.pageable.pageNumber + 1) : EMPTY;
-        }), tap(res => items = [...items, ...res.content]), skipWhile(res => !res.last), map(_ => items));
-    }
-    getPage(index) {
-        return this.backend
-            .getJson(`/get?size=${this.MAX_PAGE_SIZE}&page=${index || 0}`, this.backend.getInboxBase());
+    setItem(key, value, debounce = 500) {
+        if (!debounce) {
+            return this.storage.setItem(key, value);
+        }
+        else {
+            if (!this.itemsMap.has(key)) {
+                const subject = new Subject();
+                subject.pipe(debounceTime(debounce), switchMap(val => this.storage.setItem(key, val))).subscribe();
+                this.itemsMap.set(key, subject);
+            }
+            this.itemsMap.get(key).next(value);
+            return of(true);
+        }
     }
     /**
-     * Fetches state informations for the users inbox
-     *
-     * @returns inbox state object
+     * Get a stored item by its key.
+     * @param key The item's key
+     * @returns The item's value if the key exists, null otherwise
      */
-    getState() {
-        return this.inboxState;
+    getItem(key) {
+        return this.storage.getItem(key)
+            .pipe(map((item) => {
+            // IndexedDB issue after update (transform wrapped items)
+            return Object.keys(item || {}).join() === 'value' ? item.value : item;
+        }));
     }
     /**
-     * Public access to fetch inbox
+     * Removes an item from the storage.
+     * @param key The item's key
+     * @returns Resolves true if removing the item succeeded, false otherwise
      */
-    refreshInboxState() {
-        this.fetchInboxState();
+    removeItem(key) {
+        return this.storage.removeItem(key);
     }
     /**
-     * Retrieve inbox state
+     * Deletes all items from local storage
+     * @param filter optional - Delete all keys that pass through filter
+     * @returns Resolves true if clearing all items succeeded, false otherwise
      */
-    fetchInboxState() {
-        this.backend
-            .getJson('/state', this.backend.getInboxBase())
-            .pipe(map(res => res))
-            .subscribe(res => {
-            this.inboxState = res;
-            this.inboxStateSource.next(this.inboxState);
-        }, Utils.logError(null, 'Failed to fetch inbox state!'));
+    clear(filter) {
+        return filter
+            ? this.getStorageKeys().pipe(switchMap((keys) => {
+                const list = keys.filter((k) => filter(k)).map((k) => this.removeItem(k));
+                return list.length ? forkJoin(list).pipe(map(() => true)) : of(true);
+            }))
+            : this.storage.clear();
     }
-    /**
-     * Removes an item from the inbox.
-     *
-     * @param item inbox item to be removed
-     * @returns Observable<any>
-     */
-    removeItem(item) {
-        return this.backend
-            .del('/' + item.id, this.backend.getInboxBase())
-            .pipe(tap(() => this.updateInboxItems(item.id)));
+    getStorageKeys() {
+        return new Observable((observer) => {
+            const keys = [];
+            this.storageMap.keys().subscribe({
+                next: (key) => keys.push(key),
+                complete: () => observer.next(keys)
+            });
+        }).pipe(first());
     }
-    /**
-     * Soft update for data in the inbox.
-     *
-     * @param id
-     * @param item
-     * @param multi
-     */
-    updateInboxItems(id, item, multi) {
-        if (this.backend.update(this.inboxItems, multi || [{ id, item }])) {
-            this.inboxItemsSource.next(this.inboxItems);
-        }
+    getStorage() {
+        return this.getStorageKeys().pipe(switchMap((keys) => keys.length
+            ? forkJoin(Utils.arrayToObject(keys, (o) => o, (k) => this.getItem(k)))
+            : of({})));
     }
-    /**
-     * Marks an inbox item as read.
-     *
-     * @param item the item to be marked as read
-     * @returns Observable<any>
-     */
-    markAsRead(item) {
-        return this.backend.put('/read/' + item.id, this.backend.getInboxBase());
+    setStorage(options) {
+        return forkJoin(Object.keys(options || {}).map((k) => this.setItem(k, options[k])));
     }
 }
-InboxService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, deps: [{ token: BackendService }], target: i0.ɵɵFactoryTarget.Injectable });
-InboxService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, decorators: [{
+AppCacheService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, deps: [{ token: i1$2.LocalStorage }, { token: i1$2.StorageMap }], target: i0.ɵɵFactoryTarget.Injectable });
+AppCacheService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AppCacheService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: BackendService }]; } });
+        }], ctorParameters: function () { return [{ type: i1$2.LocalStorage }, { type: i1$2.StorageMap }]; } });
 
 /**
- * `BpmService` handles interaction related to BPM tasks.
- *
- * The main parts provided and used by this service are Processes and WorkItems.
- * Processes are defined on the backend side. They describe a set of tasks that will be executed by the process.
- * Tasks that require user interaction are referred to as WorkItems.
- *
- * Processes can be related to a special object type, but they don't have to. In addition to that they can refer
- * to dms objects.
+ * Collection of System Services
  */
-class BpmService {
-    constructor(capabilities, backend, eventService, inboxService) {
-        this.capabilities = capabilities;
+class SystemService {
+    constructor(backend, logger, eventService, appCache) {
         this.backend = backend;
+        this.logger = logger;
         this.eventService = eventService;
-        this.inboxService = inboxService;
-        this.processItemsSource = new ReplaySubject(1);
-        /**
-         * Long term observable emitting the current processes
-         */
-        this.processItems$ = this.processItemsSource.asObservable();
-    }
-    /**
-     * Retrieve all processes of the current user.
-     *
-     * @param size Maximum number of processes to be fetched
-     * @returns List of Processes
-     */
-    getProcesses(size = 1000) {
-        return this.backend
-            .getJson(`/process/user?size=${size}`, this.backend.getBpmBase())
-            .pipe(map(response => response.content.map(item => new Process(item))), tap((processes) => {
-            this.processItems = processes;
-            this.processItemsSource.next(this.processItems);
-        }));
-    }
-    /**
-     * Getter for the executable Processes. If types are provided, you'll get
-     * only the processes that are executable for all of them
-     * @param types List of dms object types to fetch executable processes for
-     * @param useCached If the cached data should be returned rather than requesting again
-     * @param additionalData If the additional form data should be also included
-     * @param modelid The process model ID to only return the data for one process
-     * @returns List of executable processes
-     */
-    getExecutableProcesses(types, useCached, additionalData, modelid, global) {
-        if (this.capabilities.hasCapability('bpm')) {
-            return (!!this.executableProcesses && useCached) ? of(this.executableProcesses) : this.fetchExecutableProcesses(types, additionalData, modelid, global);
-        }
-        else {
-            return of([]);
-        }
+        this.appCache = appCache;
+        this.systemSource = new ReplaySubject();
+        this.system$ = this.systemSource.asObservable();
+        // session cache for object type forms
+        this.objectTypeForms = [];
+        this.cachedRoles = [];
+        this.eventService.on(EnaioEvent.SYSTEM_STATUS_SCHEMA_CHANGED).subscribe(() => {
+            this.fetchSystemDefinition(this.user);
+        });
     }
-    initExecutableProcesses() {
-        let uri = '/bpm/process/executable';
-        return this.backend.get(uri).pipe(tap(res => this.hasMainExecutableProcesses = res?.length));
+    set system(s) {
+        this._system = s;
     }
-    /**
-     * Gets executable Processes for a given set of dms object.You'll get
-     * only the processes that are executable for all of them.
-     * @param dmsObjects List of dms objects to fetch executable processes for
-     * @returns List of executable processes
-     */
-    getExecutableProcessesForDmsObjects(dmsObjects) {
-        return this.getExecutableProcesses(dmsObjects.map(o => o.typeName), false, true);
+    get system() {
+        return JSON.parse(JSON.stringify(this._system));
     }
     /**
-     * Fetches executable Processes from the backend.
-     * @param types List of dms object types to fetch executable processes for
-     * @param additionalData If the additional form data should be also included
-     * @param modelid The process model ID to only return the data for one process
-     * @returns List of executable processes
+     * Gets all ObjectTypes
+     *
+     * @returns An array containing all object types
      */
-    fetchExecutableProcesses(types, additionalData, modelid, global) {
-        let uri = '/bpm/process/executable';
-        if (additionalData) {
-            uri += '?form=true&fields=true';
-        }
-        if (types) {
-            uri += (additionalData ? '&' : '?') + `type=${types.join(',')}`;
-        }
-        if (modelid) {
-            uri += (additionalData || types ? '&' : '?') + `modelid=${modelid}`;
-        }
-        return this.backend.get(uri).pipe(map(res => res), tap(res => {
-            // Extend existing processes with additional data, instead of overwriting all processes
-            if (global) {
-                if (additionalData) {
-                    if (!this.executableProcesses) {
-                        this.executableProcesses = [];
-                    }
-                    res.forEach(proc => {
-                        const existingProcIndex = this.executableProcesses.findIndex(item => item.id === proc.id);
-                        if (existingProcIndex === -1) {
-                            this.executableProcesses.push(proc);
-                        }
-                        else {
-                            this.executableProcesses[existingProcIndex] = proc;
-                        }
-                    });
-                }
-                else {
-                    this.executableProcesses = res;
-                }
-            }
-        }));
+    getObjectTypes() {
+        return this.system.types;
     }
     /**
-     * Getter for a processes file. The file of a process contains
-     * dms objects attached to the process.
-     * @param processId ID of the process to fetch attached objects for
+     * Gets an ObjectType by name.
+     *
+     * @param objectTypeName The name of the object type
+     * @returns the ObjectType matching the given name
      */
-    getProcessFile(processId) {
-        return this.backend
-            .getJson(`/process/${processId}/file`, this.backend.getBpmBase()).pipe(map(res => res.content.map(i => {
-            return {
-                id: i.elementid,
-                title: i.title,
-                description: i.description ? i.description : '',
-                iconid: i.iconid,
-                creator: i.creator,
-                addtime: i.addtime,
-                type: i.type
-            };
-        })));
+    getObjectType(objectTypeName) {
+        return this.system.types.find(t => t.name === objectTypeName);
     }
     /**
-     * Retrieves a work item.
-     * @param processId ID of the parent process
-     * @param itemId ID of the work item itself
-     * @param options Options to be added to the backend call
-     * @returns a WorkItem
+     * Get form elements from form model. This is useful if you have to fetch them
+     * for a special situation like SEARCH
+     * @param objectTypeName ObjectType to fetch elements for
+     * @param situation Form model situation to be fetched
+     * @param isContextType Flag indicating that the form model should be fetched for a context mode
      */
-    getWorkItem(processId, itemId, options) {
-        const params = options ? options : { form: true, fields: true };
-        const tasks = [
-            this.backend.getJson(Utils.buildUri(`/bpm/process/${processId}/${itemId}`, params)),
-            this.getProcessFile(processId)
-        ];
-        return forkJoin(tasks).pipe(map(res => {
-            const wi = new WorkItem(res[0]);
-            wi.setFile(res[1]);
-            return wi;
+    getFormElementsFromFormModel(objectTypeName, situation, isContextType) {
+        return this.getObjectTypeForm(objectTypeName, situation, isContextType ? 'CONTEXT' : null).pipe(switchMap(model => {
+            const elements = [];
+            this.processFormModelElements(model, elements);
+            return of(elements);
         }));
     }
-    /**
-     * Saves a work item.
-     * @param item The work item to be saved
-     * @returns The updated WorkItem
-     */
-    saveWorkItem(item) {
-        const { id, processId, file, data } = item;
-        const payload = { contents: file, data };
-        const params = { keeplock: true, isautolock: false };
-        return this.backend
-            .post(Utils.buildUri(`/bpm/process/${processId}/${id}/save`, params), payload)
-            .pipe(mergeMap(() => this.getWorkItem(processId, id)));
+    processFormModelElements(model, elements) {
+        model.elements.forEach(e => {
+            if (e.type !== "o2mGroup" && e.type !== "o2mGroupStack") {
+                elements.push(e);
+            }
+            else if (e.elements && e.elements.length) {
+                this.processFormModelElements(e, elements);
+            }
+        });
     }
     /**
-     * Forwards a work item. If a WorkItem provides different actions (@link WorkItemAction)
-     * you can provide the selected action too.
-     * @param item The work item to be forwarded
-     * @param action Action used for forwarding
+     * Checks whether or not the given type implements a given supertype
+     * @param type Type to be checked
+     * @param superTypeName Name of the supertype
      */
-    forwardWorkItem(item, action) {
-        const params = { keeplock: false, isautolock: false };
-        const payload = {
-            action: action,
-            contents: item.file,
-            data: item.data
-        };
-        return this.backend
-            .post(Utils.buildUri(`/bpm/process/${item.processId}/${item.id}/save`, params), payload)
-            .pipe(tap(() => this.inboxService.updateInboxItems(item.id)));
+    implementsType(type, superTypeName) {
+        return type.name === superTypeName || (type.implements && type.implements.indexOf(superTypeName) !== -1);
     }
     /**
-     * Locks a WorkItem for the current user (personalization), meaning that the
-     * current user is now in charge of fulfilling the WorkItem task.
-     * @param item The WorkItem to be locked
-     * @returns The updated WorkItem
+     * Gets a codesystem
+     *
+     * @param id The codesystems id
+     * @returns The codesystem object matching the given id
      */
-    lockWorkItem(item) {
-        return this.backend.put(`/bpm/process/${item.processId}/${item.id}/lock`)
-            .pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
+    getCodesystem(id) {
+        return this.system.codesystems.find(t => t.id === id || t.name === id);
     }
     /**
-     * Releases the lock for a WorkItem.
-     * @param item The work item to be unlocked
-     * @returns The updated WorkItem
+     * Get the form model of an object type.
+     *
+     * @param objectTypeName The object type name
+     * @param situation The form situation to be fetched
+     * @param mode Form mode to fetch (e.g. CONTEXT)
+     * @returns The object type form model
      */
-    unlockWorkItem(item) {
-        return this.backend.del(`/bpm/process/${item.processId}/${item.id}/lock`).pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
+    getObjectTypeForm(objectTypeName, situation, mode) {
+        /** check if we have a cached form first */
+        let cachedForm;
+        let i = 0;
+        while (!cachedForm && i < this.objectTypeForms.length) {
+            if (this.objectTypeForms[i].name === objectTypeName &&
+                this.objectTypeForms[i].mode === mode &&
+                this.objectTypeForms[i].situation === situation) {
+                cachedForm = this.objectTypeForms[i];
+            }
+            i++;
+        }
+        if (cachedForm) {
+            /** return a clone of the cached model as otherwise model changes will be added to the chached model */
+            return of(_.cloneDeep(cachedForm));
+        }
+        else {
+            let uri = `/ui/form/${objectTypeName}?situation=${situation}`;
+            uri += !!mode ? `&formmode=${mode}` : '';
+            /** fetch and cache the requested form, if no cached version was found */
+            return this.backend.getViaTempCache(uri, () => this.backend
+                .getJson(uri)
+                .pipe(tap((model) => this.objectTypeForms.push(_.cloneDeep(model)))));
+        }
     }
     /**
-     * Starts an executable process.
-     * @param executableProcessId ID of the executable Process to be started
-     * @param data Data to be passed to the process (simple object of key/value pairs)
-     * @param contents Objects to be attached to the process (process.file).
+     * Fetches the backends system definition and updates system$ Observable.
+     * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the
+     * system definition every time.
+     *
+     * @param user The user to load the system definition for
+     * @returns true when successfull
      */
-    startProcess(executableProcessId, data, contents) {
-        return this.backend.post(`/bpm/process/?modelid=${executableProcessId}`, {
-            data: data,
-            contents: contents
-        });
-    }
+    getSystemDefinition(user) {
+        this.user = user;
+        // todo: temporary: OrgChanges could not be recognized but affect object definition
+        return this.fetchSystemDefinition(user);
+        // todo: enable again when OrgChanges are recognizable (DO NOT DELETE!)
+        // // is there a cached version
+        // return this.appCache
+        //   .getItem(this.appCache.SYSTEM_DEFINITION)
+        //   .catch((error) => {
+        //     this.logger.error('Error fetching cached version of system definition.', error);
+        //     return this.fetchSystemDefinition(user);
+        //   })
+        //   .flatMap((cachedSystemDefinition: any) => {
+        //
+        //     // yes? then check if it's up to date
+        //     if (cachedSystemDefinition) {
+        //
+        //       if (
+        //         user.schema.version !== cachedSystemDefinition.info.version ||
+        //         user.id !== cachedSystemDefinition.info.user ||
+        //         user.getSchemaLocale() !== cachedSystemDefinition.info.locale
+        //       ) {
+        //         return this.fetchSystemDefinition(user);
+        //       } else {
+        //         // cache is up to date. return the cached one
+        //         this.logger.debug('System definition is up to date, using cached version.', cachedSystemDefinition);
+        //         this.system = cachedSystemDefinition;
+        //         this.systemSource.next(this.system);
+        //         return of(true);
+        //       }
+        //     } else {
+        //       // no cached systemDefinition found
+        //       return this.fetchSystemDefinition(user);
+        //     }
+        //   });
+    }
     /**
-     * Returns the history for a process. Which entries are returned depends on the
-     * permissions of the current user.
-     * @param processId The ID of the process to fetch history for
-     * @returns Observable<WorkItemHistoryEntry[]>
+     * Creates a value depending on a given Type
+     *
+     * @param string valueType
+     * @returns any
      */
-    getProcessHistory(processId) {
-        return this.backend
-            .getJson(`/bpm/process/${processId}/history`)
-            .pipe(map(res => res && res.length ? res.map(item => new WorkItemHistoryEntry(item)) : []));
+    getDefaultValue(valueType) {
+        let defaultValue;
+        switch (valueType) {
+            case 'CURRENT_USER': {
+                defaultValue = this.user.name;
+                break;
+            }
+            case 'CURRENT_USER_NAME': {
+                defaultValue = this.user.title;
+                break;
+            }
+            case 'CURRENT_DATETIME': {
+                defaultValue = new Date();
+                break;
+            }
+            case 'CURRENT_DATE': {
+                defaultValue = moment().startOf('day').toDate();
+                break;
+            }
+            case 'YEAR': {
+                defaultValue = moment().year();
+                break;
+            }
+            case 'MONTH': {
+                defaultValue = moment().month() + 1;
+                break;
+            }
+            case 'DAY': {
+                defaultValue = moment().date();
+                break;
+            }
+            case 'HOUR': {
+                defaultValue = moment().hour();
+                break;
+            }
+            case 'MINUTE': {
+                defaultValue = moment().minute();
+                break;
+            }
+            case 'SECOND': {
+                defaultValue = moment().second();
+                break;
+            }
+            case 'WEEK_OF_YEAR': {
+                defaultValue = moment().isoWeek();
+                break;
+            }
+            case 'FIRST_DAY_OF_WEEK': {
+                defaultValue = moment().startOf('isoWeek').toDate();
+                break;
+            }
+            case 'FIRST_DAY_OF_MONTH': {
+                defaultValue = moment().startOf('month').toDate();
+                break;
+            }
+            case 'FIRST_DAY_OF_YEAR': {
+                defaultValue = moment().startOf('year').toDate();
+                break;
+            }
+        }
+        return defaultValue;
     }
     /**
-     * Removes a content from the work items file.
-     * @param processId The ID of the process to remove the item from
-     * @param workItemId The ID of the work item containing the file element to be removed
-     * @param workItemContentId The the ID of the file element to be removed
+     * Fetches the system definition from the server. Provided params are used for storing the
+     * recent version in cache.
+     *
+     * @param user The user to fetch the system definition for
+     * @return boolean
      */
-    removeFileElement(processId, workItemId, workItemContentId) {
-        return this.backend
-            .del(`/process/${processId}/file/${workItemContentId}?activityid=${workItemId}`, this.backend.getBpmBase());
+    fetchSystemDefinition(user) {
+        const fetches = [
+            this.backend.getJson('/system/type/list?elements=true&basetypes=true'),
+            this.backend.getJson('/system/cs/list?elements=true')
+        ];
+        return forkJoin(fetches)
+            .pipe(catchError(Utils.catch((error) => {
+            this.logger.error('Error fetching recent version of system definition from server.', error);
+            this.systemSource.error('Error fetching recent version of system definition from server.');
+        })), map((data) => {
+            this.objectTypeForms = [];
+            const system = {
+                /**
+                 * info about the current system definition
+                 */
+                info: {
+                    user: user.id,
+                    locale: user.getSchemaLocale(),
+                    version: user.schema.version
+                },
+                /**
+                 * supported backend locales
+                 */
+                locales: user.schema.supportedLocales,
+                /**
+                 * object type definitions
+                 */
+                types: [],
+                /**
+                 * codesystems cache
+                 */
+                codesystems: []
+            };
+            const types = data[0];
+            system.types = types.map(t => new ObjectType(t));
+            system.codesystems = data[1];
+            this.system = system;
+            this.systemSource.next(system);
+            this.logger.debug('Fetched new version of system definition (user: ' + user.id + ', version: ' + user.schema.version + ').');
+            this.appCache
+                .setItem(this.appCache.SYSTEM_DEFINITION, system)
+                .subscribe(() => {
+                this.logger.debug('Cached recent version');
+            }, Utils.logError(null, 'Error caching recent version of system definition.'));
+            return true;
+        }));
     }
     /**
-     * Add contents to a work items file.
-     * @param processId The ID of the process
-     * @param workItemId The ID of the activity
-     * @param elements The Elements to be added
-     * @returns The updated WorkItem
+     * Retrieve an organization object by its ID
+     * @param id ID of org object
      */
-    addFileElements(processId, workItemId, elements) {
-        const tasks = [];
-        elements.forEach((e) => {
-            tasks.push(this.backend.post(`/process/${processId}/file/${e.id}?type=${e.type.name}&activityid=${workItemId}`, {}, this.backend.getBpmBase()));
-        });
-        return forkJoin(tasks)
-            .pipe(mergeMap(() => this.getWorkItem(processId, workItemId)));
+    getOrganizationObjectById(id) {
+        return this.backend.getJson(`/organization/id/${id}`);
     }
     /**
-     * Add a objects from the clipboard to a WorkItem.
-     * @param workItem The workItem to add the objects to
-     * @param clipboard Clipboard object holding user selected objects
-     * @returns The updated WorkItem
+     * Fetches the organization object for a given name.
+     *
+     * @param name The name to fetch object for
+     * @returns
      */
-    addFileElementsFromClipboard(workItem, clipboard) {
-        if ((workItem && workItem.fileEntryPermissions.add) && clipboard && clipboard.elements.length && clipboard.action === ClipboardAction.COPY) {
-            let contents;
-            if (workItem.file.length) {
-                // only add items that are not already part of the attachments
-                const attachmentIds = workItem.file.map(e => e.id);
-                contents = clipboard.elements.filter(e => attachmentIds.indexOf(e.id) === -1);
-            }
-            else {
-                contents = clipboard.elements;
-            }
-            return this.addFileElements(workItem.processId, workItem.id, contents);
+    getOrganizationObject(name) {
+        return this.getOrganizationObjects([name]).pipe(map(res => res[0]));
+    }
+    /**
+     * Fetches a collection of organization objects
+     *
+     * @param names Array of names to fetch objects for
+     * @returns A Array of Organization Objects
+     */
+    getOrganizationObjects(names) {
+        const toFetch = names.map(name => this.backend.getJson(`/organization/name/${name}`).pipe(catchError(error => of({ id: name, active: false }))));
+        return forkJoin(toFetch);
+    }
+    /**
+     * Fetches a collection of organization roles
+     *
+     * @return A Array of Organization Roles
+     */
+    getRoles() {
+        if (this.cachedRoles.length) {
+            return of(this.cachedRoles);
         }
         else {
-            return throwError('error');
+            return this.backend
+                .get('/organization/role')
+                .pipe(map(o => o), tap(roles => (this.cachedRoles = roles)));
         }
     }
 }
-BpmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, deps: [{ token: CapabilitiesService }, { token: BackendService }, { token: EventService }, { token: InboxService }], target: i0.ɵɵFactoryTarget.Injectable });
-BpmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, decorators: [{
+SystemService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, deps: [{ token: BackendService }, { token: Logger }, { token: EventService }, { token: AppCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
+SystemService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: CapabilitiesService }, { type: BackendService }, { type: EventService }, { type: InboxService }]; } });
+        }], ctorParameters: function () { return [{ type: BackendService }, { type: Logger }, { type: EventService }, { type: AppCacheService }]; } });
 
 /**
- * Representation of an object type. Object types are defined with the system definition and describe
- * different kind of objects that allowed to be created.
+ * Handles the systems capabilities. Capabilities are settings that enable/disable certain client features.
  */
-class ObjectType {
+class CapabilitiesService {
     /**
-     * Creates a new instance
-     * @param json The JSON object received from the backend. This will be used to construct the new object type instance
+     * @ignore
      */
-    constructor(json) {
-        this.id = json.id;
-        this.implements = json.implements ? json.implements : [];
-        this.isFolder = json.folder;
-        this.isContextFolder = json.iscontextfolder;
-        this.isAbstract = json.abstract;
-        this.iconId = json.icon ? json.icon.id : null;
-        this.maxFiles = json.maxfiles;
-        this.minFiles = json.minfiles;
-        this.name = json.name;
-        this.qname = json.qname;
-        this.label = json.label;
-        this.description = json.description;
-        this.group = json.group ? json.group.label : "";
-        this.elements = json.elements;
-        this.allowedcontexttypes = json.allowedcontexttypes
-            ? json.allowedcontexttypes
-            : [];
-        this.supertypes = json.supertypes ? json.supertypes.map(t => t.name) : [];
-        this.shareable = json.shareable;
-        this.parenttypes = this.getParentTypes(json.allowedlocations);
-    }
-    getParentTypes(allowedlocations) {
-        if (allowedlocations) {
-            return allowedlocations.parenttypes.map(types => types.name);
-        }
-        return [];
-    }
-}
-
-/**
- * Representation of a prepared item. A prepared item is an item that is supposed to create a new dms object.
- * Adding a new object to yuuvis<sup>&reg;</sup> RAD starts with a prepared item. If all the required properties are set up, the item
- * will be used to create a new dms object.
- */
-class PreparedItem {
-    /**
-     * Prepared items title
-     */
-    get title() {
-        return this.selectedtype ? this.selectedtype.label : '';
+    constructor(system) {
+        this.system = system;
     }
     /**
-     * Creates a new instance
-     * @param json The JSON object received from the backend. This will be used to construct the new prepared item instance
+     * Sets the capabilities based on a given object set by auth.service
+     *
+     * @param userCapabilities Object containing capabilities properties
+     * @param useSingleSingOn Whether or not to set up single signon on capability
+     * @returns The newly created capabilities object
      */
-    constructor(json) {
-        Object.assign(this, json);
+    setCapabilities(userCapabilities, useSingleSingOn) {
+        this.capabilities = {
+            bpm: userCapabilities.bpm,
+            favorites: userCapabilities.favorites,
+            followup: userCapabilities.followup,
+            subscription: userCapabilities.subscription,
+            intray: userCapabilities.intray,
+            storedqueries: userCapabilities.storedqueries,
+            recyclebin: userCapabilities.recyclebin,
+            inbox: userCapabilities.bpm || userCapabilities.followup || userCapabilities.subscription,
+            notifications: userCapabilities.followup || userCapabilities.subscription,
+            template: userCapabilities.template,
+            sso: useSingleSingOn || false,
+        };
+        return this.capabilities;
     }
     /**
-     * Returns true if the preparedItem contains content (template or actual file), false otherwise
+     * Getter for the Capabilities
      */
-    hasContent() {
-        return !!this.template || this.contentcount > 0;
+    getCapabilities() {
+        return { ...this.capabilities, signing: !!this.system.getObjectType('yuvsigning') };
     }
     /**
-     * Retrieves the prepared items selected type object from the list
-     * of available types.
-     * @returns The type object that is selected or NULL
+     * Check if Capability is present
+     * @param capability Capability to check for
+     * @returns True if the capability is set, false otherwise
      */
-    getSelectedTypeObject() {
-        return this.types.find(t => t.selected);
+    hasCapability(capability) {
+        return this.capabilities[capability];
     }
 }
+CapabilitiesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, deps: [{ token: SystemService }], target: i0.ɵɵFactoryTarget.Injectable });
+CapabilitiesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: CapabilitiesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SystemService }]; } });
 
-class UploadTarget {
-    /**
-     * Creates a new instance of UploadTarget
-     *
-     * @param id Upload targets unique id
-     * @param type Upload targets type
-     */
-    constructor(id, type) {
-        this.id = id;
-        this.type = type;
-    }
+/**
+ * Items emitted by the inbox service
+ */
+class InboxItem {
     /**
-     * Return Method if the Upload is Successfull
-     *
-     * @param target
-     * @returns the provided UploadTarget if the Upload was Successfull.
+     * Creates a new instance
+     * @param json The JSON object received from the backend. This will be used to construct the new inbox item instance
      */
-    onUploadSuccess(target) {
-        return target;
+    constructor(json) {
+        // todo: jsut use Object assign when backend changes are done
+        // Object.assign(this, json);
+        this.id = json.inboxentryid;
+        this.title = json.title;
+        this.description = json.description;
+        this.type = json.type;
+        this.sourceId = json.source ? json.source.id : null;
+        this.iconId = json.target && json.target.icon ? json.target.icon.id : null;
+        this.accepted = json.accepted;
+        this.isdeputy = json.isdeputy;
+        this.duetime = json.duetime;
+        this.received = json.receivetime;
+        this.target = json.target;
     }
     /**
-     * Return method if the Upload fails
-     *
-     * @returns an empty Object if the Upload fails
+     * Determines whether or not the inbox item is overdue
+     * @returns True when inbox item is overdue, false otherwise
      */
-    onUploadFail() {
-        return {};
+    isOverdue() {
+        return this.duetime && moment(this.duetime).isBefore(moment());
     }
 }
-/**
- * general filing target
- */
-UploadTarget.ROOT = 'root';
-/**
- * add file(s) to context folder
- */
-UploadTarget.CONTEXT = 'context';
-/**
- * add file(s) to context folders dynamic structure
- */
-UploadTarget.CONTEXT_TREE = 'contexttree';
-/**
- * set/replace content file of a dms object
- */
-UploadTarget.OBJECT = 'object';
-/**
- * custom targets (e.g. for plugin development)
- */
-UploadTarget.CUSTOM = 'custom';
-
-var Direction;
-(function (Direction) {
-    Direction["LTR"] = "ltr";
-    Direction["RTL"] = "rtl";
-})(Direction || (Direction = {}));
+InboxItem.TYPE_BPM = 'BPM';
+InboxItem.TYPE_RESUBMISSION = 'RESUBMISSION';
+InboxItem.TYPE_SUBSCRIPTION = 'SUBSCRIPTION';
 
 /**
- * @ignore
- */
-const moment = momentImported;
-/**
- * Collection of System Services
+ * InboxService handles interaction with the inbox service on the backend side.
  */
-class SystemService {
-    constructor(backend, logger, eventService, appCache) {
+class InboxService {
+    constructor(backend) {
         this.backend = backend;
-        this.logger = logger;
-        this.eventService = eventService;
-        this.appCache = appCache;
-        this.systemSource = new ReplaySubject();
-        this.system$ = this.systemSource.asObservable();
-        // session cache for object type forms
-        this.objectTypeForms = [];
-        this.cachedRoles = [];
-        this.eventService.on(EnaioEvent.SYSTEM_STATUS_SCHEMA_CHANGED).subscribe(() => {
-            this.fetchSystemDefinition(this.user);
-        });
-    }
-    set system(s) {
-        this._system = s;
-    }
-    get system() {
-        return JSON.parse(JSON.stringify(this._system));
+        // backends maximum page size
+        this.MAX_PAGE_SIZE = 1000;
+        this.inboxStateSource = new ReplaySubject(1);
+        this.inboxState$ = this.inboxStateSource.asObservable();
+        this.inboxItemsSource = new ReplaySubject(1);
+        this.inboxItemsGridData$ = this.inboxItemsSource.asObservable();
+        this.inboxItems$ = this.inboxItemsGridData$.pipe(this.backend.gridDataFilter);
     }
     /**
-     * Gets all ObjectTypes
+     * Fetches inbox items from the backend.
      *
-     * @returns An array containing all object types
+     * @returns Observable of inbox items.
      */
-    getObjectTypes() {
-        return this.system.types;
+    getItems() {
+        return this.getAllPages()
+            .pipe(map(res => res.map(item => new InboxItem(item))), tap(res => {
+            this.inboxItems = res;
+            this.inboxItemsSource.next(this.inboxItems);
+        }), catchError(Utils.throw(() => this.inboxItemsSource.next([]))));
+    }
+    getAllPages() {
+        let items = [];
+        return this.getPage().pipe(expand(res => {
+            return !res.last ? this.getPage(res.pageable.pageNumber + 1) : EMPTY;
+        }), tap(res => items = [...items, ...res.content]), skipWhile(res => !res.last), map(_ => items));
+    }
+    getPage(index) {
+        return this.backend
+            .getJson(`/get?size=${this.MAX_PAGE_SIZE}&page=${index || 0}`, this.backend.getInboxBase());
     }
     /**
-     * Gets an ObjectType by name.
+     * Fetches state informations for the users inbox
      *
-     * @param objectTypeName The name of the object type
-     * @returns the ObjectType matching the given name
+     * @returns inbox state object
      */
-    getObjectType(objectTypeName) {
-        return this.system.types.find(t => t.name === objectTypeName);
+    getState() {
+        return this.inboxState;
     }
     /**
-     * Get form elements from form model. This is useful if you have to fetch them
-     * for a special situation like SEARCH
-     * @param objectTypeName ObjectType to fetch elements for
-     * @param situation Form model situation to be fetched
-     * @param isContextType Flag indicating that the form model should be fetched for a context mode
+     * Public access to fetch inbox
      */
-    getFormElementsFromFormModel(objectTypeName, situation, isContextType) {
-        return this.getObjectTypeForm(objectTypeName, situation, isContextType ? 'CONTEXT' : null).pipe(switchMap(model => {
-            const elements = [];
-            this.processFormModelElements(model, elements);
-            return of(elements);
-        }));
-    }
-    processFormModelElements(model, elements) {
-        model.elements.forEach(e => {
-            if (e.type !== "o2mGroup" && e.type !== "o2mGroupStack") {
-                elements.push(e);
-            }
-            else if (e.elements && e.elements.length) {
-                this.processFormModelElements(e, elements);
-            }
-        });
+    refreshInboxState() {
+        this.fetchInboxState();
     }
     /**
-     * Checks whether or not the given type implements a given supertype
-     * @param type Type to be checked
-     * @param superTypeName Name of the supertype
+     * Retrieve inbox state
      */
-    implementsType(type, superTypeName) {
-        return type.name === superTypeName || (type.implements && type.implements.indexOf(superTypeName) !== -1);
+    fetchInboxState() {
+        this.backend
+            .getJson('/state', this.backend.getInboxBase())
+            .pipe(map(res => res))
+            .subscribe(res => {
+            this.inboxState = res;
+            this.inboxStateSource.next(this.inboxState);
+        }, Utils.logError(null, 'Failed to fetch inbox state!'));
     }
     /**
-     * Gets a codesystem
+     * Removes an item from the inbox.
      *
-     * @param id The codesystems id
-     * @returns The codesystem object matching the given id
+     * @param item inbox item to be removed
+     * @returns Observable<any>
      */
-    getCodesystem(id) {
-        return this.system.codesystems.find(t => t.id === id || t.name === id);
+    removeItem(item) {
+        return this.backend
+            .del('/' + item.id, this.backend.getInboxBase())
+            .pipe(tap(() => this.updateInboxItems(item.id)));
     }
     /**
-     * Get the form model of an object type.
+     * Soft update for data in the inbox.
      *
-     * @param objectTypeName The object type name
-     * @param situation The form situation to be fetched
-     * @param mode Form mode to fetch (e.g. CONTEXT)
-     * @returns The object type form model
+     * @param id
+     * @param item
+     * @param multi
      */
-    getObjectTypeForm(objectTypeName, situation, mode) {
-        /** check if we have a cached form first */
-        let cachedForm;
-        let i = 0;
-        while (!cachedForm && i < this.objectTypeForms.length) {
-            if (this.objectTypeForms[i].name === objectTypeName &&
-                this.objectTypeForms[i].mode === mode &&
-                this.objectTypeForms[i].situation === situation) {
-                cachedForm = this.objectTypeForms[i];
-            }
-            i++;
+    updateInboxItems(id, item, multi) {
+        if (this.backend.update(this.inboxItems, multi || [{ id, item }])) {
+            this.inboxItemsSource.next(this.inboxItems);
         }
-        if (cachedForm) {
-            /** return a clone of the cached model as otherwise model changes will be added to the chached model */
-            return of(_.cloneDeep(cachedForm));
+    }
+    /**
+     * Marks an inbox item as read.
+     *
+     * @param item the item to be marked as read
+     * @returns Observable<any>
+     */
+    markAsRead(item) {
+        return this.backend.put('/read/' + item.id, this.backend.getInboxBase());
+    }
+}
+InboxService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, deps: [{ token: BackendService }], target: i0.ɵɵFactoryTarget.Injectable });
+InboxService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: InboxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BackendService }]; } });
+
+/**
+ * `BpmService` handles interaction related to BPM tasks.
+ *
+ * The main parts provided and used by this service are Processes and WorkItems.
+ * Processes are defined on the backend side. They describe a set of tasks that will be executed by the process.
+ * Tasks that require user interaction are referred to as WorkItems.
+ *
+ * Processes can be related to a special object type, but they don't have to. In addition to that they can refer
+ * to dms objects.
+ */
+class BpmService {
+    constructor(capabilities, backend, eventService, inboxService) {
+        this.capabilities = capabilities;
+        this.backend = backend;
+        this.eventService = eventService;
+        this.inboxService = inboxService;
+        this.processItemsSource = new ReplaySubject(1);
+        /**
+         * Long term observable emitting the current processes
+         */
+        this.processItems$ = this.processItemsSource.asObservable();
+    }
+    /**
+     * Retrieve all processes of the current user.
+     *
+     * @param size Maximum number of processes to be fetched
+     * @returns List of Processes
+     */
+    getProcesses(size = 1000) {
+        return this.backend
+            .getJson(`/process/user?size=${size}`, this.backend.getBpmBase())
+            .pipe(map(response => response.content.map(item => new Process(item))), tap((processes) => {
+            this.processItems = processes;
+            this.processItemsSource.next(this.processItems);
+        }));
+    }
+    /**
+     * Getter for the executable Processes. If types are provided, you'll get
+     * only the processes that are executable for all of them
+     * @param types List of dms object types to fetch executable processes for
+     * @param useCached If the cached data should be returned rather than requesting again
+     * @param additionalData If the additional form data should be also included
+     * @param modelid The process model ID to only return the data for one process
+     * @returns List of executable processes
+     */
+    getExecutableProcesses(types, useCached, additionalData, modelid, global) {
+        if (this.capabilities.hasCapability('bpm')) {
+            return (!!this.executableProcesses && useCached) ? of(this.executableProcesses) : this.fetchExecutableProcesses(types, additionalData, modelid, global);
         }
         else {
-            let uri = `/ui/form/${objectTypeName}?situation=${situation}`;
-            uri += !!mode ? `&formmode=${mode}` : '';
-            /** fetch and cache the requested form, if no cached version was found */
-            return this.backend.getViaTempCache(uri, () => this.backend
-                .getJson(uri)
-                .pipe(tap((model) => this.objectTypeForms.push(_.cloneDeep(model)))));
+            return of([]);
         }
     }
+    initExecutableProcesses() {
+        let uri = '/bpm/process/executable';
+        return this.backend.get(uri).pipe(tap(res => this.hasMainExecutableProcesses = res?.length));
+    }
     /**
-     * Fetches the backends system definition and updates system$ Observable.
-     * Subscribe to the system$ observable instead of calling this function, otherwise you'll trigger fetching the
-     * system definition every time.
-     *
-     * @param user The user to load the system definition for
-     * @returns true when successfull
+     * Gets executable Processes for a given set of dms object.You'll get
+     * only the processes that are executable for all of them.
+     * @param dmsObjects List of dms objects to fetch executable processes for
+     * @returns List of executable processes
      */
-    getSystemDefinition(user) {
-        this.user = user;
-        // todo: temporary: OrgChanges could not be recognized but affect object definition
-        return this.fetchSystemDefinition(user);
-        // todo: enable again when OrgChanges are recognizable (DO NOT DELETE!)
-        // // is there a cached version
-        // return this.appCache
-        //   .getItem(this.appCache.SYSTEM_DEFINITION)
-        //   .catch((error) => {
-        //     this.logger.error('Error fetching cached version of system definition.', error);
-        //     return this.fetchSystemDefinition(user);
-        //   })
-        //   .flatMap((cachedSystemDefinition: any) => {
-        //
-        //     // yes? then check if it's up to date
-        //     if (cachedSystemDefinition) {
-        //
-        //       if (
-        //         user.schema.version !== cachedSystemDefinition.info.version ||
-        //         user.id !== cachedSystemDefinition.info.user ||
-        //         user.getSchemaLocale() !== cachedSystemDefinition.info.locale
-        //       ) {
-        //         return this.fetchSystemDefinition(user);
-        //       } else {
-        //         // cache is up to date. return the cached one
-        //         this.logger.debug('System definition is up to date, using cached version.', cachedSystemDefinition);
-        //         this.system = cachedSystemDefinition;
-        //         this.systemSource.next(this.system);
-        //         return of(true);
-        //       }
-        //     } else {
-        //       // no cached systemDefinition found
-        //       return this.fetchSystemDefinition(user);
-        //     }
-        //   });
+    getExecutableProcessesForDmsObjects(dmsObjects) {
+        return this.getExecutableProcesses(dmsObjects.map(o => o.typeName), false, true);
     }
     /**
-     * Creates a value depending on a given Type
-     *
-     * @param string valueType
-     * @returns any
+     * Fetches executable Processes from the backend.
+     * @param types List of dms object types to fetch executable processes for
+     * @param additionalData If the additional form data should be also included
+     * @param modelid The process model ID to only return the data for one process
+     * @returns List of executable processes
      */
-    getDefaultValue(valueType) {
-        let defaultValue;
-        switch (valueType) {
-            case 'CURRENT_USER': {
-                defaultValue = this.user.name;
-                break;
-            }
-            case 'CURRENT_USER_NAME': {
-                defaultValue = this.user.title;
-                break;
-            }
-            case 'CURRENT_DATETIME': {
-                defaultValue = new Date();
-                break;
-            }
-            case 'CURRENT_DATE': {
-                defaultValue = moment().startOf('day').toDate();
-                break;
-            }
-            case 'YEAR': {
-                defaultValue = moment().year();
-                break;
-            }
-            case 'MONTH': {
-                defaultValue = moment().month() + 1;
-                break;
-            }
-            case 'DAY': {
-                defaultValue = moment().date();
-                break;
-            }
-            case 'HOUR': {
-                defaultValue = moment().hour();
-                break;
-            }
-            case 'MINUTE': {
-                defaultValue = moment().minute();
-                break;
-            }
-            case 'SECOND': {
-                defaultValue = moment().second();
-                break;
-            }
-            case 'WEEK_OF_YEAR': {
-                defaultValue = moment().isoWeek();
-                break;
-            }
-            case 'FIRST_DAY_OF_WEEK': {
-                defaultValue = moment().startOf('isoWeek').toDate();
-                break;
+    fetchExecutableProcesses(types, additionalData, modelid, global) {
+        let uri = '/bpm/process/executable';
+        if (additionalData) {
+            uri += '?form=true&fields=true';
+        }
+        if (types) {
+            uri += (additionalData ? '&' : '?') + `type=${types.join(',')}`;
+        }
+        if (modelid) {
+            uri += (additionalData || types ? '&' : '?') + `modelid=${modelid}`;
+        }
+        return this.backend.get(uri).pipe(map(res => res), tap(res => {
+            // Extend existing processes with additional data, instead of overwriting all processes
+            if (global) {
+                if (additionalData) {
+                    if (!this.executableProcesses) {
+                        this.executableProcesses = [];
+                    }
+                    res.forEach(proc => {
+                        const existingProcIndex = this.executableProcesses.findIndex(item => item.id === proc.id);
+                        if (existingProcIndex === -1) {
+                            this.executableProcesses.push(proc);
+                        }
+                        else {
+                            this.executableProcesses[existingProcIndex] = proc;
+                        }
+                    });
+                }
+                else {
+                    this.executableProcesses = res;
+                }
             }
-            case 'FIRST_DAY_OF_MONTH': {
-                defaultValue = moment().startOf('month').toDate();
-                break;
+        }));
+    }
+    /**
+     * Getter for a processes file. The file of a process contains
+     * dms objects attached to the process.
+     * @param processId ID of the process to fetch attached objects for
+     */
+    getProcessFile(processId) {
+        return this.backend
+            .getJson(`/process/${processId}/file`, this.backend.getBpmBase()).pipe(map(res => res.content.map(i => {
+            return {
+                id: i.elementid,
+                title: i.title,
+                description: i.description ? i.description : '',
+                iconid: i.iconid,
+                creator: i.creator,
+                addtime: i.addtime,
+                type: i.type
+            };
+        })));
+    }
+    /**
+     * Retrieves a work item.
+     * @param processId ID of the parent process
+     * @param itemId ID of the work item itself
+     * @param options Options to be added to the backend call
+     * @returns a WorkItem
+     */
+    getWorkItem(processId, itemId, options) {
+        const params = options ? options : { form: true, fields: true };
+        const tasks = [
+            this.backend.getJson(Utils.buildUri(`/bpm/process/${processId}/${itemId}`, params)),
+            this.getProcessFile(processId)
+        ];
+        return forkJoin(tasks).pipe(map(res => {
+            const wi = new WorkItem(res[0]);
+            wi.setFile(res[1]);
+            return wi;
+        }));
+    }
+    /**
+     * Saves a work item.
+     * @param item The work item to be saved
+     * @returns The updated WorkItem
+     */
+    saveWorkItem(item) {
+        const { id, processId, file, data } = item;
+        const payload = { contents: file, data };
+        const params = { keeplock: true, isautolock: false };
+        return this.backend
+            .post(Utils.buildUri(`/bpm/process/${processId}/${id}/save`, params), payload)
+            .pipe(mergeMap(() => this.getWorkItem(processId, id)));
+    }
+    /**
+     * Forwards a work item. If a WorkItem provides different actions (@link WorkItemAction)
+     * you can provide the selected action too.
+     * @param item The work item to be forwarded
+     * @param action Action used for forwarding
+     */
+    forwardWorkItem(item, action) {
+        const params = { keeplock: false, isautolock: false };
+        const payload = {
+            action: action,
+            contents: item.file,
+            data: item.data
+        };
+        return this.backend
+            .post(Utils.buildUri(`/bpm/process/${item.processId}/${item.id}/save`, params), payload)
+            .pipe(tap(() => this.inboxService.updateInboxItems(item.id)));
+    }
+    /**
+     * Locks a WorkItem for the current user (personalization), meaning that the
+     * current user is now in charge of fulfilling the WorkItem task.
+     * @param item The WorkItem to be locked
+     * @returns The updated WorkItem
+     */
+    lockWorkItem(item) {
+        return this.backend.put(`/bpm/process/${item.processId}/${item.id}/lock`)
+            .pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
+    }
+    /**
+     * Releases the lock for a WorkItem.
+     * @param item The work item to be unlocked
+     * @returns The updated WorkItem
+     */
+    unlockWorkItem(item) {
+        return this.backend.del(`/bpm/process/${item.processId}/${item.id}/lock`).pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
+    }
+    /**
+     * Starts an executable process.
+     * @param executableProcessId ID of the executable Process to be started
+     * @param data Data to be passed to the process (simple object of key/value pairs)
+     * @param contents Objects to be attached to the process (process.file).
+     */
+    startProcess(executableProcessId, data, contents) {
+        return this.backend.post(`/bpm/process/?modelid=${executableProcessId}`, {
+            data: data,
+            contents: contents
+        });
+    }
+    /**
+     * Returns the history for a process. Which entries are returned depends on the
+     * permissions of the current user.
+     * @param processId The ID of the process to fetch history for
+     * @returns Observable<WorkItemHistoryEntry[]>
+     */
+    getProcessHistory(processId) {
+        return this.backend
+            .getJson(`/bpm/process/${processId}/history`)
+            .pipe(map(res => res && res.length ? res.map(item => new WorkItemHistoryEntry(item)) : []));
+    }
+    /**
+     * Removes a content from the work items file.
+     * @param processId The ID of the process to remove the item from
+     * @param workItemId The ID of the work item containing the file element to be removed
+     * @param workItemContentId The the ID of the file element to be removed
+     */
+    removeFileElement(processId, workItemId, workItemContentId) {
+        return this.backend
+            .del(`/process/${processId}/file/${workItemContentId}?activityid=${workItemId}`, this.backend.getBpmBase());
+    }
+    /**
+     * Add contents to a work items file.
+     * @param processId The ID of the process
+     * @param workItemId The ID of the activity
+     * @param elements The Elements to be added
+     * @returns The updated WorkItem
+     */
+    addFileElements(processId, workItemId, elements) {
+        const tasks = [];
+        elements.forEach((e) => {
+            tasks.push(this.backend.post(`/process/${processId}/file/${e.id}?type=${e.type.name}&activityid=${workItemId}`, {}, this.backend.getBpmBase()));
+        });
+        return forkJoin(tasks)
+            .pipe(mergeMap(() => this.getWorkItem(processId, workItemId)));
+    }
+    /**
+     * Add a objects from the clipboard to a WorkItem.
+     * @param workItem The workItem to add the objects to
+     * @param clipboard Clipboard object holding user selected objects
+     * @returns The updated WorkItem
+     */
+    addFileElementsFromClipboard(workItem, clipboard) {
+        if ((workItem && workItem.fileEntryPermissions.add) && clipboard && clipboard.elements.length && clipboard.action === ClipboardAction.COPY) {
+            let contents;
+            if (workItem.file.length) {
+                // only add items that are not already part of the attachments
+                const attachmentIds = workItem.file.map(e => e.id);
+                contents = clipboard.elements.filter(e => attachmentIds.indexOf(e.id) === -1);
             }
-            case 'FIRST_DAY_OF_YEAR': {
-                defaultValue = moment().startOf('year').toDate();
-                break;
+            else {
+                contents = clipboard.elements;
             }
+            return this.addFileElements(workItem.processId, workItem.id, contents);
+        }
+        else {
+            return throwError('error');
         }
-        return defaultValue;
     }
+}
+BpmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, deps: [{ token: CapabilitiesService }, { token: BackendService }, { token: EventService }, { token: InboxService }], target: i0.ɵɵFactoryTarget.Injectable });
+BpmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BpmService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: CapabilitiesService }, { type: BackendService }, { type: EventService }, { type: InboxService }]; } });
+
+/**
+ * Representation of a prepared item. A prepared item is an item that is supposed to create a new dms object.
+ * Adding a new object to yuuvis<sup>&reg;</sup> RAD starts with a prepared item. If all the required properties are set up, the item
+ * will be used to create a new dms object.
+ */
+class PreparedItem {
     /**
-     * Fetches the system definition from the server. Provided params are used for storing the
-     * recent version in cache.
-     *
-     * @param user The user to fetch the system definition for
-     * @return boolean
+     * Prepared items title
      */
-    fetchSystemDefinition(user) {
-        const fetches = [
-            this.backend.getJson('/system/type/list?elements=true&basetypes=true'),
-            this.backend.getJson('/system/cs/list?elements=true')
-        ];
-        return forkJoin(fetches)
-            .pipe(catchError(Utils.catch((error) => {
-            this.logger.error('Error fetching recent version of system definition from server.', error);
-            this.systemSource.error('Error fetching recent version of system definition from server.');
-        })), map((data) => {
-            this.objectTypeForms = [];
-            const system = {
-                /**
-                 * info about the current system definition
-                 */
-                info: {
-                    user: user.id,
-                    locale: user.getSchemaLocale(),
-                    version: user.schema.version
-                },
-                /**
-                 * supported backend locales
-                 */
-                locales: user.schema.supportedLocales,
-                /**
-                 * object type definitions
-                 */
-                types: [],
-                /**
-                 * codesystems cache
-                 */
-                codesystems: []
-            };
-            const types = data[0];
-            system.types = types.map(t => new ObjectType(t));
-            system.codesystems = data[1];
-            this.system = system;
-            this.systemSource.next(system);
-            this.logger.debug('Fetched new version of system definition (user: ' + user.id + ', version: ' + user.schema.version + ').');
-            this.appCache
-                .setItem(this.appCache.SYSTEM_DEFINITION, system)
-                .subscribe(() => {
-                this.logger.debug('Cached recent version');
-            }, Utils.logError(null, 'Error caching recent version of system definition.'));
-            return true;
-        }));
+    get title() {
+        return this.selectedtype ? this.selectedtype.label : '';
+    }
+    /**
+     * Creates a new instance
+     * @param json The JSON object received from the backend. This will be used to construct the new prepared item instance
+     */
+    constructor(json) {
+        Object.assign(this, json);
+    }
+    /**
+     * Returns true if the preparedItem contains content (template or actual file), false otherwise
+     */
+    hasContent() {
+        return !!this.template || this.contentcount > 0;
     }
     /**
-     * Retrieve an organization object by its ID
-     * @param id ID of org object
+     * Retrieves the prepared items selected type object from the list
+     * of available types.
+     * @returns The type object that is selected or NULL
      */
-    getOrganizationObjectById(id) {
-        return this.backend.getJson(`/organization/id/${id}`);
+    getSelectedTypeObject() {
+        return this.types.find(t => t.selected);
     }
+}
+
+class UploadTarget {
     /**
-     * Fetches the organization object for a given name.
+     * Creates a new instance of UploadTarget
      *
-     * @param name The name to fetch object for
-     * @returns
+     * @param id Upload targets unique id
+     * @param type Upload targets type
      */
-    getOrganizationObject(name) {
-        return this.getOrganizationObjects([name]).pipe(map(res => res[0]));
+    constructor(id, type) {
+        this.id = id;
+        this.type = type;
     }
     /**
-     * Fetches a collection of organization objects
+     * Return Method if the Upload is Successfull
      *
-     * @param names Array of names to fetch objects for
-     * @returns A Array of Organization Objects
+     * @param target
+     * @returns the provided UploadTarget if the Upload was Successfull.
      */
-    getOrganizationObjects(names) {
-        const toFetch = names.map(name => this.backend.getJson(`/organization/name/${name}`).pipe(catchError(error => of({ id: name, active: false }))));
-        return forkJoin(toFetch);
+    onUploadSuccess(target) {
+        return target;
     }
     /**
-     * Fetches a collection of organization roles
+     * Return method if the Upload fails
      *
-     * @return A Array of Organization Roles
+     * @returns an empty Object if the Upload fails
      */
-    getRoles() {
-        if (this.cachedRoles.length) {
-            return of(this.cachedRoles);
-        }
-        else {
-            return this.backend
-                .get('/organization/role')
-                .pipe(map(o => o), tap(roles => (this.cachedRoles = roles)));
-        }
+    onUploadFail() {
+        return {};
     }
 }
-SystemService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, deps: [{ token: BackendService }, { token: Logger }, { token: EventService }, { token: AppCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
-SystemService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SystemService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: BackendService }, { type: Logger }, { type: EventService }, { type: AppCacheService }]; } });
+/**
+ * general filing target
+ */
+UploadTarget.ROOT = 'root';
+/**
+ * add file(s) to context folder
+ */
+UploadTarget.CONTEXT = 'context';
+/**
+ * add file(s) to context folders dynamic structure
+ */
+UploadTarget.CONTEXT_TREE = 'contexttree';
+/**
+ * set/replace content file of a dms object
+ */
+UploadTarget.OBJECT = 'object';
+/**
+ * custom targets (e.g. for plugin development)
+ */
+UploadTarget.CUSTOM = 'custom';
+
+var Direction;
+(function (Direction) {
+    Direction["LTR"] = "ltr";
+    Direction["RTL"] = "rtl";
+})(Direction || (Direction = {}));
 
 /**
  * Applications user service.
@@ -3293,15 +3198,25 @@ class UserService {
             this.refreshCurrentUser().subscribe();
         }));
     }
+    /**
+     * Save or change the workspace of the current user
+     * @param workspaceConfig The value to set the saved workspace or create a new workspace
+     */
+    saveChangeWorkspace(workspaceConfig) {
+        this.user.userSettings.workspaceOptions = workspaceConfig;
+        return this.backend.put('/user/config/web', this.user.userSettings).pipe(map(() => {
+            this.refreshCurrentUser().subscribe();
+        }));
+    }
 }
-UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: UserService, deps: [{ token: BackendService }, { token: i2.TranslateService }, { token: Logger }, { token: EventService }, { token: SystemService }, { token: i1$1.HttpClient }, { token: Config }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: UserService, deps: [{ token: BackendService }, { token: i1.TranslateService }, { token: Logger }, { token: EventService }, { token: SystemService }, { token: i1$1.HttpClient }, { token: Config }], target: i0.ɵɵFactoryTarget.Injectable });
 UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: UserService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: UserService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: BackendService }, { type: i2.TranslateService }, { type: Logger }, { type: EventService }, { type: SystemService }, { type: i1$1.HttpClient }, { type: Config }]; } });
+        }], ctorParameters: function () { return [{ type: BackendService }, { type: i1.TranslateService }, { type: Logger }, { type: EventService }, { type: SystemService }, { type: i1$1.HttpClient }, { type: Config }]; } });
 
 /**
  * The Upload Service is provides access to Upload data (files)
@@ -3352,6 +3267,14 @@ class PrepareService {
         this.preparedItems$ = this.preparedItemsSource.asObservable();
         this.preparedItemCountSource = new ReplaySubject(1);
         this.preparedItemCount$ = this.preparedItemCountSource.asObservable();
+        /**
+         * Creates a prepared item on the backed side.
+         *
+         * @param parentId The ID of the parent dms object to add the prepared item to
+         * @param childType The type of object to be created
+         * @returns Observable<any>
+         */
+        this.i = 0;
     }
     /**
      * Public Fetch Prepare items
@@ -3370,14 +3293,9 @@ class PrepareService {
             this.preparedItemCountSource.next(this.preparedItemCount);
         });
     }
-    /**
-     * Creates a prepared item on the backed side.
-     *
-     * @param parentId The ID of the parent dms object to add the prepared item to
-     * @param childType The type of object to be created
-     * @returns Observable<any>
-     */
     createPreparedItem(parentId, childType) {
+        console.log('tick');
+        this.i++;
         return this.backend
             .post(this.createPreparedItemPostUrl({
             parentId: parentId,
@@ -3544,7 +3462,7 @@ class PrepareService {
      * @returns Observable<any>
      */
     uploadContent(preparedItemId, file) {
-        const uri = `${this.backend.getServiceBase()}/prepare/${preparedItemId}/content.json?form=true&contentmeta=true`;
+        const uri = `${this.backend.getBaseWithContext(this.backend.getServiceBase())}/prepare/${preparedItemId}/content.json?form=true&contentmeta=true`;
         return this.uploadService
             .upload(uri, [file])
             .pipe(
@@ -3580,7 +3498,7 @@ class PrepareService {
              *
              * @type string
              */
-            uri = this.backend.getServiceBase() + this.createPreparedItemPostUrl({
+            uri = this.backend.getBaseWithContext(this.backend.getServiceBase()) + this.createPreparedItemPostUrl({
                 parentId: null,
                 createMany: !useBatchUpload
             });
@@ -3590,7 +3508,7 @@ class PrepareService {
              * upload to dms object, means adding or replacing content file
              */
             const { referenceObject } = uploadTarget;
-            uri = `${this.backend.getServiceBase()}/dms/${referenceObject.id}/contents?type=${referenceObject.type.name}`;
+            uri = `${this.backend.getBaseWithContext(this.backend.getServiceBase())}/dms/${referenceObject.id}/contents?type=${referenceObject.type.name}`;
         }
         else if (uploadTarget.type === UploadTarget.CONTEXT || uploadTarget.type === UploadTarget.CONTEXT_TREE) {
             /**
@@ -3600,7 +3518,7 @@ class PrepareService {
              *
              * @type string
              */
-            uri = this.backend.getServiceBase() + this.createPreparedItemPostUrl({
+            uri = this.backend.getBaseWithContext(this.backend.getServiceBase()) + this.createPreparedItemPostUrl({
                 parentId: uploadTarget.referenceObject.id,
                 createMany: !useBatchUpload,
                 childType: uploadTarget.subFolder && uploadTarget.subFolder.data.type ? uploadTarget.subFolder.data.type : null
@@ -3842,17 +3760,14 @@ class AuthService {
     /**
      * @ignore
      */
-    constructor(config, coreConfig, appCache, envService, http, bpmService, ngZone, location, capabilitiesService, logger, inboxService, prepareService, backend, systemService, userService, eventService, systemStatusService, storage, local) {
+    constructor(config, coreConfig, envService, http, bpmService, ngZone, capabilitiesService, inboxService, prepareService, backend, systemService, userService, eventService, systemStatusService, storage, local) {
         this.config = config;
         this.coreConfig = coreConfig;
-        this.appCache = appCache;
         this.envService = envService;
         this.http = http;
         this.bpmService = bpmService;
         this.ngZone = ngZone;
-        this.location = location;
         this.capabilitiesService = capabilitiesService;
-        this.logger = logger;
         this.inboxService = inboxService;
         this.prepareService = prepareService;
         this.backend = backend;
@@ -4161,7 +4076,7 @@ class AuthService {
         return forkJoin(todo).pipe(map(() => currUser));
     }
 }
-AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AuthService, deps: [{ token: Config }, { token: CORE_CONFIG }, { token: AppCacheService }, { token: EnvironmentService }, { token: i1$1.HttpClient }, { token: BpmService }, { token: i0.NgZone }, { token: i6.PlatformLocation }, { token: CapabilitiesService }, { token: Logger }, { token: InboxService }, { token: PrepareService }, { token: BackendService }, { token: SystemService }, { token: UserService }, { token: EventService }, { token: SystemStatusService }, { token: i1.LocalStorage }, { token: LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AuthService, deps: [{ token: Config }, { token: CORE_CONFIG }, { token: EnvironmentService }, { token: i1$1.HttpClient }, { token: BpmService }, { token: i0.NgZone }, { token: CapabilitiesService }, { token: InboxService }, { token: PrepareService }, { token: BackendService }, { token: SystemService }, { token: UserService }, { token: EventService }, { token: SystemStatusService }, { token: i1$2.LocalStorage }, { token: LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
 AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AuthService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable,
@@ -4171,7 +4086,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
         }], ctorParameters: function () { return [{ type: Config }, { type: CoreConfig, decorators: [{
                     type: Inject,
                     args: [CORE_CONFIG]
-                }] }, { type: AppCacheService }, { type: EnvironmentService }, { type: i1$1.HttpClient }, { type: BpmService }, { type: i0.NgZone }, { type: i6.PlatformLocation }, { type: CapabilitiesService }, { type: Logger }, { type: InboxService }, { type: PrepareService }, { type: BackendService }, { type: SystemService }, { type: UserService }, { type: EventService }, { type: SystemStatusService }, { type: i1.LocalStorage }, { type: LocalStorageService }]; } });
+                }] }, { type: EnvironmentService }, { type: i1$1.HttpClient }, { type: BpmService }, { type: i0.NgZone }, { type: CapabilitiesService }, { type: InboxService }, { type: PrepareService }, { type: BackendService }, { type: SystemService }, { type: UserService }, { type: EventService }, { type: SystemStatusService }, { type: i1$2.LocalStorage }, { type: LocalStorageService }]; } });
 
 /**
  * Main initialization service of the eoFrameworkCore module. The `load()` function will contain
@@ -4236,42 +4151,89 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
 
 /**
  * @ignore
- * logger logging values to the ambient console object.
+ * APP_INITIALIZER function
  */
-class ConsoleLogService {
-    apply(fn, args) {
-        return console && console[fn] && console[fn](...args);
-    }
-    assert(...args) {
-        this.apply('assert', args);
-    }
-    debug(...args) {
-        this.apply('debug', args);
-    }
-    error(...args) {
-        this.apply('error', args);
-    }
-    group(...args) {
-        this.apply('group', args);
-    }
-    groupEnd(...args) {
-        this.apply('groupEnd', args);
+function init_module(coreInit) {
+    // Need to set to a const before returning due to:
+    // @see: https://github.com/angular/angular/issues/14485
+    const fnc = () => coreInit.initialize();
+    return fnc;
+}
+
+/**
+ * @ignore
+ * Handles missing translations
+ */
+class EoxMissingTranslationHandler {
+    /**
+     *
+     * @param MissingTranslationHandlerParams params
+     * @returns string
+     */
+    handle(params) {
+        return '!missing key: ' + params.key;
     }
-    info(...args) {
-        this.apply('info', args);
+}
+
+/**
+ * @ignore
+ * Loader that fetches translations based on the configured locations
+ */
+let EoxTranslateJsonLoader = class EoxTranslateJsonLoader {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        registerLocaleData(localeDe, 'de', localeExtraDe); // German
+        registerLocaleData(localeAr, 'ar', localeExtraAr); // Arabic
+        registerLocaleData(localeEs, 'es', localeExtraEs); // Spanish
+        registerLocaleData(localePt, 'pt', localeExtraPt); // Portuguese
+        registerLocaleData(localeFr, 'fr', localeExtraFr); // French
+        registerLocaleData(localeZh, 'zh', localeExtraZh); // Chinese
+        registerLocaleData(localeLv, 'lv', localeExtraLv); // Latvian
+        registerLocaleData(localeRu, 'ru', localeExtraRu); // Russian
+        registerLocaleData(localeIt, 'it', localeExtraIt); // Italian
+        registerLocaleData(localeNl, 'nl', localeExtraNl); // Dutch
+        registerLocaleData(localeSk, 'sk', localeExtraSk); // Slovak
+        registerLocaleData(localePl, 'pl', localeExtraPl); // Polish
+        registerLocaleData(localeUk, 'uk', localeExtraUk); // Ukrainian
+        registerLocaleData(localeJa, 'ja', localeExtraJa); // Japanese
+        registerLocaleData(localeKo, 'ko', localeExtraKo); // Korean
+        registerLocaleData(localeHi, 'hi', localeExtraHi); // Hindi
+        registerLocaleData(localeBn, 'bn', localeExtraBn); // Bengalese
+        registerLocaleData(localeDeCh, 'de-CH', localeExtraDeCh); // German (switzerland)
+        registerLocaleData(localeZhHant, 'zh-Hant', localeExtraZhHant); // Chinese (traditional)
+        registerLocaleData(localeTh, 'th', localeExtraTh); // Thai
+        registerLocaleData(localeVi, 'vi', localeExtraVi); // Vietnamese
+        registerLocaleData(localeEnGb, 'en-GB', localeExtraEnGb); // English (Great-Britain)
+        registerLocaleData(localeHe, 'he', localeExtraHe); // Hebrew
+        registerLocaleData(localeFi, 'fi', localeExtraFi); // Finish
+        registerLocaleData(localeDa, 'da', localeExtraDa); // Danish
+        registerLocaleData(localeSe, 'se', localeExtraSe); // Swedish
+        registerLocaleData(localeNb, 'nb', localeExtraNb); // Norwegian Bokmål
+        registerLocaleData(localeNn, 'nn', localeExtraNn); // Norwegian Nynorsk
+        registerLocaleData(localeId, 'id', localeExtraId); // Indonesian
+        registerLocaleData(localeMs, 'ms', localeExtraMs); // Malay
     }
-    log(...args) {
-        this.apply('log', args);
+    /**
+     *
+     * @param string lang
+     * @returns Observable<Object>
+     */
+    getTranslation(lang) {
+        return forkJoin(this.config.translations.map(folder => this.loadTranslationFile(folder, lang))).pipe(map((res) => res.reduce((acc, x) => Object.assign(acc, x), {})));
     }
-    warn(...args) {
-        this.apply('warn', args);
+    loadTranslationFile(folder, lang) {
+        return this.http.get(`${folder}${lang}.json`).pipe(catchError((e) => {
+            // ISO codes with more than 2 characters are sub-languages like de-CH.
+            // If there is no translation file for that sub-language we'll try to load
+            // the file for the base language (in this case de).
+            return lang.length > 2 ? this.loadTranslationFile(folder, lang.substring(0, 2)) : of({});
+        }));
     }
-}
-ConsoleLogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ConsoleLogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService, decorators: [{
-            type: Injectable
-        }] });
+};
+EoxTranslateJsonLoader = __decorate([
+    __param(1, Inject(CORE_CONFIG))
+], EoxTranslateJsonLoader);
 
 /**
  * `EoSharedModule` re-exports ToastrModule, TranslateModule so you can use directives
@@ -4317,6 +4279,45 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
             type: Injectable
         }], ctorParameters: function () { return [{ type: AuthService }]; } });
 
+/**
+ * @ignore
+ * logger logging values to the ambient console object.
+ */
+class ConsoleLogService {
+    apply(fn, args) {
+        return console && console[fn] && console[fn](...args);
+    }
+    assert(...args) {
+        this.apply('assert', args);
+    }
+    debug(...args) {
+        this.apply('debug', args);
+    }
+    error(...args) {
+        this.apply('error', args);
+    }
+    group(...args) {
+        this.apply('group', args);
+    }
+    groupEnd(...args) {
+        this.apply('groupEnd', args);
+    }
+    info(...args) {
+        this.apply('info', args);
+    }
+    log(...args) {
+        this.apply('log', args);
+    }
+    warn(...args) {
+        this.apply('warn', args);
+    }
+}
+ConsoleLogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ConsoleLogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: ConsoleLogService, decorators: [{
+            type: Injectable
+        }] });
+
 /**
  * Main module for connecting an app to an yuuvis<sup>&reg;</sup> RAD backend. To use it just import int in your app module:
  *
@@ -4374,7 +4375,7 @@ class EoCoreModule {
     }
 }
 EoCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: EoCoreModule, deps: [{ token: EoCoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule });
-EoCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.2", ngImport: i0, type: EoCoreModule, imports: [HttpClientModule, i2.TranslateModule, i1$2.ToastrModule], exports: [EoSharedModule] });
+EoCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.2", ngImport: i0, type: EoCoreModule, imports: [HttpClientModule, i1.TranslateModule, i1$3.ToastrModule], exports: [EoSharedModule] });
 EoCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: EoCoreModule, providers: [
         {
             /**
@@ -5048,22 +5049,20 @@ class DmsService {
         }));
     }
     /**
-     * Setter for Organization Objects With Read Rights
-     *
-     * @param DmsObject[] dmsObjects
-     * @param string[] orgaNames
-     * @param string[] orgaNameWithChildren
-     * @param id
-     * @returns Observable<any>
+     * Shares a dms object (and its children) with certain users
+     * @param dmsObject The dms object to be shared
+     * @param shareWith Array of organization objects to share the object with. Each entry
+     * will have the ID of the target organization object as well as an optional param
+     * whether or not to also share the dms objects children.
+     * @returns Observable being resolved once the request is done
      */
-    setOrganizationObjectsWithReadRights(dmsObjects, id, orgaNames, orgaNameWithChildren) {
-        const url = `/dms/${id}/share`;
-        const shares = [
-            ...orgaNameWithChildren.map(field => ({ organizationobject: field, sharechildren: true })),
-            ...orgaNames.map(name => ({ organizationobject: name, sharechildren: false }))
-        ];
-        const data = { shares };
-        return this.triggerUpdate(dmsObjects[0], this.backend.put(url, data));
+    share(dmsObject, shareWith) {
+        return this.triggerUpdate(dmsObject, this.backend.put(`/dms/${dmsObject.id}/share`, {
+            shares: shareWith.map(i => ({
+                organizationobject: i.id,
+                sharechildren: !!i.shareChildren
+            }))
+        }));
     }
     /**
      * Move a DMS Object
@@ -5301,14 +5300,14 @@ class NotificationsService {
         }
     }
 }
-NotificationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: NotificationsService, deps: [{ token: i1$2.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: NotificationsService, deps: [{ token: i1$3.ToastrService }], target: i0.ɵɵFactoryTarget.Injectable });
 NotificationsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: NotificationsService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: NotificationsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i1$2.ToastrService }]; } });
+        }], ctorParameters: function () { return [{ type: i1$3.ToastrService }]; } });
 
 /**
  * Collection of Search Services
@@ -6132,10 +6131,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
  * Collection of Signing Services
  */
 class SigningService {
-    constructor(backend, translate) {
+    constructor(backend, capabilities, translate) {
         this.backend = backend;
+        this.capabilities = capabilities;
         this.translate = translate;
     }
+    canSign() {
+        return this.capabilities.getCapabilities().signing;
+    }
     /**
      * Sign the document of a DMS Object
      * @param id the id of the dms object
@@ -6144,7 +6147,7 @@ class SigningService {
      */
     signDocument(id, signingData) {
         const uri = `/request/${id}`;
-        return this.backend.post(uri, signingData, '/signing');
+        return this.canSign ? this.backend.post(uri, signingData, '/signing') : of(null);
     }
     /**
      * Cancels the signing process of a DMS Object
@@ -6231,14 +6234,14 @@ class SigningService {
         return item.data.yuvsigstatus === 'inprocess';
     }
 }
-SigningService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SigningService, deps: [{ token: BackendService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+SigningService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SigningService, deps: [{ token: BackendService }, { token: CapabilitiesService }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
 SigningService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SigningService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SigningService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: BackendService }, { type: i2.TranslateService }]; } });
+        }], ctorParameters: function () { return [{ type: BackendService }, { type: CapabilitiesService }, { type: i1.TranslateService }]; } });
 
 class UploadFileItem {
     /**