From e9633595b71ad48914c6bbb0aeed22e11db5c478 Mon Sep 17 00:00:00 2001 From: tangwei Date: Mon, 13 Jul 2026 11:30:06 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E4=BC=98=E5=8C=96=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../service/impl/WarnDataServiceImpl.java | 310 +++++++++++++++++- 1 file changed, 307 insertions(+), 3 deletions(-) diff --git a/backend/src/main/java/com/yfd/platform/qgc_env/warn/service/impl/WarnDataServiceImpl.java b/backend/src/main/java/com/yfd/platform/qgc_env/warn/service/impl/WarnDataServiceImpl.java index 1ec35350..678074c0 100644 --- a/backend/src/main/java/com/yfd/platform/qgc_env/warn/service/impl/WarnDataServiceImpl.java +++ b/backend/src/main/java/com/yfd/platform/qgc_env/warn/service/impl/WarnDataServiceImpl.java @@ -1,5 +1,6 @@ package com.yfd.platform.qgc_env.warn.service.impl; +import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.date.DateUtil; import cn.hutool.core.util.StrUtil; @@ -28,10 +29,13 @@ import org.springframework.stereotype.Service; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; +import java.util.Comparator; import java.util.Date; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Objects; @Service public class WarnDataServiceImpl implements WarnDataService { @@ -264,6 +268,7 @@ public class WarnDataServiceImpl implements WarnDataService { @Cacheable(cacheNames = "warn#3600", keyGenerator = "cacheKeyGenerator") public DataSourceResult getAlarmPointKendoListCust(DataSourceRequest dataSourceRequest) { DataSourceLoadOptionsBase loadOptions = dataSourceRequest == null ? null : dataSourceRequest.toDevRequest(); + GroupingInfo[] groupInfos = loadOptions == null ? null : loadOptions.getGroup(); String startTimeText = loadOptions == null ? null : QgcQueryWrapperUtil.getFilterFieldValue(loadOptions, "startTime"); String endTimeText = loadOptions == null ? null : QgcQueryWrapperUtil.getFilterFieldValue(loadOptions, "endTime"); @@ -295,10 +300,23 @@ public class WarnDataServiceImpl implements WarnDataService { List> expressionRows = microservicDynamicSQLMapper.getAllList(buildAlarmPointLegendSql(), new HashMap<>()); List resultList = mergeAlarmPointData(points, qecCountMap, wqCountMap, expressionRows, yyyy); + List filteredList = applyAlarmPointFilter( + resultList, + dataSourceRequest == null ? null : dataSourceRequest.getFilter() + ); + applyAlarmPointSort(filteredList, dataSourceRequest == null ? null : dataSourceRequest.getSort()); + + if (CollUtil.isNotEmpty(dataSourceRequest == null ? null : dataSourceRequest.getGroup())) { + List> rows = buildAlarmPointGroupRows(filteredList); + return QgcQueryWrapperUtil.buildGroupResult(dataSourceRequest, rows); + } + + Page page = loadOptions == null ? null : QgcQueryWrapperUtil.buildPage(loadOptions, loadOptions.getSkip(), loadOptions.getTake()); + List pageList = applyAlarmPointPage(filteredList, loadOptions); DataSourceResult result = new DataSourceResult<>(); - result.setData(resultList); - result.setTotal(resultList.size()); + result.setData(pageList); + result.setTotal(page != null ? (long) filteredList.size() : (long) filteredList.size()); result.setAggregates(new HashMap<>()); return result; } @@ -1383,12 +1401,13 @@ public class WarnDataServiceImpl implements WarnDataService { if (point == null || !isAlarmPointVisible(point.getAnchoPointState())) { continue; } - point.setAnchoPointState(normalizeAlarmPointState(point.getAnchoPointState()) + "_ALARM"); + point.setAnchoPointState(normalizeAlarmPointState(point.getAnchoPointState())); point.setStqCount(qecCountMap.getOrDefault(point.getStcd(), 0)); point.setWqCount(wqCountMap.getOrDefault(point.getStcd(), 0)); point.setZCount(0); point.setWtCount(0); point.setYyyy(yyyy); + point.setSttpMap(point.getSttpMap() + "_ALARM"); point.setSttpCode("ENG"); int total = point.getStqCount() + point.getWqCount(); applyAlarmPointRange(point, total, expressionRows); @@ -1397,6 +1416,291 @@ public class WarnDataServiceImpl implements WarnDataService { return result; } + private List applyAlarmPointFilter(List source, DataSourceRequest.FilterDescriptor filter) { + if (CollUtil.isEmpty(source) || filter == null) { + return source; + } + List result = new ArrayList<>(); + for (AlarmPointVo item : source) { + if (matchesAlarmPointFilter(item, filter)) { + result.add(item); + } + } + return result; + } + + private boolean matchesAlarmPointFilter(AlarmPointVo item, DataSourceRequest.FilterDescriptor filter) { + if (item == null || filter == null) { + return true; + } + if (CollUtil.isNotEmpty(filter.getFilters())) { + String logic = StrUtil.blankToDefault(filter.getLogic(), "and"); + if ("or".equalsIgnoreCase(logic)) { + for (DataSourceRequest.FilterDescriptor child : filter.getFilters()) { + if (matchesAlarmPointFilter(item, child)) { + return true; + } + } + return false; + } + for (DataSourceRequest.FilterDescriptor child : filter.getFilters()) { + if (!matchesAlarmPointFilter(item, child)) { + return false; + } + } + return true; + } + if (StrUtil.isBlank(filter.getField()) || StrUtil.isBlank(filter.getOperator())) { + return true; + } + if (isAlarmPointMetaField(filter.getField())) { + return true; + } + Object actualValue = getAlarmPointFieldValue(item, filter.getField()); + return compareAlarmPointField(actualValue, filter.getValue(), filter.getOperator(), filter.isIgnoreCase()); + } + + private boolean isAlarmPointMetaField(String field) { + return "startTime".equals(field) || "endTime".equals(field); + } + + private boolean compareAlarmPointField(Object actualValue, Object expectedValue, String operator, boolean ignoreCase) { + if ("isblank".equalsIgnoreCase(operator)) { + return actualValue == null || StrUtil.isBlank(String.valueOf(actualValue)); + } + if ("isnotblank".equalsIgnoreCase(operator)) { + return actualValue != null && StrUtil.isNotBlank(String.valueOf(actualValue)); + } + if (actualValue == null) { + return expectedValue == null && ("eq".equalsIgnoreCase(operator) || "=".equals(operator)); + } + + String actualText = String.valueOf(actualValue); + String expectedText = expectedValue == null ? null : String.valueOf(expectedValue); + String left = ignoreCase && actualText != null ? actualText.toLowerCase() : actualText; + String right = ignoreCase && expectedText != null ? expectedText.toLowerCase() : expectedText; + + switch (operator.toLowerCase()) { + case "eq": + case "=": + return Objects.equals(normalizeAlarmPointCompareValue(actualValue), normalizeAlarmPointCompareValue(expectedValue)) + || Objects.equals(left, right); + case "neq": + case "<>": + return !Objects.equals(normalizeAlarmPointCompareValue(actualValue), normalizeAlarmPointCompareValue(expectedValue)) + && !Objects.equals(left, right); + case "contains": + return right != null && left != null && left.contains(right); + case "doesnotcontain": + return right == null || left == null || !left.contains(right); + case "startswith": + return right != null && left != null && left.startsWith(right); + case "endswith": + return right != null && left != null && left.endsWith(right); + case "gt": + return compareAlarmPointComparable(actualValue, expectedValue) > 0; + case "gte": + case "ge": + return compareAlarmPointComparable(actualValue, expectedValue) >= 0; + case "lt": + return compareAlarmPointComparable(actualValue, expectedValue) < 0; + case "lte": + case "le": + return compareAlarmPointComparable(actualValue, expectedValue) <= 0; + default: + return true; + } + } + + private Object normalizeAlarmPointCompareValue(Object value) { + if (value == null) { + return null; + } + if (value instanceof Number) { + return new BigDecimal(value.toString()); + } + if (value instanceof Date) { + return ((Date) value).getTime(); + } + String text = String.valueOf(value).trim(); + if (StrUtil.isBlank(text)) { + return text; + } + if (StrUtil.isNumeric(text)) { + return new BigDecimal(text); + } + return text; + } + + private int compareAlarmPointComparable(Object actualValue, Object expectedValue) { + Object left = normalizeAlarmPointCompareValue(actualValue); + Object right = normalizeAlarmPointCompareValue(expectedValue); + if (left == null && right == null) { + return 0; + } + if (left == null) { + return -1; + } + if (right == null) { + return 1; + } + if (left instanceof BigDecimal && right instanceof BigDecimal) { + return ((BigDecimal) left).compareTo((BigDecimal) right); + } + if (left instanceof Long && right instanceof Long) { + return Long.compare((Long) left, (Long) right); + } + return String.valueOf(left).compareTo(String.valueOf(right)); + } + + private void applyAlarmPointSort(List list, List sorts) { + if (CollUtil.isEmpty(list) || CollUtil.isEmpty(sorts)) { + return; + } + Comparator comparator = null; + for (DataSourceRequest.SortDescriptor sort : sorts) { + if (sort == null || StrUtil.isBlank(sort.getField()) || Boolean.FALSE.equals(sort.getNeedSortFlag())) { + continue; + } + Comparator current = (left, right) -> compareAlarmPointSortValue( + buildAlarmPointSortValue(getAlarmPointFieldValue(left, sort.getField())), + buildAlarmPointSortValue(getAlarmPointFieldValue(right, sort.getField())) + ); + if ("desc".equalsIgnoreCase(sort.getDir()) || "des".equalsIgnoreCase(sort.getDir())) { + current = current.reversed(); + } + comparator = comparator == null ? current : comparator.thenComparing(current); + } + if (comparator != null) { + list.sort(comparator); + } + } + + private Comparable buildAlarmPointSortValue(Object value) { + if (value == null) { + return null; + } + if (value instanceof BigDecimal) { + return (BigDecimal) value; + } + if (value instanceof Integer) { + return (Integer) value; + } + if (value instanceof Long) { + return (Long) value; + } + if (value instanceof Date) { + return ((Date) value).getTime(); + } + return String.valueOf(value); + } + + private int compareAlarmPointSortValue(Comparable left, Comparable right) { + if (left == null && right == null) { + return 0; + } + if (left == null) { + return 1; + } + if (right == null) { + return -1; + } + return String.valueOf(left).compareTo(String.valueOf(right)); + } + + private List applyAlarmPointPage(List source, DataSourceLoadOptionsBase loadOptions) { + if (CollUtil.isEmpty(source) || loadOptions == null || loadOptions.getTake() == null || loadOptions.getTake() <= 0) { + return source; + } + int skip = loadOptions.getSkip() == null ? 0 : Math.max(loadOptions.getSkip(), 0); + if (skip >= source.size()) { + return new ArrayList<>(); + } + int endIndex = Math.min(skip + loadOptions.getTake(), source.size()); + return new ArrayList<>(source.subList(skip, endIndex)); + } + + private List> buildAlarmPointGroupRows(List source) { + List> rows = new ArrayList<>(); + if (CollUtil.isEmpty(source)) { + return rows; + } + for (AlarmPointVo item : source) { + rows.add(new LinkedHashMap<>(BeanUtil.beanToMap(item))); + } + return rows; + } + + private Object getAlarmPointFieldValue(AlarmPointVo item, String field) { + if (item == null || StrUtil.isBlank(field)) { + return null; + } + switch (field) { + case "sttp": + return item.getSttp(); + case "stcd": + return item.getStcd(); + case "lgtd": + return item.getLgtd(); + case "lttd": + return item.getLttd(); + case "dtmel": + return item.getDtmel(); + case "anchoPointState": + return item.getAnchoPointState(); + case "sttpMap": + return item.getSttpMap(); + case "titleName": + return item.getTitleName(); + case "distance": + return item.getDistance(); + case "rvcd": + return item.getRvcd(); + case "addvcd": + return item.getAddvcd(); + case "baseId": + return item.getBaseId(); + case "rstcds": + return item.getRstcds(); + case "sttpCode": + return item.getSttpCode(); + case "ennm": + return item.getEnnm(); + case "rvnm": + return item.getRvnm(); + case "endInstalledType": + return item.getEndInstalledType(); + case "stqCount": + return item.getStqCount(); + case "wqCount": + return item.getWqCount(); + case "zCount": + return item.getZCount(); + case "wtCount": + return item.getWtCount(); + case "yyyy": + return item.getYyyy(); + case "range": + return item.getRange(); + case "ttpwr": + return item.getTtpwr(); + case "baseName": + return item.getBaseName(); + case "rstcd": + return item.getRstcd(); + case "rvcdStepSort": + return item.getRvcdStepSort(); + case "rstcdStepSort": + return item.getRstcdStepSort(); + case "siteStepSort": + return item.getSiteStepSort(); + case "logo": + return item.getLogo(); + default: + return null; + } + } + private boolean isAlarmPointVisible(String state) { return "large_eng_built".equals(state) || "mid_eng_built".equals(state)