Merge remote-tracking branch 'origin/dev_New' into dev_New

gongchunyi

11 小时以前 ed4dd489b756c220455e407786654558f53f115d

 src/main/java/com/ruoyi/production/service/impl/ProductionProductMainServiceImpl.java

@@ -2,29 +2,28 @@

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.enums.StockQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockUnQualifiedRecordTypeEnum;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.production.controller.ProductWorkOrderController;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.production.dto.ProductStructureDto;
import com.ruoyi.production.dto.ProductionProductMainDto;
import com.ruoyi.production.mapper.*;
import com.ruoyi.production.pojo.*;
import com.ruoyi.production.service.ProductionProductMainService;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.quality.mapper.QualityInspectMapper;
import com.ruoyi.quality.mapper.QualityInspectParamMapper;
import com.ruoyi.quality.mapper.QualityTestStandardMapper;
import com.ruoyi.quality.pojo.QualityInspect;
import com.ruoyi.quality.pojo.QualityInspectParam;
import com.ruoyi.quality.pojo.QualityTestStandard;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.quality.mapper.*;
import com.ruoyi.quality.pojo.*;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -32,34 +31,38 @@

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;

@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class ProductionProductMainServiceImpl extends ServiceImpl<ProductionProductMainMapper, ProductionProductMain> implements ProductionProductMainService {

    private ProductionProductMainMapper productionProductMainMapper;

    private ProductWorkOrderController productWorkOrderController;

    private ProductWorkOrderMapper productWorkOrderMapper;

    private ProductProcessRouteItemMapper productProcessRouteItemMapper;
    private SysUserMapper userMapper;

    private ProductionProductOutputMapper productionProductOutputMapper;

    private ProcessRouteItemMapper processRouteItemMapper;

    private ProductModelMapper productModelMapper;

    private QualityInspectMapper qualityInspectMapper;

    private ProductProcessMapper productProcessMapper;
    private ProductProcessRouteMapper productProcessRouteMapper;

    private ProductMapper productMapper;


    private QualityTestStandardParamMapper qualityTestStandardParamMapper;
    private QualityTestStandardMapper qualityTestStandardMapper;

    private QualityInspectParamMapper qualityInspectParamMapper;
@@ -72,6 +75,8 @@

    private SalesLedgerProductionAccountingMapper salesLedgerProductionAccountingMapper;

    private StockUtils stockUtils;


    @Override
    public IPage<ProductionProductMainDto> listPageProductionProductMainDto(Page page, ProductionProductMainDto productionProductMainDto) {
@@ -79,68 +84,35 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addProductMain(ProductionProductMainDto dto) {
        if (dto == null) {
            throw new RuntimeException("参数不能为空");
        }

        SysUser user = SecurityUtils.getLoginUser().getUser();

        if (dto.isReportWork()) {
            // 更新逻辑 - 只更新数量
            QueryWrapper<ProductionProductOutput> outputWrapper = new QueryWrapper<>();
            outputWrapper.eq("product_main_id", dto.getProductMainId());

            ProductionProductOutput output = productionProductOutputMapper.selectOne(outputWrapper);
            if (output == null) {
                throw new RuntimeException("产出记录不存在");
            }

            // 查询生产核算记录
            QueryWrapper<SalesLedgerProductionAccounting> accountingWrapper = new QueryWrapper<>();
            accountingWrapper.eq("sales_ledger_work_id", dto.getProductMainId());
            SalesLedgerProductionAccounting accounting = salesLedgerProductionAccountingMapper.selectOne(accountingWrapper);
            if (accounting == null) {
                throw new RuntimeException("生产核算记录不存在");
            }

            // 只更新数量
            if (dto.getQuantity() != null) {
                output.setQuantity(output.getQuantity().add(dto.getQuantity()));
                productionProductOutputMapper.updateById(output);
                // 更新生产核算记录
                accounting.setFinishedNum(accounting.getFinishedNum().add(dto.getQuantity()));
                salesLedgerProductionAccountingMapper.updateById(accounting);
            }
            return true;
        }

        // 新增逻辑
        SysUser user = userMapper.selectUserById(dto.getUserId());
        ProductionProductMain productionProductMain = new ProductionProductMain();
        //当前工艺路线对应的工序详情
        ProductProcessRouteItem productProcessRouteItem = productProcessRouteItemMapper.selectById(dto.getProductProcessRouteItemId());
        if (productProcessRouteItem == null) {
            throw new RuntimeException("工艺路线项不存在");
        }

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

        //当前具体工序
        ProductProcess productProcess = productProcessMapper.selectById(productProcessRouteItem.getProcessId());
        //工艺路线中当前工序对应的产出规格型号
        ProductModel productModel = productModelMapper.selectById(productProcessRouteItem.getProductModelId());
        //查询该生产订单对应的bom
        ProductProcessRoute productProcessRoute = productProcessRouteMapper.selectById(productProcessRouteItem.getProductRouteId());
        /*新增报工主表*/
        //查询最大报工编号
        String datePrefix = "BG" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyMMdd"));
        QueryWrapper<ProductionProductMain> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("MAX(product_no) as maxNo")
                .likeRight("product_no", datePrefix);

        List<Map<String, Object>> resultList = productionProductMainMapper.selectMaps(queryWrapper);

        int sequenceNumber = 1;
        if (resultList != null && !resultList.isEmpty()) {
            Map<String, Object> result = resultList.get(0);

            if (result != null) {
                Object maxNoObj = result.get("maxNo");
                if (maxNoObj != null) {
                    String lastNo = maxNoObj.toString();
                    System.out.println("lastNo: " + lastNo);

                    if (lastNo.startsWith(datePrefix)) {
                        try {
                            String seqStr = lastNo.substring(datePrefix.length());
@@ -152,129 +124,182 @@
                }
            }
        }

        String productNo = String.format("%s%03d", datePrefix, sequenceNumber);
        productionProductMain.setProductNo(productNo);
        productionProductMain.setUserId(user.getUserId());
        productionProductMain.setUserId(dto.getUserId());
        productionProductMain.setUserName(dto.getUserName());
        productionProductMain.setProductProcessRouteItemId(dto.getProductProcessRouteItemId());
        productionProductMain.setWorkOrderId(dto.getWorkOrderId());
        productionProductMain.setStatus(0);

        // 添加报工主表
        int insert = productionProductMainMapper.insert(productionProductMain);

        //更新工单
        if (insert > 0) {
            UpdateWrapper<ProductWorkOrder> wrapper = new UpdateWrapper<>();
            wrapper.set("report_work", true)
                    .set("quantity", dto.getQuantity())
                    .set("product_main_id", productionProductMain.getId())
                    .eq("id", dto.getWorkOrderId());
            productWorkOrderMapper.update(null, wrapper);
        productionProductMainMapper.insert(productionProductMain);
        /*新增报工投入表*/
        List<ProductStructureDto> productStructureDtos = productStructureMapper.listBybomAndProcess(productProcessRoute.getBomId(), productProcess.getId());
        if (productStructureDtos.size() == 0) {
            //如果该工序没有产品结构的投入品,那这个投入品和产出品是同一个
            ProductStructureDto productStructureDto = new ProductStructureDto();
            productStructureDto.setProductModelId(productProcessRouteItem.getProductModelId());
            productStructureDto.setUnitQuantity(BigDecimal.ONE);
            productStructureDtos.add(productStructureDto);
        }
        ProductProcess productProcess = productProcessMapper.selectById(productProcessRouteItem.getProcessId());
        ProductModel productModel = productProcessRouteItem.getProductModelId() != null ?
                productModelMapper.selectById(productProcessRouteItem.getProductModelId()) : null;
        for (ProductStructureDto productStructureDto : productStructureDtos) {
            ProductModel productModel1 = productModelMapper.selectById(productStructureDto.getProductModelId());
            Product product = productMapper.selectById(productModel1.getProductId());
            BigDecimal stockQuantity = stockUtils.getStockQuantity(productModel1.getId()).get("stockQuantity");
            if (!(stockQuantity.compareTo(BigDecimal.ZERO) > 0)) {
                throw new RuntimeException(product.getProductName()+"产品的"+productModel1.getModel() + "的规格库存为0");
            }
            if (stockQuantity.compareTo(productStructureDto.getUnitQuantity().multiply(dto.getQuantity())) < 0) {
                throw new RuntimeException(product.getProductName()+"产品的"+productModel1.getModel() + "的规格库存不足");
            }
            ProductionProductInput productionProductInput = new ProductionProductInput();
            productionProductInput.setProductModelId(productStructureDto.getProductModelId());
            productionProductInput.setQuantity(productStructureDto.getUnitQuantity().multiply(dto.getQuantity()));
            productionProductInput.setProductMainId(productionProductMain.getId());
            productionProductInputMapper.insert(productionProductInput);
            stockUtils.substractStock(productStructureDto.getProductModelId(), productionProductInput.getQuantity(), StockQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode(), productionProductMain.getId());

        if (productModel != null) {
        }
        /*新增报工产出表*/
        ProductionProductOutput productionProductOutput = new ProductionProductOutput();
        productionProductOutput.setProductMainId(productionProductMain.getId());
        productionProductOutput.setProductModelId(productProcessRouteItem.getProductModelId());
        productionProductOutput.setQuantity(dto.getQuantity() != null ? dto.getQuantity() : BigDecimal.ZERO);
        productionProductOutput.setScrapQty(dto.getScrapQty() != null ? dto.getScrapQty() : BigDecimal.ZERO);
        productionProductOutputMapper.insert(productionProductOutput);
        //合格数量=报工数量-报废数量
        BigDecimal productQty = productionProductOutput.getQuantity().subtract(productionProductOutput.getScrapQty());
        //只有合格数量>0才能增加相应数据
        if (productQty.compareTo(BigDecimal.ZERO)>0) {
            /*新增质检*/
            //对应的过程检或者出厂检
            List<ProductProcessRouteItem> productProcessRouteItems = productProcessRouteItemMapper.selectList(Wrappers.<ProductProcessRouteItem>lambdaQuery().eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId()));
            int inspectType = 1;
            String process = productProcess.getName();//工序
            if (productProcessRouteItem.getDragSort() == productProcessRouteItems.size()) {
                //最后一道工序生成出厂检
                inspectType = 2;
                process = null;
            }
            Product product = productMapper.selectById(productModel.getProductId());
            int inspectType = "组装".equals(productProcess.getName()) ? 2 : 1;

            QualityInspect qualityInspect = new QualityInspect();
            qualityInspect.setProductId(product.getId());
            qualityInspect.setProductName(product.getProductName());
            qualityInspect.setModel(productModel.getModel());
            qualityInspect.setUnit(productModel.getUnit());
            qualityInspect.setQuantity(dto.getQuantity());
            qualityInspect.setProcess(productProcess.getName());
            qualityInspect.setQuantity(productQty);
            qualityInspect.setProcess(process);
            qualityInspect.setInspectState(0);
            qualityInspect.setInspectType(inspectType);
            qualityInspect.setProductMainId(productionProductMain.getId());
            qualityInspect.setProductModelId(productModel.getId());
            qualityInspectMapper.insert(qualityInspect);

            qualityTestStandardMapper.selectList(
                    new LambdaQueryWrapper<QualityTestStandard>()
                            .eq(QualityTestStandard::getProductId, product.getId())
            ).forEach(standard -> {
                QualityInspectParam param = new QualityInspectParam();
                BeanUtils.copyProperties(standard, param);
                param.setId(null);
                param.setInspectId(qualityInspect.getId());
                qualityInspectParamMapper.insert(param);
            });
        }
        // 添加投入
        if (productModel != null) {
            List<ProductStructureDto> productStructureDtos = productStructureMapper.listByproductModelId(productModel.getId());
            for (ProductStructureDto productStructureDto : productStructureDtos) {
                ProductionProductInput productionProductInput = new ProductionProductInput();
                productionProductInput.setProductModelId(productStructureDto.getProductModelId());
                productionProductInput.setQuantity(productStructureDto.getUnitQuantity());
                productionProductInput.setProductMainId(productionProductMain.getId());
                productionProductInputMapper.insert(productionProductInput);
            List<QualityTestStandard> qualityTestStandard = qualityTestStandardMapper.getQualityTestStandardByProductId(product.getId(), inspectType, process);
            if (qualityTestStandard.size() > 0) {
                qualityInspect.setTestStandardId(qualityTestStandard.get(0).getId());
                qualityInspectMapper.updateById(qualityInspect);
                qualityTestStandardParamMapper.selectList(Wrappers.<QualityTestStandardParam>lambdaQuery()
                        .eq(QualityTestStandardParam::getTestStandardId, qualityTestStandard.get(0).getId()))//默认获取最新的
                        .forEach(qualityTestStandardParam -> {
                            QualityInspectParam param = new QualityInspectParam();
                            BeanUtils.copyProperties(qualityTestStandardParam, param);
                            param.setId(null);
                            param.setInspectId(qualityInspect.getId());
                            qualityInspectParamMapper.insert(param);
                        });
            }
            /*更新工单和生产订单*/
            ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(dto.getWorkOrderId());
            productWorkOrder.setCompleteQuantity(productWorkOrder.getCompleteQuantity().add(productQty));
            if (ObjectUtils.isNull(productWorkOrder.getActualStartTime())) {
                productWorkOrder.setActualStartTime(LocalDate.now());//实际开始时间
            }
            if (productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) == 0) {
                productWorkOrder.setActualEndTime(LocalDate.now());//实际结束时间
            }
            productWorkOrderMapper.updateById(productWorkOrder);
            //生产订单
            ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
            if (ObjectUtils.isNull(productOrder.getStartTime())) {
                productOrder.setStartTime(LocalDateTime.now());//开始时间
            }
            if (productProcessRouteItem.getDragSort() == productProcessRouteItems.size()) {
                //如果是最后一道工序报工之后生产订单完成数量+
                productOrder.setCompleteQuantity(productOrder.getCompleteQuantity().add(productQty));
                if (productOrder.getCompleteQuantity().compareTo(productOrder.getQuantity()) == 0) {
                    productOrder.setEndTime(LocalDateTime.now());//结束时间
                }
            }
            productOrderMapper.updateById(productOrder);
            /*添加生产核算*/
            SalesLedgerProductionAccounting salesLedgerProductionAccounting = SalesLedgerProductionAccounting.builder()
                    .salesLedgerWorkId(productionProductMain.getId())
                    .salesLedgerSchedulingId(0L)
                    .salesLedgerId(productOrder.getSalesLedgerId())
                    .salesLedgerProductId(productOrder.getProductModelId())
                    .schedulingUserId(user.getUserId())
                    .schedulingUserName(user.getNickName())
                    .finishedNum(productQty)
                    .workHours(productProcess.getSalaryQuota())
                    .process(productProcess.getName())
                    .schedulingDate(LocalDate.now())
                    .tenantId(dto.getTenantId())
                    .build();
            salesLedgerProductionAccountingMapper.insert(salesLedgerProductionAccounting);
        }

        // 添加产出
        ProductionProductOutput productionProductOutput = new ProductionProductOutput();
        productionProductOutput.setProductMainId(productionProductMain.getId());
        productionProductOutput.setProductModelId(productProcessRouteItem.getProductModelId());
        productionProductOutput.setQuantity(dto.getQuantity() != null ? dto.getQuantity() : BigDecimal.ZERO);
        productionProductOutputMapper.insert(productionProductOutput);

        // 获取生产订单
        ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(dto.getWorkOrderId());
        ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
        if (productOrder == null) {
            throw new RuntimeException("生产订单不存在");
        //如果报废数量>0,需要进入报废的库存
        if (dto.getScrapQty().compareTo(BigDecimal.ZERO) > 0) {
            stockUtils.addUnStock(productModel.getId(), dto.getScrapQty(), StockUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode(), productionProductMain.getId());
        }
        // 添加生产核算
        SalesLedgerProductionAccounting salesLedgerProductionAccounting = SalesLedgerProductionAccounting.builder()
                .salesLedgerWorkId(productionProductMain.getId())
                .salesLedgerSchedulingId(0L)
                .salesLedgerId(productOrder.getSalesLedgerId())
                .salesLedgerProductId(productOrder.getProductModelId())
                .schedulingUserId(user.getUserId())
                .schedulingUserName(user.getNickName())
                .finishedNum(dto.getQuantity() != null ? dto.getQuantity() : BigDecimal.ZERO)
                .workHours(productProcess.getSalaryQuota())
                .process(productProcess.getName())
                .schedulingDate(LocalDate.now())
                .tenantId(dto.getTenantId())
                .build();
        salesLedgerProductionAccountingMapper.insert(salesLedgerProductionAccounting);

        return true;
    }

    @Override
    @Transactional
    public Boolean removeProductMain(ProductionProductMainDto dto) {
        Long id = dto.getId();

        // 删除质检参数和质检记录
        ProductionProductMain productionProductMain = productionProductMainMapper.selectById(dto.getId());
        //该报工对应的工艺路线详情
        ProductProcessRouteItem productProcessRouteItem = productProcessRouteItemMapper.selectById(productionProductMain.getProductProcessRouteItemId());
        ProductionProductOutput productionProductOutput = productionProductOutputMapper.selectList(Wrappers.<ProductionProductOutput>lambdaQuery().eq(ProductionProductOutput::getProductMainId, productionProductMain.getId())).get(0);
        /*删除核算*/
        salesLedgerProductionAccountingMapper.delete(
                new LambdaQueryWrapper<SalesLedgerProductionAccounting>()
                        .eq(SalesLedgerProductionAccounting::getSalesLedgerWorkId, productionProductMain.getId())
        );
        /*更新工单和生产订单*/
        ProductWorkOrder productWorkOrder = productWorkOrderMapper.selectById(productionProductMain.getWorkOrderId());
        productWorkOrder.setCompleteQuantity(productWorkOrder.getCompleteQuantity().subtract(productionProductOutput.getQuantity()));
        productWorkOrder.setActualEndTime(null);
        productWorkOrderMapper.updateById(productWorkOrder);
        //判断是否是最后一道工序
        List<ProductProcessRouteItem> productProcessRouteItems = productProcessRouteItemMapper.selectList(Wrappers.<ProductProcessRouteItem>lambdaQuery().eq(ProductProcessRouteItem::getProductRouteId, productProcessRouteItem.getProductRouteId()));
        if (productProcessRouteItem.getDragSort() == productProcessRouteItems.size()){
            ProductOrder productOrder = productOrderMapper.selectById(productWorkOrder.getProductOrderId());
            productOrder.setCompleteQuantity(productOrder.getCompleteQuantity().subtract(productionProductOutput.getQuantity()));
            productOrder.setEndTime(null);
            productOrderMapper.updateById(productOrder);
        }
        /*删除产出*/
        //删除质检
        qualityInspectMapper.selectList(
                new LambdaQueryWrapper<QualityInspect>()
                        .eq(QualityInspect::getProductMainId, id)
                        .eq(QualityInspect::getProductMainId, productionProductMain.getId())
        ).forEach(q -> {
            qualityInspectParamMapper.delete(
                    new LambdaQueryWrapper<QualityInspectParam>()
                            .eq(QualityInspectParam::getInspectId, q.getId()));
            qualityInspectMapper.deleteById(q.getId());
        });

        // 删除产出记录
        productionProductOutputMapper.delete(new LambdaQueryWrapper<ProductionProductOutput>()
                .eq(ProductionProductOutput::getProductMainId, id)
        );

        // 删除关联的核算数据
        salesLedgerProductionAccountingMapper.delete(
                        new LambdaQueryWrapper<SalesLedgerProductionAccounting>()
                                .eq(SalesLedgerProductionAccounting::getSalesLedgerWorkId, id)
                );

                .eq(ProductionProductOutput::getProductMainId, productionProductMain.getId()));
        //删除投入记录
        productionProductInputMapper.delete(new LambdaQueryWrapper<ProductionProductInput>()
                .eq(ProductionProductInput::getProductMainId, productionProductMain.getId()));
        //删除报废的入库记录
        stockUtils.deleteStockRecord(productionProductMain.getId(), StockUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode());
        //删除投入对应的出库记录
        stockUtils.deleteStockRecord(productionProductMain.getId(), StockQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode());
        // 删除主表
        return productionProductMainMapper.deleteById(id) > 0;
        productionProductMainMapper.deleteById(productionProductMain.getId());
        return true;
    }
}