1.原辅料下单标准

liding

2025-04-08 09ddece4effc738f2611c053d8f0f1fb22102597

 basic-server/src/main/java/com/ruoyi/basic/service/impl/StandardProductListServiceImpl.java

@@ -12,13 +12,12 @@
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.QueryWrappers;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.basic.service.StandardProductListService;
import lombok.AllArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@@ -48,45 +47,58 @@

    private ProductPartMapper productPartMapper;

    private StructureTestObjectPartMapper  structureTestObjectPartMapper;
    private StructureTestObjectPartMapper structureTestObjectPartMapper;

    @Autowired
    private StandardMethodListService standardMethodListService;

    @Autowired
    private StructureItemParameterMapper structureItemParameterMapper;

    @Autowired
    private ModelMapper modelMapper;

    @Autowired
    private StandardProductListBackupRelMapper standardProductListBackupRelMapper;

    @Autowired
    private StandardProductListUpdateRecordMapper standardProductListUpdateRecordMapper;

    @Autowired
    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)){
        if (ObjectUtils.isEmpty(standardProductList)) {
            throw new RuntimeException("更新失败,未查找到检查项");
        }
        // 判断当前状态 如果是审核中
        if(StandardProductListChcekTypeEnums.CHECK_ING.getCode().equals(list.getCheckStatus())){
        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)){
        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);
