nuxeo-development-framework 3.1.1 → 3.1.2

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

@@ -0,0 +1,122 @@
+import { Inject, Injectable } from "@angular/core";
+
+@Injectable({
+  providedIn: "root",
+})
+export class RolesService {
+  constructor(@Inject("environment") private environment) {}
+
+  getRoleName(role, code = null): string {
+    if (this.environment.RolesConstants[role]) {
+      return code
+        ? this.environment.RolesConstants[role].replace(
+            "{departmentTitle}",
+            code
+          )
+        : `^${this.environment.RolesConstants[role].replace(
+            "{departmentTitle}",
+            ".*."
+          )}$`;
+    } else {
+      console.warn(`role: ${role} does not exist in roles config`);
+      return role;
+    }
+  }
+
+  isUserInRole(user, role, code = null): boolean {
+    let hasRole = false;
+    const groups = user ? user.extendedGroups || user.groups : [];
+    if (groups && groups.length > 0) {
+      if (Array.isArray(role)) {
+        role.forEach((r) => {
+          if (
+            groups.filter((item) => {
+              if (code) {
+                return (item.name || item) === this.getRoleName(r, code);
+              } else {
+                const regex = new RegExp(this.getRoleName(r));
+                return regex.test(item.name || item);
+              }
+            }).length > 0
+          ) {
+            hasRole = true;
+            return;
+          }
+        });
+      } else {
+        hasRole =
+          groups.filter((item) => {
+            if (code) {
+              return (item.name || item) === this.getRoleName(role, code);
+            } else {
+              const regex = new RegExp(this.getRoleName(role));
+              return regex.test(item.name || item);
+            }
+          }).length > 0;
+      }
+    }
+    return hasRole;
+  }
+
+  getUserRoleName(user, code) {
+    let found = null;
+    const groups = user ? user.extendedGroups || user.groups : [];
+
+    if (groups && groups.length) {
+      Object.keys(this.environment.RolesConstants).forEach((key) => {
+        const roleWCode = this.environment.RolesConstants[key].replace(
+          "{departmentTitle}",
+          code
+        );
+        if((code && roleWCode.includes('dms_user_')) || !code)
+        groups.forEach((group) => {
+          if (group.name || group === roleWCode) {
+            found = key;
+          }
+        });
+      });
+    }
+    return found;
+  }
+
+  isUserManagerInDepartment(user, code) {
+    let filteredRoles = Object.values(this.environment.RolesConstants).filter(
+      (role: any) => role.includes("{departmentTitle}")
+    );
+    let departmentRoles = [];
+    let isUserInDepartment: boolean = false;
+    const groups = user ? user.extendedGroups || user.groups : [];
+    if (groups && groups.length) {
+      filteredRoles.forEach((key: any) => {
+        const roleWCode = key.replace("{departmentTitle}", code);
+        departmentRoles.push(roleWCode);
+      });
+    }
+    departmentRoles = departmentRoles.filter((role: string) => {
+      return role.includes("Manager");
+    });
+    groups.forEach((group) => {
+      const groupName = group.name || group;
+      const departmentIsIncluded: boolean = departmentRoles.includes(groupName);
+      if (departmentIsIncluded) {
+        isUserInDepartment = true;
+      }
+    });
+    return isUserInDepartment;
+  }
+  getUserDepartment(currentUser, prefix = "cts_role_") {
+    let allGroups: string[] = currentUser.properties.groups;
+    let departmentCode = "";
+    allGroups.some((group) => {
+      if (!group.includes("cts_role_sys") && group.includes("cts_role")) {
+        departmentCode = group;
+        return true;
+      }
+    });
+    let prefixLength = prefix.length;
+    departmentCode = departmentCode.substring(prefixLength);
+    let lastIndex = departmentCode.lastIndexOf("_");
+    departmentCode = departmentCode.substring(0, lastIndex);
+    return departmentCode;
+  }
+}

package/src/lib/Core/services/translation/translate-loader.service.ts

