nuxeo-development-framework 3.0.9 → 3.1.2

package/src/lib/components/dynamic-form/interfaces/dynamic-form-keyvaluepairsitem-properties.interface.ts

@@ -0,0 +1,11 @@
+import { DynamicFormItemProperties } from './dynamic-form-item-properties.interface';
+
+export interface DynamicFormKeyValuePairsItemType {
+  name: string;
+  value: string;
+}
+
+export interface DynamicFormKeyValuePairsItemProperties
+  extends DynamicFormItemProperties {
+  value: DynamicFormKeyValuePairsItemType[];
+}

package/src/lib/components/dynamic-form/interfaces/dynamic-form-selectitem-properties.interface.ts

@@ -0,0 +1,13 @@
+import { DynamicFormItemProperties } from './dynamic-form-item-properties.interface';
+import { Observable } from 'rxjs';
+
+export interface DynamicFormSelectItemOption<T> {
+  label: string;
+  key: T;
+}
+
+export interface DynamicFormSelectItemProperties<T>
+  extends DynamicFormItemProperties {
+  value: string;
+  options$: Observable<DynamicFormSelectItemOption<T>[]>;
+}

package/src/lib/components/dynamic-form/interfaces/dynamic-form-textitem-pipe-property.interface.ts

@@ -0,0 +1,6 @@
+import { PipeTransform } from '@angular/core';
+
+export interface DynamicFormTextItemPipeProperty {
+  pipe: PipeTransform;
+  params?: any[];
+}

package/src/lib/components/dynamic-form/interfaces/dynamic-form-textitem-properties.interface.ts

@@ -0,0 +1,9 @@
+import { DynamicFormItemProperties } from './dynamic-form-item-properties.interface';
+import { DynamicFormTextItemPipeProperty } from './dynamic-form-textitem-pipe-property.interface';
+
+export interface DynamicFormTextItemProperties extends DynamicFormItemProperties {
+  multiline?: boolean;
+  multivalued?: boolean;
+  pipes?: DynamicFormTextItemPipeProperty[];
+  clickCallBack?: any;
+}

package/src/lib/components/dynamic-form/interfaces/indifferent-config.interface.ts

@@ -0,0 +1 @@
+export declare type InDifferentConfig = '*';

package/src/lib/components/dynamic-form/interfaces/layout-oriented-config.interface.ts

@@ -0,0 +1,17 @@
+import { Property } from './property.interface';
+
+export interface LayoutOrientedConfigItem {
+  aspect?: string;
+  type?: string;
+  properties: string | string[] | Property[];
+  includeAll?: boolean;
+  exclude?: string | string[];
+  editable?: boolean;
+}
+
+export interface LayoutOrientedConfigLayoutBlock {
+  title: string;
+  items: LayoutOrientedConfigItem[];
+}
+
+export type LayoutOrientedConfig = Array<LayoutOrientedConfigLayoutBlock>;

package/src/lib/components/dynamic-form/interfaces/organised-property-group.interface.ts

@@ -0,0 +1,7 @@
+import { Property } from './property.interface';
+
+export interface OrganisedPropertyGroup {
+  title: string;
+  name?: string;
+  properties: Property[];
+}

package/src/lib/components/dynamic-form/interfaces/preset-config.interface.ts

@@ -0,0 +1,8 @@
+import { InDifferentConfig } from './indifferent-config.interface';
+import { AspectOrientedConfig } from './aspect-oriented-config.interface';
+import { LayoutOrientedConfig } from './layout-oriented-config.interface';
+
+export declare type PresetConfig =
+  | InDifferentConfig
+  | AspectOrientedConfig
+  | LayoutOrientedConfig;

package/src/lib/components/dynamic-form/interfaces/property-group.interface.ts

@@ -0,0 +1,14 @@
+import { Property } from './property.interface';
+
+export interface PropertyGroup {
+  name: string;
+  title: string;
+  description?: string;
+  properties: {
+    [key: string]: Property;
+  };
+}
+
+export interface PropertyGroupContainer {
+  [key: string]: PropertyGroup;
+}

