12/27

src/main/java/cn/cslg/pas/common/dto/invalidDTO/AlterPatentClaimDTO.java

@@ -0,0 +1,31 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+/**
+ * 修改权利要求
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+public class AlterPatentClaimDTO {
+    /**
+     * 权利要求id
+     */
+    private Integer claimId;
+
+    /**
+     * 修改后文本
+     */
+    private String content;
+
+    /**
+     * 修改说明
+     */
+    private String description;
+
+    /**
+     * 是否第一次
+     */
+    private Boolean ifFirst;
+}

src/main/java/cn/cslg/pas/common/dto/invalidDTO/EditPatentClaimHistoryDTO.java

@@ -0,0 +1,25 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+public class EditPatentClaimHistoryDTO {
+    /**
+     * 修改权要历史id
+     */
+    private Integer patentClaimHistoryId;
+
+    /**
+     * 修改后文本
+     */
+    private String content;
+
+    /**
+     * 修改说明
+     */
+    private String description;
+}

src/main/java/cn/cslg/pas/common/dto/invalidDTO/PatentClaimDTO.java

@@ -0,0 +1,13 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+public class PatentClaimDTO {
+    private Integer claimId;
+    private Boolean ifFirst;
+}

src/main/java/cn/cslg/pas/common/vo/invalidVO/PatentClaimHistoryVO.java

@@ -0,0 +1,15 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import lombok.Data;
+
+/**
+ * 权利要求历史VO
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+public class PatentClaimHistoryVO {
+    private QueryPatentClaimHistoryVO originalClaimVO;
+    private QueryPatentClaimHistoryVO firstClaimVO;
+    private QueryPatentClaimHistoryVO secondClaimVO;
+}

src/main/java/cn/cslg/pas/common/vo/invalidVO/QueryPatentClaimHistoryVO.java

@@ -0,0 +1,42 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+
+/**
+ * 权利要求历史VO
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+public class QueryPatentClaimHistoryVO {
+    private Integer projectId;
+    private Integer claimId;
+    private Integer sysOrder;
+    private String content;
+    private Integer claimType;
+    //内容类型
+    private Integer contentType;
+    private String parentOrder;
+
+    /**
+     * 权利要求修改历史id
+     */
+    private Integer claimHistoryId;
+
+    /**
+     * 修改类型（0修改文本  1删除  2修改序号）
+     */
+    private Integer operateType;
+
+    /**
+     * 修改说明
+     */
+    private String description;
+
+    /**
+     * 是否第一次修改
+     */
+    private Boolean ifFirst;
+
+}

src/main/java/cn/cslg/pas/controller/PatentClaimHistoryContorller.java

@@ -0,0 +1,67 @@
+package cn.cslg.pas.controller;
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.dto.invalidDTO.AlterPatentClaimDTO;
+import cn.cslg.pas.common.dto.invalidDTO.EditPatentClaimHistoryDTO;
+import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
+import cn.cslg.pas.common.model.cronModel.Records;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
+import cn.cslg.pas.domain.business.PatentClaimHistory;
+import cn.cslg.pas.service.business.invalidReport.PatentClaimHistoryService;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 权利要求历史
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Slf4j
+@RequestMapping(Constants.API_XiaoSHI + "/patentClaimHistory")
+@RestController
+public class PatentClaimHistoryContorller {
+    @Autowired
+    private PatentClaimHistoryService patentClaimHistoryService;
+
+    @Operation(summary = "修改权利要求")
+    @PostMapping("/alterPatentClaim")
+    public Response alterPatentClaim(@RequestBody AlterPatentClaimDTO alterPatentClaimDTO){
+        Integer id = patentClaimHistoryService.alterPatentClaim(alterPatentClaimDTO);
+        Records records = new Records();
+        records.setData(id);
+        return Response.success(records);
+    }
+
+    @Operation(summary = "编辑权利要求历史")
+    @PostMapping("/editPatentClaimHistory")
+    public Response editPatentClaimHistory(@RequestBody EditPatentClaimHistoryDTO editPatentClaimHistoryDTO){
+        Integer id = patentClaimHistoryService.editPatentClaimHistory(editPatentClaimHistoryDTO);
+        Records records = new Records();
+        records.setData(id);
+        return Response.success(records);
+    }
+
+
+    @Operation(summary = "删除权利要求")
+    @PostMapping("/deletePatentClaim")
+    public Response deletePatentClaim(@RequestBody PatentClaimDTO patentClaimDTO){
+        patentClaimHistoryService.deletePatentClaim(patentClaimDTO);
+        return Response.success("");
+    }
+
+    @Operation(summary = "查看权利要求修改历史")
+    @PostMapping("/queryPatentClaimHistory")
+    public Response queryPatentClaimHistory(@RequestBody PatentClaimDTO patentClaimDTO){
+        PatentClaimHistoryVO patentClaimHistoryVO = patentClaimHistoryService.queryPatentClaimHistory(patentClaimDTO);
+        Records records = new Records();
+        records.setData(patentClaimHistoryVO);
+        return Response.success(records);
+    }
+
+}

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

