12/28

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

@@ -18,10 +18,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Service;
 import org.springframework.web.bind.annotation.RequestBody;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -210,7 +207,6 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
             this.saveBatch(patentClaimHistories);
         } else {
             // 这条权要并没有修改过排序，有可能之后的权要被删除过，也有可能没有任何操作
-
             //首先，新增一条记录
             PatentClaimHistory deleteClaimHistory = new PatentClaimHistory();
             deleteClaimHistory.setClaimId(claimId);
@@ -226,7 +222,6 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                     .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<>();
@@ -265,47 +260,102 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
                 });
                 this.saveBatch(patentClaimHistories);
             } 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);
+                LambdaQueryWrapper<PatentClaimHistory> queryWrapper = new LambdaQueryWrapper<>();
+                queryWrapper.eq(PatentClaimHistory::getIfFirst, !ifFirst)
+                        .eq(PatentClaimHistory::getClaimId, claimId)
+                        .eq(PatentClaimHistory::getOperateType, 2);
+                PatentClaimHistory ifExistFirst = this.getOne(queryWrapper, false);
+                if (ifExistFirst != null) {
+                    Integer order = ifExistFirst.getSysOrder();
+                    LambdaQueryWrapper<PatentClaimHistory> queryWrapper1 = new LambdaQueryWrapper<>();
+                    queryWrapper1.eq(PatentClaimHistory::getIfFirst, !ifFirst)
+                            .in(PatentClaimHistory::getClaimId, sortLaterIds)
+                            .eq(PatentClaimHistory::getOperateType, 2)
+                            .ge(PatentClaimHistory::getSysOrder, order);
+                    List<PatentClaimHistory> firstHistories = this.list(queryWrapper1);
+                    List<PatentClaimHistory> needInsert = new ArrayList<>();
+                    LambdaQueryWrapper<PatentClaimHistory> queryWrapper2 = new LambdaQueryWrapper<>();
+                    queryWrapper2.eq(PatentClaimHistory::getIfFirst, false)
+                            .in(PatentClaimHistory::getClaimId, sortLaterIds)
+                            .eq(PatentClaimHistory::getOperateType, 2);
+                    List<PatentClaimHistory> secondHistories = this.list(queryWrapper2);
+                    if (!secondHistories.isEmpty()) {
+                        List<Integer> secondIds = secondHistories.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
+                        secondHistories.forEach(item -> item.setSysOrder(item.getSysOrder() - 1));
+                        this.updateBatchById(secondHistories);
+                        needInsert = firstHistories.stream().filter(item -> !secondIds.contains(item.getClaimId())).collect(Collectors.toList());
+                    } else {
+                        needInsert = firstHistories;
+                    }
+                    needInsert.forEach(item -> {
+                        PatentClaimHistory needIns = new PatentClaimHistory();
+                        needIns.setClaimId(item.getClaimId());
+                        needIns.setOperateType(2);
+                        needIns.setSysOrder(item.getSysOrder() - 1);
+                        needIns.setCreateId(item.getCreateId());
+                        patentClaimHistories.add(needIns);
+                    });
+                    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)
+                                        .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);
+                    } 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);
+                    }
+                }
             }
         }
-
     }