@eo-sdk/client 10.0.0-beta.5 → 10.0.0-rc.2

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

@@ -1,21 +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 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$2 from 'ngx-toastr';
+import * as i1$3 from 'ngx-toastr';
 import { ToastrModule } from 'ngx-toastr';
 import { __decorate, __param } from 'tslib';
 import { EMPTY, throwError, Subject, of, forkJoin, Observable, ReplaySubject, BehaviorSubject, timer, interval } from 'rxjs';
-import { filter, debounceTime, switchMap, map, first, tap, finalize, shareReplay, catchError, expand, skipWhile, mergeMap, takeUntil } from 'rxjs/operators';
-import * as i6 from '@angular/common';
+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 i1 from '@ngx-pwa/local-storage';
-import * as FileSaver from 'file-saver';
 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';
@@ -1216,14 +1215,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 {
     /**
@@ -1311,124 +1322,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
  */
@@ -1586,60 +1479,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 {
-    /**
-     * @ignore
-     */
-    constructor() {
-    }
-    /**
-     * 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;
-    }
+class ObjectType {
     /**
-     * Getter for the Capabilities
+     * Creates a new instance
+     * @param json The JSON object received from the backend. This will be used to construct the new object type instance
      */
-    getCapabilities() {
-        return this.capabilities;
+    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);
     }
-    /**
-     * 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
 /**
@@ -1990,218 +1866,713 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
     } });
 
 /**
- * Items emitted by the inbox service
+ * 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 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;
+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));
     }
     /**
-     * Determines whether or not the inbox item is overdue
-     * @returns True when inbox item is overdue, false otherwise
+     * 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
      */
-    isOverdue() {
-        return this.duetime && moment(this.duetime).isBefore(moment());
-    }
-}
-InboxItem.TYPE_BPM = 'BPM';
-InboxItem.TYPE_RESUBMISSION = 'RESUBMISSION';
-InboxItem.TYPE_SUBSCRIPTION = 'SUBSCRIPTION';
-
-/**
- * InboxService handles interaction with the inbox service on the backend side.
- */
-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);
-    }
-    /**
-     * Fetches inbox items from the backend.
-     *
-     * @returns Observable of inbox items.
-     */
-    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();
+        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));
     }
     /**
-     * Retrieve all processes of the current user.
+     * Gets all ObjectTypes
      *
-     * @param size Maximum number of processes to be fetched
-     * @returns List of Processes
+     * @returns An array containing all object types
      */
-    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);
-        }));
+    getObjectTypes() {
+        return this.system.types;
     }
     /**
-     * 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
+     * Gets an ObjectType by name.
+     *
+     * @param objectTypeName The name of the object type
+     * @returns the ObjectType matching the given name
      */
-    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([]);
-        }
-    }
-    initExecutableProcesses() {
-        let uri = '/bpm/process/executable';
-        return this.backend.get(uri).pipe(tap(res => this.hasMainExecutableProcesses = res === null || res === void 0 ? void 0 : res.length));
+    getObjectType(objectTypeName) {
+        return this.system.types.find(t => t.name === objectTypeName);
     }
     /**
-     * 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
+     * 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
      */
-    getExecutableProcessesForDmsObjects(dmsObjects) {
-        return this.getExecutableProcesses(dmsObjects.map(o => o.typeName), false, true);
+    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);
+            }
+        });
     }
     /**
-     * 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
+     * Checks whether or not the given type implements a given supertype
+     * @param type Type to be checked
+     * @param superTypeName Name of the supertype
      */
