feat: 生态流量沿程变化-小时

This commit is contained in:
tangwei 2026-05-29 15:10:51 +08:00
parent d77c7d60bb
commit 1e96f432ed
29 changed files with 649 additions and 1662 deletions

View File

@ -58,6 +58,7 @@ public class SecurityConfig {
.requestMatchers("/tempFile/**").permitAll() .requestMatchers("/tempFile/**").permitAll()
.requestMatchers("/system/user/auditUser").permitAll() .requestMatchers("/system/user/auditUser").permitAll()
.requestMatchers("/eng/**").permitAll() .requestMatchers("/eng/**").permitAll()
.requestMatchers("/eq/**").permitAll()
.requestMatchers("/env/**").permitAll() .requestMatchers("/env/**").permitAll()
.requestMatchers("/wt/**").permitAll() .requestMatchers("/wt/**").permitAll()
.requestMatchers("/zq/**").permitAll() .requestMatchers("/zq/**").permitAll()

View File

@ -110,4 +110,12 @@ public class SwaggerConfig {
.packagesToScan("com.yfd.platform.qgc_eng.controller") .packagesToScan("com.yfd.platform.qgc_eng.controller")
.build(); .build();
} }
@Bean
public GroupedOpenApi groupEngEqApi() {
return GroupedOpenApi.builder()
.group("4.1. 全过程-常规水电数据服务-生态流量")
.packagesToScan("com.yfd.platform.qgc_eng.eq.controller")
.build();
}
} }

View File

@ -1,54 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.entity.vo.AlarmStcdCountVo;
import com.yfd.platform.qgc_eng.service.AlarmPointService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
import java.util.Map;
/**
* 运行告警锚点控制器
*/
@RestController
@RequestMapping("/eng/alarmPoint")
@Tag(name = "运行告警锚点控制器")
public class AlarmPointController {
/**
* 服务对象
*/
@Resource
private AlarmPointService alarmPointService;
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "条件过滤数据列表定制")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult<AlarmStcdCountVo> dataSourceResult = alarmPointService.processKendoList(dataSourceRequest, filterResult, page);
alarmPointService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
/**
* 获取警报统计数据
* @param stcd 电站ID
* @return 响应结果
*/
@PostMapping({"/getAlarmCount"})
@Operation(summary = "获取警报统计数据")
public ResponseResult getAlarmCount(String stcd) {
AlarmStcdCountVo vo = alarmPointService.getAlarmCount(stcd);
return ResponseResult.successData(vo);
}
}

View File

