fix: 跑通一个接口map返回方式

backend/src/main/java/com/yfd/platform/common/enums/QecIntervalEnum.java

@@ -0,0 +1,36 @@
+package com.yfd.platform.common.enums;
+
+public enum QecIntervalEnum {
+    QEC_STLL_1_DY95("QEC_STLL_1_DY95","生态流量达标率所在统计区间:>=95%"),
+    QEC_STLL_2_90AND95("QEC_STLL_2_90AND95","生态流量达标率所在统计区间:90%~95%"),
+    QEC_STLL_3_80AND90("QEC_STLL_3_80AND90","生态流量达标率所在统计区间:80%~90%"),
+    QEC_STLL_4_XY80("QEC_STLL_4_XY80","生态流量达标率所在统计区间:<80%"),
+    QEC_STLL_5_EMPTY("QEC_STLL_5_EMPTY","无生态流量数据"),
+    QEC_STLL_6_NOEQMN("QEC_STLL_6_NOEQMN","无生态流量要求");
+    /** 变量类型 code */
+    private String code;
+
+
+    /** 描述. */
+    private String desc;
+
+
+    QecIntervalEnum(String code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    /**
+     * @return the code - {返回值描述信息}.
+     */
+    public String getCode() {
+        return code;
+    }
+
+    /**
+     * @return the desc - {返回值描述信息}.
+     */
+    public String getDesc() {
+        return desc;
+    }
+}

backend/src/main/java/com/yfd/platform/common/enums/ShowEnum.java

@@ -0,0 +1,22 @@
+package com.yfd.platform.common.enums;
+
+public enum ShowEnum {
+    Q(1,"环评要求"),
+    M(2,"水利部要求"),
+    A(3,"多年平均流量10%"),
+    N(4,"无生态流量要求");
+    private Integer code;
+    private String desc;
+
+    ShowEnum(Integer code,String desc){
+        this.code=code;
+        this.desc=desc;
+    }
+
+    public Integer getCode(){
+        return code;
+    }
+    public String getDesc(){
+        return desc;
+    }
+}

backend/src/main/java/com/yfd/platform/eng/controller/EngEqIntervalController.java

@@ -83,13 +83,11 @@ public class EngEqIntervalController {
     @Operation(summary = "生态流量达标率 小时统计(二级页面)")
     public ResponseResult getQgcHourKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
         String kendoGroupCode = "EngEqHour";
-//        KendoParamGroupServiceApi serviceApi = SpringContextHolder.getBean(KendoParamGroupServiceApi.class);
+//        Map<String, GroupResult> filterResult = KendoUtil.getGroupResultMap(dataSourceRequest, null, EngEqIntervalController.class);
-//        String filter = serviceApi.getParamGroupConfigByCode(TenantContextHolder.getPlatformId(), kendoGroupCode);
-        Map<String, GroupResult> filterResult = KendoUtil.getGroupResultMap(dataSourceRequest, null, EngEqIntervalController.class);
         String groupBy = KendoUtil.getGroupBy(dataSourceRequest);
         Page page = KendoUtil.getPage(dataSourceRequest);
-        DataSourceResult result = eqIntervalService.getQgcHourKendoListCust(dataSourceRequest, filterResult, page, groupBy);
+        DataSourceResult result = eqIntervalService.getQgcHourKendoListCust(dataSourceRequest, null, page, groupBy);
-        eqIntervalService.processKendoGetListLoadResult(dataSourceRequest, result);
+//        eqIntervalService.processKendoGetListLoadResult(dataSourceRequest, result);
         return ResponseResult.successData(result);
     }
 
@@ -116,7 +114,7 @@ public class EngEqIntervalController {
      */
     @PostMapping({"/qgc/getQgcStaticData"})
     @Operation(summary = "生态流量达标率 区间范围统计(一级页面)")
-    @Log(module = "生态流量", value = "生态流量达标率统计")
+//    @Log(module = "生态流量", value = "生态流量达标率统计")
     public ResponseResult getQgcStaticData(@RequestBody DataSourceRequest dataSourceRequest) {
         DataSourceLoadOptionsBase loadOptionsBase = dataSourceRequest.toDevRequest();
         String type = QueryWrapperUtil.getFilterFieldValue(loadOptionsBase, "type");

backend/src/main/java/com/yfd/platform/utils/QueryWrapperUtil.java

@@ -1,5 +1,7 @@
 package com.yfd.platform.utils;
 
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
 import com.baomidou.mybatisplus.core.metadata.TableInfo;
@@ -7,16 +9,11 @@ import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.zny.dec.framework.kendo.entity.dto.devextreme.DataSourceLoadOptionsBase;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -523,6 +520,401 @@ public class QueryWrapperUtil {
         return result;
     }
 
+    /**
+     * 格式化日期时间值（适配Oracle和达梦数据库）
+     *
+     * @param value 日期字符串
+     * @return 格式化后的SQL日期值
+     */
+    private static String formatDateTimeValue(String value) {
+        if (value == null || value.isEmpty()) {
+            return "NULL";
+        }
+
+        // 去除首尾空格
+        value = value.trim();
+
+        // 判断是否包含时间部分
+        if (value.length() == 10) {
+            // 只有日期部分: 2026-03-08
+            // Oracle/达梦格式: TO_DATE('2026-03-08', 'YYYY-MM-DD')
+            return "TO_DATE('" + value + "', 'YYYY-MM-DD')";
+        } else if (value.length() == 19) {
+            // 包含时间部分: 2026-03-08 00:00:00
+            // Oracle/达梦格式: TO_DATE('2026-03-08 00:00:00', 'YYYY-MM-DD HH24:MI:SS')
+            return "TO_DATE('" + value + "', 'YYYY-MM-DD HH24:MI:SS')";
+        } else if (value.length() > 19) {
+            // 包含毫秒: 2026-03-08 00:00:00.000
+            // Oracle/达梦格式: TO_TIMESTAMP('2026-03-08 00:00:00.000', 'YYYY-MM-DD HH24:MI:SS.FF3')
+            return "TO_TIMESTAMP('" + value + "', 'YYYY-MM-DD HH24:MI:SS.FF3')";
+        } else {
+            // 其他格式，尝试直接使用TO_DATE
+            return "TO_DATE('" + value + "', 'YYYY-MM-DD HH24:MI:SS')";
+        }
+    }
+
+    /**
+     * 构建单个字段的SQL条件（优化版，支持Oracle/达梦日期函数）
+     *
+     * @param field 字段名
+     * @param operator 操作符
+     * @param value 值
+     * @param valueType 值类型
+     * @return SQL条件字符串（包含字段名、操作符和值）
+     */
+    private static String buildSingleCondition(String field, String operator, String value, String valueType) {
+        // 转换操作符
+        String sqlOperator = convertOperator(operator);
+
+        // 根据值类型格式化值
+        String formattedValue;
+
+        // 特殊处理日期类型的BETWEEN操作
+        if (("date".equalsIgnoreCase(valueType) || "datetime".equalsIgnoreCase(valueType) || "timestamp".equalsIgnoreCase(valueType))
+                && "BETWEEN".equals(sqlOperator)) {
+            formattedValue = formatBetweenDateValue(value, valueType);
+        } else {
+            formattedValue = formatValue(value, valueType, sqlOperator);
+        }
+
+        // 构建SQL条件：字段 操作符 值
+        return field + " " + sqlOperator + " " + formattedValue;
+    }
+
+    /**
+     * 格式化BETWEEN操作符的日期值（Oracle/达梦优化）
+     *
+     * @param value 原始值（两个日期用逗号分隔）
+     * @param valueType 值类型
+     * @return 格式化后的BETWEEN值
+     */
+    private static String formatBetweenDateValue(String value, String valueType) {
+        String[] values = value.split(",");
+        if (values.length != 2) {
+            return formatValue(value, valueType, "BETWEEN");
+        }
+
+        String startValue = values[0].trim();
+        String endValue = values[1].trim();
+
+        String formattedStart = formatDateTimeValue(startValue);
+        String formattedEnd = formatDateTimeValue(endValue);
+
+        return formattedStart + " AND " + formattedEnd;
+    }
+
+    /**
+     * 从DataSourceLoadOptionsBase的filter中提取条件，按字段分组返回SQL条件Map
+     *
+     * @param loadOptions DataSourceLoadOptionsBase对象
+     * @return Map<字段名, SQL条件字符串>，例如: {"dtin": "dtin = '1'", "tm": "(tm >= TO_DATE('2026-03-08 00:00:00', 'YYYY-MM-DD HH24:MI:SS') AND tm <= TO_DATE('2026-03-09 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))"}
+     */
+    public static Map<String, String> buildSqlConditionsByField(DataSourceLoadOptionsBase loadOptions) {
+        Map<String, String> fieldConditions = new LinkedHashMap<>();
+
+        if (loadOptions == null || loadOptions.getFilter() == null) {
+            return fieldConditions;
+        }
+
+        Object filter = loadOptions.getFilter();
+
+        try {
+            // 将filter转换为JSONArray格式处理
+            JSONArray filterArray = JSONUtil.parseArray(JSONUtil.toJsonStr(filter));
+            parseFilterToArray(filterArray, fieldConditions);
+
+            // 对所有字段的条件添加括号包裹，确保AND查询时的逻辑优先级正确
+            fieldConditions.replaceAll((key, value) -> "(" + value + ")");
+        } catch (Exception e) {
+            // 如果解析失败，记录日志但不影响主流程
+            e.printStackTrace();
+        }
+
+        return fieldConditions;
+    }
+    /**
+     * 递归解析filter数组，将条件按字段分组存入Map
+     *
+     * @param filterArray filter数组
+     * @param fieldConditions 存储字段条件的Map
+     */
+    private static void parseFilterToArray(JSONArray filterArray, Map<String, String> fieldConditions) {
+        if (filterArray == null || filterArray.isEmpty()) {
+            return;
+        }
+
+        int i = 0;
+
+        while (i < filterArray.size()) {
+            Object item = filterArray.get(i);
+
+            // 跳过逻辑运算符 [ "and" ] 或 [ "or" ]
+            if (item instanceof JSONArray) {
+                JSONArray subArray = (JSONArray) item;
+                if (isLogicalOperator(subArray)) {
+                    i++;
+                    continue;
+                }
+
+                // 判断是否是条件数组 [ "field", "operator", "value", "type" ]
+                if (isConditionArray(subArray)) {
+                    String field = subArray.get(0).toString();
+                    String operator = subArray.get(1).toString();
+                    String value = subArray.get(2).toString();
+                    String valueType = subArray.size() > 3 ? subArray.get(3).toString() : "string";
+
+                    // 生成SQL条件片段
+                    String sqlCondition = buildSingleCondition(field, operator, value, valueType);
+
+                    // 统一转换为大写作为key
+                    String fieldKey = field.toUpperCase();
+
+                    // 如果该字段已存在条件，则用 AND 连接
+                    if (fieldConditions.containsKey(fieldKey)) {
+                        fieldConditions.put(fieldKey, fieldConditions.get(fieldKey) + " AND " + sqlCondition);
+                    } else {
+                        fieldConditions.put(fieldKey, sqlCondition);
+                    }
+                    i++;
+                    continue;
+                }
+            }
+
+            i++;
+        }
+    }
+
+    /**
+     * 判断数组是否是逻辑运算符
+     *
+     * @param array 待判断的数组
+     * @return true表示是逻辑运算符数组
+     */
+    private static boolean isLogicalOperator(JSONArray array) {
+        if (array.size() == 1) {
+            String value = array.get(0).toString().toLowerCase();
+            return "and".equals(value) || "or".equals(value);
+        }
+        return false;
+    }
+
+    /**
+     * 判断数组是否是条件数组
+     * 条件数组格式: [ "field", "operator", "value", "type" ]
+     *
+     * @param array 待判断的数组
+     * @return true表示是条件数组
+     */
+    private static boolean isConditionArray(JSONArray array) {
+        return array.size() >= 3 && array.size() <= 4;
+    }
+
+    /**
+     * 转换操作符为标准SQL操作符
+     *
+     * @param operator 原始操作符
+     * @return SQL操作符
+     */
+    private static String convertOperator(String operator) {
+        if (operator == null) {
+            return "=";
+        }
+
+        switch (operator.toLowerCase()) {
+            case "=":
+                return "=";
+            case "<>":
+            case "!=":
+                return "<>";
+            case ">":
+                return ">";
+            case ">=":
+                return ">=";
+            case "<":
+                return "<";
+            case "<=":
+                return "<=";
+            case "contains":
+                return "LIKE";
+            case "startswith":
+                return "LIKE";
+            case "endswith":
+                return "LIKE";
+            case "in":
+                return "IN";
+            case "not in":
+                return "NOT IN";
+            case "between":
+                return "BETWEEN";
+            default:
+                return operator;
+        }
+    }
+
+    /**
+     * 根据值类型格式化SQL值
+     *
+     * @param value 原始值
+     * @param valueType 值类型 (string, number, date, boolean等)
+     * @param operator SQL操作符
+     * @return 格式化后的SQL值
+     */
+    private static String formatValue(String value, String valueType, String operator) {
+        if (value == null || "null".equalsIgnoreCase(value)) {
+            return "NULL";
+        }
+
+        // 处理IN操作符
+        if ("IN".equals(operator) || "NOT IN".equals(operator)) {
+            return formatInValue(value, valueType);
+        }
+
+        // 处理BETWEEN操作符（非日期类型）
+        if ("BETWEEN".equals(operator) && !isDateType(valueType)) {
+            return formatBetweenValue(value, valueType);
+        }
+
+        // 处理LIKE操作符
+        if ("LIKE".equals(operator)) {
+            return formatLikeValue(value, valueType);
+        }
+
+        // 根据类型格式化
+        if (isDateType(valueType)) {
+            return formatDateTimeValue(value);
+        }
+
+        switch (valueType.toLowerCase()) {
+            case "string":
+                return "'" + escapeSqlString(value) + "'";
+            case "number":
+            case "int":
+            case "integer":
+            case "double":
+            case "float":
+            case "decimal":
+                return value;
+            case "boolean":
+                return Boolean.parseBoolean(value) ? "1" : "0";
+            default:
+                return "'" + escapeSqlString(value) + "'";
+        }
+    }
+
+    /**
+     * 判断是否为日期类型
+     *
+     * @param valueType 值类型
+     * @return true表示是日期类型
+     */
+    private static boolean isDateType(String valueType) {
+        if (valueType == null) {
+            return false;
+        }
+        String type = valueType.toLowerCase();
+        return "date".equals(type) || "datetime".equals(type) || "timestamp".equals(type);
+    }
+
+    /**
+     * 格式化IN操作符的值
+     *
+     * @param value 原始值
+     * @param valueType 值类型
+     * @return 格式化后的IN值列表
+     */
+    private static String formatInValue(String value, String valueType) {
+        // 假设值是逗号分隔的
+        String[] values = value.split(",");
+        StringBuilder result = new StringBuilder("(");
+
+        for (int i = 0; i < values.length; i++) {
+            if (i > 0) {
+                result.append(", ");
+            }
+            String v = values[i].trim();
+            if (isDateType(valueType)) {
+                result.append(formatDateTimeValue(v));
+            } else if ("string".equalsIgnoreCase(valueType)) {
+                result.append("'").append(escapeSqlString(v)).append("'");
+            } else {
+                result.append(v);
+            }
+        }
+
+        result.append(")");
+        return result.toString();
+    }
+
+    /**
+     * 格式化BETWEEN操作符的值（非日期类型）
+     *
+     * @param value 原始值（两个值用逗号分隔）
+     * @param valueType 值类型
+     * @return 格式化后的BETWEEN值
+     */
+    private static String formatBetweenValue(String value, String valueType) {
+        String[] values = value.split(",");
+        if (values.length != 2) {
+            return value;
+        }
+
+        String startValue = values[0].trim();
+        String endValue = values[1].trim();
+
+        String formattedStart = formatSingleValue(startValue, valueType);
+        String formattedEnd = formatSingleValue(endValue, valueType);
+
+        return formattedStart + " AND " + formattedEnd;
+    }
+
+    /**
+     * 格式化LIKE操作符的值
+     *
+     * @param value 原始值
+     * @param valueType 值类型
+     * @return 格式化后的LIKE值
+     */
+    private static String formatLikeValue(String value, String valueType) {
+        // LIKE操作通常需要添加通配符
+        if (!value.contains("%")) {
+            value = "%" + value + "%";
+        }
+        return "'" + escapeSqlString(value) + "'";
+    }
+
+    /**
+     * 格式化单个值
+     *
+     * @param value 原始值
+     * @param valueType 值类型
+     * @return 格式化后的值
+     */
+    private static String formatSingleValue(String value, String valueType) {
+        if (isDateType(valueType)) {
+            return formatDateTimeValue(value);
+        } else if ("string".equalsIgnoreCase(valueType)) {
+            return "'" + escapeSqlString(value) + "'";
+        } else {
+            return value;
+        }
+    }
+
+    /**
+     * 转义SQL字符串中的特殊字符
+     *
+     * @param value 原始字符串
+     * @return 转义后的字符串
+     */
+    private static String escapeSqlString(String value) {
+        if (value == null) {
+            return "";
+        }
+        // 转义单引号
+        return value.replace("'", "''");
+    }
+
+
+
     /**
      * 通用请求 DTO（用于承载分页与分组信息）。
      * <p>

backend/src/main/resources/application-devtw.yml

@@ -39,6 +39,23 @@ logging:
 swagger-ui:
     enabled: true
 
+mybatis-plus:
+  mapper-locations: classpath*:**/mapper/*Mapper.xml,classpath*:**/mapping/*Mapper.xml
+  global-config:
+    banner: false
+    db-config:
+      id-type: ASSIGN_ID
+      insert-strategy: not_null
+      update-strategy: not_null
+      select-strategy: not_empty
+      table-underline: true
+      logic-delete-value: 1
+      logic-not-delete-value: 0
+      logic-delete-field: isDeleted
+  configuration:
+    map-underscore-to-camel-case: true
+    cache-enabled: false
+    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
 
 # 登录相关配置
 login: