nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/components/viewer-log/components/viewer-log/viewer-log.component.ts

@@ -0,0 +1,28 @@
+import { Component, Input, OnInit, SimpleChanges, ViewEncapsulation } from '@angular/core';
+
+@Component({
+  selector: 'cts-viewer-log',
+  templateUrl: './viewer-log.component.html',
+  styleUrls: ['./viewer-log.component.scss'],
+  encapsulation:ViewEncapsulation.None
+})
+export class ViewerLogComponent implements OnInit {
+  loading = true;
+  @Input()
+  correspondence;
+
+  @Input()
+  newLogActor = false; // flage used to change logs to take actore not from dc creator but from person
+  @Input() isArabic;
+  constructor() {}
+
+  logSuccess(e) {
+    if(e){
+      this.loading = false
+    }
+  }
+  ngOnInit(): void {}
+  ngOnChanges(changes: SimpleChanges): void {
+    this.correspondence = this.correspondence;
+  }
+}

package/src/lib/components/viewer-log/viewer-log.module.ts

@@ -0,0 +1,12 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { LatestActivityModule } from '../latest-activity/latest-activity.module';
+import { ViewerLogComponent } from './components/viewer-log/viewer-log.component';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+
+@NgModule({
+  declarations: [ViewerLogComponent],
+  imports: [CommonModule, LatestActivityModule, MatProgressBarModule],
+  exports: [ViewerLogComponent],
+})
+export class ViewerLogModule {}

package/src/lib/components/vocabulary/interfaces/op-type.interface.ts

@@ -0,0 +1,4 @@
+export type opType =
+  | 'AC_UA_Vocabulary_AddEntry'
+  | 'AC_UA_Vocabulary_UpdateEntry'
+  | 'AC_UA_Vocabulary_RemoveEntry';

package/src/lib/components/vocabulary/services/vocabulary-api.service.ts

