package com.ruoyi.production.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.appendix.service.AppendixService;
|
import com.ruoyi.procurementrecord.utils.StockUtils;
|
import com.ruoyi.production.dto.ProductOrderDto;
|
import com.ruoyi.production.dto.ProductStructureDto;
|
import com.ruoyi.production.enums.ProductOrderStatusEnum;
|
import com.ruoyi.production.mapper.*;
|
import com.ruoyi.production.pojo.*;
|
import com.ruoyi.production.service.ProductOrderService;
|
import com.ruoyi.productionPlan.mapper.ProductOrderPlanMapper;
|
import com.ruoyi.productionPlan.mapper.ProductionPlanMapper;
|
import com.ruoyi.productionPlan.pojo.ProductOrderPlan;
|
import com.ruoyi.productionPlan.pojo.ProductionPlan;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
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.List;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class ProductOrderServiceImpl extends ServiceImpl<ProductOrderMapper, ProductOrder> implements ProductOrderService {
|
|
@Autowired
|
private ProductOrderMapper productOrderMapper;
|
|
@Autowired
|
private ProcessRouteMapper processRouteMapper;
|
|
@Autowired
|
private ProductProcessRouteMapper productProcessRouteMapper;
|
|
@Autowired
|
private ProcessRouteItemMapper processRouteItemMapper;
|
|
@Autowired
|
private ProductProcessRouteItemMapper productProcessRouteItemMapper;
|
|
@Autowired
|
private ProductWorkOrderMapper productWorkOrderMapper;
|
|
@Autowired
|
private ProductionProductMainMapper productionProductMainMapper;
|
|
@Autowired
|
private ProductOrderPlanMapper productOrderPlanMapper;
|
|
@Autowired
|
private ProductionPlanMapper productionPlanMapper;
|
|
@Autowired
|
private ProductionProductOutputMapper productionProductOutputMapper;
|
|
@Autowired
|
private ProductionProductInputMapper productionProductInputMapper;
|
|
@Autowired
|
private QualityInspectMapper qualityInspectMapper;
|
|
@Autowired
|
private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;
|
|
@Autowired
|
private StockUtils stockUtils;
|
|
@Autowired
|
private AppendixService appendixService;
|
|
@Override
|
public IPage<ProductOrderDto> pageProductOrder(Page<ProductOrder> page, ProductOrderDto productOrder) {
|
return productOrderMapper.pageProductOrder(page, productOrder);
|
}
|
|
@Override
|
public int bindingRoute(ProductOrder productOrder) {
|
//新增生产订单下的工艺路线主表
|
ProcessRoute processRoute = processRouteMapper.selectById(productOrder.getRouteId());
|
ProductProcessRoute productProcessRoute = new ProductProcessRoute();
|
productProcessRoute.setProductModelId(processRoute.getProductModelId());
|
productProcessRoute.setProcessRouteCode(processRoute.getProcessRouteCode());
|
productProcessRoute.setProductOrderId(productOrder.getId());
|
productProcessRoute.setBomId(processRoute.getBomId());
|
productProcessRouteMapper.insert(productProcessRoute);
|
//新增生产订单下的工艺路线子表
|
List<ProcessRouteItem> processRouteItems = processRouteItemMapper.selectList(new QueryWrapper<ProcessRouteItem>().lambda().eq(ProcessRouteItem::getRouteId, processRoute.getId()));
|
// 生成当前日期的前缀：年月日
|
String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
|
for (ProcessRouteItem processRouteItem : processRouteItems) {
|
ProductProcessRouteItem productProcessRouteItem = new ProductProcessRouteItem();
|
productProcessRouteItem.setProductModelId(processRouteItem.getProductModelId());
|
productProcessRouteItem.setProcessId(processRouteItem.getProcessId());
|
productProcessRouteItem.setProductOrderId(productOrder.getId());
|
productProcessRouteItem.setProductRouteId(productProcessRoute.getId());
|
productProcessRouteItem.setDragSort(processRouteItem.getDragSort());
|
int insert = productProcessRouteItemMapper.insert(productProcessRouteItem);
|
if (insert > 0) {
|
// 查询今日已存在的最大工单号
|
ProductWorkOrder lastWorkOrder = productWorkOrderMapper.selectMax(datePrefix);
|
int sequenceNumber = 1; // 默认序号
|
if (lastWorkOrder != null && lastWorkOrder.getWorkOrderNo() != null) {
|
String lastNo = lastWorkOrder.getWorkOrderNo().toString();
|
if (lastNo.startsWith(datePrefix)) {
|
String seqStr = lastNo.substring(datePrefix.length());
|
try {
|
sequenceNumber = Integer.parseInt(seqStr) + 1;
|
} catch (NumberFormatException e) {
|
sequenceNumber = 1;
|
}
|
}
|
}
|
// 生成完整的工单号
|
String workOrderNoStr = "GD" + String.format("%s%03d", datePrefix, sequenceNumber);
|
ProductWorkOrder productWorkOrder = new ProductWorkOrder();
|
productWorkOrder.setProductProcessRouteItemId(productProcessRouteItem.getId());
|
productWorkOrder.setProductOrderId(productOrder.getId());
|
ProductOrder order = productOrderMapper.selectById(productOrder.getId());
|
productWorkOrder.setPlanQuantity(order.getQuantity());
|
productWorkOrder.setWorkOrderNo(workOrderNoStr);
|
productWorkOrder.setStatus(1);
|
productWorkOrderMapper.insert(productWorkOrder);
|
}
|
}
|
return productOrderMapper.updateById(productOrder);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean revoke(ProductOrder productOrder) {
|
// todo 判断是否产生报工信息
|
|
// 查询合并的生产计划
|
List<ProductOrderPlan> productOrderPlans = productOrderPlanMapper.selectList(Wrappers.<ProductOrderPlan>lambdaQuery().in(ProductOrderPlan::getProductOrderId, productOrder.getId()));
|
if (productOrderPlans.isEmpty()) {
|
throw new RuntimeException("合并的生产计划不存在");
|
}
|
for (ProductOrderPlan productOrderPlan : productOrderPlans) {
|
ProductionPlan productionPlan = productionPlanMapper.selectById(productOrderPlan.getProductionPlanId());
|
productionPlan.setAssignedQuantity(productionPlan.getAssignedQuantity().subtract(productOrderPlan.getAssignedQuantity()));
|
productionPlanMapper.updateById(productionPlan);
|
}
|
// 删除关联关系
|
productOrderPlanMapper.delete(Wrappers.<ProductOrderPlan>lambdaQuery().in(ProductOrderPlan::getProductOrderId, productOrder.getId()));
|
// 删除订单
|
productOrderMapper.deleteById(productOrder.getId());
|
// todo 删除订单下的工艺路线子表
|
return null;
|
}
|
|
@Override
|
public List<ProcessRoute> listProcessRoute(Long productModelId) {
|
return productOrderMapper.listProcessRoute(productModelId);
|
}
|
|
@Override
|
public List<ProductStructureDto> listProcessBom(Long orderId) {
|
return productOrderMapper.listProcessBom(orderId);
|
}
|
|
@Override
|
public Boolean addProductOrder(ProductOrder productOrder) {
|
String string = generateNextOrderNo(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));
|
productOrder.setNpsNo(string);
|
productOrder.setCompleteQuantity(BigDecimal.ZERO);
|
this.save(productOrder);
|
if (ObjectUtils.isNotEmpty(productOrder.getRouteId())) {
|
this.bindingRoute(productOrder);
|
}
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean delete(Long[] ids) {
|
List<ProductOrder> orders = productOrderMapper.selectList(Wrappers.<ProductOrder>lambdaQuery().in(ProductOrder::getId, ids));
|
|
if (orders.isEmpty()) {
|
throw new RuntimeException("生产订单不存在");
|
}
|
for (ProductOrder order : orders) {
|
if (!ProductOrderStatusEnum.canDelete(order.getStatus())) {
|
throw new RuntimeException("只有【待开始、已取消】状态的订单才可以删除");
|
}
|
}
|
|
// 是否已生产
|
List<ProductWorkOrder> productWorkOrders = productWorkOrderMapper.selectList(Wrappers.<ProductWorkOrder>lambdaQuery().in(ProductWorkOrder::getProductOrderId, ids));
|
|
if (!productWorkOrders.isEmpty()) {
|
List<Long> workOrderIds = productWorkOrders.stream()
|
.map(ProductWorkOrder::getId)
|
.collect(Collectors.toList());
|
|
List<ProductionProductMain> productionProductMains = productionProductMainMapper.selectList(Wrappers.<ProductionProductMain>lambdaQuery().in(ProductionProductMain::getWorkOrderId, workOrderIds));
|
if (!productionProductMains.isEmpty()) {
|
throw new RuntimeException("生产订单已经开始生产,不能删除");
|
}
|
|
// 删除工单
|
productWorkOrderMapper.delete(Wrappers.<ProductWorkOrder>lambdaQuery().in(ProductWorkOrder::getProductOrderId, ids));
|
}
|
|
// 回退生产计划
|
List<ProductOrderPlan> productOrderPlans = productOrderPlanMapper.selectList(Wrappers.<ProductOrderPlan>lambdaQuery().in(ProductOrderPlan::getProductOrderId, ids));
|
|
for (ProductOrderPlan productOrderPlan : productOrderPlans) {
|
ProductionPlan productionPlan = productionPlanMapper.selectById(productOrderPlan.getProductionPlanId());
|
|
if (productionPlan != null) {
|
// 回退数量
|
BigDecimal newAssigned = productionPlan.getAssignedQuantity()
|
.subtract(productOrderPlan.getAssignedQuantity());
|
|
if (newAssigned.compareTo(BigDecimal.ZERO) < 0) {
|
newAssigned = BigDecimal.ZERO;
|
}
|
productionPlan.setAssignedQuantity(newAssigned);
|
BigDecimal volume = productionPlan.getVolume() == null ? BigDecimal.ZERO : productionPlan.getVolume();
|
|
int status;
|
if (newAssigned.compareTo(BigDecimal.ZERO) == 0) {
|
status = 0; // 未下发
|
} else if (newAssigned.compareTo(volume) < 0) {
|
status = 1; // 部分下发
|
} else {
|
status = 2; // 已下发
|
}
|
productionPlan.setStatus(status);
|
|
productionPlanMapper.updateById(productionPlan);
|
}
|
}
|
|
// 删除中间表
|
productOrderPlanMapper.delete(Wrappers.<ProductOrderPlan>lambdaQuery().in(ProductOrderPlan::getProductOrderId, ids));
|
|
// 删除附表的工艺路线与BOM
|
for (Long id : ids) {
|
ProductOrder productOrder = baseMapper.selectById(id);
|
appendixService.deleteData(productOrder.getRouteId());
|
}
|
|
// productProcessRouteItemMapper.delete(new LambdaQueryWrapper<ProductProcessRouteItem>().in(ProductProcessRouteItem::getProductOrderId, ids));
|
// productProcessRouteMapper.delete(new LambdaQueryWrapper<ProductProcessRoute>().in(ProductProcessRoute::getProductOrderId, ids));
|
|
// 删除订单
|
productOrderMapper.delete(new LambdaQueryWrapper<ProductOrder>().in(ProductOrder::getId, ids));
|
|
return true;
|
}
|
|
//获取当前生产订单号
|
public String getMaxOrderNoByDate(String datePrefix) {
|
QueryWrapper<ProductOrder> queryWrapper = new QueryWrapper<>();
|
// 匹配以 SC + 日期开头的订单号
|
queryWrapper.likeRight("nps_no", "SC" + datePrefix);
|
// 按订单号倒序排列
|
queryWrapper.orderByDesc("nps_no");
|
queryWrapper.last("LIMIT 1");
|
|
ProductOrder latestOrder = this.getOne(queryWrapper);
|
return latestOrder != null ? latestOrder.getNpsNo() : null;
|
}
|
|
public String generateNextOrderNo(String datePrefix) {
|
String maxOrderNo = getMaxOrderNoByDate(datePrefix);
|
int sequence = 1; // 默认起始序号
|
if (maxOrderNo != null && !maxOrderNo.isEmpty()) {
|
// 提取流水号部分（假设格式为 SC + 日期 + 流水号）
|
String sequenceStr = maxOrderNo.substring(("SC" + datePrefix).length());
|
try {
|
sequence = Integer.parseInt(sequenceStr) + 1;
|
} catch (NumberFormatException e) {
|
// 异常情况下重置为1
|
sequence = 1;
|
}
|
}
|
// 生成新订单号
|
return "SC" + datePrefix + String.format("%04d", sequence);
|
}
|
|
|
}
|