@ -1,121 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.common.GroupResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.service.EngEqService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import java.util.Map;
/**
* 电站生态流量统计查询
*/
@RestController
@RequestMapping("/eng/eq/")
@Tag(name = "电站生态流量统计查询")
public class EngEqController {
/**
* 服务对象
*/
@Resource
private EngEqService msEngEqService;
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "条件过滤数据列表定制")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, GroupResult> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult dataSourceResult = msEngEqService.processKendoList(dataSourceRequest, filterResult, page);
msEngEqService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
/**
* 导出
* @param dataSourceRequest 数据源请求
* @param response 响应
*/
@PostMapping({"/export"})
@Operation(summary = "导出")
public void export(@RequestBody DataSourceRequest dataSourceRequest, HttpServletResponse response) {
// 实际应该实现导出逻辑
}
/**
* 月统计数据有数据的电站
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping("/lastEngDataSite")
@Operation(summary = "查询指定时间有数据的站点")
public ResponseResult lastEngDataSite(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.lastEngDataSite(dataSourceRequest);
return ResponseResult.successData(result);
}
@PostMapping("/default/stcd")
@Operation(summary = "获取生态流量默认有数据的电站")
public ResponseResult getDefaultStcd(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.getDefaultStcd(dataSourceRequest);
return ResponseResult.successData(result);
}
@PostMapping("/getSfdbInfo")
@Operation(summary = "获取不达标详情数据")
public ResponseResult getSfdbInfo(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.getSfdbInfo(dataSourceRequest);
return ResponseResult.successData(result);
}
@PostMapping({"/qecSfdbCountByStcd"})
@Operation(summary = "生态流量不达标测站数")
public ResponseResult qecSfdbCountByStcd(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.qecSfdbCountByStcd(dataSourceRequest);
return ResponseResult.successData(result);
}
/**
* 生态流量达标率计算基地维度不达标原因维度
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/qecRateCount"})
@Operation(summary = "生态流量达标率计算(基地维度、不达标原因维度)")
public ResponseResult qecRateCount(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.qecRateCount(dataSourceRequest);
return ResponseResult.successData(result);
}
/**
* 生态流量不达标数量计算电站维度不达标原因维度
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/qecSfdbCount"})
@Operation(summary = "生态流量不达标数量计算(电站维度、不达标原因维度)")
public ResponseResult qecSfdbCount(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceResult result = msEngEqService.qecSfdbCount(dataSourceRequest);
return ResponseResult.successData(result);
}
@PostMapping({"/group/GetKendoListCust"})
public ResponseResult getGroupKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, GroupResult> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult dataSourceResult = msEngEqService.processKendoList(dataSourceRequest, filterResult, page);
msEngEqService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
}

View File

@ -1,108 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.service.EngEqDataService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* 电站实时数据查询
*/
@RestController
@RequestMapping("/eng/eq/data")
@Tag(name = "电站实时数据查询")
public class EngEqDataController {
/**
* 服务对象
*/
@Resource
private EngEqDataService engEqDataService;
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "生态流量沿程变化-小时")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult dataSourceResult = engEqDataService.processKendoList(dataSourceRequest, filterResult, page);
engEqDataService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
/**
* 导出
* @param dataSourceRequest 数据源请求
* @param response 响应
*/
@PostMapping({"/export"})
@Operation(summary = "导出")
public void export(@RequestBody DataSourceRequest dataSourceRequest, HttpServletResponse response) {
// 实际应该实现导出逻辑
}
@PostMapping({"/day/GetKendoListCust"})
@Operation(summary = "查询生态流量 日 数据")
public ResponseResult getKendoDayListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
String groupBy = ""; // 实际应该根据业务需求处理分组
DataSourceResult dataSourceResult = engEqDataService.processDayKendoList(dataSourceRequest, filterResult, page, groupBy);
engEqDataService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
@PostMapping({"/drtp/GetKendoListCust"})
@Operation(summary = "查询生态流量 周旬月季年 数据")
public ResponseResult getKendoDrtpListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
String groupBy = ""; // 实际应该根据业务需求处理分组
DataSourceResult dataSourceResult = engEqDataService.processKendoDrtpList(dataSourceRequest, filterResult, page, groupBy);
engEqDataService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
@PostMapping({"/fastSiteLastData/GetKendoListCust"})
@Operation(summary = "查询沿程第一个电站的生态流量数据时间")
public ResponseResult getFastSiteLastData(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
String groupBy = ""; // 实际应该根据业务需求处理分组
DataSourceResult dataSourceResult = engEqDataService.getFastSiteLastData(dataSourceRequest, filterResult, page, groupBy);
engEqDataService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
/**
* 生态流量沿程变化面板
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/along/GetKendoListCust"})
@Operation(summary = "查询生态流量(沿程数据)")
public ResponseResult getKendoAlongListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult dataSourceResult = engEqDataService.processKendoList(dataSourceRequest, filterResult, page);
engEqDataService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
@PostMapping({"/getEngLimit"})
@Operation(summary = "根据时间范围查询电站生态流量限值及来源")
public ResponseResult getEngLimit(@RequestBody DataSourceRequest dataSourceRequest) {
Object result = engEqDataService.getEngLimit(dataSourceRequest);
return ResponseResult.successData(result);
}
}

View File

@ -1,130 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.annotation.Log;
import com.yfd.platform.common.DataSourceLoadOptionsBase;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.domain.MsEngEq;
import com.yfd.platform.qgc_eng.service.EngEqIntervalService;
import com.yfd.platform.qgc_eng.service.EngEqService;
import com.yfd.platform.utils.KendoUtil;
import com.yfd.platform.utils.QgcQueryWrapperUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* 生态流量区间统计控制器
*/
@RestController
@RequestMapping("/eng/eq/interval")
@Tag(name = "电站生态流量区间统计查询")
public class EngEqIntervalController {
/**
* 服务对象
*/
@Resource
private EngEqIntervalService eqIntervalService;
@Resource
private EngEqService engEqService;
/**
* 生态流量达标情况
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "生态流量达标情况")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page<MsEngEq> page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult result = eqIntervalService.processKendoList(dataSourceRequest, filterResult, page);
eqIntervalService.processKendoGetListLoadResult(dataSourceRequest, result);
return ResponseResult.successData(result);
}
/**
* 导出
* @param dataSourceRequest 数据源请求
* @param response 响应
*/
@PostMapping({"/export"})
@Operation(summary = "导出")
@Log(module = "生态流量", value = "导出生态流量数据")
public void export(@RequestBody DataSourceRequest dataSourceRequest, HttpServletResponse response) {
// 实际应该实现导出逻辑
}
/**
* 生态流量达标率 小时统计(二级页面)
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/qgc/hour/GetKendoListCust"})
@Operation(summary = "生态流量达标率 小时统计(二级页面)")
public ResponseResult getQgcHourKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
String kendoGroupCode = "EngEqHour";
// 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, null, page, null);
// eqIntervalService.processKendoGetListLoadResult(dataSourceRequest, result);
return ResponseResult.successData(result);
}
/**
* 生态流量达标率 日统计(二级页面)
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/qgc/day/GetKendoListCust"})
@Operation(summary = "生态流量达标率 日统计(二级页面)")
public ResponseResult getQgcDayKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page<MsEngEq> page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
String groupBy = ""; // 实际应该根据业务需求处理分组
DataSourceResult result = eqIntervalService.getQgcDayKendoListCust(dataSourceRequest, filterResult, page, groupBy);
eqIntervalService.processKendoGetListLoadResult(dataSourceRequest, result);
return ResponseResult.successData(result);
}
/**
* 生态流量达标率 区间范围统计(一级页面)
* @param dataSourceRequest 数据源请求
* @return 响应结果
*/
@PostMapping({"/qgc/getQgcStaticData"})
@Operation(summary = "生态流量达标率 区间范围统计(一级页面)")
// @Log(module = "生态流量", value = "生态流量达标率统计")
public ResponseResult getQgcStaticData(@RequestBody DataSourceRequest dataSourceRequest) {
DataSourceLoadOptionsBase loadOptionsBase = dataSourceRequest.toDevRequest();
String type = QgcQueryWrapperUtil.getFilterFieldValue(loadOptionsBase, "type");
ResponseResult r;
if("hour".equals(type)){
r = this.getQgcHourKendoListCust(dataSourceRequest);
}else if("day".equals(type)){
r = this.getQgcDayKendoListCust(dataSourceRequest);
}else{
return ResponseResult.error("请选择生态流量达标率统计类型(小时还是天统计)");
}
if(r != null && r.get("code").equals("0") && r.get("data") != null){
DataSourceResult dataSourceResult = (DataSourceResult) r.get("data");
if(dataSourceResult != null && dataSourceResult.getData() != null){
Map<String, Object> staticData = eqIntervalService.getQgcQecStaticData(dataSourceResult.getData(), type);
return ResponseResult.successData(staticData);
}
}
return ResponseResult.success();
}
}

View File

@ -1,54 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.common.GroupResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.service.EngEqService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* 电站生态流量统计结果查询
*/
@RestController
@RequestMapping("/eng/eq/stat")
@Tag(name = "电站生态流量统计结果查询")
public class EngEqStatController {
/**
* 服务对象
*/
@Resource
private EngEqService msEngEqService;
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "条件过滤数据列表定制")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, GroupResult> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult dataSourceResult = msEngEqService.processKendoList(dataSourceRequest, filterResult, page);
msEngEqService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
/**
* 导出
* @param dataSourceRequest 数据源请求
* @param response 响应
*/
@PostMapping({"/export"})
@Operation(summary = "导出")
public void export(@RequestBody DataSourceRequest dataSourceRequest, HttpServletResponse response) {
// 实际应该实现导出逻辑
}
}

View File

@ -1,42 +0,0 @@
package com.yfd.platform.qgc_eng.controller;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.entity.EqSpecial;
import com.yfd.platform.qgc_eng.service.EngSpecialService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
* 电站专题-环保设施运行情况
*/
@RestController
@RequestMapping("/eng/special")
@Tag(name = "电站专题-环保设施运行情况")
public class EngSpecialController {
/**
* 服务对象
*/
@Resource
private EngSpecialService engSpecialService;
@PostMapping({"/GetKendoListCust"})
@Operation(summary = "条件过滤数据列表定制")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
Page page = new Page<>(dataSourceRequest.getPage(), dataSourceRequest.getPageSize());
Map<String, Object> filterResult = null; // 实际应该根据业务需求处理筛选
DataSourceResult<EqSpecial> dataSourceResult = engSpecialService.processKendoList(dataSourceRequest, filterResult, page);
engSpecialService.processKendoGetListLoadResult(dataSourceRequest, dataSourceResult);
return ResponseResult.successData(dataSourceResult);
}
}

View File

@ -1,61 +0,0 @@
package com.yfd.platform.qgc_eng.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 生态流量实体类
*/
@Data
@TableName("ms_eng_eq")
public class MsEngEq implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
private String id;
/**
* 电站ID
*/
private String stationId;
/**
* 电站名称
*/
private String stationName;
/**
* 时间
*/
private Date time;
/**
* 生态流量值
*/
private Double eqValue;
/**
* 达标状态
*/
private String status;
/**
* 统计类型hour/day
*/
private String type;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新时间
*/
private Date updateTime;
}

View File

@ -1,54 +0,0 @@
package com.yfd.platform.qgc_eng.entity;
import lombok.Data;
/**
* 电站专题-环保设施运行情况
*/
@Data
public class EqSpecial {
/**
* 主键
*/
private String id;
/**
* 电站ID
*/
private String stcd;
/**
* 电站名称
*/
private String stnm;
/**
* 环保设施类型
*/
private String eqType;
/**
* 设施名称
*/
private String eqName;
/**
* 运行状态
*/
private String status;
/**
* 检查时间
*/
private String checkTime;
/**
* 检查人
*/
private String checker;
/**
* 备注
*/
private String remark;
}

