package cn.iocoder.yudao.module.mes.controller.admin.pro.task;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.collection.ListUtil;
|
import cn.hutool.core.util.ObjUtil;
|
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
|
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
|
import cn.iocoder.yudao.framework.common.pojo.PageParam;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.GanttDataRespVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.MesProTaskPageReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.MesProTaskRespVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.MesProTaskSaveReqVO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.workorder.vo.MesProWorkOrderPageReqVO;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO;
|
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.workorder.MesProWorkOrderDO;
|
import cn.iocoder.yudao.module.mes.enums.MesBizTypeConstants;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.md.unitmeasure.MesMdUnitMeasureService;
|
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskService;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderService;
|
import io.swagger.v3.oas.annotations.Operation;
|
import io.swagger.v3.oas.annotations.Parameter;
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
import jakarta.annotation.Resource;
|
import jakarta.servlet.http.HttpServletResponse;
|
import jakarta.validation.Valid;
|
import org.springframework.security.access.prepost.PreAuthorize;
|
import org.springframework.validation.annotation.Validated;
|
import org.springframework.web.bind.annotation.*;
|
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteProcessDO;
|
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteProcessService;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.feedback.MesProFeedbackDO;
|
import cn.iocoder.yudao.module.mes.enums.pro.MesProFeedbackStatusEnum;
|
import cn.iocoder.yudao.module.mes.service.pro.feedback.MesProFeedbackService;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.*;
|
|
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
|
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
|
import static cn.iocoder.yudao.framework.common.util.collection.MapUtils.findAndThen;
|
|
@Tag(name = "管理后台 - MES 生产任务")
|
@RestController
|
@RequestMapping("/mes/pro/task")
|
@Validated
|
public class MesProTaskController {
|
|
@Resource
|
private MesProTaskService taskService;
|
@Resource
|
private MesProWorkOrderService workOrderService;
|
@Resource
|
private MesMdWorkstationService workstationService;
|
@Resource
|
private MesProProcessService processService;
|
@Resource
|
private MesMdItemService itemService;
|
@Resource
|
private CrmCustomerApi customerApi;
|
@Resource
|
private MesMdUnitMeasureService unitMeasureService;
|
@Resource
|
private MesProRouteProcessService routeProcessService;
|
@Resource
|
private MesProFeedbackService feedbackService;
|
|
@PostMapping("/create")
|
@Operation(summary = "创建生产任务")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:create')")
|
public CommonResult<Long> createTask(@Valid @RequestBody MesProTaskSaveReqVO createReqVO) {
|
return success(taskService.createTask(createReqVO));
|
}
|
|
@PutMapping("/update")
|
@Operation(summary = "更新生产任务")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:update')")
|
public CommonResult<Boolean> updateTask(@Valid @RequestBody MesProTaskSaveReqVO updateReqVO) {
|
taskService.updateTask(updateReqVO);
|
return success(true);
|
}
|
|
@DeleteMapping("/delete")
|
@Operation(summary = "删除生产任务")
|
@Parameter(name = "id", description = "编号", required = true)
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:delete')")
|
public CommonResult<Boolean> deleteTask(@RequestParam("id") Long id) {
|
taskService.deleteTask(id);
|
return success(true);
|
}
|
|
@GetMapping("/get")
|
@Operation(summary = "获得生产任务")
|
@Parameter(name = "id", description = "编号", required = true, example = "1024")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:query')")
|
public CommonResult<MesProTaskRespVO> getTask(@RequestParam("id") Long id) {
|
MesProTaskDO task = taskService.getTask(id);
|
if (task == null) {
|
return success(null);
|
}
|
return success(buildTaskRespVOList(ListUtil.of(task)).get(0));
|
}
|
|
@GetMapping("/page")
|
@Operation(summary = "获得生产任务分页")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:query')")
|
public CommonResult<PageResult<MesProTaskRespVO>> getTaskPage(@Valid MesProTaskPageReqVO pageReqVO) {
|
PageResult<MesProTaskDO> pageResult = taskService.getTaskPage(pageReqVO);
|
return success(new PageResult<>(buildTaskRespVOList(pageResult.getList()), pageResult.getTotal()));
|
}
|
|
@GetMapping("/pending-feedback-page")
|
@Operation(summary = "获得待报工台账分页", description = "已排产且仍有待报工数量的任务（状态=进行中）")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:query')")
|
public CommonResult<PageResult<MesProTaskRespVO>> getPendingFeedbackPage(@Valid MesProTaskPageReqVO pageReqVO) {
|
PageResult<MesProTaskDO> pageResult = taskService.getPendingFeedbackPage(pageReqVO);
|
return success(new PageResult<>(buildTaskRespVOList(pageResult.getList()), pageResult.getTotal()));
|
}
|
|
@GetMapping("/gantt-list")
|
@Operation(summary = "获得甘特图任务列表", description = "后端组装工单=project + 任务=task 列表")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:query')")
|
public CommonResult<List<GanttDataRespVO>> listGanttTaskList(@Valid MesProWorkOrderPageReqVO reqVO) {
|
// 1.1 查询匹配的工单（不分页）
|
reqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
|
List<MesProWorkOrderDO> workOrders = workOrderService.getWorkOrderPage(reqVO).getList();
|
if (CollUtil.isEmpty(workOrders)) {
|
return success(Collections.emptyList());
|
}
|
// 1.2 批量查询所有工单下的任务，按 workOrderId 分组
|
List<MesProTaskDO> allTasks = taskService.getTaskListByWorkOrderIds(
|
convertSet(workOrders, MesProWorkOrderDO::getId));
|
Map<Long, List<MesProTaskDO>> taskMap = convertMultiMap(allTasks, MesProTaskDO::getWorkOrderId);
|
|
// 2.1 查询关联数据
|
java.util.Set<Long> allItemIds = new java.util.HashSet<>();
|
allItemIds.addAll(convertSet(workOrders, MesProWorkOrderDO::getProductId));
|
allItemIds.addAll(convertSet(allTasks, MesProTaskDO::getItemId));
|
Map<Long, MesMdItemDO> itemMap = itemService.getItemMap(allItemIds);
|
Map<Long, MesMdUnitMeasureDO> unitMap = unitMeasureService.getUnitMeasureMap(
|
convertSet(itemMap.values(), MesMdItemDO::getUnitMeasureId));
|
Map<Long, MesMdWorkstationDO> workstationMap = workstationService.getWorkstationMap(
|
convertSet(allTasks, MesProTaskDO::getWorkstationId));
|
Map<Long, MesProProcessDO> processMap = processService.getProcessMap(
|
convertSet(allTasks, MesProTaskDO::getProcessId));
|
// 2.2 组装甘特图数据
|
List<GanttDataRespVO> ganttData = new java.util.ArrayList<>();
|
for (MesProWorkOrderDO workOrder : workOrders) {
|
// 2.2.a 工单 -> project 行
|
MesMdItemDO item = itemMap.get(workOrder.getProductId());
|
String productName = item != null ? item.getName() : "";
|
GanttDataRespVO woData = new GanttDataRespVO()
|
.setId(MesBizTypeConstants.PRO_WORKORDER + "_" + workOrder.getId())
|
.setOriginalId(workOrder.getId())
|
.setType(MesBizTypeConstants.PRO_WORKORDER)
|
.setText(buildGanttText(item, workOrder.getQuantity(), unitMap))
|
.setProduct(productName)
|
.setQuantity(workOrder.getQuantity())
|
.setDuration(0L)
|
.setProgress(calcProgress(workOrder.getQuantityProduced(), workOrder.getQuantity()));
|
if (ObjUtil.notEqual(workOrder.getParentId(), MesProWorkOrderDO.PARENT_ID_NULL)) {
|
woData.setParent(MesBizTypeConstants.PRO_WORKORDER + "_" + workOrder.getParentId());
|
}
|
ganttData.add(woData);
|
|
// 2.2.b 任务 -> task 行
|
List<MesProTaskDO> woTasks = taskMap.getOrDefault(workOrder.getId(), Collections.emptyList());
|
for (MesProTaskDO task : woTasks) {
|
MesMdWorkstationDO ws = workstationMap.get(task.getWorkstationId());
|
MesProProcessDO proc = processMap.get(task.getProcessId());
|
MesMdItemDO taskItem = itemMap.get(task.getItemId());
|
GanttDataRespVO tData = new GanttDataRespVO()
|
.setId(MesBizTypeConstants.PRO_TASK + "_" + task.getId())
|
.setOriginalId(task.getId())
|
.setType(MesBizTypeConstants.PRO_TASK)
|
.setText(buildGanttText(taskItem, task.getQuantity(), unitMap))
|
.setParent(MesBizTypeConstants.PRO_WORKORDER + "_" + workOrder.getId())
|
.setWorkstation(ws != null ? ws.getName() : null)
|
.setProcess(proc != null ? proc.getName() : null)
|
.setColor(task.getColorCode())
|
.setQuantity(task.getQuantity())
|
.setStartDate(task.getStartTime()).setEndDate(task.getEndTime())
|
.setDuration(task.getDuration() != null ? task.getDuration().longValue() : null)
|
.setProgress(calcProgress(task.getProducedQuantity(), task.getQuantity()));
|
ganttData.add(tData);
|
}
|
}
|
return success(ganttData);
|
}
|
|
@GetMapping("/export-excel")
|
@Operation(summary = "导出生产任务 Excel")
|
@PreAuthorize("@ss.hasPermission('mes:pro-task:export')")
|
@ApiAccessLog(operateType = EXPORT)
|
public void exportTaskExcel(@Valid MesProTaskPageReqVO pageReqVO,
|
HttpServletResponse response) throws IOException {
|
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
|
List<MesProTaskDO> list = taskService.getTaskPage(pageReqVO).getList();
|
List<MesProTaskRespVO> voList = buildTaskRespVOList(list);
|
ExcelUtils.write(response, "生产任务.xls", "数据", MesProTaskRespVO.class, voList);
|
}
|
|
// ==================== 拼接 VO ====================
|
|
private List<MesProTaskRespVO> buildTaskRespVOList(List<MesProTaskDO> list) {
|
if (CollUtil.isEmpty(list)) {
|
return Collections.emptyList();
|
}
|
// 批量查询关联数据
|
Map<Long, MesProWorkOrderDO> workOrderMap = workOrderService.getWorkOrderMap(
|
convertSet(list, MesProTaskDO::getWorkOrderId));
|
Map<Long, MesMdWorkstationDO> workstationMap = workstationService.getWorkstationMap(
|
convertSet(list, MesProTaskDO::getWorkstationId));
|
Map<Long, MesProProcessDO> processMap = processService.getProcessMap(
|
new ArrayList<>(convertSet(list, MesProTaskDO::getProcessId)));
|
Map<Long, MesMdItemDO> itemMap = itemService.getItemMap(
|
convertSet(list, MesProTaskDO::getItemId));
|
Map<Long, MesMdUnitMeasureDO> unitMeasureMap = unitMeasureService.getUnitMeasureMap(
|
convertSet(itemMap.values(), MesMdItemDO::getUnitMeasureId));
|
Map<Long, CrmCustomerRespDTO> customerMap = customerApi.getCustomerMap(
|
convertSet(list, MesProTaskDO::getClientId));
|
// 工序的 checkFlag：批量查询后构建 routeId -> processId -> checkFlag 的双层 Map
|
Set<Long> routeIds = convertSet(list, MesProTaskDO::getRouteId);
|
Map<Long, Map<Long, Boolean>> routeProcessCheckFlagMap = new HashMap<>();
|
if (CollUtil.isNotEmpty(routeIds)) {
|
List<MesProRouteProcessDO> allRouteProcesses = routeProcessService.getRouteProcessListByRouteIds(routeIds);
|
for (MesProRouteProcessDO rp : allRouteProcesses) {
|
routeProcessCheckFlagMap
|
.computeIfAbsent(rp.getRouteId(), k -> new HashMap<>())
|
.put(rp.getProcessId(), Boolean.TRUE.equals(rp.getCheckFlag()));
|
}
|
}
|
// 报工在途量：按任务聚合 feedbackQuantity（草稿/审批中/待检验 = 在途；已完成 = 已审批）
|
List<MesProFeedbackDO> taskFeedbacks = feedbackService.getFeedbackListByTaskIds(
|
convertSet(list, MesProTaskDO::getId));
|
Map<Long, BigDecimal> inTransitMap = new HashMap<>();
|
for (MesProFeedbackDO fb : taskFeedbacks) {
|
BigDecimal fbQty = fb.getFeedbackQuantity() == null ? BigDecimal.ZERO : fb.getFeedbackQuantity();
|
if (!ObjUtil.equal(fb.getStatus(), MesProFeedbackStatusEnum.FINISHED.getStatus())) {
|
inTransitMap.merge(fb.getTaskId(), fbQty, BigDecimal::add);
|
}
|
}
|
// 拼接 VO
|
return convertList(list, task -> {
|
MesProTaskRespVO vo = BeanUtils.toBean(task, MesProTaskRespVO.class);
|
// 待报工数量 = 排产数量 - 已生产数量；报工完成率 = 已生产 / 排产 × 100
|
BigDecimal quantity = task.getQuantity() == null ? BigDecimal.ZERO : task.getQuantity();
|
BigDecimal produced = task.getProducedQuantity() == null ? BigDecimal.ZERO : task.getProducedQuantity();
|
vo.setPendingQuantity(quantity.subtract(produced));
|
vo.setFeedbackRate(quantity.compareTo(BigDecimal.ZERO) == 0 ? BigDecimal.ZERO
|
: produced.multiply(new BigDecimal("100")).divide(quantity, 2, RoundingMode.HALF_UP));
|
// 在途报工量（草稿/审批中/待检验）+ 可报工数量 = 排产 - 已生产 - 在途
|
BigDecimal inTransit = inTransitMap.getOrDefault(task.getId(), BigDecimal.ZERO);
|
vo.setInTransitQuantity(inTransit);
|
vo.setReportableQuantity(quantity.subtract(produced).subtract(inTransit).max(BigDecimal.ZERO));
|
findAndThen(workOrderMap, task.getWorkOrderId(), wo ->
|
vo.setWorkOrderCode(wo.getCode()).setWorkOrderName(wo.getName()).setRequestDate(wo.getRequestDate()));
|
findAndThen(workstationMap, task.getWorkstationId(), ws ->
|
vo.setWorkstationCode(ws.getCode()).setWorkstationName(ws.getName()));
|
findAndThen(processMap, task.getProcessId(), p ->
|
vo.setProcessName(p.getName()));
|
findAndThen(itemMap, task.getItemId(), item -> {
|
vo.setItemCode(item.getCode()).setItemName(item.getName()).setItemSpecification(item.getSpecification());
|
findAndThen(unitMeasureMap, item.getUnitMeasureId(), unit ->
|
vo.setUnitMeasureName(unit.getName()));
|
});
|
findAndThen(customerMap, task.getClientId(), customer ->
|
vo.setClientName(customer.getName()));
|
findAndThen(routeProcessCheckFlagMap, task.getRouteId(), processCheckMap ->
|
findAndThen(processCheckMap, task.getProcessId(), vo::setCheckFlag));
|
return vo;
|
});
|
}
|
|
/**
|
* 拼接甘特图显示文本，格式："[产品名][数量][单位]"
|
*/
|
private String buildGanttText(MesMdItemDO item, BigDecimal quantity,
|
Map<Long, MesMdUnitMeasureDO> unitMap) {
|
String itemName = item != null ? item.getName() : "";
|
String quantityStr = quantity != null ? quantity.stripTrailingZeros().toPlainString() : "";
|
String unitName = "";
|
if (item != null && item.getUnitMeasureId() != null) {
|
MesMdUnitMeasureDO unit = unitMap.get(item.getUnitMeasureId());
|
unitName = unit != null ? unit.getName() : "";
|
}
|
return itemName + quantityStr + unitName;
|
}
|
|
/**
|
* 计算进度 = 已生产 / 总量，返回 0~1
|
*/
|
private float calcProgress(BigDecimal produced, BigDecimal total) {
|
if (total == null || total.compareTo(BigDecimal.ZERO) <= 0 || produced == null) {
|
return 0f;
|
}
|
return produced.divide(total, RoundingMode.HALF_UP).floatValue();
|
}
|
|
}
|
