diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/overview/controller/OverviewController.java b/backend/src/main/java/com/yfd/platform/qgc_env/overview/controller/OverviewController.java new file mode 100644 index 00000000..5858db55 --- /dev/null +++ b/backend/src/main/java/com/yfd/platform/qgc_env/overview/controller/OverviewController.java @@ -0,0 +1,29 @@ +package com.yfd.platform.qgc_env.overview.controller; + +import com.yfd.platform.common.DataSourceRequest; +import com.yfd.platform.config.ResponseResult; +import com.yfd.platform.qgc_env.overview.service.OverviewService; +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("/overview") +@Tag(name = "首页概览") +@Validated +public class OverviewController { + + @Resource + private OverviewService overviewService; + + @PostMapping("/msstbprpt/GetKendoList") + @Operation(summary = "首页基础设施概览列表") + public ResponseResult getMsstbprptList(@RequestBody DataSourceRequest dataSourceRequest) { + return ResponseResult.successData(overviewService.getMsstbprptList(dataSourceRequest)); + } +} diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/overview/entity/vo/OverviewMsstbprptVo.java b/backend/src/main/java/com/yfd/platform/qgc_env/overview/entity/vo/OverviewMsstbprptVo.java new file mode 100644 index 00000000..effa1e33 --- /dev/null +++ b/backend/src/main/java/com/yfd/platform/qgc_env/overview/entity/vo/OverviewMsstbprptVo.java @@ -0,0 +1,72 @@ +package com.yfd.platform.qgc_env.overview.entity.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 OverviewMsstbprptVo implements Serializable { + + private static final long serialVersionUID = 1L; + + private String id; + private String stcd; + private String stnm; + private String sttp; + private String sttpCode; + private String sttpName; + private String sttpFullPath; + private Integer sttpTreeLevel; + private String blprdId; + private Double lgtd; + private Double lttd; + private Double dtmel; + private String stlc; + private Integer usfl; + private String rstcd; + private String ennm; + private String baseId; + private String baseName; + private String hbrvcd; + private String hbrvcdName; + private String rvcd; + private String rvcdName; + private String addvcd; + private String addvcdName; + private String country; + private String countryName; + private String stCode; + private String stName; + private Date stdsdt; + private Date pststdt; + private Date pesstdt; + private Date ststdt; + private Date jcdt; + private Date stwddt; + private String introduce; + private String precis; + private String logo; + private String inffile; + private Integer dtin; + private String dtinName; + private Date dtinTm; + private Integer bldsttCode; + private String bldsttCcode; + private String bldsttCcodeName; + private Double inv; + private Integer invinmn; + private String dsun; + private String jbtxcs; + private Integer dtfrqcy; + private String remark; + private String vlsr; + private Date vlsrTm; + private Integer orderIndex; + private Integer baseStepSort; + private Integer rvcdStepSort; + private Integer rstcdStepSort; + private Integer siteStepSort; +} diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/OverviewService.java b/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/OverviewService.java new file mode 100644 index 00000000..c8be8692 --- /dev/null +++ b/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/OverviewService.java @@ -0,0 +1,10 @@ +package com.yfd.platform.qgc_env.overview.service; + +import com.yfd.platform.common.DataSourceRequest; +import com.yfd.platform.common.DataSourceResult; +import com.yfd.platform.qgc_env.overview.entity.vo.OverviewMsstbprptVo; + +public interface OverviewService { + + DataSourceResult getMsstbprptList(DataSourceRequest dataSourceRequest); +} diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/impl/OverviewServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/impl/OverviewServiceImpl.java new file mode 100644 index 00000000..f516c562 --- /dev/null +++ b/backend/src/main/java/com/yfd/platform/qgc_env/overview/service/impl/OverviewServiceImpl.java @@ -0,0 +1,599 @@ +package com.yfd.platform.qgc_env.overview.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.MicroservicDynamicSQLMapper; +import com.yfd.platform.qgc_env.overview.entity.vo.OverviewMsstbprptVo; +import com.yfd.platform.qgc_env.overview.service.OverviewService; +import com.yfd.platform.utils.QgcQueryWrapperUtil; +import jakarta.annotation.Resource; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; + +@Service +public class OverviewServiceImpl implements OverviewService { + + @Resource + private MicroservicDynamicSQLMapper microservicDynamicSQLMapper; + + @Override + public DataSourceResult getMsstbprptList(DataSourceRequest dataSourceRequest) { + DataSourceLoadOptionsBase loadOptions = dataSourceRequest == null ? null : dataSourceRequest.toDevRequest(); + List selectFields = resolveSelectFields(dataSourceRequest == null ? null : dataSourceRequest.getSelect()); + + StringBuilder sql = new StringBuilder(); + sql.append("SELECT ") + .append(buildSelectSql(selectFields)) + .append(" FROM (") + .append(buildBaseSql()) + .append(") t WHERE 1 = 1 "); + + Map paramMap = new HashMap<>(); + String filterSql = buildFilterCondition(dataSourceRequest == null ? null : dataSourceRequest.getFilter(), paramMap, new int[]{0}); + if (StrUtil.isNotBlank(filterSql)) { + sql.append(" AND ").append(filterSql); + } + sql.append(buildOrderBySql(dataSourceRequest == null ? null : dataSourceRequest.getSort())); + + Page page = loadOptions == null ? null + : QgcQueryWrapperUtil.buildPage(loadOptions, loadOptions.getSkip(), loadOptions.getTake()); + List list = microservicDynamicSQLMapper.pageAllListWithResultType( + page, sql.toString(), paramMap, OverviewMsstbprptVo.class + ); + + DataSourceResult result = new DataSourceResult<>(); + result.setData(list); + result.setTotal(page == null ? list.size() : page.getTotal()); + result.setAggregates(new HashMap<>()); + return result; + } + + private String buildBaseSql() { + return buildFbSql() + " UNION ALL " + buildDwSql() + " UNION ALL " + buildFpSql(); + } + + private String buildFbSql() { + return "SELECT " + + "fb.STCD AS id, " + + "fb.STCD AS stcd, " + + "fb.STNM AS stnm, " + + "fb.STTP AS sttp, " + + "fb.STTP AS sttpCode, " + + "sttp.STTP_NAME AS sttpName, " + + "sttp.FULL_PATH AS sttpFullPath, " + + "sttp.TREE_LEVEL AS sttpTreeLevel, " + + "CAST(fb.BLPRD AS VARCHAR2(64)) AS blprdId, " + + "fb.LGTD AS lgtd, " + + "fb.LTTD AS lttd, " + + "fb.ELEV AS dtmel, " + + "fb.STLC AS stlc, " + + "fb.USFL AS usfl, " + + "fb.RSTCD AS rstcd, " + + "eng.ENNM AS ennm, " + + "NVL(fb.BASE_ID, eng.BASE_ID) AS baseId, " + + "hb.BASENAME AS baseName, " + + "NVL(fb.HBRVCD, eng.HBRVCD) AS hbrvcd, " + + "hbrv.HBRVNM AS hbrvcdName, " + + "eng.RVCD AS rvcd, " + + "rv.RVNM AS rvcdName, " + + "eng.ADDVCD AS addvcd, " + + "addv.ADDVNM AS addvcdName, " + + "eng.COUNTRY AS country, " + + "country.COUNTRY_NAME AS countryName, " + + "CAST(NULL AS VARCHAR2(64)) AS stCode, " + + "CAST(NULL AS VARCHAR2(200)) AS stName, " + + "fb.STDSDT AS stdsdt, " + + "fb.PSTSTDT AS pststdt, " + + "fb.PESSTDT AS pesstdt, " + + "fb.SWDT AS ststdt, " + + "fb.JCDT AS jcdt, " + + "fb.WDDT AS stwddt, " + + "fb.INTRODUCE AS introduce, " + + "fb.INTRODUCE AS precis, " + + "fb.LOGO AS logo, " + + "fb.INFFILE AS inffile, " + + "fb.DTIN AS dtin, " + + "CASE WHEN NVL(fb.DTIN, 0) = 1 THEN '已接入' ELSE '未接入' END AS dtinName, " + + "fb.DTIN_TM AS dtinTm, " + + "fb.BLDSTT_CODE AS bldsttCode, " + + "CASE fb.BLDSTT_CODE WHEN 0 THEN '0' WHEN 1 THEN '1' WHEN 2 THEN '2' ELSE NULL END AS bldsttCcode, " + + "CASE fb.BLDSTT_CODE WHEN 0 THEN '未建/规划' WHEN 1 THEN '在建' WHEN 2 THEN '已建' ELSE NULL END AS bldsttCcodeName, " + + "fb.INV AS inv, " + + "fb.INVINMN AS invinmn, " + + "fb.DSUN AS dsun, " + + "fb.JBTXCS AS jbtxcs, " + + "fb.DTFRQCY AS dtfrqcy, " + + "fb.REMARK AS remark, " + + "fb.VLSR AS vlsr, " + + "fb.VLSR_TM AS vlsrTm, " + + "fb.ORDER_INDEX AS orderIndex, " + + "NVL(hb.ORDER_INDEX, 999999) AS baseStepSort, " + + "NVL(hbrv.ORDER_INDEX, 999999) AS rvcdStepSort, " + + "NVL(eng.ORDER_INDEX, 999999) AS rstcdStepSort, " + + "NVL(fb.ORDER_INDEX, 999999) AS siteStepSort " + + "FROM SD_FBRD_B_H fb " + + "LEFT JOIN SD_STTP_B sttp ON sttp.STTP_CODE = fb.STTP AND NVL(sttp.ENABLE, 1) = 1 " + + "LEFT JOIN SD_ENGINFO_B_H eng ON eng.STCD = fb.RSTCD AND NVL(eng.IS_DELETED, 0) = 0 " + + "LEFT JOIN SD_HYDROBASE hb ON hb.BASEID = NVL(fb.BASE_ID, eng.BASE_ID) AND NVL(hb.IS_DELETED, 0) = 0 " + + "LEFT JOIN SD_HBRV_DIC hbrv ON hbrv.HBRVCD = NVL(fb.HBRVCD, eng.HBRVCD) AND hbrv.BASEID = NVL(fb.BASE_ID, 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 SD_COUNTRY_B country ON country.COUNTRY_ID = eng.COUNTRY AND NVL(country.ENABLED, 1) = 1 "; + } + + private String buildDwSql() { + return "SELECT " + + "dw.STCD AS id, " + + "dw.STCD AS stcd, " + + "dw.STNM AS stnm, " + + "dw.STTP AS sttp, " + + "dw.STTP AS sttpCode, " + + "sttp.STTP_NAME AS sttpName, " + + "sttp.FULL_PATH AS sttpFullPath, " + + "sttp.TREE_LEVEL AS sttpTreeLevel, " + + "CAST(NULL AS VARCHAR2(64)) AS blprdId, " + + "dw.LGTD AS lgtd, " + + "dw.LTTD AS lttd, " + + "dw.ELEV AS dtmel, " + + "dw.STLC AS stlc, " + + "dw.USFL AS usfl, " + + "dw.RSTCD AS rstcd, " + + "eng.ENNM AS ennm, " + + "NVL(dw.BASE_ID, eng.BASE_ID) AS baseId, " + + "hb.BASENAME AS baseName, " + + "NVL(dw.HBRVCD, eng.HBRVCD) AS hbrvcd, " + + "hbrv.HBRVNM AS hbrvcdName, " + + "eng.RVCD AS rvcd, " + + "rv.RVNM AS rvcdName, " + + "eng.ADDVCD AS addvcd, " + + "addv.ADDVNM AS addvcdName, " + + "eng.COUNTRY AS country, " + + "country.COUNTRY_NAME AS countryName, " + + "CAST(NULL AS VARCHAR2(64)) AS stCode, " + + "CAST(NULL AS VARCHAR2(200)) AS stName, " + + "dw.STDSDT AS stdsdt, " + + "dw.PSTSTDT AS pststdt, " + + "dw.PESSTDT AS pesstdt, " + + "dw.SWDT AS ststdt, " + + "dw.JCDT AS jcdt, " + + "dw.WDDT AS stwddt, " + + "dw.INTRODUCE AS introduce, " + + "dw.INTRODUCE AS precis, " + + "dw.LOGO AS logo, " + + "dw.INFFILE AS inffile, " + + "dw.DTIN AS dtin, " + + "CASE WHEN NVL(dw.DTIN, 0) = 1 THEN '已接入' ELSE '未接入' END AS dtinName, " + + "dw.DTIN_TM AS dtinTm, " + + "dw.BLDSTT_CODE AS bldsttCode, " + + "CASE dw.BLDSTT_CODE WHEN 0 THEN '0' WHEN 1 THEN '1' WHEN 2 THEN '2' ELSE NULL END AS bldsttCcode, " + + "CASE dw.BLDSTT_CODE WHEN 0 THEN '未建/规划' WHEN 1 THEN '在建' WHEN 2 THEN '已建' ELSE NULL END AS bldsttCcodeName, " + + "dw.INV AS inv, " + + "dw.INVINMN AS invinmn, " + + "CAST(NULL AS VARCHAR2(500)) AS dsun, " + + "dw.QTSSJBTX AS jbtxcs, " + + "dw.DTFRQCY AS dtfrqcy, " + + "dw.REMARK AS remark, " + + "dw.VLSR AS vlsr, " + + "dw.VLSR_TM AS vlsrTm, " + + "dw.ORDER_INDEX AS orderIndex, " + + "NVL(hb.ORDER_INDEX, 999999) AS baseStepSort, " + + "NVL(hbrv.ORDER_INDEX, 999999) AS rvcdStepSort, " + + "NVL(eng.ORDER_INDEX, 999999) AS rstcdStepSort, " + + "NVL(dw.ORDER_INDEX, 999999) AS siteStepSort " + + "FROM SD_DW_B_H dw " + + "LEFT JOIN SD_STTP_B sttp ON sttp.STTP_CODE = dw.STTP AND NVL(sttp.IS_DELETED, 0) = 0 AND NVL(sttp.ENABLE, 1) = 1 " + + "LEFT JOIN SD_ENGINFO_B_H eng ON eng.STCD = dw.RSTCD AND NVL(eng.IS_DELETED, 0) = 0 " + + "LEFT JOIN SD_HYDROBASE hb ON hb.BASEID = NVL(dw.BASE_ID, eng.BASE_ID) AND NVL(hb.IS_DELETED, 0) = 0 " + + "LEFT JOIN SD_HBRV_DIC hbrv ON hbrv.HBRVCD = NVL(dw.HBRVCD, eng.HBRVCD) AND hbrv.BASEID = NVL(dw.BASE_ID, 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 SD_COUNTRY_B country ON country.COUNTRY_ID = eng.COUNTRY AND NVL(country.ENABLED, 1) = 1 " + + "WHERE NVL(dw.IS_DELETED, 0) = 0 "; + } + + private String buildFpSql() { + return "SELECT " + + "fp.STCD AS id, " + + "fp.STCD AS stcd, " + + "fp.STNM AS stnm, " + + "fp.STTP AS sttp, " + + "fp.STTP AS sttpCode, " + + "sttp.STTP_NAME AS sttpName, " + + "sttp.FULL_PATH AS sttpFullPath, " + + "sttp.TREE_LEVEL AS sttpTreeLevel, " + + "CAST(fp.BLPRD AS VARCHAR2(64)) AS blprdId, " + + "fp.LGTD AS lgtd, " + + "fp.LTTD AS lttd, " + + "fp.ELEV AS dtmel, " + + "fp.STLC AS stlc, " + + "fp.USFL AS usfl, " + + "fp.RSTCD AS rstcd, " + + "eng.ENNM AS ennm, " + + "eng.BASE_ID AS baseId, " + + "hb.BASENAME AS baseName, " + + "eng.HBRVCD AS hbrvcd, " + + "hbrv.HBRVNM AS hbrvcdName, " + + "eng.RVCD AS rvcd, " + + "rv.RVNM AS rvcdName, " + + "eng.ADDVCD AS addvcd, " + + "addv.ADDVNM AS addvcdName, " + + "eng.COUNTRY AS country, " + + "country.COUNTRY_NAME AS countryName, " + + "CAST(NULL AS VARCHAR2(64)) AS stCode, " + + "CAST(NULL AS VARCHAR2(200)) AS stName, " + + "fp.STDSDT AS stdsdt, " + + "fp.PSTSTDT AS pststdt, " + + "fp.PESSTDT AS pesstdt, " + + "fp.SWDT AS ststdt, " + + "fp.JCDT AS jcdt, " + + "fp.WDDT AS stwddt, " + + "fp.INTRODUCE AS introduce, " + + "fp.INTRODUCE AS precis, " + + "fp.LOGO AS logo, " + + "fp.INFFILE AS inffile, " + + "fp.DTIN AS dtin, " + + "CASE WHEN NVL(fp.DTIN, 0) = 1 THEN '已接入' ELSE '未接入' END AS dtinName, " + + "fp.DTIN_TM AS dtinTm, " + + "fp.BLDSTT_CODE AS bldsttCode, " + + "CASE fp.BLDSTT_CODE WHEN 0 THEN '0' WHEN 1 THEN '1' WHEN 2 THEN '2' ELSE NULL END AS bldsttCcode, " + + "CASE fp.BLDSTT_CODE WHEN 0 THEN '未建/规划' WHEN 1 THEN '在建' WHEN 2 THEN '已建' ELSE NULL END AS bldsttCcodeName, " + + "fp.INV AS inv, " + + "fp.INVINMN AS invinmn, " + + "CAST(NULL AS VARCHAR2(500)) AS dsun, " + + "fp.JBTXCS AS jbtxcs, " + + "fp.DTFRQCY AS dtfrqcy, " + + "fp.REMARK AS remark, " + + "fp.VLSR AS vlsr, " + + "fp.VLSR_TM AS vlsrTm, " + + "fp.ORDER_INDEX AS orderIndex, " + + "NVL(hb.ORDER_INDEX, 999999) AS baseStepSort, " + + "NVL(hbrv.ORDER_INDEX, 999999) AS rvcdStepSort, " + + "NVL(eng.ORDER_INDEX, 999999) AS rstcdStepSort, " + + "NVL(fp.ORDER_INDEX, 999999) AS siteStepSort " + + "FROM SD_FPSS_B_H fp " + + "LEFT JOIN SD_ENGINFO_B_H eng ON eng.STCD = fp.RSTCD " + + "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_STTP_B sttp ON sttp.STTP_CODE = fp.STTP AND NVL(sttp.IS_DELETED, 0) = 0 AND NVL(sttp.ENABLE, 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 SD_COUNTRY_B country ON country.COUNTRY_ID = eng.COUNTRY AND NVL(country.ENABLED, 1) = 1 "; + } + + private List resolveSelectFields(List select) { + List fields = CollUtil.isEmpty(select) + ? new ArrayList<>(buildSelectMap().keySet()) + : new ArrayList<>(select); + LinkedHashSet uniqueFields = new LinkedHashSet<>(); + for (String field : fields) { + if (StrUtil.isNotBlank(field)) { + uniqueFields.add(field.trim()); + } + } + if (uniqueFields.isEmpty()) { + uniqueFields.add("stcd"); + } + return new ArrayList<>(uniqueFields); + } + + private String buildSelectSql(List selectFields) { + Map columnMap = buildSelectMap(); + List selectParts = new ArrayList<>(); + for (String field : selectFields) { + String column = columnMap.get(field); + if (StrUtil.isNotBlank(column)) { + selectParts.add(column); + } else { + selectParts.add("NULL AS \"" + field + "\""); + } + } + if (selectParts.isEmpty()) { + selectParts.add("t.stcd AS \"stcd\""); + } + return String.join(", ", selectParts); + } + + private Map buildSelectMap() { + Map columnMap = new LinkedHashMap<>(); + columnMap.put("id", "t.id AS \"id\""); + columnMap.put("stcd", "t.stcd AS \"stcd\""); + columnMap.put("stnm", "t.stnm AS \"stnm\""); + columnMap.put("sttp", "t.sttp AS \"sttp\""); + columnMap.put("sttpCode", "t.sttpCode AS \"sttpCode\""); + columnMap.put("sttpName", "t.sttpName AS \"sttpName\""); + columnMap.put("sttpFullPath", "t.sttpFullPath AS \"sttpFullPath\""); + columnMap.put("sttpTreeLevel", "t.sttpTreeLevel AS \"sttpTreeLevel\""); + columnMap.put("blprdId", "t.blprdId AS \"blprdId\""); + columnMap.put("lgtd", "t.lgtd AS \"lgtd\""); + columnMap.put("lttd", "t.lttd AS \"lttd\""); + columnMap.put("dtmel", "t.dtmel AS \"dtmel\""); + columnMap.put("stlc", "t.stlc AS \"stlc\""); + columnMap.put("usfl", "t.usfl AS \"usfl\""); + columnMap.put("rstcd", "t.rstcd AS \"rstcd\""); + columnMap.put("ennm", "t.ennm AS \"ennm\""); + columnMap.put("baseId", "t.baseId AS \"baseId\""); + columnMap.put("baseName", "t.baseName AS \"baseName\""); + columnMap.put("hbrvcd", "t.hbrvcd AS \"hbrvcd\""); + columnMap.put("hbrvcdName", "t.hbrvcdName AS \"hbrvcdName\""); + columnMap.put("rvcd", "t.rvcd AS \"rvcd\""); + columnMap.put("rvcdName", "t.rvcdName AS \"rvcdName\""); + columnMap.put("addvcd", "t.addvcd AS \"addvcd\""); + columnMap.put("addvcdName", "t.addvcdName AS \"addvcdName\""); + columnMap.put("country", "t.country AS \"country\""); + columnMap.put("countryName", "t.countryName AS \"countryName\""); + columnMap.put("stCode", "t.stCode AS \"stCode\""); + columnMap.put("stName", "t.stName AS \"stName\""); + columnMap.put("stdsdt", "t.stdsdt AS \"stdsdt\""); + columnMap.put("pststdt", "t.pststdt AS \"pststdt\""); + columnMap.put("pesstdt", "t.pesstdt AS \"pesstdt\""); + columnMap.put("ststdt", "t.ststdt AS \"ststdt\""); + columnMap.put("jcdt", "t.jcdt AS \"jcdt\""); + columnMap.put("stwddt", "t.stwddt AS \"stwddt\""); + columnMap.put("introduce", "t.introduce AS \"introduce\""); + columnMap.put("precis", "t.precis AS \"precis\""); + columnMap.put("logo", "t.logo AS \"logo\""); + columnMap.put("inffile", "t.inffile AS \"inffile\""); + columnMap.put("dtin", "t.dtin AS \"dtin\""); + columnMap.put("dtinName", "t.dtinName AS \"dtinName\""); + columnMap.put("dtinTm", "t.dtinTm AS \"dtinTm\""); + columnMap.put("bldsttCode", "t.bldsttCode AS \"bldsttCode\""); + columnMap.put("bldsttCcode", "t.bldsttCcode AS \"bldsttCcode\""); + columnMap.put("bldsttCcodeName", "t.bldsttCcodeName AS \"bldsttCcodeName\""); + columnMap.put("inv", "t.inv AS \"inv\""); + columnMap.put("invinmn", "t.invinmn AS \"invinmn\""); + columnMap.put("dsun", "t.dsun AS \"dsun\""); + columnMap.put("jbtxcs", "t.jbtxcs AS \"jbtxcs\""); + columnMap.put("dtfrqcy", "t.dtfrqcy AS \"dtfrqcy\""); + columnMap.put("remark", "t.remark AS \"remark\""); + columnMap.put("vlsr", "t.vlsr AS \"vlsr\""); + columnMap.put("vlsrTm", "t.vlsrTm AS \"vlsrTm\""); + columnMap.put("orderIndex", "t.orderIndex AS \"orderIndex\""); + columnMap.put("baseStepSort", "t.baseStepSort AS \"baseStepSort\""); + columnMap.put("rvcdStepSort", "t.rvcdStepSort AS \"rvcdStepSort\""); + columnMap.put("rstcdStepSort", "t.rstcdStepSort AS \"rstcdStepSort\""); + columnMap.put("siteStepSort", "t.siteStepSort AS \"siteStepSort\""); + return columnMap; + } + + private String buildFilterCondition(DataSourceRequest.FilterDescriptor filter, + Map paramMap, + int[] indexHolder) { + if (filter == null) { + return ""; + } + if (StrUtil.isNotBlank(filter.getField())) { + return buildLeafCondition(filter, paramMap, indexHolder); + } + if (CollUtil.isEmpty(filter.getFilters())) { + return ""; + } + List 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 paramMap, + int[] indexHolder) { + String field = filter.getField(); + if (StrUtil.isBlank(field)) { + return ""; + } + String operator = StrUtil.blankToDefault(filter.getOperator(), "eq").toLowerCase(); + String column = mapFilterColumn(field); + if (StrUtil.isBlank(column)) { + return ""; + } + if ("isnull".equals(operator)) { + return column + " IS NULL"; + } + if ("isnotnull".equals(operator)) { + return column + " IS NOT NULL"; + } + if ("isempty".equals(operator)) { + return "(" + column + " IS NULL OR " + column + " = '')"; + } + if ("isnotempty".equals(operator)) { + return "(" + column + " IS NOT NULL AND " + column + " <> '')"; + } + if ("in".equals(operator) || "ni".equals(operator)) { + List values = normalizeValues(filter.getValue()); + if (values.isEmpty()) { + return ""; + } + List placeholders = new ArrayList<>(); + for (Object item : values) { + String key = "overviewP" + indexHolder[0]++; + paramMap.put(key, item); + placeholders.add("#{map." + key + "}"); + } + if (placeholders.isEmpty()) { + return ""; + } + return column + ("ni".equals(operator) ? " NOT IN (" : " IN (") + String.join(", ", placeholders) + ")"; + } + Object value = filter.getValue(); + if (value == null) { + return ""; + } + String key = "overviewP" + indexHolder[0]++; + return switch (operator) { + case "eq" -> { + paramMap.put(key, value); + yield column + " = #{map." + key + "}"; + } + case "neq" -> { + paramMap.put(key, value); + yield column + " <> #{map." + key + "}"; + } + case "contains" -> { + paramMap.put(key, "%" + value + "%"); + yield column + " LIKE #{map." + key + "}"; + } + case "doesnotcontain" -> { + paramMap.put(key, "%" + value + "%"); + yield column + " NOT 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 + " > #{map." + key + "}"; + } + case "gte" -> { + paramMap.put(key, value); + yield column + " >= #{map." + key + "}"; + } + case "lt" -> { + paramMap.put(key, value); + yield column + " < #{map." + key + "}"; + } + case "lte" -> { + paramMap.put(key, value); + yield column + " <= #{map." + key + "}"; + } + default -> ""; + }; + } + + private String mapFilterColumn(String field) { + if (StrUtil.isBlank(field)) { + return null; + } + return switch (field) { + case "id" -> "t.id"; + case "stcd" -> "t.stcd"; + case "stnm" -> "t.stnm"; + case "sttp" -> "t.sttp"; + case "sttpCode" -> "t.sttpCode"; + case "sttpName" -> "t.sttpName"; + case "sttpFullPath" -> "t.sttpFullPath"; + case "sttpTreeLevel" -> "t.sttpTreeLevel"; + case "blprdId" -> "t.blprdId"; + case "lgtd" -> "t.lgtd"; + case "lttd" -> "t.lttd"; + case "dtmel" -> "t.dtmel"; + case "stlc" -> "t.stlc"; + case "usfl" -> "t.usfl"; + case "rstcd" -> "t.rstcd"; + case "ennm" -> "t.ennm"; + 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 "addvcd" -> "t.addvcd"; + case "addvcdName" -> "t.addvcdName"; + case "country" -> "t.country"; + case "countryName" -> "t.countryName"; + case "stCode" -> "t.stCode"; + case "stName" -> "t.stName"; + case "introduce" -> "t.introduce"; + case "precis" -> "t.precis"; + case "logo" -> "t.logo"; + case "inffile" -> "t.inffile"; + case "dtin" -> "t.dtin"; + case "dtinName" -> "t.dtinName"; + case "dtinTm" -> "t.dtinTm"; + case "bldsttCode" -> "t.bldsttCode"; + case "bldsttCcode" -> "t.bldsttCcode"; + case "bldsttCcodeName" -> "t.bldsttCcodeName"; + case "inv" -> "t.inv"; + case "invinmn" -> "t.invinmn"; + case "dsun" -> "t.dsun"; + case "jbtxcs" -> "t.jbtxcs"; + case "dtfrqcy" -> "t.dtfrqcy"; + case "remark" -> "t.remark"; + case "vlsr" -> "t.vlsr"; + case "vlsrTm" -> "t.vlsrTm"; + case "orderIndex" -> "t.orderIndex"; + case "baseStepSort" -> "t.baseStepSort"; + case "rvcdStepSort" -> "t.rvcdStepSort"; + case "rstcdStepSort" -> "t.rstcdStepSort"; + case "siteStepSort" -> "t.siteStepSort"; + case "stdsdt" -> "t.stdsdt"; + case "pststdt" -> "t.pststdt"; + case "pesstdt" -> "t.pesstdt"; + case "ststdt" -> "t.ststdt"; + case "jcdt" -> "t.jcdt"; + case "stwddt" -> "t.stwddt"; + default -> null; + }; + } + + private String buildOrderBySql(List sortList) { + if (CollUtil.isEmpty(sortList)) { + return " ORDER BY t.baseStepSort ASC, t.rvcdStepSort ASC, t.rstcdStepSort ASC, t.siteStepSort ASC, t.stnm ASC"; + } + List orderItems = new ArrayList<>(); + for (DataSourceRequest.SortDescriptor sort : sortList) { + if (sort == null || StrUtil.isBlank(sort.getField())) { + continue; + } + String column = mapFilterColumn(sort.getField()); + if (StrUtil.isBlank(column)) { + continue; + } + String dir = "desc".equalsIgnoreCase(sort.getDir()) || "des".equalsIgnoreCase(sort.getDir()) ? "DESC" : "ASC"; + orderItems.add(column + " " + dir + " NULLS LAST"); + } + if (orderItems.isEmpty()) { + return " ORDER BY t.baseStepSort ASC, t.rvcdStepSort ASC, t.rstcdStepSort ASC, t.siteStepSort ASC, t.stnm ASC"; + } + return " ORDER BY " + String.join(", ", orderItems); + } + + private List normalizeValues(Object value) { + List values = new ArrayList<>(); + collectValues(value, values); + return values; + } + + private void collectValues(Object value, List values) { + if (value == null) { + return; + } + if (value instanceof List list) { + for (Object item : list) { + collectValues(item, values); + } + return; + } + if (value instanceof Object[] array) { + for (Object item : array) { + collectValues(item, values); + } + return; + } + values.add(value); + } +}