diff --git a/backend/src/main/java/com/yfd/platform/qgc_base/controller/SdEngInfoBHController.java b/backend/src/main/java/com/yfd/platform/qgc_base/controller/SdEngInfoBHController.java index feb06ac0..4382224e 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_base/controller/SdEngInfoBHController.java +++ b/backend/src/main/java/com/yfd/platform/qgc_base/controller/SdEngInfoBHController.java @@ -2,6 +2,7 @@ package com.yfd.platform.qgc_base.controller; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.yfd.platform.annotation.Log; +import com.yfd.platform.common.DataSourceRequest; import com.yfd.platform.config.ResponseResult; import com.yfd.platform.qgc_base.domain.SdEngInfoBH; import com.yfd.platform.qgc_base.domain.SdEngInfoBHRequest; @@ -81,6 +82,12 @@ public class SdEngInfoBHController { return ResponseResult.successData(engInfoBHService.selectRegDropdown(sdEngInfoBHRequest)); } + @PostMapping("/vmsstbprpt/GetKendoList") + @Operation(summary = "电站统计查询") + public ResponseResult getVmsstbprptList(@RequestBody DataSourceRequest dataSourceRequest) { + return ResponseResult.successData(engInfoBHService.getVmsstbprptKendoList(dataSourceRequest)); + } + @Log(module = "电站管理", value = "新增电站") @PostMapping("/add") @Operation(summary = "新增电站") @@ -104,4 +111,4 @@ public class SdEngInfoBHController { boolean result = engInfoBHService.deleteEngInfo(stcd); return result ? ResponseResult.success("删除成功") : ResponseResult.error("删除失败"); } -} \ No newline at end of file +} diff --git a/backend/src/main/java/com/yfd/platform/qgc_base/domain/vo/EngVmsstbprptVo.java b/backend/src/main/java/com/yfd/platform/qgc_base/domain/vo/EngVmsstbprptVo.java new file mode 100644 index 00000000..ba6b5723 --- /dev/null +++ b/backend/src/main/java/com/yfd/platform/qgc_base/domain/vo/EngVmsstbprptVo.java @@ -0,0 +1,110 @@ +package com.yfd.platform.qgc_base.domain.vo; + +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +@Data +@Schema(description = "电站统计查询") +public class EngVmsstbprptVo implements Serializable { + + private static final long serialVersionUID = 1L; + + private String id; + private String sttpCode; + private String sttpName; + private String stcd; + private String stnm; + private String ennm; + private String baseId; + private String baseName; + private String hbrvcd; + private String hbrvcdName; + private String rvcd; + private String rvcdName; + private String addvcdName; + private String hynm; + private String topHynm; + private String stlc; + private Date jcdt; + private Date piodt; + private Date aiodt; + private String bldstt; + private Integer bldsttCcode; + private Double nrupar; + private Double dstcrvr; + private Double avyrp; + private Double avw; + private Double avq; + private Double avq01; + private Double avq02; + private Double avq03; + private Double avq04; + private Double avq05; + private Double avq06; + private Double avq07; + private Double avq08; + private Double avq09; + private Double avq10; + private Double avq11; + private Double avq12; + private Double obmxq; + private Double obmnq; + private Double hmxq; + private String dsnfqfrq; + private Integer dsrcin; + private String ckfqfqr; + private Integer chrcin; + private Double obmxw3; + private Double dsw3; + private Double ckw3; + private Double avsd; + private Double avs; + private Double obmxs; + private Double ckflz; + private Double dsflz; + private Double normz; + private Double uzfc; + private Double fsltdz; + private String ydownz; + private Double ddz; + private Double nrzar; + private Double bcklen; + private Double ttcp; + private Double nmzcp; + private String fldcpStr; + private Double actcp; + private Double ddcp; + private Double cpsc; + private String rgcp; + private Double dsflzmxq; + private Double dsflzxyz; + private Double ckflzmxq; + private Double ckflzxyz; + private Double ksqadjq; + private Double ksqxyz; + private String gemaxrq; + private Double mxgeqxyz; + private Double ttpwr; + private Integer gncnt; + private String gntp; + private Double grntpwr; + private Double yrge; + private Double ushr; + private Double k; + private String dmtp; + private Double dmcrel; + private Double mxdmhg; + private Double dmlen; + private Double sgyge; + private Double unyge; + private Double gap; + private String dvtp; + private Integer dtin; + private Integer baseStepSort; + private Integer rvcdStepSort; + private Integer rstcdStepSort; + private Integer siteStepSort; +} diff --git a/backend/src/main/java/com/yfd/platform/qgc_base/service/ISdEngInfoBHService.java b/backend/src/main/java/com/yfd/platform/qgc_base/service/ISdEngInfoBHService.java index 5a14f586..c26255a1 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_base/service/ISdEngInfoBHService.java +++ b/backend/src/main/java/com/yfd/platform/qgc_base/service/ISdEngInfoBHService.java @@ -8,6 +8,7 @@ import com.yfd.platform.qgc_base.domain.SdEngInfoBH; import com.yfd.platform.qgc_base.domain.SdEngInfoBHRequest; import com.yfd.platform.qgc_base.domain.vo.EngBaseInfoVo; import com.yfd.platform.qgc_base.domain.vo.EngEiaapprovalVo; +import com.yfd.platform.qgc_base.domain.vo.EngVmsstbprptVo; import java.util.List; import java.util.Set; @@ -66,4 +67,6 @@ public interface ISdEngInfoBHService extends IService { EngBaseInfoVo getStInfoByStcd(String stcd); DataSourceResult getEiaapprovalKendoList(DataSourceRequest dataSourceRequest); + + DataSourceResult getVmsstbprptKendoList(DataSourceRequest dataSourceRequest); } diff --git a/backend/src/main/java/com/yfd/platform/qgc_base/service/impl/SdEngInfoBHServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_base/service/impl/SdEngInfoBHServiceImpl.java index d1e63e39..56ac8a13 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_base/service/impl/SdEngInfoBHServiceImpl.java +++ b/backend/src/main/java/com/yfd/platform/qgc_base/service/impl/SdEngInfoBHServiceImpl.java @@ -2,11 +2,16 @@ package com.yfd.platform.qgc_base.service.impl; import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.bean.copier.CopyOptions; +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.StrUtil; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; 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.GroupHelper; +import com.yfd.platform.common.GroupingInfo; import com.yfd.platform.common.MicroservicDynamicSQLMapper; import com.yfd.platform.qgc_data.domain.SysUserDataScope; import com.yfd.platform.qgc_data.mapper.SysUserDataScopeMapper; @@ -14,16 +19,20 @@ import com.yfd.platform.qgc_base.domain.SdEngInfoBH; import com.yfd.platform.qgc_base.domain.SdEngInfoBHRequest; import com.yfd.platform.qgc_base.domain.vo.EngBaseInfoVo; import com.yfd.platform.qgc_base.domain.vo.EngEiaapprovalVo; +import com.yfd.platform.qgc_base.domain.vo.EngVmsstbprptVo; import com.yfd.platform.qgc_base.mapper.SdEngInfoBHMapper; import com.yfd.platform.qgc_base.service.ISdEngInfoBHService; +import com.yfd.platform.utils.QgcQueryWrapperUtil; import com.yfd.platform.utils.SecurityUtils; import jakarta.annotation.Resource; import org.springframework.stereotype.Service; import org.springframework.util.StringUtils; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; @@ -207,6 +216,137 @@ public class SdEngInfoBHServiceImpl extends ServiceImpl getVmsstbprptKendoList(DataSourceRequest dataSourceRequest) { + DataSourceResult result = new DataSourceResult<>(); + result.setAggregates(new HashMap<>()); + if (dataSourceRequest == null) { + result.setData(new ArrayList<>()); + result.setTotal(0L); + return result; + } + + Set authorizedStations = null; +// if (!"admin".equals(SecurityUtils.getCurrentUsername())) { +// authorizedStations = getUserAuthorizedStationCodes(); +// if (authorizedStations == null || authorizedStations.isEmpty()) { +// result.setData(new ArrayList<>()); +// result.setTotal(0L); +// return result; +// } +// } + + DataSourceLoadOptionsBase loadOptions = dataSourceRequest.toDevRequest(); + if (CollUtil.isEmpty(dataSourceRequest.getGroup())) { + return queryVmsstbprptDetailList(dataSourceRequest, loadOptions, authorizedStations); + } + return queryVmsstbprptGroupList(dataSourceRequest, loadOptions, authorizedStations); + } + + private DataSourceResult queryVmsstbprptDetailList(DataSourceRequest dataSourceRequest, + DataSourceLoadOptionsBase loadOptions, + Set authorizedStations) { + StringBuilder sql = new StringBuilder(); + sql.append("SELECT ") + .append(buildVmsstbprptDetailSelectSql(dataSourceRequest.getSelect())) + .append(" FROM (") + .append(buildVmsstbprptViewSql()) + .append(") t WHERE 1 = 1 "); + + Map paramMap = new HashMap<>(); + appendAuthorizedStations(sql, paramMap, authorizedStations, "t.stcd"); + + String filterSql = buildVmsstbprptFilterCondition(dataSourceRequest.getFilter(), paramMap, new int[]{0}); + if (StrUtil.isNotBlank(filterSql)) { + sql.append(" AND ").append(filterSql); + } + sql.append(buildVmsstbprptDetailOrderBySql(dataSourceRequest.getSort())); + + Page page = loadOptions == null ? null : QgcQueryWrapperUtil.buildPage(loadOptions, loadOptions.getSkip(), loadOptions.getTake()); + List list = microservicDynamicSQLMapper.pageAllListWithResultType(page, sql.toString(), paramMap, EngVmsstbprptVo.class); + DataSourceResult result = new DataSourceResult<>(); + result.setData(list); + result.setTotal(page == null ? list.size() : page.getTotal()); + result.setAggregates(new HashMap<>()); + return result; + } + + private DataSourceResult queryVmsstbprptGroupList(DataSourceRequest dataSourceRequest, + DataSourceLoadOptionsBase loadOptions, + Set authorizedStations) { + List groups = dataSourceRequest.getGroup(); + GroupingInfo[] groupInfos = loadOptions == null ? new GroupingInfo[0] : loadOptions.getGroup(); + List selectItems = new ArrayList<>(); + for (DataSourceRequest.GroupDescriptor descriptor : groups) { + if (descriptor == null || StrUtil.isBlank(descriptor.getField())) { + continue; + } + String column = mapVmsstbprptColumn(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 = mapVmsstbprptColumn(aggregate.getField()); + if (StrUtil.isBlank(aggregateColumn) || StrUtil.isBlank(aggregate.getAggregate())) { + continue; + } + String aggregateSql = buildAggregateSql(aggregate.getAggregate(), aggregateColumn, aggregate.getField()); + if (StrUtil.isNotBlank(aggregateSql)) { + selectItems.add(aggregateSql); + } + } + } + } + if (selectItems.isEmpty()) { + selectItems.add("t.STCD AS STCD"); + selectItems.add("COUNT(*) AS COUNT_STCD"); + } + + StringBuilder sql = new StringBuilder(); + sql.append("SELECT ") + .append(String.join(", ", selectItems)) + .append(" FROM (") + .append(buildVmsstbprptViewSql()) + .append(") t WHERE 1 = 1 "); + + Map paramMap = new HashMap<>(); + appendAuthorizedStations(sql, paramMap, authorizedStations, "t.stcd"); + + String filterSql = buildVmsstbprptFilterCondition(dataSourceRequest.getFilter(), paramMap, new int[]{0}); + if (StrUtil.isNotBlank(filterSql)) { + sql.append(" AND ").append(filterSql); + } + + List groupByColumns = new ArrayList<>(); + for (DataSourceRequest.GroupDescriptor descriptor : groups) { + if (descriptor == null || StrUtil.isBlank(descriptor.getField())) { + continue; + } + String column = mapVmsstbprptColumn(descriptor.getField()); + if (StrUtil.isNotBlank(column)) { + groupByColumns.add(column); + } + } + if (!groupByColumns.isEmpty()) { + sql.append(" GROUP BY ").append(String.join(", ", groupByColumns)); + } + sql.append(buildVmsstbprptGroupOrderBySql(groups)); + + List> rows = microservicDynamicSQLMapper.pageAllList(null, sql.toString(), paramMap); + DataSourceResult result = new DataSourceResult<>(); + if (Boolean.TRUE.equals(dataSourceRequest.getGroupResultFlat())) { + result.setData((List) (List) new GroupHelper().faltGroup(rows, Arrays.asList(groupInfos))); + } else { + result.setData((List) (List) new GroupHelper().group(rows, Arrays.asList(groupInfos))); + } + result.setTotal((long) rows.size()); + result.setAggregates(new HashMap<>()); + return result; + } + @Override public DataSourceResult getEiaapprovalKendoList(DataSourceRequest dataSourceRequest) { DataSourceResult result = new DataSourceResult<>(); @@ -319,6 +459,470 @@ public class SdEngInfoBHServiceImpl extends ServiceImpl selectFields) { + Map columns = vmsstbprptFieldColumns(); + List 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 vmsstbprptFieldColumns() { + Map columns = new LinkedHashMap<>(); + columns.put("id", "t.id AS id"); + columns.put("sttpCode", "t.sttpCode AS sttpCode"); + columns.put("sttpName", "t.sttpName AS sttpName"); + columns.put("stcd", "t.stcd AS stcd"); + columns.put("stnm", "t.stnm AS stnm"); + columns.put("ennm", "t.ennm AS ennm"); + columns.put("baseId", "t.baseId AS baseId"); + columns.put("baseName", "t.baseName AS baseName"); + columns.put("hbrvcd", "t.hbrvcd AS hbrvcd"); + columns.put("hbrvcdName", "t.hbrvcdName AS hbrvcdName"); + columns.put("rvcd", "t.rvcd AS rvcd"); + columns.put("rvcdName", "t.rvcdName AS rvcdName"); + columns.put("addvcdName", "t.addvcdName AS addvcdName"); + columns.put("hynm", "t.hynm AS hynm"); + columns.put("topHynm", "t.topHynm AS topHynm"); + columns.put("stlc", "t.stlc AS stlc"); + columns.put("jcdt", "t.jcdt AS jcdt"); + columns.put("piodt", "t.piodt AS piodt"); + columns.put("aiodt", "t.aiodt AS aiodt"); + columns.put("bldstt", "t.bldstt AS bldstt"); + columns.put("bldsttCcode", "t.bldsttCcode AS bldsttCcode"); + columns.put("nrupar", "t.nrupar AS nrupar"); + columns.put("dstcrvr", "t.dstcrvr AS dstcrvr"); + columns.put("avyrp", "t.avyrp AS avyrp"); + columns.put("avw", "t.avw AS avw"); + columns.put("avq", "t.avq AS avq"); + columns.put("avq01", "t.avq01 AS avq01"); + columns.put("avq02", "t.avq02 AS avq02"); + columns.put("avq03", "t.avq03 AS avq03"); + columns.put("avq04", "t.avq04 AS avq04"); + columns.put("avq05", "t.avq05 AS avq05"); + columns.put("avq06", "t.avq06 AS avq06"); + columns.put("avq07", "t.avq07 AS avq07"); + columns.put("avq08", "t.avq08 AS avq08"); + columns.put("avq09", "t.avq09 AS avq09"); + columns.put("avq10", "t.avq10 AS avq10"); + columns.put("avq11", "t.avq11 AS avq11"); + columns.put("avq12", "t.avq12 AS avq12"); + columns.put("obmxq", "t.obmxq AS obmxq"); + columns.put("obmnq", "t.obmnq AS obmnq"); + columns.put("hmxq", "t.hmxq AS hmxq"); + columns.put("dsnfqfrq", "t.dsnfqfrq AS dsnfqfrq"); + columns.put("dsrcin", "t.dsrcin AS dsrcin"); + columns.put("ckfqfqr", "t.ckfqfqr AS ckfqfqr"); + columns.put("chrcin", "t.chrcin AS chrcin"); + columns.put("obmxw3", "t.obmxw3 AS obmxw3"); + columns.put("dsw3", "t.dsw3 AS dsw3"); + columns.put("ckw3", "t.ckw3 AS ckw3"); + columns.put("avsd", "t.avsd AS avsd"); + columns.put("avs", "t.avs AS avs"); + columns.put("obmxs", "t.obmxs AS obmxs"); + columns.put("ckflz", "t.ckflz AS ckflz"); + columns.put("dsflz", "t.dsflz AS dsflz"); + columns.put("normz", "t.normz AS normz"); + columns.put("uzfc", "t.uzfc AS uzfc"); + columns.put("fsltdz", "t.fsltdz AS fsltdz"); + columns.put("ydownz", "t.ydownz AS ydownz"); + columns.put("ddz", "t.ddz AS ddz"); + columns.put("nrzar", "t.nrzar AS nrzar"); + columns.put("bcklen", "t.bcklen AS bcklen"); + columns.put("ttcp", "t.ttcp AS ttcp"); + columns.put("nmzcp", "t.nmzcp AS nmzcp"); + columns.put("fldcpStr", "t.fldcpStr AS fldcpStr"); + columns.put("actcp", "t.actcp AS actcp"); + columns.put("ddcp", "t.ddcp AS ddcp"); + columns.put("cpsc", "t.cpsc AS cpsc"); + columns.put("rgcp", "t.rgcp AS rgcp"); + columns.put("dsflzmxq", "t.dsflzmxq AS dsflzmxq"); + columns.put("dsflzxyz", "t.dsflzxyz AS dsflzxyz"); + columns.put("ckflzmxq", "t.ckflzmxq AS ckflzmxq"); + columns.put("ckflzxyz", "t.ckflzxyz AS ckflzxyz"); + columns.put("ksqadjq", "t.ksqadjq AS ksqadjq"); + columns.put("ksqxyz", "t.ksqxyz AS ksqxyz"); + columns.put("gemaxrq", "t.gemaxrq AS gemaxrq"); + columns.put("mxgeqxyz", "t.mxgeqxyz AS mxgeqxyz"); + columns.put("ttpwr", "t.ttpwr AS ttpwr"); + columns.put("gncnt", "t.gncnt AS gncnt"); + columns.put("gntp", "t.gntp AS gntp"); + columns.put("grntpwr", "t.grntpwr AS grntpwr"); + columns.put("yrge", "t.yrge AS yrge"); + columns.put("ushr", "t.ushr AS ushr"); + columns.put("k", "t.k AS k"); + columns.put("dmtp", "t.dmtp AS dmtp"); + columns.put("dmcrel", "t.dmcrel AS dmcrel"); + columns.put("mxdmhg", "t.mxdmhg AS mxdmhg"); + columns.put("dmlen", "t.dmlen AS dmlen"); + columns.put("sgyge", "t.sgyge AS sgyge"); + columns.put("unyge", "t.unyge AS unyge"); + columns.put("gap", "t.gap AS gap"); + columns.put("dvtp", "t.dvtp AS dvtp"); + columns.put("dtin", "t.dtin AS dtin"); + columns.put("baseStepSort", "t.baseStepSort AS baseStepSort"); + columns.put("rvcdStepSort", "t.rvcdStepSort AS rvcdStepSort"); + columns.put("rstcdStepSort", "t.rstcdStepSort AS rstcdStepSort"); + columns.put("siteStepSort", "t.siteStepSort AS siteStepSort"); + return columns; + } + + private String buildVmsstbprptFilterCondition(DataSourceRequest.FilterDescriptor filter, + Map paramMap, + int[] indexHolder) { + if (filter == null) { + return ""; + } + if (StrUtil.isNotBlank(filter.getField())) { + return buildVmsstbprptLeafCondition(filter, paramMap, indexHolder); + } + if (CollUtil.isEmpty(filter.getFilters())) { + return ""; + } + List childConditions = new ArrayList<>(); + for (DataSourceRequest.FilterDescriptor child : filter.getFilters()) { + String childSql = buildVmsstbprptFilterCondition(child, paramMap, indexHolder); + if (StrUtil.isNotBlank(childSql)) { + childConditions.add("(" + childSql + ")"); + } + } + if (childConditions.isEmpty()) { + return ""; + } + String logic = "or".equalsIgnoreCase(filter.getLogic()) ? " OR " : " AND "; + return String.join(logic, childConditions); + } + + private String buildVmsstbprptLeafCondition(DataSourceRequest.FilterDescriptor filter, + Map paramMap, + int[] indexHolder) { + String column = mapVmsstbprptColumn(filter.getField()); + if (StrUtil.isBlank(column)) { + return ""; + } + String operator = filter.getOperator() == null ? "eq" : filter.getOperator().toLowerCase(); + if ("sttpCode".equalsIgnoreCase(filter.getField()) && "eq".equals(operator) && filter.getValue() != null) { + return "t.sttpCode = 'ENG'"; + } + return buildVmsstbprptCondition(column, filter, paramMap, indexHolder, isVmsstbprptDateField(filter.getField())); + } + + private String buildVmsstbprptCondition(String column, + DataSourceRequest.FilterDescriptor filter, + Map paramMap, + int[] indexHolder, + boolean dateField) { + String operator = filter.getOperator() == null ? "eq" : filter.getOperator().toLowerCase(); + Object value = filter.getValue(); + if ("isnull".equals(operator)) { + return column + " IS NULL"; + } + if ("isnotnull".equals(operator)) { + return column + " IS NOT NULL"; + } + if ("in".equals(operator)) { + List values = normalizeFilterValues(value); + if (values.isEmpty()) { + return ""; + } + List placeholders = new ArrayList<>(); + for (Object item : values) { + String key = "vmsParam" + indexHolder[0]++; + paramMap.put(key, item); + placeholders.add("#{map." + key + "}"); + } + return column + " IN (" + String.join(", ", placeholders) + ")"; + } + if (value == null) { + return ""; + } + String key = "vmsParam" + indexHolder[0]++; + String expr = buildVmsstbprptValueExpr(key, dateField, value); + return switch (operator) { + case "eq" -> { + paramMap.put(key, value); + yield column + " = " + expr; + } + case "neq" -> { + paramMap.put(key, value); + yield column + " <> " + expr; + } + 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 + " > " + expr; + } + case "gte" -> { + paramMap.put(key, value); + yield column + " >= " + expr; + } + case "lt" -> { + paramMap.put(key, value); + yield column + " < " + expr; + } + case "lte" -> { + paramMap.put(key, value); + yield column + " <= " + expr; + } + default -> ""; + }; + } + + private String buildVmsstbprptValueExpr(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 boolean isVmsstbprptDateField(String field) { + if (StrUtil.isBlank(field)) { + return false; + } + return switch (field) { + case "jcdt", "piodt", "aiodt" -> true; + default -> false; + }; + } + + private String buildVmsstbprptDetailOrderBySql(List sortList) { + if (CollUtil.isEmpty(sortList)) { + return " ORDER BY baseStepSort ASC, rvcdStepSort ASC, rstcdStepSort ASC, siteStepSort ASC, stnm ASC"; + } + List orderItems = new ArrayList<>(); + for (DataSourceRequest.SortDescriptor sortDescriptor : sortList) { + if (sortDescriptor == null || StrUtil.isBlank(sortDescriptor.getField())) { + continue; + } + String column = mapVmsstbprptColumn(sortDescriptor.getField()); + if (StrUtil.isBlank(column)) { + continue; + } + String dir = "desc".equalsIgnoreCase(sortDescriptor.getDir()) ? "DESC" : "ASC"; + orderItems.add(column + " " + dir); + } + if (orderItems.isEmpty()) { + return " ORDER BY baseStepSort ASC, rvcdStepSort ASC, rstcdStepSort ASC, siteStepSort ASC, stnm ASC"; + } + return " ORDER BY " + String.join(", ", orderItems); + } + + private String buildVmsstbprptGroupOrderBySql(List groups) { + if (CollUtil.isEmpty(groups)) { + return ""; + } + List orderItems = new ArrayList<>(); + for (DataSourceRequest.GroupDescriptor descriptor : groups) { + if (descriptor == null || StrUtil.isBlank(descriptor.getField())) { + continue; + } + String column = mapVmsstbprptColumn(descriptor.getField()); + if (StrUtil.isBlank(column)) { + continue; + } + String dir = "desc".equalsIgnoreCase(descriptor.getDir()) ? "DESC" : "ASC"; + orderItems.add(column + " " + dir); + } + return orderItems.isEmpty() ? "" : " ORDER BY " + String.join(", ", orderItems); + } + + private String buildAggregateSql(String aggregate, String column, String field) { + String upperField = field == null ? "" : field.toUpperCase(); + return switch (aggregate.toLowerCase()) { + case "sum" -> "SUM(" + column + ") AS SUM_" + upperField; + case "avg" -> "AVG(" + column + ") AS AVG_" + upperField; + case "min" -> "MIN(" + column + ") AS MIN_" + upperField; + case "max" -> "MAX(" + column + ") AS MAX_" + upperField; + case "count" -> "COUNT(" + column + ") AS COUNT_" + upperField; + default -> null; + }; + } + + private String mapVmsstbprptColumn(String field) { + if (StrUtil.isBlank(field)) { + return null; + } + return switch (field) { + case "id" -> "t.id"; + case "sttpCode" -> "t.sttpCode"; + case "sttpName" -> "t.sttpName"; + case "stcd" -> "t.stcd"; + case "stnm", "ennm" -> "t.stnm"; + case "baseId" -> "t.baseId"; + case "baseName" -> "t.baseName"; + case "hbrvcd" -> "t.hbrvcd"; + case "hbrvcdName" -> "t.hbrvcdName"; + case "rvcd" -> "t.rvcd"; + case "rvcdName" -> "t.rvcdName"; + case "addvcdName" -> "t.addvcdName"; + case "hynm" -> "t.hynm"; + case "topHynm" -> "t.topHynm"; + case "stlc" -> "t.stlc"; + case "jcdt", "piodt", "aiodt" -> "t." + field; + case "bldstt", "rgcp", "gntp", "dmtp", "dvtp", "ydownz", "gemaxrq" -> "t." + field; + case "bldsttCcode", "dsrcin", "chrcin", "dtin", "gncnt" -> "t." + field; + case "nrupar", "dstcrvr", "avyrp", "avw", "avq", + "avq01", "avq02", "avq03", "avq04", "avq05", "avq06", "avq07", "avq08", "avq09", "avq10", "avq11", "avq12", + "obmxq", "obmnq", "hmxq", "obmxw3", "dsw3", "ckw3", "avsd", "avs", "obmxs", "ckflz", "dsflz", "normz", + "uzfc", "fsltdz", "ddz", "nrzar", "bcklen", "ttcp", "nmzcp", "actcp", "ddcp", "cpsc", "dsflzmxq", + "dsflzxyz", "ckflzmxq", "ckflzxyz", "ksqadjq", "ksqxyz", "mxgeqxyz", "ttpwr", "grntpwr", "yrge", "ushr", + "k", "dmcrel", "mxdmhg", "dmlen", "sgyge", "unyge", "gap" -> "t." + field; + case "fldcpStr" -> "t.fldcpStr"; + case "baseStepSort" -> "NVL(t.baseStepSort, 999999)"; + case "rvcdStepSort" -> "NVL(t.rvcdStepSort, 999999)"; + case "rstcdStepSort" -> "NVL(t.rstcdStepSort, 999999)"; + case "siteStepSort" -> "NVL(t.siteStepSort, 999999)"; + default -> null; + }; + } + private String buildEiaapprovalBaseSql() { return "SELECT " + "e.ID AS id, " + @@ -384,6 +988,13 @@ public class SdEngInfoBHServiceImpl extends ServiceImpl paramMap, Set authorizedStations) { + appendAuthorizedStations(sql, paramMap, authorizedStations, "e.STCD"); + } + + private void appendAuthorizedStations(StringBuilder sql, + Map paramMap, + Set authorizedStations, + String column) { if (authorizedStations == null || authorizedStations.isEmpty()) { return; } @@ -394,7 +1005,7 @@ public class SdEngInfoBHServiceImpl extends ServiceImpl