@@ -95,45 +107,18 @@

    @Override
    public List<StandardProductList> selectStandardProductList(InsSampleReceiveDto insSample) {
        // 是否没有产品
        boolean isNoSample = false;
//        String[] models = insSample.getModel().split("-(?=[^-]*$)");//拆分最后一个【-】
        String model = insSample.getModel();
        String modelNum = insSample.getModelNum();
        List<StandardProductList> list = standardProductListMapper.selectDetail(insSample.getStandardMethodListId(), 1, model, insSample.getIsCableTag());
        if (list.size() == 0) {
            if (Objects.equals(insSample.getFactory(), "") || insSample.getFactory() == null) {
                return null;
            }
            String[] split = insSample.getFactory().split(" - ");
            split[3] = split[3].replace("- ", "");
            String tree = split[0] + " - " + split[1] + " - " + split[2] + " - " + split[3] + " - null";
            list = standardProductListMapper.selectDetail2(insSample.getStandardMethodListId(), 1, tree, insSample.getIsCableTag());
            if (list.size() == 0) {
                String tree1 = split[0] + " - " + split[1] + " - " + split[2] + " - null - " + split[3];
                list = standardProductListMapper.selectDetail2(insSample.getStandardMethodListId(), 1, tree1, insSample.getIsCableTag());

                // 只有对象的一层
                if (list.size() == 0) {
                    String tree2 = split[0] + " - " + split[1] + " - " + split[2] + " - null - null";
                    list = standardProductListMapper.selectDetail2(insSample.getStandardMethodListId(), 1, tree2, insSample.getIsCableTag());
                    // 样品直接赋值样品分类
                    list.forEach(standardProductList -> standardProductList.setSample(standardProductList.getSampleType()));
                    isNoSample = true;
                }
            }
        // 查询检查项目
        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;
        }
        String[] split1 = insSample.getFactory().split(" - ");
        if (!isNoSample) {
            //判断长度
            if (split1.length > 4) {
                if (ObjectUtils.isNotEmpty(split1[3])) {
                    list = list.stream().filter(list1 -> Objects.nonNull(list1.getSample()) && Objects.equals(list1.getSample(), split1[3])).collect(Collectors.toList());
                } else if (split1[3].equals("")) {
                    list = list.stream().filter(list1 -> Objects.nonNull(list1.getSampleType()) && Objects.equals(list1.getSampleType(), split1[2])).collect(Collectors.toList());
                }
            }
        }
        list = standardProductListMapper.standardProductListNoPage(standardProductListDto);
        list = list.stream().filter(a -> {
                    try {
                        if (a.getSection() != null && !Objects.equals(a.getSection(), "")) {
@@ -224,8 +209,8 @@
        }

        ProductPart productPart = productPartMapper.selectOne(new LambdaQueryWrapper<ProductPart>().eq(ProductPart::getPartNo, insSample.getPartNo()));
        if (productPart != null){
            if (StringUtils.isNotEmpty(productPart.getInspectionItem())){
        if (productPart != null) {
            if (StringUtils.isNotEmpty(productPart.getInspectionItem())) {
                String inspectionItem = productPart.getInspectionItem();
                list = list.stream()
                        .filter(standardProductList -> inspectionItem.equals(standardProductList.getInspectionItem()))
@@ -234,8 +219,8 @@
        }

        StructureTestObjectPart structureTestObjectPart = structureTestObjectPartMapper.selectOne(new LambdaQueryWrapper<StructureTestObjectPart>().eq(StructureTestObjectPart::getPartNo, insSample.getPartNo()));
        if (structureTestObjectPart != null){
            if (StringUtils.isNotEmpty(structureTestObjectPart.getInspectionItem())){
        if (structureTestObjectPart != null) {
            if (StringUtils.isNotEmpty(structureTestObjectPart.getInspectionItem())) {
                String inspectionItem = structureTestObjectPart.getInspectionItem();
                list = list.stream()
                        .filter(standardProductList -> inspectionItem.equals(standardProductList.getInspectionItem()))
@@ -246,16 +231,15 @@
    }

    /**
     *
     * @param str                 判定公式
     * @param model               型号
     * @param standardCores       芯数
     * @param conductorMaterial   导体材质
     * @param conductorType       导体类型
     * @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) {
    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()) {
@@ -328,11 +312,11 @@
        boolean existWorkShopFlag = standardMethodListService.existWorkShop(tree);
        // 拼接树
        String[] trees = tree.split(" - ");
        if(trees == null && trees.length < 4){
        if (trees == null && trees.length < 4) {
            return map;
        }
        // 车间层级多一层级
        if(existWorkShopFlag){
        if (existWorkShopFlag) {
            switch (trees.length) {
                case 7:
                    sampleType = trees[4];
@@ -350,7 +334,7 @@
                    checkItemQueryTree.append("[").append("\"").append(trees[4]).append("\"").append("]");
                    break;
            }
        }else {
        } else {
            switch (trees.length) {
                case 6:
                    sampleType = trees[3];
@@ -369,17 +353,30 @@
                    break;
            }
        }
        if(StringUtils.isEmpty(checkItemQueryTree.toString())){
        if (StringUtils.isEmpty(checkItemQueryTree.toString())) {
            return map;
        }
        // 根据检验对象/产品查询检验项
        List<StructureItemParameter> structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(checkItemQueryTree.toString());
        // 如果是产品的检查项为空向上推
        if(CollectionUtils.isEmpty(structureItemParameterList)){
            String query = "[\"" + sampleType + "\"]";
            structureItemParameterList = structureItemParameterMapper.selectItemParameterBySample(query);
        // 判断是否为委托要求标准
        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)
@@ -393,14 +390,14 @@
            boolean existFlag = false;
            // 判断是否已绑定
            for (StandardProductList productList : standardProductList) {
                if(structureItemParameter.getId().equals(productList.getStructureItemParameterId())) {
                if (structureItemParameter.getId().equals(productList.getStructureItemParameterId())) {
                    BeanUtils.copyProperties(productList, addStandProductList);
                    existFlag = true;
                    break;
                }
            }
            // 如果未绑定
            if(!existFlag){
            if (!existFlag) {
                BeanUtils.copyProperties(structureItemParameter, addStandProductList);
                addStandProductList.setStructureItemParameterId(structureItemParameter.getId());

@@ -484,11 +481,34 @@

    /**
     * 修改标准库区间
     *
     * @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;
    }
@@ -496,6 +516,7 @@

    /**
     * 标准库拖拽
     *
     * @param resetTreeDragDTO
     */
    @Override
@@ -514,7 +535,7 @@
                    resetTreeDragDTO.getTree());

            // 从下往上
        } else if (beginIndex > endIndex){
        } else if (beginIndex > endIndex) {
            standardProductListMapper.updateSortDown(beginIndex,
                    endIndex,
                    methodId,
@@ -535,6 +556,7 @@

    /**
     * 检验项要求值对比
     *
     * @param copyDto
     * @return
     */
@@ -578,6 +600,7 @@

    /**
     * 检验项复制对比一个
     *
     * @param dto
     * @return
     */
@@ -612,6 +635,7 @@

    /**
     * 检验项复制排序
     *
     * @param copyDto
     * @return
     */
@@ -650,9 +674,11 @@
    public void productListSubmit(StandardProductListUpdateRecord standardProductListUpdateRecord) {
        // 查询所有待审核的数据
        QueryWrapper<StandardProductList> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("check_status",StandardProductListChcekTypeEnums.WAIT_CHECK.getCode());
        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);
@@ -670,11 +696,12 @@
        }

        // 修改标准树下检查项状态为审核中
        standardProductListMapper.updateProductListCheckStatus(standardProductListIds,StandardProductListChcekTypeEnums.CHECK_ING.getCode());
        standardProductListMapper.updateProductListCheckStatus(standardProductListIds, StandardProductListChcekTypeEnums.CHECK_ING.getCode());
    }

    /**
     * 标准树下检验项审核
     *
     * @param standardProductListUpdateRecord
     */
    @Override
@@ -682,9 +709,9 @@
    public void productListCheck(StandardProductListUpdateRecord standardProductListUpdateRecord) {
        // 查询所有审核中的数据
        QueryWrapper<StandardProductList> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("check_status",StandardProductListChcekTypeEnums.CHECK_ING.getCode());
        queryWrapper.eq("check_status", StandardProductListChcekTypeEnums.CHECK_ING.getCode());
        List<StandardProductList> standardProductListArray = standardProductListMapper.selectList(queryWrapper);
        if(CollectionUtils.isEmpty(standardProductListArray)){
        if (CollectionUtils.isEmpty(standardProductListArray)) {
            return;
        }
        List<Long> standardProductListIds = new ArrayList<>();
@@ -692,28 +719,61 @@
            standardProductListIds.add(standardProductList.getId());
        }
        // 审核通过
        if(StandardProductListChcekTypeEnums.PASS_CHECK.getCode().equals(standardProductListUpdateRecord.getCheckStatus())){
            // 删除备份数据
            standardProductListBackupRelMapper.deleteBatchIds(standardProductListIds);
        if (StandardProductListChcekTypeEnums.PASS_CHECK.getCode().equals(standardProductListUpdateRecord.getCheckStatus())) {
            // 修改状态
            standardProductListMapper.updateProductListCheckStatus(standardProductListIds,StandardProductListChcekTypeEnums.PASS_CHECK.getCode());
            standardProductListMapper.updateProductListCheckStatus(standardProductListIds, StandardProductListChcekTypeEnums.PASS_CHECK.getCode());
        }
        // 审核未通过
        if(StandardProductListChcekTypeEnums.NO_PASS_CHECK.getCode().equals(standardProductListUpdateRecord.getCheckStatus())){
            // 查询所有的备份数据
        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);
                standardProductList.setCheckStatus("");
                standardProductListMapper.updateById(standardProductList);
            }
            // 删除备份数据
            standardProductListBackupRelMapper.deleteBatchIds(standardProductListIds);
            // 回滚检验项目厂家密度绑定表数据
            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;
        }
    }
}