@@ -0,0 +1,173 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { TranslateLoader } from '@ngx-translate/core';
+import { Observable, forkJoin, throwError, of } from 'rxjs';
+import { ComponentTranslationModel } from '../../models/component.model';
+import { map, catchError, retry } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TranslateLoaderService implements TranslateLoader {
+
+  private prefix: string = 'i18n';
+  private suffix: string = '.json';
+  private providers: ComponentTranslationModel[] = [];
+  private queue: string[][] = [];
+  private defaultLang: string = 'en';
+
+  constructor(private http: HttpClient) {
+  }
+
+  setDefaultLang(value: string) {
+    this.defaultLang = value || 'en';
+  }
+
+  registerProvider(name: string, path: string) {
+    const registered = this.providers.find((provider) => provider.name === name);
+    if (registered) {
+      registered.path = path;
+    } else {
+      this.providers.push(new ComponentTranslationModel({ name: name, path: path }));
+    }
+  }
+
+  providerRegistered(name: string): boolean {
+    return this.providers.find((x) => x.name === name) ? true : false;
+  }
+
+  fetchLanguageFile(lang: string, component: ComponentTranslationModel, fallbackUrl?: string): Observable<void> {
+    const translationUrl = fallbackUrl || `${component.path}/${this.prefix}/${lang}${this.suffix}?v=${Date.now()}`;
+
+    return this.http.get(translationUrl).pipe(
+      map((res: any) => {
+        component.json[lang] = res;
+      }),
+      retry(3),
+      catchError(() => {
+        if (!fallbackUrl && lang.includes('-')) {
+          const [langId] = lang.split('-');
+
+          if (langId && langId !== this.defaultLang) {
+            const url = `${component.path}/${this.prefix}/${langId}${this.suffix}?v=${Date.now()}`;
+
+            return this.fetchLanguageFile(lang, component, url);
+          }
+        }
+        return throwError(`Failed to load ${translationUrl}`);
+      })
+    );
+  }
+
+  getComponentToFetch(lang: string): Array<Observable<any>> {
+    const observableBatch = [];
+    if (!this.queue[lang]) {
+      this.queue[lang] = [];
+    }
+    this.providers.forEach((component) => {
+
+      if (!this.isComponentInQueue(lang, component.name)) {
+        this.queue[lang].push(component.name);
+        observableBatch.push(
+          this.fetchLanguageFile(lang, component)
+        );
+      }
+    });
+
+    return observableBatch;
+  }
+
+  init(lang: string) {
+    if (this.queue[lang] === undefined) {
+      this.queue[lang] = [];
+    }
+  }
+
+  isComponentInQueue(lang: string, name: string) {
+    return (this.queue[lang] || []).find((x) => x === name) ? true : false;
+  }
+
+  getFullTranslationJSON(lang: string): any {
+    let result = {};
+
+    this.providers
+      .slice(0)
+      .sort((a, b) => {
+        if (a.name === 'app') {
+          return 1;
+        }
+        if (b.name === 'app') {
+          return -1;
+        }
+        return a.name.localeCompare(b.name);
+      })
+      .forEach((model) => {
+        if (model.json && model.json[lang]) {
+          result = this.merge(result, model.json[lang]);
+        }
+      });
+
+    return result;
+  }
+
+  getTranslation(lang: string): Observable<any> {
+    let hasFailures = false;
+    const batch = [
+      ...this.getComponentToFetch(lang).map((observable) => {
+        return observable.pipe(
+          catchError((error) => {
+            console.warn(error);
+            hasFailures = true;
+            return of(error);
+          })
+        );
+      })
+    ];
+
+    return new Observable((observer) => {
+
+      if (batch.length > 0) {
+        forkJoin(batch).subscribe(
+          () => {
+            const fullTranslation = this.getFullTranslationJSON(lang);
+            if (fullTranslation) {
+              observer.next(fullTranslation);
+            }
+            if (hasFailures) {
+              observer.error('Failed to load some resources');
+            } else {
+              observer.complete();
+            }
+          },
+          () => {
+            observer.error('Failed to load some resources');
+          });
+      } else {
+        const fullTranslation = this.getFullTranslationJSON(lang);
+        if (fullTranslation) {
+          observer.next(fullTranslation);
+          observer.complete();
+        }
+      }
+    });
+  }
+
+  merge(...objects): any {
+    const result = {};
+
+    objects.forEach((source) => {
+      Object.keys(source).forEach((prop) => {
+        if (prop in result && Array.isArray(result[prop])) {
+          result[prop] = result[prop].concat(source[prop]);
+        } else if (prop in result && typeof result[prop] === 'object') {
+          result[prop] = this.merge(result[prop], source[prop]);
+        } else {
+          result[prop] = source[prop];
+        }
+      });
+    });
+
+    return result;
+  }
+
+}

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

