nuxeo-development-framework 5.6.3 → 5.6.4

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,157 @@
+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
+	 * @deprecated This method is deprecated for column components and will be removed in a future version.
+	 * Use `ColumnRendererRegistryService.register()` instead for registering column components.
+	 *
+	 * @example
+	 * // For columns (deprecated)
+	 * this.setComponents({ 'common.components.text': TextComponent, 'number': NumberComponent });
+	 *
+	 * // For columns (recommended - single)
+	 * this.columnRegistry.register({
+	 *   name: 'Text Column',
+	 *   type: 'common.text',
+	 *   category: 'basic',
+	 *   component: TextComponent
+	 * });
+	 *
+	 * // For columns (recommended - multiple)
+	 * this.columnRegistry.register([
+	 *   {
+	 *     name: 'Text Column',
+	 *     type: 'common.text',
+	 *     category: 'basic',
+	 *     component: TextComponent
+	 *   },
+	 *   {
+	 *     name: 'Number Column',
+	 *     type: 'common.number',
+	 *     category: 'basic',
+	 *     component: NumberComponent
+	 *   }
+	 * ]);
+	 *
+	 * // For viewer components (still supported)
+	 * this.setComponents({ 'viewer.components.pdf': PdfViewerComponent });
+	 */
+	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,137 @@
+import { Inject, Injectable } from '@angular/core';
+import { KeycloakService } from 'keycloak-angular';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+import { UserPreferencesService } from '../user/user-preferences.service';
+import { LocalStoragService } from '../localStorag/local-storag.service';
+import { Router, RoutesRecognized } from '@angular/router';
+import { HttpClient } from '@angular/common/http';
+import { Subscription } from 'rxjs';
+import { CookieService } from 'ngx-cookie-service'
+@Injectable({
+  providedIn: 'root'
+})
+export class InitializationService {
+routerSubscription : Subscription;
+  constructor(
+    private keycloak: KeycloakService,
+    private nuxeoService: NuxeoService,
+    private router : Router,
+    private cookieService : CookieService,
+    private httpClient : HttpClient,
+    private storage: LocalStoragService, 
+    private userPreferences: UserPreferencesService, 
+    @Inject('environment') private environment
+  ) { }
+
+  initializer(loginMethod = 'keyclock') {
+  return new Promise(async (resolve, reject) => {
+      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);
+      }
+
+    });
+  }
+
+  async initiateKeyClock(){
+    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();
+   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 : any) => {
+      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 : string){
+   let newFormate = formate.substring(3,(formate.length-5));
+   return JSON.parse(atob(newFormate))
+  }
+
+}

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/ndf-transform.service.ts

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+export interface NdfTransformerDataModel {
+	id?: string;
+	code?: string;
+	arabicTitle: string;
+	englishTitle: string;
+}
+
+export type NdfTransformerFunction = (keys: string[]) => Observable<NdfTransformerDataModel[]>;
+
+@Injectable({
+	providedIn: 'root'
+})
+export class NdfTransformService {
+	private readonly _transformations = new Map<string, NdfTransformerFunction>();
+
+	/**
+	 * Registers one or multiple transformer functions.
+	 *
+	 * @param {Record<string, NdfTransformerFunction> | string} keys - A record of key-function pairs or a single key.
+	 * @param {NdfTransformerFunction} [arg2] - A transformer function if registering a single key.
+	 */
+	register(keys: Record<string, NdfTransformerFunction>): void;
+	register(key: string, fn: NdfTransformerFunction): void;
+	register(arg1: string | Record<string, NdfTransformerFunction>, arg2?: NdfTransformerFunction): void {
+		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: string): NdfTransformerFunction | undefined {
+		return this._transformations.get(key);
+	}
+
+	/**
+	 * Retrieves all registered transformer functions.
+	 *
+	 * @returns {Map<string, NdfTransformerFunction>} - A map of all transformer functions.
+	 */
+	getAll(): Map<string, NdfTransformerFunction> {
+		return this._transformations;
+	}
+
+	/**
+	 * Clears all registered transformer functions.
+	 */
+	clear(): void {
+		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: string): boolean {
+		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: string): void {
+		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: string, keys: string[]): Observable<NdfTransformerDataModel[]> {
+		const fn = this.get(key);
+		if (!fn) {
+			throw new Error(`No transformer registered for key: ${key}`);
+		}
+		return fn(keys);
+	}
+}