fixed 官方无效删除

src/main/java/cn/cslg/pas/service/business/AvoidDesignWholeService.java

@@ -191,8 +191,6 @@ public class AvoidDesignWholeService extends ServiceImpl<AvoidDesignWholeMapper,
                 }
                 avoidDesignVOS.add(avoidDesignVO);
             }
-        } else {
-            throw new XiaoShiException("未查询到特征");
         }
         return avoidDesignVOS;
     }

src/main/java/cn/cslg/pas/service/business/invalidReport/PatentClaimHistoryService.java

@@ -22,6 +22,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.RequestBody;
 
 import java.util.*;
@@ -323,51 +324,65 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                     });
                     this.saveBatch(patentClaimHistories);
                 } else {
-                    LambdaQueryWrapper<PatentClaimHistory> queryWrapper1 = new LambdaQueryWrapper<>();
-                    queryWrapper1.in(PatentClaimHistory::getClaimId, sortLaterIds)
-                            .eq(PatentClaimHistory::getOperateType, 2);
-                    List<PatentClaimHistory> ifExist = this.list(queryWrapper1);
-                    if (!ifExist.isEmpty()) {
-                        List<PatentClaimHistory> secondHistories = new ArrayList<>();
-                        sortLaterIds.forEach(item -> {
-                            LambdaQueryWrapper<PatentClaimHistory> queryWrapper2 = new LambdaQueryWrapper<>();
-                            queryWrapper2.eq(PatentClaimHistory::getIfFirst, ifFirst)
-                                    .eq(PatentClaimHistory::getClaimId, item)
-                                    .eq(PatentClaimHistory::getOperateType, 2);
-                            PatentClaimHistory secondHistory = this.getOne(queryWrapper2, false);
-                            if (secondHistory != null) {
-                                secondHistory.setSysOrder(secondHistory.getSysOrder() - 1);
-                                secondHistories.add(secondHistory);
-                            } else {
-                                LambdaQueryWrapper<PatentClaimHistory> queryWrapper3 = new LambdaQueryWrapper<>();
-                                queryWrapper3.eq(PatentClaimHistory::getIfFirst, !ifFirst)
+                    if (!CollectionUtils.isEmpty(sortLaterIds)) {
+                        LambdaQueryWrapper<PatentClaimHistory> queryWrapper1 = new LambdaQueryWrapper<>();
+                        queryWrapper1.in(PatentClaimHistory::getClaimId, sortLaterIds)
+                                .eq(PatentClaimHistory::getOperateType, 2);
+                        List<PatentClaimHistory> ifExist = this.list(queryWrapper1);
+                        if (!ifExist.isEmpty()) {
+                            List<PatentClaimHistory> secondHistories = new ArrayList<>();
+                            sortLaterIds.forEach(item -> {
+                                LambdaQueryWrapper<PatentClaimHistory> queryWrapper2 = new LambdaQueryWrapper<>();
+                                queryWrapper2.eq(PatentClaimHistory::getIfFirst, ifFirst)
                                         .eq(PatentClaimHistory::getClaimId, item)
                                         .eq(PatentClaimHistory::getOperateType, 2);
-                                PatentClaimHistory thirdHistory = this.getOne(queryWrapper3, false);
-                                if (thirdHistory != null) {
-                                    PatentClaimHistory third = new PatentClaimHistory();
-                                    third.setClaimId(thirdHistory.getClaimId());
-                                    third.setOperateType(2);
-                                    third.setSysOrder(thirdHistory.getSysOrder() - 1);
-                                    third.setCreateId(thirdHistory.getCreateId());
-                                    third.setIfFirst(ifFirst);
-                                    patentClaimHistories.add(third);
+                                PatentClaimHistory secondHistory = this.getOne(queryWrapper2, false);
+                                if (secondHistory != null) {
+                                    secondHistory.setSysOrder(secondHistory.getSysOrder() - 1);
+                                    secondHistories.add(secondHistory);
                                 } else {
-                                    PatentClaim patentClaim1 = patentClaimService.getById(item);
-                                    PatentClaimHistory patentClaimHistory1 = new PatentClaimHistory();
-                                    patentClaimHistory1.setClaimId(item);
-                                    patentClaimHistory1.setCreateId(patentClaim1.getCreateId());
-                                    patentClaimHistory1.setIfFirst(false);
-                                    patentClaimHistory1.setOperateType(2);
-                                    patentClaimHistory1.setSysOrder(patentClaim1.getSysOrder() - 1);
-                                    patentClaimHistories.add(patentClaimHistory1);
+                                    LambdaQueryWrapper<PatentClaimHistory> queryWrapper3 = new LambdaQueryWrapper<>();
+                                    queryWrapper3.eq(PatentClaimHistory::getIfFirst, !ifFirst)
+                                            .eq(PatentClaimHistory::getClaimId, item)
+                                            .eq(PatentClaimHistory::getOperateType, 2);
+                                    PatentClaimHistory thirdHistory = this.getOne(queryWrapper3, false);
+                                    if (thirdHistory != null) {
+                                        PatentClaimHistory third = new PatentClaimHistory();
+                                        third.setClaimId(thirdHistory.getClaimId());
+                                        third.setOperateType(2);
+                                        third.setSysOrder(thirdHistory.getSysOrder() - 1);
+                                        third.setCreateId(thirdHistory.getCreateId());
+                                        third.setIfFirst(ifFirst);
+                                        patentClaimHistories.add(third);
+                                    } else {
+                                        PatentClaim patentClaim1 = patentClaimService.getById(item);
+                                        PatentClaimHistory patentClaimHistory1 = new PatentClaimHistory();
+                                        patentClaimHistory1.setClaimId(item);
+                                        patentClaimHistory1.setCreateId(patentClaim1.getCreateId());
+                                        patentClaimHistory1.setIfFirst(false);
+                                        patentClaimHistory1.setOperateType(2);
+                                        patentClaimHistory1.setSysOrder(patentClaim1.getSysOrder() - 1);
+                                        patentClaimHistories.add(patentClaimHistory1);
+                                    }
                                 }
-                            }
-                        });
-                        this.saveBatch(patentClaimHistories);
-                        this.updateBatchById(secondHistories);
+                            });
+                            this.saveBatch(patentClaimHistories);
+                            this.updateBatchById(secondHistories);
+                        } else {
+                            // 待新增的权利要求
+                            secondFilter.forEach(item -> {
+                                PatentClaimHistory insertClaimHistory = new PatentClaimHistory();
+                                insertClaimHistory.setClaimId(item.getId());
+                                insertClaimHistory.setSysOrder(item.getSysOrder() - 1);
+                                insertClaimHistory.setIfFirst(ifFirst);
+                                insertClaimHistory.setOperateType(2);
+                                insertClaimHistory.setCreateId(item.getCreateId());
+                                patentClaimHistories.add(insertClaimHistory);
+                            });
+                            this.saveBatch(patentClaimHistories);
+                        }
                     } else {
-                        // 待新增的权利要求
+                        //todo 待新增的权利要求
                         secondFilter.forEach(item -> {
                             PatentClaimHistory insertClaimHistory = new PatentClaimHistory();
                             insertClaimHistory.setClaimId(item.getId());