@@ -0,0 +1,221 @@
+import {
+  Inject,
+  Injectable,
+  InjectionToken,
+  Optional,
+  Renderer2,
+  RendererFactory2,
+} from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, forkJoin, from, Observable } from 'rxjs';
+import { TranslateLoaderService } from './translate-loader.service';
+import {
+  UserPreferencesService,
+  UserPreferenceValues,
+} from '../user/user-preferences.service';
+import { LocalStoragService } from '../localStorag/local-storag.service';
+import { Lang } from '../../enums/language.enum';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+import { catchError, map } from 'rxjs/operators';
+import { AppConfigService } from '../../../configuration/app-config.service';
+
+export const TRANSLATION_PROVIDER = new InjectionToken(
+  'Injection token for translation providers.'
+);
+
+export interface TranslationProvider {
+  name: string;
+  source: string;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TranslationService {
+  public arabicFile;
+  public englishFile;
+  defaultLang: string;
+  userLang: string;
+  customLoader: TranslateLoaderService;
+  lang: string;
+  private renderer: Renderer2;
+  isArabic = new BehaviorSubject<boolean>(false);
+  isArabic$ = this.isArabic.asObservable();
+  translationApiName;
+  constructor(
+    public translate: TranslateService,
+    private rendererFactory: RendererFactory2,
+    private localStorage: LocalStoragService,
+    userPreferencesService: UserPreferencesService,
+    private appConfig : AppConfigService,
+    private nuxeoService: NuxeoService, 
+    @Inject('environment') private environment,
+    @Optional() @Inject(TRANSLATION_PROVIDER) providers: TranslationProvider[]
+  ) {
+    this.translationApiName = this.appConfig.myConfiguration['translationApi'] ? this.appConfig.myConfiguration['translationApi'] : null;
+    this.customLoader = <TranslateLoaderService>this.translate.currentLoader;
+    this.renderer = rendererFactory.createRenderer(null, null);
+
+    this.defaultLang = 'en';
+    translate.setDefaultLang(this.defaultLang);
+    this.customLoader.setDefaultLang(this.defaultLang);
+
+    if (providers && providers.length > 0) {
+      for (const provider of providers) {
+        this.addTranslationFolder(provider.name, provider.source);
+      }
+    }
+    userPreferencesService
+      .select(UserPreferenceValues.Locale)
+      .subscribe((locale) => {
+        if (locale) {
+          this.userLang = locale.split('-')[0];
+        }
+        if (this.userLang) {
+          this.loadTranslation(this.userLang, this.defaultLang);
+        } else {
+          this.loadTranslation(this.defaultLang);
+        }
+      });
+  }
+
+  /**
+   * Adds a new folder of translation source files.
+   * @param name Name for the translation provider
+   * @param path Path to the folder
+   */
+  addTranslationFolder(name: string = '', path: string = '') {
+    if (!this.customLoader.providerRegistered(name)) {
+      this.customLoader.registerProvider(name, path);
+    }
+  }
+
+  /**
+   * Loads a translation file.
+   * @param lang Language code for the language to load
+   * @param fallback Language code to fall back to if the first one was unavailable
+   */
+  loadTranslation(lang: string, fallback?: string) {
+    if (lang === Lang.Arabic) {
+      this.renderer.addClass(document.body, 'rtl');
+      this.isArabic.next(true);
+    } else {
+      this.renderer.removeClass(document.body, 'rtl');
+      this.isArabic.next(false);
+    }
+    const arabicFile$ = this.getOrCreateTranslationFile('ar');
+    const englishFile$ = this.getOrCreateTranslationFile('en');
+
+    forkJoin([
+      arabicFile$,
+      englishFile$,
+      this.translate.getTranslation(lang),
+    ]).subscribe(
+      (res: any) => {
+        this.arabicFile = res[0];
+        this.englishFile = res[1];
+        this.translate.use(lang);
+        let ArorEnFile =
+          lang === 'en'
+            ? JSON.parse(res[1].properties['note:note'])
+            : JSON.parse(res[0].properties['note:note']);
+        this.translate.setTranslation(
+          this.translate.currentLang,
+          { ...ArorEnFile },
+          true
+        );
+
+        this.onTranslationChanged(lang);
+      },
+      () => {
+        if (fallback && fallback !== lang) {
+          this.loadTranslation(fallback);
+        }
+      }
+    );
+  }
+
+  /**
+   * Triggers a notification callback when the translation language changes.
+   * @param lang The new language code
+   */
+  onTranslationChanged(lang: string): void {
+    this.translate.onTranslationChange.next({
+      lang: lang,
+      translations: this.customLoader.getFullTranslationJSON(lang),
+    });
+  }
+
+  /**
+   * Sets the target language for translations.
+   * @param lang Code name for the language
+   * @returns Translations available for the language
+   */
+  use(lang: string): Observable<any> {
+    this.customLoader.init(lang);
+    return this.translate.use(lang);
+  }
+
+  /**
+   * Gets the translation for the supplied key.
+   * @param key Key to translate
+   * @param interpolateParams String(s) to be interpolated into the main message
+   * @returns Translated text
+   */
+  get(
+    key: string | Array<string>,
+    interpolateParams?: Object
+  ): Observable<string | any> {
+    return this.translate.get(key, interpolateParams);
+  }
+
+  /**
+   * Directly returns the translation for the supplied key.
+   * @param key Key to translate
+   * @param interpolateParams String(s) to be interpolated into the main message
+   * @returns Translated text
+   */
+  instant(
+    key: string | Array<string>,
+    interpolateParams?: Object
+  ): string | any {
+    return key ? this.translate.instant(key, interpolateParams) : '';
+  }
+
+  getOrCreateTranslationFile(lang) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation( this.translationApiName ? this.translationApiName : 'AC_UA_Translation_GetOrCreate', {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .params({ language: lang })
+        .execute({
+          headers: {
+            properties: '*',
+          },
+        })
+    ).pipe(
+      catchError((err) => {
+        console.log(err);
+        throw err;
+      })
+    );
+  }
+  updateTranslationFile(doc, params = {}) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .repository()
+        .headers({
+          properties: '*',
+        })
+        .update(doc, params)
+    ).pipe(
+      map((data: any) => {
+        return data;
+      }),
+      catchError((err) => {
+        throw err;
+      })
+    );
+  }
+}

