@jeecg/online 1.0.1

package/GraphreportAutoChart.js

@@ -0,0 +1,352 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { h, nextTick, defineComponent, provide, ref, computed, reactive, watch, resolveComponent, openBlock, createElementBlock, createVNode, withCtx, createBlock, Fragment, createCommentVNode } from "vue";
+import { router } from "/@/router";
+import ErrorTip from "./ErrorTip.js";
+import ChartAutoRender from "./ChartAutoRender.js";
+import { BasicForm, useForm } from "/@/components/Form";
+import { g as getParamsInfo, a as getChartsData } from "./graphreport.api.js";
+import { DatePicker, Input, InputNumber } from "ant-design-vue";
+import { isArray } from "/@/utils/is";
+import { formatToDate } from "/@/utils/dateUtil";
+import { _ as _export_sfc } from "./index.js";
+import "./ChartTabsRender.js";
+import "./useChartRender.js";
+import "/@/utils/propTypes";
+import "/@/hooks/web/usePrintJS";
+import "/@/utils/file/download";
+import "/@/utils/dict/JDictSelectUtil";
+import "/@/components/chart/Bar.vue";
+import "/@/components/chart/Pie.vue";
+import "/@/components/chart/BarMulti.vue";
+import "/@/components/chart/LineMulti.vue";
+import "/@/utils/http/axios";
+import "/@/hooks/web/useMessage";
+import "./cloneDeep.js";
+import "./_arrayPush.js";
+import "./isArray.js";
+import "./ChartSingleRender.js";
+import "./ChartDoubleRender.js";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "vue-router";
+function useParseFormSchemas(chartsData, showSearchField) {
+  function parseFormSchemas() {
+    return __async(this, null, function* () {
+      let { head, items, dictOptions } = chartsData.value;
+      if (head.dataType === "sql") {
+        let formSchemas = [];
+        items.forEach((field) => {
+          if (field.searchFlag !== "Y")
+            return;
+          let isRange = field.searchMode === "group";
+          let schema = {};
+          let schemas = [];
+          if (field.dictCode && dictOptions[field.dictCode]) {
+            schema.component = "Select";
+            schema.componentProps = {
+              options: dictOptions[field.dictCode]
+            };
+          } else if (["Integer", "Long"].includes(field.fieldType)) {
+            schema.component = "InputNumber";
+            if (isRange) {
+              schema.render = getRangeRender(schemas, field, InputNumber);
+            }
+          } else if (field.fieldType === "Date") {
+            schema.component = "DatePicker";
+            schema.componentProps = {
+              format: "YYYY-MM-DD"
+            };
+            if (isRange) {
+              schema.render = getRangeRender(schemas, field, DatePicker);
+            }
+          } else {
+            schema.component = "Input";
+            if (isRange) {
+              schema.render = getRangeRender(schemas, field, Input);
+            }
+          }
+          formSchemas = formSchemas.concat(__spreadValues({
+            label: field.fieldTxt,
+            field: field.fieldName,
+            component: "Input",
+            itemProps: {
+              class: { "range-query": isRange }
+            }
+          }, schema)).concat(schemas);
+        });
+        showSearchField.value = formSchemas.length > 0;
+        yield nextTick();
+        return formSchemas;
+      } else {
+        showSearchField.value = false;
+        return null;
+      }
+    });
+  }
+  return { parseFormSchemas };
+}
+function getRangeRender(schemas, fieldItem, component) {
+  let { fieldTxt: label, fieldName: beginField } = fieldItem;
+  let endField = beginField + "_end";
+  schemas.push({ label: "", field: endField, component: "Input", show: false });
+  return function({ model }) {
+    return [
+      h(component, {
+        value: model[beginField],
+        "onUpdate:value": (v) => model[beginField] = v,
+        placeholder: "\u8BF7\u8F93\u5165\u5F00\u59CB" + label,
+        format: "YYYY-MM-DD"
+      }),
+      h("span", { class: "range-span" }, "~"),
+      h(component, {
+        value: model[endField],
+        "onUpdate:value": (v) => model[endField] = v,
+        placeholder: "\u8BF7\u8F93\u5165\u7ED3\u675F" + label,
+        format: "YYYY-MM-DD"
+      })
+    ];
+  };
+}
+var GraphreportAutoChart_vue_vue_type_style_index_0_scoped_true_lang = "";
+const _sfc_main = defineComponent({
+  name: "GraphreportAutoChart",
+  components: { BasicForm, ErrorTip, ChartAutoRender },
+  props: {},
+  setup() {
+    provide("setErrorTip", setErrorTip);
+    const $route = router.currentRoute;
+    const loading = ref(false);
+    const code = computed(() => $route.value.params.code);
+    const errorTip = ref(null);
+    const errors = reactive({ resultIsEmpty: false });
+    const chartsData = ref();
+    const paramsMap = reactive({});
+    const selfParamsMap = reactive({});
+    const searchFormMap = reactive({});
+    const paramsRef = getPageComputed(paramsMap, "");
+    const selfParamsRef = getPageComputed(selfParamsMap);
+    const searchFormModal = getPageComputed(searchFormMap, {});
+    const showSearchField = ref(false);
+    const adaptiveColProps = { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 };
+    const [registerSearchForm, searchForm] = useForm({
+      schemas: [],
+      compact: true,
+      labelWidth: 120,
+      autoSubmitOnEnter: true,
+      rowProps: { gutter: 8 },
+      baseColProps: __spreadValues({}, adaptiveColProps),
+      labelCol: { xs: 24, sm: 8, md: 6, lg: 8, xl: 6, xxl: 6 },
+      wrapperCol: {},
+      showAdvancedButton: true,
+      autoAdvancedCol: 3,
+      actionColOptions: __spreadProps(__spreadValues({}, adaptiveColProps), {
+        style: { textAlign: "left" }
+      }),
+      resetFunc: onReset,
+      submitFunc: onSubmit
+    });
+    watch($route, () => {
+      selfParamsRef.value = null;
+      loadChartsData();
+    }, { immediate: true });
+    function setErrorTip(tip) {
+      errorTip.value = tip;
+    }
+    function loadChartsData() {
+      return __async(this, null, function* () {
+        loading.value = true;
+        if (!code.value) {
+          loading.value = false;
+          return false;
+        }
+        let params = { id: code.value, params: paramsRef.value };
+        if (selfParamsRef.value == null) {
+          selfParamsRef.value = {};
+          try {
+            let result = yield getParamsInfo({ headId: params.id });
+            if (result && result.length > 0) {
+              for (let i of result) {
+                selfParamsRef.value["self_" + i.paramName] = !$route.value.query[i.paramName] ? "" : $route.value.query[i.paramName];
+              }
+            }
+          } catch (e) {
+            return;
+          }
+        }
+        try {
+          let result = yield getChartsData(__spreadValues(__spreadValues({}, params), selfParamsRef.value));
+          let { head, data, items, dictOptions } = result;
+          if (data && data.length === 0) {
+            errors.resultIsEmpty = true;
+          } else {
+            errors.resultIsEmpty = false;
+            chartsData.value = { head, data, items, dictOptions };
+            parseChartsData();
+          }
+        } finally {
+          loading.value = false;
+        }
+      });
+    }
+    function getPageComputed(map, defVal) {
+      return computed({
+        get() {
+          if (map[code.value] == null) {
+            map[code.value] = defVal;
+          }
+          return map[code.value];
+        },
+        set: (val) => map[code.value] = val
+      });
+    }
+    const { parseFormSchemas } = useParseFormSchemas(chartsData, showSearchField);
+    function parseChartsData() {
+      return __async(this, null, function* () {
+        let schemas = yield parseFormSchemas();
+        if (schemas) {
+          searchForm.resetSchema(schemas);
+        }
+      });
+    }
+    function onReset() {
+      return __async(this, null, function* () {
+        paramsRef.value = "";
+        loadChartsData();
+      });
+    }
+    function onSubmit() {
+      return __async(this, null, function* () {
+        const data = yield searchForm.validate();
+        let { items } = chartsData.value;
+        let params = [];
+        for (let field of items) {
+          if (field.searchFlag !== "Y")
+            continue;
+          let values = null;
+          if (!field.searchMode)
+            field.searchMode = "single";
+          if (field.searchMode === "single") {
+            values = data[field.fieldName];
+          } else {
+            let _begin = data[field.fieldName];
+            let _end = data[`${field.fieldName}_end`];
+            values = [_begin, _end];
+          }
+          if (field.fieldType === "Date") {
+            values = formatDate(values);
+          }
+          if (values != null && (values[0] != null || values[1] != null)) {
+            params.push({
+              value: values,
+              fieldTxt: field.fieldTxt,
+              fieldName: field.fieldName,
+              fieldType: field.fieldType,
+              searchMode: field.searchMode
+            });
+          }
+        }
+        paramsRef.value = encodeURIComponent(JSON.stringify(params));
+        loadChartsData();
+      });
+    }
+    function formatDate(values) {
+      if (values) {
+        if (isArray(values)) {
+          if (values[0]) {
+            values[0] = formatToDate(values[0]);
+          }
+          if (values[1]) {
+            values[1] = formatToDate(values[1]);
+          }
+        } else {
+          return formatToDate(values);
+        }
+      }
+      return values;
+    }
+    return {
+      loading,
+      errors,
+      errorTip,
+      chartsData,
+      showSearchField,
+      searchFormModal,
+      registerSearchForm
+    };
+  }
+});
+const _hoisted_1 = { class: "p-2" };
+const _hoisted_2 = {
+  key: 0,
+  class: "search-field"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ErrorTip = resolveComponent("ErrorTip");
+  const _component_BasicForm = resolveComponent("BasicForm");
+  const _component_ChartAutoRender = resolveComponent("ChartAutoRender");
+  const _component_a_spin = resolveComponent("a-spin");
+  return openBlock(), createElementBlock("div", _hoisted_1, [
+    createVNode(_component_a_spin, { spinning: _ctx.loading }, {
+      default: withCtx(() => [
+        _ctx.errorTip ? (openBlock(), createBlock(_component_ErrorTip, {
+          key: 0,
+          tip: _ctx.errorTip
+        }, null, 8, ["tip"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          _ctx.showSearchField ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            createVNode(_component_BasicForm, {
+              onRegister: _ctx.registerSearchForm,
+              model: _ctx.searchFormModal
+            }, null, 8, ["onRegister", "model"])
+          ])) : createCommentVNode("", true),
+          _ctx.errors.resultIsEmpty ? (openBlock(), createBlock(_component_ErrorTip, {
+            key: 1,
+            tip: "\u6CA1\u6709\u67E5\u8BE2\u5230\u4EFB\u4F55\u6570\u636E"
+          })) : (openBlock(), createBlock(_component_ChartAutoRender, {
+            key: 2,
+            chartsData: _ctx.chartsData
+          }, null, 8, ["chartsData"]))
+        ], 64))
+      ]),
+      _: 1
+    }, 8, ["spinning"])
+  ]);
+}
+var GraphreportAutoChart = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-39167fbc"]]);
+export { GraphreportAutoChart as default };

