ngx-rs-ant 0.12.4 → 0.12.8

package/esm2020/data-grid/data-grid.factory.mjs

@@ -0,0 +1,396 @@
+import CustomStore from "devextreme/data/custom_store";
+import { lastValueFrom, map, Subject } from "rxjs";
+import { Injectable } from "@angular/core";
+import { DataGridService } from "./data-grid.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DataGridFactory {
+    constructor(http) {
+        this.http = http;
+        this.typeMap = {
+            STRING: {
+                dataType: 'string',
+                filterOperations: ['contains', 'startswith', 'endswith', '=', '<>']
+            },
+            TEXT: {
+                dataType: 'string',
+                filterOperations: ['contains', 'startswith', 'endswith', '=', '<>']
+            },
+            BOOLEAN: {
+                dataType: 'boolean',
+                filterOperations: []
+            },
+            INTEGER: {
+                dataType: 'number',
+                filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between']
+            },
+            DOUBLE: {
+                dataType: 'number',
+                filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between']
+            },
+            DATE: {
+                dataType: 'date',
+                filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between'],
+                format: 'yyyy/MM/dd'
+            },
+            DATETIME: {
+                dataType: 'datetime',
+                filterOperations: ['>', '<', 'between'],
+                format: 'yyyy/MM/dd HH:mm:ss'
+            }
+        };
+        this.service = new DataGridService(http);
+    }
+    makeDataGridColumns(tenant, className, view) {
+        const result = new Subject();
+        this.service.getMetadataByView(tenant, className, view || '').subscribe(response => {
+            const columns = [];
+            for (let field of response.data.columns) {
+                switch (field.type) {
+                    case 'FILE':
+                        columns.push({
+                            dataField: field.name,
+                            caption: field.caption,
+                            dataType: 'string',
+                            alignment: 'center',
+                            cssClass: 'cell-vertical-middle',
+                            allowHeaderFiltering: false,
+                            allowFiltering: false,
+                            allowSorting: false,
+                            cellTemplate: 'fileCellTemplate',
+                            visible: field.visible,
+                            fixed: field.fixed
+                        });
+                        break;
+                    case 'NORMAL':
+                        const column = {
+                            dataField: field.name,
+                            caption: field.caption,
+                            dataType: this.typeMap[field.dataType].dataType,
+                            alignment: 'left',
+                            cssClass: 'cell-vertical-middle',
+                            allowHeaderFiltering: true,
+                            headerFilter: {
+                                allowSelectAll: false
+                            },
+                            filterOperations: this.typeMap[field.dataType].filterOperations,
+                            format: this.typeMap[field.dataType].format,
+                            visible: field.visible,
+                            fixed: field.fixed
+                        };
+                        columns.push(column);
+                        switch (field.dataType) {
+                            case 'BOOLEAN':
+                                column.allowHeaderFiltering = false;
+                                column.alignment = 'center';
+                                column.trueText = '是';
+                                column.falseText = '否';
+                                break;
+                            case 'DATE':
+                            case 'DATETIME':
+                                column.headerFilter.dataSource = (options) => {
+                                    options.dataSource.group.length = 3;
+                                    options.dataSource.postProcess = (data) => {
+                                        data.forEach((year) => {
+                                            year.text = year.key + '年';
+                                            year.items.forEach((month) => {
+                                                month.text = month.key + '月';
+                                                month.items.forEach((day) => {
+                                                    day.text = day.key + '日';
+                                                    day.items = [];
+                                                });
+                                            });
+                                        });
+                                        data.unshift({
+                                            key: '',
+                                            value: null,
+                                            text: '(空白)'
+                                        });
+                                    };
+                                };
+                                break;
+                            case 'DOUBLE':
+                            case 'INTEGER':
+                                column.headerFilter.dataSource = (options) => {
+                                    options.dataSource.postProcess = (data) => {
+                                        data.unshift({
+                                            key: '',
+                                            value: null,
+                                            text: '(空白)'
+                                        });
+                                        data.push({
+                                            key: '__',
+                                            value: '__',
+                                            text: '__',
+                                            visible: false
+                                        });
+                                    };
+                                };
+                                break;
+                            case 'STRING':
+                                column.headerFilter.dataSource = (options) => {
+                                    options.dataSource.postProcess = (data) => {
+                                        data.unshift({
+                                            key: '',
+                                            value: null,
+                                            text: '(空白)'
+                                        });
+                                        data.push({
+                                            key: '__',
+                                            value: '__',
+                                            text: '__',
+                                            visible: false
+                                        });
+                                    };
+                                };
+                                switch (field.config.constraint.type) {
+                                    case 'USER':
+                                        column.headerFilter.dataSource = {
+                                            store: new CustomStore({
+                                                load: () => {
+                                                    return lastValueFrom(this.service.getUserColumnDataSource(tenant, className, view, field.name));
+                                                }
+                                            }),
+                                            paginate: true
+                                        };
+                                        if (field.config.constraint.multiple) {
+                                            column.allowFiltering = false;
+                                            column.lookup = {
+                                                dataSource: {
+                                                    store: new CustomStore({
+                                                        load: () => {
+                                                            return lastValueFrom(this.service.getUserColumnDataSource(tenant, className, view, field.name));
+                                                        }
+                                                    }),
+                                                    paginate: true
+                                                },
+                                                valueExpr: 'value',
+                                                displayExpr: 'text'
+                                            };
+                                            column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+                                                if (this.defaultCalculateFilterExpression) {
+                                                    if (!filterValue) {
+                                                        return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);
+                                                    }
+                                                    return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);
+                                                }
+                                                return '';
+                                            };
+                                            column.cellTemplate = 'multipleValueCellTemplate';
+                                        }
+                                        else {
+                                            column.dataField = '__' + field.name + '\u0001User_displayName';
+                                            column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+                                                if (target === 'headerFilter') {
+                                                    if (this.defaultCalculateFilterExpression) {
+                                                        this.dataField = '__' + field.name + '\u0001User_username';
+                                                        return this.defaultCalculateFilterExpression.apply(this, [filterValue, selectedFilterOperation, target]);
+                                                    }
+                                                }
+                                                return [
+                                                    [column.name, selectedFilterOperation, filterValue],
+                                                    'or',
+                                                    ['__' + field.name + '\u0001User_username', selectedFilterOperation, filterValue]
+                                                ];
+                                            };
+                                        }
+                                        break;
+                                    case 'UNIT':
+                                        column.headerFilter.dataSource = {
+                                            store: new CustomStore({
+                                                load: () => {
+                                                    return lastValueFrom(this.service.getUnitColumnDataSource(tenant, className, view, field.name));
+                                                }
+                                            }),
+                                            paginate: true
+                                        };
+                                        if (field.config.constraint.multiple) {
+                                            column.allowFiltering = false;
+                                            column.lookup = {
+                                                dataSource: {
+                                                    store: new CustomStore({
+                                                        load: () => {
+                                                            return lastValueFrom(this.service.getUnitColumnDataSource(tenant, className, view, field.name));
+                                                        }
+                                                    }),
+                                                    paginate: true
+                                                },
+                                                valueExpr: 'value',
+                                                displayExpr: 'text'
+                                            };
+                                            column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+                                                if (this.defaultCalculateFilterExpression) {
+                                                    if (!filterValue) {
+                                                        return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);
+                                                    }
+                                                    return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);
+                                                }
+                                                return '';
+                                            };
+                                            column.cellTemplate = 'multipleValueCellTemplate';
+                                        }
+                                        else {
+                                            column.dataField = '__' + field.name + '\u0001Unit_displayName';
+                                            column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+                                                if (target === 'headerFilter') {
+                                                    if (this.defaultCalculateFilterExpression) {
+                                                        this.dataField = '__' + field.name + '\u0001Unit_name';
+                                                        return this.defaultCalculateFilterExpression.apply(this, [filterValue, selectedFilterOperation, target]);
+                                                    }
+                                                }
+                                                return [
+                                                    [column.name, selectedFilterOperation, filterValue],
+                                                    'or',
+                                                    ['__' + field.name + '\u0001Unit_name', selectedFilterOperation, filterValue]
+                                                ];
+                                            };
+                                        }
+                                        break;
+                                    case 'CUSTOM':
+                                        column.headerFilter.dataSource = {
+                                            store: new CustomStore({
+                                                load: () => {
+                                                    return lastValueFrom(this.service.getConstraintColumnDataSource(tenant, className, view, field.name, field.config.constraint.name));
+                                                }
+                                            }),
+                                            paginate: true
+                                        };
+                                        column.lookup = {
+                                            dataSource: {
+                                                store: new CustomStore({
+                                                    load: () => {
+                                                        return lastValueFrom(this.service.getConstraintEntries(field.config.constraint.name));
+                                                    }
+                                                }),
+                                                paginate: true
+                                            },
+                                            valueExpr: 'store',
+                                            displayExpr: 'display'
+                                        };
+                                        column.filterOperations = [];
+                                        if (field.config.constraint.multiple) {
+                                            column.calculateFilterExpression = function (filterValue, selectedFilterOperation, target) {
+                                                if (this.defaultCalculateFilterExpression) {
+                                                    if (!filterValue) {
+                                                        return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);
+                                                    }
+                                                    return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);
+                                                }
+                                                return '';
+                                            };
+                                        }
+                                        column.cellTemplate = 'multipleValueCellTemplate';
+                                        break;
+                                    default:
+                                        // column.cellTemplate = 'textCellTemplate';
+                                        break;
+                                }
+                                break;
+                            case 'TEXT':
+                                column.allowHeaderFiltering = false;
+                                column.width = 240;
+                                column.cellTemplate = 'textCellTemplate';
+                                break;
+                        }
+                        break;
+                    case 'RELATION':
+                        switch (field.relationType) {
+                            case 'MANY_TO_MANY':
+                            case 'ONE_TO_MANY':
+                                columns.push({
+                                    dataField: field.name,
+                                    caption: field.caption,
+                                    dataType: 'string',
+                                    alignment: 'left',
+                                    cssClass: 'cell-vertical-middle',
+                                    allowHeaderFiltering: false,
+                                    allowFiltering: false,
+                                    visible: field.visible,
+                                    fixed: field.fixed
+                                });
+                                break;
+                            case 'MANY_TO_ONE':
+                            case 'ONE_TO_ONE':
+                                columns.push({
+                                    dataField: field.name,
+                                    caption: field.caption,
+                                    dataType: 'string',
+                                    alignment: 'left',
+                                    cssClass: 'cell-vertical-middle',
+                                    allowHeaderFiltering: false,
+                                    filterOperations: ['='],
+                                    visible: field.visible,
+                                    fixed: field.fixed
+                                });
+                                break;
+                        }
+                }
+            }
+            result.next(columns);
+        });
+        return result;
+    }
+    makeDataGridDataSource(tenant, className, view, extraFilter) {
+        return new CustomStore({
+            key: 'oid',
+            byKey: (key) => {
+                return lastValueFrom(this.service.getOne(tenant, className, key).pipe(map(response => response.data)));
+            },
+            load: (loadOptions) => {
+                if (loadOptions.dataField) {
+                    // 未重写headerFilter的dataSource时，headerFilter会调用load方法加载筛选树，重写该方法查询该表所有数据
+                    // 该方式存在风险，无法识别一定是通过headerFilter过滤才存在dataField参数
+                    return lastValueFrom(this.service.getColumnDataSource(tenant, className, view, loadOptions.dataField));
+                }
+                let params = '?';
+                if (loadOptions.skip || loadOptions.take) {
+                    params += 'offset=' + loadOptions.skip;
+                    params += '&limit=' + loadOptions.take;
+                }
+                else {
+                    params += 'limit=0';
+                }
+                if (loadOptions.sort) {
+                    let first = true;
+                    for (const thisSort of loadOptions.sort) {
+                        if (first) {
+                            params += '&orderBy=' + thisSort.selector;
+                        }
+                        else {
+                            params += ',' + thisSort.selector;
+                        }
+                        if (thisSort.desc) {
+                            params += ' desc';
+                        }
+                        first = false;
+                    }
+                }
+                let filter;
+                if (loadOptions.filter) {
+                    filter = loadOptions.filter;
+                }
+                if (extraFilter) {
+                    if (filter) {
+                        filter = [filter, 'and', extraFilter];
+                    }
+                    else {
+                        filter = extraFilter;
+                    }
+                }
+                if (filter) {
+                    params += '&filter=' + encodeURIComponent(JSON.stringify(filter));
+                }
+                return lastValueFrom(this.service.getMany(tenant, className, params + '&view=' + (view || '')));
+            }
+        });
+    }
+}
+DataGridFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DataGridFactory, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+DataGridFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DataGridFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DataGridFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-grid.factory.js","sourceRoot":"","sources":["../../../../projects/ngx-rs-ant/src/data-grid/data-grid.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import CustomStore from \"devextreme/data/custom_store\";\r\nimport {lastValueFrom, map, Observable, Subject} from \"rxjs\";\r\nimport {Column} from \"devextreme/ui/data_grid\";\r\nimport {Injectable} from \"@angular/core\";\r\nimport {DataGridService} from \"./data-grid.service\";\r\nimport {HttpClient} from \"@angular/common/http\";\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DataGridFactory {\r\n  constructor(private http: HttpClient) {\r\n    this.service = new DataGridService(http);\r\n  }\r\n\r\n  private service!: DataGridService;\r\n\r\n  private typeMap: any = {\r\n    STRING: {\r\n      dataType: 'string',\r\n      filterOperations: ['contains', 'startswith', 'endswith', '=', '<>']\r\n    },\r\n    TEXT: {\r\n      dataType: 'string',\r\n      filterOperations: ['contains', 'startswith', 'endswith', '=', '<>']\r\n    },\r\n    BOOLEAN: {\r\n      dataType: 'boolean',\r\n      filterOperations: []\r\n    },\r\n    INTEGER: {\r\n      dataType: 'number',\r\n      filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between']\r\n    },\r\n    DOUBLE: {\r\n      dataType: 'number',\r\n      filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between']\r\n    },\r\n    DATE: {\r\n      dataType: 'date',\r\n      filterOperations: ['=', '<>', '>', '>=', '<', '<=', 'between'],\r\n      format: 'yyyy/MM/dd'\r\n    },\r\n    DATETIME: {\r\n      dataType: 'datetime',\r\n      filterOperations: ['>', '<', 'between'],\r\n      format: 'yyyy/MM/dd HH:mm:ss'\r\n    }\r\n  };\r\n\r\n  public makeDataGridColumns(tenant: any, className: any, view: any): Observable<any> {\r\n    const result = new Subject();\r\n    this.service.getMetadataByView(tenant, className, view || '').subscribe(response => {\r\n      const columns = [];\r\n      for (let field of response.data.columns) {\r\n        switch (field.type) {\r\n          case 'FILE':\r\n            columns.push({\r\n              dataField: field.name,\r\n              caption: field.caption,\r\n              dataType: 'string',\r\n              alignment: 'center',\r\n              cssClass: 'cell-vertical-middle',\r\n              allowHeaderFiltering: false,\r\n              allowFiltering: false,\r\n              allowSorting: false,\r\n              cellTemplate: 'fileCellTemplate',\r\n              visible: field.visible,\r\n              fixed: field.fixed\r\n            });\r\n            break;\r\n          case 'NORMAL':\r\n            const column: any = {\r\n              dataField: field.name,\r\n              caption: field.caption,\r\n              dataType: this.typeMap[field.dataType].dataType,\r\n              alignment: 'left',\r\n              cssClass: 'cell-vertical-middle',\r\n              allowHeaderFiltering: true,\r\n              headerFilter: {\r\n                allowSelectAll: false\r\n              },\r\n              filterOperations: this.typeMap[field.dataType].filterOperations,\r\n              format: this.typeMap[field.dataType].format,\r\n              visible: field.visible,\r\n              fixed: field.fixed\r\n            };\r\n            columns.push(column);\r\n            switch (field.dataType) {\r\n              case 'BOOLEAN':\r\n                column.allowHeaderFiltering = false;\r\n                column.alignment = 'center';\r\n                column.trueText = '是';\r\n                column.falseText = '否';\r\n                break;\r\n              case 'DATE':\r\n              case 'DATETIME':\r\n                column.headerFilter.dataSource = (options: any) => {\r\n                  options.dataSource.group.length = 3;\r\n                  options.dataSource.postProcess = (data: any) => {\r\n                    data.forEach((year: any) => {\r\n                      year.text = year.key + '年';\r\n                      year.items.forEach((month: any) => {\r\n                        month.text = month.key + '月';\r\n                        month.items.forEach((day: any) => {\r\n                          day.text = day.key + '日';\r\n                          day.items = [];\r\n                        });\r\n                      });\r\n                    });\r\n                    data.unshift({\r\n                      key: '',\r\n                      value: null,\r\n                      text: '(空白)'\r\n                    });\r\n                  };\r\n                };\r\n                break;\r\n              case 'DOUBLE':\r\n              case 'INTEGER':\r\n                column.headerFilter.dataSource = (options: any) => {\r\n                  options.dataSource.postProcess = (data: any) => {\r\n                    data.unshift({\r\n                      key: '',\r\n                      value: null,\r\n                      text: '(空白)'\r\n                    });\r\n                    data.push({\r\n                      key: '__',\r\n                      value: '__',\r\n                      text: '__',\r\n                      visible: false\r\n                    });\r\n                  };\r\n                };\r\n                break;\r\n              case 'STRING':\r\n                column.headerFilter.dataSource = (options: any) => {\r\n                  options.dataSource.postProcess = (data: any) => {\r\n                    data.unshift({\r\n                      key: '',\r\n                      value: null,\r\n                      text: '(空白)'\r\n                    });\r\n                    data.push({\r\n                      key: '__',\r\n                      value: '__',\r\n                      text: '__',\r\n                      visible: false\r\n                    });\r\n                  };\r\n                };\r\n                switch (field.config.constraint.type) {\r\n                  case 'USER':\r\n                    column.headerFilter.dataSource = {\r\n                      store: new CustomStore({\r\n                        load: () => {\r\n                          return lastValueFrom(this.service.getUserColumnDataSource(tenant, className, view, field.name));\r\n                        }\r\n                      }),\r\n                      paginate: true\r\n                    };\r\n                    if (field.config.constraint.multiple) {\r\n                      column.allowFiltering = false;\r\n                      column.lookup = {\r\n                        dataSource: {\r\n                          store: new CustomStore({\r\n                            load: () => {\r\n                              return lastValueFrom(this.service.getUserColumnDataSource(tenant, className, view, field.name));\r\n                            }\r\n                          }),\r\n                          paginate: true\r\n                        },\r\n                        valueExpr: 'value',\r\n                        displayExpr: 'text'\r\n                      };\r\n                      column.calculateFilterExpression = function (this: Column, filterValue: any, selectedFilterOperation: any, target: string) {\r\n                        if (this.defaultCalculateFilterExpression) {\r\n                          if (!filterValue) {\r\n                            return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);\r\n                          }\r\n                          return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);\r\n                        }\r\n                        return '';\r\n                      };\r\n                      column.cellTemplate = 'multipleValueCellTemplate';\r\n                    } else {\r\n                      column.dataField = '__' + field.name + '\\u0001User_displayName';\r\n                      column.calculateFilterExpression = function (this: any, filterValue: any, selectedFilterOperation: any, target: string) {\r\n                        if (target === 'headerFilter') {\r\n                          if (this.defaultCalculateFilterExpression) {\r\n                            this.dataField = '__' + field.name + '\\u0001User_username';\r\n                            return this.defaultCalculateFilterExpression.apply(this, [filterValue, selectedFilterOperation, target]);\r\n                          }\r\n                        }\r\n                        return [\r\n                          [column.name, selectedFilterOperation, filterValue],\r\n                          'or',\r\n                          ['__' + field.name + '\\u0001User_username', selectedFilterOperation, filterValue]\r\n                        ];\r\n                      };\r\n                    }\r\n                    break;\r\n                  case 'UNIT':\r\n                    column.headerFilter.dataSource = {\r\n                      store: new CustomStore({\r\n                        load: () => {\r\n                          return lastValueFrom(this.service.getUnitColumnDataSource(tenant, className, view, field.name));\r\n                        }\r\n                      }),\r\n                      paginate: true\r\n                    };\r\n                    if (field.config.constraint.multiple) {\r\n                      column.allowFiltering = false;\r\n                      column.lookup = {\r\n                        dataSource: {\r\n                          store: new CustomStore({\r\n                            load: () => {\r\n                              return lastValueFrom(this.service.getUnitColumnDataSource(tenant, className, view, field.name));\r\n                            }\r\n                          }),\r\n                          paginate: true\r\n                        },\r\n                        valueExpr: 'value',\r\n                        displayExpr: 'text'\r\n                      };\r\n                      column.calculateFilterExpression = function (this: Column, filterValue: any, selectedFilterOperation: any, target: string) {\r\n                        if (this.defaultCalculateFilterExpression) {\r\n                          if (!filterValue) {\r\n                            return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);\r\n                          }\r\n                          return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);\r\n                        }\r\n                        return '';\r\n                      };\r\n                      column.cellTemplate = 'multipleValueCellTemplate';\r\n                    } else {\r\n                      column.dataField = '__' + field.name + '\\u0001Unit_displayName';\r\n                      column.calculateFilterExpression = function (this: Column, filterValue: any, selectedFilterOperation: any, target: string) {\r\n                        if (target === 'headerFilter') {\r\n                          if (this.defaultCalculateFilterExpression) {\r\n                            this.dataField = '__' + field.name + '\\u0001Unit_name';\r\n                            return this.defaultCalculateFilterExpression.apply(this, [filterValue, selectedFilterOperation, target]);\r\n                          }\r\n                        }\r\n                        return [\r\n                          [column.name, selectedFilterOperation, filterValue],\r\n                          'or',\r\n                          ['__' + field.name + '\\u0001Unit_name', selectedFilterOperation, filterValue]\r\n                        ];\r\n                      };\r\n                    }\r\n                    break;\r\n                  case 'CUSTOM':\r\n                    column.headerFilter.dataSource = {\r\n                      store: new CustomStore({\r\n                        load: () => {\r\n                          return lastValueFrom(this.service.getConstraintColumnDataSource(tenant, className, view, field.name, field.config.constraint.name));\r\n                        }\r\n                      }),\r\n                      paginate: true\r\n                    };\r\n                    column.lookup = {\r\n                      dataSource: {\r\n                        store: new CustomStore({\r\n                          load: () => {\r\n                            return lastValueFrom(this.service.getConstraintEntries(field.config.constraint.name));\r\n                          }\r\n                        }),\r\n                        paginate: true\r\n                      },\r\n                      valueExpr: 'store',\r\n                      displayExpr: 'display'\r\n                    };\r\n                    column.filterOperations = [];\r\n                    if (field.config.constraint.multiple) {\r\n                      column.calculateFilterExpression = function (this: Column, filterValue: any, selectedFilterOperation: any, target: string) {\r\n                        if (this.defaultCalculateFilterExpression) {\r\n                          if (!filterValue) {\r\n                            return this.defaultCalculateFilterExpression.apply(this, [filterValue, '=', target]);\r\n                          }\r\n                          return this.defaultCalculateFilterExpression.apply(this, [filterValue, 'contains', target]);\r\n                        }\r\n                        return '';\r\n                      };\r\n                    }\r\n                    column.cellTemplate = 'multipleValueCellTemplate';\r\n                    break;\r\n                  default:\r\n                    // column.cellTemplate = 'textCellTemplate';\r\n                    break;\r\n                }\r\n                break;\r\n              case 'TEXT':\r\n                column.allowHeaderFiltering = false;\r\n                column.width = 240;\r\n                column.cellTemplate = 'textCellTemplate';\r\n                break;\r\n            }\r\n            break;\r\n          case 'RELATION':\r\n            switch (field.relationType) {\r\n              case 'MANY_TO_MANY':\r\n              case 'ONE_TO_MANY':\r\n                columns.push({\r\n                  dataField: field.name,\r\n                  caption: field.caption,\r\n                  dataType: 'string',\r\n                  alignment: 'left',\r\n                  cssClass: 'cell-vertical-middle',\r\n                  allowHeaderFiltering: false,\r\n                  allowFiltering: false,\r\n                  visible: field.visible,\r\n                  fixed: field.fixed\r\n                });\r\n                break;\r\n              case 'MANY_TO_ONE':\r\n              case 'ONE_TO_ONE':\r\n                columns.push({\r\n                  dataField: field.name,\r\n                  caption: field.caption,\r\n                  dataType: 'string',\r\n                  alignment: 'left',\r\n                  cssClass: 'cell-vertical-middle',\r\n                  allowHeaderFiltering: false,\r\n                  filterOperations: ['='],\r\n                  visible: field.visible,\r\n                  fixed: field.fixed\r\n                });\r\n                break;\r\n            }\r\n        }\r\n      }\r\n      result.next(columns);\r\n    });\r\n    return result;\r\n  }\r\n\r\n  public makeDataGridDataSource(tenant: any, className: any, view: any, extraFilter: any): CustomStore {\r\n    return new CustomStore({\r\n      key: 'oid',\r\n      byKey: (key: any) => {\r\n        return lastValueFrom(this.service.getOne(tenant, className, key).pipe(map(response => response.data)));\r\n      },\r\n      load: (loadOptions: any) => {\r\n        if (loadOptions.dataField) {\r\n          // 未重写headerFilter的dataSource时，headerFilter会调用load方法加载筛选树，重写该方法查询该表所有数据\r\n          // 该方式存在风险，无法识别一定是通过headerFilter过滤才存在dataField参数\r\n          return lastValueFrom(this.service.getColumnDataSource(tenant, className, view, loadOptions.dataField));\r\n        }\r\n        let params = '?';\r\n        if (loadOptions.skip || loadOptions.take) {\r\n          params += 'offset=' + loadOptions.skip;\r\n          params += '&limit=' + loadOptions.take;\r\n        } else {\r\n          params += 'limit=0';\r\n        }\r\n        if (loadOptions.sort) {\r\n          let first = true;\r\n          for (const thisSort of loadOptions.sort) {\r\n            if (first) {\r\n              params += '&orderBy=' + thisSort.selector;\r\n            } else {\r\n              params += ',' + thisSort.selector;\r\n            }\r\n            if (thisSort.desc) {\r\n              params += ' desc';\r\n            }\r\n            first = false;\r\n          }\r\n        }\r\n        let filter;\r\n        if (loadOptions.filter) {\r\n          filter = loadOptions.filter;\r\n        }\r\n        if (extraFilter) {\r\n          if (filter) {\r\n            filter = [filter, 'and', extraFilter];\r\n          } else {\r\n            filter = extraFilter;\r\n          }\r\n        }\r\n        if (filter) {\r\n          params += '&filter=' + encodeURIComponent(JSON.stringify(filter));\r\n        }\r\n        return lastValueFrom(this.service.getMany(tenant, className, params + '&view=' + (view || '')));\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/data-grid/data-grid.module.mjs

