@mediusinc/mng-commons 0.2.1-rc → 0.2.4

package/src/lib/descriptors/editor.descriptor.ts

@@ -1,880 +0,0 @@
-import {Type} from '@angular/core';
-import {AbstractControl} from '@angular/forms';
-import {FormlyFieldConfig} from '@ngx-formly/core';
-
-import {Observable, of} from 'rxjs';
-
-import {ClassType, EnumMemberType} from '../types';
-import {ILookupDataProvider, ITableDataProvider, LookupDataProvider, TableviewDataProvider} from '../data-providers';
-import {ModelDescriptor, TableDescriptor, TableviewDescriptor, FieldValidator, ILookupDescriptor} from './';
-
-import {MediusQueryParam, MediusQueryResult} from '../api/models';
-import {ObjectSerializer} from '../api/utils';
-import {ModelUtil} from '../utils';
-
-export class EditorDescriptor<T> {
-
-    public static readonly defaultGroupName = '_default';
-
-    private readonly _model: ModelDescriptor<T>;
-    private readonly _tabs: Array<FieldTabGroupDescriptor<T>> = [];
-    private readonly _groups: Array<FieldGroupDescriptor<T>> = [];
-    private readonly _fields: Array<AFieldDescriptor<any, T>> = [];
-    private _currentTabGroup?: FieldTabGroupDescriptor<T>;
-    private _currentGroup?: FieldGroupDescriptor<T>;
-
-    private _disabled: boolean = false;
-
-    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string) {
-        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty);
-    }
-
-    public get model() {
-        return this._model;
-    }
-
-    public get tabs() {
-        return this._tabs;
-    }
-
-    public get disabled() {
-        return this._disabled;
-    }
-
-    public get fields() {
-        return this._fields;
-    }
-
-    public createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<T> {
-        const tabGroup = new FieldTabGroupDescriptor<T>(this, name);
-        if (title) {
-            tabGroup.withTitle(title);
-        }
-        this.createTabGroupDescriptor(tabGroup);
-        return tabGroup;
-    }
-
-    public createFieldGroup(name: string, title?: string): FieldGroupDescriptor<T> {
-        const fieldGroup = new FieldGroupDescriptor<T>(this, name);
-        if (title) {
-            fieldGroup.withTitle(title);
-        }
-        this.createFieldGroupDescriptor(fieldGroup);
-        return fieldGroup;
-    }
-
-    public addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this {
-        this.createDefaultGroup();
-        this._fields.push(field);
-        this._currentGroup?.addField(field);
-        return this;
-    }
-
-    public addField(property: string): FieldInputDescriptor<T> {
-        const field = new FieldInputDescriptor<T>(this, property);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-
-    public removeField(property: string): this {
-        const fieldIdx = this._fields.findIndex(f => f.property === property);
-        if (fieldIdx < 0) {
-            throw new Error(`Field ${property} does not exist.`);
-        }
-        const field = this._fields[fieldIdx];
-        if (field.group) {
-            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
-            if (groupFieldIdx >= 0) {
-                field.group.fields.splice(groupFieldIdx, 1);
-            }
-        }
-        this._fields.splice(fieldIdx, 1);
-        return this;
-    }
-
-    public getField(property: string): AFieldDescriptor<any, T>|null {
-        return this._fields.find(f => f.property === property) ?? null;
-    }
-
-    public addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T> {
-        const field = new FieldLookupDescriptor<FT, T>(this, property, modelType);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-
-    public addFieldLookupEnum(property: string, options: Array<EnumMemberType>): FieldLookupEnumDescriptor<T> {
-        const propDef = ObjectSerializer.get().findAttributeDefinitionByClassType(this.model.type, property);
-        if (!propDef) {
-            throw new Error(`Property (attribute) definition not found for property ${property} on class type ${this._model.typeName}`);
-        }
-        const enumDef = ObjectSerializer.get().findEnum(propDef.type);
-        if (!enumDef) {
-            throw new Error(`Enum definition ${propDef.type} not found for property ${property} on class type ${this._model.typeName}`);
-        }
-        const field = new FieldLookupEnumDescriptor(this, property, propDef.type, options);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-
-    public addFieldManyEditor<FT>(property: string, type: ClassType<FT>, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T> {
-        const field = new FieldManyEditorDescriptor(this, property, type, tableviewDescriptor);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-
-    public addFieldManyToManyEditor<FT>(property: string, type: ClassType<FT>, mainTableDescriptor: TableDescriptor<FT>, lookupTableDescriptor: TableDescriptor<FT>): FieldManyToManyEditorDescriptor<FT, T> {
-        const field = new FieldManyToManyEditorDescriptor(this, property, type, mainTableDescriptor, lookupTableDescriptor);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-
-    public withDisabled(disabled: boolean = true): this {
-        this._disabled = disabled;
-        return this;
-    }
-
-    public addValidator(name: string, expression: (control: AbstractControl) => boolean) {
-        if (this._currentGroup) {
-            this._currentGroup.withValidator(name, expression);
-        }
-    }
-
-    public copy(): EditorDescriptor<T> {
-        const editor = new EditorDescriptor<T>(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
-        for (const tabGroup of this._tabs) {
-            editor.createTabGroupDescriptor(tabGroup.copy());
-        }
-        for (const tabGroup of editor._tabs) {
-            for (const fieldGroup of tabGroup.fields) {
-                editor._fields.push(...fieldGroup.fields);
-            }
-            editor._groups.push(...tabGroup.fields);
-        }
-        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
-        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
-        editor._disabled = this._disabled;
-        return editor;
-    }
-
-    private createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this {
-        this._currentTabGroup = tabGroup;
-        this._tabs.push(tabGroup);
-        return this;
-    }
-
-    public createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this {
-        this.createDefaultTabGroup();
-        this._currentGroup = fieldGroup;
-        this._groups.push(fieldGroup);
-        this._currentTabGroup?.addField(fieldGroup);
-        return this;
-    }
-
-    private createDefaultGroup() {
-        this.createDefaultTabGroup();
-        if (this._currentTabGroup?.fields.length === 0) {
-            this.createFieldGroup(EditorDescriptor.defaultGroupName);
-        }
-    }
-
-    private createDefaultTabGroup() {
-        if (this._tabs.length === 0) {
-            this.createTabGroup(EditorDescriptor.defaultGroupName);
-        }
-    }
-}
-
-export abstract class AGenericFieldDescriptor<ET> {
-    protected readonly _editor: EditorDescriptor<ET>;
-
-    protected constructor(editor: EditorDescriptor<ET>) {
-        this._editor = editor;
-    }
-
-    public get editor() {
-        return this._editor;
-    }
-}
-
-export abstract class AFieldDescriptor<T, ET> extends AGenericFieldDescriptor<ET> {
-
-    protected readonly _property: string;
-    protected _group?: AFieldGroupDescriptor<ET>;
-    protected _label?: string;
-    protected _placeholder?: string;
-    protected _required: boolean = false;
-    protected _disabled: boolean = false;
-    protected _className: string = '';
-    protected _getter?: (item: ET) => T;
-    protected _setter?: (item: ET, value: T) => void;
-    protected _validators: Array<FieldValidator> = [];
-
-    protected constructor(editor: EditorDescriptor<ET>, property: string) {
-        super(editor);
-        this._property = property;
-        this._label = this._editor.model.typeName + '.properties.' + property;
-    }
-
-    public abstract copy(): AFieldDescriptor<T, ET>;
-
-    public get property() {
-        return this._property;
-    }
-
-    public get group() {
-        return this._group;
-    }
-
-    public get label() {
-        return this._label;
-    }
-
-    public get placeholder() {
-        return this._placeholder;
-    }
-
-    public get required() {
-        return this._required;
-    }
-
-    public get disabled() {
-        return this._disabled;
-    }
-
-    public get className() {
-        return this._className;
-    }
-
-    public get getter() {
-        return this._getter;
-    }
-
-    public get setter() {
-        return this._setter;
-    }
-
-    public get validators() {
-        return this._validators;
-    }
-
-    public withLabel(label: string): this {
-        this._label = label;
-        return this;
-    }
-
-    public withPlaceholder(placeholder: string): this {
-        this._placeholder = placeholder;
-        return this;
-    }
-
-    public withRequired(required: boolean = true): this {
-        this._required = required;
-        return this;
-    }
-
-    public withDisabled(disabled: boolean = true): this {
-        this._disabled = disabled;
-        return this;
-    }
-
-    public withClassName(className: string): this {
-        this._className = className;
-        return this;
-    }
-
-    public withGetter(getter: (item: ET) => T): this {
-        this._getter = getter;
-        return this;
-    }
-
-    public withSetter(setter: (item: ET, value: T) => void): this {
-        this._setter = setter;
-        return this;
-    }
-
-    public withValidator(name: string, expression: (control: AbstractControl) => boolean,
-                         message: (err: any, field: FormlyFieldConfig) => string): this {
-        this._validators.push(new FieldValidator(name, expression, message));
-        return this;
-    }
-
-    protected copyFieldsTo(obj: AFieldDescriptor<T, ET>) {
-        obj._label = this._label;
-        obj._placeholder = this._placeholder;
-        obj._required = this._required;
-        obj._disabled = this._disabled;
-        obj._className = this._className;
-        obj._getter = this._getter;
-        obj._setter = this._setter;
-        obj._validators = this._validators;
-    }
-}
-
-export class FieldInputDescriptor<ET> extends AFieldDescriptor<string|number|boolean|Date, ET> {
-
-    private _fieldType: FieldInputDescriptor.TypeEnum = FieldInputDescriptor.TypeEnum.Text;
-
-    // textarea specific properties
-    private _rows?: number;
-
-    // number specific properties
-    private _numberMin?: number;
-    private _numberMax?: number;
-    private _numberStep?: number;
-    private _numberMinFractionDigits?: number;
-    private _numberMaxFractionDigits?: number;
-
-    // radio specific properties
-    private _radioOptions: Array<string> = [];
-
-    // datepicker specific properties
-    private _datePickerFormat?: string;
-    private _datePickerMin?: Date;
-    private _datePickerMax?: Date;
-    private _datePickerShowTime: boolean = false;
-
-    // input specific
-    private _maxLength?: number;
-    private _minLength?: number;
-    private _pattern?: string | RegExp;
-
-    constructor(editor: EditorDescriptor<ET>, property: string) {
-        super(editor, property);
-    }
-
-    public get fieldType() {
-        return this._fieldType;
-    }
-
-    public get numberStep() {
-        return this._numberStep;
-    }
-
-    public get numberMin() {
-        return this._numberMin;
-    }
-
-    public get numberMax() {
-        return this._numberMax;
-    }
-
-    public get rows() {
-        return this._rows;
-    }
-
-    public get numberMinFractionDigits() {
-        return this._numberMinFractionDigits;
-    }
-
-    public get numberMaxFractionDigits() {
-        return this._numberMaxFractionDigits;
-    }
-
-    public get radioOptions() {
-        return this._radioOptions;
-    }
-
-    public get datePickerFormat() {
-        return this._datePickerFormat;
-    }
-
-    public get datePickerMin() {
-        return this._datePickerMin;
-    }
-
-    public get datePickerMax() {
-        return this._datePickerMax;
-    }
-
-    public get datePickerShowTime() {
-        return this._datePickerShowTime;
-    }
-
-    public get maxLength() {
-        return this._maxLength;
-    }
-
-    public get minLength() {
-        return this._minLength;
-    }
-
-    public get pattern() {
-        return this._pattern;
-    }
-
-    public asText(minLength?: number, maxLength?: number, pattern?: string | RegExp): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Text;
-        this._minLength = minLength;
-        this._maxLength = maxLength;
-        this._pattern = pattern;
-        return this;
-    }
-
-    public asTextarea(rows: number = 3): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Textarea;
-        this._rows = rows;
-        return this;
-    }
-
-    public asNumber(step?: number, min?: number, max?: number, minFractionDigits?: number, maxFractionDigits?: number): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Number;
-        this._numberStep = step;
-        this._numberMinFractionDigits = minFractionDigits;
-        this._numberMaxFractionDigits = maxFractionDigits;
-        this._numberMin = min ?? Number.MIN_SAFE_INTEGER;
-        this._numberMax = max ?? Number.MAX_SAFE_INTEGER;
-        return this;
-    }
-
-    public asSwitch(): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Switch;
-        return this;
-    }
-
-    public asRadio(options: Array<string>): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Radio;
-        this._radioOptions = options;
-        return this;
-    }
-
-    public asDatePicker(format?: string, min?: Date, max?: Date, showTime?: boolean): this {
-        this._fieldType = FieldInputDescriptor.TypeEnum.Datepicker;
-        this._datePickerFormat = format ? format : 'dd.mm.yy';
-        this._datePickerMin = min;
-        this._datePickerMax = max;
-        this._datePickerShowTime = showTime ?? false;
-        return this;
-    }
-
-    public copy(): FieldInputDescriptor<ET> {
-        const field = new FieldInputDescriptor<ET>(this._editor, this._property);
-        this.copyFieldsTo(field);
-        field._fieldType = this._fieldType;
-        field._rows = this._rows;
-        field._numberMin = this._numberMin;
-        field._numberMax = this._numberMax;
-        field._numberStep = this._numberStep;
-        field._numberMinFractionDigits = this._numberMinFractionDigits;
-        field._numberMaxFractionDigits = this._numberMaxFractionDigits;
-        field._radioOptions = this._radioOptions;
-        field._datePickerFormat = this._datePickerFormat;
-        field._datePickerMin = this._datePickerMin;
-        field._datePickerMax = this._datePickerMax;
-        field._datePickerShowTime = this._datePickerShowTime;
-        field._maxLength = this._maxLength;
-        field._minLength = this._minLength;
-        field._pattern = this._pattern;
-        return field;
-    }
-}
-export namespace FieldInputDescriptor {
-    export enum TypeEnum {
-        Text,
-        Textarea,
-        Number,
-        Switch,
-        Radio,
-        Datepicker
-    }
-}
-
-export class FieldLookupDescriptor<T, ET> extends AFieldDescriptor<T, ET> implements ILookupDescriptor<T> {
-
-    protected readonly _modelType: ClassType<T>|null;
-    protected _lookupType: FieldLookupDescriptor.LookupTypeEnum = FieldLookupDescriptor.LookupTypeEnum.Dropdown;
-    protected _itemsLabelProperty?: string;
-    protected _itemsValueProperty?: string;
-    protected _dataKeyProperty?: string;
-    protected _dataProvider?: ILookupDataProvider<T, any>;
-
-    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>|null) {
-        super(editor, property);
-        this._modelType = modelType;
-        ModelUtil.trySetLookupItemsProperties(this);
-    }
-
-    public get modelType() {
-        return this._modelType;
-    }
-
-    public get lookupType() {
-        return this._lookupType;
-    }
-
-    public get itemsLabelProperty() {
-        return this._itemsLabelProperty;
-    }
-
-    public get itemsValueProperty() {
-        return this._itemsValueProperty;
-    }
-
-    public get dataKeyProperty() {
-        return this._dataKeyProperty;
-    }
-
-    public get dataProvider() {
-        return this._dataProvider;
-    }
-
-    public withItemsLabelProperty(itemsLabelProperty: string): this {
-        this._itemsLabelProperty = itemsLabelProperty;
-        return this;
-    }
-
-    public withItemsValueProperty(itemsValueProperty: string): this {
-        this._itemsValueProperty = itemsValueProperty;
-        return this;
-    }
-
-    public withDataKeyProperty(property: string): this {
-        this._dataKeyProperty = property;
-        return this;
-    }
-
-    public withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this {
-        const dataProvider = new LookupDataProvider<T, S>(this._modelType);
-        if (serviceType) {
-            dataProvider.withServiceType(serviceType);
-        }
-        dataProvider.withLookup(lookup);
-        this._dataProvider = dataProvider;
-        return this;
-    }
-
-    public withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this {
-        this._dataProvider = dataProvider;
-        return this;
-    }
-
-    public asAutocomplete(): this {
-        this._lookupType = FieldLookupDescriptor.LookupTypeEnum.Autocomplete;
-        return this;
-    }
-
-    public copy(): FieldLookupDescriptor<T, ET> {
-        const field = new FieldLookupDescriptor(this._editor, this._property, this._modelType);
-        this.copyFieldsTo(field);
-        field._lookupType = this._lookupType;
-        field._itemsLabelProperty = this._itemsLabelProperty;
-        field._itemsValueProperty = this._itemsValueProperty;
-        field._dataKeyProperty = this._dataKeyProperty;
-        field._dataProvider = this._dataProvider;
-        return field;
-    }
-}
-
-export namespace FieldLookupDescriptor {
-    export enum LookupTypeEnum {
-        Dropdown,
-        Autocomplete
-    }
-}
-
-export class FieldLookupEnumDescriptor<ET> extends FieldLookupDescriptor<EnumMemberType, ET> {
-
-    private readonly _enumName: string;
-
-    constructor(editor: EditorDescriptor<ET>, property: string, enumName: string, options: Array<EnumMemberType>) {
-        super(editor, property, null);
-
-        this._enumName = enumName;
-        const dataProvider = new LookupDataProvider<EnumMemberType, any>(null)
-            .withEnumName(enumName)
-            .withLookup(() => of(options));
-        this.withLookupDataProvider(dataProvider);
-    }
-
-    public get enumName() {
-        return this._enumName;
-    }
-
-    public override copy(): FieldLookupEnumDescriptor<ET> {
-        const field = new FieldLookupEnumDescriptor<ET>(this._editor, this._property, this._enumName, []);
-        this.copyFieldsTo(field);
-        field._lookupType = this._lookupType;
-        field._itemsLabelProperty = this._itemsLabelProperty;
-        field._itemsValueProperty = this._itemsValueProperty;
-        field._dataKeyProperty = this._dataKeyProperty;
-        field._dataProvider = this._dataProvider;
-        return field;
-    }
-}
-
-export class FieldManyToManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {
-
-    private readonly _model: ModelDescriptor<T>;
-    private readonly _mainTableDescriptor: TableDescriptor<T>; // table descriptor for main table component
-    private readonly _lookupTableDescriptor: TableDescriptor<T>; // table descriptor for where select will be applied
-    private _fieldType: FieldManyToManyEditorDescriptor.TypeEnum = FieldManyToManyEditorDescriptor.TypeEnum.DialogTableMultiselect;
-    private _lookupTableDataProvider: ITableDataProvider<T, any>|null = null;
-    private _actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = [];
-    private _hasLookupExcludeValues: boolean = false;
-    private _excludeFilterProperty: string = '';
-    private _excludeValueProperty: string = '';
-
-    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, mainTableDescriptor: TableDescriptor<T>, lookupTableDescriptor: TableDescriptor<T>) {
-        super(editor, property);
-        this._model = new ModelDescriptor<T>(modelType);
-        this._mainTableDescriptor = mainTableDescriptor;
-        this._lookupTableDescriptor = lookupTableDescriptor;
-        this._actions.push(FieldManyToManyEditorDescriptor.ActionEnum.Add, FieldManyToManyEditorDescriptor.ActionEnum.Delete);
-    }
-
-    public get mainTableDescriptor() {
-        return this._mainTableDescriptor;
-    }
-
-    public get lookupTableDescriptor() {
-        return this._lookupTableDescriptor;
-    }
-
-    public get lookupTableDataProvider() {
-        return this._lookupTableDataProvider;
-    }
-
-    public get actions() {
-        return this._actions;
-    }
-
-    public get fieldType() {
-        return this._fieldType;
-    }
-
-    public get hasLookupExcludeValues() {
-        return this._hasLookupExcludeValues;
-    }
-
-    public get excludeFilterProperty() {
-        return this._excludeFilterProperty;
-    }
-
-    public get excludeValueProperty() {
-        return this._excludeValueProperty;
-    }
-
-    public withLookup<S>(getAll: (queryParam: MediusQueryParam, service?: S) => Observable<MediusQueryResult<T>>, serviceType?: Type<S>): this {
-        const dataProvider = new TableviewDataProvider<T, S>(this._model.type);
-        if (serviceType) {
-            dataProvider.withServiceType(serviceType);
-        }
-        dataProvider.withGetAll(getAll);
-        this._lookupTableDataProvider = dataProvider;
-        return this;
-    }
-
-    public withLookupDataProvider(dataProvider: ITableDataProvider<T, any>): this {
-        this._lookupTableDataProvider = dataProvider;
-        return this;
-    }
-
-    public withActions(actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = []): this {
-        this.actions.push(...actions);
-        return this;
-    }
-
-    public withLookupExclude(filterProperty: string, valueProperty: string, hasLookupExclude: boolean = true): this {
-        this._hasLookupExcludeValues = hasLookupExclude;
-        this._excludeFilterProperty = filterProperty;
-        this._excludeValueProperty = valueProperty;
-        return this;
-    }
-
-    public copy(): FieldManyToManyEditorDescriptor<T, ET> {
-        const field = new FieldManyToManyEditorDescriptor(this._editor, this._property, this._model.type, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy());
-        this.copyFieldsTo(field);
-        field._fieldType = this._fieldType;
-        field._actions = this._actions.map(a => a);
-        field._lookupTableDataProvider = this._lookupTableDataProvider;
-        field._hasLookupExcludeValues = this._hasLookupExcludeValues;
-        field._excludeFilterProperty = this._excludeFilterProperty;
-        field._excludeValueProperty = this._excludeValueProperty;
-        return field;
-    }
-}
-
-export namespace FieldManyToManyEditorDescriptor {
-    export enum TypeEnum {
-        DialogTableMultiselect
-    }
-
-    export enum ActionEnum {
-        Add,
-        Delete
-    }
-}
-
-export class FieldManyEditorDescriptor<T, ET> extends AFieldDescriptor<T, ET> {
-
-    private readonly _modelType: ClassType<T>;
-    private readonly _tableviewDescriptor: TableviewDescriptor<T>;
-    private _fieldType: FieldManyEditorDescriptor.TypeEnum = FieldManyEditorDescriptor.TypeEnum.DialogEditor;
-    private _actions: Array<FieldManyEditorDescriptor.ActionEnum> = [];
-
-    constructor(editor: EditorDescriptor<ET>, property: string, modelType: ClassType<T>, tableviewDescriptor: TableviewDescriptor<T>) {
-        super(editor, property);
-        this._modelType = modelType;
-        this._tableviewDescriptor = tableviewDescriptor;
-        this._actions.push(FieldManyEditorDescriptor.ActionEnum.Add, FieldManyEditorDescriptor.ActionEnum.Edit, FieldManyEditorDescriptor.ActionEnum.Delete);
-    }
-
-    public get tableviewDescriptor() {
-        return this._tableviewDescriptor;
-    }
-
-    public get tableDescriptor() {
-        return this._tableviewDescriptor.table;
-    }
-
-    public get editorForCreate() {
-        return this._tableviewDescriptor.addEditor;
-    }
-
-    public get editorForRead() {
-        return this._tableviewDescriptor.viewEditor;
-    }
-
-    public get editorForUpdate() {
-        return this._tableviewDescriptor.editEditor;
-    }
-
-    public get fieldType() {
-        return this._fieldType;
-    }
-
-    public get actions() {
-        return this._actions;
-    }
-
-    public withActions(actions: Array<FieldManyToManyEditorDescriptor.ActionEnum> = []): this {
-        this.actions.push(...actions);
-        return this;
-    }
-
-    public copy(): FieldManyEditorDescriptor<T, ET> {
-        const field = new FieldManyEditorDescriptor(this._editor, this._property, this._modelType, this._tableviewDescriptor.copy());
-        this.copyFieldsTo(field);
-        field._fieldType = this._fieldType;
-        field._actions = this._actions.map(a => a);
-        return field;
-    }
-}
-
-export namespace FieldManyEditorDescriptor {
-    export enum TypeEnum {
-        DialogEditor
-    }
-
-    export enum ActionEnum {
-        Add,
-        Edit,
-        Delete
-    }
-}
-
-export abstract class AFieldGroupDescriptor<ET> extends AGenericFieldDescriptor<ET> {
-
-    protected readonly _name: string;
-    protected readonly _default: boolean;
-    protected _title?: string;
-    protected _fields: AGenericFieldDescriptor<ET>[] = [];
-    protected _validators: Array<FieldValidator> = [];
-
-    protected constructor(editor: EditorDescriptor<ET>, name: string) {
-        super(editor);
-        this._name = `${this.baseName}${name}`;
-        this._default = name === EditorDescriptor.defaultGroupName;
-    }
-
-    abstract get fields(): AGenericFieldDescriptor<ET>[];
-
-    abstract groupName(): string;
-
-    abstract addField(field: AGenericFieldDescriptor<ET>): this;
-
-    abstract copy(): AFieldGroupDescriptor<ET>;
-
-    public get baseName() {
-        return `${this.groupName()}_`;
-    }
-
-    public get name() {
-        return this._name;
-    }
-
-    public get default() {
-        return this._default;
-    }
-
-    public get title() {
-        return this._title;
-    }
-
-    public get validators() {
-        return this._validators;
-    }
-
-    public withTitle(title: string): this {
-        this._title = title;
-        return this;
-    }
-
-    public withValidator(name: string, expression: (control: AbstractControl) => boolean) {
-        this._validators.push(new FieldValidator(name, expression, undefined));
-        return this;
-    }
-}
-
-export class FieldTabGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {
-
-    constructor(editor: EditorDescriptor<ET>, name: string) {
-        super(editor, name);
-    }
-
-    public get fields(): Array<FieldGroupDescriptor<ET>> {
-        return this._fields as Array<FieldGroupDescriptor<ET>>;
-    }
-
-    public groupName(): string {
-        return 'tab';
-    }
-
-    public addField(field: FieldGroupDescriptor<ET>): this {
-        this._fields.push(field);
-        return this;
-    }
-
-    public copy(): FieldTabGroupDescriptor<ET> {
-        const tab = new FieldTabGroupDescriptor<ET>(this._editor, this.name.substring(this.baseName.length));
-        tab._title = this._title;
-        tab._fields = this.fields.map(f => f.copy());
-        return tab;
-    }
-}
-
-export class FieldGroupDescriptor<ET> extends AFieldGroupDescriptor<ET> {
-
-    constructor(editor: EditorDescriptor<ET>, name: string) {
-        super(editor, name);
-    }
-
-    public get fields(): Array<AFieldDescriptor<any, ET>> {
-        return this._fields as Array<AFieldDescriptor<any, ET>>;
-    }
-
-    public groupName(): string {
-        return 'group';
-    }
-
-    public addField(field: AFieldDescriptor<any, ET>): this {
-        this._fields.push(field);
-        return this;
-    }
-
-    public copy(): FieldGroupDescriptor<ET> {
-        const group = new FieldGroupDescriptor<ET>(this._editor, this.name.substring(this.baseName.length));
-        group._title = this._title;
-        group._fields = this.fields.map(f => f.copy());
-        return group;
-    }
-}