@ibiz-template/runtime 0.0.1-alpha.32 → 0.0.1-alpha.34

package/src/utils/app-de-ui-action-util/handler/ui-action-handler.ts

@@ -0,0 +1,215 @@
+import { IBizContext, RuntimeError } from '@ibiz-template/core';
+import { IPSAppDEUIAction, IPSNavigateContext } from '@ibiz-template/model';
+import { notNilEmpty } from 'qx-util';
+import { IUIActionHandler, IUIActionResult } from '../../../interface';
+import { convertNavData } from '../../nav-params/nav-params';
+import { AppDEUIActionUtil } from '../app-de-ui-action-util';
+
+/**
+ * 界面行为处理器基类
+ *
+ * @author lxm
+ * @date 2022-10-25 14:10:31
+ * @export
+ * @class UIActionHandler
+ */
+export abstract class UIActionHandler implements IUIActionHandler {
+  async exec(
+    action: IPSAppDEUIAction,
+    context: IBizContext,
+    data: IData[] | null,
+    params: IParams,
+    opts?: IData | undefined,
+  ): Promise<IUIActionResult> {
+    // **用户操作确认**
+    if (!(await this.isConfirm(action))) {
+      return {};
+    }
+
+    const { neuron } = opts!;
+    const result: IUIActionResult = {
+      refresh: action.reloadData,
+      closeView: action.closeEditView,
+    };
+
+    // 执行不同类型的界面行为独有逻辑，并且合并result
+    const _result = await this.execAction(action, context, data, params, opts);
+    Object.assign(result, _result);
+
+    await this.doNextAction(action, context, data, params, opts);
+    await this.handleResult(result, neuron);
+    return result;
+  }
+
+  /**
+   * 用户操作确认
+   *
+   * @author lxm
+   * @date 2022-10-25 14:10:55
+   * @param {IPSAppDEUIAction} action 界面行为模型
+   * @returns {*}  {Promise<boolean>}
+   */
+  async isConfirm(action: IPSAppDEUIAction): Promise<boolean> {
+    if (action.enableConfirm && action.confirmMsg) {
+      return ibiz.modal.confirm({ title: action.confirmMsg });
+    }
+    return true;
+  }
+
+  /**
+   * 执行具体界面行为的独有逻辑(子类重写)
+   *
+   * @author lxm
+   * @date 2022-10-25 15:10:03
+   * @abstract
+   * @param {IPSAppDEUIAction} action
+   * @param {IBizContext} context
+   * @param {(IData[] | null)} data
+   * @param {IParams} params
+   * @param {(IData | undefined)} [opts]
+   * @returns {*}  {Promise<IUIActionResult>}
+   */
+  abstract execAction(
+    action: IPSAppDEUIAction,
+    context: IBizContext,
+    data: IData[] | null,
+    params: IParams,
+    opts?: IData | undefined,
+  ): Promise<IUIActionResult>;
+
+  /**
+   * 执行后续界面行为
+   *
+   * @author lxm
+   * @date 2022-10-25 15:10:54
+   * @param {IPSAppDEUIAction} action
+   * @param {IBizContext} context
+   * @param {(IData[] | null)} data
+   * @param {IParams} params
+   * @param {(IData | undefined)} [opts]
+   * @returns {*}  {Promise<void>}
+   */
+  async doNextAction(
+    action: IPSAppDEUIAction,
+    context: IBizContext,
+    data: IData[] | null,
+    params: IParams,
+    opts?: IData | undefined,
+  ): Promise<void> {
+    const nextAction = action.getNextPSUIAction() as IPSAppDEUIAction;
+    if (nextAction) {
+      await AppDEUIActionUtil.exec(nextAction, context, data, params, opts);
+    }
+  }
+
+  /**
+   * 处理结果（刷新和关闭视图）
+   *
+   * @author lxm
+   * @date 2022-10-25 14:10:11
+   * @param {IUIActionResult} result
+   * @param {IData} neuron
+   */
+  async handleResult(result: IUIActionResult, neuron: IData): Promise<void> {
+    // *关闭引用视图,关闭后不再执行刷新
+    if (result.closeView) {
+      if (!neuron.call.closeView) {
+        throw new RuntimeError(`该视图不存在关闭视图能力`);
+      }
+      await neuron.call.closeView();
+      return;
+    }
+
+    // *刷新引用视图
+    if (result.refresh) {
+      if (!neuron.call.refresh) {
+        throw new RuntimeError(`该视图不存在刷新能力`);
+      }
+      await neuron.call.refresh();
+    }
+  }
+
+  /**
+   * 参数处理(根据数据目标和数据参数，导航参数)
+   *
+   * @author lxm
+   * @date 2022-08-29 17:08:00
+   * @protected
+   * @static
+   * @param {IPSAppDEUIAction} action 界面行为
+   * @param {IBizContext} context 上下文
+   * @param {(IData[] | null)} data 数据集合
+   * @param {IParams} params 视图参数
+   * @returns {*}  {Promise<{
+   *     resultContext: IBizContext; 处理后的上下文
+   *     resultData: IData[]; 处理后的数据集合
+   *     resultParams: IParams; 处理后的视图参数
+   *   }>}
+   */
+  protected static async handleParams(
+    action: IPSAppDEUIAction,
+    context: IBizContext,
+    data: IData[] | null,
+    params: IParams,
+  ): Promise<{
+    resultContext: IBizContext;
+    resultData: IData[];
+    resultParams: IParams;
+  }> {
+    let resultData = data || [];
+    // 数据目标不支持提示
+    if (
+      ['SINGLEDATA', 'MULTIDATA', 'MULTIKEY'].indexOf(action.actionTarget) !==
+      -1
+    ) {
+      throw new Error(
+        `数据类型${action.actionTarget}暂未支持,请配置无数据或单项数据主键`,
+      );
+    }
+
+    // 数据目标为无数据时，清空数据
+    if (action.actionTarget === 'NONE') {
+      resultData = [];
+    }
+
+    // 处理上下文导航参数
+    let tempContext = {};
+    const navContexts = action.getPSNavigateContexts() || [];
+
+    // 单项数据主键时，在导航参数开头加一个主键的导航参数，可以被配置的同名导航参数覆盖。
+    const appDataEntity = action.getPSAppDataEntity();
+    if (appDataEntity && action.actionTarget === 'SINGLEKEY') {
+      await appDataEntity?.fill(true);
+      const appDeName = appDataEntity.codeName.toLowerCase();
+      const { valueItem } = action;
+      navContexts.unshift({
+        key: appDeName,
+        value: valueItem || 'srfkey',
+        rawValue: false,
+      } as IPSNavigateContext);
+    }
+
+    if (notNilEmpty(navContexts)) {
+      tempContext = convertNavData(
+        navContexts!,
+        context,
+        params,
+        data?.[0] || {},
+      );
+    }
+    const resultContext = new IBizContext(tempContext, context);
+
+    // 处理导航视图参数
+    let resultParams: IData = {};
+    const navParams = action.getPSNavigateParams();
+    if (notNilEmpty(navParams)) {
+      resultParams = convertNavData(
+        navParams!,
+        context,
+        params,
+        data?.[0] || {},
+      );
+    }
+    return { resultContext, resultData, resultParams };
+  }
+}

