改动

zss

2023-08-17 35091697a5421218d31e7e2d2c58b6a5385cc663

 inspect-server/src/main/java/com/yuanchu/mom/service/impl/FinishedInspectServiceImpl.java

@@ -4,10 +4,12 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yuanchu.mom.mapper.ImportRepertoryMapper;
import com.yuanchu.mom.mapper.InspectUnacceptedMapper;
import com.yuanchu.mom.mapper.RepertoryMapper;
import com.yuanchu.mom.pojo.FinishedInspect;
import com.yuanchu.mom.mapper.FinishedInspectMapper;
import com.yuanchu.mom.pojo.ImportRepertory;
import com.yuanchu.mom.pojo.InspectUnaccepted;
import com.yuanchu.mom.pojo.Repertory;
import com.yuanchu.mom.service.FinishedInspectService;
@@ -48,6 +50,9 @@
    @Resource
    RepertoryMapper repertoryMapper;

    @Resource
    ImportRepertoryMapper importRepertoryMapper;

    @Override
    public Integer addProcessInspectionSheet(FinishedInspect finishedInspect) {
        finishedInspect.setType(0);
@@ -69,76 +74,132 @@
        updateWrapper.eq(FinishedInspect::getId, finishedInspectId);
        updateWrapper.set(FinishedInspect::getResult, result);
        finishedInspectMapper.update(new FinishedInspect(), updateWrapper);
        //如果检验结论为不合格,则需要新增不合格检验单,还需要新增半成品库存
        FinishedInspect finishedInspect = finishedInspectMapper.selectById(finishedInspectId);
        /*检验结论为不合格*/
        if (result == 0) {
            /*新增不合格检验单*/
            InspectUnaccepted inspectUnaccepted = InspectUnaccepted.builder()
                    .reason(finishedInspect.getProjectName() + "不合格")  //暂且定义为工程名称不合格
                    .rawInspectId(finishedInspectId)
                    .type(finishedInspect.getType())
                    .build();
            inspectUnacceptedMapper.insert(inspectUnaccepted);
            /*新增半成品(1)库存*/
            //如果入库的信息一样只有库存不一样,则在原来的库存数量上加上相应的数量
            LambdaQueryWrapper<Repertory> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Repertory::getOrderCode, finishedInspect.getOrderNumber())
                    .eq(Repertory::getCode, finishedInspect.getMaterialCode())
                    .eq(Repertory::getName, finishedInspect.getMaterial())
                    .eq(Repertory::getSpecifications, finishedInspect.getSpecificationsModel())
                    .eq(Repertory::getUnit, finishedInspect.getUnit())
                    .eq(Repertory::getType, 1);
            Repertory rep = repertoryMapper.selectOne(queryWrapper);
            if (rep != null && rep.getCheckState()==1) {
                rep.setNumber(rep.getNumber() + finishedInspect.getQuantity());
                rep.setUserName(username);
                repertoryMapper.updateById(rep);
            } else {
                //如果除了库存别的信息有任何一个不一样,则新增一条半成品库存
                Repertory repertory = Repertory.builder()
                        .orderCode(finishedInspect.getOrderNumber())
                        .code(finishedInspect.getMaterialCode())
                        .name(finishedInspect.getMaterial())
                        .specifications(finishedInspect.getSpecificationsModel())
                        .unit(finishedInspect.getUnit())
                        .number(finishedInspect.getQuantity())
                        .userName(username)
                        .type(1)
                        .checkState(1)
            //如果是成品的结论为不合格,需要新增成品不合格检验单
            if (finishedInspect.getType() == 0) {
                /*新增成品不合格检验单*/
                InspectUnaccepted inspectUnaccepted = InspectUnaccepted.builder()
                        .reason(finishedInspect.getProjectName() + "不合格")  //暂且定义为工程名称不合格
                        .rawInspectId(finishedInspectId)
                        .build();
                repertoryMapper.insert(repertory);
                inspectUnacceptedMapper.insert(inspectUnaccepted);
            }
            //如果是过程检验的结论为不合格,需要新增半成品库存且检验结果为不合格
            if (finishedInspect.getType() == 1) {
                /*新增半成品(1)库存*/
                //如果入库的信息一样只有库存不一样,则在原来的库存数量上加上相应的数量
                LambdaQueryWrapper<Repertory> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(Repertory::getOrderCode, finishedInspect.getOrderNumber())
                        .eq(Repertory::getQualityTraceability, finishedInspect.getQualityTraceability())
                        .eq(Repertory::getName, finishedInspect.getMaterial())
                        .eq(Repertory::getSpecifications, finishedInspect.getSpecificationsModel())
                        .eq(Repertory::getUnit, finishedInspect.getUnit())
                        .eq(Repertory::getType, 1)
                        .eq(Repertory::getCheckResult, 0);
                Repertory rep = repertoryMapper.selectOne(queryWrapper);
                if (rep != null) {
                    rep.setNumber(rep.getNumber() + finishedInspect.getQuantity());
                    rep.setUserName(username);
                    repertoryMapper.updateById(rep);
                } else {
                    //如果除了库存别的信息有任何一个不一样,则新增一条半成品库存
                    Repertory repertory = Repertory.builder()
                            .orderCode(finishedInspect.getOrderNumber())
                            .qualityTraceability(finishedInspect.getQualityTraceability())
                            .name(finishedInspect.getMaterial())
                            .specifications(finishedInspect.getSpecificationsModel())
                            .unit(finishedInspect.getUnit())
                            .number(finishedInspect.getQuantity())
                            .userName(username)
                            .type(1)
                            .checkResult(0)//检验结果为不合格
                            .build();
                    repertoryMapper.insert(repertory);
                }
            }
        }
        //如果检验合格,需要新增成品(0)库存
        /*检验结论为合格*/
        if (result == 1) {
            //如果入库的信息一样只有库存不一样,则在原来的库存数量上加上相应的数量
            LambdaQueryWrapper<Repertory> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Repertory::getOrderCode, finishedInspect.getOrderNumber())
                    .eq(Repertory::getCode, finishedInspect.getMaterialCode())
                    .eq(Repertory::getName, finishedInspect.getMaterial())
                    .eq(Repertory::getSpecifications, finishedInspect.getSpecificationsModel())
                    .eq(Repertory::getUnit, finishedInspect.getUnit())
                    .eq(Repertory::getType, 0);
            Repertory rep = repertoryMapper.selectOne(queryWrapper);
            if (rep != null && rep.getCheckState()==1) {
                rep.setNumber(rep.getNumber() + finishedInspect.getQuantity());
                rep.setUserName(username);
                repertoryMapper.updateById(rep);
            } else {
                //如果除了库存别的信息有任何一个不一样,则新增一条成品库存
                Repertory repertory = Repertory.builder()
            //如果是成品检验合格,,需要新增成品(0)库存和入库记录
            if (finishedInspect.getType() == 0) {
                /*新增成品入库记录*/
                ImportRepertory importRepertory = ImportRepertory.builder()
                        .orderCode(finishedInspect.getOrderNumber())
                        .code(finishedInspect.getMaterialCode())
                        .qualityTraceability(finishedInspect.getQualityTraceability())
                        .name(finishedInspect.getMaterial())
                        .specifications(finishedInspect.getSpecificationsModel())
                        .unit(finishedInspect.getUnit())
                        .number(finishedInspect.getQuantity())
                        .userName(username)
                        .type(0)
                        .checkState(1)
                        .build();
                repertoryMapper.insert(repertory);
                importRepertoryMapper.insert(importRepertory);
                /*新增成品(0)库存*/
                //如果入库的信息一样只有库存不一样,则在原来的库存数量上加上相应的数量
                LambdaQueryWrapper<Repertory> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(Repertory::getOrderCode, finishedInspect.getOrderNumber())
                        .eq(Repertory::getQualityTraceability, finishedInspect.getQualityTraceability())
                        .eq(Repertory::getName, finishedInspect.getMaterial())
                        .eq(Repertory::getSpecifications, finishedInspect.getSpecificationsModel())
                        .eq(Repertory::getUnit, finishedInspect.getUnit())
                        .eq(Repertory::getType, 0)
                        .eq(Repertory::getCheckResult, 1);
                Repertory rep = repertoryMapper.selectOne(queryWrapper);
                if (rep != null) {
                    rep.setNumber(rep.getNumber() + finishedInspect.getQuantity());
                    rep.setUserName(username);
                    repertoryMapper.updateById(rep);
                } else {
                    //如果除了库存别的信息有任何一个不一样,则新增一条成品库存
                    Repertory repertory = Repertory.builder()
                            .orderCode(finishedInspect.getOrderNumber())
                            .qualityTraceability(finishedInspect.getQualityTraceability())
                            .name(finishedInspect.getMaterial())
                            .specifications(finishedInspect.getSpecificationsModel())
                            .unit(finishedInspect.getUnit())
                            .number(finishedInspect.getQuantity())
                            .userName(username)
                            .type(0)
                            .checkResult(1)   //库存检验结果为合格
                            .build();
                    repertoryMapper.insert(repertory);
                }
            }
            //如果是过程检验合格,需要新增半成品(1)库存,检验结果为合格1
            if (finishedInspect.getType()==1) {
                /*新增半成品(1)库存*/
                //如果入库的信息一样只有库存不一样,则在原来的库存数量上加上相应的数量
                LambdaQueryWrapper<Repertory> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(Repertory::getOrderCode, finishedInspect.getOrderNumber())
                        .eq(Repertory::getQualityTraceability, finishedInspect.getQualityTraceability())
                        .eq(Repertory::getName, finishedInspect.getMaterial())
                        .eq(Repertory::getSpecifications, finishedInspect.getSpecificationsModel())
                        .eq(Repertory::getUnit, finishedInspect.getUnit())
                        .eq(Repertory::getType, 1)
                        .eq(Repertory::getCheckResult, 1);
                Repertory rep = repertoryMapper.selectOne(queryWrapper);
                if (rep != null) {
                    rep.setNumber(rep.getNumber() + finishedInspect.getQuantity());
                    rep.setUserName(username);
                    repertoryMapper.updateById(rep);
                } else {
                    //如果除了库存别的信息有任何一个不一样,则新增一条半成品库存
                    Repertory repertory = Repertory.builder()
                            .orderCode(finishedInspect.getOrderNumber())
                            .qualityTraceability(finishedInspect.getQualityTraceability())
                            .name(finishedInspect.getMaterial())
                            .specifications(finishedInspect.getSpecificationsModel())
                            .unit(finishedInspect.getUnit())
                            .number(finishedInspect.getQuantity())
                            .userName(username)
                            .type(1)
                            .checkResult(1)//检验结果为合格
                            .build();
                    repertoryMapper.insert(repertory);
                }
            }

        }
        return 1;
    }