@ctzy-web-client/data-model 1.0.6 → 1.0.7

package/es/abstract/where/SingleCondition.mjs

@@ -0,0 +1,22 @@
+import { Condition } from './Condition.mjs';
+
+class SingleCondition extends Condition {
+  constructor(f, o, v) {
+    super();
+    this.f = "";
+    this.o = "=";
+    this.v = "";
+    this.f = f;
+    this.v = v;
+    this.o = o;
+  }
+  toJSON() {
+    return {
+      f: this.f,
+      o: this.o,
+      v: this.v
+    };
+  }
+}
+
+export { SingleCondition };

package/es/abstract/where/Where.mjs

@@ -0,0 +1,21 @@
+import { CombineCondition } from './CombineCondition.mjs';
+import { SingleCondition } from './SingleCondition.mjs';
+
+class Where extends CombineCondition {
+  getCondition(fieldName) {
+    let conditions = this.conditions.slice();
+    for (let i = 0; i < conditions.length; i++) {
+      const condition = conditions[i];
+      if (condition instanceof CombineCondition) {
+        conditions = conditions.concat(condition.conditions);
+      } else if (condition instanceof SingleCondition) {
+        if (condition.f === fieldName) {
+          return condition;
+        }
+      }
+    }
+    return null;
+  }
+}
+
+export { Where };

package/es/decorator/constant.mjs

@@ -0,0 +1,11 @@
+const DATA_MODEL_DEFINE = {
+  table: Symbol("DATA TABLE DEFINE"),
+  form: Symbol("DATA FORM DEFINE")
+};
+const DATA_TABLE = "DATA_TABLE";
+const DATA_FORM = "DATA_FORM";
+const DATA_TABLE_COLUMNS = "DATA_TABLE_COLUMNS";
+const DATA_TABLE_FILTER_COLUMN = "DATA_TABLE_FILTER_COLUMN";
+const DATA_FORM_COLUMNS = "DATA_FORM_COLUMNS";
+
+export { DATA_FORM, DATA_FORM_COLUMNS, DATA_MODEL_DEFINE, DATA_TABLE, DATA_TABLE_COLUMNS, DATA_TABLE_FILTER_COLUMN };

package/es/decorator/dataForm.mjs

@@ -0,0 +1,18 @@
+import { DATA_FORM } from './constant.mjs';
+import '../abstract/DataForm.mjs';
+
+function dataForm(option) {
+  return function decorator(classType) {
+    if (classType.constructor !== Function) {
+      throw new Error(`@dataForm \u53EA\u80FD\u7528\u4E8E\u7C7B\u7684\u6CE8\u89E3`);
+    }
+    let dataForm2 = classType[DATA_FORM];
+    if (dataForm2) {
+      return;
+    }
+    dataForm2 = classType[DATA_FORM] = option;
+    return classType;
+  };
+}
+
+export { dataForm as default };

package/es/decorator/dataTable.mjs

@@ -0,0 +1,18 @@
+import { DATA_MODEL_DEFINE, DATA_TABLE } from './constant.mjs';
+import '../abstract/DataTable.mjs';
+
+function dataTable(option) {
+  return function decorator(classType) {
+    if (classType.constructor !== Function) {
+      throw new Error(`@dataTable \u53EA\u80FD\u7528\u4E8E\u7C7B\u7684\u6CE8\u89E3`);
+    }
+    let dataTable2 = classType[DATA_MODEL_DEFINE.table];
+    if (dataTable2) {
+      return;
+    }
+    classType[DATA_TABLE] = option;
+    return classType;
+  };
+}
+
+export { dataTable as default };

package/es/decorator/filterColumn.mjs

