@ued_fpi/data-visual 1.2.15 → 1.2.19

package/dist/lib/wgms/src/CrossSectionCorrelation/index.d.ts

@@ -4,17 +4,8 @@ export declare const DvWgmsCrossSectionCorrelation: {
         $: import("vue").ComponentInternalInstance;
         $data: {};
         $props: {
-            time?: number | undefined;
-            beginTime?: number | undefined;
-            endTime?: number | undefined;
-            queryTimeType?: string | undefined;
-            accessCode?: string | undefined;
-            limit?: number | undefined;
-            analysisTime?: number | undefined;
-            targetFactorId?: number | undefined;
-            sourceFactors?: string | undefined;
-            delayedFlag?: boolean | undefined;
-            filterEmpty?: boolean | undefined;
+            params?: import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis | undefined;
+            isLazy?: boolean | undefined;
             key?: string | number | symbol | undefined;
             style?: unknown;
             ref?: import("vue").VNodeRef | undefined;
@@ -74,62 +65,31 @@ export declare const DvWgmsCrossSectionCorrelation: {
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            time: {
-                type: NumberConstructor;
-                default: number;
+            params: {
+                type: globalThis.PropType<import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+                default: () => {
+                    alartTime: number;
+                    analysisTime: number;
+                    accessCode: string;
+                    targetFactorId: number;
+                    queryTimeType: string;
+                    beginTime: number;
+                    endTime: number;
+                    delayedFlag: boolean;
+                    filterEmptyData: boolean;
+                    limit: number;
+                    factorCode: string;
+                };
             };
-            analysisTime: {
-                type: NumberConstructor;
-                default: number;
-            };
-            beginTime: {
-                type: NumberConstructor;
-                default: number;
-            };
-            endTime: {
-                type: NumberConstructor;
-                default: number;
-            };
-            accessCode: {
-                type: StringConstructor;
-                default: string;
-            };
-            targetFactorId: {
-                type: NumberConstructor;
-                default: number;
-            };
-            queryTimeType: {
-                type: StringConstructor;
-                default: string;
-            };
-            sourceFactors: {
-                type: StringConstructor;
-                default: string;
-            };
-            delayedFlag: {
+            isLazy: {
                 type: BooleanConstructor;
                 default: boolean;
             };
-            filterEmpty: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            limit: {
-                type: NumberConstructor;
-                default: number;
-            };
-        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-            time: number;
-            beginTime: number;
-            endTime: number;
-            queryTimeType: string;
-            accessCode: string;
-            limit: number;
-            analysisTime: number;
-            targetFactorId: number;
-            sourceFactors: string;
-            delayedFlag: boolean;
-            filterEmpty: boolean;
+        }>>, {
+            reload: () => Promise<void>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            params: import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis;
+            isLazy: boolean;
         }, {}, string, {}> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
@@ -151,110 +111,57 @@ export declare const DvWgmsCrossSectionCorrelation: {
         $nextTick: typeof import("vue").nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
     } & Readonly<import("vue").ExtractPropTypes<{
-        time: {
-            type: NumberConstructor;
-            default: number;
-        };
-        analysisTime: {
-            type: NumberConstructor;
-            default: number;
-        };
-        beginTime: {
-            type: NumberConstructor;
-            default: number;
-        };
-        endTime: {
-            type: NumberConstructor;
-            default: number;
-        };
-        accessCode: {
-            type: StringConstructor;
-            default: string;
-        };
-        targetFactorId: {
-            type: NumberConstructor;
-            default: number;
-        };
-        queryTimeType: {
-            type: StringConstructor;
-            default: string;
-        };
-        sourceFactors: {
-            type: StringConstructor;
-            default: string;
-        };
-        delayedFlag: {
-            type: BooleanConstructor;
-            default: boolean;
+        params: {
+            type: globalThis.PropType<import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+            default: () => {
+                alartTime: number;
+                analysisTime: number;
+                accessCode: string;
+                targetFactorId: number;
+                queryTimeType: string;
+                beginTime: number;
+                endTime: number;
+                delayedFlag: boolean;
+                filterEmptyData: boolean;
+                limit: number;
+                factorCode: string;
+            };
         };
-        filterEmpty: {
+        isLazy: {
             type: BooleanConstructor;
             default: boolean;
         };
-        limit: {
-            type: NumberConstructor;
-            default: number;
-        };
-    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    }>> & import("vue").ShallowUnwrapRef<{
+        reload: () => Promise<void>;
+    }> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    time: {
-        type: NumberConstructor;
-        default: number;
-    };
-    analysisTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    beginTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    accessCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    targetFactorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    queryTimeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    sourceFactors: {
-        type: StringConstructor;
-        default: string;
-    };
-    delayedFlag: {
-        type: BooleanConstructor;
-        default: boolean;
+    params: {
+        type: globalThis.PropType<import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+        default: () => {
+            alartTime: number;
+            analysisTime: number;
+            accessCode: string;
+            targetFactorId: number;
+            queryTimeType: string;
+            beginTime: number;
+            endTime: number;
+            delayedFlag: boolean;
+            filterEmptyData: boolean;
+            limit: number;
+            factorCode: string;
+        };
     };
-    filterEmpty: {
+    isLazy: {
         type: BooleanConstructor;
         default: boolean;
     };
-    limit: {
-        type: NumberConstructor;
-        default: number;
-    };
-}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-    time: number;
-    beginTime: number;
-    endTime: number;
-    queryTimeType: string;
-    accessCode: string;
-    limit: number;
-    analysisTime: number;
-    targetFactorId: number;
-    sourceFactors: string;
-    delayedFlag: boolean;
-    filterEmpty: boolean;
+}>>, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    params: import("./api/types").CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis;
+    isLazy: boolean;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
 export default _CrossSectionCorrelation;

package/dist/lib/wgms/src/CrossSectionCorrelation/index.vue.d.ts

@@ -1,104 +1,50 @@
+import type { CROSS_SECTION_CORRELATION_API_REQUEST } from './api/types';
 declare const _default: import("vue").DefineComponent<{
-    time: {
-        type: NumberConstructor;
-        default: number;
-    };
-    analysisTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    beginTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    accessCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    targetFactorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    queryTimeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    sourceFactors: {
-        type: StringConstructor;
-        default: string;
-    };
-    delayedFlag: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    filterEmpty: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    limit: {
-        type: NumberConstructor;
-        default: number;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    time: {
-        type: NumberConstructor;
-        default: number;
-    };
-    analysisTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    beginTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    accessCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    targetFactorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    queryTimeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    sourceFactors: {
-        type: StringConstructor;
-        default: string;
-    };
-    delayedFlag: {
+    params: {
+        type: globalThis.PropType<CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+        default: () => {
+            alartTime: number;
+            analysisTime: number;
+            accessCode: string;
+            targetFactorId: number;
+            queryTimeType: string;
+            beginTime: number;
+            endTime: number;
+            delayedFlag: boolean;
+            filterEmptyData: boolean;
+            limit: number;
+            factorCode: string;
+        };
+    };
+    isLazy: {
         type: BooleanConstructor;
         default: boolean;
     };
-    filterEmpty: {
+}, {
+    reload: () => Promise<void>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    params: {
+        type: globalThis.PropType<CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis>;
+        default: () => {
+            alartTime: number;
+            analysisTime: number;
+            accessCode: string;
+            targetFactorId: number;
+            queryTimeType: string;
+            beginTime: number;
+            endTime: number;
+            delayedFlag: boolean;
+            filterEmptyData: boolean;
+            limit: number;
+            factorCode: string;
+        };
+    };
+    isLazy: {
         type: BooleanConstructor;
         default: boolean;
     };
-    limit: {
-        type: NumberConstructor;
-        default: number;
-    };
 }>>, {
-    time: number;
-    beginTime: number;
-    endTime: number;
-    queryTimeType: string;
-    accessCode: string;
-    limit: number;
-    analysisTime: number;
-    targetFactorId: number;
-    sourceFactors: string;
-    delayedFlag: boolean;
-    filterEmpty: boolean;
+    params: CROSS_SECTION_CORRELATION_API_REQUEST.correlationAnalysis;
+    isLazy: boolean;
 }, {}>;
 export default _default;

package/dist/lib/wgms/src/CrossSectionCorrelation/index.vue.js

@@ -4,141 +4,138 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 
 const vue = require('vue');
 const dayjs = require('dayjs');
+const tools = require('../../utils/tools.js');
 const ProgressBar_vue_vue_type_script_setup_true_lang = require('../common/ProgressBar.vue.js');
 require('../common/ProgressBar.vue2.js');
 const index = require('./api/index.js');
 
 const _hoisted_1 = { class: "dv-wgms-cross-section-correlation" };
 const _hoisted_2 = { class: "section-correlation-table" };
-const _hoisted_3 = /* @__PURE__ */ vue.createStaticVNode('<div class="section-correlation-list header"><span class="sort"></span><span class="name"></span><span class="progress"></span><span class="correlation-coefficient">相关系数</span><span class="alarm">报警数</span></div>', 1);
-const _hoisted_4 = { class: "sort" };
-const _hoisted_5 = ["title"];
-const _hoisted_6 = { class: "progress" };
-const _hoisted_7 = { class: "correlation-coefficient green" };
-const _hoisted_8 = { class: "alarm red" };
+const _hoisted_3 = { class: "section-correlation-list header" };
+const _hoisted_4 = /* @__PURE__ */ vue.createElementVNode("span", { class: "sort" }, null, -1);
+const _hoisted_5 = /* @__PURE__ */ vue.createElementVNode("span", { class: "name" }, null, -1);
+const _hoisted_6 = {
+  key: 0,
+  class: "progress"
+};
+const _hoisted_7 = {
+  key: 1,
+  class: "correlation-coefficient"
+};
+const _hoisted_8 = /* @__PURE__ */ vue.createElementVNode("span", { class: "alarm" }, "报警数", -1);
+const _hoisted_9 = { class: "sort" };
+const _hoisted_10 = ["title"];
+const _hoisted_11 = {
+  key: 0,
+  class: "progress"
+};
+const _hoisted_12 = {
+  key: 1,
+  class: "correlation-coefficient green"
+};
+const _hoisted_13 = { class: "alarm red" };
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   __name: "index",
   props: {
-    time: {
-      type: Number,
-      default: dayjs().startOf("year").valueOf()
-    },
-    analysisTime: {
-      type: Number,
-      default: 27
-    },
-    beginTime: {
-      type: Number,
-      default: dayjs().startOf("year").valueOf()
-    },
-    endTime: {
-      type: Number,
-      default: dayjs().endOf("year").valueOf()
-    },
-    accessCode: {
-      type: String,
-      default: ""
-    },
-    targetFactorId: {
-      type: Number,
-      default: 27
-    },
-    queryTimeType: {
-      type: String,
-      default: "hour"
-    },
-    sourceFactors: {
-      type: String,
-      default: ""
-    },
-    delayedFlag: {
-      type: Boolean,
-      default: true
+    params: {
+      type: Object,
+      default: () => {
+        return {
+          alartTime: 1701964799999,
+          // 报警时间
+          analysisTime: 24,
+          accessCode: "31100614",
+          targetFactorId: 1,
+          queryTimeType: "day",
+          beginTime: 170136e7,
+          // 分析时间开始
+          endTime: 1701964799999,
+          // 分析时间结束
+          delayedFlag: true,
+          filterEmptyData: true,
+          limit: 3,
+          factorCode: "w01009"
+        };
+      }
     },
-    filterEmpty: {
+    isLazy: {
       type: Boolean,
       default: false
-    },
-    limit: {
-      type: Number,
-      default: 3
     }
   },
-  setup(__props) {
+  setup(__props, { expose: __expose }) {
     const props = __props;
     const data = vue.reactive({
-      relativeData: [],
-      firstAlarmNum: "",
-      params: {
-        time: 16539264e5,
-        analysisTime: 24,
-        accessCode: "GKA330100_2009",
-        targetFactorId: 27,
-        queryTimeType: "hour",
-        beginTime: 16539264e5,
-        endTime: 16566912e5,
-        sourceFactors: "",
-        delayedFlag: true,
-        filterEmpty: false,
-        limit: 3
-      }
+      relativeData: []
     });
     const getData = async () => {
-      const res = await index.correlationAnalysis(data.params);
+      const params = {
+        time: dayjs(props?.params?.alartTime).valueOf(),
+        // 报警时间
+        analysisTime: props?.params?.analysisTime,
+        accessCode: props?.params?.accessCode,
+        targetFactorId: props?.params?.targetFactorId,
+        queryTimeType: props?.params?.queryTimeType,
+        beginTime: props?.params?.beginTime,
+        // 分析时间开始
+        endTime: tools.getDateEndTime(props?.params?.queryTimeType, props.params?.endTime),
+        sourceFactors: props?.params?.factorCode,
+        delayedFlag: props?.params?.delayedFlag,
+        filterEmptyData: props?.params?.filterEmptyData,
+        limit: props?.params?.limit
+      };
+      const res = await index.correlationAnalysis(params);
       const resData = res.data || [];
       data.relativeData = resData.map((item) => {
         return {
+          rank: item.rank,
           label: item.name,
           alarmNum: item.alarmCount,
-          coefficientDoubleValue: item.corr
+          coefficientDoubleValue: item.corr !== null ? item.corr : "--"
         };
       });
+      if (props?.params?.queryTimeType === "hour")
+        data.relativeData = data.relativeData.filter((item) => !(item.alarmNum === 0 && item.coefficientDoubleValue === "--"));
+      else
+        data.relativeData = data.relativeData.filter((item) => item.alarmNum !== 0);
     };
-    const initData = () => {
-      data.params = {
-        time: props.time,
-        analysisTime: props.analysisTime,
-        accessCode: props.accessCode,
-        targetFactorId: props.targetFactorId,
-        queryTimeType: props.queryTimeType,
-        beginTime: props.beginTime,
-        endTime: props.endTime,
-        sourceFactors: props.sourceFactors,
-        delayedFlag: props.delayedFlag,
-        filterEmpty: props.filterEmpty,
-        limit: props.limit
-      };
-      getData();
-    };
-    vue.watch(() => [props.time, props.analysisTime, props.accessCode, props.targetFactorId, props.queryTimeType, props.beginTime, props.endTime, props.sourceFactors, props.delayedFlag, props.filterEmpty, props.limit], () => {
-      initData();
+    vue.onMounted(() => {
+      !props.isLazy && getData();
     });
-    vue.onMounted(async () => {
-      await vue.nextTick();
-      initData();
+    vue.watch([() => props.params, () => props.isLazy], () => {
+      !props.isLazy && getData();
+    }, { deep: true });
+    __expose({
+      reload: getData
     });
-    const { relativeData, params } = vue.toRefs(data);
+    const { relativeData } = vue.toRefs(data);
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
         vue.createElementVNode("div", _hoisted_2, [
-          _hoisted_3,
+          vue.createElementVNode("div", _hoisted_3, [
+            _hoisted_4,
+            _hoisted_5,
+            props?.params?.queryTimeType === "hour" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_6)) : vue.createCommentVNode("", true),
+            props?.params?.queryTimeType === "hour" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_7, "相关系数")) : vue.createCommentVNode("", true),
+            _hoisted_8
+          ]),
           (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(relativeData), (item, index) => {
             return vue.openBlock(), vue.createElementBlock("div", {
               key: index,
               class: "section-correlation-list"
             }, [
-              vue.createElementVNode("span", _hoisted_4, vue.toDisplayString(index + 1), 1),
+              vue.createElementVNode("span", _hoisted_9, vue.toDisplayString(item.rank), 1),
               vue.createElementVNode("span", {
                 class: "name",
                 title: item.label
-              }, vue.toDisplayString(item.label), 9, _hoisted_5),
-              vue.createElementVNode("div", _hoisted_6, [
+              }, vue.toDisplayString(item.label), 9, _hoisted_10),
+              props?.params?.queryTimeType === "hour" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11, [
                 vue.createVNode(ProgressBar_vue_vue_type_script_setup_true_lang.default, {
                   percentage: item.coefficientDoubleValue * 100
                 }, null, 8, ["percentage"])
-              ]),
-              vue.createElementVNode("span", _hoisted_7, vue.toDisplayString(item.coefficientDoubleValue || "--"), 1),
-              vue.createElementVNode("span", _hoisted_8, vue.toDisplayString(item.alarmNum || "--"), 1)
+              ])) : vue.createCommentVNode("", true),
+              props?.params?.queryTimeType === "hour" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_12, vue.toDisplayString(item.coefficientDoubleValue ?? "--"), 1)) : vue.createCommentVNode("", true),
+              vue.createElementVNode("span", _hoisted_13, vue.toDisplayString(item.alarmNum || item.alarmNum === 0 ? item.alarmNum : "--"), 1)
             ]);
           }), 128))
         ])

package/dist/lib/wgms/src/DayKLine/api/index.d.ts

@@ -0,0 +1,21 @@
+import type { DAY_KLINE_API_REQUEST, DAY_KLINE_API_RESPONSE } from './types';
+/**
+ * @name: getKLine
+ * @test: test font
+ * @msg: K线
+ * @param {DAY_KLINE_API_REQUEST} params
+ * @return {*}
+ */
+export declare const getKLine: (params: DAY_KLINE_API_REQUEST.getKLine) => Promise<{
+    code: number;
+    data: DAY_KLINE_API_RESPONSE.getKLineTs[] | null;
+    message: string;
+}>;
+/**
+ * @name: waterSurfaceListAll
+ * @test: test font
+ * @msg: 地表水断面水质等级
+ * @param {UPSTREAM_IMPACT_API_REQUEST} params
+ * @return {*}
+ */
+export declare const waterSurfaceListAll: (params: {}) => Promise<any>;

package/dist/lib/wgms/src/DayKLine/api/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const request = require('../../../service/request.js');
+
+const getKLine = (params) => {
+  return request.default({
+    url: "/api/v1.0/analyse/kLineAnalyse",
+    server: "wgmsMonitorDataServer",
+    method: "get",
+    params
+  });
+};
+const waterSurfaceListAll = (params) => {
+  return request.default({
+    url: "/api/v1.0/water/qualityGrade/listAll",
+    server: "envStandardManagerServer",
+    params
+  });
+};
+
+exports.getKLine = getKLine;
+exports.waterSurfaceListAll = waterSurfaceListAll;