@ctzy-web-client/data-model 1.0.0 → 1.0.3

package/es/abstract/DataColumn.mjs

@@ -0,0 +1,65 @@
+import { BehaviorSubject } from 'rxjs';
+
+class DataColumn {
+  constructor(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    this.title = "";
+    this.name = "";
+    this.attrName = "";
+    this.fullAttrName = "";
+    this.default = void 0;
+    this._visible = true;
+    this.component = void 0;
+    this.isExtend = false;
+    this.componentTitle = "";
+    this.componentProps = void 0;
+    this._visibleSubject = null;
+    this.title = (_a = options == null ? void 0 : options.title) != null ? _a : this.title;
+    this.name = (_b = options == null ? void 0 : options.name) != null ? _b : this.name;
+    this.attrName = (_c = options == null ? void 0 : options.attrName) != null ? _c : this.attrName;
+    this.default = (_d = options == null ? void 0 : options.default) != null ? _d : this.default;
+    this._visible = (_e = options == null ? void 0 : options.visible) != null ? _e : this._visible;
+    this.component = (_f = options == null ? void 0 : options.component) != null ? _f : this.component;
+    this.componentTitle = (_g = options == null ? void 0 : options.componentTitle) != null ? _g : this.componentTitle;
+    this.componentProps = (_h = options == null ? void 0 : options.componentProps) != null ? _h : this.componentProps;
+    this.isExtend = (_i = options == null ? void 0 : options.isExtend) != null ? _i : this.isExtend;
+    this.fullAttrName = this.isExtend ? options == null ? void 0 : options.fullAttrName : this.attrName;
+    this._visibleSubject = new BehaviorSubject(this._visible);
+  }
+  get visible() {
+    return this._visible;
+  }
+  set visible(visible) {
+    if (visible) {
+      this.show();
+      return;
+    }
+    this.hide();
+  }
+  getVisibleSubject() {
+    return this._visibleSubject;
+  }
+  show() {
+    if (this._visible) {
+      return;
+    }
+    this._visible = true;
+    this._visibleSubject.next(this._visible);
+  }
+  hide() {
+    if (!this._visible) {
+      return;
+    }
+    this._visible = false;
+    this._visibleSubject.next(this._visible);
+  }
+  toggleVisible() {
+    if (this._visible) {
+      this.hide();
+      return;
+    }
+    this.show();
+  }
+}
+
+export { DataColumn as default };

package/es/abstract/DataForm.mjs