View File

@ -1,39 +0,0 @@
package com.yfd.platform.qgc_eng.entity.vo;
import lombok.Data;
/**
* 警报锚点统计VO
*/
@Data
public class AlarmStcdCountVo {
/**
* 电站ID
*/
private String stcd;
/**
* 电站名称
*/
private String stnm;
/**
* 警报数量
*/
private Integer alarmCount;
/**
* 未处理数量
*/
private Integer unhandledCount;
/**
* 处理中数量
*/
private Integer handlingCount;
/**
* 已处理数量
*/
private Integer handledCount;
}

View File

@ -1,54 +0,0 @@
package com.yfd.platform.qgc_eng.entity.vo;
import lombok.Data;
/**
* 生态流量小时数据VO
*/
@Data
public class EngEqDataVo {
/**
* 电站ID
*/
private String stcd;
/**
* 电站名称
*/
private String stnm;
/**
* 时间
*/
private String tm;
/**
* 生态流量值
*/
private Double eqValue;
/**
* 状态
*/
private String status;
/**
* 不达标原因
*/
private String reason;
/**
* 限值
*/
private Double limitValue;
/**
* 限值来源
*/
private String limitSource;
/**
* 是否左边界
*/
private Integer isLeft;
}

View File

@ -1,59 +0,0 @@
package com.yfd.platform.qgc_eng.entity.vo;
import lombok.Data;
/**
* 生态流量日数据VO
*/
@Data
public class EngEqDayDataVo {
/**
* 电站ID
*/
private String stcd;
/**
* 电站名称
*/
private String stnm;
/**
* 日期
*/
private String tm;
/**
* 日平均生态流量
*/
private Double avgValue;
/**
* 日最小生态流量
*/
private Double minValue;
/**
* 日最大生态流量
*/
private Double maxValue;
/**
* 状态
*/
private String status;
/**
* 不达标原因
*/
private String reason;
/**
* 限值
*/
private Double limitValue;
/**
* 限值来源
*/
private String limitSource;
}

View File

@ -1,59 +0,0 @@
package com.yfd.platform.qgc_eng.entity.vo;
import lombok.Data;
/**
* 生态流量周旬月季年数据VO
*/
@Data
public class EngEqDrtpDataVo {
/**
* 电站ID
*/
private String stcd;
/**
* 电站名称
*/
private String stnm;
/**
* 时间
*/
private String tm;
/**
* 平均生态流量
*/
private Double avgValue;
/**
* 最小生态流量
*/
private Double minValue;
/**
* 最大生态流量
*/
private Double maxValue;
/**
* 状态
*/
private String status;
/**
* 不达标原因
*/
private String reason;
/**
* 限值
*/
private Double limitValue;
/**
* 限值来源
*/
private String limitSource;
}

View File

@ -0,0 +1,29 @@
package com.yfd.platform.qgc_eng.eq.controller;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.config.ResponseResult;
import com.yfd.platform.qgc_eng.eq.service.EngEqDataService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/eq/data")
@Tag(name = "电站实时数据查询")
@Validated
public class EngEqDataController {
@Resource
private EngEqDataService engEqDataService;
@PostMapping("/GetKendoListCust")
@Operation(summary = "生态流量沿程变化-小时")
public ResponseResult getKendoListCust(@RequestBody DataSourceRequest dataSourceRequest) {
return ResponseResult.successData(engEqDataService.getKendoListCust(dataSourceRequest));
}
}

View File

@ -0,0 +1,129 @@
package com.yfd.platform.qgc_eng.eq.entity.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
@Data
@Schema(description = "生态流量小时数据")
public class EngEqDataVo {
@Schema(description = "主键")
private String id;
@Schema(description = "电站编码")
private String stcd;
@Schema(description = "电站名称")
private String stnm;
@Schema(description = "电站名称")
private String ennm;
@Schema(description = "数据时间")
private Date tm;
@Schema(description = "入库流量")
private BigDecimal qi;
@Schema(description = "出库流量")
private BigDecimal qo;
@Schema(description = "生态流量限值(环保部)")
private BigDecimal qecLimit;
@Schema(description = "生态流量")
private BigDecimal qec;
@Schema(description = "生态流量限值(水利部)")
private BigDecimal mwrLimit;
@Schema(description = "生态流量限值(多年平均)")
private BigDecimal avqLimit;
@Schema(description = "生态流量系数(环保部)")
private BigDecimal qecC;
@Schema(description = "生态流量系数(水利部)")
private BigDecimal mwrC;
@Schema(description = "生态流量系数(多年平均)")
private BigDecimal avqC;
@Schema(description = "生态流量是否达标(环保部)")
private Integer sfdb;
@Schema(description = "生态流量是否达标(环保部)中文")
private String sfdbName;
@Schema(description = "生态流量是否达标(水利部)")
private Integer mwrSfdb;
@Schema(description = "生态流量是否达标(水利部)中文")
private String mwrSfdbName;
@Schema(description = "生态流量是否达标(多年平均)")
private Integer avqSfdb;
@Schema(description = "生态流量是否达标(多年平均)中文")
private String avqSfdbName;
@Schema(description = "坝上水位")
private BigDecimal rz;
@Schema(description = "坝下水位")
private BigDecimal dz;
@Schema(description = "基地名称")
private String baseName;
@Schema(description = "流域名称")
private String rvcdName;
@Schema(description = "河段名称")
private String hbrvcdName;
@Schema(description = "行政区名称")
private String addvcdName;
@Schema(description = "AI识别生态流量值")
private BigDecimal qecAi;
@Schema(description = "基地编码")
private String baseId;
@Schema(description = "河段编码")
private String hbrvcd;
@Schema(description = "公司编码")
private String hycd;
@Schema(description = "流域编码")
private String rvcd;
@Schema(description = "建设状态分类")
private Integer bldsttCcode;
@Schema(description = "环保部规则详情ID")
private String qecRuleDid;
@Schema(description = "水利部规则详情ID")
private String qecMwrruleDid;
@Schema(description = "去年同期生态流量")
private BigDecimal beforeQec;
@Schema(description = "基地排序")
private Integer baseStepSort;
@Schema(description = "流域排序")
private Integer rvcdStepSort;
@Schema(description = "电站排序")
private Integer rstcdStepSort;
@Schema(description = "站点排序")
private Integer siteStepSort;
}

View File

@ -0,0 +1,9 @@
package com.yfd.platform.qgc_eng.eq.service;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
public interface EngEqDataService {
DataSourceResult getKendoListCust(DataSourceRequest dataSourceRequest);
}

View File

