super-page-runtime 2.0.9 → 2.0.13

package/dist/es/components/runtime/utils/api/api-util.d.ts

@@ -4,8 +4,13 @@
  * @param customRules  自定义的校验规则
  */
 export declare function setCustomRules(pageContext: any, customRules: any): void;
+/**
+ * 刷新页面
+ * @param pageContext
+ */
+export declare function refreshPage(pageContext: any): void;
 /**
  * 获得表单数据
  * @param pageContext
  */
-export declare function getData(pageContext: any): Promise<unknown>;
+export declare function getFormData(pageContext: any): Promise<unknown>;

package/dist/es/components/runtime/utils/api/api-util.js

@@ -3,7 +3,14 @@ import { getSessionCache } from "agilebuilder-ui/src/utils/auth";
 import http from "agilebuilder-ui/src/utils/request";
 import { getBaseUrl } from "../common-util.js";
 import { dealCompleteTaskParam } from "../events/standard-event.js";
-function getData(pageContext) {
+import { packageCustomRules, getWorkflowRules } from "../events/validator-util.js";
+import { handleEvent } from "../events/event-util.js";
+function refreshPage(pageContext) {
+  getFormData(pageContext).then((commonEntity) => {
+    pageContext.isRefresh = true;
+  });
+}
+function getFormData(pageContext) {
   const pageType = pageContext.pageType;
   if (pageType && pageType === "form") {
     console.log("获取表单数据getData--pageContext=", pageContext);
@@ -64,6 +71,23 @@ function getCommonFormData(pageContext) {
         pageContext.entity.data = commonEntity.entity;
         pageContext.initFormNo = commonEntity.formNo;
       }
+      const customRules = pageContext.customRules;
+      let formRules = pageContext.rules;
+      const newFormRules = packageCustomRules(customRules, formRules);
+      pageContext.rules = newFormRules;
+      const pageDesign = {
+        runtime: { events: pageContext.events },
+        systemCode: "",
+        systemVersion: 0,
+        code: "",
+        version: 0,
+        workflowCode: "",
+        workflowVersion: 0,
+        name: "",
+        uuid: "",
+        label: ""
+      };
+      handleEvent(null, pageContext, pageDesign, "load");
       resolve(commonEntity);
     }).catch((error) => {
       reject(error);
@@ -117,12 +141,126 @@ function getWorkflowFormData(pageContext) {
       pageContext.definitionId = commonEntity.definitionId;
       pageContext.entity.task = commonEntity.taskParamMap;
       dealCompleteTaskParam(commonEntity, true, pageContext);
+      pageContext.workflowRules = getWorkflowRules(pageContext);
+      const pageType = pageContext.pageType;
+      if (pageType && pageType === "form") {
+        changePermissionListToMap(pageContext);
+        const pageDesign = {
+          runtime: { events: pageContext.events },
+          systemCode: "",
+          systemVersion: 0,
+          code: "",
+          version: 0,
+          workflowCode: "",
+          workflowVersion: 0,
+          name: "",
+          uuid: "",
+          label: ""
+        };
+        handleEvent(null, pageContext, pageDesign, "load");
+      }
       resolve(commonEntity);
     }).catch((error) => {
       reject(error);
     });
   });
 }