@@ -0,0 +1,178 @@
+import get from 'lodash/get';
+import { DATA_FORM, DATA_FORM_COLUMNS } from '../decorator/constant.mjs';
+import { sortColumn } from '../utils/index.mjs';
+import DataModel from './DataModel.mjs';
+import FormColumn from './FormColumn.mjs';
+
+class DataForm extends DataModel {
+  constructor(option) {
+    super(option);
+    this.changed = false;
+    this.locking = false;
+    this.disabled = false;
+    this.data = {};
+    this.formValivators = [];
+    this._loadCallbacks = [];
+    this._inited = false;
+  }
+  setOptions(options) {
+    if (!options.model) {
+      return;
+    }
+    super.setOptions({
+      ...options.model[DATA_FORM],
+      model: options.model
+    });
+  }
+  disable() {
+    this.disabled = true;
+  }
+  enable() {
+    this.disabled = false;
+  }
+  init() {
+    super.init();
+    const model = this.model;
+    if (!model) {
+      return;
+    }
+    if (this.extendField) {
+      return;
+    } else {
+      const columns = (model[DATA_FORM_COLUMNS] || []).map((columnConfig) => new FormColumn(columnConfig));
+      for (const column of columns) {
+        this.addColumn(column);
+      }
+      model.formColumns = this.getColumns().map((column) => column.attrName);
+    }
+    this.setData(null);
+    this._inited = true;
+    this.emit("init-completed");
+  }
+  setExtendFieldInfos(extendFieldInfos) {
+    if (this._inited) {
+      return;
+    }
+    this.extendFieldInfos = extendFieldInfos;
+    const formColumns = extendFieldInfos.map((extendField) => {
+      var _a;
+      return new FormColumn({
+        name: extendField.name,
+        title: extendField.title,
+        attrName: extendField.name,
+        submitName: extendField.name,
+        default: extendField.defaultValue || "",
+        isExtend: !extendField.type,
+        required: !!extendField.isRequired,
+        component: extendField.component,
+        componentProps: (_a = extendField.extendInfo) != null ? _a : {},
+        fullAttrName: `${this.extendField}.${extendField.name}`
+      });
+    });
+    this.setColumns(formColumns);
+    this.setData(null);
+    this._inited = true;
+    for (const callback of this._loadCallbacks) {
+      callback();
+    }
+    this.emit("init-completed");
+  }
+  setData(data) {
+    if (data) {
+      this.data = data;
+    } else {
+      this.reset();
+    }
+    this.ready = true;
+  }
+  reset() {
+    this.setData(this.formatData({}));
+  }
+  async loadDataByRecId(params) {
+    if (!this._inited) {
+      return new Promise((resolve, reject) => {
+        this._loadCallbacks.push(() => {
+          this.loadDataByRecId(params).then(resolve, reject);
+        });
+      });
+    }
+    this.locking = true;
+    if (typeof params !== "object") {
+      params = {
+        [this.primaryKey]: params
+      };
+    }
+    params = {
+      ...this.defaultParams,
+      ...params
+    };
+    this.emit("before-load", params);
+    return this.adapter.loadDataByRecIdHandle(this, params).then((res) => {
+      const data = this.formatData(Array.isArray(res.data) ? res.data[0] : res.data);
+      this.setData(data);
+      this.emit("load-successfully", res);
+      return res;
+    }).catch((e) => {
+      this.emit("load-failed", e);
+      return Promise.reject(e);
+    }).finally(() => {
+      this.locking = false;
+      this.emit("load-complete");
+    });
+  }
+  formatSubmitData(data) {
+    return this._format(data, "submitName");
+  }
+  sortColumns(columns) {
+    return sortColumn(columns, this.model.formColumns || []);
+  }
+  async validate() {
+    if (!this.formValivators.length) {
+      return Promise.resolve(false);
+    }
+    const validateResults = await Promise.all(this.formValivators.map((validator) => validator.validate().then(() => true, () => false)));
+    return validateResults.reduce((result, item) => result && item, true);
+  }
+  async submit(data = {}) {
+    if (this.disabled) {
+      throw new Error("\u7981\u7528\u72B6\u6001\u4E0D\u80FD\u4FDD\u5B58");
+    }
+    if (this.locking) {
+      return;
+    }
+    if (!await this.validate()) {
+      return;
+    }
+    this.locking = true;
+    const submitData = {};
+    for (let column of this.getColumns().filter((column2) => !column2.isExtend)) {
+      submitData[column.submitName] = this.data[column.attrName];
+    }
+    if (this.extendField) {
+      let extendObject = {};
+      for (let column of this.getColumns().filter((column2) => column2.isExtend)) {
+        extendObject[column.attrName] = get(this.data, column.fullAttrName);
+      }
+      submitData[this.extendField] = extendObject;
+    }
+    Object.assign(submitData, data);
+    this.emit("before-submit", data);
+    return this.adapter.submitHandle(this, submitData).then((res) => {
+      this.emit("submit-successfully", res);
+      return res;
+    }).catch((e) => {
+      this.emit("submit-failed", e);
+      return Promise.reject(e);
+    }).finally(() => {
+      this.emit("submit-complete");
+      this.locking = false;
+    });
+  }
+  setDisplayColumns(displayColumns) {
+    const displayColumnNames = displayColumns.map((column) => column.fullAttrName);
+    this._displayColumns = this.getColumns().filter((column) => displayColumnNames.includes(column.fullAttrName));
+    this.getDisplayColumnsSubject().next(this.getDisplayColumns());
+  }
+}
+
+export { DataForm as default };

