package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.dto.FileUrlDTO;
import com.whyc.dto.Response;
import com.whyc.mapper.ProductHistoryMapper;
import com.whyc.mapper.ProductMapper;
import com.whyc.pojo.*;
import com.whyc.util.DateUtil;
import com.whyc.util.*;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
public class ProductService {
    @Autowired(required = false)
    private ProductMapper mapper;

    @Autowired(required = false)
    private ProductHistoryMapper hisMapper;

    @Autowired
    private ProductHistoryService phService;

    @Autowired
    private MaterialProductHistoryService mphService;

    @Autowired
    private ProductBomService pbService;

    @Autowired
    private ProductBomHistoryService pbhService;

    @Autowired
    private MaterialService mService;

    @Autowired
    private ProductLockLogService productLockLogService;

    @Autowired
    private MaterialHistoryService materialHistoryService;

    //查询出所有的产品信息(分页加模糊查询<产品的编码，型号，名字，定制表编号>
    public Response getAllProduct(String subCode,String parentCode, String parentName, String parentModel, String customCode,Integer enabled, int pageCurr, int pageSize) {
        PageHelper.startPage(pageCurr,pageSize);
        /*QueryWrapper wrapper=new QueryWrapper();
        if(parentCode!=null){
            wrapper.like("parent_code",parentCode);
        }
        if(parentName!=null){
            wrapper.like("parent_name",parentName);
        }
        if(parentModel!=null){
            wrapper.like("parent_model",parentModel);
        }
        if(customCode!=null){
            if(customCode.isEmpty()){
                wrapper.eq("custom_code",customCode);
            }else{
                wrapper.like("custom_code",customCode);
            }
        }
        wrapper.orderByAsc("id");
        List list=mapper.selectList(wrapper);*/
        List<Product> list=mapper.getAllProduct(subCode,parentCode,parentName,parentModel,customCode,enabled);
        /*list.stream().forEach(product -> {
            //1.查询是否存在该记录
            QueryWrapper qwrapper=new QueryWrapper();
            qwrapper.eq("id",product.getId());
            qwrapper.last("limit 1");
            ProductHistory pHis=hisMapper.selectOne(qwrapper);
            product.setEnabled(pHis.getEnabled());
        });*/
        PageInfo pageInfo=new PageInfo(list);
        return new Response().setII(1,list.size()>0,pageInfo,"返回产品信息");
    }

    public Product getVersion(String parentCode, String customCode) {
        QueryWrapper<Product> query = Wrappers.query();
        query.eq("parent_code",parentCode).eq("custom_code",customCode).last(" limit 1");
        return mapper.selectOne(query);
    }

    public Product getVersion(Integer productId) {
        QueryWrapper<Product> query = Wrappers.query();
        query.eq("product_id",productId);
        return mapper.selectOne(query);
    }

    public int updateVersion(String parentCode, String customCode, Integer nextVersion) {
        UpdateWrapper<Product> update = Wrappers.update();
        update.set("version",nextVersion).eq("parent_code",parentCode).eq("custom_code",customCode);
        mapper.update(null,update);

        QueryWrapper<Product> query = Wrappers.query();
        query.select("id").eq("parent_code",parentCode).eq("custom_code",customCode);
        return mapper.selectOne(query).getId();
    }

    public Product getById(Integer id) {
        return mapper.selectById(id);
    }

    public void deleteByParentCodeAndCustomCode(String parentCode, String customCode) {
        UpdateWrapper<Product> update = Wrappers.update();
        update.eq("parent_code",parentCode).eq("custom_code",customCode);
        mapper.delete(update);
    }

    public void insert(Product product) {
        mapper.insert(product);
    }

