nuxeo-development-framework 3.1.6 → 3.1.8

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

@@ -1,160 +0,0 @@
-
-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

@@ -1,137 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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();
-  });
-});