package org.dromara.eims.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import lombok.RequiredArgsConstructor;
|
import org.dromara.common.core.utils.StringUtils;
|
import org.dromara.common.mybatis.core.page.PageQuery;
|
import org.dromara.common.mybatis.core.page.TableDataInfo;
|
import org.dromara.eims.domain.*;
|
import org.dromara.eims.domain.vo.EimsEquVo;
|
import org.dromara.eims.mapper.*;
|
import org.dromara.eims.service.IReportService;
|
import org.dromara.system.mapper.SysDeptMapper;
|
import org.springframework.stereotype.Service;
|
|
import java.time.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@RequiredArgsConstructor
|
@Service
|
public class ReportServiceImpl implements IReportService {
|
|
private static final String UNCHECKED = "未点检";
|
private static final String PENDING_VERIFICATION = "待验证";
|
private static final String COMPLETED = "已完成";
|
private static final String NOT_APPLICABLE = "/";
|
|
|
private static final String MAINT_0 = "待保养";
|
private static final String MAINT_1 = "保养中";
|
private static final String MAINT_2 = "待验证";
|
private static final String MAINT_3 = "已完成";
|
|
private final EimsInspectRecordMapper baseMapper;
|
private final EimsInspectStMapper inspectStMapper;
|
private final EimsInspectPlanMapper inspectPlanMapper;
|
private final SysDeptMapper sysDeptMapper;
|
private final EimsEquMapper equMapper;
|
private final EimsMaintOrderMapper maintOrderMapper;
|
private final EimsMaintPlanMapper maintPlanMapper;
|
|
@Override
|
public TableDataInfo<Map<String, Object>> queryPageListCustom(Map<String, Object> queryParams, PageQuery pageQuery) {
|
LambdaQueryWrapper<EimsEqu> equWrapper = Wrappers.lambdaQuery();
|
|
if (queryParams.containsKey("keyword")) {
|
String keyword = (String) queryParams.get("keyword");
|
equWrapper.and(StringUtils.isNotBlank(keyword),
|
wrapper -> wrapper
|
.like(EimsEqu::getEquName, keyword)
|
.or()
|
.like(EimsEqu::getAssetNo, keyword)
|
);
|
}
|
|
Page<EimsEquVo> equList = equMapper.selectVoPage(pageQuery.build(), equWrapper);
|
return TableDataInfo.build(fitInspData(equList, queryParams));
|
}
|
|
@Override
|
public TableDataInfo<Map<String, Object>> queryMaintList(Map<String, Object> queryParams, PageQuery pageQuery) {
|
LambdaQueryWrapper<EimsEqu> equWrapper = Wrappers.lambdaQuery();
|
|
if (queryParams.containsKey("keyword")) {
|
String keyword = (String) queryParams.get("keyword");
|
equWrapper.and(StringUtils.isNotBlank(keyword),
|
wrapper -> wrapper
|
.like(EimsEqu::getEquName, keyword)
|
.or()
|
.like(EimsEqu::getAssetNo, keyword)
|
);
|
}
|
|
Page<EimsEquVo> equList = equMapper.selectVoPage(pageQuery.build(), equWrapper);
|
return TableDataInfo.build(fitMaintData(equList, queryParams));
|
}
|
|
private Page<Map<String, Object>> fitMaintData(Page<EimsEquVo> equPageList, Map<String, Object> queryParams) {
|
Integer selectYear = getYearFromParams(queryParams);
|
LocalDate firstDay = Year.of(selectYear).atDay(1); // 第一天
|
LocalDate lastDay = Year.of(selectYear).atDay(Year.of(selectYear).length());
|
Page<Map<String, Object>> page = new Page<>(
|
equPageList.getCurrent(),
|
equPageList.getSize(),
|
equPageList.getTotal(),
|
equPageList.searchCount()
|
);
|
if (equPageList.getRecords().isEmpty()) {
|
return page;
|
}
|
|
List<Long> equIds = equPageList.getRecords().stream()
|
.map(EimsEquVo::getEquId)
|
.collect(Collectors.toList());
|
|
Map<Long, List<EimsMaintOrder>> maintOrderMap = getMaintOrderMap(equIds, firstDay, lastDay);
|
Map<Long, List<EimsMaintPlan>> maintPlanMap = getMaintPlanMap(equIds,selectYear);
|
|
List<Map<String, Object>> resultList = equPageList.getRecords().stream()
|
.map(equ -> buildMaintReport(equ, maintOrderMap, maintPlanMap))
|
.collect(Collectors.toList());
|
|
page.setRecords(resultList);
|
|
return page;
|
}
|
|
private Page<Map<String, Object>> fitInspData(Page<EimsEquVo> equPageList, Map<String, Object> queryParams) {
|
YearMonth yearMonth = getYearMonthFromParams(queryParams);
|
LocalDate firstDay = yearMonth.atDay(1);
|
LocalDate lastDay = yearMonth.atEndOfMonth();
|
|
Page<Map<String, Object>> page = new Page<>(
|
equPageList.getCurrent(),
|
equPageList.getSize(),
|
equPageList.getTotal(),
|
equPageList.searchCount()
|
);
|
|
if (equPageList.getRecords().isEmpty()) {
|
return page;
|
}
|
|
List<Long> equIds = equPageList.getRecords().stream()
|
.map(EimsEquVo::getEquId)
|
.collect(Collectors.toList());
|
|
Map<Long, List<EimsInspectSt>> inspectStMap = getInspectStMap(equIds, firstDay, lastDay);
|
Map<Long, List<EimsInspectPlan>> inspectPlanMap = getInspectPlanMap(equIds, yearMonth);
|
|
List<Map<String, Object>> resultList = equPageList.getRecords().stream()
|
.map(equ -> buildEquipmentReport(equ, inspectStMap, inspectPlanMap, yearMonth))
|
.collect(Collectors.toList());
|
|
page.setRecords(resultList);
|
return page;
|
}
|
|
private YearMonth getYearMonthFromParams(Map<String, Object> queryParams) {
|
if (queryParams.containsKey("selectMonth")) {
|
String[] parts = queryParams.get("selectMonth").toString().split("-");
|
return YearMonth.of(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
|
}
|
return YearMonth.now();
|
}
|
|
private Map<Long, List<EimsInspectSt>> getInspectStMap(List<Long> equIds, LocalDate firstDay, LocalDate lastDay) {
|
LambdaQueryWrapper<EimsInspectSt> sWrapper = Wrappers.lambdaQuery();
|
sWrapper.in(EimsInspectSt::getEquId, equIds)
|
.between(EimsInspectSt::getPlanTime, firstDay, lastDay)
|
.eq(EimsInspectSt::getType, "Day");
|
|
return inspectStMapper.selectList(sWrapper).stream()
|
.collect(Collectors.groupingBy(EimsInspectSt::getEquId));
|
}
|
|
private Map<Long, List<EimsInspectPlan>> getInspectPlanMap(List<Long> equIds, YearMonth yearMonth) {
|
LocalDateTime firstDayTime = yearMonth.atDay(1).atStartOfDay();
|
LocalDateTime lastDayTime = yearMonth.atEndOfMonth().atTime(23, 59, 59);
|
|
LambdaQueryWrapper<EimsInspectPlan> pWrapper = Wrappers.lambdaQuery();
|
pWrapper.in(EimsInspectPlan::getEquId, equIds)
|
.between(EimsInspectPlan::getCreateTime, firstDayTime, lastDayTime);
|
|
return inspectPlanMapper.selectList(pWrapper).stream()
|
.collect(Collectors.groupingBy(EimsInspectPlan::getEquId));
|
}
|
|
private Map<String, Object> buildEquipmentReport(EimsEquVo equ,
|
Map<Long, List<EimsInspectSt>> inspectStMap,
|
Map<Long, List<EimsInspectPlan>> inspectPlanMap,
|
YearMonth yearMonth) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("equName", equ.getEquName());
|
item.put("assetNo", equ.getAssetNo());
|
|
List<EimsInspectSt> equInspList = inspectStMap.getOrDefault(equ.getEquId(), Collections.emptyList());
|
List<EimsInspectPlan> equPlanList = inspectPlanMap.getOrDefault(equ.getEquId(), Collections.emptyList());
|
|
Map<String, EimsInspectSt> stMap = equInspList.stream()
|
.collect(Collectors.toMap(
|
inspSt -> String.valueOf(inspSt.getPlanTime().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDate().getDayOfMonth()),
|
inspSt -> inspSt,
|
(existing, replacement) -> existing
|
));
|
|
Map<String, EimsInspectPlan> planMap = equPlanList.stream()
|
.collect(Collectors.toMap(
|
inspPlan -> String.valueOf(inspPlan.getCreateTime().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDate().getDayOfMonth()),
|
inspPlan -> inspPlan,
|
(existing, replacement) -> existing
|
));
|
|
int daysInMonth = yearMonth.lengthOfMonth();
|
for (int day = 1; day <= daysInMonth; day++) {
|
String dayKey = "day_" + day;
|
if (planMap.containsKey(String.valueOf(day))) {
|
item.put(dayKey, UNCHECKED);
|
} else if (stMap.containsKey(String.valueOf(day))) {
|
EimsInspectSt st = stMap.get(String.valueOf(day));
|
switch (st.getStatus()) {
|
case "0":
|
item.put(dayKey, UNCHECKED);
|
break;
|
case "1":
|
item.put(dayKey, PENDING_VERIFICATION);
|
break;
|
case "2":
|
item.put(dayKey, COMPLETED);
|
break;
|
default:
|
item.put(dayKey, NOT_APPLICABLE);
|
}
|
} else {
|
item.put(dayKey, NOT_APPLICABLE);
|
}
|
}
|
|
return item;
|
}
|
|
|
|
|
|
private Integer getYearFromParams(Map<String, Object> queryParams) {
|
if (queryParams.containsKey("selectYear")) {
|
String year = queryParams.get("selectYear").toString();
|
return Integer.parseInt(year);
|
}
|
return LocalDate.now().getYear();
|
}
|
private Map<Long, List<EimsMaintOrder>> getMaintOrderMap(List<Long> equIds, LocalDate firstDay, LocalDate lastDay) {
|
LambdaQueryWrapper<EimsMaintOrder> sWrapper = Wrappers.lambdaQuery();
|
sWrapper.in(EimsMaintOrder::getEquId, equIds)
|
.between(EimsMaintOrder::getPlanTime, firstDay, lastDay);
|
|
return maintOrderMapper.selectList(sWrapper).stream()
|
.collect(Collectors.groupingBy(EimsMaintOrder::getEquId));
|
}
|
|
private Map<Long, List<EimsMaintPlan>> getMaintPlanMap(List<Long> equIds, Integer year) {
|
LocalDateTime firstDay = Year.of(year).atDay(1).atStartOfDay();
|
LocalDateTime lastDay = Year.of(year).atDay(Year.of(year).length())
|
.atTime(23, 59, 59);
|
|
LambdaQueryWrapper<EimsMaintPlan> pWrapper = Wrappers.lambdaQuery();
|
pWrapper.in(EimsMaintPlan::getEquId, equIds)
|
.between(EimsMaintPlan::getCreateTime, firstDay, lastDay);
|
|
return maintPlanMapper.selectList(pWrapper).stream()
|
.collect(Collectors.groupingBy(EimsMaintPlan::getEquId));
|
}
|
|
private Map<String, Object> buildMaintReport(EimsEquVo equ,
|
Map<Long, List<EimsMaintOrder>> maintOrderMap,
|
Map<Long, List<EimsMaintPlan>> maintPlanMap) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("equName", equ.getEquName());
|
item.put("assetNo", equ.getAssetNo());
|
|
List<EimsMaintOrder> equMaintOrderList = maintOrderMap.getOrDefault(equ.getEquId(), Collections.emptyList());
|
List<EimsMaintPlan> equMaintPlanList = maintPlanMap.getOrDefault(equ.getEquId(), Collections.emptyList());
|
|
|
Map<String, String> orderMap = equMaintOrderList.stream()
|
.collect(Collectors.groupingBy(
|
order -> String.valueOf(order.getPlanTime().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDate().getMonthValue()),
|
Collectors.collectingAndThen(
|
Collectors.toList(),
|
orders -> {
|
boolean allZero = orders.stream().allMatch(o -> o.getStatus().equals("0"));
|
if (allZero) {
|
return MAINT_0; // 待保养
|
}
|
boolean allGtOne = orders.stream().allMatch(o -> Integer.parseInt(o.getStatus()) > 1);
|
if (allGtOne) {
|
return MAINT_2; // 待验证
|
}
|
boolean allGtTwo = orders.stream().allMatch(o -> Integer.parseInt(o.getStatus()) > 2);
|
if (allGtTwo) {
|
return MAINT_3; // 已完成
|
}
|
return "保养中";
|
}
|
)
|
));
|
Map<String, EimsMaintPlan> planMap = equMaintPlanList.stream()
|
.collect(Collectors.toMap(
|
maintPlan -> String.valueOf(maintPlan.getCreateTime().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDate().getMonthValue()),
|
maintPlan -> maintPlan,
|
(existing, replacement) -> existing
|
));
|
|
int monthInYear = 12;
|
for (int month = 1; month <= monthInYear; month++) {
|
String monthKey = "month_" + month;
|
if (planMap.containsKey(String.valueOf(month))) {
|
item.put(monthKey, MAINT_0);
|
} else if (orderMap.containsKey(String.valueOf(month))) {
|
String result = orderMap.get(String.valueOf(month));
|
item.put(monthKey, result);
|
|
} else {
|
item.put(monthKey, NOT_APPLICABLE);
|
}
|
}
|
|
return item;
|
}
|
}
|
