package com.ruoyi.production.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.framework.web.domain.R;
|
import com.ruoyi.production.mapper.*;
|
import com.ruoyi.production.util.TaskPlanQuantityUtil;
|
import com.ruoyi.technology.mapper.*;
|
import com.ruoyi.production.pojo.*;
|
import com.ruoyi.production.service.ProductionOrderRoutingOperationService;
|
import com.ruoyi.production.service.ProductionProductMainService;
|
import com.ruoyi.technology.pojo.*;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
@RequiredArgsConstructor
|
public class ProductionOrderRoutingOperationServiceImpl extends ServiceImpl<ProductionOrderRoutingOperationMapper, ProductionOrderRoutingOperation>
|
implements ProductionOrderRoutingOperationService {
|
|
private final ProductionOrderRoutingOperationMapper productionOrderRoutingOperationMapper;
|
private final ProductionOperationTaskMapper productionOperationTaskMapper;
|
private final ProductionProductMainMapper productionProductMainMapper;
|
private final ProductionProductMainService productionProductMainService;
|
private final TechnologyOperationParamMapper technologyOperationParamMapper;
|
private final TechnologyParamMapper technologyParamMapper;
|
private final ProductionOrderRoutingOperationParamMapper productionOrderRoutingOperationParamMapper;
|
private final ProductionOrderMapper productionOrderMapper;
|
private final ProductionOrderRoutingMapper productionOrderRoutingMapper;
|
private final ProductionOrderBomMapper productionOrderBomMapper;
|
private final ProductionBomStructureMapper productionBomStructureMapper;
|
private final TechnologyRoutingOperationMapper technologyRoutingOperationMapper;
|
|
@Override
|
public R addRouteItem(ProductionOrderRoutingOperation productionOrderRoutingOperation) {
|
// 新增工艺路线
|
int insert = productionOrderRoutingOperationMapper.insert(productionOrderRoutingOperation);
|
//工序关联的参数需要同步新增
|
List<TechnologyOperationParam> technologyOperationParams = technologyOperationParamMapper.selectList(Wrappers.<TechnologyOperationParam>lambdaQuery()
|
.eq(TechnologyOperationParam::getTechnologyOperationId, productionOrderRoutingOperation.getTechnologyOperationId()));
|
// 参数与前置条件校验
|
if (CollectionUtils.isNotEmpty(technologyOperationParams)){
|
ArrayList<ProductionOrderRoutingOperationParam> productionOrderRoutingOperationParams = new ArrayList<>();
|
// 遍历处理数据并组装结果
|
for (TechnologyOperationParam technologyOperationParam : technologyOperationParams) {
|
TechnologyParam technologyParam = technologyParamMapper.selectById(technologyOperationParam.getTechnologyParamId());
|
ProductionOrderRoutingOperationParam productionOrderRoutingOperationParam = new ProductionOrderRoutingOperationParam();
|
productionOrderRoutingOperationParam.setProductionOrderId(productionOrderRoutingOperation.getProductionOrderId());
|
productionOrderRoutingOperationParam.setProductionOrderRoutingOperationId(productionOrderRoutingOperation.getId());
|
productionOrderRoutingOperationParam.setParamCode(technologyParam.getParamCode());
|
productionOrderRoutingOperationParam.setParamName(technologyParam.getParamName());
|
productionOrderRoutingOperationParam.setParamType(technologyParam.getParamType());
|
productionOrderRoutingOperationParam.setParamFormat(technologyParam.getParamFormat());
|
productionOrderRoutingOperationParam.setUnit(technologyParam.getUnit());
|
productionOrderRoutingOperationParam.setIsRequired(technologyParam.getIsRequired());
|
productionOrderRoutingOperationParam.setRemark(technologyParam.getRemark());
|
productionOrderRoutingOperationParam.setParamId(technologyParam.getId());
|
productionOrderRoutingOperationParam.setTechnologyOperationId(productionOrderRoutingOperation.getTechnologyOperationId());
|
productionOrderRoutingOperationParams.add(productionOrderRoutingOperationParam);
|
}
|
productionOrderRoutingOperationParamMapper.insert(productionOrderRoutingOperationParams);
|
}
|
String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
|
if (insert > 0) {
|
ProductionOperationTask lastTask = productionOperationTaskMapper.selectOne(
|
Wrappers.<ProductionOperationTask>lambdaQuery()
|
.likeRight(ProductionOperationTask::getWorkOrderNo, "GD" + datePrefix)
|
.orderByDesc(ProductionOperationTask::getWorkOrderNo)
|
.last("limit 1"));
|
int sequenceNumber = 1;
|
if (lastTask != null && lastTask.getWorkOrderNo() != null) {
|
String lastNo = lastTask.getWorkOrderNo();
|
if (lastNo.startsWith("GD" + datePrefix)) {
|
String seqStr = lastNo.substring(("GD" + datePrefix).length());
|
try {
|
sequenceNumber = Integer.parseInt(seqStr) + 1;
|
} catch (NumberFormatException e) {
|
sequenceNumber = 1;
|
}
|
}
|
}
|
String workOrderNoStr = "GD" + String.format("%s%03d", datePrefix, sequenceNumber);
|
ProductionOperationTask productionOperationTask = new ProductionOperationTask();
|
productionOperationTask.setProductionOrderRoutingOperationId(productionOrderRoutingOperation.getId());
|
productionOperationTask.setProductionOrderId(productionOrderRoutingOperation.getProductionOrderId());
|
productionOperationTask.setPlanQuantity(BigDecimal.ZERO);
|
productionOperationTask.setCompleteQuantity(BigDecimal.ZERO);
|
productionOperationTask.setWorkOrderNo(workOrderNoStr);
|
productionOperationTask.setStatus(1);
|
productionOperationTaskMapper.insert(productionOperationTask);
|
}
|
return R.ok();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R updateRouteItem(ProductionOrderRoutingOperation productionOrderRoutingOperation) {
|
Long operationId = productionOrderRoutingOperation.getId();
|
|
// 更新工艺路线工序
|
productionOrderRoutingOperationMapper.updateById(productionOrderRoutingOperation);
|
|
// 重新查询完整记录（前端可能没有传递所有字段，如 productionOrderId）
|
ProductionOrderRoutingOperation updatedOperation = productionOrderRoutingOperationMapper.selectById(operationId);
|
if (updatedOperation == null) {
|
throw new ServiceException("工艺路线工序不存在");
|
}
|
|
// 查询是否存在工单
|
ProductionOperationTask productionOperationTask = productionOperationTaskMapper.selectOne(
|
new LambdaQueryWrapper<ProductionOperationTask>()
|
.eq(ProductionOperationTask::getProductionOrderRoutingOperationId, operationId)
|
.last("limit 1"));
|
|
// 根据是否需要生产进行处理
|
Boolean isProduction = updatedOperation.getIsProduction();
|
|
if (Boolean.TRUE.equals(isProduction)) {
|
// 需要生产：检查工单是否存在，不存在则生成
|
if (productionOperationTask == null) {
|
ProductionOperationTask task = new ProductionOperationTask();
|
task.setProductionOrderRoutingOperationId(updatedOperation.getId());
|
task.setProductionOrderId(updatedOperation.getProductionOrderId());
|
// 获取生产订单
|
ProductionOrder productionOrder = productionOrderMapper.selectById(updatedOperation.getProductionOrderId());
|
if (productionOrder == null) {
|
throw new ServiceException("生产订单不存在");
|
}
|
|
// 获取订单BOM
|
ProductionOrderBom orderBom = productionOrderBomMapper.selectOne(
|
Wrappers.<ProductionOrderBom>lambdaQuery()
|
.eq(ProductionOrderBom::getProductionOrderId, productionOrder.getId()));
|
|
// 确定根产品规格ID
|
Long rootProductModelId = orderBom != null && orderBom.getProductModelId() != null
|
? orderBom.getProductModelId()
|
: productionOrder.getProductModelId();
|
|
// 获取BOM结构列表
|
List<ProductionBomStructure> orderBomStructureList = orderBom == null || orderBom.getId() == null
|
? Collections.emptyList()
|
: productionBomStructureMapper.selectList(
|
Wrappers.<ProductionBomStructure>lambdaQuery()
|
.eq(ProductionBomStructure::getProductionOrderBomId, orderBom.getId())
|
.orderByAsc(ProductionBomStructure::getId));
|
|
// 构建工序需求量映射
|
Map<String, BigDecimal> operationDemandedQuantityMap =
|
TaskPlanQuantityUtil.buildOperationDemandedQuantityMap(orderBomStructureList, rootProductModelId);
|
|
// 获取工艺路线工序（用于计算计划数量）
|
TechnologyRoutingOperation sourceOperation = technologyRoutingOperationMapper.selectById(
|
updatedOperation.getTechnologyRoutingOperationId());
|
// 将原来的私有方法替换为调用工具类
|
BigDecimal planQuantity = TaskPlanQuantityUtil.resolveTaskPlanQuantity(
|
sourceOperation,
|
operationDemandedQuantityMap,
|
productionOrder,
|
rootProductModelId);
|
task.setPlanQuantity(planQuantity);
|
task.setCompleteQuantity(BigDecimal.ZERO);
|
task.setWorkOrderNo(generateNextTaskNo());
|
task.setStatus(2);
|
productionOperationTaskMapper.insert(task);
|
}
|
} else {
|
// 不需要生产：检查工单是否存在
|
if (productionOperationTask != null) {
|
validateTaskCanRemove(productionOperationTask);
|
// 没有报工，则删除工单
|
productionOperationTaskMapper.deleteById(productionOperationTask.getId());
|
}
|
}
|
|
return R.ok();
|
}
|
|
private void validateTaskCanRemove(ProductionOperationTask task) {
|
if (task == null || task.getId() == null) {
|
return;
|
}
|
if (defaultDecimal(task.getCompleteQuantity()).compareTo(BigDecimal.ZERO) > 0) {
|
throw new ServiceException("工序已产生报工记录，无法根据 BOM 变更删除对应工序快照");
|
}
|
long reportCount = productionProductMainMapper.selectCount(
|
Wrappers.<ProductionProductMain>lambdaQuery()
|
.eq(ProductionProductMain::getProductionOperationTaskId, task.getId()));
|
if (reportCount > 0) {
|
throw new ServiceException("工序已产生报工记录，无法根据 BOM 变更删除对应工单");
|
}
|
}
|
|
private BigDecimal defaultDecimal(BigDecimal value) {
|
return value == null ? BigDecimal.ZERO : value;
|
}
|
|
@Override
|
public R deleteRouteItem(Long id) {
|
// 删除工艺路线
|
try {
|
// 查询并准备业务数据
|
ProductionOperationTask productionOperationTask = productionOperationTaskMapper.selectOne(
|
new LambdaQueryWrapper<ProductionOperationTask>()
|
.eq(ProductionOperationTask::getProductionOrderRoutingOperationId, id)
|
.last("limit 1"));
|
// 参数与前置条件校验
|
if (productionOperationTask == null) {
|
throw new RuntimeException("删除失败：未找到关联的生产工单");
|
}
|
if (productionOperationTask.getCompleteQuantity() != null
|
&& BigDecimal.ZERO.compareTo(productionOperationTask.getCompleteQuantity()) < 0) {
|
throw new RuntimeException("删除失败：该工单已开始生产，请先删除生产报工");
|
}
|
List<ProductionProductMain> productionProductMains = productionProductMainMapper.selectList(
|
new LambdaQueryWrapper<ProductionProductMain>()
|
.eq(ProductionProductMain::getProductionOperationTaskId, productionOperationTask.getId()));
|
// 遍历处理数据并组装结果
|
for (ProductionProductMain main : productionProductMains) {
|
productionProductMainService.removeProductMain(main.getId());
|
}
|
Long productionOrderId = productionOperationTask.getProductionOrderId();
|
Long routingId = null;
|
ProductionOrderRoutingOperation deleteItem = productionOrderRoutingOperationMapper.selectById(id);
|
if (deleteItem != null) {
|
routingId = deleteItem.getOrderRoutingId();
|
}
|
productionOperationTaskMapper.delete(new LambdaQueryWrapper<ProductionOperationTask>()
|
.eq(ProductionOperationTask::getProductionOrderRoutingOperationId, id));
|
productionOrderRoutingOperationMapper.deleteById(id);
|
if (routingId != null) {
|
List<ProductionOrderRoutingOperation> operationList = productionOrderRoutingOperationMapper.selectList(
|
Wrappers.<ProductionOrderRoutingOperation>lambdaQuery()
|
.eq(ProductionOrderRoutingOperation::getOrderRoutingId, routingId)
|
.eq(ProductionOrderRoutingOperation::getProductionOrderId, productionOrderId)
|
.orderByAsc(ProductionOrderRoutingOperation::getDragSort));
|
for (int i = 0; i < operationList.size(); i++) {
|
ProductionOrderRoutingOperation item = operationList.get(i);
|
if (!Integer.valueOf(i + 1).equals(item.getDragSort())) {
|
item.setDragSort(i + 1);
|
// 持久化或输出处理结果
|
productionOrderRoutingOperationMapper.updateById(item);
|
}
|
}
|
}
|
return R.ok();
|
} catch (Exception e) {
|
throw new RuntimeException("删除生产工艺路线失败：" + e.getMessage());
|
}
|
}
|
|
@Override
|
public int sortRouteItem(ProductionOrderRoutingOperation productionOrderRoutingOperation) {
|
// 排序工艺路线
|
ProductionOrderRoutingOperation oldItem = productionOrderRoutingOperationMapper.selectById(productionOrderRoutingOperation.getId());
|
List<ProductionOrderRoutingOperation> operationList = productionOrderRoutingOperationMapper.selectList(
|
Wrappers.<ProductionOrderRoutingOperation>lambdaQuery()
|
.eq(ProductionOrderRoutingOperation::getOrderRoutingId, oldItem.getOrderRoutingId())
|
.orderByAsc(ProductionOrderRoutingOperation::getDragSort));
|
Integer targetPosition = productionOrderRoutingOperation.getDragSort();
|
if (targetPosition != null && targetPosition >= 1) {
|
operationList.removeIf(item -> item.getId().equals(oldItem.getId()));
|
operationList.add(targetPosition - 1, oldItem);
|
for (int i = 0; i < operationList.size(); i++) {
|
ProductionOrderRoutingOperation item = operationList.get(i);
|
int dragSort = i + 1;
|
if (!Integer.valueOf(dragSort).equals(item.getDragSort())) {
|
item.setDragSort(dragSort);
|
productionOrderRoutingOperationMapper.updateById(item);
|
}
|
}
|
return 1;
|
}
|
return 0;
|
}
|
|
private String generateNextTaskNo() {
|
// 生成下一个生产工单号
|
String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
|
String prefix = "GD" + datePrefix;
|
ProductionOperationTask lastTask = productionOperationTaskMapper.selectOne(
|
Wrappers.<ProductionOperationTask>lambdaQuery()
|
.likeRight(ProductionOperationTask::getWorkOrderNo, prefix)
|
.orderByDesc(ProductionOperationTask::getWorkOrderNo)
|
.last("limit 1"));
|
int sequence = 1;
|
if (lastTask != null && lastTask.getWorkOrderNo() != null && lastTask.getWorkOrderNo().startsWith(prefix)) {
|
try {
|
sequence = Integer.parseInt(lastTask.getWorkOrderNo().substring(prefix.length())) + 1;
|
} catch (NumberFormatException ignored) {
|
sequence = 1;
|
}
|
}
|
return prefix + String.format("%03d", sequence);
|
}
|
}
|
