@mediusinc/mng-commons 0.0.1-rc.3 → 0.2.1-rc

package/src/lib/descriptors/field.validator.ts

@@ -0,0 +1,35 @@
+import {AbstractControl} from '@angular/forms';
+import {FormlyFieldConfig} from '@ngx-formly/core';
+
+import {Observable} from 'rxjs';
+
+export class FieldValidator {
+    private readonly _name: string;
+    private readonly _expression?: (control: AbstractControl) => boolean;
+    private readonly _message?: (err: any, field: FormlyFieldConfig) => string | Observable<string>;
+    private readonly _options?: { errorPath: string };
+
+    constructor(name: string, expression?: (control: AbstractControl) => boolean,
+                message?: (err: any, field: FormlyFieldConfig) => string | Observable<string>, options?: { errorPath: string }) {
+        this._name = name;
+        this._expression = expression;
+        this._message = message;
+        this._options = options;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public get expression() {
+        return this._expression;
+    }
+
+    public get message() {
+        return this._message;
+    }
+
+    public get options() {
+        return this._options;
+    }
+}

package/src/lib/descriptors/index.ts

@@ -0,0 +1,7 @@
+export * from './action.descriptor';
+export * from './editor.descriptor';
+export * from './field.validator';
+export * from './lookup.descriptor';
+export * from './model.descriptor';
+export * from './table.descriptor';
+export * from './tableview.descriptor';

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

@@ -0,0 +1,20 @@
+import {Type} from '@angular/core';
+
+import {Observable} from 'rxjs';
+
+import {ILookupDataProvider} from '../data-providers';
+import {ClassType} from '../types';
+import {MediusQueryParam} from '../api/models';
+
+export interface ILookupDescriptor<T> {
+    modelType: ClassType<T>|null;
+    itemsLabelProperty?: string;
+    itemsValueProperty?: string;
+    dataKeyProperty?: string;
+    dataProvider?: ILookupDataProvider<T, any>;
+    withItemsLabelProperty(itemsLabelProperty: string): this;
+    withItemsValueProperty(itemsLabelProperty: string): this;
+    withDataKeyProperty(dataKeyProperty: string): this;
+    withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this;
+    withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
+}

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

@@ -0,0 +1,47 @@
+import {ClassType} from '../types';
+import {ModelUtil, TypeUtil} from '../utils';
+
+export class ModelDescriptor<T> {
+    private readonly _type: ClassType<T>;
+    private readonly _typeName: string;
+    private _idPropertyName?: string;
+    private _titlePropertyName?: string;
+
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string) {
+        this._type = modelType;
+        this._idPropertyName = idProperty ?? (ModelUtil.findIdAttribute(modelType) ?? undefined);
+        this._titlePropertyName = titleProperty ?? (ModelUtil.findTitleAttribute(modelType) ?? undefined);
+        this._typeName = TypeUtil.findTypeName(this._type);
+    }
+
+    public get type() {
+        return this._type;
+    }
+
+    public get typeName() {
+        return this._typeName;
+    }
+
+    public get idPropertyName() {
+        return this._idPropertyName;
+    }
+
+    public get titlePropertyName() {
+        return this._titlePropertyName;
+    }
+
+    public withIdPropertyName(idProperty: string): this {
+        this._idPropertyName = idProperty;
+        return this;
+    }
+
+    public withTitlePropertyName(titleProperty: string): this {
+        this._titlePropertyName = titleProperty;
+        return this;
+    }
+
+    public copy(): ModelDescriptor<T> {
+        const model = new ModelDescriptor(this._type, this._idPropertyName, this._titlePropertyName);
+        return model;
+    }
+}

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

