package cn.iocoder.yudao.module.mes.controller.admin.dv.statistics;
|
|
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
|
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
|
import cn.iocoder.yudao.module.mes.controller.admin.dv.statistics.vo.MesDvOeeRespVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.dv.statistics.vo.MesDvStatisticsRespVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.maintenrecord.MesDvMaintenRecordDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.repair.MesDvRepairDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryTypeMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.maintenrecord.MesDvMaintenRecordMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.repair.MesDvRepairMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
|
import cn.iocoder.yudao.module.mes.enums.dv.MesDvMachineryStatusEnum;
|
import io.swagger.v3.oas.annotations.Operation;
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
import jakarta.annotation.Resource;
|
import org.springframework.format.annotation.DateTimeFormat;
|
import org.springframework.security.access.prepost.PreAuthorize;
|
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.RequestParam;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.Duration;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
|
|
@Tag(name = "管理后台 - MES 设备统计")
|
@RestController
|
@RequestMapping("/mes/dv/statistics")
|
@Validated
|
public class MesDvStatisticsController {
|
|
@Resource
|
private MesDvMachineryMapper machineryMapper;
|
@Resource
|
private MesDvMachineryTypeMapper machineryTypeMapper;
|
@Resource
|
private MesDvRepairMapper repairMapper;
|
@Resource
|
private MesDvMaintenRecordMapper maintenRecordMapper;
|
@Resource
|
private MesProTaskMapper taskMapper;
|
|
@GetMapping("/summary")
|
@Operation(summary = "设备统计汇总（台账/维修/保养/类型分布）")
|
@PreAuthorize("@ss.hasPermission('mes:dv-machinery:query')")
|
public CommonResult<MesDvStatisticsRespVO> getSummary() {
|
MesDvStatisticsRespVO vo = new MesDvStatisticsRespVO();
|
|
// 1. 设备台账统计
|
Long total = machineryMapper.selectCount();
|
Long producing = machineryMapper.selectCount(new LambdaQueryWrapperX<MesDvMachineryDO>()
|
.eq(MesDvMachineryDO::getStatus, MesDvMachineryStatusEnum.PRODUCING.getStatus()));
|
Long stopped = machineryMapper.selectCount(new LambdaQueryWrapperX<MesDvMachineryDO>()
|
.eq(MesDvMachineryDO::getStatus, MesDvMachineryStatusEnum.STOP.getStatus()));
|
Long maintaining = machineryMapper.selectCount(new LambdaQueryWrapperX<MesDvMachineryDO>()
|
.eq(MesDvMachineryDO::getStatus, MesDvMachineryStatusEnum.MAINTENANCE.getStatus()));
|
vo.setTotalMachinery(total);
|
vo.setProducingCount(producing);
|
vo.setStoppedCount(stopped);
|
vo.setMaintainingCount(maintaining);
|
vo.setFaultRate(total != null && total > 0
|
? (double) (stopped + maintaining) / total * 100 : 0D);
|
|
// 2. 维修统计
|
vo.setTotalRepair(repairMapper.selectCount());
|
vo.setFinishedRepair(repairMapper.selectCount(new LambdaQueryWrapperX<MesDvRepairDO>()
|
.eq(MesDvRepairDO::getStatus, cn.iocoder.yudao.module.mes.enums.dv.MesDvRepairStatusEnum.FINISHED.getStatus())));
|
vo.setProcessingRepair((vo.getTotalRepair() != null ? vo.getTotalRepair() : 0L)
|
- (vo.getFinishedRepair() != null ? vo.getFinishedRepair() : 0L));
|
|
// 3. 保养统计
|
vo.setTotalMainten(maintenRecordMapper.selectCount());
|
vo.setFinishedMainten(maintenRecordMapper.selectCount(new LambdaQueryWrapperX<MesDvMaintenRecordDO>()
|
.eq(MesDvMaintenRecordDO::getStatus, cn.iocoder.yudao.module.mes.enums.dv.MesDvMaintenRecordStatusEnum.SUBMITTED.getStatus())));
|
|
// 4. 按设备类型分布
|
List<MesDvMachineryDO> machineryList = machineryMapper.selectList();
|
Map<Long, Long> typeCountMap = new HashMap<>();
|
for (MesDvMachineryDO machinery : machineryList) {
|
if (machinery.getMachineryTypeId() == null) {
|
continue;
|
}
|
typeCountMap.merge(machinery.getMachineryTypeId(), 1L, Long::sum);
|
}
|
List<MesDvMachineryTypeDO> typeList = machineryTypeMapper.selectList();
|
Map<Long, String> typeNameMap = new HashMap<>();
|
for (MesDvMachineryTypeDO type : typeList) {
|
typeNameMap.put(type.getId(), type.getName());
|
}
|
List<MesDvStatisticsRespVO.TypeItem> typeDistribution = new ArrayList<>();
|
typeCountMap.forEach((typeId, count) -> {
|
MesDvStatisticsRespVO.TypeItem item = new MesDvStatisticsRespVO.TypeItem();
|
item.setMachineryTypeId(typeId);
|
item.setMachineryTypeName(typeNameMap.get(typeId));
|
item.setCount(count);
|
typeDistribution.add(item);
|
});
|
vo.setTypeDistribution(typeDistribution);
|
return success(vo);
|
}
|
|
@GetMapping("/oee")
|
@Operation(summary = "设备 OEE 统计（稼动率×性能开动率×良品率）")
|
@PreAuthorize("@ss.hasPermission('mes:dv-machinery:query')")
|
public CommonResult<MesDvOeeRespVO> getOee(
|
@RequestParam(value = "startTime", required = false)
|
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
|
@RequestParam(value = "endTime", required = false)
|
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime) {
|
// 1. 查询统计区间内任务（按完成时间过滤；不传区间则统计全部）
|
List<MesProTaskDO> allTasks = taskMapper.selectList(new LambdaQueryWrapperX<MesProTaskDO>()
|
.betweenIfPresent(MesProTaskDO::getFinishDate, new LocalDateTime[]{startTime, endTime}));
|
|
// 2. 整体 OEE
|
MesDvOeeRespVO vo = new MesDvOeeRespVO();
|
OeeCalc overall = calcOee(allTasks);
|
vo.setOverallOee(overall.oee);
|
vo.setOverallAvailability(overall.availability);
|
vo.setOverallPerformance(overall.performance);
|
vo.setOverallQuality(overall.quality);
|
vo.setTaskCount((long) allTasks.size());
|
|
// 3. 按设备聚合：任务按工作站分组，设备通过 workstationId 关联工作站
|
Map<Long, List<MesProTaskDO>> tasksByWorkstation = new HashMap<>();
|
for (MesProTaskDO task : allTasks) {
|
if (task.getWorkstationId() == null) {
|
continue;
|
}
|
tasksByWorkstation.computeIfAbsent(task.getWorkstationId(), k -> new ArrayList<>()).add(task);
|
}
|
List<MesDvOeeRespVO.MachineryOee> items = new ArrayList<>();
|
for (MesDvMachineryDO machinery : machineryMapper.selectList()) {
|
if (machinery.getWorkstationId() == null) {
|
continue; // 未绑定工作站，无法关联任务
|
}
|
List<MesProTaskDO> tasks = tasksByWorkstation.getOrDefault(machinery.getWorkstationId(), Collections.emptyList());
|
OeeCalc calc = calcOee(tasks);
|
MesDvOeeRespVO.MachineryOee item = new MesDvOeeRespVO.MachineryOee();
|
item.setMachineryId(machinery.getId());
|
item.setMachineryCode(machinery.getCode());
|
item.setMachineryName(machinery.getName());
|
item.setOee(calc.oee);
|
item.setAvailability(calc.availability);
|
item.setPerformance(calc.performance);
|
item.setQuality(calc.quality);
|
item.setTaskCount((long) tasks.size());
|
item.setPlannedQuantity(calc.plannedQuantity);
|
item.setProducedQuantity(calc.producedQuantity);
|
items.add(item);
|
}
|
vo.setItems(items);
|
return success(vo);
|
}
|
|
private static OeeCalc calcOee(List<MesProTaskDO> tasks) {
|
double totalPlannedHours = 0, totalActualHours = 0;
|
BigDecimal totalPlannedQty = BigDecimal.ZERO, totalProducedQty = BigDecimal.ZERO, totalQualifyQty = BigDecimal.ZERO;
|
for (MesProTaskDO task : tasks) {
|
if (task.getDuration() != null) {
|
totalPlannedHours += task.getDuration() * 8D; // 1 工作日 = 8 小时
|
}
|
if (task.getFirstFeedbackTime() != null && task.getLastFeedbackTime() != null
|
&& task.getLastFeedbackTime().isAfter(task.getFirstFeedbackTime())) {
|
totalActualHours += Duration.between(task.getFirstFeedbackTime(), task.getLastFeedbackTime()).toMinutes() / 60D;
|
}
|
if (task.getQuantity() != null) {
|
totalPlannedQty = totalPlannedQty.add(task.getQuantity());
|
}
|
if (task.getProducedQuantity() != null) {
|
totalProducedQty = totalProducedQty.add(task.getProducedQuantity());
|
}
|
if (task.getQualifyQuantity() != null) {
|
totalQualifyQty = totalQualifyQty.add(task.getQualifyQuantity());
|
}
|
}
|
OeeCalc calc = new OeeCalc();
|
// 稼动率 = 实际报工时长 / 计划时长（无计划时长时按 1 处理）
|
calc.availability = percent(totalPlannedHours > 0 ? Math.min(1D, totalActualHours / totalPlannedHours) : 1D);
|
// 性能开动率 = 实际产量 / 计划产量
|
calc.performance = totalPlannedQty.compareTo(BigDecimal.ZERO) > 0
|
? percent(Math.min(1D, totalProducedQty.divide(totalPlannedQty, 4, RoundingMode.HALF_UP).doubleValue())) : 0D;
|
// 良品率 = 合格品 / 实际产量（无产量时按 1 处理）
|
calc.quality = totalProducedQty.compareTo(BigDecimal.ZERO) > 0
|
? percent(Math.min(1D, totalQualifyQty.divide(totalProducedQty, 4, RoundingMode.HALF_UP).doubleValue())) : 100D;
|
// OEE(%) = 稼动率(%) × 性能(%) × 良品率(%) / 10000，保留两位小数
|
calc.oee = Math.round(calc.availability * calc.performance * calc.quality / 10000D * 100D) / 100D;
|
calc.plannedQuantity = totalPlannedQty;
|
calc.producedQuantity = totalProducedQty;
|
return calc;
|
}
|
|
/** 比例(0-1) 转百分比，保留两位小数 */
|
private static double percent(double ratio) {
|
return Math.round(ratio * 10000D) / 100D;
|
}
|
|
private static class OeeCalc {
|
private Double availability;
|
private Double performance;
|
private Double quality;
|
private Double oee;
|
private BigDecimal plannedQuantity;
|
private BigDecimal producedQuantity;
|
}
|
|
}
|
