@ibiz-template/runtime 0.5.1 → 0.5.3-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ibiz-template/runtime",
-  "version": "0.5.1",
+  "version": "0.5.3-beta.0",
   "description": "控制器包",
   "type": "module",
   "main": "out/index.js",
@@ -29,7 +29,7 @@
   "author": "chitanda",
   "license": "MIT",
   "devDependencies": {
-    "@ibiz-template/core": "^0.5.1-next.0",
+    "@ibiz-template/core": "^0.5.2",
     "@ibiz/model-core": "^0.1.2",
     "@types/path-browserify": "^1.0.2",
     "@types/qs": "^6.9.11",
@@ -59,5 +59,5 @@
     "qx-util": "^0.4.8",
     "ramda": "^0.29.0"
   },
-  "gitHead": "f442a5daebbca26f24b167d8afa470d8fd2ff8b8"
+  "gitHead": "5eb401038895adf73adda7baf784193ef0f40ce5"
 }

package/src/app-hub.ts

@@ -233,6 +233,32 @@ export class AppHub implements IAppHubService {
     throw new RuntimeError(`视图[${id}]不存在`);
   }
 
+  /**
+   * 根据视图模型路径，加参数重新计算视图模型
+   *
+   * @author chitanda
+   * @date 2024-01-08 11:01:54
+   * @param {string} appId
+   * @param {string} modelPath
+   * @param {IParams} params
+   * @return {*}  {Promise<IAppView>}
+   */
+  async loadAppView(
+    appId: string,
+    modelPath: string,
+    params: IParams,
+  ): Promise<IAppView> {
+    if (this.modelLoaderProvider) {
+      const model = await this.modelLoaderProvider.loadAppView(
+        appId,
+        modelPath,
+        params,
+      );
+      return model;
+    }
+    throw new RuntimeError(`视图[${modelPath}]不存在`);
+  }
+
   /**
    * 根据应用实体代码名称查找应用视图
    *

package/src/controller/control/form/edit-form/edit-form.controller.ts

@@ -441,8 +441,6 @@ export class EditFormController
           ),
         );
       }
-
-      await awaitTimeout(2000);
     } finally {
       if (showBusyIndicator) {
         this.endLoading();

package/src/controller/control/tree-grid-ex/tree-grid-ex-column/tree-grid-ex-field-column/tree-grid-ex-field-column.controller.ts

@@ -1,11 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import {
-  IDETreeDEFColumn,
-  IDETreeNode,
-  IDETreeNodeDataItem,
-} from '@ibiz/model-core';
+import { IDETreeDEFColumn } from '@ibiz/model-core';
 import { TreeGridExColumnController } from '../tree-grid-ex-column/tree-grid-ex-column.controller';
-import { ITreeGridExRowState } from '../../../../../interface';
 
 /**
  * 树表格（增强）属性列控制器
@@ -15,32 +10,4 @@ import { ITreeGridExRowState } from '../../../../../interface';
  * @class TreeGridExFieldColumnController
  * @extends {TreeGridExColumnController<IDETreeDEFColumn>}
  */
-export class TreeGridExFieldColumnController extends TreeGridExColumnController<IDETreeDEFColumn> {
-  /**
-   * 给rowController初始化属性列的状态
-   *
-   * @author zpc
-   * @date 2024-01-07 21:09:43
-   * @param {ITreeGridExRowState} row
-   */
-  initColumnStates(row: ITreeGridExRowState): void {
-    const { data } = row;
-    if (!this.model.id || !data._deData) {
-      return;
-    }
-
-    const { detreeNodeDataItems } = this.treeGrid.getNodeModel(
-      data._nodeId,
-    ) as IDETreeNode;
-    const targetTreeNodeDataItem = detreeNodeDataItems?.find(
-      (treeNodeDataItem: IDETreeNodeDataItem) => {
-        return treeNodeDataItem.detreeColumnId === this.model.id;
-      },
-    );
-    if (targetTreeNodeDataItem && targetTreeNodeDataItem.appDEFieldId) {
-      (data as IData)[this.model.id.toLowerCase()] = (data._deData as IData)[
-        targetTreeNodeDataItem.appDEFieldId.toLowerCase()
-      ];
-    }
-  }
-}
+export class TreeGridExFieldColumnController extends TreeGridExColumnController<IDETreeDEFColumn> {}