@ -0,0 +1,473 @@
package com.yfd.platform.qgc_eng.eq.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceLoadOptionsBase;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.common.GroupHelper;
import com.yfd.platform.common.GroupingInfo;
import com.yfd.platform.common.MicroservicDynamicSQLMapper;
import com.yfd.platform.qgc_eng.eq.entity.vo.EngEqDataVo;
import com.yfd.platform.qgc_eng.eq.service.EngEqDataService;
import com.yfd.platform.utils.QgcQueryWrapperUtil;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Service
public class EngEqDataServiceImpl implements EngEqDataService {
@Resource
private MicroservicDynamicSQLMapper microservicDynamicSQLMapper;
@Override
public DataSourceResult getKendoListCust(DataSourceRequest dataSourceRequest) {
DataSourceLoadOptionsBase loadOptions = dataSourceRequest == null ? null : dataSourceRequest.toDevRequest();
if (CollUtil.isEmpty(dataSourceRequest == null ? null : dataSourceRequest.getGroup())) {
return queryDetailList(dataSourceRequest, loadOptions);
}
return queryGroupList(dataSourceRequest, loadOptions);
}
private DataSourceResult<EngEqDataVo> queryDetailList(DataSourceRequest dataSourceRequest,
DataSourceLoadOptionsBase loadOptions) {
StringBuilder sql = new StringBuilder();
sql.append("SELECT ")
.append(buildDetailSelectSql(dataSourceRequest == null ? null : dataSourceRequest.getSelect()))
.append(" ")
.append(buildFromSql())
.append(" WHERE NVL(eng.IS_DELETED, 0) = 0 ")
.append(" AND NVL(sqr.IS_DELETED, 0) = 0 ");
Map<String, Object> paramMap = new HashMap<>();
String filterSql = buildFilterCondition(dataSourceRequest == null ? null : dataSourceRequest.getFilter(), paramMap, new int[]{0});
if (StrUtil.isNotBlank(filterSql)) {
sql.append(" AND ").append(filterSql).append(" ");
}
sql.append(buildDetailOrderBySql(dataSourceRequest == null ? null : dataSourceRequest.getSort()));
Page<?> page = loadOptions == null ? null : QgcQueryWrapperUtil.buildPage(loadOptions, loadOptions.getSkip(), loadOptions.getTake());
List<EngEqDataVo> list = microservicDynamicSQLMapper.pageAllListWithResultType(page, sql.toString(), paramMap, EngEqDataVo.class);
DataSourceResult<EngEqDataVo> result = new DataSourceResult<>();
result.setData(list);
result.setTotal(page != null ? page.getTotal() : list.size());
result.setAggregates(new HashMap<>());
return result;
}
private DataSourceResult queryGroupList(DataSourceRequest dataSourceRequest,
DataSourceLoadOptionsBase loadOptions) {
StringBuilder sql = new StringBuilder();
List<DataSourceRequest.GroupDescriptor> groups = dataSourceRequest.getGroup();
GroupingInfo[] groupInfos = loadOptions == null ? new GroupingInfo[0] : loadOptions.getGroup();
sql.append("SELECT ");
List<String> selectItems = new ArrayList<>();
for (DataSourceRequest.GroupDescriptor descriptor : groups) {
if (descriptor == null || StrUtil.isBlank(descriptor.getField())) {
continue;
}
String column = mapEqColumn(descriptor.getField());
if (StrUtil.isBlank(column)) {
continue;
}
selectItems.add(column + " AS " + descriptor.getField().toUpperCase());
selectItems.add("COUNT(*) AS COUNT_" + descriptor.getField().toUpperCase());
if (CollUtil.isNotEmpty(descriptor.getAggregates())) {
for (DataSourceRequest.AggregateDescriptor aggregate : descriptor.getAggregates()) {
String aggregateColumn = mapEqColumn(aggregate.getField());
if (StrUtil.isBlank(aggregateColumn) || StrUtil.isBlank(aggregate.getAggregate())) {
continue;
}
selectItems.add(buildAggregateSql(aggregate.getAggregate(), aggregateColumn, aggregate.getField()));
}
}
}
if (selectItems.isEmpty()) {
selectItems.add("eng.STCD AS STCD");
selectItems.add("COUNT(*) AS COUNT_STCD");
}
sql.append(String.join(", ", selectItems)).append(" ");
sql.append(buildFromSql())
.append(" WHERE NVL(eng.IS_DELETED, 0) = 0 ")
.append(" AND NVL(sqr.IS_DELETED, 0) = 0 ");
Map<String, Object> paramMap = new HashMap<>();
String filterSql = buildFilterCondition(dataSourceRequest == null ? null : dataSourceRequest.getFilter(), paramMap, new int[]{0});
if (StrUtil.isNotBlank(filterSql)) {
sql.append(" AND ").append(filterSql).append(" ");
}
List<String> groupByColumns = new ArrayList<>();
for (DataSourceRequest.GroupDescriptor descriptor : groups) {
if (descriptor == null || StrUtil.isBlank(descriptor.getField())) {
continue;
}
String column = mapEqColumn(descriptor.getField());
if (StrUtil.isNotBlank(column)) {
groupByColumns.add(column);
}
}
if (!groupByColumns.isEmpty()) {
sql.append(" GROUP BY ").append(String.join(", ", groupByColumns)).append(" ");
}
sql.append(buildGroupOrderBySql(groups));
List<Map<String, Object>> rows = microservicDynamicSQLMapper.pageAllList(null, sql.toString(), paramMap);
DataSourceResult result = new DataSourceResult();
if (dataSourceRequest.getGroupResultFlat() != null && dataSourceRequest.getGroupResultFlat()) {
result.setData(new GroupHelper().faltGroup(rows, Arrays.asList(groupInfos)));
} else {
result.setData(new GroupHelper().group(rows, Arrays.asList(groupInfos)));
}
result.setTotal(0L);
result.setAggregates(new HashMap<>());
return result;
}
private String buildFromSql() {
return " FROM SD_ENGINFO_B_H eng " +
"LEFT JOIN SD_HYDROBASE hb ON hb.BASEID = eng.BASE_ID AND NVL(hb.IS_DELETED, 0) = 0 " +
"LEFT JOIN SD_HBRV_DIC hbrv ON hbrv.HBRVCD = eng.HBRVCD AND hbrv.BASEID = eng.BASE_ID " +
" AND NVL(hbrv.IS_DELETED, 0) = 0 AND NVL(hbrv.ENABLED, 1) = 1 " +
"LEFT JOIN SD_RVCD_DIC rv ON rv.RVCD = eng.RVCD " +
"LEFT JOIN SD_ADDVCD_DIC addv ON addv.ADDVCD = eng.ADDVCD " +
"LEFT JOIN MS_ALONG_B along ON along.RVCD = eng.HBRVCD AND along.CODE = 'common' AND NVL(along.IS_DELETED, 0) = 0 " +
"LEFT JOIN ( " +
" SELECT det.SORT, cfg.RVCD, det.STCD " +
" FROM MS_ALONGDET_B det " +
" INNER JOIN MS_ALONG_B cfg ON det.ALONG_ID = cfg.ID " +
" WHERE NVL(det.IS_DELETED, 0) = 0 AND NVL(cfg.IS_DELETED, 0) = 0 AND cfg.CODE = 'common' " +
") rstSort ON rstSort.RVCD = eng.HBRVCD " +
" AND rstSort.STCD = eng.STCD "+
"LEFT JOIN ( " +
" SELECT det.SORT, cfg.RVCD, det.STCD " +
" FROM MS_ALONGDET_B det " +
" INNER JOIN MS_ALONG_B cfg ON det.ALONG_ID = cfg.ID " +
" WHERE NVL(det.IS_DELETED, 0) = 0 AND NVL(cfg.IS_DELETED, 0) = 0 AND cfg.CODE = 'common' " +
") siteSort ON siteSort.RVCD = eng.HBRVCD AND siteSort.STCD = eng.STCD " +
"INNER JOIN SD_QEC_R sqr ON sqr.STCD = eng.STCD " +
"LEFT JOIN SD_HYDROPW_R shr ON shr.STCD = sqr.STCD AND shr.TM = sqr.TM AND NVL(shr.IS_DELETED, 0) = 0 " +
"LEFT JOIN SD_QEC_R bsqr ON bsqr.STCD = sqr.STCD AND ADD_MONTHS(bsqr.TM, 12) = sqr.TM AND NVL(bsqr.IS_DELETED, 0) = 0 ";
}
private String buildDetailSelectSql(List<String> selectFields) {
Map<String, String> columns = detailFieldColumns();
List<String> selected = new ArrayList<>();
if (CollUtil.isEmpty(selectFields)) {
selected.addAll(columns.values());
} else {
for (String field : selectFields) {
String column = columns.get(field);
if (StrUtil.isNotBlank(column)) {
selected.add(column);
}
}
if (selected.isEmpty()) {
selected.addAll(columns.values());
}
}
return String.join(", ", selected);
}
private Map<String, String> detailFieldColumns() {
Map<String, String> columns = new LinkedHashMap<>();
columns.put("id", "sqr.ID AS id");
columns.put("stcd", "eng.STCD AS stcd");
columns.put("stnm", "eng.ENNM AS stnm");
columns.put("ennm", "eng.ENNM AS ennm");
columns.put("tm", "sqr.TM AS tm");
columns.put("qi", "shr.QI AS qi");
columns.put("qo", "shr.QO AS qo");
columns.put("qecLimit", "sqr.QEC_LIMIT AS qecLimit");
columns.put("qec", "sqr.QEC AS qec");
columns.put("mwrLimit", "sqr.MWR_LIMIT AS mwrLimit");
columns.put("avqLimit", "eng.AVQ AS avqLimit");
columns.put("qecC", "sqr.QEC_C AS qecC");
columns.put("mwrC", "sqr.MWR_C AS mwrC");
columns.put("avqC", "sqr.AVQ_C AS avqC");
columns.put("sfdb", "sqr.SFDB AS sfdb");
columns.put("sfdbName", "CASE NVL(sqr.SFDB, -1) WHEN 0 THEN '不达标' WHEN 1 THEN '达标' WHEN 2 THEN '无生态流量数据' WHEN 3 THEN '无生态流量限值要求' ELSE NULL END AS sfdbName");
columns.put("mwrSfdb", "sqr.MWR_SFDB AS mwrSfdb");
columns.put("mwrSfdbName", "CASE NVL(sqr.MWR_SFDB, -1) WHEN 0 THEN '不达标' WHEN 1 THEN '达标' WHEN 2 THEN '无生态流量数据' WHEN 3 THEN '无生态流量限值要求' ELSE NULL END AS mwrSfdbName");
columns.put("avqSfdb", "sqr.AVQ_SFDB AS avqSfdb");
columns.put("avqSfdbName", "CASE NVL(sqr.AVQ_SFDB, -1) WHEN 0 THEN '不达标' WHEN 1 THEN '达标' WHEN 2 THEN '无生态流量数据' WHEN 3 THEN '无生态流量限值要求' ELSE NULL END AS avqSfdbName");
columns.put("rz", "shr.RZ AS rz");
columns.put("dz", "shr.DZ AS dz");
columns.put("baseName", "hb.BASENAME AS baseName");
columns.put("rvcdName", "rv.RVNM AS rvcdName");
columns.put("hbrvcdName", "hbrv.HBRVNM AS hbrvcdName");
columns.put("addvcdName", "addv.ADDVNM AS addvcdName");
columns.put("qecAi", "sqr.WATERFLOW AS qecAi");
columns.put("baseId", "eng.BASE_ID AS baseId");
columns.put("hbrvcd", "eng.HBRVCD AS hbrvcd");
columns.put("hycd", "eng.HYCD AS hycd");
columns.put("rvcd", "eng.RVCD AS rvcd");
columns.put("bldsttCcode", "eng.BLDSTT_CODE AS bldsttCcode");
columns.put("qecRuleDid", "sqr.QEC_RULE_DID AS qecRuleDid");
columns.put("qecMwrruleDid", "sqr.QEC_MWRRULE_DID AS qecMwrruleDid");
columns.put("beforeQec", "bsqr.QEC AS beforeQec");
columns.put("baseStepSort", "NVL(hb.ORDER_INDEX, 999999) AS baseStepSort");
columns.put("rvcdStepSort", "NVL(along.ORDER_INDEX, 999999) AS rvcdStepSort");
columns.put("rstcdStepSort", "NVL(rstSort.SORT, 999999) AS rstcdStepSort");
columns.put("siteStepSort", "NVL(siteSort.SORT, 999999) AS siteStepSort");
return columns;
}
private String buildDetailOrderBySql(List<DataSourceRequest.SortDescriptor> sortList) {
if (CollUtil.isEmpty(sortList)) {
return " ORDER BY baseStepSort ASC, rvcdStepSort ASC, rstcdStepSort ASC, siteStepSort ASC, tm DESC";
}
List<String> orders = new ArrayList<>();
for (DataSourceRequest.SortDescriptor sort : sortList) {
if (sort == null || StrUtil.isBlank(sort.getField())) {
continue;
}
String column = mapOrderColumn(sort.getField());
if (StrUtil.isBlank(column)) {
continue;
}
String dir = "desc".equalsIgnoreCase(sort.getDir()) || "des".equalsIgnoreCase(sort.getDir()) ? "DESC" : "ASC";
orders.add(column + " " + dir);
}
if (orders.isEmpty()) {
return " ORDER BY baseStepSort ASC, rvcdStepSort ASC, rstcdStepSort ASC, siteStepSort ASC, tm DESC";
}
return " ORDER BY " + String.join(", ", orders);
}
private String buildGroupOrderBySql(List<DataSourceRequest.GroupDescriptor> groups) {
if (CollUtil.isEmpty(groups)) {
return "";
}
List<String> orders = new ArrayList<>();
for (DataSourceRequest.GroupDescriptor descriptor : groups) {
if (descriptor == null || StrUtil.isBlank(descriptor.getField())) {
continue;
}
String column = mapEqColumn(descriptor.getField());
if (StrUtil.isBlank(column)) {
continue;
}
String dir = "desc".equalsIgnoreCase(descriptor.getDir()) || "des".equalsIgnoreCase(descriptor.getDir()) ? "DESC" : "ASC";
orders.add(column + " " + dir);
}
return orders.isEmpty() ? "" : " ORDER BY " + String.join(", ", orders);
}
private String buildAggregateSql(String aggregate, String column, String field) {
String normalized = aggregate == null ? "" : aggregate.toLowerCase();
return switch (normalized) {
case "sum", "min", "max", "avg", "count" -> normalized.toUpperCase() + "(" + column + ") AS " + normalized + "_" + field;
default -> "";
};
}
private String buildFilterCondition(DataSourceRequest.FilterDescriptor filter,
Map<String, Object> paramMap,
int[] indexHolder) {
if (filter == null) {
return "";
}
if (StrUtil.isNotBlank(filter.getField())) {
return buildLeafCondition(filter, paramMap, indexHolder);
}
if (CollUtil.isEmpty(filter.getFilters())) {
return "";
}
List<String> conditions = new ArrayList<>();
for (DataSourceRequest.FilterDescriptor child : filter.getFilters()) {
String childSql = buildFilterCondition(child, paramMap, indexHolder);
if (StrUtil.isNotBlank(childSql)) {
conditions.add("(" + childSql + ")");
}
}
if (conditions.isEmpty()) {
return "";
}
String logic = "or".equalsIgnoreCase(filter.getLogic()) ? " OR " : " AND ";
return String.join(logic, conditions);
}
private String buildLeafCondition(DataSourceRequest.FilterDescriptor filter,
Map<String, Object> paramMap,
int[] indexHolder) {
String field = filter.getField();
String column = mapEqColumn(field);
if (StrUtil.isBlank(column)) {
return "";
}
String operator = StrUtil.blankToDefault(filter.getOperator(), "eq").toLowerCase();
Object value = filter.getValue();
if ("isnull".equals(operator)) {
return column + " IS NULL";
}
if ("isnotnull".equals(operator)) {
return column + " IS NOT NULL";
}
boolean dateField = isEqDateField(field);
if ("in".equals(operator)) {
List<Object> values = normalizeValues(value);
if (values.isEmpty()) {
return "";
}
List<String> placeholders = new ArrayList<>();
for (Object item : values) {
String key = "eqParam" + indexHolder[0]++;
paramMap.put(key, item);
placeholders.add(buildEqValueExpr(key, dateField, item));
}
return column + " IN (" + String.join(", ", placeholders) + ")";
}
if ("vdid".equalsIgnoreCase(field)) {
return "";
}
if (value == null) {
return "";
}
String key = "eqParam" + indexHolder[0]++;
String valueExpr = buildEqValueExpr(key, dateField, value);
return switch (operator) {
case "eq" -> {
paramMap.put(key, value);
yield column + " = " + valueExpr;
}
case "neq" -> {
paramMap.put(key, value);
yield column + " <> " + valueExpr;
}
case "contains" -> {
paramMap.put(key, "%" + value + "%");
yield column + " LIKE #{map." + key + "}";
}
case "startswith" -> {
paramMap.put(key, value + "%");
yield column + " LIKE #{map." + key + "}";
}
case "endswith" -> {
paramMap.put(key, "%" + value);
yield column + " LIKE #{map." + key + "}";
}
case "gt" -> {
paramMap.put(key, value);
yield column + " > " + valueExpr;
}
case "gte" -> {
paramMap.put(key, value);
yield column + " >= " + valueExpr;
}
case "lt" -> {
paramMap.put(key, value);
yield column + " < " + valueExpr;
}
case "lte" -> {
paramMap.put(key, value);
yield column + " <= " + valueExpr;
}
default -> "";
};
}
private boolean isEqDateField(String field) {
return "tm".equalsIgnoreCase(field);
}
private String buildEqValueExpr(String paramKey, boolean dateField, Object value) {
if (!dateField || value == null) {
return "#{map." + paramKey + "}";
}
String text = String.valueOf(value).trim();
if (text.length() <= 10) {
return "TO_DATE(#{map." + paramKey + "}, 'YYYY-MM-DD')";
}
return "TO_DATE(#{map." + paramKey + "}, 'YYYY-MM-DD HH24:MI:SS')";
}
private List<Object> normalizeValues(Object value) {
List<Object> values = new ArrayList<>();
if (value instanceof List<?> list) {
for (Object item : list) {
if (item != null) {
values.add(item);
}
}
return values;
}
if (value instanceof Object[] array) {
for (Object item : array) {
if (item != null) {
values.add(item);
}
}
return values;
}
if (value != null) {
values.add(value);
}
return values;
}
private String mapEqColumn(String field) {
if (StrUtil.isBlank(field)) {
return null;
}
return switch (field) {
case "baseName" -> "hb.BASENAME";
case "stnm", "ennm" -> "eng.ENNM";
case "baseId" -> "eng.BASE_ID";
case "rvcdName" -> "rv.RVNM";
case "addvcdName" -> "addv.ADDVNM";
case "stcd" -> "eng.STCD";
case "tm" -> "sqr.TM";
case "rz" -> "shr.RZ";
case "qec" -> "sqr.QEC";
case "sfdb" -> "sqr.SFDB";
case "qi" -> "shr.QI";
case "qo" -> "shr.QO";
case "dz" -> "shr.DZ";
case "qecLimit" -> "sqr.QEC_LIMIT";
case "hbrvcd" -> "eng.HBRVCD";
case "hbrvcdName" -> "hbrv.HBRVNM";
case "rvcdStepSort" -> "NVL(along.ORDER_INDEX, 999999)";
case "rstcdStepSort" -> "NVL(rstSort.SORT, 999999)";
case "siteStepSort" -> "NVL(siteSort.SORT, 999999)";
case "hycd" -> "eng.HYCD";
case "rvcd" -> "eng.HBRVCD";
case "bldsttCcode" -> "eng.BLDSTT_CODE";
case "baseStepSort" -> "NVL(hb.ORDER_INDEX, 999999)";
case "mwrLimit" -> "sqr.MWR_LIMIT";
case "avqLimit" -> "eng.AVQ";
case "mwrSfdb" -> "sqr.MWR_SFDB";
case "avqSfdb" -> "sqr.AVQ_SFDB";
case "qecC" -> "sqr.QEC_C";
case "mwrC" -> "sqr.MWR_C";
case "avqC" -> "sqr.AVQ_C";
case "qecAi" -> "sqr.WATERFLOW";
default -> null;
};
}
private String mapOrderColumn(String field) {
if (StrUtil.isBlank(field)) {
return null;
}
return switch (field) {
case "baseStepSort", "rvcdStepSort", "rstcdStepSort", "siteStepSort",
"tm", "stcd", "stnm", "ennm", "qi", "qo", "qec", "sfdb",
"rz", "dz", "qecLimit", "mwrLimit", "avqLimit", "baseName",
"rvcdName", "hbrvcdName", "addvcdName", "qecAi" -> field;
default -> null;
};
}
}