@@ -0,0 +1,514 @@
+import {Type} from '@angular/core';
+
+import {Observable} from 'rxjs';
+
+import {ModelDescriptor} from './model.descriptor';
+import {ILookupDescriptor} from './lookup.descriptor';
+import {ClassType} from '../types';
+import {ILookupDataProvider, LookupDataProvider} from '../data-providers';
+import {ModelUtil} from '../utils';
+import {MediusQueryParam} from '../api/models';
+
+export class TableDescriptor<T> {
+
+    private readonly _model: ModelDescriptor<T>;
+    private _filterDisplay: TableDescriptor.FilterDisplayEnum = TableDescriptor.FilterDisplayEnum.Menu;
+    private _paginationMode: TableDescriptor.PaginationModeEnum = TableDescriptor.PaginationModeEnum.Pagination;
+    private _columns: Array<ColumnDescriptor<any, T>> = [];
+    private _title?: string;
+    private _dataKeyProperty?: string;
+    private _hasDefaultSort: boolean = false;
+    private _defaultSortProperty: string[] = [];
+    private _defaultSortAsc: boolean[] = [];
+
+    private _rowHeight: number = 45;
+    private _tableFullHeightOffset: number = 315;
+
+    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string) {
+        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty);
+    }
+
+    public get model() {
+        return this._model;
+    }
+
+    public get filterDisplay() {
+        return this._filterDisplay;
+    }
+
+    public get paginationMode() {
+        return this._paginationMode;
+    }
+
+    public get columns() {
+        return this._columns;
+    }
+
+    public get title() {
+        return this._title;
+    }
+
+    public get dataKeyProperty() {
+        return this._dataKeyProperty;
+    }
+
+    public get hasDefaultSort() {
+        return this._hasDefaultSort;
+    }
+
+    public get defaultSortProperty() {
+        return this._defaultSortProperty;
+    }
+
+    public get defaultSortAsc() {
+        return this._defaultSortAsc;
+    }
+
+    public get rowHeight() {
+        return this._rowHeight;
+    }
+
+    public get tableFullHeightOffset() {
+        return this._tableFullHeightOffset;
+    }
+
+    public addColumnDescriptor<CT>(column: ColumnDescriptor<CT, T>): TableDescriptor<T> {
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return this;
+    }
+
+    public addColumn(property: string): ColumnDescriptor<string, T> {
+        const column = new ColumnDescriptor<string, T>(this, property);
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return column;
+    }
+
+    public addColumnNumber(property: string, displayFormat?: string): ColumnDescriptor<number, T> {
+        const column = new ColumnDescriptor<number, T>(this, property);
+        column.asNumber(displayFormat);
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return column;
+    }
+
+    public addColumnDate(property: string, displayFormat?: string): ColumnDescriptor<Date, T> {
+        const column = new ColumnDescriptor<Date, T>(this, property);
+        column.asDate(displayFormat);
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return column;
+    }
+
+    public addColumnBoolean(property: string): ColumnDescriptor<boolean, T> {
+        const column = new ColumnDescriptor<boolean, T>(this, property);
+        column.asBoolean();
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return column;
+    }
+
+    public addColumnObject<CT>(property: string, modelType: ClassType<CT>, displayProperty: string): ColumnDescriptor<CT, T> {
+        const column = new ColumnDescriptor<CT, T>(this, property);
+        column.withModelType(modelType);
+        column.withDisplayPropertyPath(displayProperty);
+        this._columns.push(column);
+        this.setDataKeyFromColumn();
+        return column;
+    }
+
+    public withFilterDisplay(filterDisplayType: TableDescriptor.FilterDisplayEnum): this {
+        this._filterDisplay = filterDisplayType;
+        return this;
+    }
+
+    public withPaginationMode(paginationMode: TableDescriptor.PaginationModeEnum): this {
+        this._paginationMode = paginationMode;
+        return this;
+    }
+
+    public withTitle(title: string): TableDescriptor<T> {
+        this._title = title;
+        return this;
+    }
+
+    public withDataKeyProperty(property: string): TableDescriptor<T> {
+        this._dataKeyProperty = property;
+        return this;
+    }
+
+    public withDefaultSort(property: string, asc: boolean = true): TableDescriptor<T> {
+        this._hasDefaultSort = true;
+        this._defaultSortProperty.push(property);
+        this._defaultSortAsc.push(asc);
+        return this;
+    }
+
+    public withRowHeight(rowHeight: number): TableDescriptor<T> {
+        this._rowHeight = rowHeight;
+        return this;
+    }
+
+    public withTableFullHeightOffset(tableFullHeightOffset: number): TableDescriptor<T> {
+        this._tableFullHeightOffset = tableFullHeightOffset;
+        return this;
+    }
+
+    private setDataKeyFromColumn() {
+        if (!this._dataKeyProperty && this._columns.length === 1) {
+            this._dataKeyProperty = this._columns[0].property;
+        }
+    }
+
+    public copy(): TableDescriptor<T> {
+        const descriptor = new TableDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
+        descriptor._columns = this.columns.map(c => c.copy());
+        descriptor._title = this._title;
+        descriptor._dataKeyProperty = this._dataKeyProperty;
+        descriptor._defaultSortProperty = this._defaultSortProperty.map(p => p);
+        descriptor._defaultSortAsc = this._defaultSortAsc.map(p => p);
+        descriptor._filterDisplay = this._filterDisplay;
+        return descriptor;
+    }
+}
+
+export namespace TableDescriptor {
+    export enum PaginationModeEnum {
+        Pagination,
+        InfiniteScroll
+    }
+
+    export enum FilterDisplayEnum {
+        Row,
+        Menu
+    }
+}
+
+export class ColumnDescriptor<T, TT> {
+
+    private readonly _table: TableDescriptor<TT>;
+    private readonly _property: string;
+    private _modelType: ClassType<T>|null = null;
+    private _columnType: ColumnDescriptor.TypeEnum = ColumnDescriptor.TypeEnum.String;
+    private _title?: string;
+    private _displayPropertyPath?: string;
+    private _isSortEnabled: boolean = false;
+    private _filterDescriptor?: FilterDescriptor<T>;
+    private _displayFormat?: string;
+
+    constructor(table: TableDescriptor<TT>, property: string) {
+        this._table = table;
+        this._property = property;
+    }
+
+    public get table() {
+        return this._table;
+    }
+
+    public get property() {
+        return this._property;
+    }
+
+    public get modelType() {
+        return this._modelType;
+    }
+
+    public get displayPropertyPath() {
+        return this._displayPropertyPath;
+    }
+
+    public get title() {
+        return this._title;
+    }
+
+    public get isSortEnabled() {
+        return this._isSortEnabled;
+    }
+
+    public get columnType() {
+        return this._columnType;
+    }
+
+    public get filterDescriptor() {
+        return this._filterDescriptor;
+    }
+
+    public get displayFormat() {
+        return this._displayFormat;
+    }
+
+    public asType(type: ColumnDescriptor.TypeEnum = ColumnDescriptor.TypeEnum.String): this {
+        this._columnType = type;
+        return this;
+    }
+
+    public asNumber(displayFormat: string = '1.0-0'): this {
+        this._columnType = ColumnDescriptor.TypeEnum.Number;
+        this._displayFormat = displayFormat;
+        return this;
+    }
+
+    public asDate(displayFormat: string = 'dd.MM.yyyy'): this {
+        this._columnType = ColumnDescriptor.TypeEnum.Date;
+        this._displayFormat = displayFormat;
+        return this;
+    }
+
+    public asBoolean(): this {
+        this._columnType = ColumnDescriptor.TypeEnum.Boolean;
+        return this;
+    }
+
+    public withModelType(modelType: ClassType<T>): this {
+        this._modelType = modelType;
+        return this;
+    }
+
+    public withTitle(title: string): this {
+        this._title = title;
+        return this;
+    }
+
+    public withDisplayPropertyPath(displayPropertyPath: string): this {
+        this._displayPropertyPath = displayPropertyPath;
+        return this;
+    }
+
+    public withFilter(): FilterDescriptor<T> {
+        this._filterDescriptor = new FilterDescriptor<any>(this._property);
+        this._filterDescriptor.asFilterType(this._columnType);
+        return this._filterDescriptor;
+    }
+
+    public withFilterLookup(): FilterLookupDescriptor<T> {
+        const filterDescriptor = new FilterLookupDescriptor<any>(this._property, this._modelType);
+        this._filterDescriptor = filterDescriptor;
+        return filterDescriptor;
+    }
+
+    public withSort(isEnabled: boolean = true): this {
+        this._isSortEnabled = isEnabled;
+        return this;
+    }
+
+    public copy(): ColumnDescriptor<T, TT> {
+        const descriptor = new ColumnDescriptor<T, TT>(this._table, this._property);
+        descriptor._displayPropertyPath = this._displayPropertyPath;
+        descriptor._title = this._title;
+        descriptor._isSortEnabled = this._isSortEnabled;
+        descriptor._columnType = this._columnType;
+        descriptor._filterDescriptor = this._filterDescriptor?.copy();
+        return descriptor;
+    }
+}
+
+export namespace ColumnDescriptor {
+    export enum TypeEnum {
+        String,
+        Number,
+        Boolean,
+        Date
+    }
+}
+
+export class FilterDescriptor<T> {
+
+    protected readonly _property: string;
+    protected _filterType = FilterDescriptor.TypeEnum.String;
+    protected _filterProperty?: string;
+
+    protected _placeholder?: string;
+    protected _className: string = '';
+
+    constructor(property: string) {
+        this._property = property;
+    }
+
+    public get property() {
+        return this._property;
+    }
+
+    public get filterType() {
+        return this._filterType;
+    }
+
+    public get filterProperty() {
+        return this._filterProperty;
+    }
+
+    public get placeholder() {
+        return this._placeholder;
+    }
+
+    public get className() {
+        return this._className;
+    }
+
+    public asFilterType(filterType: ColumnDescriptor.TypeEnum) {
+        this._filterType = filterType;
+        return this;
+    }
+
+    /**
+     * Sets different filter property name instead of default property. Use this if API requires different property provided to perform correct filter.
+     * @param filterProperty
+     */
+    public withFilterProperty(filterProperty: string): this {
+        this._filterProperty = filterProperty;
+        return this;
+    }
+
+    public withPlaceholder(placeholder: string): this {
+        this._placeholder = placeholder;
+        return this;
+    }
+
+    public withClassName(className: string): this {
+        this._className = className;
+        return this;
+    }
+
+    protected copyFieldsTo(descriptor: FilterDescriptor<T>) {
+        descriptor._filterType = this._filterType;
+        descriptor._filterProperty = this._filterProperty;
+        descriptor._placeholder = this._placeholder;
+        descriptor._className = this._className;
+    }
+
+    public copy(): FilterDescriptor<T> {
+        const descriptor = new FilterDescriptor<T>(this._property);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+}
+
+export namespace FilterDescriptor {
+    export enum TypeEnum {
+        String,
+        Number,
+        Boolean,
+        Date,
+        Lookup
+    }
+}
+
+export class FilterLookupDescriptor<T> extends FilterDescriptor<T> implements ILookupDescriptor<T> {
+
+    private readonly _modelType: ClassType<T>|null = null;
+    private _lookupType?: FilterLookupDescriptor.LookupTypeEnum = FilterLookupDescriptor.LookupTypeEnum.Dropdown;
+
+    private _dataProvider?: ILookupDataProvider<T, any>;
+    private _itemsLabelProperty?: string;
+    private _itemsValueProperty?: string;
+    private _dataKeyProperty? : string;
+
+    private _multiselect: boolean = false;
+    protected _dropdownClassName: string = 'mng-filter-lookup-dropdown';
+
+    constructor(property: string, modelType: ClassType<T>|null) {
+        super(property);
+        this._modelType = modelType;
+        this._filterType = FilterDescriptor.TypeEnum.Lookup;
+        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 get multiselect() {
+        return this._multiselect;
+    }
+
+    public withItemsLabelProperty(itemsLabelProperty: string): this {
+        this._itemsLabelProperty = itemsLabelProperty;
+        return this;
+    }
+
+    public withItemsValueProperty(itemsValueProperty: string): this {
+        this._itemsValueProperty = itemsValueProperty;
+        return this;
+    }
+
+    public withDataKeyProperty(dataKeyProperty: string): this {
+        this._dataKeyProperty = dataKeyProperty;
+        return this;
+    }
+
+    public get dropdownClassName() {
+        return this._dropdownClassName;
+    }
+
+    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 withMultiselect(multiselect = true) {
+        this._multiselect = multiselect;
+        return this;
+    }
+
+    public withDropdownClassName(dropdownClassName: string): this {
+        this._dropdownClassName = dropdownClassName;
+        return this;
+    }
+
+    public asAutocomplete(): this {
+        this._lookupType = FilterLookupDescriptor.LookupTypeEnum.Autocomplete;
+        return this;
+    }
+
+    protected override copyFieldsTo(descriptor: FilterLookupDescriptor<T>) {
+        super.copyFieldsTo(descriptor);
+        descriptor._dataProvider = this._dataProvider;
+        descriptor._lookupType = this._lookupType;
+        descriptor._itemsLabelProperty = this._itemsLabelProperty;
+        descriptor._itemsValueProperty = this._itemsValueProperty;
+        descriptor._dataKeyProperty = this._dataKeyProperty;
+    }
+
+    public override copy(): FilterLookupDescriptor<T> {
+        const descriptor = new FilterLookupDescriptor<T>(this._property, this._modelType);
+        this.copyFieldsTo(descriptor);
+        return descriptor;
+    }
+}
+
+export namespace FilterLookupDescriptor {
+    export enum LookupTypeEnum {
+        Dropdown,
+        Autocomplete
+    }
+}