产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
buhuazhen
2026-04-24 0ca7d78f0e8e8a6984314803aba21ab1d25472b3 
 src/main/java/com/ruoyi/production/service/impl/ProductOrderServiceImpl.java


@@ -1,22 +1,238 @@


package com.ruoyi.production.service.impl;




import cn.hutool.core.collection.CollUtil;


import cn.hutool.core.lang.Assert;


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.procurementrecord.utils.StockUtils;


import com.ruoyi.production.dto.ProductOrderDto;


import com.ruoyi.production.mapper.ProductOrderMapper;


import com.ruoyi.production.pojo.ProductOrder;


import com.ruoyi.production.dto.ProductStructureDto;


import com.ruoyi.production.mapper.*;


import com.ruoyi.production.pojo.*;


import com.ruoyi.production.service.ProductOrderService;


import com.ruoyi.production.service.ProductProcessService;


import com.ruoyi.production.service.ProductWorkOrderService;


import com.ruoyi.production.service.ProductionPrintOrderService;


import com.ruoyi.quality.mapper.QualityInspectMapper;


import lombok.RequiredArgsConstructor;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.context.annotation.Lazy;


import org.springframework.stereotype.Service;




import java.math.BigDecimal;


import java.time.LocalDate;


import java.time.LocalDateTime;


import java.time.format.DateTimeFormatter;


import java.util.HashMap;


import java.util.List;


import java.util.Map;


import java.util.function.Function;


import java.util.stream.Collectors;




@Service


@RequiredArgsConstructor


public class ProductOrderServiceImpl extends ServiceImpl<ProductOrderMapper, ProductOrder> implements ProductOrderService {




    private final ProductWorkOrderService productWorkOrderService;


    private final ProductProcessService productProcessService;




    @Autowired


    @Lazy


    private ProductionPrintOrderService  productionPrintOrderService;


    @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 ProductionProductOutputMapper productionProductOutputMapper;


    @Autowired


    private ProductionProductInputMapper productionProductInputMapper;


    @Autowired


    private QualityInspectMapper qualityInspectMapper;


    @Autowired


    private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;


    @Autowired


    private StockUtils stockUtils;




    @Override


    public IPage<ProductOrderDto> pageProductOrder(Page page, ProductOrderDto productOrder) {


        return productOrderMapper.pageProductOrder(page, productOrder);


        IPage<ProductOrderDto> productOrderDtoIPage = productOrderMapper.pageProductOrder(page, productOrder);


        // 填充印刷单信息


        List<ProductOrderDto> records = productOrderDtoIPage.getRecords();


        if (CollUtil.isNotEmpty(records)) {


            List<Long> orderIds = records.stream().map(ProductOrderDto::getId).collect(Collectors.toList());


            Map<Long, ProductionPrintOrder> collect = productionPrintOrderService.getListByOrders(orderIds).stream().collect(Collectors.toMap(ProductionPrintOrder::getProductOrderId, Function.identity()));


            records.forEach(record -> {


                ProductionPrintOrder productionPrintOrder = collect.get(record.getId());


                if (productionPrintOrder != null) {


                    productionPrintOrder.convertProductOrderDto(record);


                }


            });






        }




        return productOrderDtoIPage;


    }




    @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()));


        Map<Long, ProductProcess> productProcessMap = new HashMap<>();


        if(CollUtil.isNotEmpty(processRouteItems)){


            productProcessMap = productProcessService


                    .list(new LambdaQueryWrapper<ProductProcess>().in(ProductProcess::getId, processRouteItems.stream().map(ProcessRouteItem::getProcessId).collect(Collectors.toList())))


                    .stream()


                    .collect(Collectors.toMap(ProductProcess::getId, productProcess -> productProcess));




        }


        // 生成当前日期的前缀：年月日


        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 productWorkOrder = new ProductWorkOrder();


                productWorkOrder.setProductProcessRouteItemId(productProcessRouteItem.getId());


                productWorkOrder.setProductOrderId(productOrder.getId());


                ProductOrder order = productOrderMapper.selectById(productOrder.getId());


                productWorkOrder.setPlanQuantity(order.getQuantity());


                productWorkOrder.setWorkOrderNo(productWorkOrderService.generateProductWorkOrder(null, productProcessMap.getOrDefault(productProcessRouteItem.getProcessId(), new ProductProcess()).getName(), productOrder.getNpsNo()));


                productWorkOrder.setStatus(1);


                productWorkOrderMapper.insert(productWorkOrder);


            }


        }


        return productOrderMapper.updateById(productOrder);


    }




    @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


    public Boolean delete(Long[] ids) {


        //如果已经开始生产,不能删除


        //查询生产订单下的工单


        List<ProductWorkOrder> productWorkOrders = productWorkOrderMapper.selectList(Wrappers.<ProductWorkOrder>lambdaQuery().in(ProductWorkOrder::getProductOrderId, ids));


        if (productWorkOrders.size() > 0) {


            //判断是否有报工数据


            List<ProductionProductMain> productionProductMains = productionProductMainMapper.selectList(Wrappers.<ProductionProductMain>lambdaQuery()


                    .in(ProductionProductMain::getWorkOrderId, productWorkOrders.stream().map(ProductWorkOrder::getId).collect(Collectors.toList())));


            if (productionProductMains.size() > 0) {


                throw new RuntimeException("生产订单已经开始生产,不能删除");


            }


            //删除工单


            productWorkOrderMapper.delete(Wrappers.<ProductWorkOrder>lambdaQuery().in(ProductWorkOrder::getProductOrderId, ids));


        }


        //删除工艺路线


        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;


    }




    @Override


    public ProductWorkOrder startProduction(Long id) {


        LocalDateTime now = LocalDateTime.now();


        ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(id);


        productWorkOrder.setStartProductTime(now);


        Assert.notNull(productWorkOrder, "工单不存在");






        ProductWorkOrder needUpdate = new ProductWorkOrder();


        needUpdate.setId(id);


        needUpdate.setStartProductTime(now);


        productWorkOrderMapper.updateById(needUpdate);




        return productWorkOrder;


    }




    //获取当前生产订单号


    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) {


        return "SC" + datePrefix + formatOrderSequence(datePrefix);


    }




    public String generateNextOrderByContractNo(String datePrefix, String contractNo) {


        return contractNo + formatOrderSequence(datePrefix);


    }




    private String formatOrderSequence(String datePrefix) {


        int sequence = 1; // 默认起始序号


        String maxOrderNo = getMaxOrderNoByDate(datePrefix);


        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 String.format("%04d", sequence);


    }




}