nuxeo-development-framework 3.1.4 → 3.1.6

package/src/lib/Core/services/extension/extension-loader.service.ts

@@ -0,0 +1,160 @@
+
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { ContentActionType } from './action.extensions';
+import { filterEnabled, getValue, mergeObjects, sortByOrder } from './extenion-utils';
+
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ExtensionLoaderService {
+    constructor(private http: HttpClient) {
+    }
+
+    load(configPath: string, pluginsPath: string, extensions?: string[]): Promise<any> {
+        return new Promise<any>((resolve) => {
+            this.loadConfig(configPath, 0).then((result) => {
+                if (result) {
+                    let config = result.config;
+
+                    const override = sessionStorage.getItem('app.extension.config');
+                    if (override) {
+                        config = JSON.parse(override);
+                    }
+
+                    if (!config.$references || !config.$references.length) {
+                        config.$references = this.filterIgnoredExtensions(extensions || [], config.$ignoreReferenceList);
+                    } else {
+                        config.$references = this.filterIgnoredExtensions(config.$references, config.$ignoreReferenceList);
+                    }
+
+                    if (config.$references && config.$references.length > 0) {
+                        const plugins = config.$references.map((name, idx) =>
+                            this.loadConfig(`${pluginsPath}/${name}`, idx)
+                        );
+
+                        Promise.all(plugins).then((results) => {
+                            const configs = results
+                                .filter((entry:any) => entry)
+                                .sort(sortByOrder)
+                                .map((entry:any) => entry.config);
+
+                            if (configs.length > 0) {
+                                config = mergeObjects(config, ...configs);
+                            }
+
+                            config = {
+                                ...config,
+                                ...this.getMetadata(result.config),
+                                $references: configs.map((ext) => this.getMetadata(ext))
+                            };
+
+                            resolve(config);
+                        });
+                    } else {
+                        resolve(config);
+                    }
+                }
+            });
+        });
+    }
+
+    protected getMetadata(config: any): any {
+        const result: any = {};
+
+        Object
+            .keys(config)
+            .filter((key) => key.startsWith('$'))
+            .forEach((key) => {
+                result[key] = config[key];
+            });
+
+        return result;
+    }
+
+    protected loadConfig(
+        url: string,
+        order: number
+    ): Promise<{ order: number; config: any }> {
+        return new Promise((resolve) => {
+            this.http.get<any>(url).subscribe(
+                (config) => {
+                    resolve({
+                        order,
+                        config
+                    });
+                },
+                () => {
+                    resolve(null);
+                }
+            );
+        });
+    }
+
+    /**
+     * Retrieves configuration elements.
+     * Filters element by **enabled** and **order** attributes.
+     * Example:
+     *  `getElements<ViewerExtensionRef>(config, 'features.viewer.content')`
+     */
+    getElements<T extends any>(
+        config: any,
+        key: string,
+        fallback: Array<T> = []
+    ): Array<T> {
+        const values = getValue(config, key) || fallback || [];
+        return values.filter(filterEnabled).sort(sortByOrder);
+    }
+
+    getContentActions(
+        config: any,
+        key: string
+    ): Array<any> {
+        return this.getElements(config, key).map(this.setActionDefaults);
+    }
+
+    getRules(config: any): Array<any> {
+        if (config && config.rules) {
+            return config.rules;
+        }
+        return [];
+    }
+
+    getRoutes(config: any): Array<any> {
+        if (config) {
+            return config.routes || [];
+        }
+        return [];
+    }
+
+    getActions(config: any): Array<any> {
+        if (config) {
+            return config.actions || [];
+        }
+        return [];
+    }
+
+    getFeatures(config: any): any {
+        if (config) {
+            return config.features || [];
+        }
+        return [];
+    }
+
+    protected setActionDefaults(action: any): any {
+        if (action) {
+            action.type = action.type || ContentActionType.default;
+            action.icon = action.icon || 'extension';
+        }
+        return action;
+    }
+
+    private filterIgnoredExtensions(extensions: Array<string | any>, ignoreReferenceList: string[]): Array<string | any> {
+        if (!ignoreReferenceList || !ignoreReferenceList.length) {
+            return extensions;
+        }
+
+        return extensions.map((file: string) => file.match('(?!.*\/).+')[0]).filter((fileName: string) => !ignoreReferenceList.includes(fileName));
+    }
+}

package/src/lib/Core/services/extension/extension.service.ts