    public Response zipParse(MultipartFile file, Product baseProduct) throws IOException, InvalidFormatException {
        Product product = new Product();
        List<ProductBom> bomList = new LinkedList<>();
        Response response = new Response();
        //检查是否为zip
        boolean isZip = Zip4jUtil.checkZipFileParam(file);
        if (!isZip) {
            return response.set(1, false, "上传的文件格式不是zip");
        }
        //zip存储路径:doc_file/product_submit/${username}/{dateFormat}/${timeStamp}
        String rootFile = CommonUtil.getRootFile();
        DocUser user = ActionUtil.getUser();
        String dateFormat = new SimpleDateFormat("YYYY-MM").format(new Date());
        long timeStamp = System.currentTimeMillis();
        String filePath = rootFile + File.separator + "product_submit" + File.separator + user.getName() + File.separator + dateFormat + File.separator + timeStamp;
        File parentFile = new File(filePath);
        String originalFilename = file.getOriginalFilename();
        File zipFile = new File(filePath + File.separator + originalFilename);
        /*if (!zipFile.exists()) {
            zipFile.mkdirs();
        }*/
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        file.transferTo(zipFile);
        //解压文件夹
        Zip4jUtil.unPackZip(zipFile, null, filePath);
        //遍历解压后的文件夹路径,解析excel
        System.out.println(filePath);
        List<String> fileList = new ArrayList<>();
        //图纸筛选
        fileList = FileUtil.getStaticFilePath(parentFile, fileList);
        List<FileUrlDTO> dwgExistsList = getDwgList(fileList);
        for (int i = 0; i < fileList.size(); i++) {
            String fileTempUrl = fileList.get(i);
            //查询需上传的bom数据
            //if (fileTempUrl.contains(".xls") && fileTempUrl.contains("(BOM)")) {
            int excelType = 1; //.xls
            if (fileTempUrl.substring(fileTempUrl.lastIndexOf(File.separator)+1).contains("(BOM).xls")) {
                Workbook workbook = null;
                InputStream inputStream = new FileInputStream(new File(fileTempUrl));
                workbook = WorkbookFactory.create(inputStream);
                inputStream.close();
                //List<? extends PictureData> allPictures = workbook.getAllPictures();
                if(fileTempUrl.substring(fileTempUrl.lastIndexOf(".")+1).equals("xlsx")) {
                    excelType = 2; //.xlsx
                    /*Collections.sort(allPictures, new Comparator<PictureData>() {
                        @Override
                        public int compare(PictureData o1, PictureData o2) {
                            // Name: /xl/media/image1.png - Content Type: image/png
                            String s1 = o1.toString();
                            int contentTypeIndex = s1.indexOf(" - Content Type");
                            String s1Front = s1.substring(0, contentTypeIndex);
                            String imageNumStr1 = s1Front.substring(s1Front.lastIndexOf("/") + 1, s1Front.lastIndexOf(".")).replace("image", "");

                            String s2 = o2.toString();
                            int contentTypeIndex2 = s2.indexOf(" - Content Type");
                            String s2Front = s2.substring(0, contentTypeIndex2);
                            String imageNumStr2 = s2Front.substring(s2Front.lastIndexOf("/") + 1, s2Front.lastIndexOf(".")).replace("image", "");

                            return Integer.parseInt(imageNumStr1) - Integer.parseInt(imageNumStr2);


                        }
                    });*/
                }
                //取第一个sheet表
                Sheet sheet = workbook.getSheetAt(0);
                //存储图片信息及所在分页
                Map<Integer,PictureData> pictureDataMap = new HashMap<>();
                if(excelType == 1){ //.xls
                    HSSFPatriarch drawingPatriarch = ((HSSFSheet) sheet).getDrawingPatriarch();
                    if(drawingPatriarch!=null) {
                        List<HSSFShape> children = drawingPatriarch.getChildren();
                        for (HSSFShape child : children) {
                            HSSFPicture picture = (HSSFPicture) child;
                            HSSFPictureData pictureData = picture.getPictureData();
                            HSSFClientAnchor anchor = (HSSFClientAnchor) child.getAnchor();
                            //行,不能跨行;
                            int row1 = anchor.getRow1();
                            int row2 = anchor.getRow2();
                            if (row1 == row2) {
                                //不跨行,有效
                                pictureDataMap.put(row1, pictureData);
                            }
                        }
                    }
                }
                else if(excelType == 2){ //.xlsx
                    XSSFDrawing drawingPatriarch = ((XSSFSheet) sheet).getDrawingPatriarch();
                    if(drawingPatriarch!=null) {
                        List<XSSFShape> children = drawingPatriarch.getShapes();
                        for (XSSFShape child : children) {
                            XSSFPicture picture = (XSSFPicture) child;
                            XSSFPictureData pictureData = picture.getPictureData();
                            XSSFClientAnchor anchor = (XSSFClientAnchor) child.getAnchor();
                            //行,不能跨行;
                            int row1 = anchor.getRow1();
                            int row2 = anchor.getRow2();
                            if (row1 == row2) {
                                //不跨行,有效
                                pictureDataMap.put(row1, pictureData);
                            }
                        }
                    }
                }
                Set<Integer> pictureRowSet = new HashSet<>();
                if(!pictureDataMap.isEmpty()) {
                    pictureRowSet = pictureDataMap.keySet();
                }
                int lastRowNum = sheet.getLastRowNum();
                //取第三行,并以第三行开始
                Row row2 = sheet.getRow(1);
                //现在规定为17列
                short lastCellNum = row2.getLastCellNum();
                if(lastCellNum !=18){
                    return response.set(1, false, "上传文件的bom清单列数不对");
                }
                for (int k = 2; k < lastRowNum + 1; k++) {
                    if(k==2){
                        product.setParentCode(sheet.getRow(2).getCell(1).getStringCellValue());
                        if(!originalFilename.contains(product.getParentCode())){
                            return response.set(1,false,"上传的产品压缩包必须包含产品编码");
                        }
                        product.setParentName(sheet.getRow(2).getCell(2).getStringCellValue());
                        String parentModel = sheet.getRow(2).getCell(3).getStringCellValue();
                        parentModel = parentModel.trim();
                        String regexStr = "[\\/*?\"|:<>\t]";
                        boolean matches = Pattern.compile(regexStr).matcher(parentModel).find();
                        if(!matches) {
                            product.setParentModel(parentModel);
                        }else{
                            return response.set(1,false,"母料型号包含非法字符:\\/*?\"|:<>或前置空格");
                        }
                    }
                    ProductBom bom = new ProductBom();
                    for (int j = 0; j < lastCellNum; j++) {
                        Row row = sheet.getRow(k);
                        Cell cell = row.getCell(j);
                        String cellValue = null;
                        Double cellValueInt = 0d;
                        if (j == 9 || j == 0) { //1和10列为数值
                            cellValueInt = cell.getNumericCellValue();
                        } else if (j != 16) { //16列为图片
                            cellValue = cell.getStringCellValue();
                        }
                        if(cellValue!=null) {
                            cellValue = cellValue.trim();
                        }
                        switch (j) {
                            case 0: {
                                bom.setId(cellValueInt.intValue());
                            }
                            break;
                            case 4: {
                                bom.setCategory(cellValue);
                            }
                            break;
                            case 5: {
                                bom.setSubCode(cellValue);
                            }
                            break;
                            case 6: {
                                bom.setSubName(cellValue);
                            }
                            break;
                            case 7: {
                                bom.setSubModel(cellValue);
                                //判断图纸查看是否存在
                                bom.setDwgExist(0);
                                String dwgFileName = cellValue + ".dwg";
                                for (int n = 0; n < dwgExistsList.size(); n++) {
                                    FileUrlDTO fileUrlDTO = dwgExistsList.get(n);
                                    if (dwgFileName.toUpperCase().equals(fileUrlDTO.getFileName().toUpperCase())) {
                                        //存在
                                        bom.setDwgExist(1);
                                        bom.setDwgUrl(fileUrlDTO.getHttpFileUrl());
                                        break;
                                    }
                                }
                            }
                            break;
                            case 8: {
                                bom.setUnit(cellValue);
                            }
                            break;
                            case 9: {
                                bom.setQuantity(cellValueInt.intValue());
                            }
                            break;
                            case 10: {
                                bom.setProducer(cellValue);
                            }
                            break;
                            case 11: {
                                bom.setProducerSpecification(cellValue);
                            }
                            break;
                            case 12: {
                                bom.setMaterial(cellValue);
                            }
                            break;
                            case 13: {
                                bom.setThickness(cellValue);
                            }
                            break;
                            case 14: {
                                bom.setSurfaceDetail(cellValue);
                            }
                            break;
                            case 15: {
                                bom.setNotes(cellValue);
                            }
                            break;
                            case 16: {
                                /* 弃用,不适用于 图片不按顺序摆放情况
                                //图片,从0开始,到图片size为止
                                int m = k - 2;
                                if (m < allPictures.size()) {
                                    PictureData pictureData = allPictures.get(m);
                                    //图片存储 product_submit/username/2022-07/
                                    String approvingPath = rootFile + File.separator + "product_submit" + File.separator + user.getName() + File.separator + dateFormat + File.separator + timeStamp;
                                    File provingFile = new File(approvingPath);
                                    if (!provingFile.exists()) {
                                        provingFile.mkdirs();
                                    }
                                    String suffix = pictureData.suggestFileExtension();
                                    String picturePath = approvingPath + File.separator + bom.getSubModel() + "-bom." + suffix;
                                    String picturePathFront = "doc_file" + File.separator + "product_submit" + File.separator + user.getName() + File.separator + dateFormat + File.separator + timeStamp + File.separator + bom.getSubModel() + "-bom." + suffix;
                                    byte[] data = pictureData.getData();
                                    FileOutputStream fileOutputStream = null;
                                    File pictureFile = new File(picturePath);
                                    fileOutputStream = new FileOutputStream(pictureFile);
                                    fileOutputStream.write(data);

                                    bom.setPictureUrl(picturePathFront);
                                }*/
                                if (!pictureRowSet.isEmpty() && pictureRowSet.contains(k)) {

                                    PictureData pictureData = pictureDataMap.get(k);
                                    //判断物料型号是否包含非法字符(图片会转化为路径)
                                    if(bom.getSubModel()!=null) {
                                        String regexStr = "[\\/*?\"|:<>\t]";
                                        boolean matches = Pattern.compile(regexStr).matcher(bom.getSubModel()).find();
                                        if (matches) {
                                            return response.set(1, false, "型号为"+bom.getSubModel()+"的物料包含非法字符:\\/*?\"|:<>或前置空格");
                                        }
                                    }
                                    //图片存储 product_submit/username/2022-07/
                                    String approvingPath = rootFile + File.separator + "product_submit" + File.separator + user.getName() + File.separator + dateFormat + File.separator + timeStamp;
                                    File provingFile = new File(approvingPath);
                                    if (!provingFile.exists()) {
                                        provingFile.mkdirs();
                                    }
                                    String suffix = pictureData.suggestFileExtension();
                                    String picturePath = approvingPath + File.separator + bom.getSubModel() + "-bom." + suffix;
                                    String picturePathFront = "doc_file" + File.separator + "product_submit" + File.separator + user.getName() + File.separator + dateFormat + File.separator + timeStamp + File.separator + bom.getSubModel() + "-bom." + suffix;
                                    byte[] data = pictureData.getData();
                                    FileOutputStream fileOutputStream = null;
                                    File pictureFile = new File(picturePath);
                                    fileOutputStream = new FileOutputStream(pictureFile);
                                    fileOutputStream.write(data);

                                    bom.setPictureUrl(picturePathFront);
                                }
                            }
                            break;
                            case 17: {
                                if(cellValue!=null && !cellValue.trim().equals("")) {
                                    if(cellValue.contains(",") || cellValue.contains("，")){
                                        bom.setRelatedMaterialCodes(cellValue);
                                    }else{
                                        return response.set(1, false, "上传文件的bom清单内替料格式不对");
                                    }
                                }
                            }
                            break;
                        }
                    }
                    bomList.add(bom);
                }
                //追加物料规范校验 暂时去除这个功能
                /*List<MaterialCheckDTO> checkList = bomList.stream().map(bom->{
                    MaterialCheckDTO dto = new MaterialCheckDTO();
                    dto.setNum(bom.getId());
                    dto.setSubCode(bom.getSubCode());
                    dto.setSubName(bom.getSubName());
                    dto.setSubModel(bom.getSubModel());
                    return dto;
                }).collect(Collectors.toList());
                List<MaterialCheckDTO> irregularList = CommonUtil.checkFormat(checkList);
                if(irregularList.size()>0){
                    return response.setII(1,false,irregularList,"名称或型号命名不规范");
                }*/
                product.setBomList(bomList);
            }
        }
        //产品bom对比
        Map<String,List> compareMap = pbhService.parseCompare(baseProduct,product);
        //return response.setIII(1, true, product,compareMap, filePath);
        return response.setIII(1, true, product,compareMap, zipFile.toString());

    }

    private List<FileUrlDTO> getDwgList(List<String> fileList) {
        List<FileUrlDTO> list = new LinkedList<>();
        fileList.forEach(fileUrl->{
            if(fileUrl.substring(fileUrl.lastIndexOf(".")+1).equals("dwg")) {
                FileUrlDTO dto = new FileUrlDTO();
                dto.setFileName(fileUrl.substring(fileUrl.lastIndexOf(File.separator) + 1));
                dto.setHttpFileUrl(fileUrl.substring(fileUrl.lastIndexOf("doc_file" + File.separator + "product_submit")));
                list.add(dto);
            }
        });
        return list;
    }

    /**
     * 这个接口是进行产品新增,产品bom新增的接口.
     * 新增方式有很多,有直接从zip解析新增产品,也可以基于原有产品复制进行定制等.需要注意兼容!
     * @param product 产品新增,bom新增,产品版本更新
     * @return
     * @throws IOException
     */
    @Transactional(rollbackFor = {RuntimeException.class,Exception.class})
    public Response add(Product product) throws IOException {
        String parentCode = product.getParentCode();
        String customCode = product.getCustomCode();
        String parentModel = product.getParentModel();
        List<ProductBom> bomList = product.getBomList();
        String zipFilePath = product.getFileUrl();
        Date date = new Date();
        String dateStr = DateUtil.YYYY_MM_DD_HH_MM_SS_UNION.format(date);
        Long userId = ActionUtil.getUser().getId();
        boolean isCopyCustom = false;
        Product relatedProduct = null;
        //校验凡是有定制表单号的产品，不能使用已上传过的标准产品编码
        if(customCode!=null && !customCode.trim().equals("")){
            ProductHistory standard = phService.getStandard(parentCode);
            if(standard !=null){
                return new Response().set(1,false,"系统存在此次母物料编码的标准产品,拒绝提交");
            }
        }
        //判断是否为依据产品复制定制的产品
        if(bomList == null){
            bomList = pbService.getBomByProductId(product.getId());
            isCopyCustom = true;
        }else{
            if(product.getId() != null){ //关联关系从产品id继承
                relatedProduct = getById(product.getId());
            }
        }
        //不是基于产品复制,则必定存在zip包,必然存在路径
        String fileUrl = null;
        if(!isCopyCustom) {
            fileUrl = zipFilePath.substring(0, zipFilePath.lastIndexOf(File.separator));
        }
        //查询新增产品最新的版本号
        ProductHistory latestProduct = phService.getLatestVersion(parentCode, customCode);
        ProductHistory enabledProduct = phService.getEnabledByParentCodeAndCustomCode(parentCode, customCode);
        int currentVersion = 0;
        if (latestProduct != null) {
            currentVersion = latestProduct.getVersion();
        }
        Integer nextVersion = currentVersion + 1;
        //产品物料关系迁移
        //查询生效版本的关联关系
        Product copyCustomProduct = null;
        if(isCopyCustom){
            //查询产品对应的关联关系
            copyCustomProduct = getById(product.getId());
            List<MaterialProductHistory> relatedList = mphService.getListByParentCodeAndCustomCodeAndVersion(copyCustomProduct.getParentCode(), copyCustomProduct.getCustomCode(), copyCustomProduct.getVersion());
            relatedList.forEach(related->{
                related.setCustomCode(product.getCustomCode());
                related.setSVersion(nextVersion);
                related.setEVersion(nextVersion);
                related.setCreateTime(date);
            });
            if(relatedList.size()!=0){
                mphService.insertBatch(relatedList);
            }
        }else {
            if(relatedProduct == null
                || (relatedProduct.getParentCode().equals(product.getParentCode())
                && relatedProduct.getCustomCode().equals(product.getCustomCode())
                )
            ) { //属于是产品升级或基于标准产品定制
                List<MaterialProductHistory> mpList = new LinkedList<>();
                if (latestProduct != null && enabledProduct != null) { //产品升级
                    mpList = mphService.getListByParentCodeAndCustomCodeAndVersion(parentCode, customCode, enabledProduct.getVersion());
                }else{ //基于标准产品定制/新添加标准产品
                    Product version = getVersion(parentCode, "");
                    if(version!=null) { //新添加标准产品
                        int standardEnabledVersion = version.getVersion();
                        mpList = mphService.getListByParentCodeAndCustomCodeAndVersion(parentCode, "", standardEnabledVersion);
                    }
                }
                if (mpList.size() != 0) { //存在关联关系
                    //当前的产品bom明细包含 继承的产品子件物料,继承关系保留
                    //设置mpList关联的物料详细信息
                    mpList = mphService.getListWithMaterialInfo(mpList);
                    List<String> newBomMaterialStrList = bomList.stream().map(bom -> bom.getSubCode() + "/" + bom.getSubModel()).collect(Collectors.toList());
                    mpList = mpList.stream().filter(mp -> newBomMaterialStrList.contains(mp.getSubMaterial().getSubCode() + "/" + mp.getSubMaterial().getSubModel())).collect(Collectors.toList());
                    if(mpList.size()!=0) {
                        if ((latestProduct !=null && enabledProduct!=null) && latestProduct.getVersion().intValue() == enabledProduct.getVersion()) {
                            //最新版本生效,关联关系版本连着的
                            mphService.updateVersionBatch(mpList);
                        } else {
                            //关联关系版本不连着,生成新纪录:包含 升级和基于标准产品定制
                            if(customCode.equals("")) {
                                mpList.forEach(mp -> {
                                    mp.setSVersion(nextVersion);
                                    mp.setEVersion(nextVersion);
                                    mp.setCreateTime(date);
                                });
                            }else{
                                mpList.forEach(mp -> {
                                    mp.setCustomCode(customCode);
                                    mp.setSVersion(nextVersion);
                                    mp.setEVersion(nextVersion);
                                    mp.setCreateTime(date);
                                });
                            }
                            mphService.insertBatch(mpList);
                        }
                    }
                }
            }else{ //属于不同产品继承关联关系
                List<MaterialProductHistory> mpList = mphService.getListByParentCodeAndCustomCodeAndVersion(relatedProduct.getParentCode(), relatedProduct.getCustomCode(), relatedProduct.getVersion());
                if(mpList.size()!=0) {
                    //当前的产品bom明细包含 继承的产品子件物料,保留
                    //设置mpList关联的物料详细信息
                    mpList = mphService.getListWithMaterialInfo(mpList);
                    List<String> newBomMaterialStrList = bomList.stream().map(bom -> bom.getSubCode() + "/" + bom.getSubModel()).collect(Collectors.toList());
                    mpList = mpList.stream().filter(mp -> newBomMaterialStrList.contains(mp.getSubMaterial().getSubCode() + "/" + mp.getSubMaterial().getSubModel())).collect(Collectors.toList());
                    if(mpList.size()!=0) {
                        mpList.forEach(mp -> {
                            mp.setParentCode(parentCode);
                            mp.setCustomCode(customCode);
                            mp.setSVersion(nextVersion);
                            mp.setEVersion(nextVersion);
                            mp.setCreateTime(date);
                        });
                        mphService.insertBatch(mpList);
                    }
                }
            }
        }

        //查询是否bomList中有替料
        // 有的话,检查关联表中是否已存在或本版本已生效
        List<MaterialProductHistory> newAddedList = new LinkedList<>();
        List<MaterialProductHistory> versionUpdateList = new LinkedList<>();

        List<MaterialProductHistory> mpListInDB = mphService.getListByParentCodeAndCustomCodeAndSubMaterialIdAndVersion(parentCode,customCode,bomList,currentVersion);
        List<String> subMaterialListInDB = mpListInDB.stream().map(mp->mp.getSubMaterial().getSubCode()+"_"+mp.getSubMaterial().getSubModel()).collect(Collectors.toList());
        bomList.forEach(bom->{
            if(bom.getRelatedMaterialCodes()!=null) {
                String relatedMaterialCodes = bom.getRelatedMaterialCodes().trim();
                if (!relatedMaterialCodes.equals("")) {
                    if(subMaterialListInDB!=null&&subMaterialListInDB.size()>0){
                        if (subMaterialListInDB.contains(bom.getSubCode()+"_"+bom.getSubModel())) { //当前物料有替代料
                            String[] relatedList;
                            if (relatedMaterialCodes.contains(",")) {
                                relatedList = relatedMaterialCodes.split(",");
                            } else {
                                relatedList = relatedMaterialCodes.split("，");
                            }
                            for (String related : relatedList) {
                                bom.setRelatedMaterialCodes(related);
                                boolean exists = false;
                                for (MaterialProductHistory mp : mpListInDB) {
                                    //物料相同,替代料相同
                                    if ((mp.getSubMaterial().getSubCode()+"_"+mp.getSubMaterial().getSubModel()).equals(bom.getSubCode()+"_"+bom.getSubModel())
                                            && mp.getRelatedSubMaterial().getSubCode().equals(related)) {
                                        //只可能存在0 和 1 的情况,因为查询的是 >=上个版本
                                        if (nextVersion - mp.getEVersion() == 0) { //已存在,无需添加
                                            //break;
                                        } else if (nextVersion - mp.getEVersion() == 1) {  //更新到当前版本
                                            mp.setEVersion(nextVersion);
                                            versionUpdateList.add(mp);
                                        }
                                        exists = true;
                                    }
                                }
                                if(!exists) { //不存在相邻及相同的记录版本,新增
                                    MaterialProductHistory newTemp = new MaterialProductHistory();
                                    newTemp.setParentCode(parentCode);
                                    newTemp.setCustomCode(customCode);
                                    newTemp.setSubCode(bom.getSubCode());
                                    Material material = mService.getByCodeAndModel(bom.getSubCode(), bom.getSubModel(),true);
                                    newTemp.setSubMaterialId(material.getId());
                                    newTemp.setSVersion(nextVersion);
                                    newTemp.setEVersion(nextVersion);
                                    newTemp.setQuantity(bom.getQuantity());
                                    //2323-09-08 与杨红兰微信确认<就按照我上传清单的时间，系统里最新的是啥型号，就取什么型号>
                                    Material relatedMaterial = mService.getLastByCode(related);
                                    if(relatedMaterial == null){
                                        throw new RuntimeException("当前替料"+related+",编码在平台中不存在,无法关联替代");
                                    }
                                    newTemp.setMaterialId(relatedMaterial.getId());
                                    newTemp.setCreateTime(date);
                                    newAddedList.add(newTemp);
                                }
                            }
                        }
                        else{
                            String[] relatedList;
                            if (relatedMaterialCodes.contains(",")) {
                                relatedList = relatedMaterialCodes.split(",");
                            } else {
                                relatedList = relatedMaterialCodes.split("，");
                            }
                            for (String related : relatedList) {
                                MaterialProductHistory newTemp = new MaterialProductHistory();
                                newTemp.setParentCode(parentCode);
                                newTemp.setCustomCode(customCode);
                                newTemp.setSubCode(bom.getSubCode());
                                Material material = mService.getByCodeAndModel(bom.getSubCode(), bom.getSubModel(),true);
                                newTemp.setSubMaterialId(material.getId());
                                newTemp.setSVersion(nextVersion);
                                newTemp.setEVersion(nextVersion);
                                newTemp.setQuantity(bom.getQuantity());
                                //2323-09-08 与杨红兰微信确认<就按照我上传清单的时间，系统里最新的是啥型号，就取什么型号>
                                Material relatedMaterial = mService.getLastByCode(related);
                                if(relatedMaterial == null){
                                    throw new RuntimeException("当前替料"+related+",编码在平台中不存在,无法关联替代");
                                }
                                newTemp.setMaterialId(relatedMaterial.getId());
                                newTemp.setCreateTime(date);
                                newAddedList.add(newTemp);
                            }
                        }
                    }
                }
            }
        });
        //执行更新
        if(newAddedList.size()!=0) {
            mphService.insertBatch(newAddedList);
        }
        if(versionUpdateList.size()!=0) {
            mphService.updateVersionBatch(versionUpdateList);
        }


        //将产品文件复制至正式路径
        //文件转移,未跟子件挂钩的所有图纸图片转移到产品版本下:doc_file/product/{产品型号}/standard或者{customCode}}/{version}/
        //跟子件挂钩的转移到子件图纸下:doc_file/material/
        if(isCopyCustom){
            //product下的图纸复制到新的路径
            String rootFile = CommonUtil.getRootFile();
            String customStr = copyCustomProduct.getCustomCode().equals("")?"standard":copyCustomProduct.getCustomCode();
            String fromDir = rootFile + "product" + File.separator + product.getParentModel() + File.separator + customStr + File.separator + copyCustomProduct.getVersion();
            String toDir = rootFile + "product" + File.separator + product.getParentModel() + File.separator + product.getCustomCode() + File.separator + 1;
            org.aspectj.util.FileUtil.copyDir(new File(fromDir),new File(toDir));
            //product_history/product/bom/bom_history
            // -> his
            ProductHistory his = new ProductHistory();
            his.setParentCode(product.getParentCode());
            his.setParentName(product.getParentName());
            his.setParentModel(product.getParentModel());
            his.setCustomCode(product.getCustomCode());
            his.setCreateTime(date);
            his.setVersionTime(product.getVersionTime());
            his.setVersion(1);
            his.setSubVersionMax(1);
            //上传后的最初始使能状态为-1
            //第一次解锁后,后续的锁定和解锁在0和1之间切换
            his.setEnabled(-1);
            phService.insertAndUpdateEnabled(his);
            //phService.insert(his);
            // -> product 现有产品和产品bom需要插入,version默认为-1,同时要做删除原来的旧版本
            product.setId(his.getId());
            product.setCreateTime(date);
            product.setVersion(-1);
            deleteAndInsert(product);
            // -> bom
            bomList.forEach(bom-> {
                bom.setProductId(product.getId());
                bom.setSubVersion(1);
            });
            pbService.insertBatch(bomList);
            // -> bom_his
            List<ProductBomHistory> bomHistoryList = new LinkedList<>();
            bomList.forEach(bom->{
                ProductBomHistory bomHistory = new ProductBomHistory();
                bomHistory.setProductId(his.getId());
                bomHistory.setMaterialId(bom.getMaterialId());
                bomHistory.setQuantity(bom.getQuantity());
                bomHistory.setCategory(bom.getCategory());
                bomHistory.setMaterial(bom.getMaterial());
                bomHistory.setNotes(bom.getNotes());
                bomHistory.setProducer(bom.getProducer());
                bomHistory.setProducerSpecification(bom.getProducerSpecification());
                bomHistory.setSurfaceDetail(bom.getSurfaceDetail());
                bomHistory.setThickness(bom.getThickness());
                bomHistory.setSubSVersion(1);
                bomHistory.setSubEVersion(1);
                bomHistoryList.add(bomHistory);
            });
            pbhService.insertBatch(bomHistoryList);
        }else {
            File file = new File(fileUrl);
            List<String> fileUrlList = new LinkedList<>();
            List<String> excelExcludeUrlList = null;
            List<String> picUrlList = new LinkedList<>();
            //存于物料下,bom内有对应
            List<String> materialUrlList = new LinkedList<>();
            //存于产品下,bom内没对应
            List<String> productUrlList = new LinkedList<>();

            //List<Material> materialDwgUrlNameList = new LinkedList<>();

            fileUrlList = FileUtil.getStaticFilePath(file, fileUrlList);
            //图纸dwg 子件/产品
            excelExcludeUrlList = fileUrlList.stream().filter(url -> !(url.contains(".xls") || url.contains(".xlsx"))).collect(Collectors.toList());
            //picUrlList = fileUrlList.stream().filter(url -> url.contains(".png") || url.contains(".jpeg")).collect(Collectors.toList());

            List<ProductBom> finalBomList = bomList;
            excelExcludeUrlList.forEach(excelExcludeUr -> {
                boolean existFlag = false;
                for (ProductBom bom : finalBomList) {
                    String filename = excelExcludeUr.substring(excelExcludeUr.lastIndexOf(File.separator) + 1, excelExcludeUr.lastIndexOf("."));
                    String fileFullName = excelExcludeUr.substring(excelExcludeUr.lastIndexOf(File.separator) + 1);
                    String fileSuffix = fileFullName.substring(fileFullName.lastIndexOf("."));
                    if (bom.getSubModel().toUpperCase().equals(filename.toUpperCase()) && excelExcludeUr.substring(excelExcludeUr.lastIndexOf(".")+1).equals("dwg")) {
                        materialUrlList.add(excelExcludeUr);
                        existFlag = true;


                        bom.setDwgUrl("doc_file" + File.separator + "material" + File.separator + bom.getSubCode() + "-" + bom.getSubModel()
                                + File.separator + filename + "_" + dateStr + fileSuffix);
                        break;
                    }
                    else if((bom.getSubModel().toUpperCase()+"-BOM").equals(filename.toUpperCase()) && (excelExcludeUr.substring(excelExcludeUr.lastIndexOf(".")+1).equals("png") ||excelExcludeUr.substring(excelExcludeUr.lastIndexOf(".")+1).equals("jpeg"))
                    ){
                        picUrlList.add(excelExcludeUr);
                        existFlag = true;


                        bom.setPictureUrl("doc_file" + File.separator + "material" + File.separator + bom.getSubCode() + "-" + bom.getSubModel()
                                + File.separator + filename + "_" + dateStr + fileSuffix);
                        break;
                    }
                }
                if (!existFlag) {
                    productUrlList.add(excelExcludeUr);
                }
            });

            /*//一定是有对应物料的,包含从bom内剥离的(删除掉:上面已经处理)
            picUrlList.forEach(picUrl -> {
                for (ProductBom bom : finalBomList) {
                    String filename = picUrl.substring(picUrl.lastIndexOf(File.separator) + 1, picUrl.lastIndexOf("."));
                    String fileFullName = picUrl.substring(picUrl.lastIndexOf(File.separator) + 1);
                    if ((bom.getSubModel().toUpperCase()+"-BOM").equals(filename.toUpperCase())) {
                        bom.setPictureUrl("doc_file" + File.separator + "material"
                                + File.separator + fileFullName);
                        break;
                    }
                }
            });*/

            //转移路径
            String projectDir = CommonUtil.getProjectDir();
            //doc_file/product/{产品型号}/standard或者{customCode}}/{version}/
            //跟子件挂钩的转移到子件图纸下:doc_file/material/
            String customCodeString = null;
            if (customCode != null && !customCode.equals("")) {
                customCodeString = customCode;
            } else {
                customCodeString = "standard";
            }
            String productDir = projectDir + File.separator + "doc_file" + File.separator + "product" + File.separator + parentModel
                    + File.separator + customCodeString + File.separator + nextVersion;
            String materialDir = projectDir + File.separator + "doc_file" + File.separator + "material";
            File productDirFile = new File(productDir);
            File materialFile = new File(materialDir);
            if (!productDirFile.exists()) {
                productDirFile.mkdirs();
            }
            if (!materialFile.exists()) {
                materialFile.mkdirs();
            }
            //之前上传的产品bom压缩包,转移到正式版本下留存
            File zipFileNew = new File(productDir + File.separator + zipFilePath.substring(zipFilePath.lastIndexOf(File.separator) + 1));
            FileCopyUtils.copy(new File(zipFilePath), zipFileNew);

            productUrlList.forEach(productUrl -> {
                String fileName = productUrl.substring(productUrl.lastIndexOf(File.separator) + 1);

                try {
                    FileCopyUtils.copy(new File(productUrl), new File(productDir + File.separator + fileName));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            //物料dwg图纸存到对应的 物料编码+型号 下面
            for (String materialUrl : materialUrlList) {
                try {
                    String dwgName = materialUrl.substring(materialUrl.lastIndexOf(File.separator) + 1, materialUrl.length() - 4);
                    //确定物料的具体型号
                    String subModel = null;
                    String subCode = null;
                    for (ProductBom bom : bomList) {
                        String bomSubMode = bom.getSubModel();
                        if (bomSubMode.toUpperCase().equals(dwgName.toUpperCase())) {
                            subModel = bomSubMode;
                            subCode = bom.getSubCode();
                            break;
                        }
                    }
                    File dwgFile;
                    if (subModel != null) {
                        dwgFile = new File(materialDir + File.separator + subCode + "-" + subModel + File.separator + dwgName + "_" + dateStr + ".dwg");
                        File dwgDir = new File(materialDir + File.separator + subCode + "-" + subModel);
                        if(!dwgDir.exists()){
                            dwgDir.mkdirs();
                        }
                    } else {
                        dwgFile = new File(materialDir + File.separator + dwgName + "_" + dateStr + ".dwg");
                    }
                    if (!dwgFile.exists()) {
                        FileCopyUtils.copy(new File(materialUrl), dwgFile);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            for (String picUrl : picUrlList) {
                String picFullName = picUrl.substring(picUrl.lastIndexOf(File.separator) + 1);
                String picSubModel = picFullName.substring(0, picFullName.lastIndexOf("."));
                String picSuffix = picFullName.substring(picFullName.lastIndexOf("."));
                try {
                    //确定物料的具体型号和编码
                    String subModel = null;
                    String subCode = null;
                    for (ProductBom bom : bomList) {
                        String bomSubMode = bom.getSubModel();
                        if ((bomSubMode + "-bom").toUpperCase().equals(picSubModel.toUpperCase())) {
                            subModel = bomSubMode;
                            subCode = bom.getSubCode();
                            break;
                        }
                    }
                    File picFile;
                    if (subModel != null) {
                        picFile = new File(materialDir + File.separator + subCode + "-" + subModel + File.separator + picSubModel + "_" + dateStr + picSuffix);
                        File picDir = new File(materialDir + File.separator + subCode + "-" + subModel);
                        if(!picDir.exists()){
                            picDir.mkdirs();
                        }
                    } else {
                        picFile = new File(materialDir + File.separator + picSubModel + "_" + dateStr + picSuffix);
                    }
                    if (!picFile.exists()) {
                        FileCopyUtils.copy(new File(picUrl), picFile);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            //物料表中不存在的(依据:物料编码+物料型号),则添加到物料表中去(包含product这个物料)
            //更新图纸和图片
            List<Material> materialExistList = mService.getListByCodeAndModelList2(bomList);
            //List<String> subCodeList = materialExistList.stream().map(Material::getSubCode).collect(Collectors.toList());
            List<String> subCodeList = materialExistList.stream().map(material -> material.getSubCode()+"/"+material.getSubModel()).collect(Collectors.toList());
            //需要更新到物料表中的物料(存在图纸或者图片)
            List<MaterialHistory> materialHistoryList = new LinkedList<>();
            //新物料
            List<Material> newMaterialList = new LinkedList<>();
            //判断物料是否已经存在于物料表中
            List<Material> materialUpdateList = new LinkedList<>();
            for (ProductBom bom : bomList) {
                if (!subCodeList.contains(bom.getSubCode() + "/" + bom.getSubModel())) {
                    Material material = new Material();
                    material.setCreateDate(date);
                    material.setDwgUrl(bom.getDwgUrl());
                    material.setFileUrl(bom.getFileUrl());
                    material.setPictureUrl(bom.getPictureUrl());
                    material.setStatus(1);
                    material.setSubCode(bom.getSubCode());
                    material.setSubModel(bom.getSubModel());
                    material.setSubName(bom.getSubName());
                    material.setType(bom.getType());
                    material.setUnit(bom.getUnit());
                    material.setUpUserId(userId);

                    newMaterialList.add(material);
                } else { //物料已经存在的
                    // 物料历史表是为了存储物料的历史图片和dwg图纸
                    Material material = new Material();
                    if (bom.getPictureUrl() != null) {
                        material.setPictureUrl(bom.getPictureUrl());
                    }
                    if (bom.getDwgUrl() != null) {
                        material.setDwgUrl(bom.getDwgUrl());
                    }
                    if (material.getPictureUrl() != null || material.getDwgUrl() != null) {
                        material.setSubCode(bom.getSubCode());
                        material.setSubModel(bom.getSubModel());
                        materialUpdateList.add(material);
                    }
                }
            }
            //对新增到物料表中的物料,根据 物料编码+物料型号 进行去重处理
            newMaterialList = newMaterialList.stream().filter(distinctByKey(m->m.getSubCode()+"/"+m.getSubModel())).collect(Collectors.toList());

            //母料是否存在
            Material materialDB = mService.getByCodeAndModel(product.getParentCode(), product.getParentModel(),true);
            if (materialDB == null) {
                Material material = new Material();
                material.setSubCode(product.getParentCode());
                material.setSubName(product.getParentName());
                material.setSubModel(product.getParentModel());
                material.setCreateDate(date);
                material.setStatus(1);
                material.setUpUserId(userId);

                newMaterialList.add(material);
            }
            if(newMaterialList.size()!=0) {
                mService.insertBatch(newMaterialList);
            }
            if(materialUpdateList.size()!=0) {
                mService.updateDwgUrlAndPicUrl(materialUpdateList);
            }
            //更新product_history/product_bom_history/product/product_bom,
            // product的主键沿用对应product_history的
            //根据编码和型号确定物料id并对应quantity,存入数据库.
            //List<Material> bomMaterialList = mService.getListByCodeAndModelList2(bomList);
            //List<ProductBom> bomMaterialList = pbService.getListByCodeAndModelList2(bomList);
            List<Material> existMaterialListWithSameSubCodeAndModel = mService.getSameSubCodeAndModel(bomList);
            List<ProductBom> bomMaterialList;
            bomList.forEach(bom->{
                String codeModelUnionStr = bom.getSubCode() + "/" + bom.getSubModel();
                for (int i = 0; i < existMaterialListWithSameSubCodeAndModel.size(); i++) {
                    Material materialExists = existMaterialListWithSameSubCodeAndModel.get(i);
                    if(codeModelUnionStr.equals(materialExists.getSubCode() + "/" + materialExists.getSubModel())){
                        bom.setId(materialExists.getId());
                        break;
                    }
                }
            });
            bomMaterialList = bomList;
            // -> product_history
            ProductHistory productHistory = new ProductHistory();
            productHistory.setParentCode(product.getParentCode());
            productHistory.setParentName(product.getParentName());
            productHistory.setParentModel(product.getParentModel());
            productHistory.setNotes(product.getNotes());
            productHistory.setCustomCode(product.getCustomCode());
            productHistory.setCreateTime(date);
            productHistory.setVersionTime(product.getVersionTime());
            productHistory.setVersion(nextVersion);
            //版本新增,初始bom子件版本为1
            productHistory.setSubVersionMax(1);

            productHistory.setEnabled(-1);
            phService.insertAndUpdateEnabled(productHistory);
            // -> product 现有产品和产品bom需要插入,version默认为-1,同时要做删除原来的旧版本
            product.setId(productHistory.getId());
            product.setCreateTime(date);
            product.setVersion(-1);
            deleteAndInsert(product);
            // -> product_bom
            List<ProductBom> productBomList = new LinkedList<>();
            bomMaterialList.forEach(bomMaterial -> {
                ProductBom bom = new ProductBom();
                bom.setProductId(product.getId());
                bom.setMaterialId(bomMaterial.getId());
                bom.setQuantity(bomMaterial.getQuantity());
                bom.setCategory(bomMaterial.getCategory());
                bom.setMaterial(bomMaterial.getMaterial());
                bom.setNotes(bomMaterial.getNotes());
                bom.setProducer(bomMaterial.getProducer());
                bom.setProducerSpecification(bomMaterial.getProducerSpecification());
                bom.setSurfaceDetail(bomMaterial.getSurfaceDetail());
                bom.setThickness(bomMaterial.getThickness());
                bom.setSubVersion(1);
                bom.setCreateDate(date);

                productBomList.add(bom);
            });
            pbService.insertBatch(productBomList);
            // -> product_bom_history
            List<ProductBomHistory> bomHistoryList = new LinkedList<>();
            bomMaterialList.forEach(bomMaterial -> {
                ProductBomHistory bomHistory = new ProductBomHistory();
                bomHistory.setProductId(productHistory.getId());
                bomHistory.setMaterialId(bomMaterial.getId());
                bomHistory.setQuantity(bomMaterial.getQuantity());
                bomHistory.setCategory(bomMaterial.getCategory());
                bomHistory.setMaterial(bomMaterial.getMaterial());
                bomHistory.setNotes(bomMaterial.getNotes());
                bomHistory.setProducer(bomMaterial.getProducer());
                bomHistory.setProducerSpecification(bomMaterial.getProducerSpecification());
                bomHistory.setSurfaceDetail(bomMaterial.getSurfaceDetail());
                bomHistory.setThickness(bomMaterial.getThickness());
                bomHistory.setSubSVersion(1);
                bomHistory.setSubEVersion(1);
                bomHistory.setCreateDate(date);

                bomHistoryList.add(bomHistory);
            });
            pbhService.insertBatch(bomHistoryList);
            //插入到物料历史表的,
            // 包含新物料包含图纸图片的,
            // 也包含旧物料包含图纸图片的
            if(newMaterialList.size()>0){
                for (Material material : newMaterialList) {
                    //存在图纸或者图片,就插入历史
                    if(material.getDwgUrl()!=null || material.getPictureUrl()!=null) {
                        MaterialHistory materialHistory = new MaterialHistory();
                        materialHistory.setPictureUrl(material.getPictureUrl());
                        materialHistory.setProductId(productHistory.getId());
                        materialHistory.setDwgUrl(material.getDwgUrl());
                        materialHistory.setUpUserId(userId.intValue());
                        materialHistory.setCreateTime(date);
                        materialHistory.setMaterialId(material.getId());
                        materialHistoryList.add(materialHistory);
                    }
                }
            }
            if(materialUpdateList.size()>0) {
                //更新物料图纸图片的同时,添加新的图纸图片信息到物料历史表中
                for (Material material : materialUpdateList) {
                    MaterialHistory materialHistory = new MaterialHistory();
                    materialHistory.setPictureUrl(material.getPictureUrl());
                    materialHistory.setProductId(productHistory.getId());
                    materialHistory.setDwgUrl(material.getDwgUrl());
                    materialHistory.setUpUserId(userId.intValue());
                    materialHistory.setCreateTime(date);
                    for (Material materialInDB : materialExistList) {
                        if ((material.getSubCode() + "/" + material.getSubModel()).equals(materialInDB.getSubCode() + "/" + materialInDB.getSubModel())) {
                            materialHistory.setMaterialId(materialInDB.getId());
                            break;
                        }
                    }
                    materialHistoryList.add(materialHistory);
                }
            }
            if(materialHistoryList.size()>0) {
                materialHistoryService.addBatch(materialHistoryList);
            }
            //如果新上传的bom中存在0108、0109开头的物料,(肯定会被识别成新物料,之前的操作已经被插入到表中)
            // 在数据库存在相同的物料编码存在且不同的物料型号,则将数据库最新的物料的附件复制一份并状态同步,填充到新的物料表中
            for (Material material : newMaterialList) { //新物料
                String subCode = material.getSubCode();
                String subModel = material.getSubModel();
                if(subCode.startsWith("0108") || subCode.startsWith("0109")){
                    Material materialWithSameCodeLatest = mService.getByCodeAndModel(subCode, subModel, false);
                    if(materialWithSameCodeLatest!=null){
                        //附件转移并设置
                        mService.transferCopiedAttachment(materialWithSameCodeLatest,material);
                    }
                }
            }

        }
        //添加新增日志到tb_product_lock_log表
        ProductLockLog lockLog = new ProductLockLog();
        lockLog.setParentCode(parentCode);
        lockLog.setCustomCode(customCode);
        lockLog.setVersion(nextVersion);
        lockLog.setVersionTime(DateUtil.YYYY_MM_DD_HH_MM_SS.format(product.getVersionTime()));
        lockLog.setReason("产品bom上传");
        lockLog.setOwner(ActionUtil.getUser().getName());
        lockLog.setCreateTime(date);
        //-1代表日志类型为:产品bom上传
        lockLog.setLockFlag(-1);

        productLockLogService.insert(lockLog);
        return new Response().set(1,true,"新增完成");
    }

    private void deleteAndInsert(Product product) {
        Product productDB = getByProductCodeAndCustomCode(product.getParentCode(), product.getCustomCode());
        if(productDB!=null) {
            mapper.deleteById(productDB.getId());
            pbService.deleteByProductId(productDB.getId());
        }
        mapper.insert(product);
    }

    private void delete(Product product) {
        Product productDB = getByProductCodeAndCustomCode(product.getParentCode(), product.getCustomCode());
        if(productDB!=null) {
            mapper.deleteById(productDB.getId());
            pbService.deleteByProductId(productDB.getId());
        }
    }

    private Product getByProductCodeAndCustomCode(String parentCode, String customCode) {
        QueryWrapper<Product> query = Wrappers.query();
        query.eq("parent_code",parentCode).eq("custom_code",customCode).last(" limit 1");
        return mapper.selectOne(query);
    }
    //查询出所有的产品无参不分页（产品上传的是用）
    public Response getUpBomUseProduct() {
        List list=mapper.selectList(null);
        return new Response().setII(1,list.size()>0,list,"");
    }
    //根据产品id查询被锁定的物料dwg和产品丝印
    public Response getLockedByProductId(int productId) {
        List listMaterial=mapper.selectListMaterial(productId);
        List listProduct=mapper.selectListProduct(productId);
        return new Response().setIII(1,listMaterial.size()>0||listProduct.size()>0,listMaterial,listProduct,"");
    }

    //反馈管理-查询所有的产品
    public Response getFkProduct() {
        //QueryWrapper wrapper=new QueryWrapper();
        //wrapper.ne("version",-1);
        List list=mapper.selectList(null);
        return new Response().setII(1,list.size()>0,list,"反馈管理-查询所有的产品");
    }

    //产品对比下拉选中
    public Response getCompareProduct() {
        List list=mapper.selectList(null);
        return new Response().setII(1,list.size()>0,list,"产品对比下拉选中-查询当前使用的所有的产品");
    }
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return object -> seen.putIfAbsent(keyExtractor.apply(object), Boolean.TRUE) == null;
    }
    //验证母料编码是否存在产品中
    public Response judgeParentCode(String parentCode,String customCode) {
        int count = mapper.judgeParentCode(parentCode,customCode);
        return  new Response().set(1,count>0,"验证母料编码是否存在产品中");
    }
}