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<StandardProductListMapper, StandardProductList>
|
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<StandardProductList> 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<StandardProductList> 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<String> sections = JSON.parseArray(a.getSection(), String.class);// 区间
|
List<String> cores = JSON.parseArray(a.getCores(), String.class); // 芯数
|
List<String> conductorMaterials = JSON.parseArray(a.getConductorMaterial(), String.class); // 导体材质
|
List<String> conductorTypes = JSON.parseArray(a.getConductorType(), String.class); // 导体类型
|
List<String> asks = JSON.parseArray(a.getAsk(), String.class);
|
List<String> 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<String> 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<String, String> 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<Long> collect = list.stream().map(StandardProductList::getId).collect(Collectors.toList());
|
if (CollectionUtils.isNotEmpty(collect)) {
|
List<StandardProductListSupplierAsk> supplierAsks = standardProductListSupplierAskMapper.selectList(Wrappers.<StandardProductListSupplierAsk>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<ProductPart>().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<StructureTestObjectPart>().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<String, Object> selectStandardProductListByMethodId(Integer id, String tree) {
|
String sampleType = "";
|
String sample = "";
|
String model = "";
|
StringBuilder checkItemQueryTree = new StringBuilder(); // 检查项查询 只拼接 检查对象-产品
|
|
// 返回结果
|
Map<String, Object> 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<StructureItemParameter> structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(structureItemParameterDto);
|
// 如果是产品的检查项为空向上推
|
if (CollectionUtils.isEmpty(structureItemParameterList)) {
|
String query = "[\"" + sampleType + "\"]";
|
structureItemParameterDto.setTree(query);
|
structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(structureItemParameterDto);
|
}
|
// 查询标准库已绑定检查项目
|
List<StandardProductList> standardProductList = standardProductListMapper.selectList(Wrappers.<StandardProductList>lambdaQuery()
|
.eq(StandardProductList::getStandardMethodListId, id)
|
.like(StandardProductList::getTree, tree)
|
.orderByAsc(StandardProductList::getSort));
|
|
// 封装参数
|
List<StandardProductList> 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.<StandardProductList>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<number>"
|
String number = s;
|
if (!s.matches("\\d+")) {
|
number = s.replaceAll("\\D", "");
|
}
|
return Integer.parseInt(number);
|
}
|
|
@Override
|
public IPage<StandardProductList> selectStandardProductByMethodId(Integer id, String tree, Integer page, String laboratory, String item, String items) {
|
IPage<StandardProductList> iPage = new Page<>();
|
iPage.setSize(100);
|
iPage.setCurrent(page);
|
return standardProductListMapper.standardProductListIPage(id, tree, iPage, laboratory, item, items);
|
}
|
|
@Override
|
public Map<String, List<?>> selectStandardProductEnumByMethodId(Integer id, String tree, String item) {
|
HashMap<String, List<?>> map = new HashMap<>();
|
map.put("item", standardProductListMapper.selectList(Wrappers.<StandardProductList>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.<StandardProductList>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.<StandardProductList>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.<StandardProductList>lambdaUpdate()
|
.eq(StandardProductList::getId, productionId)
|
.set(StandardProductList::getSort, endIndex));
|
}
|
|
@Override
|
public void resetTreeDragBatch(List<StandardProductList> standardProductLists) {
|
this.updateBatchById(standardProductLists);
|
}
|
|
/**
|
* 检验项要求值对比
|
*
|
* @param copyDto
|
* @return
|
*/
|
@Override
|
public List<StandardProductList> copyStandardProductList(CopyStandardProductListDto copyDto) {
|
List<StandardProductList> 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<StandardProductList> 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<StandardProductList> productLists = new ArrayList<>();
|
productLists.add(oldProductList);
|
return productLists;
|
}
|
|
/**
|
* 检验项复制排序
|
*
|
* @param copyDto
|
* @return
|
*/
|
@Override
|
public boolean copyStandardProductSort(CopyStandardProductListDto copyDto) {
|
List<StandardProductList> 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<StandardProductList> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.WAIT_CHECK.getCode());
|
List<StandardProductList> unCheckStandardProductListArray = standardProductListMapper.selectList(queryWrapper);
|
if (CollectionUtils.isEmpty(unCheckStandardProductListArray)) {
|
throw new RuntimeException("暂无修改数据");
|
}
|
List<Long> standardProductListIds = new ArrayList<>();
|
// 插入修改记录
|
standardProductListUpdateRecordMapper.insert(standardProductListUpdateRecord);
|
// 插入修改记录关联表
|
List<StandardProductListUpdateRecordRel> 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<StandardProductList> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.CHECK_ING.getCode());
|
List<StandardProductList> standardProductListArray = standardProductListMapper.selectList(queryWrapper);
|
if (CollectionUtils.isEmpty(standardProductListArray)) {
|
return;
|
}
|
List<Long> 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<StandardProductListBackupRel> standardProductListBackupRelList = standardProductListBackupRelMapper.selectBatchIds(standardProductListIds);
|
// 回滚标准树下的检验项目数据
|
for (StandardProductListBackupRel standardProductListBackupRel : standardProductListBackupRelList) {
|
StandardProductList standardProductList = new StandardProductList();
|
BeanUtils.copyProperties(standardProductListBackupRel, standardProductList);
|
standardProductListMapper.updateById(standardProductList);
|
}
|
// 回滚检验项目厂家密度绑定表数据
|
QueryWrapper<StandardProductListSupplierAskBackupRel> supplierAskBackupRelQueryWrapper = new QueryWrapper<>();
|
supplierAskBackupRelQueryWrapper.in("product_list_id", standardProductListIds);
|
List<StandardProductListSupplierAskBackupRel> standardProductListSupplierAskBackupRelList = standardProductListSupplierAskBackupRelMapper.selectList(supplierAskBackupRelQueryWrapper);
|
if (!CollectionUtils.isEmpty(standardProductListSupplierAskBackupRelList)) {
|
QueryWrapper<StandardProductListSupplierAsk> deleteWrapper = new QueryWrapper<>();
|
deleteWrapper.in("product_list_id", standardProductListIds);
|
standardProductListSupplierAskMapper.delete(deleteWrapper);
|
ArrayList<StandardProductListSupplierAsk> 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<StandardProductListUpdateRecord> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.CHECK_ING.getCode());
|
List<StandardProductListUpdateRecord> standardProductListUpdateRecordList = standardProductListUpdateRecordMapper.selectList(queryWrapper);
|
if (CollectionUtils.isEmpty(standardProductListUpdateRecordList)) {
|
return false;
|
} else {
|
return true;
|
}
|
}
|
}
|