@@ -0,0 +1,66 @@
+import { Inject, Injectable, Injector } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { from, Observable, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';
+import { opType } from '../interfaces/op-type.interface';
+import { BaseService } from '../../../shared/services/base/base.service';
+@Injectable({
+  providedIn: 'root',
+})
+export class VocabularyApiService extends BaseService {
+  vocabular = {};
+  constructor(
+    private nuxeoService: NuxeoService,
+    private injector: Injector
+  ) {
+    super(injector);
+  }
+
+  getVocabularyList(listName): Observable<any> {
+    return this.actualGetVocabularyList(listName)
+  }
+
+  getVocabularyListByFilters(listName, params = {}, filter = {}, fullText = null): Observable<any> {
+    return this.actualGetVocabularyList(listName, {
+      filters: filter,
+      searchTerm: fullText,
+      ...params
+    });
+  }
+
+  actualGetVocabularyList(listName, extraParams = {}): Observable<any> {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation('Directory.SuggestEntries', {})
+        .params({
+          directoryName: listName,
+          dbl10n: false,
+          localize: true,
+          lang: this.translateService.currentLang,
+          ...extraParams
+        })
+        .execute()
+    );
+  }
+
+  vocabularyOperations(opName: opType, body) {
+    return from(
+      this.nuxeoService.nuxeoClient
+        .operation(opName, {
+          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+        .context({ vocabulary: body })
+        .execute()
+    ).pipe(
+      catchError((err) => {
+        console.log(err);
+        throw err;
+      })
+    );
+  }
+  getVocListByVocName(vocName): Observable<any> {
+    const url = `${this.environment.nuxeo}/api/v1/directory/${vocName}`;
+    return this.get<any>({ endpoint: url, headers: { properties: '*' } });
+  }
+}

package/src/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.html

@@ -0,0 +1,23 @@
+<div class="translated-vocbulary-wrapper" [ngClass]="{'rtl-translated-vocbulary-wrapper' : isArabic === true}">
+        <div class="vocabulary-title text-base font-bold text-accent-900 mb-0">
+            {{label | translate}}
+            <span *ngIf="isRequired()" class="required-flage">*</span>
+        </div>
+        <ng-select
+            [bindLabel]="bindLabel"
+            [bindValue]="bindValue"
+            [placeholder]="placeholder"
+            [multiple]="multiple"
+            [clearable]="clear"
+            [searchable]="searchable"
+            [closeOnSelect]="closeOnSelect"
+            [hideSelected]="hideSelectedItems"
+            [loading]="loading"
+            (scrollToEnd)="onScrollToEnd()"
+            (change)="emitSelection($event)"
+            [disabled]="disabled"
+            [(ngModel)]="selection"
+        >
+        <ng-option *ngFor="let option of buffer" [value]="option[bindValue]">{{isArabic ? option[bindLabel] : option[bindLabel]}}</ng-option>
+        </ng-select>
+</div>

package/src/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.scss

@@ -0,0 +1,10 @@
+.translated-vocbulary-wrapper {
+    .vocabulary-title {
+        .required-flage{
+            color: rgb(239, 68, 68);
+        }
+    }
+}
+.rtl-translated-vocbulary-wrapper {
+    direction: rtl;
+}

package/src/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.ts

@@ -0,0 +1,220 @@
+import { Component, EventEmitter, Input, OnChanges, OnDestroy, Optional, Output, Self, ViewChild } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
+import { NgSelectComponent } from '@ng-select/ng-select';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable, Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
+
+import { TranslationService } from '../../../core/services/translation/translation.service';
+import { VocabularyApiService } from '../services/vocabulary-api.service';
+import { filter } from 'lodash';
+
+@Component({
+    selector: 'app-translated-vocabulary-select',
+    templateUrl: './translated-vocabulary-select.component.html',
+    styleUrls: ['./translated-vocabulary-select.component.scss'],
+})
+export class TranslatedVocabularySelectComponent
+    implements OnChanges, OnDestroy, ControlValueAccessor {
+    @ViewChild(NgSelectComponent) ngSelectComponent: NgSelectComponent;
+    /** Field Label */
+    @Input() label: string;
+    /** Property name to bind value to */
+    @Input() bindValue;
+    /** Property name to bind label to */
+    @Input() arbBindLabel;
+    /** Property name to bind label to */
+    @Input() engBindLabel;
+    /** Items array */
+    // @Input() data;
+    /** Placeholder string */
+    @Input() placeholder;
+    /** can select multiple */
+    @Input() multiple = false;
+    /** is searchable */
+    @Input() searchable = false;
+    /** should close on select */
+    @Input() closeOnSelect = true;
+    /** should hide selected items */
+    @Input() hideSelectedItems = false;
+    /** is disabled */
+    @Input() disabled = false;
+    /** should show clear action */
+    @Input() clear = true;
+    /** filter to be sent from out side to send it in api to filter the vocabulary items */
+    @Input() filter;
+    /** flage to indicate if call api without filter or wait untile there is filter and then call api*/
+    @Input() useFilter = true;
+
+    /** is vocabulary select */
+    // @Input() voc = false;
+    /** vocabulary id for translation (for vocabulary select only) */
+    @Input() vocbularyId: string;
+    /** Should show loading indicator */
+    loading = false;
+    @Input() mapingResponse = false;
+
+    @Input() params = {};
+    @Input() getByDirectorySuggestion: boolean = true;
+    /** event emitted with selected items */
+    @Output() onSelectItems = new EventEmitter();
+
+    bindLabel;
+    selection = [];
+    data = [];
+    buffer = [];
+    bufferSize = 50;
+    numberOfItemsFromEndBeforeFetchingMore = 10;
+    private _unsubscribeAll: Subject<any> = new Subject<any>();
+    isArabic = false;
+    propagateChange: any = () => { };
+    validateFn: any = () => { };
+
+    public onTouched: any = () => {
+        /*Empty*/
+    };
+    public get invalid(): boolean {
+        return this.control ? this.control.invalid : false;
+    }
+
+    public get showError(): boolean {
+        if (!this.control) {
+            return false;
+        }
+
+        const { dirty, touched } = this.control;
+
+        return this.invalid ? dirty || touched : false;
+    }
+    constructor(
+        public translate: TranslateService,
+        private translationService: TranslationService,
+        private vocabularyApiServ: VocabularyApiService,
+        @Self() @Optional() public control: NgControl
+    ) {
+        if (this.control) {
+            this.control.valueAccessor = this;
+        }
+    }
+
+    ngOnInit() {
+        this.translationService.isArabic
+            .pipe(takeUntil(this._unsubscribeAll))
+            .subscribe((res) => {
+                this.isArabic = res;
+                this.bindLabel = this.isArabic
+                    ? this.arbBindLabel
+                    : this.engBindLabel;
+            });
+        if (!this.useFilter) {
+            this.getlistOfVocabulary();
+        }
+    }
+
+    getlistOfVocabulary() {
+        this.loading = true;
+        if (this.vocbularyId) {
+            const observable: Observable<any> = (this.getByDirectorySuggestion) ? this.vocabularyApiServ
+                .getVocabularyListByFilters(this.vocbularyId, this.params, this.filter).pipe(map(res => {
+                    let tempArr = [];
+                    if (this.mapingResponse) {
+                        res.forEach((element) => {
+                            tempArr.push({
+                                label_ar: element.displayLabel,
+                                label_en: element.displayLabel,
+                            });
+                        });
+                    } else {
+                        tempArr = res;
+                    }
+                    return tempArr;
+                }))
+                : this.vocabularyApiServ.getVocListByVocName(this.vocbularyId).pipe(map((res: { entries: Array<Record<string, any>> }) => {
+                    return res.entries.map(elem => elem.properties);
+                }))
+            observable.subscribe((res) => {
+                this.data = res;
+                this.buffer = (this.data || []).slice(0, this.bufferSize);
+                this.loading = false;
+            }, err => {
+                this.loading = false;
+            });
+        }
+    }
+
+    ngOnChanges(changes): void {
+        if (this.useFilter && changes.filter && changes.filter.currentValue) {
+            this.getlistOfVocabulary();
+        }
+    }
+
+    emitSelection(event) {
+        this.propagateChange(this.selection);
+        this.onSelectItems.emit(event);
+    }
+
+    onScrollToEnd() {
+        this.fetchMore();
+    }
+
+    private fetchMore() {
+        this.loading = true;
+        const len = this.buffer.length;
+        const more = this.data.slice(len, this.bufferSize + len);
+        this.buffer = this.data.concat(more);
+        this.loading = false;
+    }
+
+    writeValue(value) {
+        if (value) {
+            this.selection = value;
+        } else {
+            //added to allow reseting ui when resetting form
+            this.selection = [];
+        }
+    }
+
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+
+    registerOnTouched(fn: any) {
+        this.onTouched = fn;
+    }
+
+    validate(c: FormControl) {
+        return this.validateFn(c);
+    }
+
+    isRequired() {
+        if (!this.control || !this.control.control.validator) {
+            return false;
+        }
+
+        const validator = this.control.control.validator({} as AbstractControl);
+        return validator && validator.required;
+    }
+
+    hasErrors(): boolean {
+        return this.showError;
+    }
+    reset() {
+        this.ngSelectComponent.handleClearClick();
+    }
+
+    ngOnDestroy(): void {
+        this._unsubscribeAll.next();
+        this._unsubscribeAll.complete();
+    }
+    // onSearch =  (term: string, item: any) => {
+    //   let key = '';
+    //   this.voc ? key =  "vocabulary." + this.vocId + "." + item.id : key = item.label;
+    //   let value = this.translate.instant(key);
+    //     if(value){
+    //       return value.toLowerCase().includes(term);
+    //     }else{
+    //       return item.label.includes(term);
+    //     }
+
+    // }
+}

package/src/lib/components/vocabulary/vocabulary/vocabulary.component.html

@@ -0,0 +1,12 @@
+<app-dynamic-form-selectitem
+  [data]="data"
+  [bindLabel]="bindLabel"
+  [bindValue]="bindValue"
+  [placeholder]="placeholder"
+  [multiple]="multiple"
+  [searchable]="searchable"
+  [closeOnSelect]="closeOnSelect"
+  [hideSelectedItems]="hideSelectedItems"
+  [loading]="loading"
+  (onSelectItems)="getSelecteditems($event)"
+></app-dynamic-form-selectitem>

package/src/lib/components/vocabulary/vocabulary/vocabulary.component.spec.ts

@@ -0,0 +1,25 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { VocabularyComponent } from './vocabulary.component';
+
+describe('VocabularyComponent', () => {
+  let component: VocabularyComponent;
+  let fixture: ComponentFixture<VocabularyComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ VocabularyComponent ]
+    })
+    .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(VocabularyComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,80 @@
+import { Component, EventEmitter, forwardRef, Input, OnInit, Output } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { VocabularyApiService } from '../services/vocabulary-api.service';
+@Component({
+  selector: 'cts-vocabulary',
+  templateUrl: './vocabulary.component.html',
+  styleUrls: ['./vocabulary.component.scss'],
+  providers: [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => VocabularyComponent),
+      multi: true
+    }
+  ]
+})
+export class VocabularyComponent implements OnInit {
+  data = [];
+  @Input() bindValue;
+  @Input() bindLabel;
+  @Input() placeholder;
+  @Input() multiple = false;
+  @Input() searchable = true;
+  @Input() closeOnSelect = true;
+  @Input() hideSelectedItems = false;
+  @Input() isAsync = false;
+  @Input() attachSource = false;
+  @Input() source$: Observable<any>;
+  @Input() hideLoaded = false;
+  @Input() vocabularyType = '';
+
+  @Output() onSelecting = new EventEmitter();
+  loading= false;
+  selection=[];
+
+  // function related to value accessor
+  propagateChange: any = () => { };
+  validateFn: any = () => { };
+  public onTouched: any = () => { /*Empty*/ }
+
+  constructor(private vocabularyApi : VocabularyApiService) { }
+
+  ngOnInit(): void {
+    if(this.vocabularyType){
+      this.getLisOfOptions(this.vocabularyType);
+    }
+  }
+
+  getLisOfOptions(type){
+    this.loading = true;
+    this.vocabularyApi.getVocabularyList(type).subscribe(res => {
+      this.loading = false;
+      this.data = res;
+    });
+  }
+
+  getSelecteditems(selectedItems){
+    this.propagateChange(selectedItems);
+    this.onSelecting.emit(selectedItems);
+  }
+
+  writeValue(value) {
+    if (value) {
+      this.selection = value;
+    }
+  }
+
+  registerOnChange(fn) {
+    this.propagateChange = fn;
+  }
+
+  registerOnTouched(fn : any) {
+    this.onTouched = fn;
+  }
+
+  validate(c: FormControl) {
+    return this.validateFn(c);
+  }
+
+}

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