View File

@ -1,21 +0,0 @@
package com.yfd.platform.qgc_eng.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yfd.platform.qgc_eng.domain.MsEngEq;
import org.apache.ibatis.annotations.Select;
import java.util.Map;
/**
* 生态流量Mapper
*/
public interface EngEqMapper extends BaseMapper<MsEngEq> {
/**
* 根据条件查询生态流量数据
* @param params 查询参数
* @return 生态流量列表
*/
@Select("select * from ms_eng_eq where 1=1")
Object queryList(Map<String, Object> params);
}

View File

@ -1,37 +0,0 @@
package com.yfd.platform.qgc_eng.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.qgc_eng.entity.vo.AlarmStcdCountVo;
import java.util.Map;
/**
* 警报锚点服务
*/
public interface AlarmPointService {
/**
* 处理kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @return 数据源结果
*/
DataSourceResult<AlarmStcdCountVo> processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page);
/**
* 处理kendo返回列表字典匹配
* @param dataSourceRequest 数据源请求
* @param dataSourceResult 数据源结果
*/
void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult<AlarmStcdCountVo> dataSourceResult);
/**
* 获取警报统计数据
* @param stcd 电站ID
* @return 统计结果
*/
AlarmStcdCountVo getAlarmCount(String stcd);
}

