修改 9.21

zss

2023-09-21 2dbc49184bd74845c8da694c20d6fd03d7ac87e0

 standard-server/src/main/java/com/yuanchu/mom/service/impl/MaterialServiceImpl.java

@@ -1,6 +1,7 @@
package com.yuanchu.mom.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yuanchu.mom.mapper.*;
@@ -13,6 +14,7 @@

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -53,13 +55,20 @@
    MbomModelMapper mbomModelMapper;

    @Resource
    TechniqueService techniqueService;
    TechnologyMapper technologyMapper;

    @Resource
    TechniqueModelMapper techniqueModelMapper;
    ProductMapper productMapper;

    @Resource
    DeviceMapper deviceMapper;
    MbomMapper mbomMapper;


    //新增-->选择产品大类
    @Override
    public List<String> chooseFather() {
        return technologyTemplateMapper.chooseType();
    }

    //标准MOM-->左侧五级树展示
    @Override
@@ -70,12 +79,15 @@
    //(1,2级)新增-->物料,标准,型号
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String addMaterial(MaterialDto materialDto) {
    public String addMaterial(MaterialDto materialDto, Integer spId, Integer ver) {
        //校验添加物料是否重复
        if (materialMapper.selectOne(Wrappers.<Material>query()
        List<Material> materialList = materialMapper.selectList(Wrappers.<Material>query()
                .eq("type", materialDto.getType())
                .eq("father", materialDto.getFather())).getName().equals(materialDto.getName())) {
            return "该类型产品大类下有该产品名称";
                .eq("father", materialDto.getFather()));
        for (Material material : materialList) {
            if (material.getName().equals(materialDto.getName())) {
                return "该类型产品大类下有该产品名称";
            }
        }
        /*新增物料表*/
        Material material = new Material();
@@ -94,31 +106,140 @@
        specifications.setName(materialDto.getSpecifications());
        specifications.setStandardId(standard.getId());
        specificationsMapper.insert(specifications);
        /**
         * 根据选择的情况,判断是拉取基础数据的数据,还是某一个产品下某一个型号的数据
         */
        //如果spId传的参数是0,则拉取基础数据的数据
        if (spId == 0) {
            /*新增标准BOM-->工艺路线(批量添加)*/
            List<TechnologyTemplate> technologyTemplateList = technologyTemplateMapper.selectList(Wrappers.<TechnologyTemplate>query().eq("type", material.getFather()));
            if (ObjectUtils.isEmpty(technologyTemplateList)) {
                return "添加物料【" + materialDto.getName() + "】成功";
            }
            List<Technology> technologyList = technologyTemplateList.stream().map(technologyTemplate -> {
                Technology technology = new Technology();
                technology.setSpecificationsId(specifications.getId());
                technology.setFather(technologyTemplate.getFather());
                technology.setName(technologyTemplate.getName());
                technology.setDeviceGroup(technologyTemplate.getDeviceGroup());
                return technology;
            }).collect(Collectors.toList());
            technologyService.saveBatch(technologyList);
            /*新增标准BOM-->技术指标(批量添加)*/
            //新增的工艺路线id集合
            List<Integer> technologyIds = technologyList.stream().map(Technology::getId).collect(Collectors.toList());
            //基础数据中工艺路线id集合
            List<Integer> techTemIds = technologyTemplateList.stream().map(TechnologyTemplate::getId).collect(Collectors.toList());
            //两者长度一定一样
            List<Product> productList = new ArrayList<>();
            for (int i = 0; i < technologyIds.size(); i++) {
                List<TechnicalModel> technicalModelList = technicalModelMapper.selectList(Wrappers.<TechnicalModel>query().eq("tech_tem_id", techTemIds.get(i)));
                for (TechnicalModel technicalModel : technicalModelList) {
                    Product product = new Product();
                    product.setFather(technicalModel.getFather());
                    product.setName(technicalModel.getName());
                    product.setUnit(technicalModel.getUnit());
                    product.setTechnologyId(technologyIds.get(i));
                    productList.add(product);
                }
            }
            productService.saveBatch(productList);
            /*新增标准BOM-->物料清单(批量添加)*/
            List<Mbom> mbomList = new ArrayList<>();
            for (int i = 0; i < technologyIds.size(); i++) {
                List<MbomModel> mbomModelList = mbomModelMapper.selectList(Wrappers.<MbomModel>query().eq("tech_tem_id", techTemIds.get(i)));
                for (MbomModel mbomModel : mbomModelList) {
                    Mbom mbom = new Mbom();
                    mbom.setUnit(mbomModel.getUnit());
                    mbom.setName(mbomModel.getName());
                    mbom.setQualityTraceability(mbomModel.getQualityTraceability());
                    mbom.setSpecifications(mbomModel.getSpecifications());
                    mbom.setTechnologyId(technologyIds.get(i));
                    mbomList.add(mbom);
                }
            }
            mbomService.saveBatch(mbomList);
            return "添加物料【" + materialDto.getName() + "】成功";
        }
        //如果spId!=0,等于选择的具体型号,则添加该型号版本的数据
        /*新增标准BOM-->工艺路线(批量添加)*/
        List<TechnologyTemplate> technologyTemplateList = technologyTemplateMapper.selectList(Wrappers.<TechnologyTemplate>query().eq("type", materialDto.getFather()));
        List<Technology> technologyList = technologyTemplateList.stream().map(technologyTemplate -> {
            Technology technology = new Technology();
            technology.setSpecificationsId(specifications.getId());
            technology.setFather(technologyTemplate.getFather());
            technology.setName(technologyTemplate.getName());
            technology.setDeviceGroup(technologyTemplate.getDeviceGroup());
            return technology;
        List<Technology> technologyList = technologyMapper.selAllByVerSpId(spId, ver);
        List<Technology> technologys = technologyList.stream().map(technology -> {
            Technology tec = new Technology();
            tec.setSpecificationsId(specifications.getId());
            tec.setName(technology.getName());
            tec.setFather(technology.getFather());
            tec.setDeviceGroup(technology.getDeviceGroup());
            tec.setProductionQuota(technology.getProductionQuota());
            return tec;
        }).collect(Collectors.toList());
        technologyService.saveBatch(technologys);
        //两者长度一定一样
        for (int i = 0; i < technologyList.size(); i++) {
            /*新增标准BOM-->技术指标(批量添加)*/
            List<Product> productList = productMapper.selProByVerSpe(technologyList.get(i).getId());
            List<Product> products = new ArrayList<>();
            for (Product product : productList) {
                Product pro = new Product();
                pro.setTechnologyId(technologys.get(i).getId());
                pro.setName(product.getName());
                pro.setFather(product.getFather());
                pro.setUnit(product.getUnit());
                pro.setRequired(product.getRequired());
                pro.setInternal(product.getInternal());
                products.add(pro);
            }
            productService.saveBatch(products);
            /*新增标准BOM-->物料清单(批量添加)*/
            List<Mbom> mbomList = mbomMapper.seleByTechId(technologyList.get(i).getId());
            List<Mbom> mboms = new ArrayList<>();
            for (Mbom mbom : mbomList) {
                Mbom mbo = new Mbom();
                mbo.setTechnologyId(technologys.get(i).getId());
                mbo.setName(mbom.getName());
                mbo.setUnit(mbom.getUnit());
                mbo.setUnit(mbom.getUnit());
                mbo.setNum(mbom.getNum());
                mbo.setQualityTraceability(mbom.getQualityTraceability());
                mbo.setSpecifications(mbom.getSpecifications());
                mboms.add(mbo);
            }
            mbomService.saveBatch(mboms);
        }
        return "添加物料【" + materialDto.getName() + "】成功";
    }


    //添加同一个型号工艺路线,技术指标,物料清单的版本
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer addVersion(Integer specificationsId, Integer version) {
        List<Technology> technologyList = technologyMapper.selectList(Wrappers.<Technology>query()
                .eq("specifications_id", specificationsId)
                .eq("version", version));
        /*上一个版本的工艺路线id集合*/
        List<Integer> techTemIds = technologyList.stream().map(Technology::getId).collect(Collectors.toList());
        for (Technology technology : technologyList) {
            technology.setId(null);
            //最新版本+1
            technology.setVersion(technologyMapper.selectVerByTec(specificationsId).get(0) + 1);
        }
        technologyService.saveBatch(technologyList);
        /*新增标准BOM-->技术指标(批量添加)*/
        //新增的工艺路线id集合
        /*工艺路线的版本新增的同时该工艺路线下下的技术指标,生产工艺,物料清单都要新增*/
        //新增版本的工艺路线id集合
        List<Integer> technologyIds = technologyList.stream().map(Technology::getId).collect(Collectors.toList());
        //基础数据中工艺路线id集合
        List<Integer> techTemIds = technologyTemplateList.stream().map(TechnologyTemplate::getId).collect(Collectors.toList());
        //两者长度一定一样
        List<Product> productList = new ArrayList<>();
        for (int i = 0; i < technologyIds.size(); i++) {
            List<TechnicalModel> technicalModelList = technicalModelMapper.selectList(Wrappers.<TechnicalModel>query().eq("tech_tem_id", techTemIds.get(i)));
            for (TechnicalModel technicalModel : technicalModelList) {
            List<Product> products = productMapper.selectList(Wrappers.<Product>query().eq("technology_id", techTemIds.get(i)));
            for (Product pro : products) {
                Product product = new Product();
                product.setFather(technicalModel.getFather());
                product.setName(technicalModel.getName());
                product.setUnit(technicalModel.getUnit());
                product.setFather(pro.getFather());
                product.setName(pro.getName());
                product.setUnit(pro.getUnit());
                product.setRequired(pro.getRequired());
                product.setInternal(pro.getInternal());
                product.setVersion(pro.getVersion() + 1);
                product.setTechnologyId(technologyIds.get(i));
                productList.add(product);
            }
@@ -127,41 +248,22 @@
        /*新增标准BOM-->物料清单(批量添加)*/
        List<Mbom> mbomList = new ArrayList<>();
        for (int i = 0; i < technologyIds.size(); i++) {
            List<MbomModel> mbomModelList = mbomModelMapper.selectList(Wrappers.<MbomModel>query().eq("tech_tem_id", techTemIds.get(i)));
            for (MbomModel mbomModel : mbomModelList) {
            List<Mbom> mboms = mbomMapper.selectList(Wrappers.<Mbom>query().eq("technology_id", techTemIds.get(i)));
            for (Mbom mb : mboms) {
                Mbom mbom = new Mbom();
                mbom.setUnit(mbomModel.getUnit());
                mbom.setName(mbomModel.getName());
                mbom.setSupplier(mbomModel.getSupplier());
                mbom.setQualityTraceability(mbomModel.getQualityTraceability());
                mbom.setSpecifications(mbomModel.getSpecifications());
                mbom.setUnit(mb.getUnit());
                mbom.setName(mb.getName());
                mbom.setQualityTraceability(mb.getQualityTraceability());
                mbom.setSpecifications(mb.getSpecifications());
                mbom.setVersion(mb.getVersion() + 1);
                mbom.setNum(mb.getNum());
                mbom.setTechnologyId(technologyIds.get(i));
                mbomList.add(mbom);
            }
        }
        mbomService.saveBatch(mbomList);
        /*新增标准BOM-->生产工艺(批量添加)*/
        List<Technique> techniqueList = new ArrayList<>();
        for (int i = 0; i < technologyIds.size(); i++) {
            List<TechniqueModel> techniqueModelList = techniqueModelMapper.selectList(Wrappers.<TechniqueModel>query().eq("tech_tem_id", techTemIds.get(i)));
            for (TechniqueModel techniqueModel : techniqueModelList) {
                //查询设备名称
                Device device = deviceMapper.selectById(techniqueModel.getDeviceId());
                //查询基础生产工艺中每个设备的具体项目
                TechnicalModel technicalModel = technicalModelMapper.selectById(techniqueModel.getTechnicalModelId());
                Technique technique = new Technique();
                technique.setTechnologyId(technologyIds.get(i));
                technique.setDevice(device.getName());
                technique.setProductFather(technicalModel.getFather());
                technique.setProduct(technicalModel.getName());
                technique.setUnit(technicalModel.getUnit());
                techniqueList.add(technique);
            }
        }
        techniqueService.saveBatch(techniqueList);
        return "添加物料【" + materialDto.getName() + "】成功";
        return technologyList.get(0).getVersion();
    }


}