package/es/abstract/DataModel.mjs

@@ -0,0 +1,223 @@
+import { initializerDefineProperty as _initializerDefineProperty, applyDecoratedDescriptor as _applyDecoratedDescriptor } from '../_virtual/_rollupPluginBabelHelpers.mjs';
+import get from 'lodash/get';
+import DataModelAdapter from './DataModelAdapter.mjs';
+import './DataColumn.mjs';
+import { inject } from '@ctzy-web-client/ioc-annotations';
+import { EventDispatcher } from '@ctzy-web-client/support';
+import { InstantiationService } from '@ctzy-web-client/ioc';
+import { clone, cloneDeep } from 'lodash';
+import { BehaviorSubject } from 'rxjs';
+
+var _dec, _dec2, _class, _descriptor, _descriptor2;
+let DataModel = (_dec = inject(DataModelAdapter), _dec2 = inject(InstantiationService), _class = class DataModel2 extends EventDispatcher {
+  constructor(options) {
+    super();
+    this.name = "";
+    this.title = "";
+    this.primaryKey = "id";
+    _initializerDefineProperty(this, "adapter", _descriptor, this);
+    _initializerDefineProperty(this, "instantiationService", _descriptor2, this);
+    this.defaultParams = {};
+    this.model = null;
+    this.ready = false;
+    this._options = null;
+    this.extendField = "";
+    this.extendFieldInfos = [];
+    this._columns = [];
+    this._displayColumns = [];
+    this._columnSubscriptionMap = /* @__PURE__ */ new Map();
+    this._displayColumnsSubject = new BehaviorSubject([]);
+    this.setOptions(options);
+  }
+  setOptions(options) {
+    this._options = options;
+    this.name = options.name;
+    this.title = options.title;
+    this.primaryKey = options.primaryKey || this.primaryKey;
+    this.extendField = options.extendField;
+    this.model = options.model;
+  }
+  init() {
+    var _a;
+    if (typeof ((_a = this._options) == null ? void 0 : _a.adapter) === "function") {
+      this.adapter = this.instantiationService.createInstance(this._options.adapter);
+    }
+  }
+  _format(data, propName = "name") {
+    const columns = this.getColumns();
+    const _data = {};
+    for (let column of columns.filter((column2) => !column2.isExtend)) {
+      const value = data == null ? void 0 : data[column[propName]];
+      _data[column.attrName] = value === "" || value == null ? column.default : value;
+    }
+    if (this.extendField) {
+      let extendObject = {};
+      for (let column of columns.filter((column2) => column2.isExtend)) {
+        const value = get(data, column.fullAttrName);
+        extendObject[column.attrName] = value === "" || value == null ? column.default : value;
+      }
+      _data[this.extendField] = extendObject;
+    }
+    const extendProperties = (source, target, predicate) => {
+      let keys = Object.keys(source);
+      keys = keys.filter((key) => !columns.filter(predicate).find((column) => column.attrName === key));
+      for (const key of keys) {
+        target[key] = source[key];
+      }
+    };
+    extendProperties(data, _data, (column) => !column.isExtend);
+    if (this.extendField && data[this.extendField]) {
+      extendProperties(data[this.extendField], _data[this.extendField], (column) => column.isExtend);
+    }
+    return _data;
+  }
+  getDisplayColumnsSubject() {
+    return this._displayColumnsSubject;
+  }
+  setParam(key, value) {
+    this.defaultParams[key] = value;
+  }
+  getParam(key) {
+    return this.defaultParams[key];
+  }
+  hasParam(key) {
+    return Reflect.has(this.defaultParams, key);
+  }
+  removeParam(key) {
+    Reflect.deleteProperty(this.defaultParams, key);
+  }
+  addParams(params = {}) {
+    this.defaultParams = {
+      ...this.defaultParams,
+      ...params
+    };
+  }
+  setParams(params = {}) {
+    this.defaultParams = params;
+  }
+  clearParam() {
+    this.defaultParams = {};
+  }
+  formatData(data) {
+    return this._format(data);
+  }
+  formatExtendFieldInfo(extendFieldInfo) {
+    return {
+      title: extendFieldInfo.title,
+      name: extendFieldInfo.name,
+      default: extendFieldInfo.defaultValue,
+      attrName: extendFieldInfo.name,
+      isExtend: !extendFieldInfo.type,
+      required: !!extendFieldInfo.isRequired,
+      visible: !!extendFieldInfo.isVisible,
+      component: extendFieldInfo.component,
+      componentProps: {
+        ...extendFieldInfo.extendInfo
+      }
+    };
+  }
+  mergeTableColumn(formatedExtendFieldInfo, modelFieldInfo) {
+    return {
+      ...modelFieldInfo,
+      ...formatedExtendFieldInfo,
+      fullAttrName: `${this.extendField}.${formatedExtendFieldInfo.name}`,
+      componentProps: {
+        ...modelFieldInfo == null ? void 0 : modelFieldInfo.componentProps,
+        ...formatedExtendFieldInfo.extendInfo
+      }
+    };
+  }
+  mergeTableColumns(extendFieldInfos, modelFieldInfos = []) {
+    return extendFieldInfos.map((extendFieldInfo) => {
+      const modelFieldInfo = modelFieldInfos.find((field) => field.name === extendFieldInfo.name);
+      const formatedExtendFieldInfo = this.formatExtendFieldInfo(extendFieldInfo);
+      return this.mergeTableColumn(formatedExtendFieldInfo, modelFieldInfo);
+    });
+  }
+  getColumns() {
+    return this._columns.slice();
+  }
+  setColumns(columns) {
+    this._columnSubscriptionMap.clear();
+    this._columns = [];
+    for (let column of columns) {
+      this.addColumn(column);
+    }
+  }
+  sortColumns(columns) {
+    throw new Error("\u6682\u672A\u5B9E\u73B0\u3002");
+  }
+  addColumn(column) {
+    if (!this.getColumn(column.attrName)) {
+      this._columns = this.sortColumns(this.getColumns().concat(column));
+      const subscription = column.getVisibleSubject().subscribe({
+        next: (visible) => {
+          if (visible) {
+            this.addDisplayColumn(column);
+            return;
+          }
+          this.removeDisplayColumn(column);
+        },
+        error: () => {
+          this.removeDisplayColumn(column);
+        },
+        complete: () => {
+          this.removeDisplayColumn(column);
+        }
+      });
+      this._columnSubscriptionMap.set(column.attrName, subscription);
+    } else {
+      throw new Error("\u65E0\u6CD5\u6DFB\u52A0\u4E24\u4E2A\u5B57\u6BB5\u540D\u79F0\u4E00\u6837\u7684\u5B57\u6BB5:" + column.attrName);
+    }
+  }
+  getColumn(columnName) {
+    var _a;
+    return (_a = this._columns.find((column) => column.attrName === columnName)) != null ? _a : null;
+  }
+  getDisplayColumns() {
+    return this._displayColumns.slice();
+  }
+  setDisplayColumns(displayColumns) {
+    this._displayColumns = displayColumns;
+    this.getDisplayColumnsSubject().next(this.getDisplayColumns());
+  }
+  hasDisplayColumn(column) {
+    return !!this._displayColumns.find((item) => item.attrName === column.attrName);
+  }
+  addDisplayColumn(column) {
+    if (!this.getColumn(column.attrName) || this.hasDisplayColumn(column)) {
+      return;
+    }
+    this.setDisplayColumns(this._displayColumns.concat(column));
+  }
+  removeDisplayColumn(column) {
+    if (!this.hasDisplayColumn(column)) {
+      return;
+    }
+    this.setDisplayColumns(this._displayColumns.filter((item) => item.attrName !== column.attrName));
+  }
+  clone() {
+    const cloned = clone(this);
+    cloned.adapter = this.adapter;
+    cloned.instantiationService = this.instantiationService;
+    cloned.defaultParams = cloneDeep(this.defaultParams);
+    cloned._columns = cloneDeep(this._columns);
+    return cloned;
+  }
+}, _descriptor = _applyDecoratedDescriptor(_class.prototype, "adapter", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return null;
+  }
+}), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, "instantiationService", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return null;
+  }
+}), _class);
+
+export { DataModel as default };