@@ -0,0 +1,82 @@
+package cn.cslg.pas.domain.business;
+
+import cn.cslg.pas.domain.BaseEntity;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Data
+@TableName("patent_claim_history")
+public class PatentClaimHistory extends BaseEntity<PatentClaimHistory> {
+    /**
+     * 权利要求id
+     */
+    @TableField(value = "claim_id")
+    private Integer claimId;
+
+    /**
+     * 修改类型（0修改文本  1删除  2修改序号）
+     */
+    @TableField(value = "operate_type")
+    private Integer operateType;
+
+    /**
+     * 修改后文本
+     */
+    @TableField(value = "content")
+    private String content;
+
+    /**
+     * 修改后序号
+     */
+    @TableField(value = "sys_order")
+    private Integer sysOrder;
+
+    /**
+     * 修改说明
+     */
+    @TableField(value = "description")
+    private String description;
+
+    /**
+     * 是否第一次修改
+     */
+    @TableField(value = "if_first")
+    private Boolean ifFirst;
+
+    /**
+     * 复审委决定
+     */
+    @TableField(value = "rb_decision")
+    private String rbDecision;
+
+    /**
+     * 一审法院决定
+     */
+    @TableField(value = "court_decision1")
+    private String courtDecision1;
+
+    /**
+     * 二审法院决定
+     */
+    @TableField(value = "court_decision2")
+    private String courtDecision2;
+
+    /**
+     * 创建人
+     */
+    @TableField(value = "create_id")
+    private String createId;
+
+    /**
+     * 创建时间
+     */
+    @TableField(value = "create_time")
+    private Date createTime;
+}

src/main/java/cn/cslg/pas/mapper/InvalidReport/PatentClaimHistoryMapper.java

@@ -0,0 +1,13 @@
+package cn.cslg.pas.mapper.InvalidReport;
+
+import cn.cslg.pas.domain.business.PatentClaimHistory;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Repository
+public interface PatentClaimHistoryMapper extends BaseMapper<PatentClaimHistory> {
+}

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