@@ -0,0 +1,21 @@
+import { DATA_TABLE_FILTER_COLUMN } from './constant.mjs';
+
+function filterColumn(options) {
+  return function(target, key, description) {
+    if (arguments.length !== 3 || target.constructor === Function || typeof description.value === "function") {
+      throw new Error(`@formColumn \u53EA\u80FD\u4F7F\u7528\u5728\u7C7B\u7684\u6210\u5458\u53D8\u91CF\u4E2D`);
+    }
+    target.constructor[DATA_TABLE_FILTER_COLUMN] = target.constructor[DATA_TABLE_FILTER_COLUMN] || [];
+    const columns = target.constructor[DATA_TABLE_FILTER_COLUMN];
+    options = {
+      name: key,
+      attrName: key,
+      closable: false,
+      ...options
+    };
+    options.visible = !options.closable;
+    columns.push(options);
+  };
+}
+
+export { filterColumn as default };

package/es/decorator/formColumn.mjs

@@ -0,0 +1,19 @@
+import { DATA_FORM_COLUMNS } from './constant.mjs';
+
+function formColumn(option) {
+  return function(target, key, description) {
+    if (arguments.length !== 3 || target.constructor === Function || typeof description.value === "function") {
+      throw new Error(`@formColumn \u53EA\u80FD\u4F7F\u7528\u5728\u7C7B\u7684\u6210\u5458\u53D8\u91CF\u4E2D`);
+    }
+    target.constructor[DATA_FORM_COLUMNS] = target.constructor[DATA_FORM_COLUMNS] || [];
+    const columns = target.constructor[DATA_FORM_COLUMNS];
+    columns.push({
+      name: key,
+      submitName: option.name || key,
+      ...option,
+      attrName: key
+    });
+  };
+}
+
+export { formColumn as default };

package/es/decorator/tableColumn.mjs

@@ -0,0 +1,20 @@
+import { DATA_TABLE_COLUMNS } from './constant.mjs';
+import '../abstract/DataTable.mjs';
+import '../abstract/TableColumn.mjs';
+
+function tableColumn(option) {
+  return function(target, key, description) {
+    if (arguments.length !== 3 || target.constructor === Function || typeof description.value === "function") {
+      throw new Error(`@tableColumn \u53EA\u80FD\u4F7F\u7528\u5728\u7C7B\u7684\u6210\u5458\u53D8\u91CF\u4E2D`);
+    }
+    target.constructor[DATA_TABLE_COLUMNS] = target.constructor[DATA_TABLE_COLUMNS] || [];
+    const columns = target.constructor[DATA_TABLE_COLUMNS];
+    columns.push({
+      name: key,
+      attrName: key,
+      ...option
+    });
+  };
+}
+
+export { tableColumn as default };

package/es/factory.mjs

@@ -0,0 +1,14 @@
+import { DATA_MODEL_DEFINE } from './decorator/constant.mjs';
+import DataTable from './abstract/DataTable.mjs';
+import './abstract/dataForm2.mjs';
+
+const createDataTable = function(classType) {
+  const baseDataTable = classType[DATA_MODEL_DEFINE.table];
+  return baseDataTable ? baseDataTable.clone() : new DataTable();
+};
+const createDataForm = function(classType) {
+  const baseDataForm = classType[DATA_MODEL_DEFINE.form];
+  return baseDataForm ? baseDataForm.clone() : new dataForm();
+};
+
+export { createDataForm, createDataTable };

package/es/index.mjs

@@ -0,0 +1,14 @@
+export { default as DataTable } from './abstract/DataTable.mjs';
+export { default as DataForm } from './abstract/DataForm.mjs';
+export { FilterPanel } from './abstract/FilterPanel.mjs';
+export { default as DataModelAdapter } from './abstract/DataModelAdapter.mjs';
+export { default as dataTable } from './decorator/dataTable.mjs';
+export { default as dataForm } from './decorator/dataForm.mjs';
+export { default as tableColumn } from './decorator/tableColumn.mjs';
+export { default as formColumn } from './decorator/formColumn.mjs';
+export { default as SimpleOrm } from './SimpleOrm.mjs';
+export { default as filterColumn } from './decorator/filterColumn.mjs';
+export { CombineCondition } from './abstract/where/CombineCondition.mjs';
+export { SingleCondition } from './abstract/where/SingleCondition.mjs';
+export { Where } from './abstract/where/Where.mjs';
+export { createDataForm, createDataTable } from './factory.mjs';

