diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/wt/controller/SdWTMonitorController.java b/backend/src/main/java/com/yfd/platform/qgc_env/wt/controller/SdWTMonitorController.java index b1bf235c..e1bc5b59 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/wt/controller/SdWTMonitorController.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/wt/controller/SdWTMonitorController.java @@ -215,6 +215,20 @@ public class SdWTMonitorController { return ResponseResult.successData(sdWtMonitorService.getCxDetailList(dataSourceRequest)); } + @PostMapping("/cxDetail/removeKendoByIds") + @Operation(summary = "删除垂向水温数据") + public ResponseResult removeCxDetailByIds(@RequestBody BatchDeleteAo batchDeleteAo) { + sdWtvtRService.removeKendoByIds(batchDeleteAo); + return ResponseResult.success(); + } + + @PostMapping("/cxDetail/updateWtvtRData") + @Operation(summary = "修改垂向水温数据") + public ResponseResult updateWtvtRData(@RequestBody Map updateData) { + sdWtvtRService.updateWtvtRData(updateData); + return ResponseResult.success(); + } + @PostMapping("/wtvt/defaultYear/GetKendoListCust") @Operation(summary = "获取垂向水温有数据的年份") public ResponseResult getWtrvDefaultYear(@RequestBody DataSourceRequest dataSourceRequest) { diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/SdWtvtRService.java b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/SdWtvtRService.java index f820339c..2b62f2b3 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/SdWtvtRService.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/SdWtvtRService.java @@ -2,6 +2,9 @@ package com.yfd.platform.qgc_env.wt.service; import com.yfd.platform.common.DataSourceRequest; import com.yfd.platform.common.DataSourceResult; +import com.yfd.platform.qgc_base.entity.vo.BatchDeleteAo; + +import java.util.Map; /** * 垂向水温Service接口 @@ -18,4 +21,8 @@ public interface SdWtvtRService { * @return 数据源结果 */ DataSourceResult getWtrvDefaultYear(DataSourceRequest dataSourceRequest); + + boolean removeKendoByIds(BatchDeleteAo batchDeleteAo); + + void updateWtvtRData(Map updateData); } diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/AlongDetailServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/AlongDetailServiceImpl.java index 6e8c530c..009f7cf6 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/AlongDetailServiceImpl.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/AlongDetailServiceImpl.java @@ -816,9 +816,7 @@ public class AlongDetailServiceImpl extends ServiceImpl dateRangeMap = new HashMap<>(); Map monthRangeMap = new HashMap<>(); diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtMonitorServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtMonitorServiceImpl.java index c026f262..823cf486 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtMonitorServiceImpl.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtMonitorServiceImpl.java @@ -944,8 +944,8 @@ public class SdWtMonitorServiceImpl implements SdWtMonitorService { .append("AND t1.IS_DELETED = 0 ") .append("AND wt.IS_DELETED = 0 ") .append("AND wt.STTP = 'WTVT' ") - .append("AND t1.DT <= #{map.endTime} ") - .append("AND t1.DT >= #{map.startTime} ") + .append("AND t1.DT <= TO_DATE(#{map.endTime}, 'YYYY-MM-DD HH24:MI:SS') ") + .append("AND t1.DT >= TO_DATE(#{map.startTime}, 'YYYY-MM-DD HH24:MI:SS') ") .append("AND t1.WTHG IS NOT NULL ") .append("AND t1.VWT IS NOT NULL ") .append("GROUP BY t1.DT, t1.STCD, wt.STNM "); diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtvtRServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtvtRServiceImpl.java index bb59d92e..737f982c 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtvtRServiceImpl.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/wt/service/impl/SdWtvtRServiceImpl.java @@ -1,21 +1,33 @@ package com.yfd.platform.qgc_env.wt.service.impl; +import cn.hutool.core.collection.CollUtil; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.yfd.platform.common.DataSourceLoadOptionsBase; import com.yfd.platform.common.DataSourceRequest; import com.yfd.platform.common.DataSourceResult; import com.yfd.platform.common.MicroservicDynamicSQLMapper; +import com.yfd.platform.qgc_base.entity.vo.BatchDeleteAo; +import com.yfd.platform.qgc_base.entity.vo.DataParam; import com.yfd.platform.qgc_env.wt.entity.vo.SdWtvtYearVo; import com.yfd.platform.qgc_env.wt.mapper.SdWtvtRMapper; import com.yfd.platform.qgc_env.wt.service.SdWtvtRService; import com.yfd.platform.utils.QgcQueryWrapperUtil; +import com.yfd.platform.utils.SecurityUtils; import jakarta.annotation.Resource; import org.apache.commons.lang3.StringUtils; +import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.HashSet; import java.util.HashMap; import java.util.List; +import java.util.LinkedHashMap; import java.util.Map; +import java.util.Set; /** * 垂向水温Service实现类 @@ -32,6 +44,9 @@ public class SdWtvtRServiceImpl extends ServiceImpl @Resource private MicroservicDynamicSQLMapper microservicDynamicSQLMapper; + @Resource + private JdbcTemplate jdbcTemplate; + @Override public DataSourceResult getWtrvDefaultYear(DataSourceRequest dataSourceRequest) { DataSourceResult dataSourceResult = new DataSourceResult<>(); @@ -70,4 +85,282 @@ public class SdWtvtRServiceImpl extends ServiceImpl List> result = microservicDynamicSQLMapper.pageAllList(null, sql, paramMap); return result != null && !result.isEmpty(); } + + @Override + @Transactional(rollbackFor = Exception.class) + public boolean removeKendoByIds(BatchDeleteAo batchDeleteAo) { + String dataType = batchDeleteAo == null ? null : batchDeleteAo.getDataType(); + List dataList = batchDeleteAo == null ? null : batchDeleteAo.getDataList(); + if (CollUtil.isEmpty(dataList)) { + return true; + } + int batchSize = 500; + for (int i = 0; i < dataList.size(); i += batchSize) { + List subList = dataList.subList(i, Math.min(i + batchSize, dataList.size())); + if ("MON".equalsIgnoreCase(dataType)) { + continue; + } + if ("DATE".equalsIgnoreCase(dataType)) { + continue; + } + if ("TIME".equalsIgnoreCase(dataType)) { + deleteWtvtRData(subList); + Map dateRangeMap = new HashMap<>(); + Map monthRangeMap = new HashMap<>(); + for (DataParam param : subList) { + if (param == null || param.getId() == null || param.getDt() == null || param.getDt().length() < 10) { + continue; + } + String stcd = param.getId(); + String tm = param.getDt(); + String dateStr = tm.substring(0, 10); + if (!dateRangeMap.containsKey(stcd)) { + dateRangeMap.put(stcd, new String[]{dateStr, dateStr}); + } else { + String[] range = dateRangeMap.get(stcd); + if (dateStr.compareTo(range[0]) < 0) { + range[0] = dateStr; + } + if (dateStr.compareTo(range[1]) > 0) { + range[1] = dateStr; + } + } + + String[] ym = tm.substring(0, 7).split("-"); + if (ym.length == 2) { + Integer year = Integer.parseInt(ym[0]); + Integer month = Integer.parseInt(ym[1]); + String monthStart = year + "-" + String.format("%02d", month) + "-01"; + String monthEnd = getMonthEndDate(year, month); + String monthKey = stcd + "_" + year + "_" + month; + if (!monthRangeMap.containsKey(monthKey)) { + monthRangeMap.put(monthKey, new String[]{stcd, monthStart, monthEnd}); + } + } + } + + for (Map.Entry entry : dateRangeMap.entrySet()) { + statisticsDayDataFromHour(entry.getKey(), entry.getValue()[0], entry.getValue()[1]); + } + Set processedMonths = new HashSet<>(); + for (String[] values : monthRangeMap.values()) { + String stcd = values[0]; + String startDate = values[1]; + String endDate = values[2]; + String monthKey = stcd + "_" + startDate; + if (!processedMonths.contains(monthKey)) { + statisticsMonthDataFromDay(stcd, startDate, endDate); + processedMonths.add(monthKey); + } + } + } + } + return true; + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void updateWtvtRData(Map updateData) { + if (updateData == null || updateData.isEmpty()) { + return; + } + String stcd = asString(updateData.get("stcd")); + String dt = asString(updateData.get("dt")); + Object mapObj = updateData.get("map"); + if (StringUtils.isBlank(stcd) || StringUtils.isBlank(dt) || !(mapObj instanceof Map rawMap)) { + return; + } + + List> dataList = new ArrayList<>(); + rawMap.forEach((wthgObj, vwtObj) -> { + if (wthgObj == null) { + return; + } + String wthgStr = String.valueOf(wthgObj).trim(); + if (StringUtils.isBlank(wthgStr) || vwtObj == null) { + return; + } + String vwtStr = String.valueOf(vwtObj).trim(); + if ("-".equals(vwtStr) || "".equals(vwtStr)) { + vwtStr = null; + } + Map item = new HashMap<>(); + item.put("stcd", stcd); + item.put("tm", dt); + item.put("wthg", parseBigDecimal(wthgStr)); + item.put("vwt", parseBigDecimal(vwtStr)); + item.put("recordUser", "admin"); +// item.put("recordUser", SecurityUtils.getUserId()); + dataList.add(item); + }); + + if (dataList.isEmpty()) { + return; + } + batchUpdateWtvtRData(dataList); + + String dateStr = dt.substring(0, 10); + statisticsDayDataFromHour(stcd, dateStr, dateStr); + + String[] ym = dateStr.substring(0, 7).split("-"); + if (ym.length == 2) { + Integer year = Integer.parseInt(ym[0]); + Integer month = Integer.parseInt(ym[1]); + String startDate = year + "-" + String.format("%02d", month) + "-01"; + String endDate = getMonthEndDate(year, month); + statisticsMonthDataFromDay(stcd, startDate, endDate); + } + } + + private void deleteWtvtRData(List dataParamList) { + if (CollUtil.isEmpty(dataParamList)) { + return; + } + StringBuilder sql = new StringBuilder("DELETE FROM SD_WTVT_R WHERE "); + List params = new ArrayList<>(); + for (int i = 0; i < dataParamList.size(); i++) { + if (i > 0) { + sql.append(" OR "); + } + sql.append("(STCD = ? AND TM = TO_DATE(SUBSTR(?, 1, 19), 'YYYY-MM-DD HH24:MI:SS'))"); + DataParam item = dataParamList.get(i); + params.add(item == null ? null : item.getId()); + params.add(item == null ? null : item.getDt()); + } + jdbcTemplate.update(sql.toString(), params.toArray()); + } + + private void batchUpdateWtvtRData(List> dataList) { + if (CollUtil.isEmpty(dataList)) { + return; + } + StringBuilder sql = new StringBuilder("MERGE INTO SD_WTVT_R target USING ("); + List params = new ArrayList<>(); + for (int i = 0; i < dataList.size(); i++) { + if (i > 0) { + sql.append(" UNION ALL "); + } + sql.append("SELECT ? AS STCD, ? AS VWT, ? AS RECORD_USER, ? AS WTHG, ") + .append("TO_DATE(SUBSTR(?, 1, 19), 'YYYY-MM-DD HH24:MI:SS') AS TM FROM DUAL"); + Map item = dataList.get(i); + params.add(item.get("stcd")); + params.add(item.get("vwt")); + params.add(item.get("recordUser")); + params.add(item.get("wthg")); + params.add(item.get("tm")); + } + sql.append(") source ON (target.STCD = source.STCD AND target.TM = source.TM AND target.WTHG = source.WTHG) ") + .append("WHEN MATCHED THEN UPDATE SET target.VWT = source.VWT, target.MODIFY_USER = source.RECORD_USER, target.MODIFY_TIME = SYSDATE ") + .append("WHEN NOT MATCHED THEN INSERT (STCD, VWT, WTHG, TM, RECORD_USER, RECORD_TIME, IS_DELETED) ") + .append("VALUES (source.STCD, source.VWT, source.WTHG, source.TM, source.RECORD_USER, SYSDATE, 0)"); + jdbcTemplate.update(sql.toString(), params.toArray()); + } + + private String getMonthEndDate(Integer year, Integer month) { + Calendar calendar = Calendar.getInstance(); + calendar.set(year, month - 1, 1); + int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH); + return year + "-" + String.format("%02d", month) + "-" + String.format("%02d", lastDay); + } + + private void statisticsDayDataFromHour(String stcd, String startDate, String endDate) { + String deleteSql = "DELETE FROM SD_WTVTDAY_S T " + + "WHERE T.STCD = ? " + + "AND T.DT BETWEEN TO_DATE(?, 'YYYY-MM-DD') " + + "AND TO_DATE(?, 'YYYY-MM-DD') " + + "AND NOT EXISTS ( " + + " SELECT 1 FROM SD_WTVT_R S " + + " WHERE S.STCD = T.STCD " + + " AND S.WTHG = T.WTHG " + + " AND TRUNC(S.TM) = T.DT " + + " AND S.TM >= TO_DATE(? || ' 00:00:00', 'YYYY-MM-DD HH24:MI:SS') " + + " AND S.TM <= TO_DATE(? || ' 23:59:59', 'YYYY-MM-DD HH24:MI:SS') " + + " AND S.IS_DELETED = 0)"; + jdbcTemplate.update(deleteSql, stcd, startDate, endDate, startDate, endDate); + + String mergeSql = "MERGE INTO SD_WTVTDAY_S T " + + "USING ( " + + " SELECT STCD, TRUNC(TM) AS DT, WTHG, AVG(VWT) AS VWT " + + " FROM SD_WTVT_R " + + " WHERE STCD = ? " + + " AND TM >= TO_DATE(? || ' 00:00:00', 'YYYY-MM-DD HH24:MI:SS') " + + " AND TM <= TO_DATE(? || ' 23:59:59', 'YYYY-MM-DD HH24:MI:SS') " + + " AND IS_DELETED = 0 " + + " GROUP BY STCD, TRUNC(TM), WTHG " + + ") S " + + "ON (T.STCD = S.STCD AND T.DT = S.DT AND T.WTHG = S.WTHG) " + + "WHEN MATCHED THEN UPDATE SET " + + " T.VWT = S.VWT, " + + " T.IS_DELETED = 0, " + + " T.DELETE_USER = NULL, " + + " T.DELETE_TIME = NULL, " + + " T.MODIFY_TIME = SYSDATE " + + "WHEN NOT MATCHED THEN INSERT (ID, STCD, DT, WTHG, VWT, RECORD_TIME, IS_DELETED) " + + "VALUES (SYS_GUID(), S.STCD, S.DT, S.WTHG, S.VWT, SYSDATE, 0)"; + jdbcTemplate.update(mergeSql, stcd, startDate, endDate); + } + + private void statisticsMonthDataFromDay(String stcd, String startDate, String endDate) { + Integer startYearInt = Integer.parseInt(startDate.substring(0, 4)); + Integer startMonthInt = Integer.parseInt(startDate.substring(5, 7)); + Integer endMonthInt = Integer.parseInt(endDate.substring(5, 7)); + + String deleteSql = "DELETE FROM SD_WTVTDRTP_S T " + + "WHERE T.DRTP = 'MON' " + + "AND T.STCD = ? " + + "AND T.YEAR = ? " + + "AND T.MONTH BETWEEN ? AND ? " + + "AND EXISTS ( " + + " SELECT 1 " + + " FROM SD_WTVTDAY_S D " + + " WHERE D.STCD = T.STCD " + + " AND D.WTHG = T.WTHG " + + " AND D.IS_DELETED = 0 " + + " AND EXTRACT(YEAR FROM D.DT) = T.YEAR " + + " AND EXTRACT(MONTH FROM D.DT) = T.MONTH " + + " AND D.DT >= TO_DATE(?, 'YYYY-MM-DD') " + + " AND D.DT < TO_DATE(?, 'YYYY-MM-DD') + 1 " + + " GROUP BY D.STCD, EXTRACT(YEAR FROM D.DT), EXTRACT(MONTH FROM D.DT), D.WTHG " + + " HAVING AVG(D.VWT) IS NULL)"; + jdbcTemplate.update(deleteSql, stcd, startYearInt, startMonthInt, endMonthInt, startDate, endDate); + + String mergeSql = "MERGE INTO SD_WTVTDRTP_S T " + + "USING ( " + + " SELECT STCD, EXTRACT(YEAR FROM DT) AS YEAR, EXTRACT(MONTH FROM DT) AS MONTH, WTHG, 'MON' AS DRTP, AVG(VWT) AS VWT " + + " FROM SD_WTVTDAY_S " + + " WHERE STCD = ? " + + " AND DT >= TO_DATE(?, 'YYYY-MM-DD') " + + " AND DT < TO_DATE(?, 'YYYY-MM-DD') + 1 " + + " AND IS_DELETED = 0 " + + " GROUP BY STCD, EXTRACT(YEAR FROM DT), EXTRACT(MONTH FROM DT), WTHG " + + " HAVING AVG(VWT) IS NOT NULL " + + ") S " + + "ON (T.STCD = S.STCD AND T.DRTP = 'MON' AND T.YEAR = S.YEAR AND T.MONTH = S.MONTH AND T.WTHG = S.WTHG) " + + "WHEN MATCHED THEN UPDATE SET " + + " T.VWT = S.VWT, " + + " T.IS_DELETED = 0, " + + " T.DELETE_USER = NULL, " + + " T.DELETE_TIME = NULL, " + + " T.MODIFY_USER = USER, " + + " T.MODIFY_TIME = SYSDATE, " + + " T.TM = SYSDATE " + + "WHEN NOT MATCHED THEN INSERT (ID, STCD, VWT, DRTP, YEAR, MONTH, DR, WTHG, TM, RECORD_USER, RECORD_TIME, IS_DELETED) " + + "VALUES (SYS_GUID(), S.STCD, S.VWT, 'MON', S.YEAR, S.MONTH, NULL, S.WTHG, SYSDATE, USER, SYSDATE, 0)"; + jdbcTemplate.update(mergeSql, stcd, startDate, endDate); + } + + private BigDecimal parseBigDecimal(String str) { + try { + if (StringUtils.isBlank(str)) { + return null; + } + return new BigDecimal(str); + } catch (NumberFormatException e) { + return null; + } + } + + private String asString(Object value) { + return value == null ? null : String.valueOf(value); + } }