+function changePermissionListToMap(pageContext) {
+  changeFieldPermissionToMap(pageContext);
+  changeActionPermissionToMap(pageContext);
+}
+function changeFieldPermissionToMap(pageContext) {
+  let fieldPermissionMap = pageContext.fieldPermissionMap;
+  pageContext.actionPermissionMap;
+  const fieldPermissions = pageContext.fieldPermissions;
+  if (fieldPermissionMap === null) {
+    fieldPermissionMap = /* @__PURE__ */ new Map();
+  }
+  if (typeof fieldPermissions !== "undefined") {
+    for (let i = 0; i < fieldPermissions.length; i++) {
+      const prop = fieldPermissions[i].name;
+      if (prop) {
+        if (prop.indexOf("$") === 0 && prop.indexOf(".") > 0) {
+          const fieldPermissionOrg = fieldPermissions[i];
+          const fieldPermission = JSON.parse(JSON.stringify(fieldPermissionOrg));
+          const subModelName = prop.substring(1, prop.indexOf("."));
+          const subProp = prop.substring(prop.indexOf(".") + 1);
+          fieldPermission.name = subProp;
+          if (fieldPermission && fieldPermission.name === "all_fields") {
+            if (fieldPermission.canEdit === false) {
+              if (fieldPermission.rowIndexes) {
+                fieldPermissionMap.set(subModelName, [
+                  {
+                    name: "all_fields",
+                    canEdit: false,
+                    rowIndexes: fieldPermission.rowIndexes
+                  }
+                ]);
+              } else {
+                fieldPermissionMap.set(subModelName, [{ name: "all_fields", canEdit: false }]);
+              }
+            } else {
+              if (fieldPermission.rowIndexes) {
+                fieldPermissionMap.set(subModelName, [
+                  {
+                    name: "all_fields",
+                    canEdit: true,
+                    rowIndexes: fieldPermission.rowIndexes
+                  }
+                ]);
+              } else {
+                fieldPermissionMap.set(subModelName, [{ name: "all_fields", canEdit: true }]);
+              }
+            }
+          } else {
+            let subTableFieldPermission = fieldPermissionMap.get(subModelName);
+            if (subTableFieldPermission) {
+              subTableFieldPermission.push(fieldPermission);
+            } else {
+              subTableFieldPermission = [];
+              subTableFieldPermission.push(fieldPermission);
+            }
+            fieldPermissionMap.set(subModelName, subTableFieldPermission);
+          }
+        } else {
+          fieldPermissionMap.set(prop, fieldPermissions[i]);
+        }
+      }
+    }
+  }
+  pageContext.fieldPermissionMap = fieldPermissionMap;
+}
+function changeActionPermissionToMap(pageContext) {
+  let fieldPermissionMap = pageContext.fieldPermissionMap;
+  let actionPermissionMap = pageContext.actionPermissionMap;
+  const actionPermissions = pageContext.actionPermissions;
+  if (typeof actionPermissions !== "undefined" && actionPermissions !== null) {
+    const subModelNames = Object.keys(actionPermissions);
+    subModelNames.forEach((subModelName) => {
+      const oneTableActionPermission = actionPermissions[subModelName];
+      const subTableFieldPermission = fieldPermissionMap.get(subModelName);
+      if (subTableFieldPermission && subTableFieldPermission.length > 0 && subTableFieldPermission[0].name === "all_fields" && subTableFieldPermission[0].canEdit === false) {
+        oneTableActionPermission.canUpdate = false;
+        oneTableActionPermission.canAdd = false;
+      } else {
+        const canUpdate = oneTableActionPermission.canUpdate;
+        const updateRowIndexes = oneTableActionPermission.updateRowIndexes;
+        if (canUpdate !== void 0 && canUpdate === false && updateRowIndexes !== void 0 && updateRowIndexes !== null && updateRowIndexes.length > 0) {
+          fieldPermissionMap.set(subModelName, [
+            {
+              name: "all_fields",
+              canEdit: false,
+              rowIndexes: updateRowIndexes
+            }
+          ]);
+        }
+      }
+      actionPermissionMap.set(subModelName, oneTableActionPermission);
+    });
+  }
+  pageContext.actionPermissionMap = actionPermissionMap;
+}
 export {
-  getData
+  getFormData,
+  refreshPage
 };

package/dist/es/components/runtime/utils/charts/chart-columnline-util.js

