package com.ruoyi.basic.service.impl; import com.alibaba.fastjson.JSON; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.*; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.ruoyi.basic.dto.*; import com.ruoyi.basic.enums.StandardProductListChcekTypeEnums; import com.ruoyi.basic.mapper.*; import com.ruoyi.basic.pojo.*; import com.ruoyi.basic.service.StandardMethodListService; import com.ruoyi.basic.service.StandardProductListSupplierAskService; import com.ruoyi.common.exception.base.BaseException; import com.ruoyi.common.utils.SecurityUtils; import com.ruoyi.basic.service.StandardProductListService; import lombok.AllArgsConstructor; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; /** * @author Administrator * @description 针对表【standard_product_list(标准树下的检验项目)】的数据库操作Service实现 * @createDate 2024-03-05 10:33:29 */ @Service @AllArgsConstructor public class StandardProductListServiceImpl extends ServiceImpl implements StandardProductListService { private StandardProductListMapper standardProductListMapper; private StandardTreeMapper standardTreeMapper; private IfsInventoryQuantityMapper ifsInventoryQuantityMapper; private StandardProductListSupplierAskMapper standardProductListSupplierAskMapper; private ProductPartMapper productPartMapper; private StructureTestObjectPartMapper structureTestObjectPartMapper; private StandardMethodListService standardMethodListService; private StructureItemParameterMapper structureItemParameterMapper; private ModelMapper modelMapper; private StandardProductListBackupRelMapper standardProductListBackupRelMapper; private StandardProductListUpdateRecordMapper standardProductListUpdateRecordMapper; private StandardProductListUpdateRecordRelMapper standardProductListUpdateRecordRelMapper; private StandardProductListSupplierAskService standardProductListSupplierAskService; private StandardProductListSupplierAskBackupRelMapper standardProductListSupplierAskBackupRelMapper; private StandardMethodMapper standardMethodMapper; @Override public int upStandardProductList(StandardProductList list) { // 根据id 查询到原始值 StandardProductList standardProductList = standardProductListMapper.selectById(list.getId()); if (ObjectUtils.isEmpty(standardProductList)) { throw new RuntimeException("更新失败,未查找到检查项"); } // 判断当前状态 如果是审核中 if (StandardProductListChcekTypeEnums.CHECK_ING.getCode().equals(list.getCheckStatus())) { throw new RuntimeException("审核中不支持修改"); } // 判断检验项是否为是否委托要求 是的话不需要做备份和状态修改直接更新 StructureItemParameter structureItemParameter = structureItemParameterMapper.selectById(standardProductList.getStructureItemParameterId()); if (!ObjectUtils.isEmpty(structureItemParameter) && "1".equals(structureItemParameter.getDelegateRequestFlag())) { return standardProductListMapper.updateById(list); } // 判断是否为生效的修改如果是不做备份 if (null != list.getState()) { return standardProductListMapper.updateById(list); } // 查询最新的一次关联备份 如果存在说明未审核完继续修改了。不做数据处理。 StandardProductListBackupRel standardProductListBackupRel = standardProductListBackupRelMapper.selectById(list.getId()); if (ObjectUtils.isEmpty(standardProductListBackupRel)) { StandardProductListBackupRel productListBackupRel = new StandardProductListBackupRel(); BeanUtils.copyProperties(standardProductList, productListBackupRel); standardProductListBackupRelMapper.insert(productListBackupRel); } // 关联商家备份 StandardProductListSupplierAsk standardProductListSupplierAsk = new StandardProductListSupplierAsk(); standardProductListSupplierAsk.setProductListId(list.getId()); standardProductListSupplierAskService.backupSupplierAsk(standardProductListSupplierAsk); // 修改状态 list.setCheckStatus(StandardProductListChcekTypeEnums.WAIT_CHECK.getCode()); return standardProductListMapper.updateById(list); } @Override public List selectStandardProductList(InsSampleReceiveDto insSample) { String model = insSample.getModel(); String modelNum = insSample.getModelNum(); // 查询检查项目 StandardProductListDto standardProductListDto = new StandardProductListDto(); standardProductListDto.setTree(insSample.getFactory()); standardProductListDto.setStandardMethodListIds(insSample.getStandardMethodListIds()); standardProductListDto.setState(insSample.getState()); List list = new ArrayList<>(); if (CollectionUtils.isEmpty(standardProductListDto.getStandardMethodListIds())) { return list; } list = standardProductListMapper.standardProductListNoPage(standardProductListDto); list = list.stream().filter(a -> { try { if (a.getSection() != null && !Objects.equals(a.getSection(), "")) { List sections = JSON.parseArray(a.getSection(), String.class);// 区间 List cores = JSON.parseArray(a.getCores(), String.class); // 芯数 List conductorMaterials = JSON.parseArray(a.getConductorMaterial(), String.class); // 导体材质 List conductorTypes = JSON.parseArray(a.getConductorType(), String.class); // 导体类型 List asks = JSON.parseArray(a.getAsk(), String.class); List tells = JSON.parseArray(a.getTell(), String.class); boolean isIf; for (int i = 0; i < sections.size(); i++) { if (Objects.equals(a.getBsm(), "1")) { return true; } else { int firstIndex = a.getTree().indexOf(" - "); String result2 = null; if (firstIndex != -1) { int secondIndex = a.getTree().indexOf(" - ", firstIndex + 3); if (secondIndex != -1) { int thirdIndex = a.getTree().indexOf(" - ", secondIndex + 3); if (thirdIndex != -1) { result2 = a.getTree().substring(secondIndex + 3, thirdIndex); } } } // 判断 原辅材 包材 Set targetStrings = new HashSet<>(); targetStrings.add("原辅材"); targetStrings.add("包材"); boolean isType; isType = targetStrings.contains(result2); if (isType) { if (StringUtils.isNotEmpty(modelNum)){ String currentSection = sections.get(i); String sectionValue = currentSection; int equalIndex = currentSection.indexOf("="); if (equalIndex != -1) { sectionValue = currentSection.substring(equalIndex + 1); } if (modelNum.equals(sectionValue)) { a.setSection(sections.get(i)); a.setAsk(asks.get(i)); a.setTell(tells.get(i)); return true; } }else { return false; } } else { if (sections.get(i).contains("&")) { String[] split = sections.get(i).split("&"); isIf = getIsIf(split[0], modelNum, cores.get(i), conductorMaterials.get(i), conductorTypes.get(i), insSample) && getIsIf(split[1], modelNum, cores.get(i), conductorMaterials.get(i), conductorTypes.get(i), insSample); } else { isIf = getIsIf(sections.get(i), modelNum, cores.get(i), conductorMaterials.get(i), conductorTypes.get(i), insSample); } if (isIf) { a.setSection(sections.get(i)); a.setAsk(asks.get(i)); a.setTell(tells.get(i)); return true; } } } } return false; } } catch (Exception ignored) { return false; } return true; }).peek(standardProductList -> { //判断是否是原材下单, 需要啊把颜色绑定到试样颜色的要求值上 if (StringUtils.isNotBlank(insSample.getPartNo())) { // 判断是否有这个字段且是文本类型 if (StringUtils.isNotBlank(standardProductList.getInspectionItem()) && standardProductList.getInspectionItem().contains("试样颜色")) { Map partColor = baseMapper.selectPartColor(insSample.getPartNo()); if (CollectionUtils.isNotEmpty(partColor)) { if (StringUtils.isNotBlank(partColor.get("color"))) { // 判断检验值是否为空和不等于 - 和 / if (StringUtils.isBlank(standardProductList.getAsk()) || partColor.get("color").contains("本")) { // 没有ask直接复制 // 查询对象绑定表和产品绑定表 standardProductList.setAsk("=" + partColor.get("color") + (StringUtils.isBlank(partColor.get("color_code")) ? "" : "(" + partColor.get("color_code") + ")")); standardProductList.setTell(partColor.get("color") + (StringUtils.isBlank(partColor.get("color_code")) ? "" : "(" + partColor.get("color_code") + ")")); standardProductList.setInspectionValueType("2"); } else { // 拼接到要求描述前面 standardProductList.setTell(partColor.get("color") + (StringUtils.isBlank(partColor.get("color_code")) ? "" : "(" + partColor.get("color_code") + ")") + "@" + standardProductList.getTell()); } } } } } }) .collect(Collectors.toList()); // 查询厂家是否有特殊要求值 if (insSample.getIfsInventoryId() != null) { // 查询原材料厂家名称 String supplierName = ifsInventoryQuantityMapper.selectById(insSample.getIfsInventoryId()) .getSupplierName(); List collect = list.stream().map(StandardProductList::getId).collect(Collectors.toList()); if (CollectionUtils.isNotEmpty(collect)) { List supplierAsks = standardProductListSupplierAskMapper.selectList(Wrappers.lambdaQuery() .in(StandardProductListSupplierAsk::getProductListId, collect) .eq(StandardProductListSupplierAsk::getSupplierName, supplierName)); // 判断有没有特殊值绑定 if (CollectionUtils.isNotEmpty(supplierAsks)) { for (StandardProductList standardProductList : list) { for (StandardProductListSupplierAsk supplierAsk : supplierAsks) { if (standardProductList.getId().equals(supplierAsk.getProductListId())) { // 重新赋值要求值和要求描述 standardProductList.setAsk(supplierAsk.getAsk()); standardProductList.setTell(supplierAsk.getTell()); } } } } } } ProductPart productPart = productPartMapper.selectOne(new LambdaQueryWrapper().eq(ProductPart::getPartNo, insSample.getPartNo())); if (productPart != null) { if (StringUtils.isNotEmpty(productPart.getInspectionItem())) { String inspectionItem = productPart.getInspectionItem(); list = list.stream() .filter(standardProductList -> inspectionItem.contains(standardProductList.getInspectionItem())) .collect(Collectors.toList()); } } StructureTestObjectPart structureTestObjectPart = structureTestObjectPartMapper.selectOne(new LambdaQueryWrapper().eq(StructureTestObjectPart::getPartNo, insSample.getPartNo())); if (structureTestObjectPart != null) { if (StringUtils.isNotEmpty(structureTestObjectPart.getInspectionItem())) { String inspectionItem = structureTestObjectPart.getInspectionItem(); list = list.stream() .filter(standardProductList -> inspectionItem.equals(standardProductList.getInspectionItem())) .collect(Collectors.toList()); } } return list; } /** * @param str 判定公式 * @param model 型号 * @param standardCores 芯数 * @param conductorMaterial 导体材质 * @param conductorType 导体类型 * @param insSample * @return */ private boolean getIsIf(String str, String model, String standardCores, String conductorMaterial, String conductorType, InsSampleReceiveDto insSample) { Matcher matcher = Pattern.compile("\\d+(\\.\\d+)?").matcher(model); String model2 = ""; while (matcher.find()) { model2 += matcher.group(); break; } boolean flag = false; if (str.contains("≥") || str.contains(">=")) { String param = str.replace("≥", "").replace(">=", ""); flag = new BigDecimal(model2).compareTo(new BigDecimal(param)) > -1; } else if (str.contains("≤") || str.contains("<=")) { String param = str.replace("≤", "").replace("<=", ""); flag = new BigDecimal(model2).compareTo(new BigDecimal(param)) < 1; } else if (str.contains(">") || str.contains("＞")) { String param = str.replace(">", "").replace("＞", ""); flag = new BigDecimal(model2).compareTo(new BigDecimal(param)) > 0; } else if (str.contains("<") || str.contains("＜")) { String param = str.replace("<", "").replace("＜", ""); flag = new BigDecimal(model2).compareTo(new BigDecimal(param)) < 0; } else if (str.contains("=")) { String param = str.replace("=", ""); flag = new BigDecimal(model2).compareTo(new BigDecimal(param)) == 0; } if (flag) { boolean coresMatch = true; boolean conductorMaterialMatch = true; boolean conductorTypeMatch = true; // 判断是否有线芯数量 if (StringUtils.isNotBlank(standardCores)) { if (StringUtils.isBlank(insSample.getCores()) || !standardCores.equals(insSample.getCores())) { coresMatch = false; } } // 判断是否有导体材质 if (StringUtils.isNotBlank(conductorMaterial)) { if (StringUtils.isBlank(insSample.getConductorMaterial()) || !conductorMaterial.equals(insSample.getConductorMaterial())) { conductorMaterialMatch = false; } } // 判断是否有导体类型 if (StringUtils.isNotBlank(conductorType)) { if (StringUtils.isBlank(insSample.getConductorType()) || !conductorType.equals(insSample.getConductorType())) { conductorTypeMatch = false; } } // 最终判断 flag = coresMatch && conductorMaterialMatch && conductorTypeMatch; } return flag; } @Override @Transactional(rollbackFor = Exception.class) public Map selectStandardProductListByMethodId(Integer id, String tree) { String sampleType = ""; String sample = ""; String model = ""; StringBuilder checkItemQueryTree = new StringBuilder(); // 检查项查询 只拼接 检查对象-产品 // 返回结果 Map map = new HashMap<>(); map.put("productList", null); map.put("total", 0); // 判断是否包含车间 boolean existWorkShopFlag = standardMethodListService.existWorkShop(tree); // 拼接树 String[] trees = tree.split(" - "); if (trees == null && trees.length < 4) { return map; } // 车间层级多一层级 if (existWorkShopFlag) { switch (trees.length) { case 7: sampleType = trees[4]; sample = trees[5]; model = trees[6]; checkItemQueryTree.append("[").append("\"").append(trees[4]).append("\",\"").append(trees[5]).append("\"").append("]"); break; case 6: sampleType = trees[4]; sample = trees[5]; checkItemQueryTree.append("[").append("\"").append(trees[4]).append("\",\"").append(trees[5]).append("\"").append("]"); break; case 5: sampleType = trees[4]; checkItemQueryTree.append("[").append("\"").append(trees[4]).append("\"").append("]"); break; } } else { switch (trees.length) { case 6: sampleType = trees[3]; sample = trees[4]; model = trees[5]; checkItemQueryTree.append("[").append("\"").append(trees[3]).append("\",\"").append(trees[4]).append("\"").append("]"); break; case 5: sampleType = trees[3]; sample = trees[4]; checkItemQueryTree.append("[").append("\"").append(trees[3]).append("\",\"").append(trees[4]).append("\"").append("]"); break; case 4: sampleType = trees[3]; checkItemQueryTree.append("[").append("\"").append(trees[3]).append("\"").append("]"); break; } } if (StringUtils.isEmpty(checkItemQueryTree.toString())) { return map; } // 判断是否为委托要求标准 StandardMethod standardMethod = standardMethodMapper.selectById(id); if (ObjectUtils.isEmpty(standardMethod)) { return map; } StructureItemParameterDto structureItemParameterDto = new StructureItemParameterDto(); if (standardMethod.getName().equals("委托要求")) { structureItemParameterDto.setDelegateRequestFlag("1"); } else { structureItemParameterDto.setDelegateRequestFlag("0"); } structureItemParameterDto.setTree(checkItemQueryTree.toString()); // 根据检验对象/产品查询检验项 List structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(structureItemParameterDto); // 如果是产品的检查项为空向上推 if (CollectionUtils.isEmpty(structureItemParameterList)) { String query = "[\"" + sampleType + "\"]"; structureItemParameterDto.setTree(query); structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(structureItemParameterDto); } // 查询标准库已绑定检查项目 List standardProductList = standardProductListMapper.selectList(Wrappers.lambdaQuery() .eq(StandardProductList::getStandardMethodListId, id) .like(StandardProductList::getTree, tree) .orderByAsc(StandardProductList::getSort)); // 封装参数 List batchInsertStandardProductListArray = new ArrayList<>(); for (StructureItemParameter structureItemParameter : structureItemParameterList) { StandardProductList addStandProductList = new StandardProductList(); boolean existFlag = false; // 判断是否已绑定 for (StandardProductList productList : standardProductList) { if (structureItemParameter.getId().equals(productList.getStructureItemParameterId())) { BeanUtils.copyProperties(productList, addStandProductList); existFlag = true; break; } } // 如果未绑定 if (!existFlag) { BeanUtils.copyProperties(structureItemParameter, addStandProductList); addStandProductList.setTell(structureItemParameter.getAskTell()); addStandProductList.setStructureItemParameterId(structureItemParameter.getId()); addStandProductList.setManHour(Objects.toString(structureItemParameter.getManHour(), "")); } addStandProductList.setId(addStandProductList.getId() != null ? addStandProductList.getId() : IdWorker.getId()); batchInsertStandardProductListArray.add(addStandProductList); } // 排序处理 已有顺序按照原顺序 没有顺序的按照检验项的id升序，默认排在最后 batchInsertStandardProductListArray.sort(Comparator.comparing((StandardProductList item) -> item.getSort() != null ? item.getSort() : Integer.MAX_VALUE) .thenComparing(StandardProductList::getStructureItemParameterId)); // 删除原绑定数据 standardProductListMapper.delete(Wrappers.lambdaUpdate() .eq(StandardProductList::getStandardMethodListId, id) .eq(StandardProductList::getTree, tree)); for (int i = 0; i < batchInsertStandardProductListArray.size(); i++) { StandardProductList productList = batchInsertStandardProductListArray.get(i); productList.setTree(tree); productList.setFactory(trees[0]); productList.setLaboratory(trees[1]); productList.setSampleType(sampleType); productList.setSample(sample); productList.setModel(model); productList.setCreateUser(SecurityUtils.getUserId().intValue()); productList.setUpdateUser(SecurityUtils.getUserId().intValue()); productList.setStandardMethodListId(id); productList.setSort(i); } // 批量添加标准 if (CollectionUtils.isNotEmpty(batchInsertStandardProductListArray)) { baseMapper.saveBatchProductLists(batchInsertStandardProductListArray); } map.put("productList", batchInsertStandardProductListArray); map.put("total", batchInsertStandardProductListArray.size()); return map; } private int extractNumber(String s) { // 从字符串中提取数字的逻辑，这里假设字段的格式是 "text" String number = s; if (!s.matches("\\d+")) { number = s.replaceAll("\\D", ""); } return Integer.parseInt(number); } @Override public IPage selectStandardProductByMethodId(Integer id, String tree, Integer page, String laboratory, String item, String items) { IPage iPage = new Page<>(); iPage.setSize(100); iPage.setCurrent(page); return standardProductListMapper.standardProductListIPage(id, tree, iPage, laboratory, item, items); } @Override public Map> selectStandardProductEnumByMethodId(Integer id, String tree, String item) { HashMap> map = new HashMap<>(); map.put("item", standardProductListMapper.selectList(Wrappers.lambdaQuery() .eq(StandardProductList::getStandardMethodListId, id) .like(StandardProductList::getTree, tree) .select(StandardProductList::getInspectionItem) .groupBy(StandardProductList::getInspectionItem))); if (ObjectUtils.isNotEmpty(item)) { map.put("items", standardProductListMapper.selectList(Wrappers.lambdaQuery() .eq(StandardProductList::getStandardMethodListId, id) .eq(StandardProductList::getInspectionItem, item) .like(StandardProductList::getTree, tree) .select(StandardProductList::getInspectionItemSubclass) .groupBy(StandardProductList::getInspectionItemSubclass))); } else { map.put("items", standardProductListMapper.selectList(Wrappers.lambdaQuery() .eq(StandardProductList::getStandardMethodListId, id) .like(StandardProductList::getTree, tree) .select(StandardProductList::getInspectionItemSubclass) .groupBy(StandardProductList::getInspectionItemSubclass))); } return map; } /** * 修改标准库区间 * * @param list * @return */ @Override public boolean updateSection(StandardProductList list) { // 根据id 查询到原始值 StandardProductList standardProductList = standardProductListMapper.selectById(list.getId()); if (ObjectUtils.isEmpty(standardProductList)) { throw new RuntimeException("更新失败,未查找到检查项"); } // 判断当前状态 如果是审核中 if (StandardProductListChcekTypeEnums.CHECK_ING.getCode().equals(list.getCheckStatus())) { throw new RuntimeException("审核中不支持修改"); } // 查询最新的一次关联备份 如果存在说明未审核完继续修改了。不做数据处理。 StandardProductListBackupRel standardProductListBackupRel = standardProductListBackupRelMapper.selectById(list.getId()); if (ObjectUtils.isEmpty(standardProductListBackupRel)) { StandardProductListBackupRel productListBackupRel = new StandardProductListBackupRel(); BeanUtils.copyProperties(standardProductList, productListBackupRel); standardProductListBackupRelMapper.insert(productListBackupRel); } // 关联商家备份 StandardProductListSupplierAsk standardProductListSupplierAsk = new StandardProductListSupplierAsk(); standardProductListSupplierAsk.setProductListId(list.getId()); standardProductListSupplierAskService.backupSupplierAsk(standardProductListSupplierAsk); // 修改状态 list.setCheckStatus(StandardProductListChcekTypeEnums.WAIT_CHECK.getCode()); standardProductListMapper.updateSection(list); return true; } /** * 标准库拖拽 * * @param resetTreeDragDTO */ @Override @Transactional(rollbackFor = Exception.class) public void resetTreeDrag(ResetTreeDragDTO resetTreeDragDTO) { Integer beginIndex = Integer.parseInt(resetTreeDragDTO.getBeginIndex()); Integer endIndex = Integer.parseInt(resetTreeDragDTO.getEndIndex()); Integer methodId = Integer.parseInt(resetTreeDragDTO.getMethodId()); Long productionId = Long.parseLong(resetTreeDragDTO.getProductionId()); // 判断是从上往下拖拽还是从下往上放拖拽 // 从上往下 if (beginIndex < endIndex) { standardProductListMapper.updateSortUp(beginIndex, endIndex, methodId, resetTreeDragDTO.getTree()); // 从下往上 } else if (beginIndex > endIndex) { standardProductListMapper.updateSortDown(beginIndex, endIndex, methodId, resetTreeDragDTO.getTree()); } else { return; } // 修改标准库项顺序 standardProductListMapper.update(null, Wrappers.lambdaUpdate() .eq(StandardProductList::getId, productionId) .set(StandardProductList::getSort, endIndex)); } @Override public void resetTreeDragBatch(List standardProductLists) { this.updateBatchById(standardProductLists); } /** * 检验项要求值对比 * * @param copyDto * @return */ @Override public List copyStandardProductList(CopyStandardProductListDto copyDto) { List productLists = new ArrayList<>(); // 对比检验项一样的填充要求值要求描述 for (StandardProductList oldProductList : copyDto.getOldStandardProductList()) { String oldItemName = oldProductList.getInspectionItemClassEn() + oldProductList.getInspectionItem() + oldProductList.getInspectionItemSubclass(); for (StandardProductList newProductList : copyDto.getNewStandardProductList()) { String newItemName = newProductList.getInspectionItemClassEn() + newProductList.getInspectionItem() + newProductList.getInspectionItemSubclass(); // 判断名称是否一样 if (oldItemName.equals(newItemName)) { // 区间 oldProductList.setSection(newProductList.getSection()); // 芯数 oldProductList.setCores(newProductList.getCores()); // 要求值 oldProductList.setAsk(newProductList.getAsk()); // 要求描述 oldProductList.setTell(newProductList.getTell()); // 单价 oldProductList.setPrice(newProductList.getPrice()); // 工时分组 oldProductList.setManHour(newProductList.getManHour()); // 导体材质 oldProductList.setConductorMaterial(newProductList.getConductorMaterial()); // 导体类型 oldProductList.setConductorType(newProductList.getConductorType()); productLists.add(oldProductList); } } } return productLists; } /** * 检验项复制对比一个 * * @param dto * @return */ @Override public List copyStandardProductOne(CopyStandardProductListDto dto) { if (CollectionUtils.isEmpty(dto.getNewStandardProductList()) && dto.getNewStandardProductList().size() == 1 && CollectionUtils.isEmpty(dto.getOldStandardProductList()) && dto.getOldStandardProductList().size() == 1) { throw new BaseException("需要对比的检验项请选择一个"); } StandardProductList newProductList = dto.getNewStandardProductList().get(0); StandardProductList oldProductList = dto.getOldStandardProductList().get(0); // 区间 oldProductList.setSection(newProductList.getSection()); // 芯数 oldProductList.setCores(newProductList.getCores()); // 要求值 oldProductList.setAsk(newProductList.getAsk()); // 要求描述 oldProductList.setTell(newProductList.getTell()); // 单价 oldProductList.setPrice(newProductList.getPrice()); // 工时分组 oldProductList.setManHour(newProductList.getManHour()); // 导体材质 oldProductList.setConductorMaterial(newProductList.getConductorMaterial()); // 导体类型 oldProductList.setConductorType(newProductList.getConductorType()); List productLists = new ArrayList<>(); productLists.add(oldProductList); return productLists; } /** * 检验项复制排序 * * @param copyDto * @return */ @Override public boolean copyStandardProductSort(CopyStandardProductListDto copyDto) { List productLists = new ArrayList<>(); // 对比检验项一样的填充要求值要求描述 for (StandardProductList oldProductList : copyDto.getOldStandardProductList()) { String oldItemName = oldProductList.getInspectionItemClassEn() + oldProductList.getInspectionItem() + oldProductList.getInspectionItemSubclass(); for (StandardProductList newProductList : copyDto.getNewStandardProductList()) { String newItemName = newProductList.getInspectionItemClassEn() + newProductList.getInspectionItem() + newProductList.getInspectionItemSubclass(); // 判断名称是否一样 if (oldItemName.equals(newItemName)) { StandardProductList standardProductList = new StandardProductList(); standardProductList.setId(oldProductList.getId()); // 复制排序 standardProductList.setSort(newProductList.getSort()); productLists.add(standardProductList); } } } this.updateBatchById(productLists); return false; } /** * 标准树下检验项提交 */ @Override @Transactional(rollbackFor = Exception.class) public void productListSubmit(StandardProductListUpdateRecord standardProductListUpdateRecord) { // 查询所有待审核的数据 QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.WAIT_CHECK.getCode()); List unCheckStandardProductListArray = standardProductListMapper.selectList(queryWrapper); if (CollectionUtils.isEmpty(unCheckStandardProductListArray)) { throw new RuntimeException("暂无修改数据"); } List standardProductListIds = new ArrayList<>(); // 插入修改记录 standardProductListUpdateRecordMapper.insert(standardProductListUpdateRecord); // 插入修改记录关联表 List standardProductListUpdateRecordRelList = new ArrayList<>(); for (StandardProductList standardProductList : unCheckStandardProductListArray) { StandardProductListUpdateRecordRel standardProductListUpdateRecordRel = new StandardProductListUpdateRecordRel(); BeanUtils.copyProperties(standardProductList, standardProductListUpdateRecordRel); standardProductListUpdateRecordRel.setId(null); standardProductListUpdateRecordRel.setStandardProductListId(standardProductList.getId()); standardProductListUpdateRecordRel.setStandardProductListUpdateRecordId(standardProductListUpdateRecord.getId()); standardProductListUpdateRecordRelList.add(standardProductListUpdateRecordRel); standardProductListUpdateRecordRelMapper.insert(standardProductListUpdateRecordRel); standardProductListIds.add(standardProductList.getId()); } // 修改标准树下检查项状态为审核中 standardProductListMapper.updateProductListCheckStatus(standardProductListIds, StandardProductListChcekTypeEnums.CHECK_ING.getCode()); } /** * 标准树下检验项审核 * * @param standardProductListUpdateRecord */ @Override @Transactional(rollbackFor = Exception.class) public void productListCheck(StandardProductListUpdateRecord standardProductListUpdateRecord) { // 查询所有审核中的数据 QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.CHECK_ING.getCode()); List standardProductListArray = standardProductListMapper.selectList(queryWrapper); if (CollectionUtils.isEmpty(standardProductListArray)) { return; } List standardProductListIds = new ArrayList<>(); for (StandardProductList standardProductList : standardProductListArray) { standardProductListIds.add(standardProductList.getId()); } // 审核通过 if (StandardProductListChcekTypeEnums.PASS_CHECK.getCode().equals(standardProductListUpdateRecord.getCheckStatus())) { // 修改状态 standardProductListMapper.updateProductListCheckStatus(standardProductListIds, StandardProductListChcekTypeEnums.PASS_CHECK.getCode()); } // 审核未通过 if (StandardProductListChcekTypeEnums.NO_PASS_CHECK.getCode().equals(standardProductListUpdateRecord.getCheckStatus())) { // 查询所有标准树下的检验项目备份数据 List standardProductListBackupRelList = standardProductListBackupRelMapper.selectBatchIds(standardProductListIds); // 回滚标准树下的检验项目数据 for (StandardProductListBackupRel standardProductListBackupRel : standardProductListBackupRelList) { StandardProductList standardProductList = new StandardProductList(); BeanUtils.copyProperties(standardProductListBackupRel, standardProductList); standardProductListMapper.updateById(standardProductList); } // 回滚检验项目厂家密度绑定表数据 QueryWrapper supplierAskBackupRelQueryWrapper = new QueryWrapper<>(); supplierAskBackupRelQueryWrapper.in("product_list_id", standardProductListIds); List standardProductListSupplierAskBackupRelList = standardProductListSupplierAskBackupRelMapper.selectList(supplierAskBackupRelQueryWrapper); if (!CollectionUtils.isEmpty(standardProductListSupplierAskBackupRelList)) { QueryWrapper deleteWrapper = new QueryWrapper<>(); deleteWrapper.in("product_list_id", standardProductListIds); standardProductListSupplierAskMapper.delete(deleteWrapper); ArrayList supplierAskRollBackList = new ArrayList<>(); for (StandardProductListSupplierAskBackupRel standardProductListSupplierAskBackupRel : standardProductListSupplierAskBackupRelList) { StandardProductListSupplierAsk standardProductListSupplierAsk = new StandardProductListSupplierAsk(); BeanUtils.copyProperties(standardProductListSupplierAskBackupRel, standardProductListSupplierAsk); supplierAskRollBackList.add(standardProductListSupplierAsk); } standardProductListSupplierAskMapper.batchInsertSupplierAsk(supplierAskRollBackList); } } // 删除标准树下的检验项目备份数据 standardProductListBackupRelMapper.deleteBatchIds(standardProductListIds); // 删除绑定厂家备份数据 standardProductListSupplierAskBackupRelMapper.batchDeleteByProductIds(standardProductListIds); standardProductListUpdateRecordMapper.updateById(standardProductListUpdateRecord); } /** * 查询标准库是否存在审核中状态 * * @return */ @Override public boolean existCheckingRecord() { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.CHECK_ING.getCode()); List standardProductListUpdateRecordList = standardProductListUpdateRecordMapper.selectList(queryWrapper); if (CollectionUtils.isEmpty(standardProductListUpdateRecordList)) { return false; } else { return true; } } }