package org.dromara.eims.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import lombok.RequiredArgsConstructor;
|
import org.dromara.common.core.constant.DictConstants;
|
import org.dromara.common.core.domain.R;
|
import org.dromara.common.core.utils.DateUtils;
|
import org.dromara.common.mybatis.core.page.PageQuery;
|
import org.dromara.eims.domain.*;
|
import org.dromara.eims.domain.bo.EimsEquBo;
|
import org.dromara.eims.domain.vo.EimsInspectStVo;
|
import org.dromara.eims.domain.vo.EimsMaintOrderVo;
|
import org.dromara.eims.domain.vo.EimsRepairReqVo;
|
import org.dromara.eims.mapper.*;
|
import org.springframework.validation.annotation.Validated;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Validated
|
@RequiredArgsConstructor
|
@RestController
|
@RequestMapping("/eims/board")
|
public class BoardController {
|
private final EimsRepairReqMapper reqMapper;
|
private final EimsRepairResMapper resMapper;
|
private final EimsInspectStMapper inspStMapper;
|
private final EimsInspectRecordMapper inspRecordMapper;
|
private final EimsMaintStMapper maintStMapper;
|
private final EimsEquStatuMapper equStatuMapper;
|
private final EimsSpareMapper spareMapper;
|
private final EimsEquMapper equMapper;
|
private final EimsMaintOrderMapper maintOrderMapper;
|
|
@GetMapping("/todoList")
|
public R<List<Map<String,Object>>> todoList() {
|
List<Map<String,Object>> result = new ArrayList<>();
|
|
// 报修单-待接单
|
LambdaQueryWrapper<EimsRepairReq> reqWrapper = new LambdaQueryWrapper<>();
|
// 待接单
|
reqWrapper.eq(EimsRepairReq::getStatus, DictConstants.REPAIR_REQ_STATUS_DETAIL.DAIJIEDAN);
|
Long reqCount = reqMapper.selectCount(reqWrapper);
|
Map<String,Object> reqMap = new HashMap<>();
|
reqMap.put("menu","故障报修");
|
reqMap.put("count",reqCount);
|
result.add(reqMap);
|
|
|
//维修工单-未完成
|
LambdaQueryWrapper<EimsRepairRes> resWrapper = new LambdaQueryWrapper<>();
|
// 未完成
|
resWrapper.ne(EimsRepairRes::getStatus, DictConstants.REPAIR_RES_STATUS_DETAIL.WANCHENG);
|
Long resCount = resMapper.selectCount(resWrapper);
|
Map<String,Object> resMap = new HashMap<>();
|
resMap.put("menu","维修任务");
|
resMap.put("count",resCount);
|
result.add(resMap);
|
|
//维修工单-评价
|
LambdaQueryWrapper<EimsRepairRes> evWrapper = new LambdaQueryWrapper<>();
|
evWrapper.isNull(EimsRepairRes::getFbId);
|
Long evCount = resMapper.selectCount(evWrapper);
|
Map<String,Object> evMap = new HashMap<>();
|
evMap.put("menu","维修评价");
|
evMap.put("count",evCount);
|
result.add(evMap);
|
|
//点检汇总任务
|
LambdaQueryWrapper<EimsInspectSt> inspStWrapper = new LambdaQueryWrapper<>();
|
//未点检
|
inspStWrapper.eq(EimsInspectSt::getStatus, DictConstants.EIMS_INSPECT_STATUS_DETAIL.N);
|
Long inspStCount = inspStMapper.selectCount(inspStWrapper);
|
Map<String,Object> inspStMap = new HashMap<>();
|
inspStMap.put("menu","点检任务");
|
inspStMap.put("count",inspStCount);
|
result.add(inspStMap);
|
|
//保养汇总任务
|
LambdaQueryWrapper<EimsMaintSt> maintStWrapper = new LambdaQueryWrapper<>();
|
//未完成工单汇总
|
maintStWrapper.eq(EimsMaintSt::getStatus,DictConstants.MAINT_ORDER_ST_STATUS_DETAIL.N);
|
Long maintStCount = maintStMapper.selectCount(maintStWrapper);
|
Map<String,Object> maintStMap = new HashMap<>();
|
maintStMap.put("menu","保养任务");
|
maintStMap.put("count",maintStCount);
|
result.add(maintStMap);
|
|
//设备状态变更
|
LambdaQueryWrapper<EimsEquStatu> equStatuWrapper = new LambdaQueryWrapper<>();
|
equStatuWrapper.isNotNull(EimsEquStatu::getChangeDate);
|
// 获取当前日期
|
LocalDate today = LocalDate.now();
|
// 构造当天的 00:00:00
|
LocalDateTime startOfDay = today.atStartOfDay();
|
// 构造当天的 23:59:59
|
LocalDateTime endOfDay = today.atTime(23, 59, 59);
|
// 定义格式化模板
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
// 格式化输出
|
String startStr = startOfDay.format(formatter);
|
String endStr = endOfDay.format(formatter);
|
equStatuWrapper.between(EimsEquStatu::getChangeDate,startStr,endStr);
|
Long equStatuCount = equStatuMapper.selectCount(equStatuWrapper);
|
Map<String,Object> equStatuMap = new HashMap<>();
|
equStatuMap.put("menu","状态变更");
|
equStatuMap.put("count",equStatuCount);
|
result.add(equStatuMap);
|
|
return R.ok(result);
|
|
}
|
|
|
@GetMapping("/spareWarn")
|
public R<Map<String,Object>> spareWarn() {
|
Map<String,Object> result = new HashMap<>();
|
|
LambdaQueryWrapper<EimsSpare> spareUpWrapper = new LambdaQueryWrapper<>();
|
spareUpWrapper.isNotNull(EimsSpare::getUpperStock)
|
.isNotNull(EimsSpare::getActualStock)
|
.gt(EimsSpare::getActualStock, 0)
|
.gt(EimsSpare::getUpperStock, 0)
|
.apply("actual_stock > upper_stock");
|
Long upper = spareMapper.selectCount(spareUpWrapper);
|
|
result.put("upper",upper);
|
|
LambdaQueryWrapper<EimsSpare> spareLowWrapper = new LambdaQueryWrapper<>();
|
spareLowWrapper.isNotNull(EimsSpare::getLowerStock)
|
.isNotNull(EimsSpare::getActualStock)
|
.gt(EimsSpare::getActualStock, 0)
|
.gt(EimsSpare::getLowerStock, 0)
|
.apply("actual_stock < lower_stock");
|
Long lower = spareMapper.selectCount(spareLowWrapper);
|
result.put("lower",lower);
|
|
return R.ok(result);
|
}
|
|
/**
|
* 查询设备在用状态
|
* @return
|
*/
|
@GetMapping("/equStatu")
|
public R<Map<String,Integer>> queryEquStatu() {
|
List<EimsEqu> eimsEqus = equMapper.selectList();
|
Map<String, Integer> result = countStatus(eimsEqus);
|
return R.ok(result);
|
}
|
|
/**
|
* 查询今天点检数据
|
* @return
|
*/
|
@GetMapping("/todayInsp")
|
public R<Map<String,Object>> todayInsp() {
|
Map<String, Object> result = new HashMap<>();
|
List<Map<String, Object>> data = new ArrayList<>();
|
List<Map<String, Object>> sub = new ArrayList<>();
|
|
// 初始化主数据统计项
|
data.add(createDataItem("已完成", 0));
|
data.add(createDataItem("未完成", 0));
|
|
// 初始化子项统计
|
sub.add(createSubItem("正常", 0));
|
sub.add(createSubItem("异常", 0));
|
sub.add(createSubItem("未检", 0));
|
|
result.put("data", data);
|
result.put("sub", sub);
|
|
// 查询今日计划巡检任务
|
LambdaQueryWrapper<EimsInspectSt> inspStWrapper = new LambdaQueryWrapper<>();
|
inspStWrapper.eq(EimsInspectSt::getType, "Day");
|
inspStWrapper.eq(EimsInspectSt::getPlanTime, DateUtils.dateTimeNow(DateUtils.YYYY_MM_DD));
|
List<EimsInspectStVo> inspectStList = inspStMapper.selectVoList(inspStWrapper);
|
|
if (inspectStList == null || inspectStList.isEmpty()) {
|
return R.ok(result);
|
}
|
|
long completedCount = 0;
|
List<String> stIdList = new ArrayList<>();
|
|
for (EimsInspectStVo item : inspectStList) {
|
if (DictConstants.EIMS_INSPECT_STATUS_DETAIL.Y.equals(item.getStatus())) {
|
completedCount++;
|
}
|
stIdList.add(item.getStId());
|
}
|
|
int total = inspectStList.size();
|
data.get(0).put("value", completedCount);
|
data.get(1).put("value", total - completedCount);
|
|
// 查询巡检记录
|
List<EimsInspectRecord> recordList = Collections.emptyList();
|
if (!stIdList.isEmpty()) {
|
QueryWrapper<EimsInspectRecord> recordWrapper = new QueryWrapper<>();
|
recordWrapper.in("st_id", stIdList);
|
recordList = inspRecordMapper.selectList(recordWrapper);
|
}
|
|
if (recordList == null || recordList.isEmpty()) {
|
return R.ok(result);
|
}
|
|
long normalCount = 0;
|
long abnormalCount = 0;
|
|
for (EimsInspectRecord record : recordList) {
|
String status = record.getStatus();
|
if (DictConstants.EIMS_INSPECT_RESULT_DETAIL.Y.equals(status)) {
|
normalCount++;
|
} else if (DictConstants.EIMS_INSPECT_RESULT_DETAIL.N.equals(status)) {
|
abnormalCount++;
|
}
|
}
|
|
int unCheckedCount = recordList.size() - (int) (normalCount + abnormalCount);
|
|
sub.get(0).put("value", normalCount);
|
sub.get(1).put("value", abnormalCount);
|
sub.get(2).put("value", unCheckedCount);
|
|
return R.ok(result);
|
|
}
|
|
|
@GetMapping("/monthReq")
|
public R<Map<String,Object>> monthReq() {
|
Map<String,Object> result = new HashMap<>();
|
List<Map<String, Object>> statusList = new ArrayList<>();
|
LocalDate today = LocalDate.now();
|
LambdaQueryWrapper<EimsRepairReq> queryWrapper = new LambdaQueryWrapper<EimsRepairReq>()
|
.between(EimsRepairReq::getOccTime,
|
today.with(TemporalAdjusters.firstDayOfMonth()),
|
today.with(TemporalAdjusters.lastDayOfMonth()));
|
List<EimsRepairReqVo> reqList = reqMapper.selectVoList(queryWrapper);
|
long todayCount = reqList.stream()
|
.filter(r -> r.getReqTime() != null &&
|
r.getReqTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().isEqual(LocalDate.now()))
|
.count();
|
if (reqList != null && !reqList.isEmpty()) {
|
// 假设 reqList 已经从数据库查询出来，并且不为空
|
Map<String, Long> statusCountMap = reqList.stream()
|
.collect(Collectors.groupingBy(
|
item -> {
|
switch (item.getStatus()) {
|
case "0": return "待接单";
|
case "1": return "已接单";
|
case "2": return "维修中";
|
case "3": return "已完成";
|
default: return "未知状态";
|
}
|
},
|
Collectors.counting()
|
));
|
|
// 按固定顺序排序生成 List<Map<String, Object>>
|
|
statusList.add(Map.of("name", "待接单", "value", statusCountMap.getOrDefault("待接单", 0L)));
|
statusList.add(Map.of("name", "已接单", "value", statusCountMap.getOrDefault("已接单", 0L)));
|
statusList.add(Map.of("name", "维修中", "value", statusCountMap.getOrDefault("维修中", 0L)));
|
statusList.add(Map.of("name", "已完成", "value", statusCountMap.getOrDefault("已完成", 0L)));
|
}
|
result.put("data",statusList);
|
result.put("today",todayCount);
|
return R.ok(result);
|
|
}
|
|
@GetMapping("/monthMainit")
|
public R<Map<String,Object>> monthMainit() {
|
Map<String,Object> result = new HashMap<>();
|
List<Map<String, Object>> statusList = new ArrayList<>();
|
LocalDate today = LocalDate.now();
|
LambdaQueryWrapper<EimsMaintOrder> queryWrapper = new LambdaQueryWrapper<EimsMaintOrder>()
|
.between(EimsMaintOrder::getPlanTime,
|
today.with(TemporalAdjusters.firstDayOfMonth()),
|
today.with(TemporalAdjusters.lastDayOfMonth()));
|
List<EimsMaintOrderVo> orderList = maintOrderMapper.selectVoList(queryWrapper);
|
long todayCount = orderList.stream()
|
.filter(r -> r.getPlanTime() != null &&
|
r.getPlanTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().isEqual(LocalDate.now()))
|
.count();
|
if (orderList != null && !orderList.isEmpty()) {
|
|
Map<String, Long> statusCountMap = orderList.stream()
|
.collect(Collectors.groupingBy(
|
item -> {
|
switch (item.getStatus()) {
|
case "0": return "待保养";
|
case "1": return "保养中";
|
case "2": return "待验证";
|
case "3": return "已完成";
|
default: return "未知状态";
|
}
|
},
|
Collectors.counting()
|
));
|
|
// 按固定顺序排序生成 List<Map<String, Object>>
|
|
statusList.add(Map.of("name", "待保养", "value", statusCountMap.getOrDefault("待保养", 0L)));
|
statusList.add(Map.of("name", "保养中", "value", statusCountMap.getOrDefault("保养中", 0L)));
|
statusList.add(Map.of("name", "待验证", "value", statusCountMap.getOrDefault("待验证", 0L)));
|
statusList.add(Map.of("name", "已完成", "value", statusCountMap.getOrDefault("已完成", 0L)));
|
}
|
result.put("data",statusList);
|
result.put("today",todayCount);
|
return R.ok(result);
|
|
}
|
|
// 辅助方法：创建主数据项
|
private Map<String, Object> createDataItem(String name, long value) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("name", name);
|
item.put("value", value);
|
return item;
|
}
|
|
// 辅助方法：创建子数据项
|
private Map<String, Object> createSubItem(String name, long value) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("name", name);
|
item.put("value", value);
|
return item;
|
}
|
|
|
/**
|
* 统计各状态设备数量
|
* @param eimsEqus
|
* @return
|
*/
|
public static Map<String, Integer> countStatus(List<EimsEqu> eimsEqus) {
|
Map<String, Integer> statusCount = new HashMap<>();
|
Map<String, String> statusMap = new HashMap<String, String>() {{
|
put("0", "试用");
|
put("1", "使用");
|
put("2", "停用");
|
put("3", "报废");
|
put("4", "闲置");
|
put("5", "新增");
|
put("其他", "其他");
|
}};
|
|
for (EimsEqu equ : eimsEqus) {
|
String status = equ.getStatus();
|
status = (status == null || status.trim().isEmpty()) ? "其他" : status;
|
if(statusMap.containsKey(status)){
|
statusCount.put(statusMap.get(status), statusCount.getOrDefault(statusMap.get(status), 0) + 1);
|
}
|
|
}
|
|
|
return statusCount;
|
}
|
|
}
|