@@ -0,0 +1,279 @@
+import { getValueFromSource, formatVariableValue, setValueForVariableName } from "../page-helper-util.js";
+import { deepCopy } from "../common-util.js";
+import { CommonName, sortDatas, limitDatas } from "./chart-util.js";
+function updateChartOption(pageContext, configure, chartOption, resultData) {
+  if (!resultData || !resultData.result) {
+    return;
+  }
+  const result = resultData && resultData.result ? resultData.result : {};
+  const groupValue = resultData && resultData.groupValue ? resultData.groupValue : [];
+  const dataSetField = configure.serviceDataField;
+  let datas = null;
+  if (dataSetField) {
+    datas = result[dataSetField];
+  } else {
+    if (result) {
+      if (Array.isArray(result)) {
+        datas = result;
+      } else {
+        datas = [result];
+      }
+    }
+  }
+  if (!datas) {
+    datas = [];
+  }
+  let confGroups = configure.props ? configure.props.groups : null;
+  if (!confGroups) {
+    confGroups = [];
+  }
+  const groupMap = {};
+  const groupFields = [];
+  const realGroupFilds = [];
+  for (let g of confGroups) {
+    groupMap[g.group] = g.target;
+    if (g.target && !groupFields.includes(g.target)) {
+      groupFields.push(g.target);
+      if (groupValue.includes(g.group)) {
+        realGroupFilds.push(g.target);
+      }
+    }
+  }
+  let mulGroupShow = configure.props ? configure.props.mulGroupShow : "";
+  mulGroupShow = mulGroupShow == "break" ? "\r\n" : " ";
+  for (let d of datas) {
+    if (!d) {
+      continue;
+    }
+    const xValues2 = [];
+    for (let g of groupValue) {
+      const fieldName = groupMap[g];
+      const value = getValueFromSource(d, fieldName, void 0);
+      if (value) {
+        xValues2.push(value);
+      }
+    }
+    const xValue = xValues2.join(mulGroupShow);
+    d[CommonName.X_FIELD_NAME] = xValue;
+  }
+  const itemConfs = configure.items ? configure.items : [];
+  const serieValues = [];
+  const serieValueMap = {};
+  const dynamicFileds = [];
+  const dynamicValueField = {};
+  const allValueFields = [];
+  const limitValueFields = [];
+  for (let item of itemConfs) {
+    const itemProps = item.props ? item.props : {};
+    const sourceType = itemProps.yaxisSource;
+    const yaxisField = itemProps.yaxisField;
+    const isCumulative = itemProps.isCumulative;
+    let serieValue = null;
+    if (yaxisField && (!sourceType || sourceType == "variable")) {
+      serieValue = {
+        uuid: item.uuid,
+        type: "variable",
+        field: yaxisField,
+        isCumulative,
+        data: [],
+        dynamicDatas: []
+        //动态系列数据
+      };
+      if (yaxisField && !allValueFields.includes(yaxisField)) {
+        allValueFields.push(yaxisField);
+        limitValueFields.push(yaxisField);
+      }
+    } else {
+      serieValue = {
+        uuid: item.uuid,
+        type: "fixed",
+        field: itemProps.yaxisFix,
+        data: [],
+        dynamicDatas: []
+        //动态系列数据
+      };
+    }
+    if (serieValue != null) {
+      serieValues.push(serieValue);
+      serieValueMap[item.uuid] = serieValue;
+    }
+    if (itemProps.dynamicSeriesField && // !groupFields.includes(itemProps.dynamicSeriesField) &&
+    !dynamicFileds.includes(itemProps.dynamicSeriesField) && serieValue && yaxisField) {
+      serieValue.dynamicField = itemProps.dynamicSeriesField;
+      serieValue.dynamicSeriesTitle = itemProps.dynamicSeriesTitle;
+      serieValue.dynamicShowStack = itemProps.dynamicShowStack;
+      dynamicFileds.push(itemProps.dynamicSeriesField);
+      dynamicValueField[itemProps.dynamicSeriesField] = yaxisField;
+    }
+  }
+  const dynamicLabelMap = {};
+  if (dynamicFileds.length > 0) {
+    const newDatas = [];
+    const dataMap = {};
+    for (let d of datas) {
+      if (!d) {
+        continue;
+      }
+      for (let valueField of allValueFields) {
+        const groupValue2 = d[CommonName.X_FIELD_NAME];
+        let newData = dataMap[groupValue2];
+        if (!newData) {
+          newData = {};
+          for (let gField of groupFields) {
+            newData[gField] = d[gField];
+          }
+          newData[CommonName.X_FIELD_NAME] = d[CommonName.X_FIELD_NAME];
+          dataMap[groupValue2] = newData;
+          newDatas.push(newData);
+        }
+        let newValue = getValueFromSource(d, valueField, void 0);
+        if (!isNaN(newValue)) {
+          const hisValue = newData[valueField];
+          if (!isNaN) {
+            newValue += hisValue;
+          }
+          newData[valueField] = newValue;
+        }
+      }
+    }
+    for (let dynamicField of dynamicFileds) {
+      const dynamicLabels = [];
+      for (let d of datas) {
+        if (!d) {
+          continue;
+        }
+        const groupValue2 = d[CommonName.X_FIELD_NAME];
+        let newData = dataMap[groupValue2];
+        if (!newData) {
+          continue;
+        }
+        let dynamicLabel = getValueFromSource(d, dynamicField, void 0);
+        dynamicLabel = dynamicLabel == null || dynamicLabel == void 0 ? "" : dynamicLabel;
+        if (!dynamicLabels.includes(dynamicLabel)) {
+          dynamicLabels.push(dynamicLabel);
+          limitValueFields.push(dynamicLabel);
+        }
+        const valueField = dynamicValueField[dynamicField];
+        let newValue = getValueFromSource(d, valueField, void 0);
+        if (!isNaN(newValue)) {
+          const hisValue = newData[dynamicLabel];
+          if (!isNaN) {
+            newValue += hisValue;
+          }
+          newData[dynamicLabel] = newValue;
+        }
+      }
+      dynamicLabelMap[dynamicField] = dynamicLabels;
+    }
+    datas = newDatas;
+  }
+  sortDatas(pageContext, configure, datas);
+  datas = limitDatas(pageContext, configure, datas, groupFields, limitValueFields);
+  const xValues = [];
+  const cumulativeMap = {};
+  for (let data of datas) {
+    if (!data) {
+      continue;
+    }
+    xValues.push(data[CommonName.X_FIELD_NAME]);
+    for (let item of serieValues) {
+      let serieData = item.data;
+      const dynamicDatas = item.dynamicDatas;
+      if (item.dynamicField) {
+        let dynamicLabels = dynamicLabelMap[item.dynamicField];
+        dynamicLabels = dynamicLabels ? dynamicLabels : [];
+        for (let i = 0; i < dynamicLabels.length; i++) {
+          if (i >= dynamicDatas.length) {
+            dynamicDatas.push([]);
+          }
+          serieData = dynamicDatas[i];
+          const fieldName = dynamicLabels[i];
+          let value = getValueFromSource(data, fieldName, void 0);
+          if (item.isCumulative) {
+            const hisKey = item.uuid + "_" + fieldName;
+            const hisValue = cumulativeMap[hisKey];
+            if (hisValue) {
+              value = hisValue + value;
+            }
+            cumulativeMap[hisKey] = value;
+          }
+          serieData.push(value);
+        }
+      } else if (item.type == "fixed") {
+        serieData.push(item.field);
+      } else if (item.type == "variable") {
+        let value = getValueFromSource(data, item.field, void 0);
+        if (item.isCumulative) {
+          const hisKey = item.uuid + "_field";
+          const hisValue = cumulativeMap[hisKey];
+          if (hisValue) {
+            value = hisValue + value;
+          }
+          cumulativeMap[hisKey] = value;
+        }
+        serieData.push(value);
+      } else {
+        serieData.push(void 0);
+      }
+    }
+  }
+  const defaultSeries = configure.defaultSeries;
+  const tempSeries = deepCopy(defaultSeries == null ? [] : defaultSeries);
+  const newSeries = [];
+  for (let serie of tempSeries) {
+    const serieValue = serieValueMap[serie.uuid];
+    if (serieValue.dynamicField) {
+      let dynamicLabels = dynamicLabelMap[serieValue.dynamicField];
+      dynamicLabels = dynamicLabels ? dynamicLabels : [];
+      const dynamicDatas = serieValue.dynamicDatas ? serieValue.dynamicDatas : [];
+      for (let i = 0; i < dynamicLabels.length; i++) {
+        let label = dynamicLabels[i];
+        const newSerie = deepCopy(serie);
+        if (serieValue.dynamicSeriesTitle) {
+          const dynamicSeriesTitle = serieValue.dynamicSeriesTitle.replace("${name}", label);
+          newSerie.name = formatVariableValue(pageContext, dynamicSeriesTitle);
+        } else {
+          newSerie.name = label;
+        }
+        newSerie.data = i < dynamicDatas.length ? dynamicDatas[i] : [];
+        if (serie.type == "bar" && serieValue.dynamicShowStack) {
+          newSerie.stack = serie.uuid;
+        }
+        newSeries.push(newSerie);
+      }
+    } else {
+      serie.data = serieValue ? serieValue.data : [];
+      newSeries.push(serie);
+    }
+  }
+  chartOption.series = newSeries;
+  const defaultXaxis = configure.defaultXaxis;
+  const defaultYaxis = configure.defaultYaxis;
+  if (chartOption.isBar) {
+    if (defaultYaxis) {
+      for (let tempYaxis of defaultYaxis) {
+        tempYaxis.data = xValues;
+      }
+    }
+    chartOption.xAxis = defaultXaxis;
+    chartOption.yAxis = defaultYaxis;
+  } else {
+    if (defaultXaxis && defaultXaxis.length > 0) {
+      defaultXaxis[0].data = xValues;
+    }
+    chartOption.xAxis = defaultXaxis;
+    chartOption.yAxis = defaultYaxis;
+  }
+  const selGroupVariable = configure.props ? configure.props.selGroupVariable : null;
+  const enableDrill = configure.props ? configure.props.enableDrill : null;
+  if (!enableDrill && selGroupVariable) {
+    configure.highlightInfos = [];
+    setValueForVariableName(pageContext.entity, selGroupVariable, null);
+  }
+  configure.groupFields = realGroupFilds;
+  configure.cacheDatas = datas;
+  configure.rawResult = resultData;
+}
+export {
+  updateChartOption
+};

