package com.ruoyi.lims.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.ruoyi.lims.dto.*;
|
import com.ruoyi.lims.mapper.DataCollectionMapper;
|
import com.ruoyi.lims.mapper.ExperimentMapper;
|
import com.ruoyi.lims.mapper.RealtimeMonitorMapper;
|
import com.ruoyi.lims.mapper.SampleMapper;
|
import com.ruoyi.lims.pojo.DataCollection;
|
import com.ruoyi.lims.pojo.Experiment;
|
import com.ruoyi.lims.pojo.RealtimeMonitor;
|
import com.ruoyi.lims.pojo.Sample;
|
import com.ruoyi.lims.service.LimsDataAnalysisService;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class LimsDataAnalysisServiceImpl implements LimsDataAnalysisService {
|
|
private static final DateTimeFormatter DAY_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
private static final DateTimeFormatter HOUR_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:00:00");
|
|
private final DataCollectionMapper dataCollectionMapper;
|
private final ExperimentMapper experimentMapper;
|
private final RealtimeMonitorMapper realtimeMonitorMapper;
|
private final SampleMapper sampleMapper;
|
|
@Override
|
public LimsDataAnalysisDashboardDto dashboard(LimsDataAnalysisQueryDto queryDto) {
|
LimsDataAnalysisQueryDto query = normalizeQuery(queryDto);
|
LimsDataAnalysisDashboardDto dashboardDto = new LimsDataAnalysisDashboardDto();
|
dashboardDto.setStartTime(query.getStartTime());
|
dashboardDto.setEndTime(query.getEndTime());
|
dashboardDto.setGranularity(query.getGranularity());
|
dashboardDto.setDimension(query.getDimension());
|
dashboardDto.setOverview(buildOverview(query));
|
dashboardDto.setTrend(buildTrend(query));
|
dashboardDto.setComparison(buildComparison(query));
|
dashboardDto.setQualityDistribution(buildQualityDistribution(query));
|
return dashboardDto;
|
}
|
|
@Override
|
public LimsAnalysisOverviewDto overview(LimsDataAnalysisQueryDto queryDto) {
|
return buildOverview(normalizeQuery(queryDto));
|
}
|
|
@Override
|
public List<LimsTrendPointDto> trend(LimsDataAnalysisQueryDto queryDto) {
|
return buildTrend(normalizeQuery(queryDto));
|
}
|
|
@Override
|
public List<LimsComparisonItemDto> comparison(LimsDataAnalysisQueryDto queryDto) {
|
return buildComparison(normalizeQuery(queryDto));
|
}
|
|
@Override
|
public List<LimsQualityDistributionItemDto> qualityDistribution(LimsDataAnalysisQueryDto queryDto) {
|
return buildQualityDistribution(normalizeQuery(queryDto));
|
}
|
|
private LimsAnalysisOverviewDto buildOverview(LimsDataAnalysisQueryDto query) {
|
QueryWrapper<DataCollection> totalWrapper = createDataCollectionFilter(query);
|
Long totalCollections = dataCollectionMapper.selectCount(totalWrapper);
|
|
QueryWrapper<DataCollection> abnormalWrapper = createDataCollectionFilter(query);
|
abnormalWrapper.eq("data_quality", "abnormal");
|
Long abnormalCollections = dataCollectionMapper.selectCount(abnormalWrapper);
|
|
QueryWrapper<DataCollection> qualifiedWrapper = createDataCollectionFilter(query);
|
qualifiedWrapper.eq("data_quality", "qualified");
|
Long qualifiedCollections = dataCollectionMapper.selectCount(qualifiedWrapper);
|
|
QueryWrapper<DataCollection> todayWrapper = new QueryWrapper<>();
|
todayWrapper.eq("del_flag", "0")
|
.ge("collection_time", LocalDateTime.now().minusHours(24))
|
.le("collection_time", LocalDateTime.now());
|
Long todayCollections = dataCollectionMapper.selectCount(todayWrapper);
|
|
Long inProgressExperiments = experimentMapper.selectCount(new QueryWrapper<Experiment>()
|
.eq("del_flag", "0")
|
.eq("experiment_status", "inProgress"));
|
|
Long warningMonitors = realtimeMonitorMapper.selectCount(new QueryWrapper<RealtimeMonitor>()
|
.eq("del_flag", "0")
|
.in("alert_status", Arrays.asList("warning", "alert")));
|
|
Long inStockSamples = sampleMapper.selectCount(new QueryWrapper<Sample>()
|
.eq("del_flag", "0")
|
.eq("sample_status", "inStock"));
|
|
LimsAnalysisOverviewDto dto = new LimsAnalysisOverviewDto();
|
dto.setTotalCollections(defaultLong(totalCollections));
|
dto.setTodayCollections(defaultLong(todayCollections));
|
dto.setAbnormalCollections(defaultLong(abnormalCollections));
|
dto.setInProgressExperiments(defaultLong(inProgressExperiments));
|
dto.setWarningMonitors(defaultLong(warningMonitors));
|
dto.setInStockSamples(defaultLong(inStockSamples));
|
dto.setQualifiedRate(calculateRate(qualifiedCollections, totalCollections));
|
return dto;
|
}
|
|
private List<LimsTrendPointDto> buildTrend(LimsDataAnalysisQueryDto query) {
|
String groupExpression = resolveTimeGroupExpression(query.getGranularity());
|
QueryWrapper<DataCollection> wrapper = createDataCollectionFilter(query);
|
wrapper.select(
|
groupExpression + " AS time_key",
|
"COUNT(1) AS point_count",
|
"AVG(collection_value) AS avg_value",
|
"MAX(collection_value) AS max_value",
|
"MIN(collection_value) AS min_value"
|
)
|
.groupBy(groupExpression)
|
.orderByAsc("time_key");
|
|
List<Map<String, Object>> rawRows = dataCollectionMapper.selectMaps(wrapper);
|
Map<String, LimsTrendPointDto> trendMap = rawRows.stream().map(this::mapToTrendPoint)
|
.collect(Collectors.toMap(LimsTrendPointDto::getTime, item -> item, (a, b) -> b));
|
|
List<String> axis = buildTimeAxis(query);
|
List<LimsTrendPointDto> result = new ArrayList<>();
|
for (String key : axis) {
|
LimsTrendPointDto point = trendMap.get(key);
|
if (point == null) {
|
point = new LimsTrendPointDto();
|
point.setTime(key);
|
point.setPointCount(0L);
|
point.setAvgValue(BigDecimal.ZERO);
|
point.setMaxValue(BigDecimal.ZERO);
|
point.setMinValue(BigDecimal.ZERO);
|
}
|
result.add(point);
|
}
|
return result;
|
}
|
|
private List<LimsComparisonItemDto> buildComparison(LimsDataAnalysisQueryDto query) {
|
String dimensionColumn = resolveDimensionColumn(query.getDimension());
|
|
QueryWrapper<DataCollection> wrapper = createDataCollectionFilter(query);
|
wrapper.isNotNull(dimensionColumn)
|
.ne(dimensionColumn, "")
|
.select(
|
dimensionColumn + " AS dimension_value",
|
"COUNT(1) AS point_count",
|
"AVG(collection_value) AS avg_value",
|
"MAX(collection_value) AS max_value",
|
"MIN(collection_value) AS min_value"
|
)
|
.groupBy(dimensionColumn);
|
|
List<LimsComparisonItemDto> result = dataCollectionMapper.selectMaps(wrapper).stream()
|
.map(this::mapToComparisonItem)
|
.sorted(Comparator.comparing(LimsComparisonItemDto::getPointCount, Comparator.nullsLast(Long::compareTo)).reversed())
|
.collect(Collectors.toList());
|
|
int limit = query.getTopN() == null ? 10 : query.getTopN();
|
if (result.size() > limit) {
|
return result.subList(0, limit);
|
}
|
return result;
|
}
|
|
private List<LimsQualityDistributionItemDto> buildQualityDistribution(LimsDataAnalysisQueryDto query) {
|
QueryWrapper<DataCollection> wrapper = createDataCollectionFilter(query);
|
wrapper.isNotNull("data_quality")
|
.ne("data_quality", "")
|
.select("data_quality AS category", "COUNT(1) AS point_count")
|
.groupBy("data_quality");
|
|
List<LimsQualityDistributionItemDto> result = dataCollectionMapper.selectMaps(wrapper).stream()
|
.map(this::mapToQualityDistributionItem)
|
.sorted(Comparator.comparing(LimsQualityDistributionItemDto::getPointCount, Comparator.nullsLast(Long::compareTo)).reversed())
|
.collect(Collectors.toList());
|
|
long total = result.stream().map(LimsQualityDistributionItemDto::getPointCount).filter(Objects::nonNull).mapToLong(Long::longValue).sum();
|
for (LimsQualityDistributionItemDto item : result) {
|
item.setRatio(calculateRate(item.getPointCount(), total));
|
}
|
return result;
|
}
|
|
private QueryWrapper<DataCollection> createDataCollectionFilter(LimsDataAnalysisQueryDto query) {
|
QueryWrapper<DataCollection> wrapper = new QueryWrapper<>();
|
wrapper.eq("del_flag", "0")
|
.ge("collection_time", query.getStartTime())
|
.le("collection_time", query.getEndTime());
|
if (StringUtils.hasText(query.getDataType())) {
|
wrapper.eq("data_type", query.getDataType().trim());
|
}
|
if (StringUtils.hasText(query.getDeviceCode())) {
|
wrapper.eq("device_code", query.getDeviceCode().trim());
|
}
|
return wrapper;
|
}
|
|
private String resolveTimeGroupExpression(String granularity) {
|
if ("hour".equalsIgnoreCase(granularity)) {
|
return "DATE_FORMAT(collection_time, '%Y-%m-%d %H:00:00')";
|
}
|
return "DATE_FORMAT(collection_time, '%Y-%m-%d')";
|
}
|
|
private String resolveDimensionColumn(String dimension) {
|
if ("deviceName".equalsIgnoreCase(dimension)) {
|
return "device_name";
|
}
|
if ("deviceCode".equalsIgnoreCase(dimension)) {
|
return "device_code";
|
}
|
return "data_type";
|
}
|
|
private List<String> buildTimeAxis(LimsDataAnalysisQueryDto query) {
|
List<String> axis = new ArrayList<>();
|
if ("hour".equalsIgnoreCase(query.getGranularity())) {
|
LocalDateTime cursor = query.getStartTime().withMinute(0).withSecond(0).withNano(0);
|
LocalDateTime end = query.getEndTime().withMinute(0).withSecond(0).withNano(0);
|
while (!cursor.isAfter(end)) {
|
axis.add(cursor.format(HOUR_FORMATTER));
|
cursor = cursor.plusHours(1);
|
}
|
return axis;
|
}
|
LocalDate cursor = query.getStartTime().toLocalDate();
|
LocalDate end = query.getEndTime().toLocalDate();
|
while (!cursor.isAfter(end)) {
|
axis.add(cursor.format(DAY_FORMATTER));
|
cursor = cursor.plusDays(1);
|
}
|
return axis;
|
}
|
|
private LimsTrendPointDto mapToTrendPoint(Map<String, Object> row) {
|
LimsTrendPointDto point = new LimsTrendPointDto();
|
point.setTime(asString(readIgnoreCase(row, "time_key")));
|
point.setPointCount(defaultLong(asLong(readIgnoreCase(row, "point_count"))));
|
point.setAvgValue(scale(asBigDecimal(readIgnoreCase(row, "avg_value"))));
|
point.setMaxValue(scale(asBigDecimal(readIgnoreCase(row, "max_value"))));
|
point.setMinValue(scale(asBigDecimal(readIgnoreCase(row, "min_value"))));
|
return point;
|
}
|
|
private LimsComparisonItemDto mapToComparisonItem(Map<String, Object> row) {
|
LimsComparisonItemDto item = new LimsComparisonItemDto();
|
item.setDimensionValue(asString(readIgnoreCase(row, "dimension_value")));
|
item.setPointCount(defaultLong(asLong(readIgnoreCase(row, "point_count"))));
|
item.setAvgValue(scale(asBigDecimal(readIgnoreCase(row, "avg_value"))));
|
item.setMaxValue(scale(asBigDecimal(readIgnoreCase(row, "max_value"))));
|
item.setMinValue(scale(asBigDecimal(readIgnoreCase(row, "min_value"))));
|
return item;
|
}
|
|
private LimsQualityDistributionItemDto mapToQualityDistributionItem(Map<String, Object> row) {
|
LimsQualityDistributionItemDto item = new LimsQualityDistributionItemDto();
|
item.setCategory(asString(readIgnoreCase(row, "category")));
|
item.setPointCount(defaultLong(asLong(readIgnoreCase(row, "point_count"))));
|
item.setRatio(BigDecimal.ZERO);
|
return item;
|
}
|
|
private Object readIgnoreCase(Map<String, Object> row, String key) {
|
if (row.containsKey(key)) {
|
return row.get(key);
|
}
|
for (Map.Entry<String, Object> entry : row.entrySet()) {
|
if (entry.getKey() != null && entry.getKey().equalsIgnoreCase(key)) {
|
return entry.getValue();
|
}
|
}
|
return null;
|
}
|
|
private BigDecimal calculateRate(Number part, Number total) {
|
if (part == null || total == null || total.longValue() == 0L) {
|
return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
|
}
|
return BigDecimal.valueOf(part.longValue())
|
.multiply(BigDecimal.valueOf(100))
|
.divide(BigDecimal.valueOf(total.longValue()), 2, RoundingMode.HALF_UP);
|
}
|
|
private BigDecimal scale(BigDecimal value) {
|
if (value == null) {
|
return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
|
}
|
return value.setScale(2, RoundingMode.HALF_UP);
|
}
|
|
private String asString(Object value) {
|
return value == null ? "" : String.valueOf(value);
|
}
|
|
private Long asLong(Object value) {
|
if (value == null) {
|
return 0L;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).longValue();
|
}
|
return Long.parseLong(String.valueOf(value));
|
}
|
|
private BigDecimal asBigDecimal(Object value) {
|
if (value == null) {
|
return BigDecimal.ZERO;
|
}
|
if (value instanceof BigDecimal) {
|
return (BigDecimal) value;
|
}
|
if (value instanceof Number) {
|
return BigDecimal.valueOf(((Number) value).doubleValue());
|
}
|
return new BigDecimal(String.valueOf(value));
|
}
|
|
private Long defaultLong(Long value) {
|
return value == null ? 0L : value;
|
}
|
|
private LimsDataAnalysisQueryDto normalizeQuery(LimsDataAnalysisQueryDto source) {
|
LimsDataAnalysisQueryDto query = new LimsDataAnalysisQueryDto();
|
if (source != null) {
|
query.setStartTime(source.getStartTime());
|
query.setEndTime(source.getEndTime());
|
query.setDataType(source.getDataType());
|
query.setDeviceCode(source.getDeviceCode());
|
query.setGranularity(source.getGranularity());
|
query.setDimension(source.getDimension());
|
query.setTopN(source.getTopN());
|
}
|
|
LocalDateTime now = LocalDateTime.now().withSecond(0).withNano(0);
|
if (query.getStartTime() == null && query.getEndTime() == null) {
|
query.setEndTime(now);
|
query.setStartTime(now.minusDays(6).withHour(0).withMinute(0));
|
} else if (query.getStartTime() == null) {
|
query.setStartTime(query.getEndTime().minusDays(6).withHour(0).withMinute(0));
|
} else if (query.getEndTime() == null) {
|
query.setEndTime(query.getStartTime().plusDays(6).withHour(23).withMinute(59));
|
}
|
|
if (query.getStartTime().isAfter(query.getEndTime())) {
|
LocalDateTime temp = query.getStartTime();
|
query.setStartTime(query.getEndTime());
|
query.setEndTime(temp);
|
}
|
|
if (!"hour".equalsIgnoreCase(query.getGranularity()) && !"day".equalsIgnoreCase(query.getGranularity())) {
|
query.setGranularity("day");
|
} else {
|
query.setGranularity(query.getGranularity().toLowerCase(Locale.ROOT));
|
}
|
|
if (!"deviceName".equalsIgnoreCase(query.getDimension())
|
&& !"deviceCode".equalsIgnoreCase(query.getDimension())
|
&& !"dataType".equalsIgnoreCase(query.getDimension())) {
|
query.setDimension("dataType");
|
} else if ("devicename".equalsIgnoreCase(query.getDimension())) {
|
query.setDimension("deviceName");
|
} else if ("devicecode".equalsIgnoreCase(query.getDimension())) {
|
query.setDimension("deviceCode");
|
} else {
|
query.setDimension("dataType");
|
}
|
|
if (query.getTopN() == null || query.getTopN() <= 0) {
|
query.setTopN(10);
|
} else if (query.getTopN() > 50) {
|
query.setTopN(50);
|
}
|
return query;
|
}
|
}
|
