11/1

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

@@ -178,58 +178,69 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                 .filter(item -> allOriginalClaimIds.contains(item.getId()))
                 .collect(Collectors.toList());
         List<PatentClaimHistory> patentClaimHistories = new ArrayList<>();
-        if (ifFirst) {
-            // 首先到历史表中查询是否存在此条数据 修改序号类型的，后续可以直接更新
-            LambdaQueryWrapper<PatentClaimHistory> ifExistWrapper = new LambdaQueryWrapper<>();
-            ifExistWrapper.eq(PatentClaimHistory::getClaimId, claimId)
-                    .eq(PatentClaimHistory::getOperateType, 2)
-                    .eq(PatentClaimHistory::getIfFirst, ifFirst);
-            PatentClaimHistory patentClaimHistory = this.getOne(ifExistWrapper, false);
 
-            if (patentClaimHistory != null) {//后续只需要更新表中
-                Integer deleteOrder = patentClaimHistory.getSysOrder();
-                LambdaQueryWrapper<PatentClaimHistory> queryWrapper = new LambdaQueryWrapper<>();
-                queryWrapper.in(PatentClaimHistory::getClaimId, allOriginalClaimIds)
-                        .eq(PatentClaimHistory::getIfFirst, ifFirst)
-                        .ge(PatentClaimHistory::getSysOrder, deleteOrder);
-                List<PatentClaimHistory> updateClaimHistories = this.list(queryWrapper);
-                updateClaimHistories.forEach(item -> {
-                    if (item.getClaimId().equals(claimId)) {
-                        item.setOperateType(1);
-                        item.setSysOrder(null);
-                    } else {
-                        item.setOperateType(2);
-                        item.setSysOrder(item.getSysOrder() - 1);
-                    }
-                });
-                this.updateBatchById(updateClaimHistories);
-                this.saveBatch(patentClaimHistories);
-            } else {
-                // 这条权要并没有修改过排序，有可能之后的权要被删除过，也有可能没有任何操作
-                PatentClaimHistory deleteClaimHistory = new PatentClaimHistory();
-                deleteClaimHistory.setClaimId(claimId);
-                deleteClaimHistory.setOperateType(1);
-                deleteClaimHistory.setIfFirst(ifFirst);
-                deleteClaimHistory.setCreateId("328");
-                patentClaimHistories.add(deleteClaimHistory);
+        // 首先到历史表中查询是否存在这个权要id并且是修改序号类型的，它后面的修改序号类型的可以直接更新
+        LambdaQueryWrapper<PatentClaimHistory> ifExistWrapper = new LambdaQueryWrapper<>();
+        ifExistWrapper.eq(PatentClaimHistory::getClaimId, claimId)
+                .eq(PatentClaimHistory::getOperateType, 2)
+                .eq(PatentClaimHistory::getIfFirst, ifFirst);
+        PatentClaimHistory patentClaimHistory = this.getOne(ifExistWrapper, false);
+
+        if (patentClaimHistory != null) {
+            //它后面的修改序号类型的可以直接更新
+            Integer deleteClaimOrder = patentClaimHistory.getSysOrder();
+            //查询出排序大于等于当前待删除权要id的所有后续有过修改序号的权要历史
+            LambdaQueryWrapper<PatentClaimHistory> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.in(PatentClaimHistory::getClaimId, allOriginalClaimIds)
+                    .eq(PatentClaimHistory::getIfFirst, ifFirst)
+                    .ge(PatentClaimHistory::getSysOrder, deleteClaimOrder);
+            List<PatentClaimHistory> updateClaimHistories = this.list(queryWrapper);
+            //更新权要历史，是claimId的话就将排序变为null，将操作类型从修改序号变为删除
+            updateClaimHistories.forEach(item -> {
+                if (item.getClaimId().equals(claimId)) {
+                    item.setOperateType(1);
+                    item.setSysOrder(null);
+                } else {
+                    //更新权要历史，是后续有过修改序号的权要历史的话，order-1
+                    item.setOperateType(2);
+                    item.setSysOrder(item.getSysOrder() - 1);
+                }
+            });
+            this.updateBatchById(updateClaimHistories);
+            this.saveBatch(patentClaimHistories);
+        } else {
+            // 这条权要并没有修改过排序，有可能之后的权要被删除过，也有可能没有任何操作
+
+            //首先，新增一条记录
+            PatentClaimHistory deleteClaimHistory = new PatentClaimHistory();
+            deleteClaimHistory.setClaimId(claimId);
+            deleteClaimHistory.setOperateType(1);
+            deleteClaimHistory.setIfFirst(ifFirst);
+            deleteClaimHistory.setCreateId("328");
+            patentClaimHistories.add(deleteClaimHistory);
 
-                // 找出原始权要表中，order大于这个权要order的数据，这些数据的order要比历史表中最小的order的要小
-                PatentClaim patentClaim = patentClaimService.getById(claimId);
-                // 这是所有比需要删除的权要order大的数据（第二层过滤）
-                List<PatentClaim> secondFilter = firstFilter.stream()
-                        .filter(item -> item.getSysOrder() > patentClaim.getSysOrder())
-                        .collect(Collectors.toList());
-                List<Integer> cIds = secondFilter.stream().map(PatentClaim::getId).collect(Collectors.toList());
+            // 找出原始权要表中，order大于这个权要order的数据，这些数据的order要比历史表中最小的order的要小
+            PatentClaim patentClaim = patentClaimService.getById(claimId);
+            // 过滤出原权利要求表中，比待删除这条权要排序大的那些权利要求
+            List<PatentClaim> secondFilter = firstFilter.stream()
+                    .filter(item -> item.getSysOrder() > patentClaim.getSysOrder())
+                    .collect(Collectors.toList());
+            List<Integer> sortLaterIds = secondFilter.stream().map(PatentClaim::getId).collect(Collectors.toList());
 
+            if (ifFirst) {
+                //在比待删除这条权要排序大的那些权利要求中 找出在权要历史表中存在修改序号类型的
                 LambdaQueryWrapper<PatentClaimHistory> orderWrapper = new LambdaQueryWrapper<>();
                 orderWrapper.eq(PatentClaimHistory::getOperateType, 2)
-                        .in(PatentClaimHistory::getClaimId, cIds)
+                        .in(PatentClaimHistory::getClaimId, sortLaterIds)
                         .eq(PatentClaimHistory::getIfFirst, ifFirst);
                 List<PatentClaimHistory> orderList = this.list(orderWrapper);
-                //取出有过修改序号的权要ids
+                //有过修改序号的权要
                 if (!orderList.isEmpty()) {
+                    // 有过修改序号的权要ids
                     List<Integer> orderIds = orderList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
+                    // 比待删除这条权要排序大的那些权利要求集合中删除掉那些有过修改序号的权利要求 则只剩下需要新增的权利要求
                     secondFilter.removeIf(item -> orderIds.contains(item.getId()));
+                    // 这些是有过修改序号的权要ids 只需要进行更新操作，将排序 -1
                     LambdaQueryWrapper<PatentClaimHistory> updateWrapper = new LambdaQueryWrapper<>();
                     updateWrapper.in(PatentClaimHistory::getClaimId, orderIds)
                             .eq(PatentClaimHistory::getIfFirst, ifFirst)
@@ -238,8 +249,11 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                     updateHistories.forEach(item -> item.setSysOrder(item.getSysOrder() - 1));
                     this.updateBatchById(updateHistories);
                 }
+
+                // 如果有需要删除的这个权要，除掉
                 secondFilter.removeIf(item -> item.getId().equals(claimId));
 
+                // 待新增的权利要求
                 secondFilter.forEach(item -> {
                     PatentClaimHistory insertClaimHistory = new PatentClaimHistory();
                     insertClaimHistory.setClaimId(item.getId());
@@ -250,10 +264,48 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                     patentClaimHistories.add(insertClaimHistory);
                 });
                 this.saveBatch(patentClaimHistories);
-            }
-        } else {
+            } else {
 
+//                // 第二次
+//                //在比待删除这条权要排序大的那些权利要求中 找出在权要历史表中存在修改序号类型的
+//                LambdaQueryWrapper<PatentClaimHistory> orderWrapper = new LambdaQueryWrapper<>();
+//                orderWrapper.eq(PatentClaimHistory::getOperateType, 2)
+//                        .in(PatentClaimHistory::getClaimId, sortLaterIds)
+//                        .eq(PatentClaimHistory::getIfFirst, ifFirst);
+//                List<PatentClaimHistory> hasAOrderList = this.list(orderWrapper);
+//                //有过修改序号的权要
+//                if (!orderList.isEmpty()) {
+//                    // 有过修改序号的权要ids
+//                    List<Integer> orderIds = orderList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
+//                    // 比待删除这条权要排序大的那些权利要求集合中删除掉那些有过修改序号的权利要求 则只剩下需要新增的权利要求
+//                    secondFilter.removeIf(item -> orderIds.contains(item.getId()));
+//                    // 这些是有过修改序号的权要ids 只需要进行更新操作，将排序 -1
+//                    LambdaQueryWrapper<PatentClaimHistory> updateWrapper = new LambdaQueryWrapper<>();
+//                    updateWrapper.in(PatentClaimHistory::getClaimId, orderIds)
+//                            .eq(PatentClaimHistory::getIfFirst, ifFirst)
+//                            .eq(PatentClaimHistory::getOperateType, 2);
+//                    List<PatentClaimHistory> updateHistories = this.list(updateWrapper);
+//                    updateHistories.forEach(item -> item.setSysOrder(item.getSysOrder() - 1));
+//                    this.updateBatchById(updateHistories);
+//                }
+//
+//                // 如果有需要删除的这个权要，除掉
+//                secondFilter.removeIf(item -> item.getId().equals(claimId));
+//
+//                // 待新增的权利要求
+//                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);
+            }
         }
+
     }