nuxeo-development-framework 4.1.6 → 4.1.7

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.17", 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.17", ngImport: i0, type: ExtensionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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;;8GA9GQ,gBAAgB,gGAeb,eAAe;kHAflB,gBAAgB,cAFb,MAAM;4FAET,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,138 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { RoutesRecognized } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "keycloak-angular";
+import * as i2 from "../nuxeo/nuxeo.service";
+import * as i3 from "@angular/router";
+import * as i4 from "ngx-cookie-service";
+import * as i5 from "@angular/common/http";
+import * as i6 from "../localStorag/local-storag.service";
+import * as i7 from "../user/user-preferences.service";
+export class InitializationService {
+    constructor(keycloak, nuxeoService, router, cookieService, httpClient, storage, userPreferences, environment) {
+        this.keycloak = keycloak;
+        this.nuxeoService = nuxeoService;
+        this.router = router;
+        this.cookieService = cookieService;
+        this.httpClient = httpClient;
+        this.storage = storage;
+        this.userPreferences = userPreferences;
+        this.environment = environment;
+    }
+    initializer(loginMethod = 'keyclock') {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (loginMethod === 'keyclock') {
+                    this.initiateKeyClock().then((client) => {
+                        this.userPreferences.setStoragePrefix(client.user.id);
+                        resolve(true);
+                    })
+                        .catch((err) => {
+                        console.error(err);
+                        reject(err);
+                    });
+                }
+                else if (loginMethod === 'nuxeo') {
+                    this.initiateNuxeoLogin(resolve, reject);
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+    initiateKeyClock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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();
+            return this.nuxeoService.init();
+        });
+    }
+    initiateNuxeoLogin(resolve, reject) {
+        // let cachable = this.storage.getItem('Cachable')
+        let cachable = this.cookieService.get('CMS_CACHABLE');
+        if (cachable && cachable !== 'null') {
+            // there is cachable exist
+            this.initiateClientWithNuxeo(this.decriptFormating(cachable), resolve, reject);
+        }
+        else {
+            // no cachable exist
+            this.routerSubscription = this.router.events.subscribe(val => {
+                if (val instanceof RoutesRecognized) {
+                    console.log(val.state.root.queryParams);
+                    const code = val.state.root.queryParams.code;
+                    if (code && code.length) {
+                        // if there is code exist then get from nuxeo and intite client thenr esolve with true
+                        console.log(`======Auth Code===== ${code}`);
+                        this.getFromNuxeo(code).subscribe((res) => {
+                            console.log(res);
+                            this.cookieService.set('CMS_CACHABLE', this.encriptFormating(res), 1, '/cts');
+                            // this.router.navigate([], {
+                            //   queryParams: {
+                            //     'code': null
+                            //   },
+                            //   queryParamsHandling: 'merge'
+                            // })
+                            this.initiateClientWithNuxeo(res, resolve, reject);
+                        });
+                    }
+                    else {
+                        // no cachable and no code then need to go to login page
+                        this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+                        this.login();
+                    }
+                }
+            });
+        }
+    }
+    getFromNuxeo(code) {
+        return this.httpClient.post(`${this.environment.nuxeoOptions.baseURL}/oauth2/token?grant_type=authorization_code&code=${code}&client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`, {});
+    }
+    initiateClientWithNuxeo(token, resolve, reject) {
+        this.nuxeoService.initWithNuxeoToken(token).then((client) => {
+            this.userPreferences.setStoragePrefix(client.user.id);
+            this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+            resolve(true);
+        })
+            .catch((err) => {
+            console.error(err);
+            this.routerSubscription ? this.routerSubscription.unsubscribe() : null;
+            reject(err);
+        });
+    }
+    login() {
+        window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);
+    }
+    encriptFormating(cachable) {
+        let reformatted = btoa(JSON.stringify(cachable));
+        return 'Xnd' + reformatted + 'HsTeT';
+    }
+    decriptFormating(formate) {
+        let newFormate = formate.substring(3, (formate.length - 5));
+        return JSON.parse(atob(newFormate));
+    }
+}
+InitializationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, deps: [{ token: i1.KeycloakService }, { token: i2.NuxeoService }, { token: i3.Router }, { token: i4.CookieService }, { token: i5.HttpClient }, { token: i6.LocalStoragService }, { token: i7.UserPreferencesService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+InitializationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InitializationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }, { type: i2.NuxeoService }, { type: i3.Router }, { type: i4.CookieService }, { type: i5.HttpClient }, { type: i6.LocalStoragService }, { type: i7.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initialization.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/initialization/initialization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { KeycloakService } from 'keycloak-angular';\r\nimport { NuxeoService } from '../nuxeo/nuxeo.service';\r\nimport { UserPreferencesService } from '../user/user-preferences.service';\r\nimport { LocalStoragService } from '../localStorag/local-storag.service';\r\nimport { Router, RoutesRecognized } from '@angular/router';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Subscription } from 'rxjs';\r\nimport { CookieService } from 'ngx-cookie-service'\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class InitializationService {\r\nrouterSubscription : Subscription;\r\n  constructor(\r\n    private keycloak: KeycloakService,\r\n    private nuxeoService: NuxeoService,\r\n    private router : Router,\r\n    private cookieService : CookieService,\r\n    private httpClient : HttpClient,\r\n    private storage: LocalStoragService, \r\n    private userPreferences: UserPreferencesService, \r\n    @Inject('environment') private environment\r\n  ) { }\r\n\r\n  initializer(loginMethod = 'keyclock') {\r\n  return new Promise(async (resolve, reject) => {\r\n      try {\r\n        if(loginMethod === 'keyclock'){\r\n          this.initiateKeyClock().then((client) => {\r\n            this.userPreferences.setStoragePrefix(client.user.id);\r\n            resolve(true);\r\n          })\r\n          .catch((err) => {\r\n            console.error(err);\r\n            reject(err);\r\n          });\r\n        }else if(loginMethod === 'nuxeo'){\r\n          this.initiateNuxeoLogin(resolve , reject)\r\n        }\r\n        \r\n      } catch (error) {\r\n        reject(error);\r\n      }\r\n\r\n    });\r\n  }\r\n\r\n  async initiateKeyClock(){\r\n    await this.keycloak.init({\r\n      config: this.environment.keycloak,\r\n      loadUserProfileAtStartUp: false,\r\n      initOptions: {\r\n        onLoad: 'login-required',\r\n        checkLoginIframe: false\r\n      },\r\n      enableBearerInterceptor: true,\r\n      bearerExcludedUrls: [\r\n        '/assets/', '/cts/assets/'\r\n      ],\r\n    });\r\n    const kc = this.keycloak.getKeycloakInstance();\r\n   return this.nuxeoService.init()\r\n    \r\n  }\r\n\r\n  initiateNuxeoLogin(resolve , reject){\r\n    // let cachable = this.storage.getItem('Cachable')\r\n    let cachable = this.cookieService.get('CMS_CACHABLE');\r\n    if(cachable && cachable !== 'null'){\r\n      // there is cachable exist\r\n      this.initiateClientWithNuxeo(this.decriptFormating(cachable), resolve , reject)\r\n\r\n    }else{\r\n      // no cachable exist\r\n    this.routerSubscription =  this.router.events.subscribe(val => {\r\n        if (val instanceof RoutesRecognized) {\r\n          console.log(val.state.root.queryParams);\r\n          const code = val.state.root.queryParams.code;\r\n          if (code && code.length) {\r\n            // if there is code exist then get from nuxeo and intite client thenr esolve with true\r\n            console.log(`======Auth Code===== ${code}`);\r\n             this.getFromNuxeo(code).subscribe((res) => {\r\n              console.log(res);\r\n              this.cookieService.set('CMS_CACHABLE' , this.encriptFormating(res) , 1 , '/cts')\r\n              // this.router.navigate([], {\r\n              //   queryParams: {\r\n              //     'code': null\r\n              //   },\r\n              //   queryParamsHandling: 'merge'\r\n              // })\r\n              this.initiateClientWithNuxeo(res, resolve , reject)\r\n            }); \r\n          }else{\r\n            // no cachable and no code then need to go to login page\r\n            this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n            this.login()\r\n          }\r\n        }\r\n      })\r\n    }\r\n  }\r\n\r\n  getFromNuxeo(code){\r\n    return this.httpClient.post(\r\n      `${this.environment.nuxeoOptions.baseURL}/oauth2/token?grant_type=authorization_code&code=${code}&client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`,{\r\n      })\r\n  }\r\n\r\n  initiateClientWithNuxeo(token , resolve , reject){\r\n    this.nuxeoService.initWithNuxeoToken(token).then((client : any) => {\r\n      this.userPreferences.setStoragePrefix(client.user.id);\r\n      this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n      resolve(true);\r\n    })\r\n    .catch((err) => {\r\n      console.error(err);\r\n      this.routerSubscription ? this.routerSubscription.unsubscribe() : null ;\r\n      reject(err);\r\n    });\r\n  }\r\n\r\n  login(){\r\n    window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);\r\n  }\r\n\r\n  encriptFormating(cachable){\r\n  let reformatted =  btoa(JSON.stringify(cachable));\r\n  return 'Xnd' + reformatted + 'HsTeT'\r\n  }\r\n\r\n  decriptFormating(formate : string){\r\n   let newFormate = formate.substring(3,(formate.length-5));\r\n   return JSON.parse(atob(newFormate))\r\n  }\r\n\r\n}\r\n"]}

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.17", ngImport: i0, type: LocalStoragService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStoragService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LocalStoragService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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/new-nuxeo-overide.js

@@ -0,0 +1,146 @@
+import { __decorate, __param } from "tslib";
+import { Inject } from "@angular/core";
+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');
+const qs = require('querystring');
+let NewNuxeoOverride = class NewNuxeoOverride extends Nuxeo {
+    constructor(opts = {}, environment, cookieService) {
+        super(opts);
+        this.environment = environment;
+        this.cookieService = cookieService;
+    }
+    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.refreshAccessToken()
+                        // return Authentication.refreshAuthentication(this._baseURL, this._auth)
+                        .then((refreshedToken) => {
+                        //   this.keycloak.getToken().then(refreshedAuth => {
+                        this._auth = {
+                            method: 'bearerToken',
+                            token: refreshedToken,
+                            clientId: this.environment.nuxeoOptions.client_id,
+                            clientSecret: this.environment.nuxeoOptions.client_secret
+                        };
+                        this._notifyAuthenticationRefreshed(refreshedToken);
+                        this.cookieService.set('CMS_CACHABLE', this.encriptFormating(res), 1, '/cts');
+                        return resolve(this.http(opts));
+                        //   });
+                    }, (error) => {
+                        this.logout();
+                        this.login();
+                    })
+                        .catch(() => {
+                        this.logout();
+                        this.login();
+                        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
+                    });
+                });
+            });
+        });
+    }
+    refreshAccessToken() {
+        return this.getAccessToken(this.environment.nuxeoOptions.baseURL, this.environment.nuxeoOptions.client_id, this._auth.token.refresh_token, this.environment.nuxeoOptions.client_secret);
+    }
+    login() {
+        window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);
+    }
+    logout() {
+        this.cookieService.set('CMS_CACHABLE', '', 1, '/cts');
+    }
+    encriptFormating(cachable) {
+        let reformatted = btoa(JSON.stringify(cachable));
+        return 'Xnd' + reformatted + 'HsTeT';
+    }
+    // nrefreshAccessToken = (baseURL, clientId, refreshToken, params = {}) => {
+    //   if (!baseURL) {
+    //     throw new Error('Missing `baseURL` argument');
+    //   }
+    //   if (!clientId) {
+    //     throw new Error('Missing `clientId` argument');
+    //   }
+    //   if (!refreshToken) {
+    //     throw new Error('Missing `refreshToken` argument');
+    //   }
+    //   const defaultParams = { refresh_token: refreshToken, grant_type: 'refresh_token', client_id: clientId };
+    //   const body = extend(true, defaultParams, params);
+    //   return fetchAccessToken(baseURL, body);
+    // }
+    getAccessToken(baseURL, clientId, refreshToken, clientSecret) {
+        let body = {
+            refresh_token: refreshToken,
+            grant_type: 'refresh_token',
+            client_id: clientId,
+            client_secret: clientSecret
+        };
+        // const url = baseURL.endsWith('/') ? baseURL : `${baseURL}/`;
+        return new Promise((resolve, reject) => (doFetch(`${baseURL}/oauth2/token`, {
+            method: 'POST',
+            body: qs.stringify(body),
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        })
+            .then((res) => res.json())
+            .then((token) => {
+            if (token.error) {
+                return reject(token.error);
+            }
+            return resolve(token);
+        })
+            .catch((e) => reject(e))));
+    }
+    ;
+};
+NewNuxeoOverride = __decorate([
+    __param(1, Inject('environment'))
+], NewNuxeoOverride);
+export { NewNuxeoOverride };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-nuxeo-overide.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/nuxeo/new-nuxeo-overide.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject } from \"@angular/core\";\r\nimport { KeycloakService } from \"keycloak-angular\";\r\nimport { CookieService } from \"ngx-cookie-service\";\r\n\r\nconst Nuxeo = require('nuxeo');\r\nconst doFetch = require('nuxeo/lib/deps/fetch');\r\nconst Unmarshallers = require('nuxeo/lib/unmarshallers/unmarshallers');\r\nconst Authentication = require('nuxeo/lib/auth/auth');\r\nconst qs = require('querystring');\r\n\r\nexport class NewNuxeoOverride extends Nuxeo {\r\n    \r\n    constructor(opts = {} , @Inject('environment') private environment , \r\n    private cookieService : CookieService) {\r\n    super(opts);\r\n  }\r\n  http(opts: any = {}) {\r\n    const options = this._computeFetchOptions(opts);\r\n    return new this.Promise((resolve, reject) => {\r\n      this._activeRequests += 1;\r\n\r\n      const fetchOptions: any = {\r\n        method: options.method,\r\n        headers: options.headers,\r\n        body: options.body,\r\n        signal: options.signal,\r\n      };\r\n      if (opts.credentials) {\r\n        fetchOptions.credentials = opts.credentials;\r\n      } else if (!this._auth) {\r\n        fetchOptions.credentials = 'include';\r\n      }\r\n\r\n      doFetch(options.url, fetchOptions)\r\n        .then((res) => {\r\n          this._activeRequests -= 1;\r\n          if (res.status === 401 && !opts.refreshedAuthentication) {\r\n            // try re-authenticate\r\n            opts.refreshedAuthentication = true;\r\n            return this.refreshAccessToken()\r\n            // return Authentication.refreshAuthentication(this._baseURL, this._auth)\r\n              .then((refreshedToken) => {\r\n                //   this.keycloak.getToken().then(refreshedAuth => {\r\n                    this._auth = {\r\n                        method: 'bearerToken',\r\n                        token: refreshedToken,\r\n                        clientId: this.environment.nuxeoOptions.client_id, // optional OAuth2 client ID to refresh the access token\r\n                        clientSecret: this.environment.nuxeoOptions.client_secret\r\n                      };\r\n                    this._notifyAuthenticationRefreshed(refreshedToken);\r\n                    this.cookieService.set('CMS_CACHABLE' , this.encriptFormating(res) , 1 , '/cts')\r\n                    return resolve(this.http(opts));\r\n                //   });\r\n              } , (error) => {\r\n                this.logout();\r\n                this.login();\r\n                \r\n              })\r\n              .catch(() => {\r\n                this.logout();\r\n                this.login();\r\n                throw res;\r\n              });\r\n          }\r\n\r\n          if (!(/^2/.test(`${res.status}`))) {\r\n            const error = new Error(res);\r\n            throw res;\r\n          }\r\n\r\n          if (options.resolveWithFullResponse || res.status === 204) {\r\n            return resolve(res);\r\n          }\r\n\r\n          const contentType = res.headers.get('content-type');\r\n          if (contentType && contentType.indexOf('application/json') === 0) {\r\n            options.nuxeo = this;\r\n            return resolve(res.json().then((json) => Unmarshallers.unmarshall(json, options, res)));\r\n          }\r\n          return resolve(res);\r\n        }).catch((error) => {\r\n          this._activeRequests -= 1;\r\n          error.text().then(data => {\r\n            let ret = {};\r\n            try {\r\n              ret = data ? JSON.parse(data) : {};\r\n            } catch (e) {\r\n              ret = {};\r\n            }\r\n            return reject({\r\n              status: error.status,\r\n              ret\r\n            });\r\n          });\r\n        });\r\n    });\r\n  }\r\n\r\n  refreshAccessToken() : Promise<any> {\r\n    return this.getAccessToken(this.environment.nuxeoOptions.baseURL, this.environment.nuxeoOptions.client_id,\r\n      this._auth.token.refresh_token, this.environment.nuxeoOptions.client_secret)\r\n  }\r\n\r\n  login(){\r\n    window.location.replace(`${this.environment.nuxeoOptions.baseURL}/oauth2/authorize?client_id=${this.environment.nuxeoOptions.client_id}&client_secret=${this.environment.nuxeoOptions.client_secret}&response_type=code&redirect_uri=${this.environment.nuxeoOptions.authRedirectURL}`);\r\n  }\r\n\r\n  logout(){\r\n    this.cookieService.set('CMS_CACHABLE' , '' , 1 , '/cts')\r\n  }\r\n\r\n  encriptFormating(cachable){\r\n    let reformatted =  btoa(JSON.stringify(cachable));\r\n    return 'Xnd' + reformatted + 'HsTeT'\r\n    }\r\n\r\n    // nrefreshAccessToken = (baseURL, clientId, refreshToken, params = {}) => {\r\n    //   if (!baseURL) {\r\n    //     throw new Error('Missing `baseURL` argument');\r\n    //   }\r\n    //   if (!clientId) {\r\n    //     throw new Error('Missing `clientId` argument');\r\n    //   }\r\n    //   if (!refreshToken) {\r\n    //     throw new Error('Missing `refreshToken` argument');\r\n    //   }\r\n  \r\n    //   const defaultParams = { refresh_token: refreshToken, grant_type: 'refresh_token', client_id: clientId };\r\n    //   const body = extend(true, defaultParams, params);\r\n    //   return fetchAccessToken(baseURL, body);\r\n    // }\r\n\r\n    getAccessToken(baseURL, clientId , refreshToken , clientSecret) {\r\n      let body = {\r\n        refresh_token: refreshToken, \r\n        grant_type: 'refresh_token', \r\n        client_id: clientId ,  \r\n        client_secret : clientSecret\r\n      }\r\n      // const url = baseURL.endsWith('/') ? baseURL : `${baseURL}/`;\r\n      return new Promise((resolve, reject) => (\r\n        doFetch(`${baseURL}/oauth2/token`, {\r\n          method: 'POST',\r\n          body: qs.stringify(body),\r\n          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\r\n        })\r\n          .then((res) => res.json())\r\n          .then((token) => {\r\n            if (token.error) {\r\n              return reject(token.error);\r\n            }\r\n            return resolve(token);\r\n          })\r\n          .catch((e) => reject(e))\r\n      ));\r\n    };\r\n}\r\n"]}