package/es/abstract/DataModelAdapter.mjs

@@ -0,0 +1,86 @@
+import { initializerDefineProperty as _initializerDefineProperty, applyDecoratedDescriptor as _applyDecoratedDescriptor } from '../_virtual/_rollupPluginBabelHelpers.mjs';
+import { inject, value } from '@ctzy-web-client/ioc-annotations';
+import { HttpRequest } from '@ctzy-web-client/support';
+
+var _dec, _dec2, _class, _descriptor, _descriptor2;
+let DataModelAdapter = (_dec = inject(HttpRequest), _dec2 = value("AppName"), _class = class DataModelAdapter2 {
+  constructor() {
+    _initializerDefineProperty(this, "httpRequest", _descriptor, this);
+    _initializerDefineProperty(this, "appName", _descriptor2, this);
+    this.loadDataListItfMethod = "POST";
+    this.deleteItfMethod = "POST";
+    this.loadDataByRecIdMethod = "POST";
+    this.saveItfMethod = "POST";
+    this.updateItfMethod = "POST";
+    this.extendFieldItfMethod = "POST";
+    this.loadDataListItfUrl = "/${DataModelName}/page";
+    this.saveItfUrl = "${DataModelName}/save";
+    this.updateItfUrl = "${DataModelName}/update";
+    this.loadDataByRecIdItfUrl = "/${DataModelName}/find";
+    this.deleteItfUrl = "/${DataModelName}/delete";
+    this.extendFieldItfUrl = "/sceneField/default/page";
+    this.submitMethod = "POST";
+    this.pagerNumParamName = "pageNo";
+    this.recCountParamName = "pageSize";
+    this.dataNodeName = "data";
+    this.totalRecCountNodeName = "totalRecCount";
+  }
+  formatUrl(url, context) {
+    return url.replace(/(\$\{[\S]+?\})/g, (name) => {
+      if (name == "${AppName}") {
+        return context.appName;
+      } else if (name == "${DataModelName}") {
+        return context.dataModelName;
+      }
+      return name;
+    });
+  }
+  async sendRequest(url, method, params) {
+    return this.httpRequest[method.toLowerCase()](url, params);
+  }
+  async _sendRequest(context, url, method, params) {
+    const _context = {
+      appName: this.appName,
+      dataModelName: context.name
+    };
+    url = this.formatUrl(url, _context);
+    return this.sendRequest(url, method, params);
+  }
+  getExtendsFieldHandle(context, params) {
+    return this._sendRequest(context, this.extendFieldItfUrl, this.extendFieldItfMethod, params);
+  }
+  async loadDataListHandle(context, params) {
+    return this._sendRequest(context, this.loadDataListItfUrl, this.loadDataListItfMethod, params);
+  }
+  async deleteHandle(context, params) {
+    return this._sendRequest(context, this.deleteItfUrl, this.deleteItfMethod, params);
+  }
+  async loadDataByRecIdHandle(context, params) {
+    return this._sendRequest(context, this.loadDataByRecIdItfUrl, this.loadDataByRecIdMethod, params);
+  }
+  async saveHandle(context, params) {
+    return this._sendRequest(context, this.saveItfUrl, this.saveItfMethod, params);
+  }
+  async updateHandle(context, params) {
+    return this._sendRequest(context, this.updateItfUrl, this.updateItfMethod, params);
+  }
+  async submitHandle(context, params) {
+    return (params == null ? void 0 : params[context.primaryKey]) ? this.updateHandle(context, params) : this.saveHandle(context, params);
+  }
+}, _descriptor = _applyDecoratedDescriptor(_class.prototype, "httpRequest", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return null;
+  }
+}), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, "appName", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function() {
+    return "";
+  }
+}), _class);
+
+export { DataModelAdapter as default };