11/1

src/main/java/cn/cslg/pas/domain/business/PatentClaimHistory.java

@@ -1,6 +1,7 @@
 package cn.cslg.pas.domain.business;
 
 import cn.cslg.pas.domain.BaseEntity;
+import com.baomidou.mybatisplus.annotation.FieldStrategy;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
@@ -35,7 +36,7 @@ public class PatentClaimHistory extends BaseEntity<PatentClaimHistory> {
     /**
      * 修改后序号
      */
-    @TableField(value = "sys_order")
+    @TableField(updateStrategy = FieldStrategy.IGNORED)
     private Integer sysOrder;
 
     /**

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

@@ -157,6 +157,7 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
 
     public void deletePatentClaim(PatentClaimDTO patentClaimDTO){
         Integer claimId = patentClaimDTO.getClaimId();
+        //判空
         Boolean ifFirst = patentClaimDTO.getIfFirst();
         // 根据权要id查询所有原权要
         List<PatentClaim> patentClaims = this.getAllPatentClaims(claimId);
@@ -172,75 +173,86 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
             deleteIds = patentClaimHistoryList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
         }
         allOriginalClaimIds.removeAll(deleteIds);
-        patentClaims.stream()
-                .filter(item -> !allOriginalClaimIds.contains(item.getId()))
+        // 第一层过滤掉已经被删除掉的权利要求
+        List<PatentClaim> firstFilter = patentClaims.stream()
+                .filter(item -> allOriginalClaimIds.contains(item.getId()))
                 .collect(Collectors.toList());
-        // 新增一条删除记录
         List<PatentClaimHistory> patentClaimHistories = new ArrayList<>();
-        PatentClaimHistory deleteClaimHistory = new PatentClaimHistory();
-        deleteClaimHistory.setClaimId(claimId);
-        deleteClaimHistory.setOperateType(1);
-        deleteClaimHistory.setIfFirst(ifFirst);
-        patentClaimHistories.add(deleteClaimHistory);
+        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);
 
-        // 首先到历史表中查询是否存在此条数据 修改序号类型的，后续可以直接更新
-        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);
 
-        if (patentClaimHistory != null) {//后续只需要更新表中
-            Integer deleteOrder = patentClaimHistory.getSysOrder();
-            LambdaQueryWrapper<PatentClaimHistory> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.in(PatentClaimHistory::getClaimId, allOriginalClaimIds)
-                    .eq(PatentClaimHistory::getIfFirst, ifFirst)
-                    .gt(PatentClaimHistory::getSysOrder, deleteOrder);
-            List<PatentClaimHistory> updateClaimHistories = this.list(queryWrapper);
-            updateClaimHistories.forEach(item -> {
-                item.setOperateType(2);
-                item.setSysOrder(item.getSysOrder() - 1);
-            });
-            this.updateBatchById(updateClaimHistories);
-            this.saveBatch(patentClaimHistories);
-        } else {
-            // 这条权要并没有修改过排序，有可能之后的权要被删除过，也有可能没有任何操作
-            // 找出原始权要表中，order大于这个权要order的数据，这些数据的order要比历史表中最小的order的要小
-            PatentClaim patentClaim = patentClaimService.getById(claimId);
-            // 这是所有比需要删除的权要order大的数据（第一层过滤）
-            patentClaims.stream()
-                    .filter(item -> item.getSysOrder() > patentClaim.getSysOrder())
-                    .collect(Collectors.toList());
-            List<Integer> cIds = patentClaims.stream().map(PatentClaim::getId).collect(Collectors.toList());
+                // 找出原始权要表中，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());
 
-            LambdaQueryWrapper<PatentClaimHistory> orderWrapper = new LambdaQueryWrapper<>();
-            orderWrapper.eq(PatentClaimHistory::getOperateType, 2)
-                    .in(PatentClaimHistory::getClaimId, cIds)
-                    .eq(PatentClaimHistory::getIfFirst, ifFirst);
-            List<PatentClaimHistory> orderList = this.list(orderWrapper);
-            //取出有过修改序号的权要ids
-            if (!orderList.isEmpty()) {
-                List<Integer> orderIds = orderList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
-                patentClaims.stream().filter(item -> !orderIds.contains(item.getId())).collect(Collectors.toList());
-                orderIds.retainAll(patentClaims.stream()
-                        .map(PatentClaim::getId)
-                        .collect(Collectors.toList()));
-                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);
+                LambdaQueryWrapper<PatentClaimHistory> orderWrapper = new LambdaQueryWrapper<>();
+                orderWrapper.eq(PatentClaimHistory::getOperateType, 2)
+                        .in(PatentClaimHistory::getClaimId, cIds)
+                        .eq(PatentClaimHistory::getIfFirst, ifFirst);
+                List<PatentClaimHistory> orderList = this.list(orderWrapper);
+                //取出有过修改序号的权要ids
+                if (!orderList.isEmpty()) {
+                    List<Integer> orderIds = orderList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
+                    secondFilter.removeIf(item -> orderIds.contains(item.getId()));
+                    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);
             }
-            patentClaims.forEach(item -> {
-                PatentClaimHistory insertClaimHistory = new PatentClaimHistory();
-                insertClaimHistory.setClaimId(item.getId());
-                insertClaimHistory.setIfFirst(ifFirst);
-                insertClaimHistory.setOperateType(2);
-                patentClaimHistories.add(insertClaimHistory);
-            });
-            this.saveBatch(patentClaimHistories);
+        } else {
+
         }
     }