super-page-runtime 2.0.22 → 2.0.25

package/dist/es/components/runtime/utils/form/scan-util.js

@@ -0,0 +1,191 @@
+import http from "agilebuilder-ui/src/utils/request";
+import { setValueForVariableName } from "../page-helper-util.js";
+function formatScanRuleSets(ruleList) {
+  const scanRuleSets2 = {};
+  ruleList.forEach((ruleSet) => {
+    if (ruleSet.type === "group") {
+      ruleSet.outs.forEach((valueSet) => {
+        if (!scanRuleSets2[valueSet.ruleCode]) {
+          scanRuleSets2[valueSet.ruleCode] = { outs: [], adaptations: [] };
+        }
+        scanRuleSets2[valueSet.ruleCode].outs.push(valueSet);
+      });
+    } else {
+      scanRuleSets2[ruleSet.code] = { outs: ruleSet.outs, adaptations: [] };
+    }
+  });
+  return packageScanRuleSets(scanRuleSets2);
+}
+function packageScanRuleSets(scanRuleSets2) {
+  return new Promise((resolve, reject) => {
+    if (Object.keys(scanRuleSets2).length > 0) {
+      http.post("/dc/setting-barcode-analysis/by-codes", Object.keys(scanRuleSets2)).then((res2) => {
+        res2.forEach((rule) => {
+          const ruleOuts = JSON.parse(rule.barcodeAnalysisOuts);
+          const needOutsFields = /* @__PURE__ */ new Set();
+          const outsFiledsSet = {};
+          scanRuleSets2[rule.code].outs.forEach((valueSet) => {
+            needOutsFields.add(valueSet.returnedValue);
+            outsFiledsSet[valueSet.returnedValue] = valueSet.pageVariable;
+          });
+          const filteredOutsField = [];
+          ruleOuts.forEach((outFiled) => {
+            if (needOutsFields.has(outFiled.code)) {
+              outFiled.pageVariable = outsFiledsSet[outFiled.code];
+              filteredOutsField.push(outFiled);
+            }
+          });
+          scanRuleSets2[rule.code].outs = filteredOutsField;
+          scanRuleSets2[rule.code].adaptations = JSON.parse(rule.barcodeAnalysisAdaptations);
+          resolve(scanRuleSets2);
+        });
+      });
+    } else {
+      resolve(null);
+    }
+  });
+}
+function analysisScanValue(scanValue, scanRuleSets) {
+  if (!scanValue) {
+    return null;
+  }
+  const scanSets = Object.values(scanRuleSets);
+  for (let i = 0; i < scanSets.length; i++) {
+    const scanSet = scanSets[i];
+    const adaptations = scanSet.adaptations;
+    let validStr = "";
+    for (let k = 0; k < adaptations.length; k++) {
+      const adap = adaptations[k];
+      const indexs = _getScanIndexs(scanValue, adap.startIndex, adap.endIndex);
+      const startIndex = indexs[0];
+      const endIndex = indexs[1];
+      let paramValue = scanValue.substring(startIndex, endIndex);
+      let compareValue = adap.value;
+      let operate = adap.operate;
+      if (operate == "times") {
+        const realValue = paramValue.split(compareValue == void 0 ? "" : compareValue).length - 1;
+        compareValue = realValue;
+        paramValue = adap.times;
+        operate = "=";
+      }
+      if (isNaN(paramValue) || isNaN(compareValue)) {
+        paramValue = "'" + paramValue + "'";
+        compareValue = "'" + compareValue + "'";
+      }
+      if (adap.leftBracket) {
+        validStr += adap.leftBracket;
+      }
+      if (operate == "<>") {
+        operate = "!=";
+      } else if (operate == "=") {
+        operate = "==";
+      }
+      if (operate == "include" || operate == "notinclude") {
+        validStr += paramValue + ".indexOf(" + compareValue + ")";
+        if (operate == "include") {
+          validStr += ">-1";
+        } else {
+          validStr += "<0";
+        }
+      } else {
+        validStr += paramValue + operate + compareValue;
+      }
+      if (adap.rightBracket) {
+        validStr += adap.rightBracket;
+      }
+      if (adap.joinStr && k + 1 < adaptations.length) {
+        const joinStr = adap.joinStr == "and" ? "&&" : "||";
+        validStr += joinStr;
+      }
+    }
+    let res = false;
+    if (validStr) {
+      try {
+        console.log("validStr", validStr);
+        res = eval("(" + validStr + ")");
+        console.log("res", res);
+      } catch (e) {
+        console.log(e);
+      }
+    } else {
+      res = true;
+    }
+    if (res) {
+      return executeAnalysisForScan(scanValue, scanSet);
+    }
+  }
+  return null;
+}
+function executeAnalysisForScan(scanValue2, scanSet2) {
+  if (!scanSet2 || !scanValue2) {
+    return;
+  }
+  const outs = scanSet2.outs;
+  const params = {};
+  outs.forEach((outJson) => {
+    const fieldName = outJson.fieldName;
+    if (outJson.fixedValue != void 0) {
+      params[fieldName] = outJson.fixedValue;
+    } else {
+      let pValue = scanValue2;
+      if (outJson.splitChar && outJson.splitNum) {
+        const splitChar = outJson.splitChar == "|" ? outJson.splitChar : outJson.splitChar;
+        const strs = scanValue2.split(splitChar);
+        const splitNum = outJson.splitNum < 1 ? 1 : outJson.splitNum;
+        console.log(pValue, splitChar, strs, splitNum);
+        if (splitNum <= strs.length) {
+          pValue = strs[splitNum - 1];
+        } else {
+          pValue = "";
+        }
+      }
+      if (outJson.splitChar2 && outJson.splitNum2) {
+        const splitChar2 = outJson.splitChar2 == "|" ? outJson.splitChar2 : outJson.splitChar2;
+        const strs = pValue.split(splitChar2);
+        const splitNum2 = outJson.splitNum2 < 1 ? 1 : outJson.splitNum2;
+        console.log(pValue, splitChar2, strs, splitNum2);
+        if (splitNum2 <= strs.length) {
+          pValue = strs[splitNum2 - 1];
+        } else {
+          pValue = "";
+        }
+      }
+      if (pValue.length > 0) {
+        const indexs = _getScanIndexs(pValue, outJson.startIndex, outJson.endIndex);
+        const startIndex = indexs[0];
+        const endIndex = indexs[1];
+        pValue = pValue.substring(startIndex, endIndex);
+      }
+      params[fieldName] = pValue;
+    }
+  });
+  return { value: scanValue2, params, scanSet: scanSet2 };
+}
+function _getScanIndexs(value, startIndex, endIndex) {
+  startIndex = startIndex == void 0 ? 0 : startIndex - 1;
+  startIndex = startIndex < 0 ? 0 : startIndex;
+  startIndex = startIndex > value.length - 1 ? value.length - 1 : startIndex;
+  endIndex = endIndex == void 0 ? value.length : endIndex;
+  endIndex = endIndex > value.length ? value.length : endIndex;
+  endIndex = endIndex < 1 ? 1 : endIndex;
+  if (endIndex < startIndex) {
+    endIndex = startIndex;
+  }
+  return [startIndex, endIndex];
+}
+function setScanAnalysisValue(pageContext, scanSet2, params) {
+  if (!scanSet2) {
+    return;
+  }
+  const outs = scanSet2.outs;
+  outs.forEach((outField) => {
+    const fieldName = outField.fieldName;
+    const value = params[fieldName];
+    setValueForVariableName(pageContext.entity, outField.pageVariable, value);
+  });
+}
+export {
+  analysisScanValue,
+  formatScanRuleSets,
+  setScanAnalysisValue
+};

