nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/directive/permissions/evaluators.service.ts

@@ -0,0 +1,148 @@
+import { Injectable } from "@angular/core";
+import { AppConfigService } from "../../configuration/app-config.service";
+import { first } from "rxjs/operators";
+import { NuxeoService } from "../../core/services/nuxeo/nuxeo.service";
+@Injectable({ providedIn: "root" })
+export class EvaluatorsService {
+  context = { entity: null, getEvaluator: null, user: null };
+  conditions;
+  constructor(
+    private nuxeoService: NuxeoService,
+    private appConfigService: AppConfigService
+  ) {
+    this.appConfigService.configLoaded.subscribe((ready) => {
+      if (ready) {
+        this.conditions = this.getAllRules();
+      }
+    });
+  }
+  asyncEvery = async (arr, predicate) => {
+    for (let e of arr) {
+      if (!(await predicate(e))) {
+        return false;
+      }
+    }
+    return true;
+  };
+  asyncSome = async (arr, predicate) => {
+    for (let e of arr) {
+      if (await predicate(e)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  // tslint:disable-next-line:member-ordering
+  evaluators = {
+    AND: async (context, args: any[]): Promise<boolean> => {
+      if (!args || args.length === 0) {
+        return false;
+      }
+      return await this.asyncEvery(args, async (arg) => {
+        const evaluator = await context.getEvaluator(arg.value);
+        if (!evaluator) {
+          console.warn("evaluator not found: " + arg.value);
+          return false;
+        }
+        return await evaluator(context, arg.parameters || []);
+      });
+    },
+    OR: async (context, args: any[]): Promise<boolean> => {
+      if (!args || args.length === 0) {
+        return false;
+      }
+      return await this.asyncSome(args, async (arg) => {
+        const evaluator = await context.getEvaluator(arg.value);
+        if (!evaluator) {
+          console.warn("evaluator not found: " + arg.value);
+          return false;
+        }
+        const res = await evaluator(context, arg.parameters || []);
+        return res;
+      });
+    },
+    isStatus: async (context, args) => {
+      if (args.indexOf(context.entity.state) > -1) {
+        return true;
+      } else {
+        return false;
+      }
+    },
+    isCreator: async (context, args) => {
+      //check if user loged in is the creator of that corresp
+      let owner;
+      if (context.entity.properties.owner?.properties?.username) {
+        owner = context.entity.properties.owner?.properties?.username;
+      } else if (
+        context.entity.properties["corr:owner"]?.properties?.username
+      ) {
+        owner = context.entity.properties["corr:owner"]?.properties?.username;
+      } else if (context.entity.properties.owner) {
+        owner = context.entity.properties.owner;
+      } else if (context.entity.properties["corr:owner"]) {
+        owner = context.entity.properties["corr:owner"];
+      }
+
+      if (owner === context.user.properties.username) {
+        return true;
+      } else {
+        return false;
+      }
+    },
+    isUserInrole: async (context, args) => {
+      const result = await this.nuxeoService
+        .isUserInRole(args, "")
+        .pipe(first())
+        .toPromise();
+      return result;
+    },
+  };
+
+  getEvaluator = async (key: string) => {
+    const eva = this.evaluators;
+    if (key && key.startsWith("!")) {
+      const fn = eva[key.substring(1)];
+      return async (context, args): Promise<boolean> => {
+        const result = await fn(context, ...args);
+        return !result;
+      };
+    }
+    return eva[key];
+  };
+
+  setEvaluators(evaluators) {
+    this.evaluators = { ...this.evaluators, ...evaluators };
+  }
+
+  getEvaluators() {
+    return this.evaluators;
+  }
+
+  // ----------------------------------------------------
+
+  async evaluateRule(ruleId, context?): Promise<boolean> {
+    const ruleRef = this.getRuleById(ruleId);
+    context = context || this.context;
+    context["getEvaluator"] = this.getEvaluator;
+
+    if (ruleRef) {
+      const evaluator = await this.getEvaluator(ruleRef.type);
+      if (evaluator) {
+        return await evaluator(context, ruleRef.parameters);
+      }
+    } else {
+      const evaluator = await this.getEvaluator(ruleId);
+      if (evaluator) {
+        return await evaluator(context);
+      }
+    }
+  }
+
+  getRuleById(id: string) {
+    return this.conditions[id] ? { ...this.conditions[id] } : null;
+  }
+
+  getAllRules() {
+    return this.appConfigService.conditons;
+  }
+}

package/src/lib/directive/permissions/permissions.directive.ts

@@ -0,0 +1,74 @@
+import { Directive, ElementRef, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { first , switchMap} from 'rxjs/operators';
+ import { AppConfigService } from '../../configuration/app-config.service';
+import { NuxeoService } from '../../core/services/nuxeo/nuxeo.service';
+
+import { EvaluatorsService } from './evaluators.service';
+/**
+ * Permission directive shows or hides an element,
+ * based on a predefined structured condition object in the [conditions.json]{@link ../additional-documentation/conditions-file.html} file.
+ * it will evaluate the rule and shows or hides an element based on the result.
+ * this directive can evaluate rules against a document object as well,
+ * check [conditions.json]{@link ../additional-documentation/conditions-file.html} for more information
+ * @example
+ * <div *permission="{ name: 'conditionKey', entity: nuxeoDocumentObject }">
+ *   Element with permissions
+ *  </duv>
+ *  <div *permission="{ name: 'conditionKey2' }">
+ *   Element with permissions 2
+ *  </duv>
+ * @title
+ * Permission
+ */
+@Directive({
+  selector: '[permission]'
+})
+export class PermissionsDirective implements OnInit {
+
+
+  constructor(private nuxeoService: NuxeoService, private eltRef: ElementRef, private viewContainerRef: ViewContainerRef,
+    private templateRef: TemplateRef<any>, private appConfigService : AppConfigService,
+    private evaluatorsService : EvaluatorsService,
+  
+
+   ) {
+
+
+  }
+  /** permission object */
+  @Input() permission;
+  conditions;
+
+  isVisible = false;
+  context = { entity: null, getEvaluator: null, user: null };
+ 
+
+
+  ngOnInit() {
+    this.context.getEvaluator = this.evaluatorsService.getEvaluator;
+    if (!this.permission.name) {
+
+      if (!this.isVisible) {
+        this.isVisible = true;
+        this.viewContainerRef.createEmbeddedView(this.templateRef);
+      }
+    } else {
+      this.context.entity = this.permission.entity;
+      this.context.user = this.permission.user || this.nuxeoService.nuxeoClient.user;
+      this.evaluatorsService.evaluateRule(this.permission.name, this.context).then((result) => {
+        if (result) {
+          if (!this.isVisible) {
+            this.isVisible = true;
+            this.viewContainerRef.createEmbeddedView(this.templateRef);
+          }
+        } else {
+          this.isVisible = false;
+          this.viewContainerRef.clear();
+        }
+      });
+    }
+  }
+
+
+
+}

package/src/lib/directive/rtl/set-dir-rtl.directive.ts

@@ -0,0 +1,25 @@
+import { Directive, ElementRef, Renderer2 } from '@angular/core';
+import { TranslationService } from '../../core/services/translation/translation.service';
+
+/** @ignore */
+
+@Directive({
+  selector: '[SetDirRtl]',
+})
+export class SetDirRtlDirective {
+  constructor(
+    private elRef: ElementRef,
+    private renderer: Renderer2,
+    private translation: TranslationService
+  ) {
+    this.switchDirBasedOnLanguage();
+  }
+
+  switchDirBasedOnLanguage() {
+    this.translation.isArabic.subscribe((arabic) => {
+      arabic
+        ? this.renderer.setAttribute(this.elRef.nativeElement, 'dir', 'rtl')
+        : this.renderer.setAttribute(this.elRef.nativeElement, 'dir', 'ltr');
+    });
+  }
+}

package/src/lib/directive/rtl/set-rtl.directive.ts

@@ -0,0 +1,26 @@
+import { Directive, ElementRef, Renderer2 } from '@angular/core';
+import { TranslationService } from '../../core/services/translation/translation.service';
+
+/** @ignore */
+
+@Directive({
+  selector: '[SetRtl]',
+})
+export class SetRtlDirective {
+  constructor(
+    private elRef: ElementRef,
+    private renderer: Renderer2,
+    private translation: TranslationService
+  ) {
+    this.switchClassBasedOnLanguage();
+  }
+
+  /*Switch rtl class based on the chosen language from Translation Service*/
+  switchClassBasedOnLanguage() {
+    this.translation.isArabic.subscribe((arabic) => {
+      arabic
+        ? this.renderer.addClass(this.elRef.nativeElement, 'rtl')
+        : this.renderer.removeClass(this.elRef.nativeElement, 'rtl');
+    });
+  }
+}

package/src/lib/nuxeo-development-framework.component.ts

@@ -0,0 +1,20 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+  selector: 'lib-nuxeo-development-framework',
+  template: `
+    <p>
+      nuxeo-development-framework works!
+    </p>
+  `,
+  styles: [
+  ]
+})
+export class NuxeoDevelopmentFrameworkComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

package/src/lib/nuxeo-development-framework.module.ts

@@ -0,0 +1,18 @@
+import { CommonModule } from "@angular/common";
+import { HttpClientModule } from "@angular/common/http";
+import { NgModule } from "@angular/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { NuxeoDevelopmentFrameworkComponent } from "./nuxeo-development-framework.component";
+@NgModule({
+  declarations: [NuxeoDevelopmentFrameworkComponent],
+  imports: [CommonModule, HttpClientModule, FormsModule, ReactiveFormsModule],
+  exports: [NuxeoDevelopmentFrameworkComponent],
+})
+export class NuxeoDevelopmentFrameworkModule {
+  //   public static forRoot(): ModuleWithProviders<NuxeoDevelopmentFrameworkModule> {
+  //     return {
+  //         ngModule: NuxeoDevelopmentFrameworkModule,
+  //         providers: [UserPreferencesService]
+  //     };
+  // }
+}

package/src/lib/nuxeo-development-framework.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NuxeoDevelopmentFrameworkService {
+
+  constructor() { }
+}

package/src/lib/pipes/file-size.pipe.ts

@@ -0,0 +1,61 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { TranslationService } from '../core/services/translation/translation.service';
+
+/**
+ * transforms file size into translated appropriate units
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <p>{{ file.sizeInBytes | FileSize}}</p>
+ * ~~~
+ * @title
+ * File Size
+ *
+ * @example
+ * ...
+ * constructor(...  private FileSizePipe: fileSizePiple ...){
+ *   const sizeString = this.fileSizePiple.transform(sizeInBytes);
+ * }
+ * ...
+ */
+@Pipe({
+  name: 'FileSize',
+  pure: false
+})
+export class FileSizePipe implements PipeTransform {
+
+  constructor(private translation: TranslationService) {
+  }
+
+  /**
+   *
+   * @param paramByte Size in Bytes
+   * @optional @param  decimals Decimals to show
+   * @returns translated size string
+   */
+  transform(paramByte: any, decimals: number = 2): string {
+    if (paramByte == null) {
+      return '';
+    }
+
+    const bytes = parseInt(paramByte, 10);
+    if (isNaN(bytes)) {
+      return '';
+    }
+
+    if (bytes === 0) {
+      return '0 ' + this.translation.instant('FILE_SIZE.BYTES');
+    }
+
+    const k = 1024,
+      dm = decimals || 2,
+      sizes = ['BYTES', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
+      i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    const i18nSize = this.translation.instant(`FILE_SIZE.${sizes[i]}`);
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + i18nSize;
+  }
+
+}

package/src/lib/pipes/hijri-date.pipe.ts

@@ -0,0 +1,40 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import * as moment_ from 'moment-hijri';
+
+/**
+ * Transforms and formats date into hijri
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <p>{{ dateObject | hijriDate : {format:'iYYYY iMMMM iD'}}}</p>
+ * ~~~
+ * @title
+ * Hijri Date
+ *
+ * @example
+ * ...
+ * constructor(...  private HijriDatePipe: hijriDatePipe ...){
+ *   const formattedHijriDate = this.hijriDatePipe.transform(dateObject, 'iYYYY iMMMM iD');
+ * }
+ * ...
+ */
+@Pipe({
+  name: 'hijriDate'
+})
+export class HijriDatePipe implements PipeTransform {
+
+  defaultFormat="iYYYY iMMMM iD";
+  /**
+   *
+   * @param value Date object
+   * @param format Format
+   * @returns formatted hijri date string
+   */
+  transform(value: any, format?: string): any {
+      const actualFormat = format || this.defaultFormat;
+      const m = moment_(value , 'iYYYY/iM/iD'); // Parse a Hijri date.
+      return m.format("iD iMMMM iYYYY");
+  }
+
+}

package/src/lib/pipes/localized-date.pipe.ts

@@ -0,0 +1,80 @@
+import { DatePipe } from '@angular/common';
+import { OnDestroy, Pipe, PipeTransform } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { UserPreferencesService, UserPreferenceValues } from '../core/services/user/user-preferences.service';
+
+/**
+ * Transforms date to localized date string
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <p>
+ *  {{ dateObject | localizedDate: "EEEE, MMMM dd, yyyy"  }}
+ * </p>
+ * ~~~
+ * @title
+ * Localized Date
+ *
+ * @example
+ * ...
+ * constructor(...  private LocalizedDatePipe: localizedDatePipe ...){
+ *   const localizedDateString = this.localizedDatePipe.transform(dateObject, 'EEEE, MMMM dd, yyyy');
+ * }
+ * ...
+ */
+@Pipe({
+  name: 'localizedDate',
+  pure: false
+})
+export class LocalizedDatePipe implements PipeTransform, OnDestroy {
+
+  static DEFAULT_LOCALE = 'en-US';
+  static DEFAULT_DATE_FORMAT = 'dd MMMM yyyy hh:mm a';
+
+  defaultLocale: string = LocalizedDatePipe.DEFAULT_LOCALE;
+  defaultFormat: string = LocalizedDatePipe.DEFAULT_DATE_FORMAT;
+
+  private onDestroy$ = new Subject<boolean>();
+
+  constructor(public userPreferenceService?: UserPreferencesService) {
+
+    if (this.userPreferenceService) {
+      this.userPreferenceService
+        .select(UserPreferenceValues.Locale)
+        .pipe(takeUntil(this.onDestroy$))
+        .subscribe(locale => {
+          if (locale) {
+            this.defaultLocale = locale;
+          }
+        });
+    }
+
+
+  }
+  /**
+   *
+   * @param value date object
+   * @param format format
+   * @param locale locale to convert to
+   * @returns localized date string
+   */
+  transform(value: any, format?: string, locale?: string): any {
+    try {
+      const actualFormat = format || this.defaultFormat;
+      const actualLocale = locale || this.defaultLocale;
+      const datePipe: DatePipe = new DatePipe(actualLocale);
+      return datePipe.transform(value, actualFormat, 'GMT+3');
+    } catch (e) {
+      console.warn(e);
+      return value;
+    }
+  }
+  /** @ignore */
+  ngOnDestroy(): any {
+    this.onDestroy$.next(true);
+    this.onDestroy$.complete();
+  }
+
+}

package/src/lib/pipes/multi-value.pipe.ts

@@ -0,0 +1,39 @@
+import { Pipe, PipeTransform } from '@angular/core';
+/**
+ * Transforms array of strings to single string seperated with seperator
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <p>{{ ['string 1','string 2', 'string 3'] | multiValue : {valueSeparator:', '}}}</p>
+ * ~~~
+ * @title
+ * Multi Value
+ *
+ * @example
+ * ...
+ * constructor(...  private MultiValuePipe: multiValuePipe ...){
+ *   const MultiValueString = this.multiValuePipe.transform(['string 1','string 2', 'string 3'], ', ');
+ * }
+ * ...
+ */
+@Pipe({ name: 'multiValue' })
+export class MultiValuePipe implements PipeTransform {
+
+    static DEFAULT_SEPARATOR = ', ';
+
+    /**
+     *
+     * @param values array of strings
+     * @param valueSeparator seperator to place between elements
+     * @returns the joining of all array items seperated with seperator
+     */
+    transform(values: any | any[], valueSeparator: string = MultiValuePipe.DEFAULT_SEPARATOR): string {
+
+        if (values && values instanceof Array) {
+            return values.join(valueSeparator);
+        }
+
+        return values;
+    }
+}

package/src/lib/pipes/pipes.module.ts

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SecurePipe } from './secure.pipe';
+import { LocalizedDatePipe } from './localized-date.pipe';
+import { SafeHtmlPipe } from './secure-html.pipe';
+import { TimeAgoPipe } from './time-ago.pipe';
+import { MultiValuePipe } from './multi-value.pipe';
+import { FileSizePipe } from './file-size.pipe';
+import { HijriDatePipe } from './hijri-date.pipe';
+/**
+ * @title
+ * Pipes Module
+ */
+@NgModule({
+  declarations: [SecurePipe, LocalizedDatePipe, SafeHtmlPipe, TimeAgoPipe, MultiValuePipe, FileSizePipe, HijriDatePipe],
+  imports: [CommonModule],
+  exports: [SecurePipe, LocalizedDatePipe, SafeHtmlPipe, TimeAgoPipe, MultiValuePipe, FileSizePipe, HijriDatePipe],
+  providers: [TimeAgoPipe, MultiValuePipe],
+})
+export class PipesModule { }

package/src/lib/pipes/secure-html.pipe.ts

@@ -0,0 +1,27 @@
+import { DomSanitizer } from '@angular/platform-browser';
+import { PipeTransform, Pipe } from '@angular/core';
+
+
+/**
+ * Transforms html string into safe html to be rendered in the view
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <span [innerHTML]="htmlString | safeHtml"></span>
+ * ~~~
+ * @title
+ * Safe HTML
+ */
+@Pipe({ name: 'safeHtml' })
+export class SafeHtmlPipe implements PipeTransform {
+  constructor(private sanitized: DomSanitizer) { }
+  /**
+   *
+   * @param value HTML String
+   * @returns Safe HTML
+   */
+  transform(value): any {
+    return this.sanitized.bypassSecurityTrustHtml(value);
+  }
+}

package/src/lib/pipes/secure.pipe.ts

@@ -0,0 +1,37 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+
+/**
+ * Transforms URL into async safe URL to be rendered in the view
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ *   <img [attr.src]="user.avatar | secure | async" />
+ * ~~~
+ * @title
+ * Safe URL
+ */
+@Pipe({
+  name: 'secure'
+})
+export class SecurePipe implements PipeTransform {
+
+  constructor(private http: HttpClient, private sanitizer: DomSanitizer) { }
+
+  /**
+   *
+   * @param url Resource URL
+   * @returns Safe URL
+   */
+  transform(url): Observable<SafeUrl> {
+    return this.http
+      .get(url, { responseType: 'blob' }).pipe(
+        map(val => this.sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(val)))
+      );
+  }
+
+}