-    fetchExecutableProcesses(types, additionalData, modelid, global) {
+    implementsType(type, superTypeName) {
+        return type.name === superTypeName || (type.implements && type.implements.indexOf(superTypeName) !== -1);
+    }
+    /**
+     * Gets a codesystem
+     *
+     * @param id The codesystems id
+     * @returns The codesystem object matching the given id
+     */
+    getCodesystem(id) {
+        return this.system.codesystems.find(t => t.id === id || t.name === id);
+    }
+    /**
+     * 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
+     */
+    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)))));
+        }
+    }
+    /**
+     * 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
+     */
+    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);
+        //     }
+        //   });
+    }
+    /**
+     * Creates a value depending on a given Type
+     *
+     * @param string valueType
+     * @returns any
+     */
+    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;
+    }
+    /**
+     * 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
+     */
+    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;
+        }));
+    }
+    /**
+     * Retrieve an organization object by its ID
+     * @param id ID of org object
+     */
+    getOrganizationObjectById(id) {
+        return this.backend.getJson(`/organization/id/${id}`);
+    }
+    /**
+     * Fetches the organization object for a given name.
+     *
+     * @param name The name to fetch object for
+     * @returns
+     */
+    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 this.backend
+                .get('/organization/role')
+                .pipe(map(o => o), tap(roles => (this.cachedRoles = roles)));
+        }
+    }
+}
+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 }]; } });
+
+/**
+ * Handles the systems capabilities. Capabilities are settings that enable/disable certain client features.
+ */
+class CapabilitiesService {
+    /**
+     * @ignore
+     */
+    constructor(system) {
+        this.system = system;
+    }
+    /**
+     * 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 Object.assign(Object.assign({}, this.capabilities), { signing: !!this.system.getObjectType('yuvsigning') });
+    }
+    /**
+     * 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];
+    }
+}
+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 }]; } });
+
+/**
+ * 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(this.duetime).isBefore(moment());
+    }
+}
+InboxItem.TYPE_BPM = 'BPM';
+InboxItem.TYPE_RESUBMISSION = 'RESUBMISSION';
+InboxItem.TYPE_SUBSCRIPTION = 'SUBSCRIPTION';
+
+/**
+ * InboxService handles interaction with the inbox service on the backend side.
+ */
+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);
+    }
+    /**
+     * Fetches inbox items from the backend.
+     *
+     * @returns Observable of inbox items.
+     */
+    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());
+    }
+    /**
+     * Fetches state informations for the users inbox
+     *
+     * @returns inbox state object
+     */
+    getState() {
+        return this.inboxState;
+    }
+    /**
+     * Public access to fetch inbox
+     */
+    refreshInboxState() {
+        this.fetchInboxState();
+    }
+    /**
+     * Retrieve inbox state
+     */
+    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!'));
+    }
+    /**
+     * 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)));
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * 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 {
+            return of([]);
+        }
+    }
+    initExecutableProcesses() {
+        let uri = '/bpm/process/executable';
+        return this.backend.get(uri).pipe(tap(res => this.hasMainExecutableProcesses = res === null || res === void 0 ? void 0 : res.length));
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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
+     */
+    fetchExecutableProcesses(types, additionalData, modelid, global) {
         let uri = '/bpm/process/executable';
         if (additionalData) {
             uri += '?form=true&fields=true';
@@ -2259,610 +2630,239 @@ class BpmService {
      * @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);
-            }
-            else {
-                contents = clipboard.elements;
-            }
-            return this.addFileElements(workItem.processId, workItem.id, contents);
-        }
-        else {
-            return throwError('error');
-        }
-    }
-}
-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 an object type. Object types are defined with the system definition and describe
- * different kind of objects that allowed to be created.
- */
-class ObjectType {
-    /**
-     * 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(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 : '';
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Retrieves the prepared items selected type object from the list
-     * of available types.
-     * @returns The type object that is selected or NULL
-     */
-    getSelectedTypeObject() {
-        return this.types.find(t => t.selected);
-    }
-}
-
-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;
-    }
-    /**
-     * Return Method if the Upload is Successfull
-     *
-     * @param target
-     * @returns the provided UploadTarget if the Upload was Successfull.
+     * @returns a WorkItem
      */
-    onUploadSuccess(target) {
-        return target;
+    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;
+        }));
     }
     /**
-     * Return method if the Upload fails
-     *
-     * @returns an empty Object if the Upload fails
+     * Saves a work item.
+     * @param item The work item to be saved
+     * @returns The updated WorkItem
      */
