产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
gongchunyi
3 天以前 52e93e45d7c989483693f53ded1b4483891fb055 
 src/main/java/com/ruoyi/production/service/impl/ProductOrderServiceImpl.java


@@ -4,22 +4,26 @@


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.common.enums.StockQualifiedRecordTypeEnum;


import com.ruoyi.common.enums.StockUnQualifiedRecordTypeEnum;


import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;


import com.ruoyi.common.enums.StockInUnQualifiedRecordTypeEnum;


import com.ruoyi.procurementrecord.utils.StockUtils;


import com.ruoyi.production.dto.ProductBomDto;


import com.ruoyi.production.dto.ProductOrderDto;


import com.ruoyi.production.dto.ProductStructureDto;


import com.ruoyi.production.mapper.*;


import com.ruoyi.production.pojo.*;


import com.ruoyi.production.service.ProcessRouteService;


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 com.ruoyi.quality.pojo.QualityInspect;


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;


@@ -50,6 +54,12 @@




    @Autowired


    private ProductionProductMainMapper productionProductMainMapper;




    @Autowired


    private ProductOrderPlanMapper productOrderPlanMapper;




    @Autowired


    private ProductionPlanMapper productionPlanMapper;




    @Autowired


    private ProductionProductOutputMapper productionProductOutputMapper;


@@ -84,7 +94,7 @@


        //新增生产订单下的工艺路线子表


        List<ProcessRouteItem> processRouteItems = processRouteItemMapper.selectList(new QueryWrapper<ProcessRouteItem>().lambda().eq(ProcessRouteItem::getRouteId, processRoute.getId()));


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


        String datePrefix = "GD" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));


        String datePrefix = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));


        for (ProcessRouteItem processRouteItem : processRouteItems) {


            ProductProcessRouteItem productProcessRouteItem = new ProductProcessRouteItem();


            productProcessRouteItem.setProductModelId(processRouteItem.getProductModelId());


@@ -124,6 +134,29 @@


    }




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


    }


@@ -147,92 +180,27 @@




    @Override


    public Boolean delete(Long[] ids) {




        //批量查询productOrder


        List<ProductOrder> productOrders = productOrderMapper.selectList(


                new LambdaQueryWrapper<ProductOrder>()


                        .in(ProductOrder::getId, ids)


        );


        if (!org.springframework.util.CollectionUtils.isEmpty(productOrders)) {






            // 批量查询processRouteItems


            List<ProductProcessRouteItem> allRouteItems = productProcessRouteItemMapper.selectList(


                    new LambdaQueryWrapper<ProductProcessRouteItem>()


                            .in(ProductProcessRouteItem::getProductOrderId, ids)


            );




            if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(allRouteItems)) {


                // 获取要删除的工序项ID


                List<Long> routeItemIds = allRouteItems.stream()


                        .map(ProductProcessRouteItem::getId)


                        .collect(Collectors.toList());




                // 查询关联的工单ID


                List<ProductWorkOrder> workOrders = productWorkOrderMapper.selectList(


                        new LambdaQueryWrapper<ProductWorkOrder>()


                                .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds)


                );


                if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(workOrders)) {


                    List<Long> workOrderIds = workOrders.stream()


                            .map(ProductWorkOrder::getId)


                            .collect(Collectors.toList());




                    // 查询关联的生产主表ID


                    List<ProductionProductMain> productMains = productionProductMainMapper.selectList(


                            new LambdaQueryWrapper<ProductionProductMain>()


                                    .in(ProductionProductMain::getWorkOrderId, workOrderIds)


                    );


                    List<Long> productMainIds = productMains.stream()


                            .map(ProductionProductMain::getId)


                            .collect(Collectors.toList());




                    // 删除产出表、投入表数据


                    if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(productMainIds)) {


                        productionProductOutputMapper.deleteByProductMainIds(productMainIds);


                        productionProductInputMapper.deleteByProductMainIds(productMainIds);


                        List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(


                                new LambdaQueryWrapper<QualityInspect>()


                                        .in(QualityInspect::getProductMainId, productMainIds)


                        );


                        //删除出库记录


                        for (Long productMainId : productMainIds) {


                            //删除生产出库记录


                            stockUtils.deleteStockOutRecord(productMainId, StockQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode());


                            //删除报废的入库记录


                            stockUtils.deleteStockInRecord(productMainId, StockUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode());


                        }


                        qualityInspects.forEach(qualityInspect -> {


                            //inspectState=1 已提交 不能删除


                            if (qualityInspect.getInspectState() == 1) {


                                throw new RuntimeException("已提交的检验单不能删除");


                            }


                        });


                        qualityInspectMapper.deleteByProductMainIds(productMainIds);


                        salesLedgerProductionAccountingMapper.delete(new LambdaQueryWrapper<SalesLedgerProductionAccounting>()


                                .in(SalesLedgerProductionAccounting::getProductMainId, productMainIds));


                    }




                    // 删除生产主表数据


                    productionProductMainMapper.deleteByWorkOrderIds(workOrderIds);




                    // 删除工单数据


                    productWorkOrderMapper.delete(new LambdaQueryWrapper<ProductWorkOrder>()


                            .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds));


                }


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


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


        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("生产订单已经开始生产,不能删除");


            }


            // 批量删除processRouteItem


            productProcessRouteItemMapper.delete(new LambdaQueryWrapper<ProductProcessRouteItem>()


                    .in(ProductProcessRouteItem::getProductOrderId, ids));




            // 批量删除productProcessRoute


            productProcessRouteMapper.delete(new LambdaQueryWrapper<ProductProcessRoute>()


                    .in(ProductProcessRoute::getProductOrderId, ids));




            // 批量删除productOrder


            productOrderMapper.delete(new LambdaQueryWrapper<ProductOrder>()


                    .in(ProductOrder::getId, ids));


            //删除工单


            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;


    }