package/dist/es/components/runtime/utils/charts/chart-gauge-util.js

@@ -0,0 +1,74 @@
+import { formatVariableValue, getValueFromSource } from "../page-helper-util.js";
+import { deepCopy } from "../common-util.js";
+function updateChartOption(pageContext, configure, chartOption, resultData) {
+  if (!resultData || !resultData.result) {
+    return;
+  }
+  const result = resultData && resultData.result ? resultData.result : {};
+  const dataSetField = configure.serviceDataField;
+  let datas = null;
+  if (dataSetField) {
+    datas = result[dataSetField];
+  } else {
+    if (result) {
+      datas = [result];
+    }
+  }
+  if (!datas) {
+    datas = [];
+  }
+  const nameSource = configure.props ? configure.props.nameSource : void 0;
+  const nameField = configure.props ? configure.props.nameField : void 0;
+  const nameFixed = configure.props ? configure.props.nameFixed : void 0;
+  const valueField = configure.props ? configure.props.yaxisField : void 0;
+  const groupFields = [nameField];
+  const xValues = [];
+  const yValues = [];
+  for (let d of datas) {
+    if (!d) {
+      continue;
+    }
+    let xValue = null;
+    if (nameSource == "fixed") {
+      xValue = formatVariableValue(pageContext, nameFixed);
+    } else {
+      xValue = getValueFromSource(d, nameField, void 0);
+    }
+    xValues.push(xValue);
+    const yValue = getValueFromSource(d, valueField, void 0);
+    yValues.push(yValue);
+  }
+  const defaultSeries = configure.defaultSeries;
+  let allColors = defaultSeries[0].pieColors;
+  allColors = allColors ? allColors : [];
+  let colorMap = defaultSeries[0].pieColorMap;
+  colorMap = colorMap ? colorMap : {};
+  const gaugeDatas = [];
+  for (let index = 0; index < xValues.length && index < yValues.length; index++) {
+    const data = {
+      value: yValues[index],
+      name: xValues[index]
+    };
+    if (index < allColors.length || colorMap[data.name]) {
+      let color = colorMap[data.name];
+      if (!color) {
+        color = allColors[index];
+      }
+      if (color) {
+        data.itemStyle = {
+          color
+        };
+      }
+    }
+    gaugeDatas.push(data);
+  }
+  const tempSeries = deepCopy(defaultSeries);
+  tempSeries[0].data = gaugeDatas;
+  chartOption.series = [tempSeries[0]];
+  configure.groupFields = groupFields;
+  configure.cacheDatas = datas;
+  configure.rawResult = resultData;
+}
+export {
+  updateChartOption
+};