@@ -38,4 +38,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic-params/dynamic-params.component.mjs

@@ -12,11 +12,13 @@ export class DynamicParamsComponent {
     }
 }
 DynamicParamsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-DynamicParamsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DynamicParamsComponent, selector: "rs-dynamic-params", inputs: { params: "params" }, ngImport: i0, template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>\u52A8\u6001\u53C2\u6570</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i2.DxButtonComponent, selector: "dx-button", inputs: ["accessKey", "activeStateEnabled", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "icon", "rtlEnabled", "stylingMode", "tabIndex", "template", "text", "type", "useSubmitBehavior", "validationGroup", "visible", "width"], outputs: ["onClick", "onContentReady", "onDisposing", "onInitialized", "onOptionChanged", "accessKeyChange", "activeStateEnabledChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "iconChange", "rtlEnabledChange", "stylingModeChange", "tabIndexChange", "templateChange", "textChange", "typeChange", "useSubmitBehaviorChange", "validationGroupChange", "visibleChange", "widthChange"] }, { kind: "component", type: i3.DxTextBoxComponent, selector: "dx-text-box", inputs: ["accessKey", "activeStateEnabled", "buttons", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "label", "labelMode", "mask", "maskChar", "maskInvalidMessage", "maskRules", "maxLength", "mode", "name", "placeholder", "readOnly", "rtlEnabled", "showClearButton", "showMaskMode", "spellcheck", "stylingMode", "tabIndex", "text", "useMaskedValue", "validationError", "validationErrors", "validationMessageMode", "validationMessagePosition", "validationStatus", "value", "valueChangeEvent", "visible", "width"], outputs: ["onChange", "onContentReady", "onCopy", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onKeyDown", "onKeyUp", "onOptionChanged", "onPaste", "onValueChanged", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "labelChange", "labelModeChange", "maskChange", "maskCharChange", "maskInvalidMessageChange", "maskRulesChange", "maxLengthChange", "modeChange", "nameChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "showClearButtonChange", "showMaskModeChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useMaskedValueChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationMessagePositionChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "visibleChange", "widthChange", "onBlur"] }] });
+DynamicParamsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: DynamicParamsComponent, selector: "rs-dynamic-params", inputs: { label: "label", params: "params" }, ngImport: i0, template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{label || '\u52A8\u6001\u53C2\u6570'}}</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i2.DxButtonComponent, selector: "dx-button", inputs: ["accessKey", "activeStateEnabled", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "icon", "rtlEnabled", "stylingMode", "tabIndex", "template", "text", "type", "useSubmitBehavior", "validationGroup", "visible", "width"], outputs: ["onClick", "onContentReady", "onDisposing", "onInitialized", "onOptionChanged", "accessKeyChange", "activeStateEnabledChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "iconChange", "rtlEnabledChange", "stylingModeChange", "tabIndexChange", "templateChange", "textChange", "typeChange", "useSubmitBehaviorChange", "validationGroupChange", "visibleChange", "widthChange"] }, { kind: "component", type: i3.DxTextBoxComponent, selector: "dx-text-box", inputs: ["accessKey", "activeStateEnabled", "buttons", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "label", "labelMode", "mask", "maskChar", "maskInvalidMessage", "maskRules", "maxLength", "mode", "name", "placeholder", "readOnly", "rtlEnabled", "showClearButton", "showMaskMode", "spellcheck", "stylingMode", "tabIndex", "text", "useMaskedValue", "validationError", "validationErrors", "validationMessageMode", "validationMessagePosition", "validationStatus", "value", "valueChangeEvent", "visible", "width"], outputs: ["onChange", "onContentReady", "onCopy", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onKeyDown", "onKeyUp", "onOptionChanged", "onPaste", "onValueChanged", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "labelChange", "labelModeChange", "maskChange", "maskCharChange", "maskInvalidMessageChange", "maskRulesChange", "maxLengthChange", "modeChange", "nameChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "showClearButtonChange", "showMaskModeChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useMaskedValueChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationMessagePositionChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "visibleChange", "widthChange", "onBlur"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DynamicParamsComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'rs-dynamic-params', template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>\u52A8\u6001\u53C2\u6570</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"] }]
-        }], propDecorators: { params: [{
+            args: [{ selector: 'rs-dynamic-params', template: "<div class=\"dx-field\">\n  <div class=\"dx-field-label\">\n    <span>{{label || '\u52A8\u6001\u53C2\u6570'}}</span>\n    <dx-button type=\"default\" stylingMode=\"text\" icon=\"coast-icon coast-icon-add\" (onClick)=\"add()\"></dx-button>\n  </div>\n  <div class=\"dx-field-value\">\n    <div *ngFor=\"let param of params; let index = index\">\n      <dx-text-box placeholder=\"\u53C2\u6570\u540D\" [(value)]=\"param.name\"></dx-text-box>\n      <dx-text-box placeholder=\"\u53C2\u6570\u503C\" [(value)]=\"param.value\"></dx-text-box>\n      <dx-button type=\"danger\" stylingMode=\"text\" icon=\"coast-icon coast-icon-close\"\n                 (onClick)=\"delete(index)\"></dx-button>\n    </div>\n  </div>\n</div>\n", styles: [":host .dx-field .dx-field-label{display:flex;align-items:center}:host .dx-field .dx-field-value div{display:flex;flex-flow:row nowrap}:host .dx-field .dx-field-value div dx-text-box{flex:1}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], params: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/form/form.component.mjs

@@ -50,7 +50,6 @@ export class FormComponent {
             this.submitCallback.emit({ success: false });
             // @ts-ignore
             result.brokenRules[0].validator.element().scrollIntoView();
-            console.log(result);
             return false;
         }
         return true;
@@ -83,4 +82,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
             }], submitCallback: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -1,12 +1,10 @@
-/*
- * Public API Surface of ngx-rs-ant
- */
 export * from './box-container/box-item/item-config/item-config.component';
 export * from './box-container/box-item/item-style/item-style.component';
 export * from './box-container/box-container.component';
 export * from './box-container/box-container.module';
 export * from './box-container/PluginManager';
 export * from './data-grid/data-grid.component';
+export * from './data-grid/data-grid.factory';
 export * from './data-grid/master-detail-template.directive';
 export * from './data-grid/row-buttons-template.directive';
 export * from './data-grid/data-grid.module';
@@ -22,4 +20,4 @@ export * from './modal/modal.component';
 export * from './modal/modal.module';
 export * from './modal/modal.service';
 export * from './notify/notify';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1ycy1hbnQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDREQUE0RCxDQUFDO0FBQzNFLGNBQWMsMERBQTBELENBQUM7QUFDekUsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhDQUE4QyxDQUFDO0FBQzdELGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LXJzLWFudFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vYm94LWNvbnRhaW5lci9ib3gtaXRlbS9pdGVtLWNvbmZpZy9pdGVtLWNvbmZpZy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9ib3gtY29udGFpbmVyL2JveC1pdGVtL2l0ZW0tc3R5bGUvaXRlbS1zdHlsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9ib3gtY29udGFpbmVyL2JveC1jb250YWluZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm94LWNvbnRhaW5lci9ib3gtY29udGFpbmVyLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2JveC1jb250YWluZXIvUGx1Z2luTWFuYWdlcic7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtZ3JpZC9kYXRhLWdyaWQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1ncmlkL21hc3Rlci1kZXRhaWwtdGVtcGxhdGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1ncmlkL3Jvdy1idXR0b25zLXRlbXBsYXRlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtZ3JpZC9kYXRhLWdyaWQubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1ncmlkL2RhdGEtZ3JpZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHluYW1pYy1wYXJhbXMvZHluYW1pYy1wYXJhbXMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS9mb3JtLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0vZm9ybS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtL2Zvcm0uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2ljb24tc2VsZWN0b3IvaWNvbi1zZWxlY3Rvci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pY29uLXNlbGVjdG9yL2ljb24tc2VsZWN0b3IubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvbW9kYWwuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvbW9kYWwubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvbW9kYWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL25vdGlmeS9ub3RpZnknO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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