package/src/lib/components/dynamic-form/interfaces/property.interface.ts

@@ -0,0 +1,12 @@
+export interface Property {
+  name: string;
+  title: string;
+  description?: string;
+  dataType: string;
+  defaultValue?: any;
+  mandatory: boolean;
+  multiValued: boolean;
+  editable?: boolean;
+  constraints: any[];
+  url?: string;
+}

package/src/lib/components/dynamic-form/models/dynamic-form-arrayitem.model.ts

@@ -0,0 +1,26 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import { Observable } from 'rxjs';
+import { DynamicFormArrayItemProperties } from '../interfaces/dynamic-form-arrayitem-properties.interface';
+
+export interface DynamicFormArrayItem {
+  icon: string;
+  value: string;
+}
+
+export class DynamicFormArrayItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'array';
+  value: Observable<DynamicFormArrayItem[]>;
+  noOfItemsToDisplay: number;
+
+  constructor(DynamicFormArrayItemProperties: DynamicFormArrayItemProperties) {
+    super(DynamicFormArrayItemProperties);
+    this.noOfItemsToDisplay = DynamicFormArrayItemProperties.noOfItemsToDisplay;
+  }
+
+  get displayValue(): Observable<DynamicFormArrayItem[]> {
+    return this.value;
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-baseitem.model.ts

@@ -0,0 +1,96 @@
+import {
+  DynamicFormItemProperties,
+  DynamicFormItemValidator
+} from '../interfaces/dynamic-form.interfaces';
+import { DynamicFormRequiredValidator } from '../validators/required-validator';
+import { DynamicFormLengthValidator } from '../validators/length-validator';
+import { DynamicFormRegexValidator } from '../validators/regex-validator';
+import { DynamicFormValueValidator } from '../validators/value-validator';
+
+export abstract class DynamicFormBaseItemModel {
+  get label(): string {
+    return this._label;
+  }
+  set label(newLabel: string) {
+    this._label = newLabel;
+  }
+
+  _label: string;
+  value: any;
+  key: any;
+  default: any;
+  description: any;
+  editable: boolean;
+  clickable: boolean;
+  icon?: string;
+  mandatory?: boolean;
+  constraints?: any[];
+  validators?: DynamicFormItemValidator[];
+  data?: any;
+
+  constructor(DynamicFormItemProperties: DynamicFormItemProperties) {
+    this.label = DynamicFormItemProperties.label || '';
+    this.description = DynamicFormItemProperties.description || '';
+    this.value =
+      (DynamicFormItemProperties.value &&
+        DynamicFormItemProperties.value.displayName) ||
+      DynamicFormItemProperties.value;
+    this.key = DynamicFormItemProperties.key;
+    this.mandatory = DynamicFormItemProperties.mandatory;
+    this.default = DynamicFormItemProperties.default;
+    this.editable = !!DynamicFormItemProperties.editable;
+    this.clickable = !!DynamicFormItemProperties.clickable;
+    this.icon = DynamicFormItemProperties.icon || '';
+    this.validators = DynamicFormItemProperties.validators || [];
+    this.constraints = DynamicFormItemProperties.constraints || [];
+    this.data = DynamicFormItemProperties.data || null;
+    if (this.mandatory) {
+      this.validators.push(new DynamicFormRequiredValidator());
+    }
+    this.constraints.forEach(constraint => {
+      if (constraint.type === 'LENGTH') {
+        this.validators.push(
+          new DynamicFormLengthValidator(
+            constraint.parameters.reduce((r, c) => Object.assign(r, c), {})
+          )
+        );
+      } else if (constraint.type === 'REGEX') {
+        this.validators.push(
+          new DynamicFormRegexValidator(
+            constraint.parameters.reduce((r, c) => Object.assign(r, c), {})
+          )
+        );
+      } else if (constraint.type === 'MINMAX') {
+        this.validators.push(
+          new DynamicFormValueValidator(
+            constraint.parameters.reduce((r, c) => Object.assign(r, c), {})
+          )
+        );
+      }
+    });
+  }
+
+  isEmpty(): boolean {
+    return this.value === undefined || this.value === null || this.value === '';
+  }
+
+  isValid(newValue: any): boolean {
+    if (!this.validators.length) {
+      return true;
+    }
+
+    return this.validators
+      .map(validator => validator.isValid(newValue))
+      .reduce((isValidUntilNow, isValid) => isValidUntilNow && isValid, true);
+  }
+
+  getValidationErrors(value): any[] {
+    if (!this.validators.length) {
+      return [];
+    }
+
+    return this.validators
+      .filter(validator => !validator.isValid(value))
+      .map(validator => validator);
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-boolitem.model.ts

@@ -0,0 +1,27 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import { DynamicFormBoolItemProperties } from '../interfaces/dynamic-form.interfaces';
+
+export class DynamicFormBoolItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'bool';
+  value: boolean = false;
+  default: boolean;
+
+  constructor(DynamicFormBoolItemProperties: DynamicFormBoolItemProperties) {
+    super(DynamicFormBoolItemProperties);
+
+    if (DynamicFormBoolItemProperties.value !== undefined) {
+      this.value = !!JSON.parse(DynamicFormBoolItemProperties.value);
+    }
+  }
+
+  get displayValue() {
+    if (this.isEmpty()) {
+      return this.default;
+    } else {
+      return this.value;
+    }
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-dateitem.model.ts

@@ -0,0 +1,39 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import { DynamicFormDateItemProperties } from '../interfaces/dynamic-form.interfaces';
+import { LocalizedDatePipe } from '../../../pipes/localized-date.pipe';
+
+export class DynamicFormDateItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'date';
+  format: string;
+  locale: string;
+
+  localizedDatePipe: LocalizedDatePipe;
+
+  constructor(DynamicFormDateItemProperties: DynamicFormDateItemProperties) {
+    super(DynamicFormDateItemProperties);
+
+    if (DynamicFormDateItemProperties.format) {
+      this.format = DynamicFormDateItemProperties.format;
+    }
+
+    if (DynamicFormDateItemProperties.locale) {
+      this.locale = DynamicFormDateItemProperties.locale;
+    }
+  }
+
+  get displayValue() {
+    if (!this.value) {
+      return this.default;
+    } else {
+      this.localizedDatePipe = new LocalizedDatePipe();
+      return this.localizedDatePipe.transform(
+        this.value,
+        this.format,
+        this.locale
+      );
+    }
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-datetimeitem.model.ts

@@ -0,0 +1,18 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormDateItemModel } from './dynamic-form-dateitem.model';
+import { DynamicFormDateItemProperties } from '../interfaces/dynamic-form.interfaces';
+
+export class DynamicFormDatetimeItemModel extends DynamicFormDateItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'datetime';
+  format: string = 'MMM d, y, H:mm';
+
+  constructor(DynamicFormDateItemProperties: DynamicFormDateItemProperties) {
+    super(DynamicFormDateItemProperties);
+
+    if (DynamicFormDateItemProperties.format) {
+      this.format = DynamicFormDateItemProperties.format;
+    }
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-keyvaluepairs.model.ts

@@ -0,0 +1,19 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import { DynamicFormKeyValuePairsItemProperties } from '../interfaces/dynamic-form.interfaces';
+
+export class DynamicFormKeyValuePairsItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'keyvaluepairs';
+
+  constructor(
+    DynamicFormKeyValuePairsItemProperties: DynamicFormKeyValuePairsItemProperties
+  ) {
+    super(DynamicFormKeyValuePairsItemProperties);
+  }
+
+  get displayValue() {
+    return this.value;
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-mapitem.model.ts

@@ -0,0 +1,17 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+
+export class DynamicFormMapItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'map';
+  value: Map<string, string>;
+
+  get displayValue() {
+    if (this.value && this.value.size > 0) {
+      return this.value.values().next().value;
+    } else {
+      return this.default;
+    }
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-selectitem.model.ts

@@ -0,0 +1,30 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import {
+  DynamicFormSelectItemProperties,
+  DynamicFormSelectItemOption
+} from '../interfaces/dynamic-form.interfaces';
+import { Observable, of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+
+export class DynamicFormSelectItemModel<T> extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'select';
+  options$: Observable<DynamicFormSelectItemOption<T>[]>;
+
+  constructor(DynamicFormSelectItemProperties: DynamicFormSelectItemProperties<T>) {
+    super(DynamicFormSelectItemProperties);
+
+    this.options$ = DynamicFormSelectItemProperties.options$;
+  }
+
+  get displayValue() {
+    return this.options$.pipe(
+      switchMap(options => {
+        const option = options.find(o => o.key === this.value);
+        return of(option ? option.label : '');
+      })
+    );
+  }
+}

package/src/lib/components/dynamic-form/models/dynamic-form-textitem.model.ts

@@ -0,0 +1,47 @@
+import { DynamicFormItem } from '../interfaces/dynamic-form-item.interface';
+import { DynamicComponentModel } from '../services/dynamic-component-mapper.service';
+import { DynamicFormBaseItemModel } from './dynamic-form-baseitem.model';
+import {
+  DynamicFormTextItemPipeProperty,
+  DynamicFormTextItemProperties
+} from '../interfaces/dynamic-form.interfaces';
+
+export class DynamicFormTextItemModel extends DynamicFormBaseItemModel
+  implements DynamicFormItem, DynamicComponentModel {
+  type: string = 'text';
+  inputType: string = 'text';
+  multiline?: boolean;
+  multivalued?: boolean;
+  pipes?: DynamicFormTextItemPipeProperty[];
+  clickCallBack?: any;
+
+  constructor(DynamicFormTextItemProperties: DynamicFormTextItemProperties) {
+    super(DynamicFormTextItemProperties);
+    this.multiline = !!DynamicFormTextItemProperties.multiline;
+    this.multivalued = !!DynamicFormTextItemProperties.multivalued;
+    this.pipes = DynamicFormTextItemProperties.pipes || [];
+    this.clickCallBack = DynamicFormTextItemProperties.clickCallBack
+      ? DynamicFormTextItemProperties.clickCallBack
+      : null;
+
+    if (this.default && this.isEmpty()) {
+      this.value = this.default;
+    } else if (this.isEmpty()) {
+      this.value = '';
+    }
+  }
+
+  get displayValue(): string {
+    return this.applyPipes(this.value);
+  }
+
+  private applyPipes(displayValue) {
+    if (this.pipes.length) {
+      displayValue = this.pipes.reduce((accumulator, { pipe, params = [] }) => {
+        return pipe.transform(accumulator, ...params);
+      }, displayValue);
+    }
+
+    return displayValue;
+  }
+}

package/src/lib/components/dynamic-form/services/card-item-types.service.ts

@@ -0,0 +1,55 @@
+import { Injectable, Type } from '@angular/core';
+import { DynamicFormDateItemComponent } from '../components/dynamic-form-dateitem/dynamic-form-dateitem.component';
+import { DynamicFormMapItemComponent } from '../components/dynamic-form-mapitem/dynamic-form-mapitem.component';
+import { DynamicFormTextItemComponent } from '../components/dynamic-form-textitem/dynamic-form-textitem.component';
+import { DynamicFormSelectItemComponent } from '../components/dynamic-form-selectitem/dynamic-form-selectitem.component';
+import { DynamicFormBoolItemComponent } from '../components/dynamic-form-boolitem/dynamic-form-boolitem.component';
+
+
+import {
+  DynamicComponentMapper,
+  DynamicComponentModel,
+  DynamicComponentResolver,
+  DynamicComponentResolveFunction
+} from './dynamic-component-mapper.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CardItemTypeService extends DynamicComponentMapper {
+  protected defaultValue: Type<{}> = DynamicFormTextItemComponent;
+
+  protected types: { [key: string]: DynamicComponentResolveFunction } = {
+    text: DynamicComponentResolver.fromType(DynamicFormTextItemComponent),
+    select: DynamicComponentResolver.fromType(DynamicFormSelectItemComponent),
+    int: DynamicComponentResolver.fromType(DynamicFormTextItemComponent),
+    float: DynamicComponentResolver.fromType(DynamicFormTextItemComponent),
+    date: DynamicComponentResolver.fromType(DynamicFormDateItemComponent),
+    datetime: DynamicComponentResolver.fromType(DynamicFormDateItemComponent),
+    bool: DynamicComponentResolver.fromType(DynamicFormBoolItemComponent),
+    map: DynamicComponentResolver.fromType(DynamicFormMapItemComponent),
+
+  };
+
+  getComponentTypeResolver(
+    type: string,
+    defaultValue: Type<{}> = this.defaultValue
+  ): DynamicComponentResolveFunction {
+    if (type) {
+      return (
+        this.types[type] || DynamicComponentResolver.fromType(defaultValue)
+      );
+    }
+    return DynamicComponentResolver.fromType(defaultValue);
+  }
+  resolveComponentType(
+    model: DynamicComponentModel,
+    defaultValue: Type<{}> = this.defaultValue
+  ): Type<{}> {
+    if (model) {
+      const resolver = this.getComponentTypeResolver(model.type, defaultValue);
+      return resolver(model);
+    }
+    return defaultValue;
+  }
+}

package/src/lib/components/dynamic-form/services/dynamic-component-mapper.service.ts

@@ -0,0 +1,86 @@
+import { Type } from '@angular/core';
+
+export function getType(type: any): any {
+  const res =  () => type;
+  return res;
+}
+export interface DynamicComponentModel {
+  type: string;
+}
+export type DynamicComponentResolveFunction = (
+  model: DynamicComponentModel
+) => Type<{}>;
+export class DynamicComponentResolver {
+  static fromType(type: Type<{}>): DynamicComponentResolveFunction {
+    return getType(type);
+  }
+}
+
+export abstract class DynamicComponentMapper {
+  protected defaultValue: Type<{}> = undefined;
+  protected types: { [key: string]: DynamicComponentResolveFunction } = {};
+
+  /**
+   * Gets the currently active DynamicComponentResolveFunction for a field type.
+   * @param type The type whose resolver you want
+   * @param defaultValue Default type returned for types that are not yet mapped
+   * @returns Resolver function
+   */
+  getComponentTypeResolver(
+    type: string,
+    defaultValue: Type<{}> = this.defaultValue
+  ): DynamicComponentResolveFunction {
+    if (type) {
+      return (
+        this.types[type] || DynamicComponentResolver.fromType(defaultValue)
+      );
+    }
+    return DynamicComponentResolver.fromType(defaultValue);
+  }
+
+  /**
+   * Sets or optionally replaces a DynamicComponentResolveFunction for a field type.
+   * @param type The type whose resolver you want to set
+   * @param resolver The new resolver function
+   * @param override The new resolver will only replace an existing one if this parameter is true
+   */
+  setComponentTypeResolver(
+    type: string,
+    resolver: DynamicComponentResolveFunction,
+    override: boolean = true
+  ) {
+    if (!type) {
+      throw new Error(`type is null or not defined`);
+    }
+
+    if (!resolver) {
+      throw new Error(`resolver is null or not defined`);
+    }
+
+    const existing = this.types[type];
+    if (existing && !override) {
+      throw new Error(
+        `already mapped, use override option if you intend replacing existing mapping.`
+      );
+    }
+
+    this.types[type] = resolver;
+  }
+
+  /**
+   * Finds the component type that is needed to render a form field.
+   * @param model Form field model for the field to render
+   * @param defaultValue Default type returned for field types that are not yet mapped.
+   * @returns Component type
+   */
+  resolveComponentType(
+    model: DynamicComponentModel,
+    defaultValue: Type<{}> = this.defaultValue
+  ): Type<{}> {
+    if (model) {
+      const resolver = this.getComponentTypeResolver(model.type, defaultValue);
+      return resolver(model);
+    }
+    return defaultValue;
+  }
+}