@@ -0,0 +1,25 @@
+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 { TranslatedVocabularySelectComponent } from './translated-vocabulary-select/translated-vocabulary-select.component';
+import { FormsModule } from '@angular/forms';
+// import { CoreModule } from '../../core/core.module';
+
+/** @ignore */
+@NgModule({
+  declarations: [VocabularyComponent,TranslatedVocabularySelectComponent],
+  imports: [
+    CommonModule,
+    SelectModule,
+    DynamicFormModule,
+    FormsModule,
+    
+  ],
+  exports : [
+    VocabularyComponent,
+    TranslatedVocabularySelectComponent
+  ]
+})
+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/core/adapters/adapter.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { UtilityService } from '../utilities/utility.service';
+@Injectable({
+  providedIn: 'root',
+})
+export class AdapterService {
+  constructor(private utiliService: UtilityService) {}
+
+  filterNullValues(formValue) {
+    const filtered = {};
+    for (let key in formValue) {
+      if (formValue[key] !== null) {
+        filtered[key] =
+          !Array.isArray(formValue[key]) && typeof formValue[key] === 'object'
+            ? { ...this.filterNullValues(formValue[key]) }
+            : formValue[key];
+      }
+    }
+    return filtered;
+  }
+
+  adaptIn(item: any, fieldsobj: any) {
+    const fields = this.utiliService.objectFlip(fieldsobj);
+    const properties = { ...item.properties };
+    Object.keys(fields).forEach((key) => {
+      properties[fields[key]] = item.properties[key];
+      delete properties[key];
+    });
+    item.properties = properties;
+    return item;
+  }
+
+  adaptOut(item: any, fieldsobj: any) {
+    const fields = fieldsobj;
+    let properties = { ...item };
+    Object.keys(fields).forEach((key) => {
+      if (key) {
+        properties[fields[key]] = item[key];
+        delete properties[key];
+      }
+    });
+    properties = { ...this.filterNullValues(properties) };
+
+    return properties;
+  }
+}

