nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/core/services/ndf-transform.service.js

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NdfTransformService {
+    constructor() {
+        this._transformations = new Map();
+    }
+    register(arg1, arg2) {
+        if (typeof arg1 === 'object') {
+            Object.entries(arg1).forEach(([key, fn]) => this._transformations.set(key, fn));
+            return;
+        }
+        if (typeof arg1 === 'string' && arg2) {
+            this._transformations.set(arg1, arg2);
+        }
+    }
+    /**
+     * Retrieves a transformer function by its key.
+     *
+     * @param {string} key - The key of the transformer function.
+     * @returns {NdfTransformerFunction | undefined} - The transformer function or undefined if not found.
+     */
+    get(key) {
+        return this._transformations.get(key);
+    }
+    /**
+     * Retrieves all registered transformer functions.
+     *
+     * @returns {Map<string, NdfTransformerFunction>} - A map of all transformer functions.
+     */
+    getAll() {
+        return this._transformations;
+    }
+    /**
+     * Clears all registered transformer functions.
+     */
+    clear() {
+        this._transformations.clear();
+    }
+    /**
+     * Checks if a transformer function is registered for a specific key.
+     *
+     * @param {string} key - The key to check.
+     * @returns {boolean} - True if the key exists, false otherwise.
+     */
+    has(key) {
+        return this._transformations.has(key);
+    }
+    /**
+     * Removes a transformer function by its key.
+     *
+     * @param {string} key - The key of the transformer function to remove.
+     */
+    remove(key) {
+        this._transformations.delete(key);
+    }
+    /**
+     * Executes a transformer function for a specific key with the provided input keys.
+     *
+     * @param {string} key - The key of the transformer function to execute.
+     * @param {string[]} keys - The input keys to pass to the transformer function.
+     * @throws {Error} - If no transformer function is registered for the key.
+     * @returns {Observable<NdfTransformerDataModel[]>} - The result of the transformer function.
+     */
+    transform(key, keys) {
+        const fn = this.get(key);
+        if (!fn) {
+            throw new Error(`No transformer registered for key: ${key}`);
+        }
+        return fn(keys);
+    }
+}
+NdfTransformService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfTransformService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NdfTransformService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfTransformService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmRmLXRyYW5zZm9ybS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9uZGYtdHJhbnNmb3JtLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFlM0MsTUFBTSxPQUFPLG1CQUFtQjtJQUhoQztRQUlrQixxQkFBZ0IsR0FBRyxJQUFJLEdBQUcsRUFBa0MsQ0FBQztLQWlGOUU7SUF2RUEsUUFBUSxDQUFDLElBQXFELEVBQUUsSUFBNkI7UUFDNUYsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLEVBQUU7WUFDN0IsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUNoRixPQUFPO1NBQ1A7UUFFRCxJQUFJLE9BQU8sSUFBSSxLQUFLLFFBQVEsSUFBSSxJQUFJLEVBQUU7WUFDckMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7U0FDdEM7SUFDRixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxHQUFHLENBQUMsR0FBVztRQUNkLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU07UUFDTCxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQztJQUM5QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxLQUFLO1FBQ0osSUFBSSxDQUFDLGdCQUFnQixDQUFDLEtBQUssRUFBRSxDQUFDO0lBQy9CLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILEdBQUcsQ0FBQyxHQUFXO1FBQ2QsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLEdBQVc7UUFDakIsSUFBSSxDQUFDLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILFNBQVMsQ0FBQyxHQUFXLEVBQUUsSUFBYztRQUNwQyxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxFQUFFLEVBQUU7WUFDUixNQUFNLElBQUksS0FBSyxDQUFDLHNDQUFzQyxHQUFHLEVBQUUsQ0FBQyxDQUFDO1NBQzdEO1FBQ0QsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDakIsQ0FBQzs7aUhBakZXLG1CQUFtQjtxSEFBbkIsbUJBQW1CLGNBRm5CLE1BQU07NEZBRU4sbUJBQW1CO2tCQUgvQixVQUFVO21CQUFDO29CQUNYLFVBQVUsRUFBRSxNQUFNO2lCQUNsQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBOZGZUcmFuc2Zvcm1lckRhdGFNb2RlbCB7XHJcblx0aWQ/OiBzdHJpbmc7XHJcblx0Y29kZT86IHN0cmluZztcclxuXHRhcmFiaWNUaXRsZTogc3RyaW5nO1xyXG5cdGVuZ2xpc2hUaXRsZTogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgdHlwZSBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uID0gKGtleXM6IHN0cmluZ1tdKSA9PiBPYnNlcnZhYmxlPE5kZlRyYW5zZm9ybWVyRGF0YU1vZGVsW10+O1xyXG5cclxuQEluamVjdGFibGUoe1xyXG5cdHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgTmRmVHJhbnNmb3JtU2VydmljZSB7XHJcblx0cHJpdmF0ZSByZWFkb25seSBfdHJhbnNmb3JtYXRpb25zID0gbmV3IE1hcDxzdHJpbmcsIE5kZlRyYW5zZm9ybWVyRnVuY3Rpb24+KCk7XHJcblxyXG5cdC8qKlxyXG5cdCAqIFJlZ2lzdGVycyBvbmUgb3IgbXVsdGlwbGUgdHJhbnNmb3JtZXIgZnVuY3Rpb25zLlxyXG5cdCAqXHJcblx0ICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uPiB8IHN0cmluZ30ga2V5cyAtIEEgcmVjb3JkIG9mIGtleS1mdW5jdGlvbiBwYWlycyBvciBhIHNpbmdsZSBrZXkuXHJcblx0ICogQHBhcmFtIHtOZGZUcmFuc2Zvcm1lckZ1bmN0aW9ufSBbYXJnMl0gLSBBIHRyYW5zZm9ybWVyIGZ1bmN0aW9uIGlmIHJlZ2lzdGVyaW5nIGEgc2luZ2xlIGtleS5cclxuXHQgKi9cclxuXHRyZWdpc3RlcihrZXlzOiBSZWNvcmQ8c3RyaW5nLCBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uPik6IHZvaWQ7XHJcblx0cmVnaXN0ZXIoa2V5OiBzdHJpbmcsIGZuOiBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uKTogdm9pZDtcclxuXHRyZWdpc3RlcihhcmcxOiBzdHJpbmcgfCBSZWNvcmQ8c3RyaW5nLCBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uPiwgYXJnMj86IE5kZlRyYW5zZm9ybWVyRnVuY3Rpb24pOiB2b2lkIHtcclxuXHRcdGlmICh0eXBlb2YgYXJnMSA9PT0gJ29iamVjdCcpIHtcclxuXHRcdFx0T2JqZWN0LmVudHJpZXMoYXJnMSkuZm9yRWFjaCgoW2tleSwgZm5dKSA9PiB0aGlzLl90cmFuc2Zvcm1hdGlvbnMuc2V0KGtleSwgZm4pKTtcclxuXHRcdFx0cmV0dXJuO1xyXG5cdFx0fVxyXG5cclxuXHRcdGlmICh0eXBlb2YgYXJnMSA9PT0gJ3N0cmluZycgJiYgYXJnMikge1xyXG5cdFx0XHR0aGlzLl90cmFuc2Zvcm1hdGlvbnMuc2V0KGFyZzEsIGFyZzIpO1xyXG5cdFx0fVxyXG5cdH1cclxuXHJcblx0LyoqXHJcblx0ICogUmV0cmlldmVzIGEgdHJhbnNmb3JtZXIgZnVuY3Rpb24gYnkgaXRzIGtleS5cclxuXHQgKlxyXG5cdCAqIEBwYXJhbSB7c3RyaW5nfSBrZXkgLSBUaGUga2V5IG9mIHRoZSB0cmFuc2Zvcm1lciBmdW5jdGlvbi5cclxuXHQgKiBAcmV0dXJucyB7TmRmVHJhbnNmb3JtZXJGdW5jdGlvbiB8IHVuZGVmaW5lZH0gLSBUaGUgdHJhbnNmb3JtZXIgZnVuY3Rpb24gb3IgdW5kZWZpbmVkIGlmIG5vdCBmb3VuZC5cclxuXHQgKi9cclxuXHRnZXQoa2V5OiBzdHJpbmcpOiBOZGZUcmFuc2Zvcm1lckZ1bmN0aW9uIHwgdW5kZWZpbmVkIHtcclxuXHRcdHJldHVybiB0aGlzLl90cmFuc2Zvcm1hdGlvbnMuZ2V0KGtleSk7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBSZXRyaWV2ZXMgYWxsIHJlZ2lzdGVyZWQgdHJhbnNmb3JtZXIgZnVuY3Rpb25zLlxyXG5cdCAqXHJcblx0ICogQHJldHVybnMge01hcDxzdHJpbmcsIE5kZlRyYW5zZm9ybWVyRnVuY3Rpb24+fSAtIEEgbWFwIG9mIGFsbCB0cmFuc2Zvcm1lciBmdW5jdGlvbnMuXHJcblx0ICovXHJcblx0Z2V0QWxsKCk6IE1hcDxzdHJpbmcsIE5kZlRyYW5zZm9ybWVyRnVuY3Rpb24+IHtcclxuXHRcdHJldHVybiB0aGlzLl90cmFuc2Zvcm1hdGlvbnM7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBDbGVhcnMgYWxsIHJlZ2lzdGVyZWQgdHJhbnNmb3JtZXIgZnVuY3Rpb25zLlxyXG5cdCAqL1xyXG5cdGNsZWFyKCk6IHZvaWQge1xyXG5cdFx0dGhpcy5fdHJhbnNmb3JtYXRpb25zLmNsZWFyKCk7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBDaGVja3MgaWYgYSB0cmFuc2Zvcm1lciBmdW5jdGlvbiBpcyByZWdpc3RlcmVkIGZvciBhIHNwZWNpZmljIGtleS5cclxuXHQgKlxyXG5cdCAqIEBwYXJhbSB7c3RyaW5nfSBrZXkgLSBUaGUga2V5IHRvIGNoZWNrLlxyXG5cdCAqIEByZXR1cm5zIHtib29sZWFufSAtIFRydWUgaWYgdGhlIGtleSBleGlzdHMsIGZhbHNlIG90aGVyd2lzZS5cclxuXHQgKi9cclxuXHRoYXMoa2V5OiBzdHJpbmcpOiBib29sZWFuIHtcclxuXHRcdHJldHVybiB0aGlzLl90cmFuc2Zvcm1hdGlvbnMuaGFzKGtleSk7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBSZW1vdmVzIGEgdHJhbnNmb3JtZXIgZnVuY3Rpb24gYnkgaXRzIGtleS5cclxuXHQgKlxyXG5cdCAqIEBwYXJhbSB7c3RyaW5nfSBrZXkgLSBUaGUga2V5IG9mIHRoZSB0cmFuc2Zvcm1lciBmdW5jdGlvbiB0byByZW1vdmUuXHJcblx0ICovXHJcblx0cmVtb3ZlKGtleTogc3RyaW5nKTogdm9pZCB7XHJcblx0XHR0aGlzLl90cmFuc2Zvcm1hdGlvbnMuZGVsZXRlKGtleSk7XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBFeGVjdXRlcyBhIHRyYW5zZm9ybWVyIGZ1bmN0aW9uIGZvciBhIHNwZWNpZmljIGtleSB3aXRoIHRoZSBwcm92aWRlZCBpbnB1dCBrZXlzLlxyXG5cdCAqXHJcblx0ICogQHBhcmFtIHtzdHJpbmd9IGtleSAtIFRoZSBrZXkgb2YgdGhlIHRyYW5zZm9ybWVyIGZ1bmN0aW9uIHRvIGV4ZWN1dGUuXHJcblx0ICogQHBhcmFtIHtzdHJpbmdbXX0ga2V5cyAtIFRoZSBpbnB1dCBrZXlzIHRvIHBhc3MgdG8gdGhlIHRyYW5zZm9ybWVyIGZ1bmN0aW9uLlxyXG5cdCAqIEB0aHJvd3Mge0Vycm9yfSAtIElmIG5vIHRyYW5zZm9ybWVyIGZ1bmN0aW9uIGlzIHJlZ2lzdGVyZWQgZm9yIHRoZSBrZXkuXHJcblx0ICogQHJldHVybnMge09ic2VydmFibGU8TmRmVHJhbnNmb3JtZXJEYXRhTW9kZWxbXT59IC0gVGhlIHJlc3VsdCBvZiB0aGUgdHJhbnNmb3JtZXIgZnVuY3Rpb24uXHJcblx0ICovXHJcblx0dHJhbnNmb3JtKGtleTogc3RyaW5nLCBrZXlzOiBzdHJpbmdbXSk6IE9ic2VydmFibGU8TmRmVHJhbnNmb3JtZXJEYXRhTW9kZWxbXT4ge1xyXG5cdFx0Y29uc3QgZm4gPSB0aGlzLmdldChrZXkpO1xyXG5cdFx0aWYgKCFmbikge1xyXG5cdFx0XHR0aHJvdyBuZXcgRXJyb3IoYE5vIHRyYW5zZm9ybWVyIHJlZ2lzdGVyZWQgZm9yIGtleTogJHtrZXl9YCk7XHJcblx0XHR9XHJcblx0XHRyZXR1cm4gZm4oa2V5cyk7XHJcblx0fVxyXG59XHJcbiJdfQ==

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"]}

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,155 @@
+import { __awaiter } from "tslib";
+import { APP_BASE_HREF } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { NewNuxeoOverride as myNuxeo } from './new-nuxeo-overide';
+import { NuxeoOverride as Nuxeo } from './nuxeo-override';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "keycloak-angular";
+import * as i3 from "ngx-cookie-service";
+import * as i4 from "../roles/roles.service";
+export class NuxeoService {
+    constructor(http, keycloak, baseHref, environment, cookiesService, rolesService) {
+        this.http = http;
+        this.keycloak = keycloak;
+        this.baseHref = baseHref;
+        this.environment = environment;
+        this.cookiesService = cookiesService;
+        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);
+            }
+        }));
+    }
+    initWithNuxeoToken(token) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.createClientWithNuxeoToken(token);
+                this.nuxeoClient.connect()
+                    .then((client) => {
+                    this.authenticated = true;
+                    resolve(client);
+                    this.checkForRoles();
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        }));
+    }
+    // create nuxeo client using nuxeo token
+    createClientWithNuxeoToken(token) {
+        this.nuxeoClient = new myNuxeo({
+            baseURL: this.environment.nuxeoOptions.baseURL,
+            auth: {
+                method: 'bearerToken',
+                token: token,
+                clientId: this.environment.nuxeoOptions.client_id,
+                clientSecret: this.environment.nuxeoOptions.client_secret
+            }
+        }, this.environment, this.cookiesService);
+    }
+    // create nuxeo client using keycock token
+    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.17", ngImport: i0, type: NuxeoService, deps: [{ token: i1.HttpClient }, { token: i2.KeycloakService }, { token: APP_BASE_HREF }, { token: 'environment' }, { token: i3.CookieService }, { token: i4.RolesService }], target: i0.ɵɵFactoryTarget.Injectable });
+NuxeoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NuxeoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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.CookieService }, { type: i4.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 { APP_BASE_HREF } from '@angular/common';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { KeycloakService } from 'keycloak-angular';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { from, Observable } from 'rxjs';\r\nimport { catchError } from 'rxjs/operators';\r\nimport { RolesService } from '../roles/roles.service';\r\nimport { NewNuxeoOverride as myNuxeo } from './new-nuxeo-overide';\r\nimport { NuxeoOverride as Nuxeo } from './nuxeo-override';\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 cookiesService : CookieService,\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\r\n  initWithNuxeoToken(token){\r\n    return new Promise(async (resolve, reject) => {\r\n      try {\r\n          this.createClientWithNuxeoToken(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      } catch (error) {\r\n        reject(error);\r\n      }\r\n    });\r\n  }\r\n\r\n  // create nuxeo client using nuxeo token\r\n  createClientWithNuxeoToken(token){\r\n    this.nuxeoClient = new myNuxeo({\r\n      baseURL: this.environment.nuxeoOptions.baseURL,\r\n      auth: {\r\n        method: 'bearerToken',\r\n        token: token,\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.environment , this.cookiesService);\r\n  }\r\n\r\n  // create nuxeo client using keycock token\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"]}