package cn.iocoder.yudao.module.mes.service.pro.worktime;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.feedback.vo.MesProFeedbackSaveReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.worktime.vo.MesProWorktimeCalcReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.worktime.vo.MesProWorktimeCalcRespVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.mdm.MesMdmItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackAuxDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.process.MesProProcessDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.worktime.MesProWorktimeAuxDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderParamRecordDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.MesProWorkOrderParamRecordDetailDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderParamRecordDetailMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderParamRecordMapper;
|
import cn.iocoder.yudao.module.mes.service.md.unitmeasure.MesMdUnitMeasureService;
|
import cn.iocoder.yudao.module.mes.service.mdm.MesMdmItemService;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskService;
|
import jakarta.annotation.Resource;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PRO_TASK_NOT_EXISTS;
|
|
/**
|
* MES 标准工时计算 Service 实现类
|
*
|
* <p>计算口径（与《工时考核（数改模版）》一致）：
|
* <ul>
|
* <li>方式 1-转速×节距：线速度 = 转速 × 节距 ÷ 1000 × 折算系数</li>
|
* <li>方式 2-线速度直取：线速度 = 参数值</li>
|
* <li>方式 3-满速百分比×节距：转速 = 满转速 × 百分比 ÷ 100，再按方式 1 折算线速度</li>
|
* <li>主工时（小时）= 生产长度（米）÷ 线速度（米/分）÷ 60</li>
|
* <li>辅助工时（小时）= Σ(次数 × 单项分钟数) ÷ 60；按米折算时 = 米数 ÷ 折算速度</li>
|
* <li>标准工时 = 主工时 + 辅助工时</li>
|
* </ul>
|
* 任何参数缺失都只记为“未计算原因”，不阻断报工。
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
public class MesProWorktimeServiceImpl implements MesProWorktimeService {
|
|
private static final BigDecimal SIXTY = BigDecimal.valueOf(60);
|
private static final BigDecimal THOUSAND = BigDecimal.valueOf(1000);
|
private static final BigDecimal HUNDRED = BigDecimal.valueOf(100);
|
|
@Resource
|
private MesProTaskService taskService;
|
@Resource
|
private MesProProcessService processService;
|
@Resource
|
private MesProWorktimeAuxService worktimeAuxService;
|
@Resource
|
private MesMdmItemService mdmItemService;
|
@Resource
|
private MesMdUnitMeasureService unitMeasureService;
|
@Resource
|
private MesProWorkOrderParamRecordMapper paramRecordMapper;
|
@Resource
|
private MesProWorkOrderParamRecordDetailMapper paramRecordDetailMapper;
|
|
/**
|
* 工时超出标准工时的告警阈值（百分比），默认 20%
|
*/
|
@Value("${yudao.mes.worktime.warn-threshold:20}")
|
private BigDecimal warnThreshold;
|
|
@Override
|
public MesProWorktimeCalcRespVO calculate(MesProWorktimeCalcReqVO reqVO) {
|
MesProTaskDO task = taskService.getTask(reqVO.getTaskId());
|
if (task == null) {
|
throw exception(PRO_TASK_NOT_EXISTS);
|
}
|
return doCalculate(task, reqVO.getProductionLength(), reqVO.getFeedbackQuantity(), reqVO.getAuxList());
|
}
|
|
@Override
|
public List<MesProFeedbackAuxDO> calculateForFeedback(MesProFeedbackDO feedback,
|
List<MesProFeedbackSaveReqVO.AuxValue> auxValues) {
|
MesProTaskDO task = feedback.getTaskId() != null ? taskService.getTask(feedback.getTaskId()) : null;
|
List<MesProWorktimeCalcReqVO.AuxInput> auxInputs = toAuxInputs(auxValues);
|
MesProWorktimeCalcRespVO result = doCalculate(task, feedback.getProductionLength(),
|
feedback.getFeedbackQuantity(), auxInputs);
|
|
feedback.setProductionLength(result.getProductionLength() != null
|
? result.getProductionLength() : BigDecimal.ZERO);
|
feedback.setStandardWorkHours(result.getStandardWorkHours());
|
feedback.setStandardPrimaryHours(result.getPrimaryHours());
|
feedback.setStandardAuxHours(result.getAuxHours());
|
String note = result.getNote();
|
if (CollUtil.isNotEmpty(result.getMissingReasons())) {
|
note = StrUtil.format("{}；未计算原因：{}", note, String.join("；", result.getMissingReasons()));
|
}
|
feedback.setStdCalcNote(StrUtil.maxLength(note, 500));
|
|
// 辅助工时明细：以计算结果为准，保留录入的次数/材料对，便于审核追查
|
List<MesProFeedbackAuxDO> auxList = new ArrayList<>();
|
if (CollUtil.isNotEmpty(result.getAuxList())) {
|
for (MesProWorktimeCalcRespVO.AuxResult auxResult : result.getAuxList()) {
|
auxList.add(MesProFeedbackAuxDO.builder()
|
.auxItemId(auxResult.getAuxItemId())
|
.itemName(auxResult.getItemName())
|
.measureType(auxResult.getMeasureType())
|
.quantity(auxResult.getQuantity())
|
.materialFrom(auxResult.getMaterialFrom())
|
.materialTo(auxResult.getMaterialTo())
|
.minutes(auxResult.getMinutes())
|
.remark(auxResult.getRemark())
|
.build());
|
}
|
}
|
return auxList;
|
}
|
|
@Override
|
public String buildWarnMessage(BigDecimal actualHours, BigDecimal standardHours) {
|
if (actualHours == null || standardHours == null || standardHours.signum() <= 0) {
|
return null;
|
}
|
BigDecimal threshold = warnThreshold != null ? warnThreshold : BigDecimal.valueOf(20);
|
BigDecimal diffRate = actualHours.subtract(standardHours)
|
.multiply(HUNDRED)
|
.divide(standardHours, 2, RoundingMode.HALF_UP);
|
if (diffRate.compareTo(threshold) <= 0) {
|
return null;
|
}
|
return StrUtil.format("本次报工工时 {} 小时，高于标准工时 {} 小时达 {}%，超过 {}% 阈值；"
|
+ "请核对报工工时是否录错，以及辅助项次数是否按实际填写",
|
actualHours.setScale(2, RoundingMode.HALF_UP),
|
standardHours.setScale(2, RoundingMode.HALF_UP),
|
diffRate, threshold.setScale(2, RoundingMode.HALF_UP).stripTrailingZeros());
|
}
|
|
private MesProWorktimeCalcRespVO doCalculate(MesProTaskDO task, BigDecimal productionLength,
|
BigDecimal feedbackQuantity,
|
List<MesProWorktimeCalcReqVO.AuxInput> auxInputs) {
|
MesProWorktimeCalcRespVO resp = new MesProWorktimeCalcRespVO();
|
resp.setProductionLength(productionLength);
|
resp.setStandardWorkHours(BigDecimal.ZERO);
|
resp.setPrimaryHours(BigDecimal.ZERO);
|
resp.setAuxHours(BigDecimal.ZERO);
|
resp.setAuxList(List.of());
|
List<String> missingReasons = new ArrayList<>();
|
resp.setMissingReasons(missingReasons);
|
if (task == null) {
|
missingReasons.add("生产任务不存在，无法计算标准工时");
|
resp.setNote(String.join("；", missingReasons));
|
return resp;
|
}
|
Long processId = task.getProcessId();
|
MesProProcessDO process = processId != null ? processService.getProcess(processId) : null;
|
if (process == null) {
|
missingReasons.add(StrUtil.format("生产任务的工序 ID={} 不存在，无法计算标准工时", processId));
|
resp.setNote(String.join("；", missingReasons));
|
return resp;
|
}
|
|
// 1. 生产长度：未填且报工单位为“米”时按报工数量带入
|
BigDecimal length = productionLength;
|
if (length == null || length.signum() <= 0) {
|
length = defaultProductionLength(task, feedbackQuantity);
|
}
|
if (length == null || length.signum() <= 0) {
|
missingReasons.add("未填写生产长度（米），无法计算主工时；请在报工单填写本次生产长度");
|
}
|
resp.setProductionLength(length);
|
|
// 2. 线速度
|
SpeedResult speedResult = calculateSpeed(task, process, missingReasons);
|
|
// 3. 主工时
|
BigDecimal primaryHours = BigDecimal.ZERO;
|
if (length != null && length.signum() > 0 && speedResult.speed != null && speedResult.speed.signum() > 0) {
|
primaryHours = length.divide(speedResult.speed, 6, RoundingMode.HALF_UP)
|
.divide(SIXTY, 2, RoundingMode.HALF_UP);
|
}
|
|
// 4. 辅助工时
|
AuxCalcResult auxResult = calculateAux(task, process, auxInputs, missingReasons);
|
|
// 5. 汇总
|
BigDecimal standardHours = primaryHours.add(auxResult.auxHours).setScale(2, RoundingMode.HALF_UP);
|
resp.setPrimaryHours(primaryHours);
|
resp.setAuxHours(auxResult.auxHours);
|
resp.setStandardWorkHours(standardHours);
|
resp.setAuxList(auxResult.items);
|
resp.setNote(buildNote(length, speedResult, primaryHours, auxResult));
|
return resp;
|
}
|
|
/**
|
* 计算线速度（米/分）
|
*/
|
private SpeedResult calculateSpeed(MesProTaskDO task, MesProProcessDO process, List<String> missingReasons) {
|
Integer mode = process.getStdTimeMode();
|
if (mode == null || mode == 0) {
|
missingReasons.add(StrUtil.format("工序「{}」未启用标准工时计算方式，主工时按 0 处理；"
|
+ "请在工序设置中选择计算方式并绑定参数", process.getName()));
|
return new SpeedResult(null, null);
|
}
|
Map<String, String> paramValues = loadTaskParamValues(task.getId());
|
BigDecimal factor = process.getStdTimeFactor() != null ? process.getStdTimeFactor() : BigDecimal.ONE;
|
|
if (mode == 2) {
|
BigDecimal speed = parseParam(process.getStdSpeedParamCode(), "线速度", paramValues, missingReasons);
|
return new SpeedResult(speed, StrUtil.format("线速度 {} 米/分（参数直取）", speed));
|
}
|
|
BigDecimal pitch = parseParam(process.getStdPitchParamCode(), "节距", paramValues, missingReasons);
|
BigDecimal rpm;
|
String rpmNote;
|
if (mode == 1) {
|
rpm = parseParam(process.getStdRpmParamCode(), "转速", paramValues, missingReasons);
|
rpmNote = "转速 " + plain(rpm) + " r/min";
|
} else if (mode == 3) {
|
BigDecimal percent = parseParam(process.getStdPercentParamCode(), "转速百分比", paramValues, missingReasons);
|
BigDecimal maxRpm = process.getMaxRpm();
|
if (maxRpm == null || maxRpm.signum() <= 0) {
|
missingReasons.add(StrUtil.format("工序「{}」未配置机台满转速（r/min），无法按“满速百分比×节距”计算",
|
process.getName()));
|
rpm = null;
|
} else if (percent == null) {
|
rpm = null;
|
} else {
|
rpm = maxRpm.multiply(percent).divide(HUNDRED, 4, RoundingMode.HALF_UP);
|
}
|
rpmNote = StrUtil.format("转速 {} r/min（满转速 {} × {}%）", plain(rpm), plain(maxRpm), plain(percent));
|
} else {
|
missingReasons.add(StrUtil.format("工序「{}」的标准工时计算方式[{}]无效，只能是 0/1/2/3",
|
process.getName(), mode));
|
return new SpeedResult(null, null);
|
}
|
if (rpm == null || pitch == null) {
|
return new SpeedResult(null, null);
|
}
|
BigDecimal speed = rpm.multiply(pitch).divide(THOUSAND, 4, RoundingMode.HALF_UP).multiply(factor)
|
.setScale(4, RoundingMode.HALF_UP);
|
if (speed.signum() <= 0) {
|
missingReasons.add(StrUtil.format("按转速 {} × 节距 {} ÷ 1000 × 系数 {} 算出的线速度不大于 0，请检查工艺参数",
|
plain(rpm), plain(pitch), plain(factor)));
|
return new SpeedResult(null, null);
|
}
|
String note = StrUtil.format("线速度 {} 米/分（{} × 节距 {} ÷ 1000 × 系数 {}）",
|
plain(speed), rpmNote, plain(pitch), plain(factor));
|
return new SpeedResult(speed, note);
|
}
|
|
private AuxCalcResult calculateAux(MesProTaskDO task, MesProProcessDO process,
|
List<MesProWorktimeCalcReqVO.AuxInput> auxInputs,
|
List<String> missingReasons) {
|
if (CollUtil.isEmpty(auxInputs)) {
|
return new AuxCalcResult(BigDecimal.ZERO, List.of());
|
}
|
Long workstationId = task.getWorkstationId();
|
Map<Long, MesProWorktimeAuxDO> applicableMap = new HashMap<>();
|
worktimeAuxService.getApplicableList(process.getId(), workstationId)
|
.forEach(aux -> applicableMap.put(aux.getId(), aux));
|
|
List<MesProWorktimeCalcRespVO.AuxResult> items = new ArrayList<>();
|
BigDecimal totalMinutes = BigDecimal.ZERO;
|
for (MesProWorktimeCalcReqVO.AuxInput input : auxInputs) {
|
if (input == null || input.getAuxItemId() == null) {
|
continue;
|
}
|
MesProWorktimeAuxDO aux = applicableMap.get(input.getAuxItemId());
|
if (aux == null) {
|
missingReasons.add(StrUtil.format("辅助工时项目 ID={} 未配置在当前工序「{}」或机台「{}」下，"
|
+ "已忽略该项；请刷新页面重新选择辅助项目",
|
input.getAuxItemId(), process.getName(),
|
workstationId == null ? "不限机台" : "ID=" + workstationId));
|
continue;
|
}
|
BigDecimal quantity = input.getQuantity() != null ? input.getQuantity() : BigDecimal.ZERO;
|
BigDecimal minutes;
|
if (MesProWorktimeAuxDO.MEASURE_METERS == aux.getMeasureType()) {
|
BigDecimal speed = aux.getSpeedMPerMin();
|
if (speed == null || speed.signum() <= 0) {
|
missingReasons.add(StrUtil.format("辅助项目「{}」按米折算，但未配置折算速度（米/分），已忽略该项",
|
aux.getItemName()));
|
continue;
|
}
|
minutes = quantity.divide(speed, 2, RoundingMode.HALF_UP);
|
} else {
|
BigDecimal duration = aux.getDurationMinutes() != null ? aux.getDurationMinutes() : BigDecimal.ZERO;
|
minutes = quantity.multiply(duration).setScale(2, RoundingMode.HALF_UP);
|
}
|
totalMinutes = totalMinutes.add(minutes);
|
MesProWorktimeCalcRespVO.AuxResult item = new MesProWorktimeCalcRespVO.AuxResult();
|
item.setAuxItemId(aux.getId());
|
item.setItemName(aux.getItemName());
|
item.setMeasureType(aux.getMeasureType());
|
item.setQuantity(quantity);
|
item.setMaterialFrom(input.getMaterialFrom());
|
item.setMaterialTo(input.getMaterialTo());
|
item.setMinutes(minutes);
|
item.setRemark(input.getRemark());
|
items.add(item);
|
}
|
BigDecimal auxHours = totalMinutes.divide(SIXTY, 2, RoundingMode.HALF_UP);
|
return new AuxCalcResult(auxHours, items);
|
}
|
|
/**
|
* 生产长度未填时：报工单位是“米”则直接按报工数量带入，否则返回 null 由人工填写
|
*/
|
private BigDecimal defaultProductionLength(MesProTaskDO task, BigDecimal feedbackQuantity) {
|
if (feedbackQuantity == null || feedbackQuantity.signum() <= 0 || task.getItemId() == null) {
|
return null;
|
}
|
MesMdmItemDO item = mdmItemService.getItem(task.getItemId());
|
if (item == null || item.getUnitMeasureId() == null) {
|
return null;
|
}
|
MesMdUnitMeasureDO unit = unitMeasureService.getUnitMeasure(item.getUnitMeasureId());
|
if (unit == null || unit.getName() == null) {
|
return null;
|
}
|
String unitName = unit.getName().trim();
|
if (Objects.equals(unitName, "米") || Objects.equals(unitName, "m") || Objects.equals(unitName, "M")) {
|
return feedbackQuantity;
|
}
|
return null;
|
}
|
|
/**
|
* 读取任务工艺参数记录中的参数值（编码 → 值），取第一条记录
|
*/
|
private Map<String, String> loadTaskParamValues(Long taskId) {
|
Map<String, String> values = new HashMap<>();
|
MesProWorkOrderParamRecordDO record = paramRecordMapper.selectFirstByTaskId(taskId);
|
if (record == null) {
|
return values;
|
}
|
List<MesProWorkOrderParamRecordDetailDO> details = paramRecordDetailMapper.selectListByRecordId(record.getId());
|
for (MesProWorkOrderParamRecordDetailDO detail : details) {
|
if (StrUtil.isNotBlank(detail.getParamCode()) && StrUtil.isNotBlank(detail.getParamValue())) {
|
values.putIfAbsent(detail.getParamCode(), detail.getParamValue());
|
}
|
}
|
return values;
|
}
|
|
private BigDecimal parseParam(String paramCode, String paramLabel, Map<String, String> values,
|
List<String> missingReasons) {
|
if (StrUtil.isBlank(paramCode)) {
|
missingReasons.add(StrUtil.format("工序未绑定「{}」参数编码，请在工序设置中选择{}参数", paramLabel, paramLabel));
|
return null;
|
}
|
String raw = values.get(paramCode);
|
if (StrUtil.isBlank(raw)) {
|
missingReasons.add(StrUtil.format("工艺路线参数「{}」未填写，无法计算标准工时；请先在下达的工艺参数中填写{}",
|
paramCode, paramLabel));
|
return null;
|
}
|
BigDecimal value = parseNumber(raw);
|
if (value == null) {
|
missingReasons.add(StrUtil.format("参数「{}」的值[{}]不是有效数字，无法计算标准工时；请按数值填写",
|
paramCode, raw));
|
}
|
return value;
|
}
|
|
private static BigDecimal parseNumber(String raw) {
|
if (StrUtil.isBlank(raw)) {
|
return null;
|
}
|
String normalized = StrUtil.trim(raw).replace(",", "").replace("，", "");
|
try {
|
return new BigDecimal(normalized);
|
} catch (NumberFormatException ignored) {
|
// 参数值可能带单位，例如 "1200 r/min"，取其中最前面的数值
|
java.util.regex.Matcher matcher = java.util.regex.Pattern
|
.compile("-?\\d+(?:\\.\\d+)?").matcher(normalized);
|
if (matcher.find()) {
|
try {
|
return new BigDecimal(matcher.group());
|
} catch (NumberFormatException ignoredAgain) {
|
return null;
|
}
|
}
|
return null;
|
}
|
}
|
|
private String buildNote(BigDecimal length, SpeedResult speedResult,
|
BigDecimal primaryHours, AuxCalcResult auxResult) {
|
List<String> parts = new ArrayList<>();
|
if (length != null && length.signum() > 0) {
|
parts.add(StrUtil.format("生产长度 {} 米", plain(length)));
|
}
|
parts.add(speedResult.note != null ? speedResult.note : "线速度未计算");
|
parts.add(StrUtil.format("主工时 {} 小时", plain(primaryHours)));
|
parts.add(StrUtil.format("辅助工时 {} 小时", plain(auxResult.auxHours)));
|
return String.join("；", parts);
|
}
|
|
private List<MesProWorktimeCalcReqVO.AuxInput> toAuxInputs(List<MesProFeedbackSaveReqVO.AuxValue> auxValues) {
|
if (CollUtil.isEmpty(auxValues)) {
|
return List.of();
|
}
|
List<MesProWorktimeCalcReqVO.AuxInput> inputs = new ArrayList<>();
|
for (MesProFeedbackSaveReqVO.AuxValue auxValue : auxValues) {
|
if (auxValue == null || auxValue.getAuxItemId() == null) {
|
continue;
|
}
|
MesProWorktimeCalcReqVO.AuxInput input = new MesProWorktimeCalcReqVO.AuxInput();
|
input.setAuxItemId(auxValue.getAuxItemId());
|
input.setQuantity(auxValue.getQuantity());
|
input.setMaterialFrom(auxValue.getMaterialFrom());
|
input.setMaterialTo(auxValue.getMaterialTo());
|
input.setRemark(auxValue.getRemark());
|
inputs.add(input);
|
}
|
return inputs;
|
}
|
|
private static String plain(BigDecimal value) {
|
if (value == null) {
|
return "-";
|
}
|
return value.stripTrailingZeros().toPlainString();
|
}
|
|
private record SpeedResult(BigDecimal speed, String note) {
|
}
|
|
private record AuxCalcResult(BigDecimal auxHours, List<MesProWorktimeCalcRespVO.AuxResult> items) {
|
}
|
|
}
|
