nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/core/enums/language.enum.ts

@@ -0,0 +1,4 @@
+export enum Lang {
+  Arabic = 'ar',
+  English = 'en'
+}

package/src/lib/core/env/env-manager.ts

@@ -0,0 +1,55 @@
+export interface Environment {
+  [key: string]: any;
+  production?: boolean;
+  nuxeo?: string;
+  easyShare?: string;
+  mainFolder?: string;
+  customAutomation?: string;
+  create?: string;
+  documentContent?: string;
+  notifications?: string;
+  konfuzioIframeIP?: string;
+  commentsApi?: string;
+  clientName?: string;
+  showDocsTypesPage?: string;
+  showRetentionRule?: string;
+  showRegistrationMethod?: string;
+  externalShareEnabled?: boolean;
+  keycloak?: {
+    url?: string;
+    realm?: string;
+    clientId?: string;
+  };
+  RolesConstants?: {
+    [key: string]: string | undefined;
+  };
+  enableViewerWaterMark?: boolean;
+  enablePdfLinearization?: string;
+  pdftronLicenceKey?: string;
+  pdftronVideoLicenceKey?: string;
+  dynamsoftProductKey?: string;
+  imaggaEnabled?: string;
+  enableRegisteration?: string;
+  enableSystemConfiguration?: string;
+  enableSearchNewDesign?: string;
+  enableSearchToggles?: string;
+  personScoreThreshold?: string;
+  officeEditAuthGrantMode?: string;
+  permanentMembership?: string;
+  maxFileSize?: number;
+  allowedFileTypes?: string;
+  allDepartmentFolders?: string;
+  showShutterStackFilter?: string;
+  showDocsValidationPage?: string;
+  showDataCatalogPage?: boolean;
+  enableDataCatalogConfiguration?: boolean;
+  faceRecognitionEnabled?: string;
+}
+
+export class EnvManager {
+  static environment: Environment = null;
+
+  static initialize(values: Partial<Environment>): void {
+    this.environment = { ...values };
+  }
+}

package/src/lib/core/env/index.ts

@@ -0,0 +1 @@
+export * from './env-manager';

package/src/lib/core/models/api-response.model.ts

@@ -0,0 +1,25 @@
+import { EntryModel, QuickFilter } from './base-response.models';
+
+export interface ApiResponseModel<TEntry extends Record<string, any> = EntryModel> {
+  'entity-type': string;
+  isPaginable: boolean;
+  resultsCount: number;
+  pageSize: number;
+  maxPageSize: number;
+  resultsCountLimit: number;
+  currentPageSize: number;
+  currentPageIndex: number;
+  currentPageOffset: number;
+  numberOfPages: number;
+  isPreviousPageAvailable: boolean;
+  isNextPageAvailable: boolean;
+  isLastPageAvailable: boolean;
+  isSortable: boolean;
+  hasError: boolean;
+  errorMessage: any;
+  totalSize?: number;
+  pageIndex: number;
+  pageCount: number;
+  quickFilters?: QuickFilter[];
+  entries: TEntry[];
+}

package/src/lib/core/models/automation-response.model.ts

@@ -0,0 +1,27 @@
+import { SchemaModel } from "./base-response.models";
+
+export interface AutomationResponseModel<
+  TProperties extends Record<string, any> = Record<PropertyKey, any>
+> {
+  'entity-type': string;
+  repository: string;
+  uid: string;
+  path: string;
+  type: string;
+  state: string;
+  parentRef: string;
+  isCheckedOut: boolean;
+  isRecord: boolean;
+  retainUntil: any;
+  hasLegalHold: boolean;
+  isUnderRetentionOrLegalHold: boolean;
+  isVersion: boolean;
+  isProxy: boolean;
+  changeToken: string;
+  isTrashed: boolean;
+  title: string;
+  lastModified: string;
+  properties?: TProperties;
+  facets: string[];
+  schemas: SchemaModel[];
+}

package/src/lib/core/models/base-response.models.ts

@@ -0,0 +1,14 @@
+export interface QuickFilter {
+  name: string;
+  active: boolean;
+}
+
+export interface EntryModel {
+  'entity-type': string;
+  state: string;
+}
+
+export interface SchemaModel {
+  name: string;
+  prefix: string;
+}

package/src/lib/core/models/component.model.ts

@@ -0,0 +1,11 @@
+export class ComponentTranslationModel {
+  name: string;
+  path: string;
+  json: string [];
+
+  constructor(obj?: any) {
+      this.name = obj && obj.name;
+      this.path = obj && obj.path;
+      this.json = obj && obj.json || [];
+  }
+}

package/src/lib/core/services/callApi/call-api.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CallApiService {
+  constructor(private nuxeoService: NuxeoService) {}
+
+  query(queryOptions, options): Observable<any> {
+    return this.inerQuery(queryOptions, options);
+  }
+
+  private inerQuery(queryOptions, options): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient.repository().query(queryOptions, options)
+    ).pipe(
+      map((res: any) => {
+        if (res.entries.length > 0) {
+          res.entries.forEach((data) => {
+            delete data._nuxeo;
+            delete data._repository;
+          });
+        }
+        return res;
+      })
+    );
+  }
+}

package/src/lib/core/services/extension/action.extensions.ts