package/dist/es/components/runtime/utils/page-helper-util.js

@@ -156,7 +156,11 @@ function updateChartDatasources(pageContext2, dataSourceConfs, appendParams) {
       systemCode: pageContext2.systemCode,
       pageCode: pageContext2.code
     };
-    const url = window["$vueApp"].config.globalProperties.baseURL + "/common/common-data/find-chart-datas";
+    let baseUrl = pageContext2.backendUrl;
+    if (!baseUrl) {
+      baseUrl = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const url = baseUrl + "/common/common-data/find-chart-datas";
     http.post(url, param).then((result) => {
       if (!pageContext2.chartDataSourceMap) {
         pageContext2.chartDataSourceMap = {};
@@ -198,7 +202,11 @@ function updateOptionDatasources(pageContext2, dataSourceConfs, query) {
       systemCode: pageContext2.systemCode,
       query
     };
-    const url = window["$vueApp"].config.globalProperties.baseURL + "/common/common-data/find-datas";
+    let baseUrl = pageContext2.backendUrl;
+    if (!baseUrl) {
+      baseUrl = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const url = baseUrl + "/common/common-data/find-datas";
     http.post(url, param).then((result) => {
       if (!pageContext2.optionSourceMap) {
         pageContext2.optionSourceMap = {};
@@ -611,6 +619,13 @@ function getMonitorFieldValues(monitorFieldInfos, entity) {
   }
   return values;
 }
+function getFormPropName(prop) {
+  if (prop && prop.indexOf("${") >= 0) {
+    return prop.substring(prop.indexOf(".") + 1, prop.lastIndexOf("}"));
+  } else {
+    return prop;
+  }
+}
 export {
   autoSetAfterSelect,
   caculateShowCondition,
@@ -618,6 +633,7 @@ export {
   formatVariableValue,
   getChartDatasFromPage,
   getComponentOptionConfigs,
+  getFormPropName,
   getOptionDatasFromPage,
   getValueFromSource,
   getVariableValue,

package/dist/es/components/runtime/utils/page-init-util.js

@@ -2,9 +2,9 @@ import http from "agilebuilder-ui/src/utils/request";
 import { useRoute } from "vue-router";
 import { getAdditionalParamMap } from "./events/standard-event.js";
 import { PageDimensions } from "./interfaces/page-design-types.js";
-import { formatVariableValue, setVariableValue } from "./page-helper-util.js";
+import { formatVariableValue, setVariableValue, getFormPropName } from "./page-helper-util.js";
 function queryPageDesignByCode(pageCode) {
-  return http.get("/component/super-page-design/runtime/" + pageCode);
+  return http.get(window["$vueApp"].config.globalProperties.baseAPI + "/component/super-page-design/runtime/" + pageCode);
 }
 function convertToPageContext(pageDesign, pageRequest) {
   if (pageDesign == null) {
@@ -128,7 +128,6 @@ function getFormModelFields(pageContext, formItemConfigure) {
       fields = [formItemConfigure.uuid];
     }
   }
-  debugger;
   if (entity.data.ID == void 0 && entity.data.ID == void 0) {
     if (propsBase.defaultValue) {
       let defaultValue = formatVariableValue(pageContext, propsBase.defaultValue);
@@ -149,7 +148,7 @@ function getFormModelFields(pageContext, formItemConfigure) {
   return fields;
 }
 function getPermissionCodes(configure, pageContext) {
-  if (!pageContext || pageContext.isTest || !configure) {
+  if (!pageContext || !configure) {
     return "true";
   }
   const codes = [];
@@ -182,10 +181,10 @@ function queryPageSuperGrids(pageDesign, pageContext, publishVersion) {
   const additionalParamMap = getAdditionalParamMap(pageContext);
   let additionalParamMapJson;
   const pageCode = pageContext.code;
-  if (additionalParamMap) {
+  if (additionalParamMap && Object.keys(additionalParamMap) > 0) {
     additionalParamMapJson = JSON.stringify(additionalParamMap);
   }
-  return http.post("/component/super-page-design/super-grids", {
+  return http.post(window["$vueApp"].config.globalProperties.baseAPI + "/component/super-page-design/super-grids", {
     tableRuntimes,
     additionalParamMapJson,
     pageCode,
@@ -211,13 +210,6 @@ function packageFormRules(pageContext, configure) {
     pageContext.rules[propName] = configure.props.rules;
   }
 }
-function getFormPropName(prop) {
-  if (prop && prop.indexOf("${") >= 0) {
-    return prop.substring(prop.indexOf(".") + 1, prop.lastIndexOf("}"));
-  } else {
-    return prop;
-  }
-}
 export {
   convertToPageContext,
   getFormModelFields,

package/dist/es/components/runtime/views/assemblys/data/bar-code/barcode-runtime.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./barcode-runtime.vue2.js";
+export {
+  _sfc_main as default
+};

package/dist/es/components/runtime/views/assemblys/data/bar-code/barcode-runtime.vue2.js

@@ -0,0 +1,207 @@
+import { defineComponent, computed, ref, onMounted, watch, resolveComponent, openBlock, createBlock, normalizeClass, unref, normalizeStyle, withCtx, createElementBlock, toDisplayString, createCommentVNode } from "vue";
+import qrcode from "qrcode";
+import JsBarcode from "jsbarcode";
+import { getFormModelFields } from "../../../../utils/page-init-util.js";
+import { getVariableValue, setVariableValue } from "../../../../utils/page-helper-util.js";
+import { handleEvent } from "../../../../utils/events/event-util.js";
+import "agilebuilder-ui/src/utils/request";
+const _hoisted_1 = ["src"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "barcode-runtime",
+  props: {
+    pageContext: {},
+    configure: {}
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const entity = props.pageContext.entity ? props.pageContext.entity : {};
+    let dynamicFields = getFormModelFields(props.pageContext, props.configure);
+    const dynamicModelMethod = computed({
+      get() {
+        return getVariableValue(entity, dynamicFields);
+      },
+      set(value) {
+        setVariableValue(entity, dynamicFields, value);
+      }
+    });
+    const runtimeInfo = props.configure.runtime ? props.configure.runtime : {};
+    const designProperty = ref(runtimeInfo.props ? runtimeInfo.props : {});
+    const runtimeStyle = runtimeInfo.style;
+    const runtimeClass = runtimeInfo.class;
+    const headerStyle = runtimeInfo.headerStyle;
+    const qrUrl = ref("");
+    const barcode = ref(null);
+    const barcodeFormat = ref(designProperty.value.brCodeFormat ?? "CODE128");
+    const watchVariableNames = ref([]);
+    onMounted(() => {
+      if (designProperty.value.generateRule) {
+        if (designProperty.value.generateRuleType === "fixed") {
+          handleFixedFormat();
+        } else {
+          handleSelectedRule();
+        }
+      }
+      if (dynamicModelMethod.value) {
+        createCode(dynamicModelMethod.value);
+      }
+    });
+    function getValue() {
+      return getVariableValue(entity, dynamicFields);
+    }
+    function setValue(value) {
+      return setVariableValue(entity, dynamicFields, value);
+    }
+    function handleFixedFormat() {
+      watchVariableNames.value = Array.from(
+        designProperty.value.generateRule.matchAll(/\$\{(\w+)\}/g),
+        (m) => m[1]
+      );
+      watchVariableNames.value.forEach((name) => {
+        watch(
+          () => props.pageContext.entity.data[name],
+          (newValue, oldValue) => {
+            if (newValue !== void 0 && newValue !== null) {
+              generateFixedFormatCode();
+            }
+          }
+        );
+      });
+    }
+    function handleSelectedRule() {
+      const rule = JSON.parse(
+        '[{"fieldName":"-1","fixedValue":"|"},{"fixedValue":"","fieldLength":"10","suppliement":"x","fieldName":"passenger"},{"fixedValue":"","fieldLength":"","suppliement":"","fieldName":"passengerNumber"},{"fixedValue":"AAA","fieldLength":"","suppliement":"","fieldName":"-1"}]'
+      );
+      rule.forEach((item) => {
+        if (item.fieldName !== "-1" && item.fieldName !== -1) {
+          watchVariableNames.value.push(item.fieldName);
+          watch(
+            () => props.pageContext.entity.data[item.fieldName],
+            (newValue, oldValue) => {
+              if (newValue !== void 0 && newValue !== null) {
+                generateCodeByRule(rule);
+              }
+            }
+          );
+        }
+      });
+    }
+    function generateFixedFormatCode() {
+      let allVariablesPresent = true;
+      watchVariableNames.value.forEach((name) => {
+        if (!props.pageContext.entity.data[name]) {
+          allVariablesPresent = false;
+          return;
+        }
+      });
+      if (allVariablesPresent) {
+        let barCodeValue = replaceVariables(
+          designProperty.value.generateRule,
+          props.pageContext.entity.data
+        );
+        generateCode(barCodeValue);
+      }
+    }
+    function generateCodeByRule(rule) {
+      let allVariablesPresent = true;
+      let value = "";
+      rule.forEach((item) => {
+        if (item.fieldName !== "-1" && item.fieldName !== -1) {
+          const filedValue = props.pageContext.entity.data[item.fieldName];
+          if (item.suppliement && item.fieldLength) {
+            if (!filedValue) {
+              value += "".padEnd(item.fieldLength, item.suppliement);
+            } else {
+              if (filedValue.length > item.fieldLength) {
+                value += filedValue.substring(0, item.fieldLength);
+              } else {
+                value += filedValue.padEnd(item.fieldLength, item.suppliement);
+              }
+            }
+          } else {
+            if (!filedValue) {
+              allVariablesPresent = false;
+            } else {
+              value += filedValue;
+            }
+          }
+        } else {
+          value += item.fixedValue;
+        }
+      });
+      console.log(value);
+      if (allVariablesPresent) {
+        generateCode(value);
+      }
+    }
+    function generateCode(value) {
+      createCode(value);
+      setValue(value);
+      handleEvent(value, props.pageContext, props.configure, "change", {
+        entity
+      });
+    }
+    function createCode(value) {
+      if (designProperty.value.type === "QR-code") {
+        createQrCode(value);
+      } else {
+        createBarCode(value);
+      }
+    }
+    function createBarCode(codeValue) {
+      try {
+        JsBarcode(barcode.value, codeValue, { format: barcodeFormat.value });
+      } catch (error) {
+        console.error("生成条形码时发生错误:", error);
+      }
+    }
+    function createQrCode(codeValue) {
+      qrcode.toDataURL(codeValue, (err, url) => {
+        if (err) {
+          console.error(err);
+        } else {
+          qrUrl.value = url;
+        }
+      });
+    }
+    function replaceVariables(template, variables) {
+      const regex = /\$\{(\w+)\}/g;
+      return template.replace(regex, (match, keyword) => {
+        return variables.hasOwnProperty(keyword) ? variables[keyword] : match;
+      });
+    }
+    __expose({
+      getValue,
+      setValue
+    });
+    return (_ctx, _cache) => {
+      const _component_el_form_item = resolveComponent("el-form-item");
+      return openBlock(), createBlock(_component_el_form_item, {
+        required: designProperty.value.required ? true : false,
+        class: normalizeClass(unref(runtimeClass)),
+        "label-width": designProperty.value.labelWidth,
+        style: normalizeStyle(unref(runtimeStyle))
+      }, {
+        label: withCtx(() => [
+          designProperty.value.tittleShow ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            style: normalizeStyle({ ...unref(headerStyle) })
+          }, toDisplayString(designProperty.value.title), 5)) : createCommentVNode("", true)
+        ]),
+        default: withCtx(() => [
+          designProperty.value.type === "QR-code" ? (openBlock(), createElementBlock("img", {
+            key: 0,
+            src: qrUrl.value
+          }, null, 8, _hoisted_1)) : (openBlock(), createElementBlock("canvas", {
+            key: 1,
+            ref_key: "barcode",
+            ref: barcode
+          }, null, 512))
+        ]),
+        _: 1
+      }, 8, ["required", "class", "label-width", "style"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};