@@ -0,0 +1,258 @@
+package cn.cslg.pas.service.business.invalidReport;
+
+import cn.cslg.pas.common.dto.invalidDTO.AlterPatentClaimDTO;
+import cn.cslg.pas.common.dto.invalidDTO.EditPatentClaimHistoryDTO;
+import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
+import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
+import cn.cslg.pas.common.vo.invalidVO.QueryPatentClaimHistoryVO;
+import cn.cslg.pas.domain.business.PatentClaim;
+import cn.cslg.pas.domain.business.PatentClaimHistory;
+import cn.cslg.pas.exception.XiaoShiException;
+import cn.cslg.pas.mapper.InvalidReport.PatentClaimHistoryMapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+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.stream.Collectors;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/12/26
+ */
+@Slf4j
+@Service
+public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMapper, PatentClaimHistory> {
+    @Autowired
+    private PatentClaimService patentClaimService;
+
+    /**
+     * 修改权利要求
+     * @param alterPatentClaimDTO
+     */
+    public Integer alterPatentClaim(AlterPatentClaimDTO alterPatentClaimDTO){
+        if (alterPatentClaimDTO == null) {
+            throw new XiaoShiException("入参为空");
+        }
+        Integer claimId = alterPatentClaimDTO.getClaimId();
+        if (claimId == null) {
+            throw new XiaoShiException("claimId为空");
+        }
+        PatentClaimHistory patentClaimHistory = new PatentClaimHistory();
+        BeanUtils.copyProperties(alterPatentClaimDTO, patentClaimHistory);
+        patentClaimHistory.setOperateType(0);
+        patentClaimHistory.setCreateId("328");
+        patentClaimHistory.insert();
+        return patentClaimHistory.getId();
+    }
+
+    /**
+     * 编辑权利要求历史
+     * @param editPatentClaimHistoryDTO
+     * @return
+     */
+    public Integer editPatentClaimHistory(EditPatentClaimHistoryDTO editPatentClaimHistoryDTO){
+        if (editPatentClaimHistoryDTO == null) {
+            throw new XiaoShiException("入参为空");
+        }
+        Integer id = editPatentClaimHistoryDTO.getPatentClaimHistoryId();
+        if (id == null) {
+            throw new XiaoShiException("id为空");
+        }
+        PatentClaimHistory patentClaimHistory = this.getById(id);
+        BeanUtils.copyProperties(editPatentClaimHistoryDTO, patentClaimHistory);
+        patentClaimHistory.updateById();
+        return patentClaimHistory.getId();
+    }
+
+    /**
+     * 查询权利要求修改历史
+     * @param patentClaimDTO
+     * @return
+     */
+    public PatentClaimHistoryVO queryPatentClaimHistory(PatentClaimDTO patentClaimDTO){
+        PatentClaimHistoryVO patentClaimHistoryVO = new PatentClaimHistoryVO();
+
+        if (patentClaimDTO == null) {
+            throw new XiaoShiException("入参为空");
+        }
+        Integer claimId = patentClaimDTO.getClaimId();
+        if (claimId == null) {
+            throw new XiaoShiException("claimId为空");
+        }
+        //装载原始权要
+        QueryPatentClaimHistoryVO originalClaimVO = this.loadOriginalVO(claimId);
+        patentClaimHistoryVO.setOriginalClaimVO(originalClaimVO);
+        //装载权要历史
+        Map<Integer, QueryPatentClaimHistoryVO> historyVOMap = this.loadHistoryVO(claimId);
+        QueryPatentClaimHistoryVO firstClaimVO = historyVOMap.get(1);
+        QueryPatentClaimHistoryVO secondClaimVO = historyVOMap.get(2);
+        patentClaimHistoryVO.setFirstClaimVO(firstClaimVO);
+        patentClaimHistoryVO.setSecondClaimVO(secondClaimVO);
+        return patentClaimHistoryVO;
+    }
+
+    /**
+     * 装载原始权要
+     * @param claimId
+     * @return
+     */
+    public QueryPatentClaimHistoryVO loadOriginalVO(Integer claimId){
+        QueryPatentClaimHistoryVO originalClaimVO = new QueryPatentClaimHistoryVO();
+        LambdaQueryWrapper<PatentClaim> getOriginalWrapper = new LambdaQueryWrapper<>();
+        getOriginalWrapper.eq(PatentClaim::getId, claimId);
+        PatentClaim patentClaim = patentClaimService.getOne(getOriginalWrapper, false);
+        if (patentClaim != null) {
+            BeanUtils.copyProperties(patentClaim, originalClaimVO);
+            originalClaimVO.setClaimId(patentClaim.getId());
+        }
+        return originalClaimVO;
+    }
+
+    public Map<Integer, QueryPatentClaimHistoryVO> loadHistoryVO(Integer claimId){
+        Map<Integer, QueryPatentClaimHistoryVO> historyVOMap = new HashMap<>();
+
+        LambdaQueryWrapper<PatentClaimHistory> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(PatentClaimHistory::getClaimId, claimId);
+        List<PatentClaimHistory> patentClaimHistoryList = this.list(queryWrapper);
+        if (!patentClaimHistoryList.isEmpty()) {
+            if (patentClaimHistoryList.size() == 1 || patentClaimHistoryList.size() == 2) {
+                //只有一次修改
+                QueryPatentClaimHistoryVO firstClaimVO = new QueryPatentClaimHistoryVO();
+                PatentClaimHistory patentClaimHistory = patentClaimHistoryList.get(0);
+                if (patentClaimHistory.getIfFirst() == false) {
+                    throw new XiaoShiException("历史错误");
+                }
+                //历史id
+                firstClaimVO.setClaimHistoryId(patentClaimHistory.getId());
+                BeanUtils.copyProperties(patentClaimHistory, firstClaimVO);
+                historyVOMap.put(1, firstClaimVO);
+            }
+            if (patentClaimHistoryList.size() == 2) {
+                //修改了两次
+                QueryPatentClaimHistoryVO secondClaimVO = new QueryPatentClaimHistoryVO();
+                PatentClaimHistory patentClaimHistory = patentClaimHistoryList.get(1);
+                if (patentClaimHistory.getIfFirst() == true) {
+                    throw new XiaoShiException("历史错误");
+                }
+                //历史id
+                secondClaimVO.setClaimHistoryId(patentClaimHistory.getId());
+                BeanUtils.copyProperties(patentClaimHistory, secondClaimVO);
+                historyVOMap.put(2, secondClaimVO);
+            } else {
+                throw new XiaoShiException("查询错误");
+            }
+        }
+        return historyVOMap;
+    }
+
+
+    public void deletePatentClaim(PatentClaimDTO patentClaimDTO){
+        Integer claimId = patentClaimDTO.getClaimId();
+        Boolean ifFirst = patentClaimDTO.getIfFirst();
+        // 根据权要id查询所有原权要
+        List<PatentClaim> patentClaims = this.getAllPatentClaims(claimId);
+        List<Integer> allOriginalClaimIds = patentClaims.stream().map(PatentClaim::getId).collect(Collectors.toList());
+        // 除去已经删除的
+        LambdaQueryWrapper<PatentClaimHistory> isDeleteWrapper = new LambdaQueryWrapper<>();
+        isDeleteWrapper.eq(PatentClaimHistory::getOperateType, 1)
+                .in(PatentClaimHistory::getClaimId, allOriginalClaimIds);
+        List<PatentClaimHistory> patentClaimHistoryList = this.list(isDeleteWrapper);
+        List<Integer> deleteIds = new ArrayList<>();
+        if (!patentClaimHistoryList.isEmpty()) {
+            // 有权要已经被删除
+            deleteIds = patentClaimHistoryList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
+        }
+        allOriginalClaimIds.removeAll(deleteIds);
+        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);
+
+        // 首先到历史表中查询是否存在此条数据 修改序号类型的，后续可以直接更新
+        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)
+                    .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());
+
+            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);
+            }
+            patentClaims.forEach(item -> {
+                PatentClaimHistory insertClaimHistory = new PatentClaimHistory();
+                insertClaimHistory.setClaimId(item.getId());
+                insertClaimHistory.setIfFirst(ifFirst);
+                insertClaimHistory.setOperateType(2);
+                patentClaimHistories.add(insertClaimHistory);
+            });
+            this.saveBatch(patentClaimHistories);
+        }
+    }
+
+
+    public List<PatentClaim> getAllPatentClaims(Integer claimId){
+        LambdaQueryWrapper<PatentClaim> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(PatentClaim::getId, claimId);
+        PatentClaim patentClaim = patentClaimService.getOne(queryWrapper, false);
+        Integer projectId = patentClaim.getProjectId();
+        LambdaQueryWrapper<PatentClaim> queryWrapper1 = new LambdaQueryWrapper<>();
+        queryWrapper1.eq(PatentClaim::getProjectId, projectId);
+        List<PatentClaim> patentClaims = patentClaimService.list(queryWrapper1);
+        return patentClaims;
+    }
+}

