nuxeo-development-framework 3.1.4 → 3.1.6

package/src/lib/components/vocabulary/vocabulary.module.ts

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VocabularyComponent } from './vocabulary/vocabulary.component';
+import { SelectModule } from '../select/select.module';
+import { DynamicFormModule } from '../dynamic-form/dynamic-form.module';
+// import { CoreModule } from '../../core/core.module';
+
+/** @ignore */
+@NgModule({
+  declarations: [VocabularyComponent],
+  imports: [
+    CommonModule,
+    SelectModule,
+    DynamicFormModule
+  ],
+  exports : [
+    VocabularyComponent
+  ]
+})
+export class VocabularyModule { }

package/src/lib/configuration/app-config.service.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { combineLatest, ReplaySubject } from "rxjs";
+
+@Injectable({
+  providedIn: "root",
+})
+export class AppConfigService {
+  constructor(private http: HttpClient) {}
+  myConfiguration;
+  conditons;
+  theme;
+  configLoaded = new ReplaySubject(1);
+  // load my config file from my assets
+
+  load() {
+    combineLatest([
+      this.http.get("assets/configs/configuration.json"),
+      this.http.get("assets/configs/conditions.json"),
+    ]).subscribe((res) => {
+      this.conditons = res[1];
+      this.myConfiguration = res[0];
+      this.configLoaded.next(true);
+    });
+  }
+}

package/src/lib/configuration/configuration.module.ts

@@ -0,0 +1,12 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+
+/** @ignore */
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ]
+})
+export class ConfigurationModule { }

package/src/lib/configuration/helpers/app-initializer.ts

@@ -0,0 +1,5 @@
+import { AppConfigService } from '../app-config.service';
+
+export function appInitializer(appConfigService : AppConfigService) : Function {
+  return () => appConfigService.load();
+}

package/src/lib/directive/app-has-role/app-has-role.directive.ts

@@ -0,0 +1,62 @@
+import {
+  Directive,
+  Input,
+  OnChanges,
+  OnInit,
+  TemplateRef,
+  ViewContainerRef
+} from '@angular/core';
+import { Subject } from 'rxjs';
+import { NuxeoService } from '../../Core/services/nuxeo/nuxeo.service';
+@Directive({
+  selector: '[appHasRole]'
+})
+export class AppHasRoleDirective implements OnInit, OnChanges {
+  /** the role the user must have */
+  @Input() appHasRole;
+
+  stop$ = new Subject();
+
+  isVisible = false;
+
+  constructor(
+    private viewContainerRef: ViewContainerRef,
+    private templateRef: TemplateRef<any>,
+    private nuxeoService: NuxeoService
+  ) { }
+
+  ngOnInit(): void {
+    if (this.appHasRole?.role) {
+      this.nuxeoService.isUserInRole(this.appHasRole.role, this.appHasRole.code).subscribe(data => {
+        if (data || !this.appHasRole) {
+          // If it is already visible (which can happen if
+          // his roles changed) we do not need to add it a second time
+          if (!this.isVisible) {
+            // We update the `isVisible` property and add the
+            // templateRef to the view using the
+            // 'createEmbeddedView' method of the viewContainerRef
+            this.isVisible = true;
+            this.viewContainerRef.createEmbeddedView(this.templateRef);
+          }
+        } else {
+          // If the user does not have the role,
+          // we update the `isVisible` property and clear
+          // the contents of the viewContainerRef
+          this.isVisible = false;
+          this.viewContainerRef.clear();
+        }
+      });
+    } else {
+      if (!this.isVisible) {
+        // We update the `isVisible` property and add the
+        // templateRef to the view using the
+        // 'createEmbeddedView' method of the viewContainerRef
+        this.isVisible = true;
+        this.viewContainerRef.createEmbeddedView(this.templateRef);
+      }
+    }
+  }
+  ngOnChanges(){
+    this.ngOnInit();
+  }
+}

package/src/lib/directive/clickOutSide/click-outside.directive.ts

@@ -0,0 +1,20 @@
+import { Directive, ElementRef, EventEmitter, HostListener, Output } from '@angular/core';
+
+/** @ignore */
+@Directive({
+  selector: '[clickOutside]'
+})
+export class ClickOutsideDirective {
+
+  @Output() public clickOutside = new EventEmitter<void>();
+
+  constructor(private elementRef: ElementRef) { }
+
+  @HostListener('window:click', ['$event.target']) onClick(target) {
+    const clickedInside = this.elementRef.nativeElement.contains(target);
+    if (!clickedInside) {
+      this.clickOutside.emit(target);
+    }
+  }
+
+}

package/src/lib/directive/directive.module.ts

@@ -0,0 +1,36 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ClickOutsideDirective } from './clickOutSide/click-outside.directive';
+import { SetRtlDirective } from './rtl/set-rtl.directive';
+import { PermissionsDirective } from './permissions/permissions.directive';
+import { SetDirRtlDirective } from './rtl/set-dir-rtl.directive';
+import { AppHasRoleDirective } from '../directive/app-has-role/app-has-role.directive';
+import { DragAndDropDirective } from './drag-and-drop/drag-and-drop.directive';
+
+/**
+ * @title
+ * Directives Module
+ */
+@NgModule({
+  declarations: [
+    ClickOutsideDirective,
+    SetRtlDirective,
+    PermissionsDirective,
+    SetDirRtlDirective,
+    AppHasRoleDirective,
+    DragAndDropDirective
+
+  ],
+  imports: [CommonModule],
+  exports: [
+    ClickOutsideDirective,
+    SetRtlDirective,
+    PermissionsDirective,
+    SetDirRtlDirective,  
+    AppHasRoleDirective,
+    DragAndDropDirective
+
+  ],
+  providers: []
+})
+export class DirectiveModule {}

package/src/lib/directive/drag-and-drop/drag-and-drop.directive.ts

@@ -0,0 +1,37 @@
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+
+@Directive({
+  selector: '[appDragAndDrop]'
+})
+export class DragAndDropDirective {
+
+
+  @Output() fileDroped = new EventEmitter();
+
+  constructor() { }
+
+  @HostListener('dragover', ['$event']) public onDragOver(evt){
+    evt.preventDefault();
+    evt.stopPropagation();
+  }
+
+  @HostListener('dragleave', ['$event']) public onDragLeave(evt){
+    evt.preventDefault();
+    evt.stopPropagation();
+  }
+
+  @HostListener('drop', ['$event']) public onDrop(evt){
+    let  files = [] ;
+    evt.preventDefault();
+    evt.stopPropagation();
+    
+    if (evt.dataTransfer.files.length) {
+      for (const file of evt.dataTransfer.files) {
+        files.push(file);
+      }
+
+      this.fileDroped.emit(files);
+    }
+  }
+
+}

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,31 @@
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { ModuleWithProviders, NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CoreModule } from '../lib/Core/core.module';
+import { UserPreferencesService } from '../public-api';
+import { NuxeoDevelopmentFrameworkComponent } from './nuxeo-development-framework.component';
+@NgModule({
+  declarations: [
+    NuxeoDevelopmentFrameworkComponent
+  ],
+  imports: [
+    CommonModule,
+    HttpClientModule,
+    FormsModule,
+    ReactiveFormsModule,
+    CoreModule,
+  ],
+  exports: [
+    CoreModule,
+    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");
+  }
+
+}