@@ -0,0 +1,35 @@
+import { ExtensionElement } from './extension-element';
+
+export enum ContentActionType {
+    default = 'default',
+    button = 'button',
+    separator = 'separator',
+    menu = 'menu',
+    custom = 'custom'
+}
+
+export interface ContentActionRef extends ExtensionElement {
+    type: ContentActionType;
+
+    title?: string;
+    description?: string;
+    icon?: string;
+    children?: Array<ContentActionRef>;
+    component?: string;
+    data?: any;
+    actions?: {
+        click?: string;
+        [key: string]: string;
+    };
+    rules?: {
+        enabled?: string;
+        visible?: string;
+        [key: string]: string;
+    };
+}
+
+export interface ActionRef {
+    id: string;
+    type: string;
+    payload?: any;
+}

package/src/lib/core/services/extension/component-register.service.ts

@@ -0,0 +1,25 @@
+
+import { Injectable, Type } from '@angular/core';
+
+export interface ExtensionComponent {
+    data: any;
+}
+
+@Injectable({ providedIn: 'root' })
+export class ComponentRegisterService {
+    components: { [key: string]: Type<{}> } = {};
+
+    setComponents(values: { [key: string]: Type<{}> }) {
+        if (values) {
+            this.components = Object.assign({}, this.components, values);
+        }
+    }
+
+    getComponentById<T>(id: string): Type<T> {
+        return <Type<T>> this.components[id];
+    }
+
+    hasComponentById(id: string): boolean {
+        return !!this.getComponentById(id);
+    }
+}

package/src/lib/core/services/extension/extenion-utils.ts

@@ -0,0 +1,142 @@
+
+import { ContentActionRef, ContentActionType } from './action.extensions';
+
+export function getValue(target: any, key: string): any {
+    if (!target) {
+        return undefined;
+    }
+
+    const keys = key.split('.');
+    key = '';
+
+    do {
+        key += keys.shift();
+        const value = target[key];
+        if (
+            value !== undefined &&
+            (typeof value === 'object' || !keys.length)
+        ) {
+            target = value;
+            key = '';
+        } else if (!keys.length) {
+            target = undefined;
+        } else {
+            key += '.';
+        }
+    } while (keys.length);
+
+    return target;
+}
+
+export function filterEnabled(entry: { disabled?: boolean }): boolean {
+    return !entry.disabled;
+}
+
+export function sortByOrder(
+    a: { order?: number | undefined },
+    b: { order?: number | undefined }
+) {
+    const left = a.order === undefined ? Number.MAX_SAFE_INTEGER : a.order;
+    const right = b.order === undefined ? Number.MAX_SAFE_INTEGER : b.order;
+    return left - right;
+}
+
+export function reduceSeparators(
+    acc: ContentActionRef[],
+    el: ContentActionRef,
+    i: number,
+    arr: ContentActionRef[]
+): ContentActionRef[] {
+    // remove leading separator
+    if (i === 0) {
+        if (arr[i].type === ContentActionType.separator) {
+            return acc;
+        }
+    }
+    // remove duplicate separators
+    if (i > 0) {
+        const prev = arr[i - 1];
+        if (
+            prev.type === ContentActionType.separator &&
+            el.type === ContentActionType.separator
+        ) {
+            return acc;
+        }
+
+        // remove trailing separator
+        if (i === arr.length - 1) {
+            if (el.type === ContentActionType.separator) {
+                return acc;
+            }
+        }
+    }
+
+    return acc.concat(el);
+}
+
+export function reduceEmptyMenus(
+    acc: ContentActionRef[],
+    el: ContentActionRef
+): ContentActionRef[] {
+    if (el.type === ContentActionType.menu) {
+        if ((el.children || []).length === 0) {
+            return acc;
+        }
+    }
+    return acc.concat(el);
+}
+
+export function mergeObjects(...objects: object[]): any {
+    const result = {};
+
+    objects.forEach((source) => {
+        Object.keys(source).forEach((prop) => {
+            let replace = false;
+
+            if (prop.endsWith('.$replace')) {
+                replace = true;
+                prop = prop.replace('.$replace', '');
+            }
+
+            if (!prop.startsWith('$')) {
+                if (replace) {
+                    result[prop] = source[`${prop}.$replace`];
+                } else if (prop in result && Array.isArray(result[prop])) {
+                    result[prop] = mergeArrays(result[prop], source[prop]);
+                } else if (prop in result && typeof result[prop] === 'object') {
+                    result[prop] = mergeObjects(result[prop], source[prop]);
+                } else {
+                    result[prop] = source[prop];
+                }
+            }
+        });
+    });
+
+    return result;
+}
+
+export function mergeArrays(left: any[], right: any[]): any[] {
+    const result = [];
+    const map = {};
+
+    (left || []).forEach((entry) => {
+        const element = entry;
+        if (element && element.hasOwnProperty('id')) {
+            map[element.id] = element;
+        } else {
+            result.push(element);
+        }
+    });
+
+    (right || []).forEach((entry) => {
+        const element = entry;
+        if (element && element.hasOwnProperty('id') && map[element.id]) {
+            const merged = mergeObjects(map[element.id], element);
+            map[element.id] = merged;
+        } else {
+            result.push(element);
+        }
+    });
+
+    return Object.keys(map).map((key) => map[key]).concat(result);
+}

package/src/lib/core/services/extension/extension-element.ts

@@ -0,0 +1,6 @@
+export interface ExtensionElement {
+    id: string;
+
+    order?: number;
+    disabled?: boolean;
+}

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;
+    }
+}