src/test/java/cn/cslg/pas/service/ProjectTaskServiceTests.java

@@ -1,13 +1,18 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.dto.invalidDTO.AlterPatentClaimDTO;
+import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
 import cn.cslg.pas.common.model.request.OrderDTO;
 import cn.cslg.pas.common.model.request.StringGroupRequest;
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
 import cn.cslg.pas.controller.EventController;
+import cn.cslg.pas.controller.PatentClaimHistoryContorller;
 import cn.cslg.pas.controller.PatentDigProjectFilesController;
 import cn.cslg.pas.controller.ProjectTaskController;
 import cn.cslg.pas.service.business.PatentDigProjectFilesService;
 import cn.cslg.pas.service.business.PatentNoSplitterService;
+import cn.cslg.pas.service.business.invalidReport.PatentClaimHistoryService;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.http.entity.ContentType;
 import org.junit.Assert;
@@ -36,6 +41,8 @@ public class ProjectTaskServiceTests {
 
     @Autowired
     private PatentDigProjectFilesService patentDigProjectFilesService;
+    @Autowired
+    private PatentClaimHistoryService patentClaimHistoryService;
 
 
 
@@ -92,6 +99,21 @@ public class ProjectTaskServiceTests {
         System.out.println(countMap);
     }
 
+    @Test
+        void alterPatentClaim(){
+        AlterPatentClaimDTO alterPatentClaimDTO = new AlterPatentClaimDTO();
+        alterPatentClaimDTO.setClaimId(74);
+        alterPatentClaimDTO.setContent("第一次修改后文本");
+        alterPatentClaimDTO.setDescription("第一次测试描述");
+        alterPatentClaimDTO.setIfFirst(true);
+        patentClaimHistoryService.alterPatentClaim(alterPatentClaimDTO);
+    }
 
-
+    @Test
+    void queryPatentClaim(){
+        PatentClaimDTO patentClaimDTO = new PatentClaimDTO();
+        patentClaimDTO.setClaimId(74);
+        PatentClaimHistoryVO patentClaimHistoryVO = patentClaimHistoryService.queryPatentClaimHistory(patentClaimDTO);
+        System.out.println(patentClaimHistoryVO);
+    }
 }