package/src/utils/app-de-ui-action-util/index.ts

@@ -0,0 +1,2 @@
+export * from './handler';
+export * from './app-de-ui-action-util';

package/src/utils/index.ts

@@ -1,3 +1,3 @@
-export { AppDEUIActionUtil } from './app-de-ui-action-util/app-de-ui-action-util';
 export * from './nav-params/nav-params';
+export * from './app-de-ui-action-util';
 export { openRedirectView } from './open-redirect-view/open-redirect-view';

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

@@ -6,6 +6,7 @@ import {
   IPSAppRedirectView,
   UnsupportedModelError,
 } from '@ibiz-template/model';
+import { isNilOrEmpty, notNilEmpty } from 'qx-util';
 import { OpenAppViewCommand } from '../../command';
 import { IModalData } from '../../interface';
 import { convertNavData } from '../nav-params/nav-params';
@@ -97,25 +98,14 @@ export async function openDERedirectView(
       return { ok: false, data: [] };
     }
   }
-  // 根据参数中是否给了 srfwf 来判断是否为工作流
-  const isWf = !!params.srfwf;
-  const rdTag = await calcDERdTag(entity, appView, isWf, curData);
-  // 用于查找实际重定向视图的标识，根据不同重定向类型后续做不同处理
-  let findRdTag = rdTag;
-  if (isWf) {
-    findRdTag = `${rdTag.split(':')[0]}:${params.srfwf.toUpperCase()}`;
-  }
+  const rdTag = await calcDERdTag(entity, appView, params.srfwf, curData);
+  // 拼接当前重定向视图所在应用实体名称为前缀
+  const deRdTag = `${entity.name.toUpperCase()}:${rdTag}`;
   // 所有重定向引用视图
   const allRefViews = appView.getRedirectPSAppViewRefs();
