nuxeo-development-framework 3.1.6 → 3.1.8

package/esm2015/lib/Core/services/extension/extension.service.js

@@ -0,0 +1,120 @@
+import { Injectable, InjectionToken, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./extension-loader.service";
+import * as i2 from "./component-register.service";
+export function extensionJsonsFactory() {
+    return [];
+}
+export const EXTENSION_JSONS = new InjectionToken('extension-jsons', {
+    providedIn: 'root',
+    factory: extensionJsonsFactory
+});
+export function provideExtensionConfig(jsons) {
+    return {
+        provide: EXTENSION_JSONS,
+        useValue: jsons,
+        multi: true
+    };
+}
+export class ExtensionService {
+    constructor(loader, componentRegister, extensionJsons) {
+        this.loader = loader;
+        this.componentRegister = componentRegister;
+        this.extensionJsons = extensionJsons;
+        this.config = null;
+        this.configPath = 'assets/app.extensions.json';
+        this.pluginsPath = 'assets/plugins';
+        this.features = [];
+        this.authGuards = {};
+        this.onSetup$ = new BehaviorSubject(this.config);
+        this.setup$ = this.onSetup$.asObservable();
+    }
+    /**
+     * Gets features by key.
+     * @param key Key string, using dot notation
+     * @returns Features array found by key
+     */
+    getFeature(key) {
+        const properties = Array.isArray(key) ? [key] : key.split('.');
+        return properties.reduce((prev, curr) => prev && prev[curr], this.features) || [];
+    }
+    getElements(key, fallback = []) {
+        return this.loader.getElements(this.config, key, fallback);
+    }
+    /**
+     * Adds one or more new auth guards to the existing set.
+     * @param values The new auth guards to add
+     */
+    setAuthGuards(values) {
+        if (values) {
+            this.authGuards = Object.assign({}, this.authGuards, values);
+        }
+    }
+    /**
+     * Adds one or more new components to the existing set.
+     * @param values The new components to add
+     */
+    setComponents(values) {
+        this.componentRegister.setComponents(values);
+    }
+    /**
+     * Retrieves one or more auth guards using an array of ID values.
+     * @param ids Array of ID value to look for
+     * @returns Array of auth guards or empty array if none were found
+     */
+    getAuthGuards(ids) {
+        return (ids || [])
+            .map((id) => this.authGuards[id])
+            .filter((guard) => guard);
+    }
+    /**
+     * Retrieves a registered extension component using its ID value.
+     * @param id The ID value to look for
+     * @returns The component or null if not found
+     */
+    getComponentById(id) {
+        return this.componentRegister.getComponentById(id);
+    }
+    /**
+     * Runs a lightweight expression stored in a string.
+     * @param value String containing the expression or literal value
+     * @param context Parameter object for the expression with details of app state
+     * @returns Result of evaluated expression, if found, or the literal value otherwise
+     */
+    runExpression(value, context) {
+        if (typeof value === 'string') {
+            return this.evaluateExpression(value, context);
+        }
+        else {
+            const duplicate = Object.assign({}, value);
+            Object.keys(duplicate).forEach((key) => {
+                duplicate[key] = this.evaluateExpression(duplicate[key], context);
+            });
+            return duplicate;
+        }
+    }
+    evaluateExpression(value, context) {
+        const pattern = new RegExp(/\$\((.*\)?)\)/g);
+        const matches = pattern.exec(value);
+        if (matches && matches.length > 1) {
+            const expression = matches[1];
+            const fn = new Function('context', `return ${expression}`);
+            const result = fn(context);
+            return result;
+        }
+        return value;
+    }
+}
+ExtensionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ExtensionService, deps: [{ token: i1.ExtensionLoaderService }, { token: i2.ComponentRegisterService }, { token: EXTENSION_JSONS }], target: i0.ɵɵFactoryTarget.Injectable });
+ExtensionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ExtensionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ExtensionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ExtensionLoaderService }, { type: i2.ComponentRegisterService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [EXTENSION_JSONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/extension/extension.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAQ,cAAc,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;;;;AAIvC,MAAM,UAAU,qBAAqB;IACjC,OAAO,EAAE,CAAC;AACd,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAAa,iBAAiB,EAAE;IAC7E,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,qBAAqB;CACjC,CAAC,CAAC;AAEH,MAAM,UAAU,sBAAsB,CAAC,KAAe;IAClD,OAAO;QACH,OAAO,EAAE,eAAe;QACxB,QAAQ,EAAE,KAAK;QACf,KAAK,EAAE,IAAI;KACd,CAAC;AACN,CAAC;AAKD,MAAM,OAAO,gBAAgB;IAYzB,YACc,MAA8B,EAC9B,iBAA2C,EAClB,cAAwB;QAFjD,WAAM,GAAN,MAAM,CAAwB;QAC9B,sBAAiB,GAAjB,iBAAiB,CAA0B;QAClB,mBAAc,GAAd,cAAc,CAAU;QAbrD,WAAM,GAAG,IAAI,CAAC;QAExB,eAAU,GAAG,4BAA4B,CAAC;QAC1C,gBAAW,GAAG,gBAAgB,CAAC;QAC/B,aAAQ,GAAe,EAAE,CAAC;QAC1B,eAAU,GAAgC,EAAE,CAAC;QAEnC,aAAQ,GAAG,IAAI,eAAe,CAAM,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3D,WAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;IAOtC,CAAC;IAKD;;;;OAIG;IACH,UAAU,CAAC,GAAW;QAClB,MAAM,UAAU,GAAa,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACzE,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACtF,CAAC;IAED,WAAW,CAAC,GAAW,EAAE,WAAuB,EAAE;QAC9C,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC/D,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,MAAmC;QAC7C,IAAI,MAAM,EAAE;YACR,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;SAChE;IACL,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,MAAmC;QAC7C,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IAGD;;;;OAIG;IACH,aAAa,CAAC,GAAa;QACvB,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC;aACb,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;aAChC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAMD;;;;OAIG;IACH,gBAAgB,CAAI,EAAU;QAC1B,OAAO,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAI,EAAE,CAAC,CAAC;IAC1D,CAAC;IAGD;;;;;OAKG;IACH,aAAa,CAAC,KAAkB,EAAG,OAAa;QAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAG;YAC5B,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;SAClD;aAAM;YACH,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAE,CAAC,GAAG,EAAE,EAAE;gBACpC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;YACtE,CAAC,CAAC,CAAC;YACH,OAAO,SAAS,CAAC;SACpB;IACL,CAAC;IAEO,kBAAkB,CAAC,KAAa,EAAE,OAAa;QACnD,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEpC,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,EAAE,GAAG,IAAI,QAAQ,CAAC,SAAS,EAAE,UAAU,UAAU,EAAE,CAAC,CAAC;YAC3D,MAAM,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC,CAAC;YAE3B,OAAO,MAAM,CAAC;SACjB;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;;6GA9GQ,gBAAgB,gGAeb,eAAe;iHAflB,gBAAgB,cAFb,MAAM;2FAET,gBAAgB;kBAH5B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;0BAgBQ,MAAM;2BAAC,eAAe","sourcesContent":["import { Injectable, Type, InjectionToken, Inject } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { ComponentRegisterService } from './component-register.service';\r\nimport { ExtensionLoaderService } from './extension-loader.service';\r\n\r\nexport function extensionJsonsFactory() {\r\n    return [];\r\n}\r\n\r\nexport const EXTENSION_JSONS = new InjectionToken<string[][]>('extension-jsons', {\r\n    providedIn: 'root',\r\n    factory: extensionJsonsFactory\r\n});\r\n\r\nexport function provideExtensionConfig(jsons: string[]) {\r\n    return {\r\n        provide: EXTENSION_JSONS,\r\n        useValue: jsons,\r\n        multi: true\r\n    };\r\n}\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class ExtensionService {\r\n\r\n    protected config = null;\r\n\r\n    configPath = 'assets/app.extensions.json';\r\n    pluginsPath = 'assets/plugins';\r\n    features: Array<any> = [];\r\n    authGuards: { [key: string]: Type<{}> } = {};\r\n\r\n    protected onSetup$ = new BehaviorSubject<any>(this.config);\r\n    setup$ = this.onSetup$.asObservable();\r\n\r\n    constructor(\r\n        protected loader: ExtensionLoaderService,\r\n        protected componentRegister: ComponentRegisterService,\r\n        @Inject(EXTENSION_JSONS) protected extensionJsons: string[]\r\n    ) {\r\n    }\r\n\r\n\r\n\r\n\r\n    /**\r\n     * Gets features by key.\r\n     * @param key Key string, using dot notation\r\n     * @returns Features array found by key\r\n     */\r\n    getFeature(key: string): any[] {\r\n        const properties: string[] = Array.isArray(key) ? [key] : key.split('.');\r\n        return properties.reduce((prev, curr) => prev && prev[curr], this.features) || [];\r\n    }\r\n\r\n    getElements(key: string, fallback: Array<any> = []): Array<any> {\r\n        return this.loader.getElements(this.config, key, fallback);\r\n    }\r\n\r\n    /**\r\n     * Adds one or more new auth guards to the existing set.\r\n     * @param values The new auth guards to add\r\n     */\r\n    setAuthGuards(values: { [key: string]: Type<{}> }) {\r\n        if (values) {\r\n            this.authGuards = Object.assign({}, this.authGuards, values);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds one or more new components to the existing set.\r\n     * @param values The new components to add\r\n     */\r\n    setComponents(values: { [key: string]: Type<{}> }) {\r\n        this.componentRegister.setComponents(values);\r\n    }\r\n\r\n\r\n    /**\r\n     * Retrieves one or more auth guards using an array of ID values.\r\n     * @param ids Array of ID value to look for\r\n     * @returns Array of auth guards or empty array if none were found\r\n     */\r\n    getAuthGuards(ids: string[]): Array<Type<{}>> {\r\n        return (ids || [])\r\n            .map((id) => this.authGuards[id])\r\n            .filter((guard) => guard);\r\n    }\r\n\r\n\r\n    \r\n\r\n\r\n    /**\r\n     * Retrieves a registered extension component using its ID value.\r\n     * @param id The ID value to look for\r\n     * @returns The component or null if not found\r\n     */\r\n    getComponentById<T>(id: string) {\r\n        return this.componentRegister.getComponentById<T>(id);\r\n    }\r\n\r\n\r\n    /**\r\n     * Runs a lightweight expression stored in a string.\r\n     * @param value String containing the expression or literal value\r\n     * @param context Parameter object for the expression with details of app state\r\n     * @returns Result of evaluated expression, if found, or the literal value otherwise\r\n     */\r\n    runExpression(value: string | {} , context?: any) {\r\n        if (typeof value === 'string' ) {\r\n            return this.evaluateExpression(value, context);\r\n        } else {\r\n            const duplicate = Object.assign({}, value);\r\n            Object.keys(duplicate).forEach( (key) => {\r\n                duplicate[key] = this.evaluateExpression(duplicate[key], context);\r\n            });\r\n            return duplicate;\r\n        }\r\n    }\r\n\r\n    private evaluateExpression(value: string, context?: any): string {\r\n        const pattern = new RegExp(/\\$\\((.*\\)?)\\)/g);\r\n        const matches = pattern.exec(value);\r\n\r\n        if (matches && matches.length > 1) {\r\n            const expression = matches[1];\r\n            const fn = new Function('context', `return ${expression}`);\r\n            const result = fn(context);\r\n\r\n            return result;\r\n        }\r\n        return value;\r\n    }\r\n}\r\n"]}

package/esm2015/lib/Core/services/initialization/initialization.service.js

@@ -0,0 +1,57 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "keycloak-angular";
+import * as i2 from "../nuxeo/nuxeo.service";
+import * as i3 from "../user/user-preferences.service";
+export class InitializationService {
+    constructor(keycloak, nuxeoService, userPreferences, environment) {
+        this.keycloak = keycloak;
+        this.nuxeoService = nuxeoService;
+        this.userPreferences = userPreferences;
+        this.environment = environment;
+    }
+    initializer() {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.keycloak.init({
+                    config: this.environment.keycloak,
+                    loadUserProfileAtStartUp: false,
+                    initOptions: {
+                        onLoad: 'login-required',
+                        checkLoginIframe: false
+                    },
+                    enableBearerInterceptor: true,
+                    bearerExcludedUrls: [
+                        '/assets/', '/cts/assets/'
+                    ],
+                });
+                const kc = this.keycloak.getKeycloakInstance();
+                this.nuxeoService.init()
+                    .then((client) => {
+                    this.userPreferences.setStoragePrefix(client.user.id);
+                    resolve(true);
+                })
+                    .catch((err) => {
+                    console.error(err);
+                    reject(err);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+}
+InitializationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: InitializationService, deps: [{ token: i1.KeycloakService }, { token: i2.NuxeoService }, { token: i3.UserPreferencesService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+InitializationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: InitializationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: InitializationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }, { type: i2.NuxeoService }, { type: i3.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/Core/services/localStorag/local-storag.service.js

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LocalStoragService {
+    constructor() {
+        this.memoryStore = {};
+        this.useLocalStorage = false;
+        this._prefix = '';
+        this.useLocalStorage = this.storageAvailable('localStorage');
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    set prefix(prefix) {
+        this._prefix = prefix ? prefix + '_' : '';
+    }
+    /**
+     * Gets an item.
+     * @param key Key to identify the item
+     * @returns The item (if any) retrieved by the key
+     */
+    getItem(key) {
+        if (this.useLocalStorage) {
+            return localStorage.getItem(this.prefix + key);
+        }
+        else {
+            return this.memoryStore.hasOwnProperty(this.prefix + key) ? this.memoryStore[this.prefix + key] : null;
+        }
+    }
+    /**
+     * Stores an item
+     * @param key Key to identify the item
+     * @param data Data to store
+     */
+    setItem(key, data) {
+        if (this.useLocalStorage) {
+            localStorage.setItem(this.prefix + key, data);
+        }
+        else {
+            this.memoryStore[this.prefix + key] = data.toString();
+        }
+    }
+    /** Removes all currently stored items. */
+    clear() {
+        if (this.useLocalStorage) {
+            localStorage.clear();
+        }
+        else {
+            this.memoryStore = {};
+        }
+    }
+    /**
+     * Removes a single item.
+     * @param key Key to identify the item
+     */
+    removeItem(key) {
+        if (this.useLocalStorage) {
+            localStorage.removeItem(this.prefix + key);
+        }
+        else {
+            delete this.memoryStore[this.prefix + key];
+        }
+    }
+    /**
+     * Is any item currently stored under `key`?
+     * @param key Key identifying item to check
+     * @returns True if key retrieves an item, false otherwise
+     */
+    hasItem(key) {
+        if (this.useLocalStorage) {
+            return localStorage.getItem(this.prefix + key) ? true : false;
+        }
+        else {
+            return this.memoryStore.hasOwnProperty(key);
+        }
+    }
+    storageAvailable(type) {
+        try {
+            const storage = window[type];
+            const key = '__storage_test__';
+            storage.setItem(key, key);
+            storage.removeItem(key, key);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getLocal(key) {
+        const ijsKey = 'cts' + key;
+        const data = window.localStorage.getItem(ijsKey);
+        if (data) {
+            return JSON.parse(data);
+        }
+        else {
+            return null;
+        }
+    }
+    setLocal(key, value) {
+        const ijsKey = 'cts' + key;
+        const data = value === undefined ? '' : JSON.stringify(value);
+        window.localStorage.setItem(ijsKey, data);
+    }
+    removeLocal(key) {
+        const ijsKey = 'cts' + key;
+        window.localStorage.removeItem(ijsKey);
+    }
+    removeAllLocals() {
+        for (const key in window.localStorage) {
+            if (window.localStorage.hasOwnProperty(key)) {
+                window.localStorage.removeItem(key);
+            }
+        }
+    }
+}
+LocalStoragService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: LocalStoragService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStoragService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: LocalStoragService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: LocalStoragService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-storag.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/localStorag/local-storag.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LocalStoragService {\r\n\r\n  private memoryStore: { [key: string]: any } = {};\r\n  private readonly useLocalStorage: boolean = false;\r\n  private _prefix: string = '';\r\n\r\n  get prefix() {\r\n    return this._prefix;\r\n  }\r\n\r\n  set prefix(prefix: string) {\r\n    this._prefix = prefix ? prefix + '_' : '';\r\n  }\r\n\r\n  constructor() {\r\n    this.useLocalStorage = this.storageAvailable('localStorage');\r\n  }\r\n\r\n\r\n  /**\r\n   * Gets an item.\r\n   * @param key Key to identify the item\r\n   * @returns The item (if any) retrieved by the key\r\n   */\r\n  getItem(key: string): string | null {\r\n    if (this.useLocalStorage) {\r\n      return localStorage.getItem(this.prefix + key);\r\n    } else {\r\n      return this.memoryStore.hasOwnProperty(this.prefix + key) ? this.memoryStore[this.prefix + key] : null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stores an item\r\n   * @param key Key to identify the item\r\n   * @param data Data to store\r\n   */\r\n  setItem(key: string, data: string) {\r\n    if (this.useLocalStorage) {\r\n      localStorage.setItem(this.prefix + key, data);\r\n    } else {\r\n      this.memoryStore[this.prefix + key] = data.toString();\r\n    }\r\n  }\r\n\r\n  /** Removes all currently stored items. */\r\n  clear() {\r\n    if (this.useLocalStorage) {\r\n      localStorage.clear();\r\n    } else {\r\n      this.memoryStore = {};\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Removes a single item.\r\n   * @param key Key to identify the item\r\n   */\r\n  removeItem(key: string) {\r\n    if (this.useLocalStorage) {\r\n      localStorage.removeItem(this.prefix + key);\r\n    } else {\r\n      delete this.memoryStore[this.prefix + key];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Is any item currently stored under `key`?\r\n   * @param key Key identifying item to check\r\n   * @returns True if key retrieves an item, false otherwise\r\n   */\r\n  hasItem(key: string): boolean {\r\n    if (this.useLocalStorage) {\r\n      return localStorage.getItem(this.prefix + key) ? true : false;\r\n    } else {\r\n      return this.memoryStore.hasOwnProperty(key);\r\n    }\r\n  }\r\n\r\n  private storageAvailable(type: string): boolean {\r\n    try {\r\n      const storage = window[type];\r\n      const key = '__storage_test__';\r\n      storage.setItem(key, key);\r\n      storage.removeItem(key, key);\r\n      return true;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  getLocal(key: string): any {\r\n    const ijsKey = 'cts' + key;\r\n    const data = window.localStorage.getItem(ijsKey);\r\n    if (data) {\r\n      return JSON.parse(data);\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  setLocal(key: string, value: any): void {\r\n    const ijsKey = 'cts' + key;\r\n    const data = value === undefined ? '' : JSON.stringify(value);\r\n    window.localStorage.setItem(ijsKey, data);\r\n  }\r\n\r\n  removeLocal(key: string): void {\r\n    const ijsKey = 'cts' + key;\r\n    window.localStorage.removeItem(ijsKey);\r\n  }\r\n\r\n  removeAllLocals(): void {\r\n    for (const key in window.localStorage) {\r\n      if (window.localStorage.hasOwnProperty(key)) {\r\n        window.localStorage.removeItem(key);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/Core/services/nuxeo/nuxeo-override.js

@@ -0,0 +1,82 @@
+const Nuxeo = require('nuxeo');
+const doFetch = require('nuxeo/lib/deps/fetch');
+const Unmarshallers = require('nuxeo/lib/unmarshallers/unmarshallers');
+const Authentication = require('nuxeo/lib/auth/auth');
+export class NuxeoOverride extends Nuxeo {
+    constructor(opts = {}, keycloak) {
+        super(opts);
+        this.keycloak = keycloak;
+    }
+    http(opts = {}) {
+        const options = this._computeFetchOptions(opts);
+        return new this.Promise((resolve, reject) => {
+            this._activeRequests += 1;
+            const fetchOptions = {
+                method: options.method,
+                headers: options.headers,
+                body: options.body,
+                signal: options.signal,
+            };
+            if (opts.credentials) {
+                fetchOptions.credentials = opts.credentials;
+            }
+            else if (!this._auth) {
+                fetchOptions.credentials = 'include';
+            }
+            doFetch(options.url, fetchOptions)
+                .then((res) => {
+                this._activeRequests -= 1;
+                if (res.status === 401 && !opts.refreshedAuthentication) {
+                    // try re-authenticate
+                    opts.refreshedAuthentication = true;
+                    return this.keycloak.updateToken()
+                        .then((didRefresh) => {
+                        if (didRefresh) {
+                            this.keycloak.getToken().then(refreshedAuth => {
+                                this._auth = refreshedAuth;
+                                this._notifyAuthenticationRefreshed(refreshedAuth);
+                                return resolve(this.http(opts));
+                            });
+                        }
+                        else {
+                            this.keycloak.logout();
+                            throw res;
+                        }
+                    })
+                        .catch(() => {
+                        throw res;
+                    });
+                }
+                if (!(/^2/.test(`${res.status}`))) {
+                    const error = new Error(res);
+                    throw res;
+                }
+                if (options.resolveWithFullResponse || res.status === 204) {
+                    return resolve(res);
+                }
+                const contentType = res.headers.get('content-type');
+                if (contentType && contentType.indexOf('application/json') === 0) {
+                    options.nuxeo = this;
+                    return resolve(res.json().then((json) => Unmarshallers.unmarshall(json, options, res)));
+                }
+                return resolve(res);
+            }).catch((error) => {
+                this._activeRequests -= 1;
+                error.text().then(data => {
+                    let ret = {};
+                    try {
+                        ret = data ? JSON.parse(data) : {};
+                    }
+                    catch (e) {
+                        ret = {};
+                    }
+                    return reject({
+                        status: error.status,
+                        ret
+                    });
+                });
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/Core/services/nuxeo/nuxeo.service.js

@@ -0,0 +1,120 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { NuxeoOverride as Nuxeo } from './nuxeo-override';
+import { APP_BASE_HREF } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "keycloak-angular";
+import * as i3 from "../roles/roles.service";
+export class NuxeoService {
+    constructor(http, keycloak, baseHref, environment, rolesService) {
+        this.http = http;
+        this.keycloak = keycloak;
+        this.baseHref = baseHref;
+        this.environment = environment;
+        this.rolesService = rolesService;
+        this.excludedUrls = [];
+        this.enableBearerInterceptor = true;
+        this.authenticated = false;
+        this.ctsUser = false;
+        this.ctsManger = false;
+    }
+    init() {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.keycloak.getToken().then(token => {
+                    this.createTokenClient(token);
+                    this.nuxeoClient.connect()
+                        .then((client) => {
+                        this.authenticated = true;
+                        resolve(client);
+                        this.checkForRoles();
+                    })
+                        .catch((error) => {
+                        reject(error);
+                    });
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+    createTokenClient(token) {
+        this.nuxeoClient = new Nuxeo({
+            baseURL: this.environment.nuxeo,
+            auth: {
+                method: 'bearerToken',
+                token
+            }
+        }, this.keycloak);
+    }
+    getToken() {
+        return this.keycloak.getToken();
+    }
+    doLogout() {
+        this.keycloak.logout(window.location.origin + this.baseHref);
+    }
+    isUserInRole(role, committeeCode = null) {
+        const simpleObservable = new Observable(observer => {
+            this.keycloak.isLoggedIn().then(logged => {
+                if (!logged) {
+                    observer.next(false);
+                }
+                else {
+                    const hasRole = this.rolesService.isUserInRole(this.nuxeoClient.user, role, committeeCode);
+                    observer.next(hasRole);
+                }
+            });
+        });
+        return simpleObservable;
+    }
+    createBlob(file) {
+        return new Nuxeo.Blob({
+            content: file
+        });
+    }
+    getDuplicates(params = {}, body = {}) {
+        return from(this.nuxeoClient
+            .operation('AC_Get_Duplicates', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .params(params)
+            .context(body)
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    checkForRoles() {
+        this.isCtsUser();
+        this.isCtsManger();
+    }
+    isCtsUser() {
+        this.isUserInRole('ctsSecretary', '').subscribe(data => {
+            this.ctsUser = data;
+        });
+    }
+    isCtsManger() {
+        this.isUserInRole('ctsManger', '').subscribe(data => {
+            this.ctsManger = data;
+        });
+    }
+}
+NuxeoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: NuxeoService, deps: [{ token: i1.HttpClient }, { token: i2.KeycloakService }, { token: APP_BASE_HREF }, { token: 'environment' }, { token: i3.RolesService }], target: i0.ɵɵFactoryTarget.Injectable });
+NuxeoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: NuxeoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: NuxeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.KeycloakService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_BASE_HREF]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i3.RolesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxeo.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/Core/services/nuxeo/nuxeo.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport {Inject, Injectable} from '@angular/core';\r\nimport { KeycloakService } from 'keycloak-angular';\r\nimport { from, Observable } from 'rxjs';\r\nimport { catchError, map, share, tap } from 'rxjs/operators';\r\nimport { NuxeoOverride as Nuxeo } from './nuxeo-override';\r\nimport {APP_BASE_HREF} from '@angular/common';\r\nimport { RolesService } from '../roles/roles.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NuxeoService {\r\n  nuxeoClient;\r\n  excludedUrls = [];\r\n  enableBearerInterceptor = true;\r\n  authenticated = false;\r\n  token;\r\n  tokenObservable;\r\n  constructor(private http: HttpClient, private keycloak: KeycloakService, \r\n    @Inject(APP_BASE_HREF) private baseHref: string, \r\n    @Inject('environment') private environment,\r\n    private rolesService : RolesService) {\r\n\r\n  }\r\n  init(): Promise<any> {\r\n    return new Promise(async (resolve, reject) => {\r\n      try {\r\n        this.keycloak.getToken().then(token => {\r\n        \r\n          this.createTokenClient(token);\r\n          this.nuxeoClient.connect()\r\n            .then((client) => {\r\n              this.authenticated = true;\r\n              resolve(client);\r\n              this.checkForRoles();\r\n            })\r\n            .catch((error) => {\r\n              reject(error);\r\n            });\r\n\r\n        })\r\n      } catch (error) {\r\n        reject(error);\r\n      }\r\n    });\r\n\r\n  }\r\n  createTokenClient(token) {\r\n    this.nuxeoClient = new Nuxeo({\r\n      baseURL: this.environment.nuxeo,\r\n      auth: {\r\n        method: 'bearerToken',\r\n        token\r\n      }\r\n    }, this.keycloak);\r\n  }\r\n\r\n  getToken() {\r\n    return this.keycloak.getToken();\r\n  }\r\n\r\n  doLogout() {\r\n    this.keycloak.logout(window.location.origin + this.baseHref);\r\n  }\r\n\r\n\r\n  isUserInRole(role: any, committeeCode = null): Observable<any> {\r\n    const simpleObservable = new Observable(observer => {\r\n      this.keycloak.isLoggedIn().then(logged => {\r\n        if (!logged) {\r\n          observer.next(false);\r\n        } else {\r\n          const hasRole = this.rolesService.isUserInRole(this.nuxeoClient.user, role, committeeCode);\r\n          observer.next(hasRole);\r\n        }\r\n\r\n      });\r\n    });\r\n\r\n    return simpleObservable;\r\n  }\r\n  createBlob(file): any {\r\n    return new Nuxeo.Blob({\r\n      content: file\r\n    });\r\n  }\r\n\r\n  getDuplicates(params = {}, body = {}): Observable<any> {\r\n    return from(\r\n      this.nuxeoClient\r\n        .operation('AC_Get_Duplicates', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .params(params)\r\n        .context(body)\r\n        .execute()\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  checkForRoles(){\r\n    this.isCtsUser();\r\n    this.isCtsManger();\r\n  }\r\n\r\n  ctsUser = false;\r\n  isCtsUser(){\r\n    this.isUserInRole('ctsSecretary', '').subscribe(data => {\r\n      this.ctsUser = data;\r\n    })\r\n  }\r\n  ctsManger= false;\r\n  isCtsManger(){\r\n    this.isUserInRole('ctsManger', '').subscribe(data => {\r\n      this.ctsManger = data;\r\n    })\r\n  }\r\n}\r\n"]}