@ued_fpi/data-visual 1.2.14 → 1.2.19

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

@@ -4,13 +4,9 @@ export declare const DvWgmsAuxiliaryJudgment: {
         $: import("vue").ComponentInternalInstance;
         $data: {};
         $props: {
-            endTime?: number | undefined;
-            startTime?: number | undefined;
-            timeType?: string | undefined;
-            latitude?: string | number | undefined;
-            longitude?: string | number | undefined;
-            factorId?: number | undefined;
-            siteCode?: string | undefined;
+            params?: import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult | undefined;
+            isLazy?: boolean | undefined;
+            returnData?: unknown[] | undefined;
             key?: string | number | symbol | undefined;
             style?: unknown;
             ref?: import("vue").VNodeRef | undefined;
@@ -70,42 +66,36 @@ export declare const DvWgmsAuxiliaryJudgment: {
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            startTime: {
-                type: NumberConstructor;
-                default: number;
+            params: {
+                type: globalThis.PropType<import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult>;
+                default: () => {
+                    beginTime: number;
+                    endTime: number;
+                    distance: number;
+                    factorId: number;
+                    longitude: number;
+                    latitude: number;
+                    siteCode: string;
+                    surroundingStationCodes: string;
+                    timeStamp: number;
+                    timeType: string;
+                    siteCodeList: never[];
+                };
             };
-            endTime: {
-                type: NumberConstructor;
-                default: number;
+            returnData: {
+                type: ArrayConstructor;
+                default: () => string[];
             };
-            factorId: {
-                type: NumberConstructor;
-                default: number;
+            isLazy: {
+                type: BooleanConstructor;
+                default: boolean;
             };
-            siteCode: {
-                type: StringConstructor;
-                default: string;
-            };
-            timeType: {
-                type: StringConstructor;
-                default: string;
-            };
-            latitude: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-            longitude: {
-                type: (StringConstructor | NumberConstructor)[];
-                default: number;
-            };
-        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-            endTime: number;
-            startTime: number;
-            timeType: string;
-            latitude: string | number;
-            longitude: string | number;
-            factorId: number;
-            siteCode: string;
+        }>>, {
+            reload: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            params: import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult;
+            isLazy: boolean;
+            returnData: unknown[];
         }, {}, string, {}> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
@@ -127,74 +117,66 @@ export declare const DvWgmsAuxiliaryJudgment: {
         $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<{
-        startTime: {
-            type: NumberConstructor;
-            default: number;
-        };
-        endTime: {
-            type: NumberConstructor;
-            default: number;
-        };
-        factorId: {
-            type: NumberConstructor;
-            default: number;
-        };
-        siteCode: {
-            type: StringConstructor;
-            default: string;
-        };
-        timeType: {
-            type: StringConstructor;
-            default: string;
+        params: {
+            type: globalThis.PropType<import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult>;
+            default: () => {
+                beginTime: number;
+                endTime: number;
+                distance: number;
+                factorId: number;
+                longitude: number;
+                latitude: number;
+                siteCode: string;
+                surroundingStationCodes: string;
+                timeStamp: number;
+                timeType: string;
+                siteCodeList: never[];
+            };
         };
-        latitude: {
-            type: (StringConstructor | NumberConstructor)[];
-            default: number;
+        returnData: {
+            type: ArrayConstructor;
+            default: () => string[];
         };
-        longitude: {
-            type: (StringConstructor | NumberConstructor)[];
-            default: number;
+        isLazy: {
+            type: BooleanConstructor;
+            default: boolean;
         };
-    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    }>> & import("vue").ShallowUnwrapRef<{
+        reload: () => void;
+    }> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    startTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    factorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    siteCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    timeType: {
-        type: StringConstructor;
-        default: string;
+    params: {
+        type: globalThis.PropType<import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult>;
+        default: () => {
+            beginTime: number;
+            endTime: number;
+            distance: number;
+            factorId: number;
+            longitude: number;
+            latitude: number;
+            siteCode: string;
+            surroundingStationCodes: string;
+            timeStamp: number;
+            timeType: string;
+            siteCodeList: never[];
+        };
     };
-    latitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
+    returnData: {
+        type: ArrayConstructor;
+        default: () => string[];
     };
-    longitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
     };
-}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-    endTime: number;
-    startTime: number;
-    timeType: string;
-    latitude: string | number;
-    longitude: string | number;
-    factorId: number;
-    siteCode: string;
+}>>, {
+    reload: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    params: import("./api/types").AUXILIARY_JUDGMENT_API_REQUEST.analysisResult;
+    isLazy: boolean;
+    returnData: unknown[];
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
 export default _AuxiliaryJudgment;

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

@@ -1,68 +1,59 @@
+import type { AUXILIARY_JUDGMENT_API_REQUEST } from './api/types';
 declare const _default: import("vue").DefineComponent<{
-    startTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    factorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    siteCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    timeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    latitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
-    };
-    longitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    startTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    endTime: {
-        type: NumberConstructor;
-        default: number;
-    };
-    factorId: {
-        type: NumberConstructor;
-        default: number;
-    };
-    siteCode: {
-        type: StringConstructor;
-        default: string;
-    };
-    timeType: {
-        type: StringConstructor;
-        default: string;
-    };
-    latitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
-    };
-    longitude: {
-        type: (StringConstructor | NumberConstructor)[];
-        default: number;
+    params: {
+        type: globalThis.PropType<AUXILIARY_JUDGMENT_API_REQUEST.analysisResult>;
+        default: () => {
+            beginTime: number;
+            endTime: number;
+            distance: number;
+            factorId: number;
+            longitude: number;
+            latitude: number;
+            siteCode: string;
+            surroundingStationCodes: string;
+            timeStamp: number;
+            timeType: string;
+            siteCodeList: never[];
+        };
+    };
+    returnData: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    reload: () => 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<AUXILIARY_JUDGMENT_API_REQUEST.analysisResult>;
+        default: () => {
+            beginTime: number;
+            endTime: number;
+            distance: number;
+            factorId: number;
+            longitude: number;
+            latitude: number;
+            siteCode: string;
+            surroundingStationCodes: string;
+            timeStamp: number;
+            timeType: string;
+            siteCodeList: never[];
+        };
+    };
+    returnData: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    isLazy: {
+        type: BooleanConstructor;
+        default: boolean;
     };
 }>>, {
-    endTime: number;
-    startTime: number;
-    timeType: string;
-    latitude: string | number;
-    longitude: string | number;
-    factorId: number;
-    siteCode: string;
+    params: AUXILIARY_JUDGMENT_API_REQUEST.analysisResult;
+    isLazy: boolean;
+    returnData: unknown[];
 }, {}>;
 export default _default;

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

@@ -11,80 +11,84 @@ const _hoisted_2 = { class: "conclusion-box" };
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   __name: "index",
   props: {
-    startTime: {
-      type: Number,
-      default: dayjs().startOf("year").valueOf()
-    },
-    endTime: {
-      type: Number,
-      default: dayjs().endOf("year").valueOf()
-    },
-    factorId: {
-      type: Number,
-      default: 27
-    },
-    siteCode: {
-      type: String,
-      default: ""
-    },
-    timeType: {
-      type: String,
-      default: "hour"
+    params: {
+      type: Object,
+      default: () => {
+        return {
+          beginTime: 16858944e5,
+          endTime: 16858944e5,
+          distance: 1e4,
+          factorId: 9,
+          // 因子ID
+          longitude: 120.445633,
+          latitude: 30.120086,
+          siteCode: "YYZDSTGG00S330127_0012A",
+          surroundingStationCodes: "1",
+          // 需要找的周边类型编码
+          timeStamp: 1688313541e3,
+          // 统计事件数量的时间点
+          timeType: "week",
+          siteCodeList: []
+          // 站点code
+        };
+      }
     },
-    // 经纬度
-    latitude: {
-      type: [Number, String],
-      default: 30.3992
+    returnData: {
+      type: Array,
+      default: () => {
+        return [];
+      }
     },
-    // 经纬度
-    longitude: {
-      type: [Number, String],
-      default: 119.9681
+    isLazy: {
+      type: Boolean,
+      default: false
     }
   },
-  setup(__props) {
+  setup(__props, { expose: __expose }) {
     const props = __props;
     const data = vue.reactive({
-      resultData: [],
+      resultTable: []
       // 研判结论返回
-      params: {
-        endTime: 16566912e5,
-        factorId: 27,
-        latitude: 30.3992,
-        longitude: 119.9681,
-        siteCode: "GKA330100_2009",
-        startTime: 16539264e5,
-        timeType: "hour"
-      }
     });
-    const getConclusion = () => {
-      index.analysisResult(data.params).then((res) => {
-        data.resultData = res?.data ?? [];
-      });
+    const getDateTime = () => {
+      const timeType = props?.params?.timeType;
+      const dateType = props?.params?.timeType === "day" ? "days" : props?.params?.timeType === "hour" ? "hours" : props?.params?.timeType;
+      const dataTime = props?.params?.timeType === "hour" || props?.params?.timeType === "day" ? props?.params.timeStamp : dayjs(props?.params.timeStamp).startOf(timeType).valueOf();
+      return {
+        startTime: dayjs(dataTime).add(-23, dateType).startOf(timeType).format("x"),
+        endTime: dayjs(dataTime).add(1, dateType).startOf(timeType).format("x")
+      };
     };
-    const initData = () => {
-      data.params = {
-        startTime: props?.startTime,
-        endTime: props?.endTime,
-        factorId: props?.factorId,
-        siteCode: props?.siteCode,
-        timeType: props?.timeType,
-        latitude: props?.latitude,
-        longitude: props?.longitude
+    const getConclusion = () => {
+      if (props.returnData && props.returnData.length) {
+        data.resultTable = props.returnData;
+        return;
+      }
+      const { startTime, endTime } = getDateTime();
+      const params = {
+        ...props?.params,
+        distance: props?.params?.distance / 1e3,
+        waveBeginTime: startTime,
+        waveEndTime: endTime
       };
-      getConclusion();
+      index.analysisResult(params).then((res) => {
+        data.resultTable = res?.data ?? [];
+      });
     };
-    vue.watch(() => [props.startTime, props.endTime, props.factorId, props.siteCode, props.latitude, props.longitude, props.timeType], () => {
-      initData();
-    }, { deep: true });
     vue.onMounted(async () => {
-      initData();
+      !props.isLazy && getConclusion();
+    });
+    vue.watch([() => props.params, () => props.returnData, () => props.isLazy], () => {
+      !props.isLazy && getConclusion();
+    }, { deep: true });
+    __expose({
+      reload: getConclusion
     });
-    const { params, resultData } = vue.toRefs(data);
+    const { resultTable } = vue.toRefs(data);
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
         vue.createElementVNode("div", _hoisted_2, [
-          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(resultData), (item, index) => {
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(resultTable), (item, index) => {
             return vue.openBlock(), vue.createElementBlock("div", {
               key: index,
               class: "conclusion-text"

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

@@ -0,0 +1,25 @@
+import type { CHANGE_ALONG_RIVER_API_REQUEST, CHANGE_ALONG_RIVER_API_RESPONSE } from './types';
+/**
+ * @name: pathAnalysis
+ * @test: test font
+ * @msg: 沿程分析
+ * @param {UPSTREAM_IMPACT_API_REQUEST} params
+ * @return {*}
+ */
+export declare const pathAnalysis: (params: CHANGE_ALONG_RIVER_API_REQUEST.pathAnalysis) => Promise<CHANGE_ALONG_RIVER_API_RESPONSE.pathAnalysisTs>;
+/**
+ * @name: waterSurfaceListAll
+ * @test: test font
+ * @msg: 地表水断面水质等级
+ * @param {UPSTREAM_IMPACT_API_REQUEST} params
+ * @return {*}
+ */
+export declare const waterSurfaceListAll: (params: {}) => Promise<any>;
+/**
+ * @name: surfaceWaterStandard
+ * @test: test font
+ * @msg: 获取站点目标值
+ * @param {UPSTREAM_IMPACT_API_REQUEST} params
+ * @return {*}
+ */
+export declare const surfaceWaterStandard: (params: CHANGE_ALONG_RIVER_API_REQUEST.surfaceWaterStandard) => Promise<any>;

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

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const request = require('../../../service/request.js');
+
+const pathAnalysis = (params) => {
+  return request.default({
+    url: "/api/v3.0/surfaceWater/analyse/path-analyse",
+    server: "wgmsMonitorDataServer",
+    params
+  });
+};
+const waterSurfaceListAll = (params) => {
+  return request.default({
+    url: "/api/v1.0/water/qualityGrade/listAll",
+    server: "envStandardManagerServer",
+    params
+  });
+};
+const surfaceWaterStandard = (params) => {
+  return request.default({
+    url: "/api/v3.0/quality/limit/surfaceWater",
+    server: "wgmsMonitorDataServer",
+    params
+  });
+};
+
+exports.pathAnalysis = pathAnalysis;
+exports.surfaceWaterStandard = surfaceWaterStandard;
+exports.waterSurfaceListAll = waterSurfaceListAll;

package/dist/lib/wgms/src/ChangeAlongRiver/api/types.d.ts

@@ -0,0 +1,40 @@
+export declare namespace CHANGE_ALONG_RIVER_API_REQUEST {
+    interface pathAnalysis {
+        accessCode: string;
+        factor: number | string;
+        beginTime: number;
+        endTime: number;
+        queryTimeType: string;
+        limit: number;
+    }
+    interface surfaceWaterStandard {
+        accessCodeList?: string;
+        baseLevel: string | number;
+        factor: number | string;
+        factorFlag?: boolean;
+        configTime: number;
+    }
+    interface requestParamsTs {
+        queryTimeType: string;
+        factor: number | string;
+        alarmTime: number;
+        limit: number;
+        factorName: string;
+        factorCode: string;
+        factorUnit: string;
+        siteCode?: string;
+        baseLevel: string | number;
+    }
+}
+export declare namespace CHANGE_ALONG_RIVER_API_RESPONSE {
+    interface pathAnalysisTs {
+        alarmNum: number | string;
+        coefficient: null;
+        coefficientDoubleValue: number | string;
+        coefficientPre: string;
+        quality: number;
+        rank: number | string;
+        siteName: string;
+        value: number | string;
+    }
+}