package/GraphreportList.js

@@ -0,0 +1,239 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, resolveComponent, openBlock, createElementBlock, Fragment, createElementVNode, normalizeClass, createVNode, withCtx, createBlock, createCommentVNode, createTextVNode, ref, h } from "vue";
+import { router } from "/@/router";
+import { useListPage } from "/@/hooks/system/useListPage";
+import { l as list, A as Api, d as doBatchDelete, q as queryParamsList } from "./graphreport.api.js";
+import { BasicTable, TableAction } from "/@/components/Table";
+import ExcelButton from "/@/components/jeecg/ExcelButton.vue";
+import { useModal } from "/@/components/Modal";
+import { useCopyModal } from "/@/hooks/web/useCopyModal";
+import GraphreportModal from "./GraphreportModal.js";
+import { _ as _export_sfc } from "./index.js";
+import "/@/utils/http/axios";
+import "/@/components/Form/index";
+import "/@/hooks/web/useMessage";
+import "/@/views/system/user/user.api";
+import "/@/utils/common/compUtils";
+import "/@/store/modules/permission";
+import "./FieldTable.js";
+import "/@/components/jeecg/JVxeTable/types";
+import "./useMessageOnline.js";
+import "ant-design-vue";
+import "@ant-design/icons-vue";
+import "/@/utils/is";
+import "./ParamsTable.js";
+import "/@/components/jeecg/OnLine/JPopupOnlReport.vue";
+import "vue-router";
+const _sfc_main = defineComponent({
+  name: "GraphreportList",
+  components: { ExcelButton, BasicTable, TableAction, GraphreportModal },
+  setup() {
+    const { prefixCls, doRequest, doDeleteRecord, tableContext } = useListPage({
+      designScope: "online-graphreport-list",
+      tableProps: {
+        api: list,
+        columns: [
+          { title: "\u56FE\u8868\u540D\u79F0", dataIndex: "name" },
+          { title: "\u7F16\u7801", dataIndex: "code" },
+          { title: "\u6570\u636E", dataIndex: "cgrSql" },
+          { title: "Y\u8F74\u6587\u5B57", dataIndex: "yaxisText" },
+          { title: "X\u8F74\u5B57\u6BB5", dataIndex: "xaxisField" }
+        ],
+        formConfig: {
+          labelWidth: 200,
+          schemas: [
+            { label: "\u56FE\u8868\u540D\u79F0", field: "name", component: "JInput" },
+            { label: "\u7F16\u7801", field: "code", component: "JInput" }
+          ]
+        }
+      }
+    });
+    const [registerTable, { reload }, { rowSelection, selectedRowKeys }] = tableContext;
+    const excelConfig = {
+      export: {
+        name: "Online\u56FE\u8868",
+        url: Api.exportXls
+      },
+      import: {
+        url: Api.importXls,
+        success: reload
+      }
+    };
+    const [registerFormModal, formModal] = useModal();
+    function onAdd() {
+      formModal.openModal(true, { isUpdate: false });
+    }
+    function onEdit(record) {
+      formModal.openModal(true, { isUpdate: true, record });
+    }
+    function onBatchDelete() {
+      return __async(this, null, function* () {
+        doRequest(() => doBatchDelete(selectedRowKeys.value));
+      });
+    }
+    function onGoToTest(record) {
+      router.push("/online/graphreport/chart/" + record.id);
+    }
+    const { createCopyModal } = useCopyModal();
+    function onShowOnlineUrl(record) {
+      return __async(this, null, function* () {
+        let baseUrl = `/online/graphreport/chart/${record.id}`;
+        let copyText = ref(baseUrl);
+        createCopyModal({
+          title: `\u914D\u7F6E\u5730\u5740\u3010${record.name}\u3011`,
+          content: () => h("div", {}, copyText.value),
+          copyText
+        });
+        let result = yield queryParamsList(record.id);
+        if (result && result.length > 0) {
+          let str = "?";
+          result.forEach((item) => {
+            str += item.paramName + "=${" + item.paramName + "}&";
+          });
+          str = str.substring(0, str.length - 1);
+          copyText.value = `${baseUrl}${str}`;
+        }
+      });
+    }
+    function getTableAction(record) {
+      return [
+        {
+          label: "\u7F16\u8F91",
+          onClick: () => onEdit(record)
+        }
+      ];
+    }
+    function getDropDownAction(record) {
+      return [
+        {
+          label: "\u529F\u80FD\u6D4B\u8BD5",
+          onClick: () => onGoToTest(record)
+        },
+        {
+          label: "\u914D\u7F6E\u5730\u5740",
+          onClick: () => onShowOnlineUrl(record)
+        },
+        {
+          label: "\u5220\u9664",
+          popConfirm: {
+            title: "\u786E\u5B9A\u5220\u9664\u5417\uFF1F",
+            placement: "left",
+            confirm: () => doDeleteRecord(() => doBatchDelete([record.id]))
+          }
+        }
+      ];
+    }
+    return {
+      reload,
+      prefixCls,
+      rowSelection,
+      selectedRowKeys,
+      onAdd,
+      getTableAction,
+      getDropDownAction,
+      onBatchDelete,
+      registerTable,
+      registerFormModal,
+      excelConfig
+    };
+  }
+});
+const _hoisted_1 = /* @__PURE__ */ createTextVNode("\u65B0\u589E");
+const _hoisted_2 = /* @__PURE__ */ createElementVNode("span", null, "\u5220\u9664", -1);
+const _hoisted_3 = /* @__PURE__ */ createElementVNode("span", null, "\u6279\u91CF\u64CD\u4F5C", -1);
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_button = resolveComponent("a-button");
+  const _component_ExcelButton = resolveComponent("ExcelButton");
+  const _component_a_icon = resolveComponent("a-icon");
+  const _component_a_menu_item = resolveComponent("a-menu-item");
+  const _component_a_menu = resolveComponent("a-menu");
+  const _component_a_dropdown = resolveComponent("a-dropdown");
+  const _component_TableAction = resolveComponent("TableAction");
+  const _component_BasicTable = resolveComponent("BasicTable");
+  const _component_GraphreportModal = resolveComponent("GraphreportModal");
+  return openBlock(), createElementBlock(Fragment, null, [
+    createElementVNode("div", {
+      class: normalizeClass(_ctx.prefixCls)
+    }, [
+      createVNode(_component_BasicTable, {
+        onRegister: _ctx.registerTable,
+        rowSelection: _ctx.rowSelection
+      }, {
+        tableTitle: withCtx(() => [
+          createVNode(_component_a_button, {
+            onClick: _ctx.onAdd,
+            type: "primary",
+            preIcon: "ant-design:plus"
+          }, {
+            default: withCtx(() => [
+              _hoisted_1
+            ]),
+            _: 1
+          }, 8, ["onClick"]),
+          createVNode(_component_ExcelButton, { config: _ctx.excelConfig }, null, 8, ["config"]),
+          _ctx.selectedRowKeys.length > 0 ? (openBlock(), createBlock(_component_a_dropdown, { key: 0 }, {
+            overlay: withCtx(() => [
+              createVNode(_component_a_menu, null, {
+                default: withCtx(() => [
+                  createVNode(_component_a_menu_item, {
+                    key: "1",
+                    onClick: _ctx.onBatchDelete
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(_component_a_icon, { type: "delete" }),
+                      _hoisted_2
+                    ]),
+                    _: 1
+                  }, 8, ["onClick"])
+                ]),
+                _: 1
+              })
+            ]),
+            default: withCtx(() => [
+              createVNode(_component_a_button, null, {
+                default: withCtx(() => [
+                  _hoisted_3,
+                  createVNode(_component_a_icon, { type: "down" })
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        action: withCtx(({ record }) => [
+          createVNode(_component_TableAction, {
+            actions: _ctx.getTableAction(record),
+            dropDownActions: _ctx.getDropDownAction(record)
+          }, null, 8, ["actions", "dropDownActions"])
+        ]),
+        _: 1
+      }, 8, ["onRegister", "rowSelection"])
+    ], 2),
+    createVNode(_component_GraphreportModal, {
+      onRegister: _ctx.registerFormModal,
+      onSuccess: _ctx.reload
+    }, null, 8, ["onRegister", "onSuccess"])
+  ], 64);
+}
+var GraphreportList = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { GraphreportList as default };