-    onUploadFail() {
-        return {};
-    }
-}
-/**
- * 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 = {}));
-
-/**
- * Collection of System Services
- */
-class SystemService {
-    constructor(backend, logger, eventService, appCache) {
-        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));
+    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)));
     }
     /**
-     * Gets all ObjectTypes
-     *
-     * @returns An array containing all object types
+     * 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
      */
-    getObjectTypes() {
-        return this.system.types;
+    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)));
     }
     /**
-     * Gets an ObjectType by name.
-     *
-     * @param objectTypeName The name of the object type
-     * @returns the ObjectType matching the given name
+     * 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
      */
-    getObjectType(objectTypeName) {
-        return this.system.types.find(t => t.name === objectTypeName);
+    lockWorkItem(item) {
+        return this.backend.put(`/bpm/process/${item.processId}/${item.id}/lock`)
+            .pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
     }
     /**
-     * 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
+     * Releases the lock for a WorkItem.
+     * @param item The work item to be unlocked
+     * @returns The updated WorkItem
      */
-    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);
-            }
-        });
+    unlockWorkItem(item) {
+        return this.backend.del(`/bpm/process/${item.processId}/${item.id}/lock`).pipe(mergeMap(() => this.getWorkItem(item.processId, item.id)));
     }
     /**
-     * Checks whether or not the given type implements a given supertype
-     * @param type Type to be checked
-     * @param superTypeName Name of the supertype
+     * 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).
      */
-    implementsType(type, superTypeName) {
-        return type.name === superTypeName || (type.implements && type.implements.indexOf(superTypeName) !== -1);
+    startProcess(executableProcessId, data, contents) {
+        return this.backend.post(`/bpm/process/?modelid=${executableProcessId}`, {
+            data: data,
+            contents: contents
+        });
     }
     /**
-     * Gets a codesystem
-     *
-     * @param id The codesystems id
-     * @returns The codesystem object matching the given id
+     * 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[]>
      */
-    getCodesystem(id) {
-        return this.system.codesystems.find(t => t.id === id || t.name === id);
+    getProcessHistory(processId) {
+        return this.backend
+            .getJson(`/bpm/process/${processId}/history`)
+            .pipe(map(res => res && res.length ? res.map(item => new WorkItemHistoryEntry(item)) : []));
     }
     /**
-     * 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
+     * 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
      */
-    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)))));
-        }
+    removeFileElement(processId, workItemId, workItemContentId) {
+        return this.backend
+            .del(`/process/${processId}/file/${workItemContentId}?activityid=${workItemId}`, this.backend.getBpmBase());
     }
     /**
-     * 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
+     * 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
      */
-    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);
-        //     }
-        //   });
+    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)));
     }
     /**
-     * Creates a value depending on a given Type
-     *
-     * @param string valueType
-     * @returns any
+     * 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
      */
-    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;
+    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 : '';
     }
     /**
-     * Retrieve an organization object by its ID
-     * @param id ID of org object
+     * Creates a new instance
+     * @param json The JSON object received from the backend. This will be used to construct the new prepared item instance
      */
-    getOrganizationObjectById(id) {
-        return this.backend.getJson(`/organization/id/${id}`);
+    constructor(json) {
+        Object.assign(this, json);
     }
     /**
-     * Fetches the organization object for a given name.
+     * Returns true if the preparedItem contains content (template or actual file), false otherwise
+     */
+    hasContent() {
+        return !!this.template || this.contentcount > 0;
+    }
+    /**
+     * Retrieves the prepared items selected type object from the list
+     * of available types.
+     * @returns The type object that is selected or NULL
+     */
+    getSelectedTypeObject() {
+        return this.types.find(t => t.selected);
+    }
+}
+
+class UploadTarget {
+    /**
+     * 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.
@@ -3192,15 +3192,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)
@@ -3746,17 +3756,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;
@@ -4065,7 +4072,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,
@@ -4076,7 +4083,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImpor
         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 }];
     } });
 
 /**
@@ -4368,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: [
         {
             /**
@@ -5290,14 +5297,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
@@ -6115,10 +6122,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
@@ -6127,7 +6138,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
@@ -6214,14 +6225,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 {
     /**