@bit-sun/business-component 2.4.29 → 2.4.31-alpha.0

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,
+  );
+};

package/src/components/Solution/RuleSetter/index.less

@@ -0,0 +1,221 @@
+.goBack_btn_content {
+  position: relative;
+  overflow: auto;
+  .goback_btn {
+    float: right;
+  }
+}
+.base_rule {
+  p {
+    margin: 0;
+  }
+
+  .base_rule_content {
+    margin-bottom: 20px;
+  }
+
+  .base_rule_line_title {
+    position: relative;
+    margin-bottom: 20px;
+    .rule_title {
+      height: 35px;
+      padding: 0 10px;
+      font-weight: bold;
+      font-size: 16px;
+      line-height: 35px;
+    }
+    .base_rule_btn_style {
+      position: absolute;
+      right: 0px;
+    }
+    //:global {
+    //    .ant-btn-link {
+    //        color: #008FE0;
+    //        border: 0px !important;
+    //        font-weight: bold;
+    //    }
+    //
+    //    .ant-btn-link:hover, .ant-btn-link:focus {
+    //        color: #008FE0;
+    //        background-color: transparent;
+    //        border-color: #008FE0;
+    //        border: 0px;
+    //    }
+    //
+    //    .ant-btn:not(.ant-btn-primary .ant-btn-danger):hover,
+    //    .ant-btn:not(.ant-btn-primary .ant-btn-danger):active,
+    //    .ant-btn:not(.ant-btn-primary .ant-btn-danger):focus {
+    //        color: #008FE0;
+    //    }
+    //}
+  }
+
+  .base_rule_line_content {
+    display: flex;
+    padding: 14px 10px 10px;
+    .base_rule_icon_btn {
+      margin-right: 10px;
+      color: #89b9cf;
+      font-size: 20px;
+    }
+
+    .base_rule_icon_btn:hover {
+      cursor: pointer;
+    }
+
+    .base_rule_item_desc_content {
+      height: 45px;
+      line-height: 45px;
+    }
+
+    .base_rule_item_desc {
+      margin-right: 15px;
+    }
+
+    .base_rule_item1 {
+      align-items: center;
+      width: 120px;
+      color: #f8ab3c;
+      font-size: 16px;
+    }
+
+    .base_rule_item2 {
+      width: 1200px;
+    }
+
+    .base_rule_item3 {
+      display: flex;
+      align-items: center;
+      justify-content: space-around;
+      width: calc(100% - 600px);
+    }
+
+    .line_color_red {
+      color: #ed869b;
+    }
+
+    .base_rule_item4 {
+      width: 80px;
+    }
+  }
+
+  .footer_line {
+    & > span {
+      color: #008fe0;
+      font-weight: bold;
+      font-size: 16px;
+    }
+  }
+}
+
+.rule_name_title {
+  display: inline-block;
+  height: 30px;
+  margin-right: 10px;
+  margin-bottom: 10px;
+  padding-left: 10px;
+  color: #f8ab3c;
+  font-size: 16px;
+  line-height: 30px;
+}
+
+.logical_operate_content {
+  position: relative;
+  .top_line {
+    position: absolute;
+    top: 0;
+    left: 50%;
+    z-index: 999;
+    width: 15px;
+    height: 2px;
+    background-color: #d6efe8;
+  }
+  .bottom_line {
+    position: absolute;
+    bottom: 0;
+    left: 50%;
+    z-index: 999;
+    width: 15px;
+    height: 2px;
+    background-color: #d6efe8;
+  }
+}
+
+.logical_operate_content::before {
+  position: absolute;
+  top: 0;
+  left: 50%;
+  z-index: 998;
+  width: 2px;
+  height: 100%;
+  overflow: hidden;
+  background: #d6efe8;
+  content: ' ';
+}
+
+.logical_item_btn {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  z-index: 999;
+  display: flex;
+  align-items: center;
+  width: 50px;
+  height: 30px;
+  margin-top: -15px;
+  margin-left: -25px;
+  padding: 0px;
+  color: #008fe0;
+  line-height: 30px;
+  text-align: center;
+  background-color: #ffffff;
+  cursor: pointer;
+}
+
+.logical_item_btn1 {
+  position: absolute;
+  bottom: 0;
+  left: 50%;
+  z-index: 999;
+  display: inline-block;
+  width: 30px;
+  height: 30px;
+  margin-left: -15px;
+  color: #008fe0;
+  line-height: 30px;
+  text-align: center;
+  background-color: #ffffff;
+  cursor: pointer;
+}
+
+.rule_field_style {
+  display: inline-block;
+}
+
+.icon_btn_style {
+  margin-right: 10px;
+  font-size: 20px;
+}
+
+.choose_logical_type {
+  height: 25px;
+  margin: 0px;
+  padding: 0 10px;
+  line-height: 25px;
+  cursor: pointer;
+}
+
+.choose_logical_type:first-child {
+  border-bottom: 1px solid #d9d9d9;
+}
+
+.choose_logical_type:hover {
+  color: white;
+  background-color: #008fe0;
+}
+
+// :global {
+//     .ant-popover-inner-content {
+//         padding: 0px;
+//     }
+// }