View File

@ -1,74 +0,0 @@
package com.yfd.platform.qgc_eng.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import java.util.Map;
/**
* 生态流量数据服务
*/
public interface EngEqDataService {
/**
* 处理kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @return 数据源结果
*/
DataSourceResult processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page);
/**
* 处理kendo返回列表字典匹配
* @param dataSourceRequest 数据源请求
* @param dataSourceResult 数据源结果
*/
void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult dataSourceResult);
/**
* 处理分组条件SQL
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @return SQL条件
*/
String processGroupConditionSql(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult);
/**
* 处理日数据kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @param groupBy 分组
* @return 数据源结果
*/
DataSourceResult processDayKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy);
/**
* 处理周旬月季年数据kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @param groupBy 分组
* @return 数据源结果
*/
DataSourceResult processKendoDrtpList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy);
/**
* 查询沿程第一个电站的生态流量数据时间
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @param groupBy 分组
* @return 数据源结果
*/
DataSourceResult getFastSiteLastData(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy);
/**
* 根据时间范围查询电站生态流量限值及来源
* @param dataSourceRequest 数据源请求
* @return 生态流量限值VO
*/
Object getEngLimit(DataSourceRequest dataSourceRequest);
}

View File

@ -1,59 +0,0 @@
package com.yfd.platform.qgc_eng.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.common.GroupResult;
import com.yfd.platform.qgc_eng.domain.MsEngEq;
import java.util.Map;
/**
* 生态流量区间统计服务
*/
public interface EngEqIntervalService {
/**
* 处理kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @return 数据源结果
*/
DataSourceResult processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page<MsEngEq> page);
/**
* 处理kendo返回列表字典匹配
* @param dataSourceRequest 数据源请求
* @param dataSourceResult 数据源结果
*/
void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult dataSourceResult);
/**
* 生态流量达标率 小时统计
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @param groupBy 分组
* @return 数据源结果
*/
DataSourceResult getQgcHourKendoListCust(DataSourceRequest dataSourceRequest, Map<String, GroupResult> filterResult, Page<MsEngEq> page, String groupBy);
/**
* 生态流量达标率 日统计
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @param groupBy 分组
* @return 数据源结果
*/
DataSourceResult getQgcDayKendoListCust(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page<MsEngEq> page, String groupBy);
/**
* 生态流量达标率 区间范围统计
* @param dataList 数据列表
* @param type 类型hour/day
* @return 统计结果
*/
Map<String, Object> getQgcQecStaticData(Object dataList, String type);
}