-  let refView = allRefViews?.find(view => {
-    return view.name === findRdTag;
+  const refView = allRefViews?.find(view => {
+    return view.name === deRdTag || view.name === rdTag;
   });
-  if (!refView) {
-    findRdTag = `${rdTag.split(':')[0]}`;
-    refView = allRefViews?.find(view => {
-      return view.name === findRdTag;
-    });
-  }
   if (refView) {
     const view = refView.getRefPSAppView();
     if (view) {
@@ -140,48 +130,51 @@ export async function openDERedirectView(
  * 计算重定向标识
  *
  * @author chitanda
- * @date 2022-09-28 16:09:47
+ * @date 2022-10-25 16:10:48
  * @export
- * @param {IPSAppDERedirectView} rdView
- * @param {boolean} isWf
- * @param {IData} data
+ * @param {IPSAppDataEntity} entity 重定向视图所在应用实体
+ * @param {IPSAppDERedirectView} rdView 重定向视图
+ * @param {string} wfStep 流程步骤
+ * @param {IData} data 当前数据
  * @return {*}  {Promise<string>}
  */
 export async function calcDERdTag(
   entity: IPSAppDataEntity,
   rdView: IPSAppDERedirectView,
-  isWf: boolean,
+  wfStep: string,
   data: IData,
 ): Promise<string> {
-  const multiFormField = entity.getFormTypePSAppDEField();
-  const indexTypeField = entity.getIndexTypePSAppDEField();
-  // 重定向视图标识
   let rdTag = '';
-  // 重定向视图类别属性
+  // 重定向视图自定义类别属性
   const typeField = rdView.getTypePSAppDEField();
   // 自定义重定向
   if (typeField) {
     const value = data[typeField.codeName.toLowerCase()];
-    if (value) {
-      return value;
+    if (notNilEmpty(value)) {
+      return `RDITEM:${value}`;
     }
   }
+  // 如果流程步骤存在，按照工作流优先
+  if (notNilEmpty(wfStep)) {
+    return `EDITVIEW:${wfStep.toUpperCase()}`;
+  }
   let typeValue = '';
-  if (multiFormField) {
-    typeValue = data[multiFormField.codeName.toLowerCase()];
-  } else if (indexTypeField) {
+  // 从索引属性获取重定向视图类型
+  const indexTypeField = entity.getIndexTypePSAppDEField();
+  if (indexTypeField) {
     typeValue = data[indexTypeField.codeName.toLowerCase()];
   }
-  if (typeValue) {
-    if (isWf) {
-      rdTag = `WFEDITVIEW:${typeValue}`;
-    } else {
-      rdTag = `EDITVIEW:${typeValue}`;
+  if (isNilOrEmpty(typeValue)) {
+    // 从多表单属性判断重定向视图类型
+    const multiFormField = entity.getFormTypePSAppDEField();
+    if (multiFormField) {
+      typeValue = data[multiFormField.codeName.toLowerCase()];
     }
-  } else if (isWf) {
-    rdTag = `WFEDITVIEW:`;
+  }
+  if (notNilEmpty(typeValue)) {
+    rdTag = `EDITVIEW:${typeValue}`;
   } else {
-    rdTag = `EDITVIEW:`;
+    rdTag = `EDITVIEW`;
   }
   return rdTag;
 }