新增取消拖拽功能造成的删除和插入操作接口

deslrey

21 小时以前 c072682530bb797bf7a5eaffc87e1e2b394d3b60

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

@@ -189,16 +189,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()) {
@@ -452,11 +451,225 @@
                return Integer.compare(num1, num2);
            }
        });
          // 按照索引排序
        // 按照索引排序
        if (isDrag) {
            list.sort((o1, o2) -> (o1.getSort() == null ? 0 : o1.getSort())
                    - (o2.getSort() == null ? 0 : o2.getSort()));
            list.sort(Comparator.comparingInt(o -> (o.getSort() == null ? 0 : o.getSort())));
        }

        Map<String, Object> map = new HashMap<>();
        map.put("productList", list);
        map.put("total", list.size());
        return map;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Map<String, Object> buildStandardProductListNoDrag(Integer id, String tree) {

        String[] trees = tree.split(" - ");
        List<StandardProductList> list = new ArrayList<>();
        if (trees.length == 3) {
            List<StandardTree> treeList = new ArrayList<>();
            StandardTree standardTree = new StandardTree();
            standardTree.setFactory(trees[0]);
            standardTree.setLaboratory(trees[1]);
            standardTree.setSampleType(trees[2]);

            List<ProductDto> pList = standardTreeMapper.selectPList(trees[2]);
            if (CollectionUtils.isEmpty(pList) || pList.get(0) == null) {
                List<StandardTree> treeList1 =
                        standardTreeMapper.selectList(
                                Wrappers.<StandardTree>lambdaQuery()
                                        .eq(StandardTree::getLaboratory, trees[1])
                                        .eq(StandardTree::getSampleType, trees[2])
                        );
                if (CollectionUtils.isEmpty(treeList1)) {
                    treeList.add(standardTree);
                } else {
                    treeList.addAll(treeList1);
                }
            } else {
                for (ProductDto p : pList) {
                    standardTree.setSample(p.getName());
                    List<StandardTree> treeList1 =
                            standardTreeMapper.selectList(
                                    Wrappers.<StandardTree>lambdaQuery()
                                            .eq(StandardTree::getLaboratory, trees[1])
                                            .eq(StandardTree::getSampleType, trees[2])
                                            .eq(StandardTree::getSample, p.getName())
                            );
                    if (CollectionUtils.isEmpty(treeList1)) {
                        treeList.add(JSON.parseObject(
                                JSON.toJSONString(standardTree),
                                StandardTree.class
                        ));
                    } else {
                        treeList.addAll(treeList1);
                    }
                }
            }

            for (StandardTree st : treeList) {
                String tree2 = trees[0] + " - " + trees[1] + " - " + trees[2]
                        + " - " + st.getSample() + " - " + st.getModel();

                list.addAll(
                        standardTreeMapper.selectStandardProductListByTree(
                                "\"" + trees[2] + "\"",
                                st.getSample(),
                                st.getModel(),
                                tree2,
                                trees[1]
                        )
                );
                list.addAll(
                        standardTreeMapper.selectStandardProductListByTree2(
                                "\"" + trees[2] + "\",\"" + st.getSample() + "\"",
                                st.getSample(),
                                st.getModel(),
                                tree2,
                                trees[1]
                        )
                );
            }

        } else if (trees.length == 4) {

            List<StandardTree> treeList =
                    standardTreeMapper.selectList(
                            Wrappers.<StandardTree>lambdaQuery()
                                    .eq(StandardTree::getLaboratory, trees[1])
                                    .eq(StandardTree::getSampleType, trees[2])
                                    .eq(StandardTree::getSample, trees[3])
                    );

            if (CollectionUtils.isEmpty(treeList)) {
                StandardTree st = new StandardTree();
                st.setFactory(trees[0]);
                st.setLaboratory(trees[1]);
                st.setSampleType(trees[2]);
                st.setSample(trees[3]);
                treeList.add(st);
            }

            for (StandardTree st : treeList) {
                String str = tree + " - " + st.getModel();
                list.addAll(
                        standardTreeMapper.selectStandardProductListByTree(
                                "\"" + trees[2] + "\"",
                                st.getSample(),
                                st.getModel(),
                                str,
                                trees[1]
                        )
                );
                list.addAll(
                        standardTreeMapper.selectStandardProductListByTree2(
                                "\"" + trees[2] + "\",\"" + trees[3] + "\"",
                                st.getSample(),
                                st.getModel(),
                                str,
                                trees[1]
                        )
                );
            }

        } else {
            list.addAll(
                    standardTreeMapper.selectStandardProductListByTree(
                            "\"" + trees[2] + "\"",
                            "null".equals(trees[3]) ? null : trees[3],
                            trees[4],
                            tree,
                            trees[1]
                    )
            );
            list.addAll(
                    standardTreeMapper.selectStandardProductListByTree2(
                            "\"" + trees[2] + "\",\"" + trees[3] + "\"",
                            "null".equals(trees[3]) ? null : trees[3],
                            trees[4],
                            tree,
                            trees[1]
                    )
            );
        }

        for (StandardProductList p : list) {
            p.setId(IdWorker.getId());
        }
        List<StandardProductList> oldList =
                standardProductListMapper.selectList(
                        Wrappers.<StandardProductList>lambdaQuery()
                                .eq(StandardProductList::getStandardMethodListId, id)
                                .like(StandardProductList::getTree, tree)
                );

        for (StandardProductList old : oldList) {
            for (StandardProductList cur : list) {

                // 半径只有一个值，自动赋值
                String radiusList = cur.getRadiusList();
                if (StringUtils.isNotBlank(radiusList)
                        && !"null".equals(radiusList)
                        && !"\"\"".equals(radiusList)) {
                    JSONArray jsonArray = JSON.parseArray(radiusList);
                    List<String> radius = jsonArray.toJavaList(String.class);
                    if (CollectionUtils.isNotEmpty(radius) && radius.size() == 1) {
                        cur.setRadius(radius.get(0));
                    }
                }

                if (Objects.equals(old.getInspectionItem(), cur.getInspectionItem())
                        && Objects.equals(
                        Objects.toString(old.getInspectionItemSubclass(), ""),
                        Objects.toString(cur.getInspectionItemSubclass(), "")
                )
                        && Objects.equals(old.getModel(), cur.getModel())
                        && old.getTree().contains(
                        cur.getSample() == null ? "null" : cur.getSample()
                )
                        && Objects.equals(
                        old.getStructureItemParameterId(),
                        cur.getStructureItemParameterId()
                )) {

                    cur.setId(old.getId());
                    cur.setSort(old.getSort());
                    cur.setState(old.getState());
                    cur.setMethod(old.getMethodS());
                    cur.setRadius(old.getRadius());
                    cur.setRates(old.getRates());
                    cur.setAsk(old.getAsk());
                    cur.setTell(old.getTell());
                    cur.setPrice(old.getPrice());
                    cur.setManHour(old.getManHour());
                    cur.setSection(old.getSection());
                    cur.setCores(old.getCores());
                    cur.setConductorMaterial(old.getConductorMaterial());
                    cur.setConductorType(old.getConductorType());
                    cur.setTemplateId(old.getTemplateId());
                    break;
                }
            }
        }

        list.sort((o1, o2) -> {
            String f1 = o1.getManHourGroup();
            String f2 = o2.getManHourGroup();

            boolean e1 = StringUtils.isBlank(f1);
            boolean e2 = StringUtils.isBlank(f2);

            if (e1 && e2) return 0;
            if (e1) return 1;
            if (e2) return -1;

            return Integer.compare(
                    extractNumber(f1),
                    extractNumber(f2)
            );
        });

        Map<String, Object> map = new HashMap<>();
        map.put("productList", list);
@@ -508,6 +721,7 @@

    /**
     * 修改标准库区间
     *
     * @param list
     * @return
     */
@@ -520,6 +734,7 @@

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

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

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

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

    /**
     * 检验项复制排序
     *
     * @param copyDto
     * @return
     */