@bit-sun/business-component 2.4.29 → 2.4.30

package/src/components/Solution/RuleSetter/baseRule.tsx

@@ -0,0 +1,368 @@
+import React, {
+  useEffect,
+  useState,
+  forwardRef,
+  useImperativeHandle,
+  useCallback,
+  useMemo,
+} from 'react';
+import _ from 'lodash';
+import RuleObjectComponent from '../RuleComponent/index.js';
+import { Spin, Space, Modal, message } from 'antd';
+import styles from './index.less';
+// @ts-ignore
+import { history } from 'umi';
+import { request } from 'bssula';
+import {
+  handleRuleResultList,
+  handleRuleShowBack,
+  handleRuleRequireCheck,
+  getInitClassData,
+} from './function';
+
+export default forwardRef((props: any, ref) => {
+  const {
+    scenceParams,
+    operationList = [],
+    regularDataList = [],
+    baseRuleDetailList = [],
+    systemVariableList = [],
+    defRuleDetail = {},
+  } = props;
+  const sceneId = scenceParams?.sceneId;
+  const sceneName = scenceParams?.sceneName;
+  const type = scenceParams?.type;
+  const ruleGroupList = scenceParams?.ruleGroupList;
+  const isGetDefRuleDataRes = scenceParams?.isGetDefRuleDataRes;
+  const isGetRuleDataRes = scenceParams?.isGetRuleDataRes;
+  const groupOtherPriorityList = scenceParams?.groupOtherPriorityList;
+  const extStrField01 = scenceParams?.extStrField01;
+  const instanceName = scenceParams?.instanceName;
+
+  const initialThresholdQuery = {};
+
+  const [loading, setLoading] = useState(false);
+  const [baseClassData, setBaseClassData] = useState<any>([]);
+  const [callbackData, setCallbackData] = useState<any>([]);
+  const [ruleTypeData, setRuleTypeData] = useState<any>([]);
+  const [ruleReturnConfig, setRuleReturnConfig] = useState<any>({});
+  const [templateData, setTemplateData] = useState<any>({});
+
+  const loadRuleReturnConfig = (currentSceneId: string) => {
+    request({
+      url: `/basic/ruleTemplate/${currentSceneId}`,
+      method: 'GET',
+      converter: (res: any) => {
+        return res;
+      },
+    })
+      .then(({ response }: any) => {
+        const rRConfig =
+          (response?.data?.ext && JSON.parse(response?.data?.ext)?.config) ||
+          {};
+        setRuleReturnConfig(rRConfig);
+      })
+      .catch(() => {});
+  };
+
+  const loadRuleConfigList = (currentSceneId: string) => {
+    request({
+      url: '/basic/ruleTemplate/result',
+      method: 'GET',
+      convertParams: () => {
+        return {
+          templateId: currentSceneId,
+        };
+      },
+      converter: (res: any) => {
+        return res;
+      },
+    })
+      .then(({ response }: any) => {
+        const functionRuleConfigList =
+          (Array.isArray(response?.data) &&
+            response?.data?.length &&
+            response.data.map((i: any) => {
+              const item = { ...i };
+              const ruleConfigList =
+                (Array.isArray(i.valueList) &&
+                  i.valueList?.length &&
+                  i.valueList.map((s: any) => JSON.parse(s))) ||
+                [];
+              if (ruleConfigList?.length) {
+                item.valueList = ruleConfigList.sort(
+                  (a: any, b: any) => a.priority - b.priority,
+                );
+              }
+              return item;
+            })) ||
+          [];
+        setRuleTypeData(functionRuleConfigList);
+      })
+      .catch(() => {});
+  };
+
+  useEffect(() => {
+    if (sceneId) {
+      loadRuleReturnConfig(sceneId);
+      loadRuleConfigList(sceneId);
+    }
+  }, [sceneId]);
+
+  const defRuleDetailId = defRuleDetail?.id;
+  const baseRuleDetailListFirstId = baseRuleDetailList?.[0]?.id;
+  // 处理规则设计器/规则实例 差异
+  const handleDiff = () => {
+    let diffResult: any = {};
+    if (!type) {
+      diffResult = {
+        title: `规则设计器${sceneName ? `【${sceneName}】` : ''}`,
+        onlyOneRule: true,
+        ruleList: (defRuleDetailId && [defRuleDetail]) || [],
+      };
+    }
+    if (type == 'instance') {
+      diffResult = {
+        title: sceneName || '规则实例',
+        onlyOneRule: false,
+        ruleList:
+          baseRuleDetailList?.sort(
+            (a: any, b: any) => a.priority - b.priority,
+          ) || [],
+      };
+    }
+    return diffResult;
+  };
+  const ruleList = useMemo(() => {
+    const rList = handleDiff().ruleList;
+    return rList;
+  }, [defRuleDetailId, baseRuleDetailListFirstId]);
+
+  const isTemplateRuleEdit = ruleList?.length;
+
+  useEffect(() => {
+    // 新增设计器模板
+    if (isGetDefRuleDataRes && !defRuleDetailId && !type) {
+      const initData = getInitClassData(ruleTypeData);
+      setCallbackData(initData);
+      setBaseClassData(initData);
+    }
+    // 新增规则实例
+    if (
+      isGetRuleDataRes &&
+      isGetDefRuleDataRes &&
+      !baseRuleDetailList?.[0]?.id &&
+      type == 'instance'
+    ) {
+      const templateList =
+        (defRuleDetail && defRuleDetailId && [defRuleDetail]) || [];
+      const isExitTemplateOne = templateList?.length;
+      const temp = handleRuleShowBack(
+        _.cloneDeep(templateList),
+        ruleTypeData,
+      )[0];
+      const templateInitOne = [_.omit(_.cloneDeep(temp), ['id', 'ruleId'])]; // 自动显示一条规则实例不能过滤ruleName，防止删除报错
+      const initData = isExitTemplateOne
+        ? templateInitOne
+        : getInitClassData(ruleTypeData);
+      setCallbackData(initData);
+      setBaseClassData(initData);
+    }
+
+    // 编辑
+    if (isTemplateRuleEdit) {
+      const newData = handleRuleShowBack(ruleList, ruleTypeData);
+      setCallbackData(newData);
+      setBaseClassData(newData);
+    }
+    // 设置规则实例模板数据
+    if (defRuleDetailId && type == 'instance') {
+      const templateList = (defRuleDetailId && [defRuleDetail]) || [];
+      const isExitTemplateOne = templateList?.length;
+      if (isExitTemplateOne) {
+        const temp = handleRuleShowBack(
+          _.cloneDeep(templateList),
+          ruleTypeData,
+        )[0];
+        setTemplateData(
+          _.omit(_.cloneDeep(temp), ['id', 'ruleId', 'ruleName']),
+        ); // 设置默认模板数据需要带上ruleName，因为这个ruleName不准确，在点击新增按钮还会重新生成
+      }
+    }
+  }, [
+    isTemplateRuleEdit,
+    ruleTypeData?.length,
+    isGetDefRuleDataRes,
+    isGetRuleDataRes,
+  ]);
+
+  const upDateData = (newData: any) => {
+    const upNewData = _.cloneDeep(newData);
+    setCallbackData(upNewData);
+    const handleBaseClassData = upNewData.map((item: any, index: string) => {
+      const itemData = {
+        ...item,
+        extraInfo: {
+          response: {
+            inputType: item?.extraInfo?.response?.inputType,
+            formulaName: item?.extraInfo?.response?.formulaName,
+            enable: item?.extraInfo?.response?.enable !== false,
+            value: item?.extraInfo?.response?.value || '',
+          },
+          execute: ruleTypeData.map((s: any) => {
+            const mItem = (item?.extraInfo?.execute || []).find(
+              (u: any) => u.code === s.code,
+            );
+            if (mItem) {
+              return mItem;
+            }
+            return {
+              priority: 1,
+              code: s.code,
+              properties: {
+                configPropertyCode: 'configPropertyValue',
+              },
+            };
+          }),
+        },
+      };
+      return itemData;
+    });
+    setBaseClassData(handleBaseClassData);
+  };
+
+  const handleSave = (needCheckOnlyOne: boolean = false) => {
+    const ruleResultList = handleRuleResultList(callbackData, ruleTypeData);
+    if (needCheckOnlyOne && ruleResultList?.length === 0) {
+      message.warning('请至少配置一个规则！');
+      return Promise.reject();
+    }
+    const actionRequiredCheckObject = handleRuleRequireCheck(
+      ruleResultList,
+      ruleTypeData,
+    );
+    if (actionRequiredCheckObject?.checkResult) {
+      const modal = Modal.warning({
+        title: '保存校验提示',
+        content: actionRequiredCheckObject.checkInfo.map((i: any) => (
+          <div>{i}</div>
+        )),
+      });
+      setTimeout(() => {
+        modal.destroy();
+      }, 10000);
+      return;
+    }
+
+    // setLoading(true);
+
+    // 兼容没有规则组的情况
+    const params = ruleGroupList?.length
+      ? ruleGroupList.map((groupItem: any) => ({
+          ruleDetailList: ruleResultList.map((i: any) => ({
+            ...i,
+            status: i.status || 0, // 状态：0-待发布，1-已发布，2-停用
+            ruleId: groupItem.id,
+            templateId: sceneId, // 模板id
+            ...(extStrField01
+              ? { extStrField01: extStrField01 || i?.extStrField01 }
+              : {}),
+            ...(instanceName ? { name: instanceName || i?.name } : {}),
+          })),
+          ...(extStrField01 ? { extStrField01 } : {}),
+          ruleId: groupItem.id,
+          templateId: sceneId,
+        }))
+      : [
+          {
+            ruleDetailList: ruleResultList.map((i: any) => ({
+              ...i,
+              status: i.status || 0,
+              templateId: sceneId,
+              ...(extStrField01
+                ? { extStrField01: extStrField01 || i?.extStrField01 }
+                : {}),
+              ...(instanceName ? { name: instanceName || i?.name } : {}),
+            })),
+            ...(extStrField01 ? { extStrField01 } : {}),
+            templateId: sceneId,
+          },
+        ];
+
+    const handleUrl = `/basic/ruleDetail/addAndUpdate`;
+    const handleMethod = 'POST';
+
+    return request({
+      url: handleUrl,
+      method: handleMethod,
+      convertParams: () => {
+        return params;
+      },
+      converter: (res: any) => {
+        return res;
+      },
+    });
+    // .then(({ response }: any) => {
+    //   setLoading(false);
+    //   if (handleError(response)) {
+    //     message.success('保存成功');
+    //     !type ? loadDefRuleData(sceneId) : loadRuleData(sceneId,extStrField01);
+    //   }
+    // })
+    // .catch(() => {
+    //   setLoading(false);
+    // });
+  };
+
+  useImperativeHandle(ref, () => ({
+    handleSave,
+  }));
+
+  return (
+    <Spin spinning={loading}>
+      <div className={styles.base_rule}>
+        <div className={styles.base_rule_content}>
+          <p className={styles.base_rule_line_title}>
+            <span className={styles.rule_title}>{handleDiff()?.title}</span>
+            <p style={{ float: 'right' }} />
+          </p>
+          <div>
+            {/* @ts-ignore */}
+            {sceneId ? (<RuleObjectComponent
+                {...props?.RuleObjectComponentProps}
+                onlyOneRule={handleDiff()?.onlyOneRule}
+                ruleGroupInfo={{
+                  ruleGroupList,
+                  type,
+                  templateData,
+                  groupOtherPriorityList,
+                }}
+                ruleClassData={baseClassData}
+                initialThresholdQuery={initialThresholdQuery}
+                ruleTypeData={ruleTypeData}
+                ruleReturnConfig={ruleReturnConfig}
+                operationList={operationList}
+                regularDataList={regularDataList}
+                systemVariableList={systemVariableList}
+                callBack={(newData: any) => {
+                  upDateData(newData);
+                }}
+              />
+            ) : (
+              <div style={{ padding: 20 }}>
+                请先选择
+                <a
+                  onClick={() =>
+                    history.push('/rules-center/rules-of-the-scene')
+                  }
+                >
+                  模板
+                </a>
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    </Spin>
+  );
+});

package/src/components/Solution/RuleSetter/function.ts

@@ -0,0 +1,336 @@
+// expression规则集合
+//{
+// complex,
+// dataTypeCode,
+// elementId,
+// elementName,
+// metaObjectCode,
+// operationCode,
+// operationType,
+// paramNames: [],
+// params: [],
+// propertyPath,
+// subExpression: [
+//   complex,
+//   dataTypeCode,
+//   elementId,
+//   elementName,
+//   metaObjectCode,
+//   operationCode,
+//   operationType,
+//   paramNames: [],
+//   params: [],
+//   propertyPath,
+//   subExpression: [.....] // 继续嵌套
+// ]
+// }
+// result 执行返回值/执行动作
+//{
+//     "return": {
+//         "enable": true,
+//         "value": "ticketId"
+//     },
+//     "execute": [
+//         {
+//             "priority": 1,
+//             "code": "functionCode",
+//             "properties": {
+//                 "${logisticsNum}": "dasdadasdadas"
+//             }
+//         },
+//         {
+//             "priority": 2,
+//             "code": "",
+//             "properties": {
+//                 "${detailList.skuCode}": "ccxcx",
+//                 "${logisticsNum}": "cxcxcx"
+//             }
+//         }
+//     ]
+// }
+export const formatOperationList = (data: any) => {
+  let result = data||[];
+  result = result.concat([{
+    code: 32,
+    name: 'dateTime',
+    operationList: result.find((s: any)=> s.code ==41)?.operationList || []
+  }])
+  // 新版基础中对象字段编码valueType和旧版中valueType枚举不一致，如果没有取到符号值--需要排查数据后端是否做了映射转化; 按照oldValueType进行匹配符号和第三个参数框的
+  // const oldValueType = Object.freeze({
+  //   10: '对象',
+  //   21: '字符串',
+  //   23: '长整数',
+  //   22: '小数',
+  //   41: '日期',
+  //   40: '时间',
+  //   30: '数组',
+  //   24: '布尔值',
+  // });
+  // const newValueType = {
+  //   10: '字符串',
+  //   20: '短整数',
+  //   21: '长整数',
+  //   22: '小数',
+  //   40: '数组',
+  //   41: '布尔值',
+  //   12: '富文本',
+  //   30: '日期',
+  //   31: '时间',
+  //   32: '日期时间',
+  // }
+  return result;
+};
+
+export const formatRegularList = (data: any) => {
+  let result = data;
+  return result;
+};
+
+// 回显规则处理数据
+export const handleRuleShowBack = (data: any, functionRuleList: any) => {
+  let result = data?.map((item: any, index: number) => {
+    const handleResult = {
+      response: {
+        inputType: item?.result?.response?.inputType,
+        formulaName: item?.result?.response?.formulaName,
+        enable: item?.result?.response?.enable !== false,
+        value: item?.result?.response?.value || '',
+      },
+      execute:
+        (functionRuleList?.length &&
+          functionRuleList.map((s: any, index: number) => {
+            const Item = (item?.result?.execute || []).find(
+              (u: any) => u.code === s.code,
+            );
+            if (Item) {
+              return {
+                ...Item,
+                properties: Item?.frontendProperties || Item?.properties,
+                isSelected: true,
+              };
+            }
+            return {
+              priority: index + 1,
+              code: s.code,
+              properties: {
+                configPropertyCode: 'configPropertyValue',
+              },
+            };
+          })) ||
+        [],
+    };
+    const restObject = {
+      extraInfo: handleResult,
+      id: item.id,
+      ruleId: item.ruleId,
+      priority: item.priority,
+      status: item.status,
+      extStrField01: item?.extStrField01,
+      name: item?.name,
+    };
+    if (item?.expression) {
+      return {
+        ruleName: item.ruleName || `规则${index + 1}`,
+        subExpression: item.expression,
+        ...restObject,
+      };
+    } else {
+      return {
+        ruleName: `规则${index + 1}`,
+        subExpression: {
+          expressionType: 'relation',
+          operationType: 'relation',
+          propertyPath: '',
+          params: [],
+          paramNames: [],
+        },
+        ...restObject,
+      };
+    }
+  });
+  return result;
+};
+
+const isNoEmpty = (data: any) =>
+  (Array.isArray(data) && data.length > 0) ||
+  !(data == null || data == undefined || String(data).trim() == '');
+
+// 校验执行动作必填数据
+export const handleRuleRequireCheck = (saveData: any, ruleActionData: any) => {
+  let checkResult = false; // 默认通过校验
+  const checkInfo: any = []; // 没有选必填执行动作(暂不考虑)；执行动作下的对象未选
+  if (Array.isArray(ruleActionData) && ruleActionData?.length && Array.isArray(saveData) && saveData.length) {
+    let requireList: any = [];
+    ruleActionData.forEach((s: any) => {
+      s.valueList.forEach((n: any) => {
+        if (n.required) {
+          if (requireList.some((m: any) => m.functionCode === s.code)) {
+            requireList = requireList.map((k: any) => {
+              if (k.functionCode === s.code) {
+                k.propertiesCode = [...k.propertiesCode, ...n.code];
+              }
+              return k;
+            });
+          } else {
+            requireList.push({
+              functionCode: s.code,
+              functionName: s.functionName,
+              propertiesCode: [n.code],
+            });
+          }
+        }
+      });
+    });
+
+    requireList?.length &&
+      saveData.forEach((s: any, index: number) => {
+        s.result.execute.length &&
+          s.result.execute.forEach((e: any) => {
+            if (requireList.some((r: any) => r.functionCode === e.code)) {
+              const currentRequireList = requireList.find(
+                (r: any) => r.functionCode === e.code,
+              );
+              const currentPropertiesCode = currentRequireList.propertiesCode;
+              const isComplete = currentPropertiesCode.every((c: any) =>
+                Object.keys(e.properties).some(
+                  (p: any) => p === c && isNoEmpty(e.properties[p]),
+                ),
+              );
+              if (!isComplete) {
+                checkResult = true;
+                checkInfo.push(
+                  `规则${index + 1}: 执行动作【${
+                    currentRequireList.functionName
+                  }】信息填写不完整`,
+                );
+              }
+            }
+          });
+      });
+  }
+  return { checkResult, checkInfo };
+};
+
+function isObj(object: any) {
+  return (
+    object &&
+    typeof object == 'object' &&
+    Object.prototype.toString.call(object).toLowerCase() == '[object object]'
+  );
+}
+
+// 保存规则处理数据
+export const handleRuleResultList = (data: any, ruleTypeData: any) => {
+  let result = data || [];
+  if (Array.isArray(result) && result?.length) {
+    result = result.map((i: any) => {
+      return {
+        expression: i?.subExpression, // 左侧规则
+        result: {
+          ...i?.extraInfo,
+          ...(i?.extraInfo.execute
+            ? {
+                execute: i?.extraInfo.execute
+                  .filter((s: any) => s.isSelected)
+                  ?.map((s: any) => {
+                    const saveP = s.properties;
+                    // 处理在执行动作配置中设置了默认值的
+                    const ruleValueList = ruleTypeData.find(
+                      (r: any) => r.code === s.code,
+                    )?.valueList;
+                    if (ruleValueList?.length) {
+                      ruleValueList.forEach((r: any) => {
+                        if (
+                          r.defaultValue &&
+                          r?.inputType === 10 &&
+                          r?.valueType === 21 &&
+                          saveP[r.code] === undefined
+                        ) {
+                          saveP[r.code] = ' ';
+                        } else if (r.defaultValue && !saveP[r.code]) {
+                          saveP[r.code] = r.defaultValue;
+                        }
+                      });
+                    }
+
+                    delete saveP.configPropertyCode;
+                    // 前端所需回显数据
+                    s.frontendProperties = { ...s.properties };
+                    // 格式化后端需要的数据
+                    Object.keys(s.properties).forEach((p: any) => {
+                      const v = s.properties[p];
+                      if (Array.isArray(v)) {
+                        s.properties = {
+                          ...s.properties,
+                          [p]: v.map((m: any) => m.value || m).join(','),
+                        };
+                      }
+                      if (isObj(v)) {
+                        s.properties = {
+                          ...s.properties,
+                          [p]: v.value || v.PCDCode?.join('/'),
+                        };
+                      }
+                    });
+                    return s;
+                  }),
+              }
+            : {}),
+        }, // 右侧信息
+        ruleName: i.ruleName,
+        ruleId: i.ruleId,
+        id: i.id,
+        priority: i.priority,
+        status: i.status,
+        extStrField01: i?.extStrField01,
+        name: i?.name,
+      };
+    });
+  }
+  return result;
+};
+
+export const getInitClassData = (ruleTypeData: any) => {
+  const initClassData = [
+    {
+      ruleName: `规则1`,
+      subExpression: {
+        // "expressionType": "relation",
+        operationType: 'relation',
+        propertyPath: '',
+        params: [],
+        paramNames: [],
+      },
+      extraInfo: {
+        response: {
+          enable: false,
+          value: '',
+        },
+        execute: ruleTypeData?.map((s: any) => {
+          return {
+            priority: 1,
+            code: s.code,
+            properties: {
+              configPropertyCode: 'configPropertyValue',
+            },
+          };
+        }),
+      },
+    },
+  ];
+  return initClassData;
+};
+
+export const formatGroupOtherPriorityList = (data: any, templateId: string) => {
+  const result = data.filter((i: any) => i.templateId !== templateId);
+  return result;
+};
+export const formatOtherPriorityList = (
+  data: any,
+  templateId: string,
+  extStr: string,
+) => {
+  return data.filter(
+    (i: any) => i.templateId != templateId || i.extStrField01 != extStr,
+  );
+};