package/es/utils/index.mjs

@@ -0,0 +1,15 @@
+const sortColumn = (columns, order) => {
+  return [...columns].sort((a, b) => {
+    const aIndex = order.indexOf(a.attrName);
+    const bIndex = order.indexOf(b.attrName);
+    if (aIndex === -1 && bIndex === -1) {
+      return 0;
+    }
+    if (aIndex !== -1 && bIndex !== -1) {
+      return aIndex - bIndex;
+    }
+    return aIndex === -1 ? 1 : -1;
+  });
+};
+
+export { sortColumn };

package/lib/SimpleOrm.js

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var iocAnnotations = require('@ctzy-web-client/ioc-annotations');
+var ioc = require('@ctzy-web-client/ioc');
+var DataModelAdapter = require('./abstract/DataModelAdapter.js');
+var DataTable = require('./abstract/DataTable.js');
+var dataForm = require('./abstract/dataForm2.js');
+
+var _dec, _dec2, _class, _descriptor, _descriptor2;
+let SimpleOrm = (_dec = iocAnnotations.inject(DataModelAdapter["default"]), _dec2 = iocAnnotations.inject(ioc.InstantiationService), _class = class SimpleOrm2 {
+  constructor() {
+    _rollupPluginBabelHelpers.initializerDefineProperty(this, "adapter", _descriptor, this);
+    _rollupPluginBabelHelpers.initializerDefineProperty(this, "instantiationService", _descriptor2, this);
+  }
+  createDataTable(model, options = {}) {
+    return this.instantiationService.createInstance(DataTable["default"], {
+      args: [{
+        model
+      }]
+    });
+  }
+  createDataForm(model, options = {}) {
+    return this.instantiationService.createInstance(dataForm["default"], {
+      args: [{
+        model
+      }]
+    });
+  }
+  async fill(classType, params2, maxRecCount = 1e4) {
+    const dataTable = this.createDataForm(classType);
+    return dataTable.adapter.loadDataListHandle(dataTable, Object.assign({
+      [dataTable.adapter.pagerNumParamName]: 1,
+      [dataTable.adapter.recCountParamName]: maxRecCount
+    }, params2)).then((res) => {
+      return res.data.map((dataItem) => {
+        let modelInstance = new classType();
+        dataTable.getColumns().forEach((column) => {
+          modelInstance[column.attrName] = dataItem[column.name];
+        });
+        return modelInstance;
+      });
+    });
+  }
+  async first(classType, params2) {
+    return this.fill(classType, params2, 1).then((data) => {
+      return data[0] || null;
+    });
+  }
+  async firstByRecId(classType, recId) {
+    const dataTable = this.createDataTable(classType);
+    return this.adapter.loadDataByRecIdHandle(dataTable, Object.assign({
+      [this.primaryKey]: recId
+    }, params)).then((data) => {
+      const result = Array.isArray(data.data) ? data.data[0] : data.data;
+      if (result) {
+        let modelInstance = new classType();
+        dataTable.getColumns().forEach((column) => {
+          modelInstance[column.attrName] = result[column.name];
+        });
+        return modelInstance;
+      }
+      return result;
+    });
+  }
+  submit(classType, data) {
+    const dataForm = this.createDataForm(classType);
+    dataForm.adapter = this.adapter;
+    return dataForm.submit(data);
+  }
+}, _descriptor = _rollupPluginBabelHelpers.applyDecoratedDescriptor(_class.prototype, "adapter", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return null;
+  }
+}), _descriptor2 = _rollupPluginBabelHelpers.applyDecoratedDescriptor(_class.prototype, "instantiationService", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return null;
+  }
+}), _class);
+
+exports["default"] = SimpleOrm;