package/src/controller/control/tree-grid-ex/tree-grid-ex-row.state.ts

@@ -28,10 +28,6 @@ export class TreeGridExRowState implements ITreeGridExRowState {
 
   constructor(data: ITreeNodeData, treeGrid: TreeGridExController) {
     this.data = data;
-    // 初始化属性列数据状态
-    Object.values(treeGrid.fieldColumns).forEach(column => {
-      column.initColumnStates(this);
-    });
     // 初始化操作列状态
     Object.values(treeGrid.uaColumns).forEach(column => {
       column.initActionStates(this);

package/src/interface/common/i-app-hub-service/i-app-hub-service.ts

@@ -126,6 +126,22 @@ export interface IAppHubService {
    */
   getAppView(tag: string): Promise<IAppView>;
 
+  /**
+   * 根据参数加载请求视图模型，用于后台根据运行时参数加载视图
+   *
+   * @author chitanda
+   * @date 2024-01-08 11:01:27
+   * @param {string} appId
+   * @param {string} viewId
+   * @param {IParams} params
+   * @return {*}  {Promise<IAppView>}
+   */
+  loadAppView(
+    appId: string,
+    viewId: string,
+    params: IParams,
+  ): Promise<IAppView>;
+
   /**
    * 获取应用实体模型
    *

package/src/interface/provider/model-loader.provider.ts

@@ -38,6 +38,22 @@ export interface ModelLoaderProvider {
    */
   getAppView(appId: string, codeName: string): Promise<IAppView>;
 
+  /**
+   * 根据参数加载请求视图模型，用于后台根据运行时参数加载视图
+   *
+   * @author chitanda
+   * @date 2024-01-08 10:01:43
+   * @param {string} appId
+   * @param {string} viewId
+   * @param {IParams} params
+   * @return {*}  {Promise<IAppView>}
+   */
+  loadAppView(
+    appId: string,
+    viewId: string,
+    params: IParams,
+  ): Promise<IAppView>;
+
   /**
    * 根据 id 获取应用实体模型
    *

package/src/logic-scheduler/executor/app-ui-logic-executor.ts

@@ -11,7 +11,7 @@ import {
 } from '@ibiz/model-core';
 import { notNilEmpty } from 'qx-util';
 import { OpenAppViewCommand } from '../../command';
-import { IModalData, IUILogicParams } from '../../interface';
+import { IModalData, IUILogicParams, IViewController } from '../../interface';
 import { calcDeCodeNameById } from '../../model';
 import { convertNavData } from '../../utils';
 import { LogicExecutor } from './logic-executor';
@@ -256,7 +256,13 @@ export class AppUILogicExecutor extends LogicExecutor {
 
     // 执行批添加新建逻辑
     if (enableBatchAdd && result.data) {
-      await this.doBatchAdd(appUILogic, result.data, context, newViewRef);
+      await this.doBatchAdd(
+        appUILogic,
+        result.data,
+        context,
+        newViewRef,
+        parameters.view,
+      );
     }
 
     return result;
@@ -325,10 +331,11 @@ export class AppUILogicExecutor extends LogicExecutor {
    * @return {*}  {Promise<void>}
    */
   protected async doBatchAdd(
-    appUILogic: IAppUIOpenDataLogic,
+    appUILogic: IAppUINewDataLogic,
     selections: IData[],
     context: IContext,
     newViewRef: IAppUILogicRefViewBase,
+    view: IViewController,
   ): Promise<void> {
     // 批添加新建选中数据后
     if (selections?.length) {
@@ -342,8 +349,8 @@ export class AppUILogicExecutor extends LogicExecutor {
         throw new RuntimeModelError(selfDe, '实体没有从关系集合！');
       }
 
-      // 获取选择视图对应父实体在当前实体里的外键属性名称。
-      let pickParentFieldName: string;
+      // *获取选择视图对应父实体在当前实体里的外键属性名称。
+      let pickParentFieldName: string = '';
       minorDERs?.forEach(item => {
         const majorDeName = calcDeCodeNameById(item.majorAppDataEntityId!);
         if (pickParentDeName === majorDeName) {
@@ -351,14 +358,21 @@ export class AppUILogicExecutor extends LogicExecutor {
         }
       });
 
-      // 获取key为keymapping的特殊视图参数
-      const openViewKeyParam = newViewRef.navigateParams?.find(navParam => {
-        return navParam.key === 'keymapping';
-      });
-      let addData: IData[] = [];
-      if (openViewKeyParam) {
-        const keyValuePairs = openViewKeyParam.value!.split(';');
-        const keyMapping: IData = {};
+      if (pickParentFieldName === undefined) {
+        throw new RuntimeError(
+          `没有找到${pickParentDeName}在当前实体的外键属性`,
+        );
+      }
+
+      // *转换的属性映射，默认映射一个外键属性，额外的通过当前视图的参数配置PROPERTYMAP
+      const keyMapping: IData = {
+        srfkey: pickParentFieldName,
+      };
+      const propertyMap = view.model.appViewParams?.find(
+        item => item.key!.toLowerCase() === 'PROPERTYMAP'.toLowerCase(),
+      );
+      if (propertyMap) {
+        const keyValuePairs = propertyMap.value!.split(',');
         // 遍历键值对数组并添加到 keyMapping 映射对象中
         for (const pair of keyValuePairs) {
           const [sourceKey, targetKey] = pair.split(':');
@@ -366,27 +380,23 @@ export class AppUILogicExecutor extends LogicExecutor {
             keyMapping[sourceKey] = targetKey;
           }
         }
-        addData = selections.map(item => {
-          const tempData: IData = {
-            [pickParentFieldName]: item.srfkey,
-          };
-          // 遍历映射对象，将属性从 item 复制到 tempData
-          for (const key in keyMapping) {
-            if (Object.prototype.hasOwnProperty.call(keyMapping, key)) {
-              const targetKey = keyMapping[key];
-              if (Object.prototype.hasOwnProperty.call(item, key)) {
-                tempData[targetKey] = item[key];
-              }
-            }
-          }
-          return tempData;
-        });
-      } else {
-        addData = selections.map(item => ({
-          [pickParentFieldName]: item.srfkey,
-        }));
       }
 
+      ibiz.log.debug('批量新建转换映射属性', keyMapping);
+
+      // *转换属性
+      const addData: IData[] = selections.map(item => {
+        const tempData: IData = {};
+        // 遍历映射对象，将属性从 item 复制到 tempData
+        Object.keys(keyMapping).forEach(key => {
+          const targetKey = keyMapping[key];
+          tempData[targetKey] = item[key];
+        });
+        return tempData;
+      });
+
+      ibiz.log.debug('批量新建创建数据', addData);
+
       // 获取实体服务并调用创建接口
       const service = ibiz.hub.getApp(context.srfappid).deService;
       await service.exec(selfDe.id!, 'Create', context, addData);

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

@@ -220,10 +220,12 @@ export class MethodDto {
               const items: IData[] = datum[key];
               if (items) {
                 const pKey = datum[this.entity.keyAppDEFieldId!];
-                // 特殊处理，在子包内设置父对象标识
-                items.forEach(item => {
-                  item[field.refPickupAppDEFieldId!] = pKey;
-                });
+                if (field.refPickupAppDEFieldId) {
+                  // 特殊处理，在子包内设置父对象标识
+                  items.forEach(item => {
+                    item[field.refPickupAppDEFieldId!] = pKey;
+                  });
+                }
                 await dto.sets(context, items);
                 // 删除下边一行代码，DTO 的属性也不能直接删除。界面上表单类似重复器的地方会用到，保存时也需要由界面提供
                 // delete datum[key];

package/src/service/service/entity/method/de-action.ts

@@ -463,13 +463,15 @@ export class DEActionMethod extends Method {
     const configs = uiDomain.getDERConfig(this.entity.id!);
     if (configs.length > 0) {
       configs.forEach(config => {
-        const { majorDECodeName, pickupDEFName } = config;
-        const majorLowerCodeName = majorDECodeName.toLowerCase();
-        const pickupLowerDEFName = pickupDEFName.toLowerCase();
-        const majorkey = context[majorLowerCodeName];
-        // 父主键不能是自身，否则自关系的时候就改错了
-        if (majorkey && majorkey !== data.srfkey) {
-          data[pickupLowerDEFName] = majorkey;
+        if (config.pickupDEFName) {
+          const { majorDECodeName, pickupDEFName } = config;
+          const majorLowerCodeName = majorDECodeName.toLowerCase();
+          const pickupLowerDEFName = pickupDEFName.toLowerCase();
+          const majorkey = context[majorLowerCodeName];
+          // 父主键不能是自身，否则自关系的时候就改错了
+          if (majorkey && majorkey !== data.srfkey) {
+            data[pickupLowerDEFName] = majorkey;
+          }
         }
       });
     }

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

@@ -1,6 +1,7 @@
 /* eslint-disable no-constructor-return */
 import { IDETreeDataSetNode, IDETreeNodeDataItem } from '@ibiz/model-core';
 import { updateKeyDefine } from '@ibiz-template/core';
+import { isNil } from 'ramda';
 import { IIcon, ITreeNodeData } from '../../../interface';
 import { calcDeCodeNameById } from '../../../model';
 import { ScriptFactory } from '../../../utils';
@@ -70,28 +71,46 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
       this._leaf = fieldValueToBoolean(data[model.leafFlagAppDEFieldId]);
     }
 
-    /** 数据项映射 */
+    /** 数据项和实体属性映射 */
     const dataItemKeyMap = new Map<string | symbol, string | symbol>();
     dataItemKeyMap.set('srfkey', 'srfkey');
     dataItemKeyMap.set('srfmajortext', 'srfmajortext');
 
-    const dataItemDefaults: IData = {};
     model.detreeNodeDataItems?.forEach(dataItem => {
       const uiKey = dataItem.id!.toLowerCase();
       // 后台实体属性
       const deFieldKey = dataItem.appDEFieldId!.toLowerCase();
       dataItemKeyMap.set(uiKey, deFieldKey);
-      if (dataItem.defaultValue) {
-        dataItemDefaults[uiKey] = dataItem.defaultValue;
+
+      // *设置默认值
+      if (dataItem.defaultValue && isNil(data[deFieldKey])) {
+        data[deFieldKey] = dataItem.defaultValue;
+      }
+    });
+
+    /** 表格列和数据项的映射从而算出实体属性的映射 */
+    const nodeColumnKeyMap = new Map<string | symbol, string | symbol>();
+    model.detreeNodeColumns?.forEach(column => {
+      const columnKey = column.detreeColumnId!; // 不配树表格列不会有这个模型
+      const dataItemKey = column.dataItemName; // 配了就一定有数据项名称
+      if (!columnKey || !dataItemKey) {
+        ibiz.log.error('模型异常缺少detreeColumnId或者dataItemName', column);
+      } else {
+        nodeColumnKeyMap.set(columnKey, dataItemKeyMap.get(dataItemKey)!);
       }
     });
 
     return new Proxy<TreeDataSetNodeData>(this, {
       set(target, p, value): boolean {
-        if (Object.prototype.hasOwnProperty.call(target._deData, p)) {
-          target._deData[p] = value;
+        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;
         } else {
           (target as IData)[p] = value;
         }
@@ -102,9 +121,15 @@ export class TreeDataSetNodeData extends TreeNodeData implements ITreeNodeData {
         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)!] || dataItemDefaults[p];
+          return target._deData[dataItemKeyMap.get(p)!];
         }
+        // 通过实体数据属性标识获取
         if (target._deData[p] !== undefined) {
           return target._deData[p];
         }

package/src/utils/open-redirect-view/open-redirect-view.ts

@@ -214,51 +214,80 @@ export async function getDERedirectToView(
   }
   const entity = await ibiz.hub.getAppDataEntity(entityId, appView.appId);
   const rdTag = await calcDERdTag(entity, appView, params, curData);
-  // !!!工作流临时补充特殊处理标识, 避免补充了工作流流程匹配不上, 再从默认tag匹配!!!
-  const rdTagItems = rdTag.split(':');
-  const wfRdTag =
-    rdTagItems.length === 2 ? rdTag : rdTagItems.slice(0, 2).join(':');
-  // 拼接当前重定向视图所在应用实体名称为前缀
-  const deRdTag = `${entity.name!.toUpperCase()}:${rdTag}`;
-  // 所有重定向引用视图
-  const allRefViews = [];
-  if (appView.redirectAppViewRefs) {
-    allRefViews.push(...appView.redirectAppViewRefs);
-  }
-  if (appView.appViewRefs) {
-    allRefViews.push(...appView.appViewRefs);
-  }
-  const refView = allRefViews.find(view => {
-    const matchKey = view.name || view.id;
-    // 特殊补充 wfRdTag 匹配，子流程应用特殊模式
-    return matchKey === deRdTag || matchKey === rdTag || matchKey === wfRdTag;
-  });
-  if (refView) {
-    const viewId = refView.refAppViewId;
-    if (viewId) {
-      return {
-        type: 'view',
-        viewId,
-        context,
-        params,
-        opts: { ...opts, data: [curData] },
-      };
+  let viewId = '';
+  // view://协议开头处理,值示例: view://{app}/{viewcodename}?srfwftag={wftag}
+  if (rdTag.startsWith('view://')) {
+    const url = new URL(rdTag);
+    if (url.searchParams.size > 0) {
+      url.searchParams.forEach((value, _key) => {
+        params[_key] = value;
+      });
+    }
+    const rdTagItems = url.pathname.replace('//', '').split('/');
+    // 当只有一个时，为视图标识。当有两个时，第二个是视图标识
+    const [appOrViewTag, viewTag] = rdTagItems;
+    if (viewTag) {
+      viewId = viewTag;
+    } else {
+      viewId = appOrViewTag;
     }
-    throw new RuntimeModelError(refView, `未配置实际引用视图`);
   } else {
-    ibiz.log.error(
-      '重定向视图引用有：',
-      allRefViews?.map(({ refAppViewId, name, realTitle }) => ({
-        viewId: refAppViewId,
-        tag: name,
-        title: realTitle,
-      })),
-    );
-    throw new RuntimeModelError(
-      appView,
-      `未找到重定向标识[${rdTag}]或[${deRdTag}]或工作流[${wfRdTag}]对应视图`,
-    );
+    // !!!工作流临时补充特殊处理标识, 避免补充了工作流流程匹配不上, 再从默认tag匹配!!!
+    const rdTagItems = rdTag.split(':');
+    const wfRdTag =
+      rdTagItems.length === 2 ? rdTag : rdTagItems.slice(0, 2).join(':');
+    // 拼接当前重定向视图所在应用实体名称为前缀
+    const deRdTag = `${entity.name!.toUpperCase()}:${rdTag}`;
+    // 所有重定向引用视图
+    const allRefViews = [];
+    if (appView.redirectAppViewRefs) {
+      allRefViews.push(...appView.redirectAppViewRefs);
+    }
+    if (appView.appViewRefs) {
+      allRefViews.push(...appView.appViewRefs);
+    }
+    const refView = allRefViews.find(view => {
+      const matchKey = view.name || view.id;
+      // 特殊补充 wfRdTag 匹配，子流程应用特殊模式
+      return matchKey === deRdTag || matchKey === rdTag || matchKey === wfRdTag;
+    });
+    if (refView) {
+      viewId = refView.refAppViewId!;
+      if (viewId) {
+        return {
+          type: 'view',
+          viewId,
+          context,
+          params,
+          opts: { ...opts, data: [curData] },
+        };
+      }
+      throw new RuntimeModelError(refView, `未配置实际引用视图`);
+    } else {
+      ibiz.log.error(
+        '重定向视图引用有：',
+        allRefViews?.map(({ refAppViewId, name, realTitle }) => ({
+          viewId: refAppViewId,
+          tag: name,
+          title: realTitle,
+        })),
+      );
+      throw new RuntimeModelError(
+        appView,
+        `未找到重定向标识[${rdTag}]或[${deRdTag}]或工作流[${wfRdTag}]对应视图`,
+      );
+    }
+  }
+  if (viewId) {
+    return {
+      type: 'view',
+      viewId,
+      context,
+      params,
+      opts: { ...opts, data: [curData] },
+    };
   }
+  throw new RuntimeModelError(appView, `标识[${rdTag}]未匹配到实际引用视图`);
 }
 
 /**
@@ -335,8 +364,12 @@ export async function calcDERdTag(
   // 自定义重定向
   if (typeFieldId) {
     const { codeName } = findFieldById(entity, typeFieldId)!;
-    const value = data[codeName!.toLowerCase()];
+    const value: string = data[codeName!.toLowerCase()];
     if (notNilEmpty(value)) {
+      // 如果是 view://协议开头直接返回,示例: view://{app}/{viewcodename}?srfwftag={wftag}
+      if (value.startsWith('view://')) {
+        return value;
+      }
       // 因为平台发布出来的标识全都是大写，所以这里也全部转大写
       return `${value.toUpperCase()}`;
     }