@ibiz-template/runtime 0.5.3-beta.4 → 0.5.3-beta.6

package/src/register/helper/panel-item-register.ts

@@ -46,7 +46,8 @@ export async function getPanelItemProvider(
   model: IPanelItem,
 ): Promise<IPanelItemProvider | undefined> {
   let provider: IPanelItemProvider | undefined;
-  const { itemType, sysPFPluginId, appId } = model as Required<IPanelItem>;
+  const { itemType, sysPFPluginId, appId, controlRenders } =
+    model as Required<IPanelItem>;
 
   // 找插件适配器
   if (sysPFPluginId) {
@@ -60,50 +61,55 @@ export async function getPanelItemProvider(
       return provider;
     }
   }
-
-  // 特殊容器类型
-  if (itemType === 'CONTAINER') {
-    const predefinedType =
-      (model as IPanelContainer).predefinedType || 'DEFAULT';
-    const key = `CONTAINER_${predefinedType}`;
-    provider = getProvider(key);
-    if (!provider) {
-      ibiz.log.error(
-        `找不到面板容器预置类型为${predefinedType}的适配器，注册key为${key}`,
-      );
-    } else {
-      return provider;
-    }
-  }
-
-  // 特殊直接内容类型
-  if (itemType === 'RAWITEM') {
-    const predefinedType =
-      (model as IPanelRawItem).rawItem?.predefinedType || 'DEFAULT';
-    const key = `RAWITEM_${predefinedType}`;
-    provider = getProvider(key);
-    if (!provider) {
-      ibiz.log.error(
-        `找不到面板成员直接内容预置类型为${predefinedType}的适配器，注册key为${key}`,
-      );
-    } else {
-      return provider;
+  if (controlRenders && controlRenders.length > 0) {
+    // 默认预定义 绘制器
+    provider = getProvider('PREDEFINE_RENDER');
+  } else {
+    // 特殊容器类型
+    if (itemType === 'CONTAINER') {
+      const predefinedType =
+        (model as IPanelContainer).predefinedType || 'DEFAULT';
+      const key = `CONTAINER_${predefinedType}`;
+      provider = getProvider(key);
+      if (!provider) {
+        ibiz.log.error(
+          `找不到面板容器预置类型为${predefinedType}的适配器，注册key为${key}`,
+        );
+      } else {
+        return provider;
+      }
     }
-  }
 
-  if (itemType === 'FIELD') {
-    const { editor } = model as IPanelField;
-    if (editor && editor.predefinedType) {
-      const key = `FIELD_${editor.predefinedType.toUpperCase()}`;
+    // 特殊直接内容类型
+    if (itemType === 'RAWITEM') {
+      const predefinedType =
+        (model as IPanelRawItem).rawItem?.predefinedType || 'DEFAULT';
+      const key = `RAWITEM_${predefinedType}`;
       provider = getProvider(key);
-      if (provider) {
+      if (!provider) {
+        ibiz.log.error(
+          `找不到面板成员直接内容预置类型为${predefinedType}的适配器，注册key为${key}`,
+        );
+      } else {
         return provider;
       }
     }
+
+    if (itemType === 'FIELD') {
+      const { editor } = model as IPanelField;
+      if (editor && editor.predefinedType) {
+        const key = `FIELD_${editor.predefinedType.toUpperCase()}`;
+        provider = getProvider(key);
+        if (provider) {
+          return provider;
+        }
+      }
+    }
+
+    // 找面板成员类型
+    provider = getProvider(itemType);
   }
 
-  // 找面板成员类型
-  provider = getProvider(itemType);
   if (!provider) {
     ibiz.log.error(`找不到面板成员类型${itemType}对应的适配器`);
   } else {

package/src/service/dto/method.dto.ts

@@ -28,16 +28,6 @@ export class MethodDto {
 
   protected dtoMap: Map<string, MethodDto> = new Map();
 
-  /**
-   * 当前 DTO 是否已经计算过关系相关逻辑
-   *
-   * @link this.calcRs
-   * @author chitanda
-   * @date 2023-12-26 16:12:18
-   * @protected
-   */
-  protected isCalcRs = false;
-
   /**
    * Creates an instance of MethodDto.
    * @author lxm
@@ -208,7 +198,12 @@ export class MethodDto {
     if (this.isLocalMode && !this.inSelfLoop) {
       this.service.local.clear();
     }
-    await this.calcRs(context);
+    const uiDomain = ibiz.uiDomainManager.get(context.srfsessionid);
+    if (uiDomain && uiDomain.state.rsInit !== true) {
+      await this.calcRs(context);
+      uiDomain.calcParentRs();
+      uiDomain.state.rsInit = true;
+    }
     return Promise.all(
       data.map(async datum => {
         const all = this.fields
@@ -224,7 +219,7 @@ export class MethodDto {
               }
               const dto = await this.getFieldDto(context, field);
               const items: IData[] = datum[key];
-              if (items) {
+              if (items && items.length > 0) {
                 const pKey = datum[this.entity.keyAppDEFieldId!];
                 if (field.refPickupAppDEFieldId) {
                   // 特殊处理，在子包内设置父对象标识
@@ -263,10 +258,9 @@ export class MethodDto {
    * @return {*}  {Promise<void>}
    */
   protected async calcRs(context: IContext, depth: number = 0): Promise<void> {
-    if (this.isCalcRs || depth > 10) {
+    if (depth > 10) {
       return;
     }
-    this.isCalcRs = true;
     depth += 1;
 
     const uiDomain = ibiz.uiDomainManager.get(context.srfsessionid);

package/src/service/service/entity/method/fetch.ts

@@ -32,40 +32,41 @@ export class FetchMethod extends Method {
     // 过滤参数，必须是对象
     const searchParams = params && !isArray(params) ? params : params2 || {};
 
+    // 根据数据集合来源查询数据
+    let res: HttpResponse<IData[]>;
+
     if (this.isLocalMode) {
       const cond = DEDQCondUtil.getCond(this.method);
       const items = await this.searchLocal(
         cond,
         new SearchFilter(context, searchParams),
       );
-      return new HttpResponse<IDataEntity[]>(items, 200);
-    }
+      res = new HttpResponse<IDataEntity[]>(items, 200);
+    } else {
+      switch (this.method.dataSetType) {
+        case 'INDEXDE':
+        case 'CODELIST':
+        case 'MULTIFORM':
+          res = await this.fetchCodeListSet(context, searchParams);
+          break;
+        case 'REMOTE':
+          {
+            const path = this.calcPath(context);
+            res = await this.request(path, context, params, params2);
+          }
+          break;
+        default:
+          throw new ModelError(
+            this.method,
+            `数据来源类型${this.method.dataSetType}暂未支持`,
+          );
+      }
 
-    // 根据数据集合来源查询数据
-    let res: HttpResponse<IData[]>;
-    switch (this.method.dataSetType) {
-      case 'INDEXDE':
-      case 'CODELIST':
-      case 'MULTIFORM':
-        res = await this.fetchCodeListSet(context, searchParams);
-        break;
-      case 'REMOTE':
-        {
-          const path = this.calcPath(context);
-          res = await this.request(path, context, params, params2);
-        }
-        break;
-      default:
-        throw new ModelError(
-          this.method,
-          `数据来源类型${this.method.dataSetType}暂未支持`,
-        );
+      // 转换实体对象
+      const items: IData[] = res.data || [];
+      res.data = items.map(item => this.createEntity(item));
     }
 
-    // 转换实体对象
-    const items: IData[] = res.data || [];
-    res.data = items.map(item => this.createEntity(item));
-
     // 计算属性逻辑,每条数据走一遍
     if (res.data) {
       await execFieldLogics(

package/src/service/utils/dynamic-code-list/dynamic-code-list.ts

@@ -262,16 +262,16 @@ export class DynamicCodeListCache {
     );
     let resultItems: CodeListItem[] = [];
     if (res.data.length) {
-      res.data.forEach((item: IData) => {
-        if (pvalueAppDEFieldId) {
-          const tempItems = this.prepareTreeData(res.data as IData[]);
-          if (tempItems) {
-            resultItems = tempItems;
-          }
-        } else {
-          resultItems.push(this.convertData(item));
+      if (pvalueAppDEFieldId) {
+        const tempItems = this.prepareTreeData(res.data as IData[]);
+        if (tempItems) {
+          resultItems = tempItems;
         }
-      });
+      } else {
+        res.data.forEach((item: IData) => {
+          resultItems.push(this.convertData(item));
+        });
+      }
     }
     return Object.freeze(resultItems) as CodeListItem[];
   }
@@ -281,31 +281,23 @@ export class DynamicCodeListCache {
    *
    * @return {codeListItem[] | undefined}
    */
-  protected prepareTreeData(
-    items: IData[],
-    pValue?: string | number,
-  ): CodeListItem[] | undefined {
-    const { pvalueAppDEFieldId } = this.codeList;
-    let filteredData: IData[] = [];
-    filteredData = items.filter(item => {
-      if (pValue) {
-        // 有传父value去后台数据里找出来子项pValue等于父value的
-        return item[pvalueAppDEFieldId!] === pValue;
-      }
-      // 没有传父value，只需要找出来没有父值属性的
-      return !item[pvalueAppDEFieldId!];
+  protected prepareTreeData(items: IData[]): CodeListItem[] | undefined {
+    const { valueAppDEFieldId, pvalueAppDEFieldId } = this.codeList;
+    const map: { [id: string]: CodeListItem } = {};
+    const nestedList: CodeListItem[] = [];
+    items.forEach((data: IData) => {
+      map[data[valueAppDEFieldId as string]] = this.convertData(data);
     });
-    if (filteredData.length === 0) {
-      return;
-    }
-    return filteredData.map(data => {
-      const tempCodeListItem = this.convertData(data);
-      tempCodeListItem.children = this.prepareTreeData(
-        items,
-        tempCodeListItem.value,
-      );
-      return tempCodeListItem;
+    items.forEach((data: IData) => {
+      const parent = map[data[pvalueAppDEFieldId as string]];
+      if (parent) {
+        parent.children = parent.children || [];
+        parent.children.push(map[data[valueAppDEFieldId as string]]);
+      } else {
+        nestedList.push(map[data[valueAppDEFieldId as string]]);
+      }
     });
+    return nestedList;
   }
 
   /**

package/src/service/vo/tree-node-data/tree-data-set-node-data.ts

@@ -1,13 +1,16 @@
 /* eslint-disable no-constructor-return */
 import { IDETreeDataSetNode, IDETreeNodeDataItem } from '@ibiz/model-core';
 import { updateKeyDefine } from '@ibiz-template/core';
-import { isNil } from 'ramda';
+import { clone, isNil } from 'ramda';
 import { IIcon, ITreeNodeData } from '../../../interface';
 import { calcDeCodeNameById } from '../../../model';
 import { ScriptFactory } from '../../../utils';
 import { TreeNodeData } from './tree-node-data';
 import { fieldValueToBoolean } from '../../utils';
 
+/** 克隆时赋值排除的字段 */
+const CloneExcludeKeys = ['_id', '_value', '_text', '_deData', 'clone'];
+
 /**
  * 实体数据集树节点数据
  *
@@ -17,13 +20,20 @@ import { fieldValueToBoolean } from '../../utils';
  * @implements {ITreeNodeData}
  */
 export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
-  _text: string;
+  declare _text: string;
+
+  declare _id: string;
 
-  _id!: string;
+  declare _value: string;
 
-  _value: string;
+  declare _deData: IData;
 
-  _deData: IData;
+  /**
+   * 克隆方法
+   * @author lxm
+   * @date 2024-01-12 02:37:46
+   */
+  declare clone: () => TreeDataSetNodeData;
 
   constructor(
     model: IDETreeDataSetNode,
@@ -38,12 +48,6 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
     super(model, parentNodeData, opts);
     const { data } = opts;
     this._deData = data;
-    this._text = model.textAppDEFieldId
-      ? data[model.textAppDEFieldId]
-      : data.srfmajortext;
-    this._value = model.idAppDEFieldId
-      ? data[model.idAppDEFieldId]
-      : data.srfkey;
 
     // id小写
     const selfId = `${model.id}@${data.srfkey}`.toLowerCase();
@@ -55,6 +59,26 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
       configurable: true,
     });
 
+    // 文本值
+    Object.defineProperty(this, '_text', {
+      get() {
+        return model.textAppDEFieldId
+          ? data[model.textAppDEFieldId]
+          : data.srfmajortext;
+      },
+      enumerable: true,
+      configurable: true,
+    });
+
+    // value值
+    Object.defineProperty(this, '_value', {
+      get() {
+        return model.idAppDEFieldId ? data[model.idAppDEFieldId] : data.srfkey;
+      },
+      enumerable: true,
+      configurable: true,
+    });
+
     // 实体节点额外添加上自己的实体上下文
     if (model.appDataEntityId) {
       const deName = calcDeCodeNameById(model.appDataEntityId);
@@ -73,22 +97,21 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
 
     /** 数据项和实体属性映射 */
     const dataItemKeyMap = new Map<string | symbol, string | symbol>();
-    dataItemKeyMap.set('srfkey', 'srfkey');
-    dataItemKeyMap.set('srfmajortext', 'srfmajortext');
-
+    const dataItemDefaultMap = new Map<string | symbol, unknown>();
     model.detreeNodeDataItems?.forEach(dataItem => {
-      const uiKey = dataItem.id!.toLowerCase();
-      // 后台实体属性
+      const dataItemKey = dataItem.id!.toLowerCase();
+
+      // *后台实体属性
       const deFieldKey = dataItem.appDEFieldId!.toLowerCase();
-      dataItemKeyMap.set(uiKey, deFieldKey);
+      dataItemKeyMap.set(dataItemKey, deFieldKey);
 
       // *设置默认值
-      if (dataItem.defaultValue && isNil(data[deFieldKey])) {
-        data[deFieldKey] = dataItem.defaultValue;
+      if (dataItem.defaultValue) {
+        dataItemDefaultMap.set(dataItemKey, dataItem.defaultValue);
       }
     });
 
-    /** 表格列和数据项的映射从而算出实体属性的映射 */
+    /** 表格列和数据项的映射 */
     const nodeColumnKeyMap = new Map<string | symbol, string | symbol>();
     model.detreeNodeColumns?.forEach(column => {
       const columnKey = column.detreeColumnId!; // 不配树表格列不会有这个模型
@@ -96,45 +119,87 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
       if (!columnKey || !dataItemKey) {
         ibiz.log.error('模型异常缺少detreeColumnId或者dataItemName', column);
       } else {
-        nodeColumnKeyMap.set(columnKey, dataItemKeyMap.get(dataItemKey)!);
+        nodeColumnKeyMap.set(columnKey, dataItemKey);
       }
     });
 
+    /**
+     * 获取对应key最终映射的实体属性字段，undefined就是没有映射实体属性
+     * @author lxm
+     * @date 2024-01-12 01:48:09
+     * @param {(string | symbol)} key
+     * @return {*}  {(string | symbol | undefined)}
+     */
+    const getDeKey = (key: string | symbol): string | symbol | undefined => {
+      // 表格列映射的实体数据属性名称
+      if (nodeColumnKeyMap.has(key)) {
+        return dataItemKeyMap.get(nodeColumnKeyMap.get(key)!);
+      }
+      // 数据项映射的实体数据属性名称
+      if (dataItemKeyMap.has(key)) {
+        return dataItemKeyMap.get(key);
+      }
+      // 实体属性上可枚举的属性，返回该属性名称
+      if (Object.prototype.hasOwnProperty.call(this._deData, key)) {
+        return key;
+      }
+    };
+
+    /**
+     * 获取对应属性的默认值，纯显示用的
+     * @author lxm
+     * @date 2024-01-12 02:36:53
+     * @param {(string | symbol)} key
+     * @return {*}  {unknown}
+     */
+    const getKeyDefault = (key: string | symbol): unknown => {
+      // 表格列映射的数据项的默认值
+      if (nodeColumnKeyMap.has(key)) {
+        return dataItemDefaultMap.get(nodeColumnKeyMap.get(key)!);
+      }
+      // 数据项映射的默认值
+      if (dataItemDefaultMap.has(key)) {
+        return dataItemDefaultMap.get(key);
+      }
+    };
+
+    this.clone = (): TreeDataSetNodeData => {
+      const cloneData = clone(this._deData);
+      const cloneNodeData = new TreeDataSetNodeData(model, this._parent, {
+        data: cloneData,
+        leaf: this._leaf,
+        navContext: this._context,
+        navParams: this._params,
+      });
+      Object.keys(this).forEach(key => {
+        const deKey = getDeKey(key);
+        // 非实体的映射属性，且不是排除的属性时，从原来那边赋值过来
+        if (isNil(deKey) && !CloneExcludeKeys.includes(key)) {
+          (cloneNodeData as IData)[key] = (this as IData)[key];
+        }
+      });
+      return cloneNodeData;
+    };
+
     return new Proxy<TreeDataSetNodeData>(this, {
       set(target, p, value): boolean {
-        if (nodeColumnKeyMap.has(p)) {
-          // 通过树表格列标识设置
-          target._deData[nodeColumnKeyMap.get(p)!] = value;
-        } else if (dataItemKeyMap.has(p)) {
-          // 通过树节点数据项标识设置
-          target._deData[dataItemKeyMap.get(p)!] = value;
-        } else if (Object.prototype.hasOwnProperty.call(target._deData, p)) {
-          // 通过实体数据属性标识设置
-          target._deData[p] = value;
+        const deKey = getDeKey(p);
+        if (!isNil(deKey)) {
+          target._deData[deKey] = value;
         } else {
           (target as IData)[p] = value;
         }
         return true;
       },
-
       get(target, p, _receiver): unknown {
-        if ((target as IData)[p] !== undefined) {
-          return (target as IData)[p];
-        }
-        // 通过树表格列标识获取
-        if (nodeColumnKeyMap.has(p)) {
-          return target._deData[nodeColumnKeyMap.get(p)!];
-        }
-        // 通过树节点数据项标识获取
-        if (dataItemKeyMap.has(p)) {
-          return target._deData[dataItemKeyMap.get(p)!];
-        }
-        // 通过实体数据属性标识获取
-        if (target._deData[p] !== undefined) {
-          return target._deData[p];
+        const deKey = getDeKey(p);
+        if (!isNil(deKey)) {
+          return isNil(target._deData[deKey])
+            ? getKeyDefault(p)
+            : target._deData[deKey];
         }
+        return (target as IData)[p];
       },
-
       ownKeys(target): ArrayLike<string | symbol> {
         // 整合所有并排除重复
         const allKeys = [

package/src/utils/ui-domain/ui-domain.ts

@@ -20,15 +20,34 @@ export class UIDomain {
   readonly id: string;
 
   /**
-   * DTO 父子关系映射
+   * 状态
+   *
+   * @author chitanda
+   * @date 2024-01-15 19:01:51
+   * @type {{ rsInit: boolean }} 关系是否已经初始化
+   */
+  readonly state: { rsInit: boolean } = { rsInit: false };
+
+  /**
+   * DTO 子父关系映射
    *
    * @author chitanda
    * @date 2023-12-26 15:12:13
    * @protected
-   * @type {Map<string, IAppDERS[]>}
+   * @type {Map<string, IAppDERS[]>} Map<子实体, 当前实体的父关系>
    */
   protected rsMap: Map<string, IAppDERS[]> = new Map();
 
+  /**
+   * DTO 父子关系映射
+   *
+   * @author chitanda
+   * @date 2024-01-15 17:01:42
+   * @protected
+   * @type {Map<string, IAppDERS[]>}
+   */
+  protected rs2Map: Map<string, IAppDERS[]> = new Map();
+
   /**
    * Creates an instance of UIDomain.
    *
@@ -50,11 +69,11 @@ export class UIDomain {
    *
    * @author chitanda
    * @date 2023-12-26 15:12:31
-   * @param {string} entity
+   * @param {string} appDataEntityId
    * @param {IAppDERS} configs
    */
-  setDERConfig(deCodeName: string, configs: IAppDERS[]): void {
-    this.rsMap.set(deCodeName, configs);
+  setDERConfig(appDataEntityId: string, configs: IAppDERS[]): void {
+    this.rsMap.set(appDataEntityId, configs);
   }
 
   /**
@@ -62,16 +81,37 @@ export class UIDomain {
    *
    * @author chitanda
    * @date 2023-12-26 16:12:07
-   * @param {string} deCodeName
+   * @param {string} appDataEntityId
    * @return {*}  {IAppDERS[]}
    */
-  getDERConfig(deCodeName: string): IAppDERS[] {
-    if (this.rsMap.has(deCodeName)) {
-      return this.rsMap.get(deCodeName)!;
+  getDERConfig(appDataEntityId: string): IAppDERS[] {
+    if (this.rsMap.has(appDataEntityId)) {
+      return this.rsMap.get(appDataEntityId)!;
     }
     return [];
   }
 
+  /**
+   * 根据模型给的子实体中的父关系模型，计算每个实体的子关系模型
+   *
+   * @author chitanda
+   * @date 2024-01-15 19:01:49
+   */
+  calcParentRs(): void {
+    this.rs2Map.clear();
+    this.rsMap.forEach((configs, appDataEntityId) => {
+      configs.forEach(config => {
+        config.minorAppDataEntityId = appDataEntityId;
+        const major = config.majorAppDataEntityId!;
+        if (!this.rs2Map.has(major)) {
+          this.rs2Map.set(major, []);
+        }
+        this.rs2Map.get(major)!.push(config);
+      });
+    });
+    console.log(Array.from(this.rs2Map.values()));
+  }
+
   /**
    * 界面域销毁
    *