package/src/lib/Core/services/user/user-preferences.service.ts

@@ -0,0 +1,172 @@
+
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged, map, filter } from 'rxjs/operators';
+import { LocalStoragService } from '../localStorag/local-storag.service';
+
+export enum UserPreferenceValues {
+  Locale = 'locale',
+  ExpandedSideNavStatus = 'expandedSidenav'
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserPreferencesService {
+
+  defaults = {
+    locale: 'en',
+    expandedSidenav: true
+  };
+
+  private userPreferenceStatus: any = this.defaults;
+  private onChangeSubject: BehaviorSubject<any>;
+  onChange: Observable<any>;
+
+  constructor(public translate: TranslateService,
+    private storage: LocalStoragService) {
+    this.onChangeSubject = new BehaviorSubject(this.userPreferenceStatus);
+    this.onChange = this.onChangeSubject.asObservable();
+  }
+
+  private initUserPreferenceStatus() {
+    this.initUserLanguage();
+  }
+
+  private async initUserLanguage() {
+    if (this.locale) {
+      const locale = this.locale || this.getDefaultLocale();
+
+      this.set(UserPreferenceValues.Locale, locale);
+      this.set('textOrientation', (await this.getLanguageByKey(locale)).dir || 'ltr');
+    } else {
+      const locale = this.locale || this.getDefaultLocale();
+
+      this.setWithoutStore(UserPreferenceValues.Locale, locale);
+      this.setWithoutStore('textOrientation', (await this.getLanguageByKey(locale)).dir || 'ltr');
+    }
+  }
+
+  /**
+   * Sets up a callback to notify when a property has changed.
+   * @param property The property to watch
+   * @returns Notification callback
+   */
+  select(property: string): Observable<any> {
+    return this.onChange
+      .pipe(
+        map((userPreferenceStatus) => userPreferenceStatus[property]),
+        distinctUntilChanged()
+      );
+  }
+
+  /**
+   * Gets a preference property.
+   * @param property Name of the property
+   * @param defaultValue Default to return if the property is not found
+   * @returns Preference property
+   */
+  get(property: string, defaultValue?: string): string {
+    const key = this.getPropertyKey(property);
+    const value = this.storage.getItem(key);
+    if (value === undefined || value === null) {
+      return defaultValue;
+    }
+    return value;
+  }
+
+  /**
+   * Sets a preference property.
+   * @param property Name of the property
+   * @param value New value for the property
+   */
+  set(property: string, value: any) {
+    if (!property) {
+      return;
+    }
+    this.storage.setItem(
+      this.getPropertyKey(property),
+      value
+    );
+    this.userPreferenceStatus[property] = value;
+    this.onChangeSubject.next(this.userPreferenceStatus);
+  }
+
+  /**
+   * Sets a preference property.
+   * @param property Name of the property
+   * @param value New value for the property
+   */
+  setWithoutStore(property: string, value: any) {
+    if (!property) {
+      return;
+    }
+    this.userPreferenceStatus[property] = value;
+    this.onChangeSubject.next(this.userPreferenceStatus);
+  }
+
+  /**
+   * Check if an item is present in the storage
+   * @param property Name of the property
+   * @returns True if the item is present, false otherwise
+   */
+  hasItem(property: string): boolean {
+    if (!property) {
+      return false;
+    }
+    return this.storage.hasItem(
+      this.getPropertyKey(property)
+    );
+  }
+
+  /**
+   * Gets the active storage prefix for preferences.
+   * @returns Storage prefix
+   */
+  getStoragePrefix(): string {
+    return this.storage.getItem('USER_PROFILE') || 'GUEST';
+  }
+
+  /**
+   * Sets the active storage prefix for preferences.
+   * @param value Name of the prefix
+   */
+  setStoragePrefix(value: string) {
+    this.storage.setItem('USER_PROFILE', value || 'GUEST');
+    this.initUserPreferenceStatus();
+  }
+
+  /**
+   * Gets the full property key with prefix.
+   * @param property The property name
+   * @returns Property key
+   */
+  getPropertyKey(property: string): string {
+    return `${this.getStoragePrefix()}__${property}`;
+  }
+
+
+
+  /** Current locale setting. */
+  get locale(): string {
+    return this.get(UserPreferenceValues.Locale);
+  }
+
+  set locale(value: string) {
+    this.set(UserPreferenceValues.Locale, value);
+  }
+
+  /**
+   * Gets the default locale.
+   * @returns Default locale language code
+   */
+  public getDefaultLocale(): string {
+    return this.translate.getBrowserCultureLang() || 'en';
+  }
+
+  private async getLanguageByKey(key: string) {
+    const translation = await this.translate.getTranslation(key).toPromise();
+    return translation;
+  }
+}