nuxeo-development-framework 4.1.6 → 4.1.7

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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