View File

@ -1,83 +0,0 @@
package com.yfd.platform.qgc_eng.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.common.GroupResult;
import com.yfd.platform.qgc_eng.domain.MsEngEq;
import java.util.Map;
/**
* 生态流量服务
*/
public interface EngEqService extends IService<MsEngEq> {
/**
* 处理kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @return 数据源结果
*/
DataSourceResult processKendoList(DataSourceRequest dataSourceRequest, Map<String, GroupResult> filterResult, Page page);
/**
* 处理kendo返回列表字典匹配
* @param dataSourceRequest 数据源请求
* @param dataSourceResult 数据源结果
*/
void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult dataSourceResult);
/**
* 处理分组条件SQL
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @return SQL条件
*/
String processGroupConditionSql(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult);
/**
* 月统计数据有数据的电站
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult lastEngDataSite(DataSourceRequest dataSourceRequest);
/**
* 获取生态流量默认有数据的电站
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult getDefaultStcd(DataSourceRequest dataSourceRequest);
/**
* 获取不达标详情数据
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult getSfdbInfo(DataSourceRequest dataSourceRequest);
/**
* 生态流量不达标测站数
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult qecSfdbCountByStcd(DataSourceRequest dataSourceRequest);
/**
* 生态流量达标率计算基地维度不达标原因维度
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult qecRateCount(DataSourceRequest dataSourceRequest);
/**
* 生态流量不达标数量计算电站维度不达标原因维度
* @param dataSourceRequest 数据源请求
* @return 数据源结果
*/
DataSourceResult qecSfdbCount(DataSourceRequest dataSourceRequest);
}

View File

@ -1,30 +0,0 @@
package com.yfd.platform.qgc_eng.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.qgc_eng.entity.EqSpecial;
import java.util.Map;
/**
* 电站专题-环保设施运行情况服务
*/
public interface EngSpecialService {
/**
* 处理kendo列表
* @param dataSourceRequest 数据源请求
* @param filterResult 筛选结果
* @param page 分页
* @return 数据源结果
*/
DataSourceResult<EqSpecial> processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page);
/**
* 处理kendo返回列表字典匹配
* @param dataSourceRequest 数据源请求
* @param dataSourceResult 数据源结果
*/
void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult<EqSpecial> dataSourceResult);
}

View File

@ -1,66 +0,0 @@
package com.yfd.platform.qgc_eng.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.qgc_eng.entity.vo.AlarmStcdCountVo;
import com.yfd.platform.qgc_eng.service.AlarmPointService;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 警报锚点服务实现
*/
@Service
public class AlarmPointServiceImpl implements AlarmPointService {
@Override
public DataSourceResult<AlarmStcdCountVo> processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page) {
// 模拟数据实际应该从数据库查询
List<AlarmStcdCountVo> dataList = new ArrayList<>();
// 模拟添加一些数据
AlarmStcdCountVo vo1 = new AlarmStcdCountVo();
vo1.setStcd("ST001");
vo1.setStnm("电站1");
vo1.setAlarmCount(10);
vo1.setUnhandledCount(3);
vo1.setHandlingCount(2);
vo1.setHandledCount(5);
dataList.add(vo1);
AlarmStcdCountVo vo2 = new AlarmStcdCountVo();
vo2.setStcd("ST002");
vo2.setStnm("电站2");
vo2.setAlarmCount(8);
vo2.setUnhandledCount(2);
vo2.setHandlingCount(1);
vo2.setHandledCount(5);
dataList.add(vo2);
DataSourceResult<AlarmStcdCountVo> result = new DataSourceResult<>();
result.setData(dataList);
result.setTotal(dataList.size());
return result;
}
@Override
public void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult<AlarmStcdCountVo> dataSourceResult) {
// 处理字典匹配实际应该根据业务需求实现
}
@Override
public AlarmStcdCountVo getAlarmCount(String stcd) {
// 模拟数据实际应该从数据库查询
AlarmStcdCountVo vo = new AlarmStcdCountVo();
vo.setStcd(stcd);
vo.setStnm("电站" + stcd);
vo.setAlarmCount(5);
vo.setUnhandledCount(1);
vo.setHandlingCount(1);
vo.setHandledCount(3);
return vo;
}
}

View File

@ -1,71 +0,0 @@
package com.yfd.platform.qgc_eng.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.qgc_eng.service.EngEqDataService;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Map;
/**
* 生态流量数据服务实现
*/
@Service
public class EngEqDataServiceImpl implements EngEqDataService {
@Override
public DataSourceResult processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult dataSourceResult) {
// 处理字典匹配实际应该根据业务需求实现
}
@Override
public String processGroupConditionSql(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult) {
// 模拟SQL条件实际应该根据业务需求实现
return "1=1";
}
@Override
public DataSourceResult processDayKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult processKendoDrtpList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult getFastSiteLastData(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page, String groupBy) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public Object getEngLimit(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
return null;
}
}