package/src/lib/core/core.module.ts

@@ -0,0 +1,76 @@
+import { CommonModule, registerLocaleData } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import localeAr from '@angular/common/locales/ar';
+import localeEn from '@angular/common/locales/en';
+import { APP_INITIALIZER, ModuleWithProviders, NgModule } from '@angular/core';
+import {
+	TranslateLoader,
+	TranslateModule,
+	TranslateService,
+	TranslateStore
+} from '@ngx-translate/core';
+import { RxReactiveFormsModule } from '@rxweb/reactive-form-validators';
+import { KeycloakAngularModule } from 'keycloak-angular';
+import { ToastrModule } from 'ngx-toastr';
+import { TreeviewModule } from 'ngx-treeview';
+import { AppConfigService } from '../configuration/app-config.service';
+import { appInitializer } from '../configuration/helpers/app-initializer';
+import { TranslateLoaderService } from './services/translation/translate-loader.service';
+import { TRANSLATION_PROVIDER } from './services/translation/translation.service';
+import { Environment, EnvManager } from './env';
+
+registerLocaleData(localeAr);
+registerLocaleData(localeEn);
+/** @ignore */
+
+@NgModule({
+	declarations: [],
+	imports: [
+		CommonModule,
+		TreeviewModule.forRoot(),
+		HttpClientModule,
+		TranslateModule.forRoot(),
+		ToastrModule.forRoot({
+			preventDuplicates: true
+		}),
+		KeycloakAngularModule,
+		RxReactiveFormsModule
+	],
+	exports: [
+		KeycloakAngularModule,
+		TranslateModule,
+		TreeviewModule,
+		ToastrModule,
+		RxReactiveFormsModule
+	],
+	providers: [
+		TranslateStore,
+		TranslateService,
+		{ provide: TranslateLoader, useClass: TranslateLoaderService },
+		{
+			provide: TRANSLATION_PROVIDER,
+			multi: true,
+			useValue: {
+				name: 'app',
+				source: 'assets'
+			}
+		},
+		{
+			provide: APP_INITIALIZER,
+			useFactory: appInitializer,
+			deps: [AppConfigService],
+			multi: true
+		}
+	]
+})
+export class NuxeoCoreModule {
+	static register(
+		environment: Environment
+	): ModuleWithProviders<NuxeoCoreModule> {
+		EnvManager.initialize(environment);
+		return {
+			ngModule: NuxeoCoreModule,
+			providers: [{ provide: 'environment', useValue: environment }]
+		};
+	}
+}