package/dist/es/components/runtime/utils/charts/chart-pie-util.js

@@ -0,0 +1,118 @@
+import { getValueFromSource, setValueForVariableName } from "../page-helper-util.js";
+import { deepCopy } from "../common-util.js";
+import { CommonName, sortDatas, limitDatas } from "./chart-util.js";
+function updateChartOption(pageContext, configure, chartOption, resultData) {
+  if (!resultData || !resultData.result) {
+    return;
+  }
+  const result = resultData && resultData.result ? resultData.result : {};
+  const groupValue = resultData && resultData.groupValue ? resultData.groupValue : [];
+  const dataSetField = configure.serviceDataField;
+  let datas = null;
+  if (dataSetField) {
+    datas = result[dataSetField];
+  } else {
+    if (result) {
+      if (Array.isArray(result)) {
+        datas = result;
+      } else {
+        datas = [result];
+      }
+    }
+  }
+  if (!datas) {
+    datas = [];
+  }
+  let confGroups = configure.props ? configure.props.groups : null;
+  if (!confGroups) {
+    confGroups = [];
+  }
+  const groupMap = {};
+  const groupFields = [];
+  const realGroupFilds = [];
+  for (let g of confGroups) {
+    groupMap[g.group] = g.target;
+    if (g.target && !groupFields.includes(g.target)) {
+      groupFields.push(g.target);
+      if (groupValue.includes(g.group)) {
+        realGroupFilds.push(g.target);
+      }
+    }
+  }
+  let mulGroupShow = configure.props ? configure.props.mulGroupShow : "";
+  mulGroupShow = mulGroupShow == "break" ? "\r\n" : " ";
+  for (let d of datas) {
+    if (!d) {
+      continue;
+    }
+    const xValues2 = [];
+    for (let g of groupValue) {
+      const fieldName = groupMap[g];
+      const value = getValueFromSource(d, fieldName, void 0);
+      if (value) {
+        xValues2.push(value);
+      }
+    }
+    const xValue = xValues2.join(mulGroupShow);
+    d[CommonName.X_FIELD_NAME] = xValue;
+  }
+  const itemConfs = configure.items ? configure.items : [];
+  if (itemConfs.length == 0) {
+    console.log("饼图的系列为空,操作失败!", configure);
+    return;
+  }
+  const valueField = configure.props ? configure.props.yaxisField : null;
+  console.log("valueField", valueField);
+  itemConfs[0].props.yaxisField = valueField;
+  sortDatas(pageContext, configure, datas);
+  datas = limitDatas(pageContext, configure, datas, groupFields, [valueField]);
+  const xValues = [];
+  const yValues = [];
+  for (let data of datas) {
+    if (!data) {
+      continue;
+    }
+    xValues.push(data[CommonName.X_FIELD_NAME]);
+    let value = getValueFromSource(data, valueField, void 0);
+    yValues.push(value);
+  }
+  const defaultSeries = configure.defaultSeries;
+  let pieColors = defaultSeries[0].pieColors;
+  pieColors = pieColors ? pieColors : [];
+  let pieColorMap = defaultSeries[0].pieColorMap;
+  pieColorMap = pieColorMap ? pieColorMap : {};
+  const pieDatas = [];
+  for (let index = 0; index < xValues.length && index < yValues.length; index++) {
+    const data = {
+      value: yValues[index],
+      name: xValues[index]
+    };
+    if (index < pieColors.length || pieColorMap[data.name]) {
+      let color = pieColorMap[data.name];
+      if (!color) {
+        color = pieColors[index];
+      }
+      if (color) {
+        data.itemStyle = {
+          color
+        };
+      }
+    }
+    pieDatas.push(data);
+  }
+  const tempSeries = deepCopy(defaultSeries);
+  tempSeries[0].data = pieDatas;
+  chartOption.series = [tempSeries[0]];
+  const selGroupVariable = configure.props ? configure.props.selGroupVariable : null;
+  const enableDrill = configure.props ? configure.props.enableDrill : null;
+  if (!enableDrill && selGroupVariable) {
+    configure.highlightInfos = [];
+    setValueForVariableName(pageContext.entity, selGroupVariable, null);
+  }
+  configure.groupFields = realGroupFilds;
+  configure.cacheDatas = datas;
+  configure.rawResult = resultData;
+}
+export {
+  updateChartOption
+};