File diff suppressed because one or more lines are too long

View File

@ -1,158 +0,0 @@
package com.yfd.platform.qgc_eng.service.impl;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yfd.platform.common.*;
import com.yfd.platform.qgc_eng.domain.MsEngEq;
import com.yfd.platform.qgc_eng.mapper.EngEqMapper;
import com.yfd.platform.qgc_eng.service.EngEqService;
import com.yfd.platform.utils.KendoUtil;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 生态流量服务实现
*/
@Service
public class EngEqServiceImpl extends ServiceImpl<EngEqMapper, MsEngEq> implements EngEqService {
@Resource
MicroservicDynamicSQLMapper microservicDynamicSQLMapper;
@Override
public DataSourceResult processKendoList(DataSourceRequest dataSourceRequest, Map<String, GroupResult> filterResult, Page page) {
DataSourceResult dataSourceResult = new DataSourceResult<>();
StringBuilder sql = new StringBuilder();
String kendoGroupCode = "default";
String kendoGroupCode2 = "TM";
if (filterResult.get(kendoGroupCode) !=null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode).getSelectSql())) {
sql.append(filterResult.get("default").getSelectSql());
if (filterResult.get(kendoGroupCode2) !=null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode2).getSelectSql())) {
sql.append(StrUtil.replace(filterResult.get(kendoGroupCode2).getSelectSql(),"select",","));
}
sql.append(",MET1.QEC beforeQec FROM ");
sql.append(" MS_ENG_T MET left join MS_ENG_T MET1 on MET1.stcd=MET.stcd and MET1.TYPE=met.type and add_months(MET1.TM,12)=met.tm inner join V_MS_STBPRP_T MSB on MSB.STCD=MET.STCD where MSB.STTP_CODE = 'ENG' and MSB.BLDSTT_CCODE = 2 ");//去掉大中型电站过滤条件
}
if (filterResult.get(kendoGroupCode) !=null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode).getGroupSql())) {
sql.append(" and ").append(filterResult.get(kendoGroupCode).getGroupSql());
}
if (filterResult.get(kendoGroupCode2) != null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode2).getGroupSql())) {
sql.append(" and ").append(filterResult.get(kendoGroupCode2).getGroupSql());
}
if (filterResult.get(kendoGroupCode2) !=null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode2).getOrderBySql())) {
sql.append(" ").append(filterResult.get(kendoGroupCode2).getOrderBySql());
}
//组装分组条件
String groupBy = KendoUtil.getGroupBy(dataSourceRequest);
GroupingInfo[] group = dataSourceRequest.toDevRequest().getGroup();
if (StrUtil.isNotBlank(groupBy)) {
StringBuilder temp = new StringBuilder("select ");
List<String> groupFields = new ArrayList<>();
for (GroupingInfo item : group) {
groupFields.add(item.getSelector());
}
temp.append(StrUtil.join(",",groupFields));
for (GroupingInfo item : group) {
groupFields.add(item.getSelector());
temp.append(",").append("count(*) as count_").append(item.getSelector());
}
sql = temp.append(" from ( ").append(sql).append(" ) ").append(groupBy);
}
if (filterResult.get(kendoGroupCode) !=null && StrUtil.isNotBlank(filterResult.get(kendoGroupCode).getOrderBySql())) {
sql.append(" ").append(filterResult.get(kendoGroupCode).getOrderBySql());
}
//组装map参数
Map<String, Object> map = new HashMap<>();
for (String key : filterResult.keySet()) {
map.putAll(filterResult.get(key).getParamMap());
}
if (StrUtil.isNotBlank(groupBy)) {
List<Map<String, Object>> list = microservicDynamicSQLMapper.pageAllList(page, sql.toString(), map);
//是否扁平化分组
if (null != dataSourceRequest.getGroupResultFlat() && dataSourceRequest.getGroupResultFlat()) {
dataSourceResult.setData((new GroupHelper()).faltGroup(list, Arrays.asList(group)));
} else {
dataSourceResult.setData((new GroupHelper()).group(list, Arrays.asList(group)));
}
dataSourceResult.setTotal(0);
return dataSourceResult;
}
List<MsEngEq> list = microservicDynamicSQLMapper.pageAllListWithResultType(page, sql.toString(), map,MsEngEq.class);
dataSourceResult.setData(list);
dataSourceResult.setTotal(ObjectUtil.isNotEmpty(page) ? page.getTotal() : (long) list.size());
return dataSourceResult;
}
@Override
public void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult dataSourceResult) {
// 处理字典匹配实际应该根据业务需求实现
}
@Override
public String processGroupConditionSql(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult) {
// 模拟SQL条件实际应该根据业务需求实现
return "1=1";
}
@Override
public DataSourceResult lastEngDataSite(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult getDefaultStcd(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult getSfdbInfo(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult qecSfdbCountByStcd(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult qecRateCount(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
@Override
public DataSourceResult qecSfdbCount(DataSourceRequest dataSourceRequest) {
// 模拟数据实际应该从数据库查询
DataSourceResult result = new DataSourceResult();
result.setData(new ArrayList<>());
result.setTotal(0L);
return result;
}
}

View File

@ -1,59 +0,0 @@
package com.yfd.platform.qgc_eng.service.impl;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yfd.platform.common.DataSourceRequest;
import com.yfd.platform.common.DataSourceResult;
import com.yfd.platform.qgc_eng.entity.EqSpecial;
import com.yfd.platform.qgc_eng.service.EngSpecialService;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 电站专题-环保设施运行情况服务实现
*/
@Service
public class EngSpecialServiceImpl implements EngSpecialService {
@Override
public DataSourceResult<EqSpecial> processKendoList(DataSourceRequest dataSourceRequest, Map<String, Object> filterResult, Page page) {
// 模拟数据实际应该从数据库查询
List<EqSpecial> dataList = new ArrayList<>();
// 模拟添加一些数据
EqSpecial special1 = new EqSpecial();
special1.setId("1");
special1.setStcd("ST001");
special1.setStnm("电站1");
special1.setEqType("生态流量监测设施");
special1.setEqName("流量监测仪");
special1.setStatus("正常运行");
special1.setCheckTime("2023-04-14");
special1.setChecker("张三");
special1.setRemark("");
dataList.add(special1);
EqSpecial special2 = new EqSpecial();
special2.setId("2");
special2.setStcd("ST002");
special2.setStnm("电站2");
special2.setEqType("水质监测设施");
special2.setEqName("水质分析仪");
special2.setStatus("正常运行");
special2.setCheckTime("2023-04-15");
special2.setChecker("李四");
special2.setRemark("");
dataList.add(special2);
DataSourceResult<EqSpecial> result = new DataSourceResult<>();
result.setData(dataList);
result.setTotal(dataList.size());
return result;
}
@Override
public void processKendoGetListLoadResult(DataSourceRequest dataSourceRequest, DataSourceResult<EqSpecial> dataSourceResult) {
// 处理字典匹配实际应该根据业务需求实现
}
}