@eo-sdk/client 10.7.0-rc.5 → 11.0.0-beta.1

package/esm2022/app/eo-framework-core/api/plugins.service.mjs

@@ -0,0 +1,258 @@
+import { map } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import { DmsObject, Utils, EnaioEvent } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@eo-sdk/core";
+import * as i2 from "@angular/router";
+import * as i3 from "../agent/agent.service";
+export const UNDOCK_WINDOW_NAME = 'eoViewer';
+export class PluginsService {
+    get currentUrl() {
+        return this.router.url;
+    }
+    get api() {
+        return this.getApi();
+    }
+    applyFunction(value, params, args) {
+        const fnc = value?.toString().trim();
+        if (!fnc)
+            return;
+        const f = fnc.match(/^function|^\(.*\)\s*=>/)
+            ? `return (${fnc}).apply(this,arguments)`
+            : typeof value === 'string' && !fnc.startsWith("'")
+                ? `return '${fnc}'`
+                : `return ${fnc}`;
+        try {
+            return new Function(...(params || 'api').split(',').map((a) => a.trim()), f).apply(this.api, args || [this.api]);
+        }
+        catch (e) {
+            console.error(e);
+            return;
+        }
+    }
+    constructor(backend, notifications, clipboard, logger, translate, dmsService, router, agentService, eventService, userService, appRef, ngZone) {
+        this.backend = backend;
+        this.notifications = notifications;
+        this.clipboard = clipboard;
+        this.logger = logger;
+        this.translate = translate;
+        this.dmsService = dmsService;
+        this.router = router;
+        this.agentService = agentService;
+        this.eventService = eventService;
+        this.userService = userService;
+        this.appRef = appRef;
+        this.ngZone = ngZone;
+        this.agentAction = {
+            OPEN: 'eo.agent.action.open',
+            MAIL: 'eo.agent.action.mail',
+            MAIL_AS_PDF: 'eo.agent.action.mail-pdf',
+            CLIPBOARD: 'eo.agent.action.clipboard',
+            CLIPBOARD_AS_PDF: 'eo.agent.action.clipboard-pdf',
+            EXTERNAL: 'eo.agent.action.external'
+        };
+        window['api'] = this.api;
+        this.userService
+            .user$
+            .subscribe((user) => this.user = user);
+    }
+    // todo: create inreface for API
+    getApi() {
+        return {
+            detectChanges: () => {
+                setTimeout(() => {
+                    this.appRef.tick();
+                }, 500);
+            },
+            router: {
+                get: () => this.router
+            },
+            events: {
+                enaioEventType: EnaioEvent,
+                on: (type) => this.ngZone.run(() => this.eventService.on(type)),
+                trigger: (type, data) => this.ngZone.run(() => this.eventService.trigger(type, data))
+            },
+            session: {
+                getUser: () => this.getCurrentUser()
+            },
+            dms: {
+                getObject: (id, type, version) => this.getDmsObject(id, type, version),
+                getResult: (fields, type) => this.getResult(fields, type),
+                downloadContent: (dmsObjects, rendition) => this.backend.downloadContent(dmsObjects, rendition)
+            },
+            http: {
+                get: (uri, base, options) => this.get(uri, base, options),
+                post: (uri, data, base, options) => this.post(uri, data, base, options),
+                del: (uri, base, options) => this.del(uri, base, options),
+                put: (uri, data, base, options) => this.put(uri, data, base, options)
+            },
+            config: {
+                get: () => this.getConfig()
+            },
+            content: {
+                viewer: () => window[UNDOCK_WINDOW_NAME] || (window.document.querySelector('eo-media iframe[src]') || {})['contentWindow'],
+                triggerError: (err, win, parameters) => this.ngZone.run(() => this.eventService.trigger(UNDOCK_WINDOW_NAME + 'Error', { err, win, parameters })),
+                catchError: () => this.ngZone.run(() => this.eventService.on(UNDOCK_WINDOW_NAME + 'Error'))
+            },
+            util: {
+                $: (selectors, element) => (element || window.document).querySelector(selectors),
+                $$: (selectors, element) => (element || window.document).querySelectorAll(selectors),
+                styles: (styles, id = '__styles', win = window) => {
+                    let s = win.document.head.querySelector('#' + id);
+                    if (!s) {
+                        s = win.document.createElement('style');
+                        s.setAttribute('id', id);
+                        win.document.head.appendChild(s);
+                    }
+                    s.innerHTML = styles;
+                },
+                translate: (key, data) => this.translate.instant(key, data),
+                encodeFileName: (filename) => this.encodeFileName(filename),
+                decodeHtmlCharCodes: (filename) => this.decodeHtmlCharCodes(filename),
+                notifier: {
+                    success: (text, title) => this.notifications.success(title, text),
+                    error: (text, title) => this.notifications.error(title, text),
+                    info: (text, title) => this.notifications.info(title, text),
+                    warning: (text, title) => this.notifications.warning(title, text)
+                }
+            },
+            clipboard: {
+                set: (elements, action) => this.clipboard.set(elements, action),
+                get: () => this.clipboard.get(),
+                clear: () => this.clipboard.clear()
+            },
+            // Agent
+            agent: {
+                getAvailability: () => this.getAgentAvailability(),
+                executeAction: (action, args) => this.executeAgentAction(action, args),
+                action: this.agentAction
+            }
+        };
+    }
+    getAgentAvailability() {
+        return new Promise((resolve, reject) => {
+            if (this.agentService.isConnected) {
+                resolve(this.agentService.agentAvailability.CONNECTED);
+            }
+            else {
+                resolve(this.agentService.agentAvailability.UNAVAILABLE);
+            }
+        });
+    }
+    executeAgentAction(action, args) {
+        switch (action) {
+            case this.agentAction.CLIPBOARD:
+                this.agentService.copyToClipboard(args);
+                break;
+            case this.agentAction.CLIPBOARD_AS_PDF:
+                this.agentService.copyToClipboard(args);
+                break;
+            case this.agentAction.EXTERNAL:
+                if (!args.executable) {
+                    this.logger.error('Missing field args.executable');
+                }
+                else if ((args.args && args.args.length === 0) && !Array.isArray(args.args)) {
+                    this.logger.error('Field args.args must be empty or array.');
+                }
+                else {
+                    this.agentService.sendExternalAction(args.executable, args.args || []);
+                }
+                break;
+            case this.agentAction.MAIL:
+            case this.agentAction.MAIL_AS_PDF:
+                this.agentService.sendAsMail(args);
+                break;
+            case this.agentAction.OPEN:
+                this.agentService.openDocument(args, args.lock);
+                break;
+            default:
+                break;
+        }
+    }
+    get(uri, base = '', options) {
+        return this.backend
+            .get(uri, this.backend.getHost() + base, options || { observe: 'response' }).pipe(map((res) => {
+            return options ? res : { status: res.status, data: res.body };
+        })).toPromise();
+    }
+    put(uri, data, base = '', options) {
+        return this.backend.put(uri, data, this.backend.getHost() + base, options).toPromise();
+    }
+    post(uri, data, base = '', options) {
+        return this.backend.post(uri, data, this.backend.getHost() + base, options).toPromise();
+    }
+    del(uri, base = '', options) {
+        return this.backend.del(uri, this.backend.getHost() + base, options).toPromise();
+    }
+    getCurrentUser() {
+        return this.user;
+    }
+    encodeFileName(filename) {
+        return Utils.encodeFileName(filename);
+    }
+    decodeHtmlCharCodes(str) {
+        return str.replace(/(&#(\d+);)/g, (match, capture, charCode) => String.fromCharCode(charCode));
+    }
+    getConfig() {
+        return {
+            serviceBase: this.backend.getServiceBase()
+            // todo: do we have to provide the plugin developers with these informations?
+            // after speaking to Andreas also removed from documentation
+            // pluginsBase: $eoConfig.getPluginBase(),
+            // pluginStatesBase: $eoConfig.getPluginStatesBase(),
+            // themeBase: $eoConfig.getThemeBase()
+        };
+    }
+    /**
+     * fetches dms objects from the server that match the given params
+     *
+     * @param fields - the fields to matched. example: {name: 'max', plz: '47111}
+     * @param type - the target object type
+     *
+     * @returns which will be resolved by an array of DmsObjects matching the given params
+     */
+    getResult(fields, type) {
+        let q = Object.keys(fields).filter(k => (fields[k] !== undefined && fields[k] !== null)).map(k => k + '=' + fields[k]).join(';');
+        return this.backend
+            .getJson(`/result/query?query=${encodeURIComponent(q)}&type=${type}`)
+            .toPromise()
+            .then((response) => {
+            let resObjects = [];
+            for (let item of response) {
+                resObjects.push(new DmsObject(item));
+            }
+            return Promise.resolve(resObjects);
+        })
+            .catch(this.handleError);
+    }
+    /**
+     * Loads a DMS object from the backend.
+     *
+     * @param id - The id of the DMS-Object to be fetched.
+     * @param [type] - The object type of the selected DMS-Object. Will improve performance if set.
+     * @param [version] - retrieve a specific version of the dms object
+     * @param [intent] - used for server side logging. If you provide an intent, the
+     *
+     * @returns which will be resolved by the DMS object fetched from the server
+     */
+    getDmsObject(id, type, version, intent) {
+        return this.dmsService.getDmsObject(id, type, version, intent)
+            .toPromise()
+            .then(response => {
+            return Promise.resolve(response);
+        })
+            .catch(this.handleError);
+    }
+    handleError(error) {
+        return Promise.reject(error.message || error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PluginsService, deps: [{ token: i1.BackendService }, { token: i1.NotificationsService }, { token: i1.ClipboardService }, { token: i1.Logger }, { token: i1.TranslateService }, { token: i1.DmsService }, { token: i2.Router }, { token: i3.AgentService }, { token: i1.EventService }, { token: i1.UserService }, { token: i0.ApplicationRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PluginsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: PluginsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.BackendService }, { type: i1.NotificationsService }, { type: i1.ClipboardService }, { type: i1.Logger }, { type: i1.TranslateService }, { type: i1.DmsService }, { type: i2.Router }, { type: i3.AgentService }, { type: i1.EventService }, { type: i1.UserService }, { type: i0.ApplicationRef }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugins.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/api/plugins.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {map} from 'rxjs/operators';\nimport {ApplicationRef, Injectable, NgZone} from '@angular/core';\nimport {Router} from '@angular/router';\nimport {AgentService} from '../agent/agent.service';\nimport {\n  EoUser, Logger, NotificationsService, BackendService, ClipboardService,\n  DmsService, EventService, UserService, DmsObject, ClipboardAction, Utils,\n  TranslateService, HttpOptions, EnaioEvent\n} from '@eo-sdk/core';\n\ndeclare global {\n  interface Window { api: any; }\n}\n\nexport const UNDOCK_WINDOW_NAME = 'eoViewer';\n@Injectable({\n  providedIn: 'root'\n})\nexport class PluginsService {\n\n  private user: EoUser;\n  private agentAction = {\n    OPEN: 'eo.agent.action.open',\n    MAIL: 'eo.agent.action.mail',\n    MAIL_AS_PDF: 'eo.agent.action.mail-pdf',\n    CLIPBOARD: 'eo.agent.action.clipboard',\n    CLIPBOARD_AS_PDF: 'eo.agent.action.clipboard-pdf',\n    EXTERNAL: 'eo.agent.action.external'\n  };\n\n  public get currentUrl() {\n    return this.router.url;\n  }\n\n  public get api() {\n    return this.getApi();\n  }\n\n  public applyFunction(value: string | Function | any, params?: string, args?: any) {\n    const fnc = value?.toString().trim();\n    if (!fnc) return;\n    const f = fnc.match(/^function|^\\(.*\\)\\s*=>/)\n      ? `return (${fnc}).apply(this,arguments)`\n      : typeof value === 'string' && !fnc.startsWith(\"'\")\n      ? `return '${fnc}'`\n      : `return ${fnc}`;\n      try {\n        return new Function(...(params || 'api').split(',').map((a) => a.trim()), f).apply(this.api, args || [this.api]);\n      } catch(e) {\n        console.error(e);\n        return;\n      }\n  }\n\n  constructor(private backend: BackendService,\n    private notifications: NotificationsService,\n    private clipboard: ClipboardService,\n    private logger: Logger,\n    public translate: TranslateService,\n    private dmsService: DmsService,\n    private router: Router,\n    private agentService: AgentService,\n    private eventService: EventService,\n    private userService: UserService,\n    private appRef: ApplicationRef,\n    private ngZone: NgZone) {\n\n    window['api'] = this.api;\n\n    this.userService\n      .user$\n      .subscribe((user) => this.user = user);\n  }\n\n  // todo: create inreface for API\n\n  public getApi(): any {\n    return {\n      detectChanges: () => {\n        setTimeout(() => {\n          this.appRef.tick();\n        }, 500);\n      },\n      router: {\n        get: () => this.router\n      },\n      events: {\n        enaioEventType: EnaioEvent,\n        on: (type: string) => this.ngZone.run(() => this.eventService.on(type)),\n        trigger: (type: string, data?: any) => this.ngZone.run(() => this.eventService.trigger(type, data))\n      },\n      session: {\n        getUser: () => this.getCurrentUser()\n      },\n      dms: {\n        getObject: (id, type, version) => this.getDmsObject(id, type, version),\n        getResult: (fields, type) => this.getResult(fields, type),\n        downloadContent: (dmsObjects: DmsObject[], rendition?: 'PDF'\n          | 'TIFF'\n          | 'TEXT'\n          | 'JPEG') => this.backend.downloadContent(dmsObjects, rendition)\n      },\n      http: {\n        get: (uri, base, options) => this.get(uri, base, options),\n        post: (uri, data, base, options) => this.post(uri, data, base, options),\n        del: (uri, base, options) => this.del(uri, base, options),\n        put: (uri, data, base, options) => this.put(uri, data, base, options)\n      },\n      config: {\n        get: () => this.getConfig()\n      },\n      content: {\n        viewer: () => window[UNDOCK_WINDOW_NAME] || (window.document.querySelector('eo-media iframe[src]') || {})['contentWindow'],\n        triggerError: (err, win, parameters) => this.ngZone.run(() => this.eventService.trigger(UNDOCK_WINDOW_NAME + 'Error', { err, win, parameters })),\n        catchError: () => this.ngZone.run(() => this.eventService.on(UNDOCK_WINDOW_NAME + 'Error'))\n      },\n      util: {\n        $: (selectors, element) => (element || window.document).querySelector(selectors),\n        $$: (selectors, element) => (element || window.document).querySelectorAll(selectors),\n        styles: (styles, id = '__styles', win: any = window) => {\n          let s = win.document.head.querySelector('#' + id);\n          if (!s) {\n            s = win.document.createElement('style');\n            s.setAttribute('id', id);\n            win.document.head.appendChild(s);\n          }\n          s.innerHTML = styles;\n        },\n        translate: (key, data) => this.translate.instant(key, data),\n        encodeFileName: (filename) => this.encodeFileName(filename),\n        decodeHtmlCharCodes: (filename) => this.decodeHtmlCharCodes(filename),\n        notifier: {\n          success: (text, title) => this.notifications.success(title, text),\n          error: (text, title) => this.notifications.error(title, text),\n          info: (text, title) => this.notifications.info(title, text),\n          warning: (text, title) => this.notifications.warning(title, text)\n        }\n      },\n      clipboard: {\n        set: (elements: DmsObject[], action: ClipboardAction) => this.clipboard.set(elements, action),\n        get: () => this.clipboard.get(),\n        clear: () => this.clipboard.clear()\n      },\n      // Agent\n      agent: {\n        getAvailability: () => this.getAgentAvailability(),\n        executeAction: (action, args) => this.executeAgentAction(action, args),\n        action: this.agentAction\n      }\n    };\n  }\n\n\n  public getAgentAvailability(): Promise<string> {\n    return new Promise((resolve, reject) => {\n      if (this.agentService.isConnected) {\n        resolve(this.agentService.agentAvailability.CONNECTED);\n      } else {\n        resolve(this.agentService.agentAvailability.UNAVAILABLE);\n      }\n    });\n  }\n\n  public executeAgentAction(action, args) {\n\n    switch (action) {\n      case this.agentAction.CLIPBOARD:\n        this.agentService.copyToClipboard(args);\n        break;\n      case this.agentAction.CLIPBOARD_AS_PDF:\n        this.agentService.copyToClipboard(args);\n        break;\n      case this.agentAction.EXTERNAL:\n        if (!args.executable) {\n          this.logger.error('Missing field args.executable');\n        } else if ((args.args && args.args.length === 0) && !Array.isArray(args.args)) {\n          this.logger.error('Field args.args must be empty or array.');\n        } else {\n          this.agentService.sendExternalAction(args.executable, args.args || []);\n        }\n        break;\n      case this.agentAction.MAIL:\n      case this.agentAction.MAIL_AS_PDF:\n        this.agentService.sendAsMail(args);\n        break;\n      case this.agentAction.OPEN:\n        this.agentService.openDocument(args, args.lock);\n        break;\n      default:\n        break;\n    }\n  }\n\n  public get(uri, base = '', options?: HttpOptions) {\n    return this.backend\n      .get(uri, this.backend.getHost() + base, options || {observe: 'response'}).pipe(\n        map((res: any) => {\n          return options ? res : { status: res.status, data: res.body };\n        })).toPromise();\n  }\n\n  public put(uri, data, base = '', options?: HttpOptions) {\n    return this.backend.put(uri, data, this.backend.getHost() + base, options).toPromise();\n  }\n\n  public post(uri, data, base = '', options?: HttpOptions) {\n    return this.backend.post(uri, data, this.backend.getHost() + base, options).toPromise();\n  }\n\n  public del(uri, base = '', options?: HttpOptions) {\n    return this.backend.del(uri, this.backend.getHost() + base, options).toPromise();\n  }\n\n  public getCurrentUser(): EoUser {\n    return this.user;\n  }\n\n  public encodeFileName(filename) {\n    return Utils.encodeFileName(filename);\n  }\n\n  public decodeHtmlCharCodes(str) { \n    return str.replace(/(&#(\\d+);)/g, (match, capture, charCode) => String.fromCharCode(charCode));\n  }\n\n  public getConfig() {\n    return {\n      serviceBase: this.backend.getServiceBase()\n\n      // todo: do we have to provide the plugin developers with these informations?\n      // after speaking to Andreas also removed from documentation\n      // pluginsBase: $eoConfig.getPluginBase(),\n      // pluginStatesBase: $eoConfig.getPluginStatesBase(),\n      // themeBase: $eoConfig.getThemeBase()\n    };\n  }\n\n  /**\n   * fetches dms objects from the server that match the given params\n   *\n   * @param fields - the fields to matched. example: {name: 'max', plz: '47111}\n   * @param type - the target object type\n   *\n   * @returns which will be resolved by an array of DmsObjects matching the given params\n   */\n  public getResult(fields, type): Promise<DmsObject[]> {\n\n    let q = Object.keys(fields).filter(k => (fields[k] !== undefined && fields[k] !== null)).map(k => k + '=' + fields[k]).join(';');\n\n    return this.backend\n      .getJson(`/result/query?query=${encodeURIComponent(q)}&type=${type}`)\n      .toPromise()\n      .then((response: any) => {\n        let resObjects = [];\n        for (let item of response) {\n          resObjects.push(new DmsObject(item));\n        }\n        return Promise.resolve(resObjects);\n      })\n      .catch(this.handleError);\n  }\n\n  /**\n   * Loads a DMS object from the backend.\n   *\n   * @param id - The id of the DMS-Object to be fetched.\n   * @param [type] - The object type of the selected DMS-Object. Will improve performance if set.\n   * @param [version] - retrieve a specific version of the dms object\n   * @param [intent] - used for server side logging. If you provide an intent, the\n   *\n   * @returns which will be resolved by the DMS object fetched from the server\n   */\n  public getDmsObject(id, type, version, intent?): Promise<DmsObject> {\n\n    return this.dmsService.getDmsObject(id, type, version, intent)\n      .toPromise()\n      .then(response => {\n        return Promise.resolve(response);\n      })\n      .catch(this.handleError);\n  }\n\n  private handleError(error: any): Promise<any> {\n    return Promise.reject(error.message || error);\n  }\n}\n"]}

package/esm2022/app/eo-framework-core/empty-state/empty-state.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Handles empty states. Empty states are special objects that can be passed to some
+ * components indicating an empty state (error while fetching data, empty data, ...)
+ */
+export class EmptyStateService {
+    constructor() {
+    }
+    /**
+     * Creates a new EmptyState.
+     * @param listSize The number of items inside the lists result set (if)
+     * @param message Optional message to be displayed
+     * @param icon If a special icon should be used provide its uri here otherwise
+     * the default icons will be used
+     * @returns an empty state or null in case of a listSize > 0
+     */
+    getEmptyState(listSize, message, icon) {
+        if (listSize === -1) {
+            // error while fetching data
+            return {
+                icon: icon || 'ic_error.svg',
+                text: message || '',
+                className: 'error'
+            };
+        }
+        else if (listSize === 0) {
+            // empty result
+            return {
+                icon: icon || 'ic_no-file.svg',
+                text: message || '',
+                className: 'empty'
+            };
+        }
+        else {
+            // no empty state
+            return EmptyStateService.defaultEmptyState();
+        }
+    }
+    static defaultEmptyState() {
+        return {
+            icon: undefined,
+            text: undefined,
+            className: undefined
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EmptyStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EmptyStateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EmptyStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/eo-framework-core/eo-framework-core.module.mjs

@@ -0,0 +1,105 @@
+import { ErrorHandler, NgModule, Optional, SkipSelf } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { AppSearchService } from './search/app-search.service';
+import { LocationService } from './location/location.service';
+import { SelectionService } from './selection/selection.service';
+import { PluginsService } from './api/plugins.service';
+import { GridService } from './api/grid.service';
+import { LayoutService } from './layout/layout.service';
+import { AgentService } from './agent/agent.service';
+import { ReferenceService } from './references/reference.service';
+import { PendingChangesGuard } from './pending-changes/pending-changes-guard.service';
+import { PendingChangesService } from './pending-changes/pending-changes.service';
+import { ErrorHandlerService } from './error-handler/error-handler.service';
+import { EmptyStateService } from './empty-state/empty-state.service';
+import { AuthGuard } from './route-guards/auth/auth-guard.service';
+import { CapabilitiesGuard } from './route-guards/capabilities/capabilities-guard.service';
+import { PageTitleService } from './title/page-title.service';
+import { UploadOverlayGuard } from '../eo-framework/upload-overlay/upload-overlay-guard.service';
+import * as i0 from "@angular/core";
+export class EoFrameworkCoreModule {
+    static forRoot() {
+        return {
+            ngModule: EoFrameworkCoreModule,
+            providers: []
+        };
+    }
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error('EoFrameworkCoreModule is already loaded. Import it in the AppModule only');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EoFrameworkCoreModule, deps: [{ token: EoFrameworkCoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.2", ngImport: i0, type: EoFrameworkCoreModule, imports: [CommonModule,
+            HttpClientModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EoFrameworkCoreModule, providers: [
+            AppSearchService,
+            AuthGuard,
+            PluginsService,
+            GridService,
+            LocationService,
+            SelectionService,
+            LayoutService,
+            CapabilitiesGuard,
+            PendingChangesService,
+            PendingChangesGuard,
+            AgentService,
+            UploadOverlayGuard,
+            ReferenceService,
+            EmptyStateService,
+            PageTitleService,
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: ErrorHandlerService,
+                multi: true
+            },
+            {
+                // provide a error handling for the current platform
+                provide: ErrorHandler,
+                useClass: ErrorHandlerService
+            }
+        ], imports: [CommonModule,
+            HttpClientModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: EoFrameworkCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        HttpClientModule
+                    ],
+                    providers: [
+                        AppSearchService,
+                        AuthGuard,
+                        PluginsService,
+                        GridService,
+                        LocationService,
+                        SelectionService,
+                        LayoutService,
+                        CapabilitiesGuard,
+                        PendingChangesService,
+                        PendingChangesGuard,
+                        AgentService,
+                        UploadOverlayGuard,
+                        ReferenceService,
+                        EmptyStateService,
+                        PageTitleService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: ErrorHandlerService,
+                            multi: true
+                        },
+                        {
+                            // provide a error handling for the current platform
+                            provide: ErrorHandler,
+                            useClass: ErrorHandlerService
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: EoFrameworkCoreModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/eo-framework-core/error-handler/error-handler.service.mjs

@@ -0,0 +1,89 @@
+import { tap } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { Router } from '@angular/router';
+import { TranslateService } from '@eo-sdk/core';
+import { AuthService, Logger, NotificationsService, EoError } from '@eo-sdk/core';
+import * as i0 from "@angular/core";
+export class ErrorHandlerService {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        const auth = this.injector.get(AuthService);
+        const router = this.injector.get(Router);
+        // need to use location here, because the router may not be ready
+        const currentRouteUrl = location.href.substr(location.origin.length);
+        return next.handle(req).pipe(tap((event) => {
+            if (event instanceof HttpResponse) {
+                // do stuff with response if you want
+            }
+        }, (error) => {
+            if (error instanceof HttpErrorResponse || error.isHttpErrorResponse) {
+                if (error.status === 401) {
+                    auth.logout();
+                    if (!currentRouteUrl.includes('/enter')) {
+                        const returnUrl = currentRouteUrl;
+                        const uriParamQuery = { queryParams: returnUrl ? { returnUrl } : {} };
+                        router.navigate(['/enter'], uriParamQuery).then(() => {
+                            router.navigate([{ outlets: { modal: null } }], { queryParamsHandling: 'preserve' });
+                        });
+                    }
+                }
+            }
+        }));
+    }
+    handleError(error) {
+        if (error) {
+            const logger = this.injector.get(Logger);
+            const notificationsService = this.injector.get(NotificationsService);
+            const translate = this.injector.get(TranslateService);
+            const title = error.name ? error.name : error.toString();
+            const message = error.message ? error.message : '';
+            if (!message.includes('ExpressionChangedAfterItHasBeenCheckedError')) {
+                logger.error(error);
+            }
+            else {
+                logger.warn(error);
+            }
+            if (error instanceof EoError && error.skipNotification) {
+                // do nothing: error is logged in console
+            }
+            else if (error instanceof HttpErrorResponse || error.isHttpErrorResponse) {
+                if (error.status === 401) {
+                    // do nothing: interceptor handles the error
+                }
+                else if (error.status === 503 || error.status === 500) {
+                    // todo: is there a better way (Searchservice should not return 500)
+                    if (error.url.match(/\/aggregate|\/autocomplete|\/attachments/)) {
+                        // notificationsService.error(title, message);
+                    }
+                    else {
+                        notificationsService.error(translate.instant('eo.error.connection.interrupted.title'), translate.instant('eo.error.connection.interrupted.text'));
+                    }
+                    // TODO: remove once Agent 5 is relesed
+                }
+                else if (error.status === 404 && error.url.includes('/agent/pair/')) {
+                }
+                else {
+                    notificationsService.error(title, message);
+                }
+            }
+            else if (error instanceof EoError) {
+                notificationsService.error(title, message);
+            }
+            else if (error instanceof TypeError) {
+                // notificationsService.error(title, message);
+            }
+            else if (error instanceof Error && !message.includes('ExpressionChangedAfterItHasBeenCheckedError')) {
+                // notificationsService.error(title, message);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ErrorHandlerService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ErrorHandlerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ErrorHandlerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.service.js","sourceRoot":"","sources":["../../../../../../../src/app/eo-framework-core/error-handler/error-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {tap} from 'rxjs/operators';\nimport {ErrorHandler, Injectable, Injector} from '@angular/core';\nimport {HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse} from '@angular/common/http';\nimport {NavigationExtras, Router} from '@angular/router';\nimport {TranslateService} from '@eo-sdk/core';\nimport {AuthService, Logger, NotificationsService, EoError} from '@eo-sdk/core';\nimport {Observable} from 'rxjs';\n\n@Injectable()\nexport class ErrorHandlerService implements ErrorHandler, HttpInterceptor {\n\n  constructor(private injector: Injector) {\n  }\n\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    const auth = this.injector.get(AuthService);\n    const router = this.injector.get(Router);\n    // need to use location here, because the router may not be ready\n    const currentRouteUrl = location.href.substr(location.origin.length);\n\n    return next.handle(req).pipe(tap((event: HttpEvent<any>) => {\n      if (event instanceof HttpResponse) {\n        // do stuff with response if you want\n      }\n    }, (error: any) => {\n      if (error instanceof HttpErrorResponse || error.isHttpErrorResponse) {\n        if (error.status === 401) {\n          auth.logout();\n          if (!currentRouteUrl.includes('/enter')) {\n            const returnUrl = currentRouteUrl;\n            const uriParamQuery: NavigationExtras = {queryParams: returnUrl ? {returnUrl} : {}};\n            router.navigate(['/enter'], uriParamQuery).then(() => {\n              router.navigate([{outlets: {modal: null}}], <NavigationExtras>{queryParamsHandling: 'preserve'});\n            });\n          }\n        }\n      }\n    }));\n  }\n\n  handleError(error) {\n    if (error) {\n      const logger = this.injector.get(Logger);\n      const notificationsService = this.injector.get(NotificationsService);\n      const translate = this.injector.get(TranslateService);\n\n      const title = error.name ? error.name : error.toString();\n      const message = error.message ? error.message : '';\n\n      if (!message.includes('ExpressionChangedAfterItHasBeenCheckedError')) {\n        logger.error(error);\n      } else {\n        logger.warn(error);\n      }\n\n      if (error instanceof EoError && error.skipNotification) {\n        // do nothing: error is logged in console\n      } else if (error instanceof HttpErrorResponse || error.isHttpErrorResponse) {\n\n        if (error.status === 401) {\n          // do nothing: interceptor handles the error\n        } else if (error.status === 503 || error.status === 500) {\n\n          // todo: is there a better way (Searchservice should not return 500)\n          if (error.url.match(/\\/aggregate|\\/autocomplete|\\/attachments/)) {\n            // notificationsService.error(title, message);\n          } else {\n            notificationsService.error(\n              translate.instant('eo.error.connection.interrupted.title'),\n              translate.instant('eo.error.connection.interrupted.text'));\n          }\n          // TODO: remove once Agent 5 is relesed\n        } else if (error.status === 404 && error.url.includes('/agent/pair/')) {\n        } else {\n          notificationsService.error(title, message);\n        }\n\n      } else if (error instanceof EoError) {\n        notificationsService.error(title, message);\n      } else if (error instanceof TypeError) {\n        // notificationsService.error(title, message);\n      } else if (error instanceof Error && !message.includes('ExpressionChangedAfterItHasBeenCheckedError')) {\n        // notificationsService.error(title, message);\n      }\n    }\n  }\n}\n"]}