@@ -0,0 +1,137 @@
+import { Injectable, Type, InjectionToken, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ComponentRegisterService } from './component-register.service';
+import { ExtensionLoaderService } from './extension-loader.service';
+
+export function extensionJsonsFactory() {
+    return [];
+}
+
+export const EXTENSION_JSONS = new InjectionToken<string[][]>('extension-jsons', {
+    providedIn: 'root',
+    factory: extensionJsonsFactory
+});
+
+export function provideExtensionConfig(jsons: string[]) {
+    return {
+        provide: EXTENSION_JSONS,
+        useValue: jsons,
+        multi: true
+    };
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ExtensionService {
+
+    protected config = null;
+
+    configPath = 'assets/app.extensions.json';
+    pluginsPath = 'assets/plugins';
+    features: Array<any> = [];
+    authGuards: { [key: string]: Type<{}> } = {};
+
+    protected onSetup$ = new BehaviorSubject<any>(this.config);
+    setup$ = this.onSetup$.asObservable();
+
+    constructor(
+        protected loader: ExtensionLoaderService,
+        protected componentRegister: ComponentRegisterService,
+        @Inject(EXTENSION_JSONS) protected extensionJsons: string[]
+    ) {
+    }
+
+
+
+
+    /**
+     * Gets features by key.
+     * @param key Key string, using dot notation
+     * @returns Features array found by key
+     */
+    getFeature(key: string): any[] {
+        const properties: string[] = Array.isArray(key) ? [key] : key.split('.');
+        return properties.reduce((prev, curr) => prev && prev[curr], this.features) || [];
+    }
+
+    getElements(key: string, fallback: Array<any> = []): Array<any> {
+        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: { [key: string]: Type<{}> }) {
+        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: { [key: string]: Type<{}> }) {
+        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: string[]): Array<Type<{}>> {
+        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<T>(id: string) {
+        return this.componentRegister.getComponentById<T>(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: string | {} , context?: any) {
+        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;
+        }
+    }
+
+    private evaluateExpression(value: string, context?: any): string {
+        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;
+    }
+}

package/src/lib/Core/services/initialization/initialization.service.ts

@@ -0,0 +1,50 @@
+import { Inject, Injectable } from '@angular/core';
+import { KeycloakService } from 'keycloak-angular';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+import { UserPreferencesService } from '../user/user-preferences.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class InitializationService {
+
+  constructor(
+    private keycloak: KeycloakService,
+    private nuxeoService: NuxeoService, 
+    private userPreferences: UserPreferencesService, 
+    @Inject('environment') private environment
+  ) { }
+
+  initializer() {
+  return new Promise(async (resolve, reject) => {
+      try {
+        await 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);
+      }
+
+    });
+  }
+}

package/src/lib/Core/services/localStorag/local-storag.service.ts

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LocalStoragService {
+
+  private memoryStore: { [key: string]: any } = {};
+  private readonly useLocalStorage: boolean = false;
+  private _prefix: string = '';
+
+  get prefix() {
+    return this._prefix;
+  }
+
+  set prefix(prefix: string) {
+    this._prefix = prefix ? prefix + '_' : '';
+  }
+
+  constructor() {
+    this.useLocalStorage = this.storageAvailable('localStorage');
+  }
+
+
+  /**
+   * Gets an item.
+   * @param key Key to identify the item
+   * @returns The item (if any) retrieved by the key
+   */
+  getItem(key: string): string | null {
+    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: string, data: string) {
+    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: string) {
+    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: string): boolean {
+    if (this.useLocalStorage) {
+      return localStorage.getItem(this.prefix + key) ? true : false;
+    } else {
+      return this.memoryStore.hasOwnProperty(key);
+    }
+  }
+
+  private storageAvailable(type: string): boolean {
+    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: string): any {
+    const ijsKey = 'cts' + key;
+    const data = window.localStorage.getItem(ijsKey);
+    if (data) {
+      return JSON.parse(data);
+    } else {
+      return null;
+    }
+  }
+
+  setLocal(key: string, value: any): void {
+    const ijsKey = 'cts' + key;
+    const data = value === undefined ? '' : JSON.stringify(value);
+    window.localStorage.setItem(ijsKey, data);
+  }
+
+  removeLocal(key: string): void {
+    const ijsKey = 'cts' + key;
+    window.localStorage.removeItem(ijsKey);
+  }
+
+  removeAllLocals(): void {
+    for (const key in window.localStorage) {
+      if (window.localStorage.hasOwnProperty(key)) {
+        window.localStorage.removeItem(key);
+      }
+    }
+  }
+}

package/src/lib/Core/services/nuxeo/nuxeo-override.ts

@@ -0,0 +1,86 @@
+import { KeycloakService } from "keycloak-angular";
+
+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 = {}, private keycloak: KeycloakService) {
+    super(opts);
+  }
+  http(opts: any = {}) {
+    const options = this._computeFetchOptions(opts);
+    return new this.Promise((resolve, reject) => {
+      this._activeRequests += 1;
+
+      const fetchOptions: any = {
+        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
+            });
+          });
+        });
+    });
+  }
+
+
+}

package/src/lib/Core/services/nuxeo/nuxeo.service.ts

@@ -0,0 +1,123 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import {Inject, Injectable} from '@angular/core';
+import { KeycloakService } from 'keycloak-angular';
+import { from, Observable } from 'rxjs';
+import { catchError, map, share, tap } from 'rxjs/operators';
+import { NuxeoOverride as Nuxeo } from './nuxeo-override';
+import {APP_BASE_HREF} from '@angular/common';
+import { RolesService } from '../roles/roles.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NuxeoService {
+  nuxeoClient;
+  excludedUrls = [];
+  enableBearerInterceptor = true;
+  authenticated = false;
+  token;
+  tokenObservable;
+  constructor(private http: HttpClient, private keycloak: KeycloakService, 
+    @Inject(APP_BASE_HREF) private baseHref: string, 
+    @Inject('environment') private environment,
+    private rolesService : RolesService) {
+
+  }
+  init(): Promise<any> {
+    return new Promise(async (resolve, reject) => {
+      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: any, committeeCode = null): Observable<any> {
+    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): any {
+    return new Nuxeo.Blob({
+      content: file
+    });
+  }
+
+  getDuplicates(params = {}, body = {}): Observable<any> {
+    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();
+  }
+
+  ctsUser = false;
+  isCtsUser(){
+    this.isUserInRole('ctsSecretary', '').subscribe(data => {
+      this.ctsUser = data;
+    })
+  }
+  ctsManger= false;
+  isCtsManger(){
+    this.isUserInRole('ctsManger', '').subscribe(data => {
+      this.ctsManger = data;
+    })
+  }
+}

package/src/lib/Core/services/roles/roles.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { RolesService } from './roles.service';
+
+describe('RolesService', () => {
+  let service: RolesService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(RolesService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});