Merge branch 'shaoyin'

src/main/java/cn/cslg/pas/common/dto/FinalProofGroupDTO.java

@@ -0,0 +1,27 @@
+package cn.cslg.pas.common.dto;
+
+import lombok.Data;
+
+@Data
+public class FinalProofGroupDTO {
+
+    private Integer proofGroupId;
+
+    private Integer invalidStatueId;
+
+    private String invalidReason;
+
+    private String presentOpinions;
+
+    private Integer projectId;
+
+    private String rbDecision;
+
+    private Integer featureSort;
+
+    private String featureContent;
+
+    private String courtOpinions1;
+
+    private String courtOpinions2;
+}

src/main/java/cn/cslg/pas/common/dto/GetInvalidReasonClaimsDTO.java

@@ -0,0 +1,13 @@
+package cn.cslg.pas.common.dto;
+
+import lombok.Data;
+
+@Data
+public class GetInvalidReasonClaimsDTO {
+
+    //专题库id
+    private Integer projectId;
+
+    //法条类型    1三性  2非三性
+    private Integer statueType;
+}

src/main/java/cn/cslg/pas/common/dto/InvalidReasonDTO.java

@@ -0,0 +1,22 @@
+package cn.cslg.pas.common.dto;
+
+import lombok.Data;
+
+@Data
+public class InvalidReasonDTO {
+
+    //无效理由法条id
+    private Integer invalidStatueId;
+
+    //法条id
+    private Integer statuteId;
+
+    //权要序号
+    private Integer claimSort;
+
+    //权要内容
+    private String claimText;
+
+    //专题库id
+    private Integer projectId;
+}

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

@@ -8,4 +8,5 @@ import lombok.Data;
 @Data
 public class QueryClaimDTO {
     private  Integer projectId;
+    private  Integer editVersion;
 }

src/main/java/cn/cslg/pas/common/vo/GetInvalidReasonClaimsVO.java

@@ -0,0 +1,32 @@
+package cn.cslg.pas.common.vo;
+
+import cn.cslg.pas.common.dto.InvalidReasonDTO;
+import lombok.Data;
+
+
+@Data
+public class GetInvalidReasonClaimsVO {
+
+    private InvalidReasonDTO invalidReasonDTO;
+
+    private Integer proofGroupId;
+
+    private Integer invalidStatueId;
+
+    private String invalidReason;
+
+    private String presentOpinions;
+
+    private Integer projectId;
+
+    private String rbDecision;
+
+    private Integer featureSort;
+
+    private String featureContent;
+
+    private String courtOpinions1;
+
+    private String courtOpinions2;
+
+}

src/main/java/cn/cslg/pas/common/vo/PersonSelfFieldVO.java

@@ -35,5 +35,6 @@ public class PersonSelfFieldVO {
     private Boolean ifPersonal;
     private Boolean ifSort=true;
     private Boolean ifNotOrder;
+    private Boolean editable;
 
 }

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

@@ -1,6 +1,9 @@
 package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.dto.FinalProofGroupDTO;
+import cn.cslg.pas.common.dto.InvalidReasonDTO;
+import cn.cslg.pas.common.dto.GetInvalidReasonClaimsDTO;
 import cn.cslg.pas.common.dto.business.InvalidStatutesDTO;
 import cn.cslg.pas.common.dto.invalidDTO.GetInvalidStatutesDTO;
 import cn.cslg.pas.common.dto.invalidDTO.UpdateMessageDTO;
@@ -9,13 +12,13 @@ import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupEditDTO;
 import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupQueryDTO;
 import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupVO;
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.GetInvalidReasonClaimsVO;
 import cn.cslg.pas.common.vo.invalidVO.InvalidStatutesVO;
 import cn.cslg.pas.service.FinalInvalidStatueService;
 import cn.cslg.pas.service.business.InvalidStatutesService;
 import io.swagger.v3.oas.annotations.Operation;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.ArrayList;
@@ -115,4 +118,87 @@ public class InvalidStatutesController {
         }
         return Response.success(records);
     }
+
+    //----------------------------------韶音 三性/非三性------------------
+    @Operation(summary = "添加无效理由")
+    @PostMapping("/addInvalidReason")
+    public Response addInvalidReason(@RequestBody InvalidReasonDTO vo) {
+        Integer invalidStatueId = null;
+        try {
+            invalidStatueId = finalInvalidStatueService.addInvalidReason(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(invalidStatueId);
+    }
+
+    @Operation(summary = "查询三性/非三性无效理由")
+    @PostMapping("/getInvalidReasonClaims")
+    public Response getInvalidReasonClaims(@RequestBody GetInvalidReasonClaimsDTO vo) {
+        List<GetInvalidReasonClaimsVO> claimsVOS = new ArrayList<>();
+        try {
+            claimsVOS = finalInvalidStatueService.getInvalidReasonClaims(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(claimsVOS);
+    }
+
+    @Operation(summary = "修改无效理由")
+    @PostMapping("/editInvalidReason")
+    public Response editInvalidReason(@RequestBody InvalidReasonDTO vo) {
+        Integer invalidStatueId = null;
+        try {
+            invalidStatueId = finalInvalidStatueService.editInvalidReason(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(invalidStatueId);
+    }
+
+    @Operation(summary = "删除无效理由")
+    @PostMapping("/delInvalidReason")
+    public Response delInvalidReason(@RequestBody InvalidReasonDTO vo) {
+        try {
+            finalInvalidStatueService.delInvalidReason(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success("删除成功");
+    }
+
+    @Operation(summary = "添加特征")
+    @PostMapping("/addFeature")
+    public Response addFeature(@RequestBody FinalProofGroupDTO vo) {
+        Integer proofGroupId = null;
+        try {
+            proofGroupId = finalInvalidStatueService.addFeature(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(proofGroupId);
+    }
+
+    @Operation(summary = "编辑特征")
+    @PostMapping("/editFeature")
+    public Response editFeature(@RequestBody FinalProofGroupDTO vo) {
+        Integer proofGroupId = null;
+        try {
+            proofGroupId = finalInvalidStatueService.editFeature(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(proofGroupId);
+    }
+
+    @Operation(summary = "删除特征")
+    @PostMapping("/delFeature")
+    public Response delFeature(@RequestBody FinalProofGroupDTO vo) {
+        try {
+            finalInvalidStatueService.delFeature(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success("删除成功");
+    }
 }

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

@@ -67,5 +67,13 @@ public class PatentClaimController {
         }
         return Response.success("更新成功");
     }
+    //更新权要法院意见等信息
+    @Operation(summary = "获取不同版本的权利要求")
+    @PostMapping("/getVersionClaims")
+    public Response getVersionClaims(@RequestBody QueryClaimDTO queryClaimDTO) throws Exception {
+        List<PatentClaimVO> patentClaimVOS  = patentClaimService.getVersionPatentClaim(queryClaimDTO);
+        return Response.success(patentClaimVOS);
+    }
+
 
 }

src/main/java/cn/cslg/pas/domain/FinalProofGroup.java

@@ -13,7 +13,6 @@ import lombok.Data;
 @Data
 public class FinalProofGroup extends BaseEntity<FinalProofGroup> {
 
-
     private Integer finalInvalidStatueId;
 
     private String invalidReason;
@@ -28,4 +27,12 @@ public class FinalProofGroup extends BaseEntity<FinalProofGroup> {
 
     private Date createTime;
 
+    private Integer featureSort;
+
+    private String featureContent;
+
+    private String courtOpinions1;
+
+    private String courtOpinions2;
+
 }

src/main/java/cn/cslg/pas/service/FinalInvalidStatueService.java

@@ -1,15 +1,24 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.dto.FinalProofGroupDTO;
+import cn.cslg.pas.common.dto.InvalidReasonDTO;
+import cn.cslg.pas.common.dto.GetInvalidReasonClaimsDTO;
 import cn.cslg.pas.common.dto.invalidDTO.PatentClaimDTO;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
 import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupEditDTO;
 import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupQueryDTO;
 import cn.cslg.pas.common.model.finalInvalid.FinalProfGroupVO;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.common.vo.GetInvalidReasonClaimsVO;
 import cn.cslg.pas.common.vo.invalidVO.PatentClaimHistoryVO;
+import cn.cslg.pas.domain.BaseEntity;
 import cn.cslg.pas.domain.FinalInvalidStatue;
 import cn.cslg.pas.domain.FinalProofGroup;
 import cn.cslg.pas.domain.business.InvalidStatutes;
-import cn.cslg.pas.domain.business.ProofGroup;
+import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.FinalInvalidStatueMapper;
+import cn.cslg.pas.mapper.FinalProofGroupMapper;
 import cn.cslg.pas.service.business.InvalidStatutesService;
 import cn.cslg.pas.service.business.ProofGroupService;
 import cn.cslg.pas.service.business.invalidReport.PatentClaimHistoryService;
@@ -17,9 +26,14 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.elasticsearch.core.query.UpdateQuery;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -37,6 +51,12 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
     private static List<Integer> inStatueIds = Arrays.asList(2, 3, 4);
     private final ProofGroupService proofGroupService;
     private final FinalProofGroupService finalProofGroupService;
+    private final FinalInvalidStatueMapper invalidStatueMapper;
+    private final FinalProofGroupMapper proofGroupMapper;
+    @Autowired
+    private CacheUtils cacheUtils;
+    @Autowired
+    private LoginUtils loginUtils;
 
     public void ImportByProjectId(Integer projectId, Integer statueType) {
 
@@ -88,7 +108,7 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
         map.put("claimText", claimText);
         map.put("court1", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision1());
         map.put("court2", patentClaimHistoryVO.getOriginalClaimVO().getCourtDecision2());
-        if( patentClaimHistoryVO.getOriginalClaimVO().getSysOrder()!=null) {
+        if (patentClaimHistoryVO.getOriginalClaimVO().getSysOrder() != null) {
             map.put("index", patentClaimHistoryVO.getOriginalClaimVO().getSysOrder().toString());
         }
         return map;
@@ -102,8 +122,8 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
         //根据projectId查询最终无效理由和证据
         LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId)
-                    .orderByAsc(FinalInvalidStatue::getStatuteId)
-                    .orderByAsc(FinalInvalidStatue::getClaimOrder);
+                .orderByAsc(FinalInvalidStatue::getStatuteId)
+                .orderByAsc(FinalInvalidStatue::getClaimOrder);
 
         if (statusType != null) {
             if (statusType.equals(1)) {
@@ -124,21 +144,20 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
         queryWrapper1.in(FinalProofGroup::getFinalInvalidStatueId, ids);
         finalProofGroups = finalProofGroupService.list(queryWrapper1);
 
-        for(FinalInvalidStatue finalInvalidStatue:finalInvalidStatues)
-        {
-            Integer id =finalInvalidStatue.getId();
- List<FinalProofGroup> statueGroups =finalProofGroups.stream().filter(item->item.getFinalInvalidStatueId().equals(id)).collect(Collectors.toList());
- statueGroups.forEach(item->{
-     FinalProfGroupVO finalProfGroupVO = new FinalProfGroupVO();
-     if (finalInvalidStatue != null) {
-         finalProfGroupVO.setInvalidStatue(finalInvalidStatue);
-     }
-     finalProfGroupVO.setId(item.getId());
-     finalProfGroupVO.setPresentOpinions(item.getPresentOpinions());
-     finalProfGroupVO.setInvalidReason(item.getInvalidReason());
-     finalProfGroupVO.setRbDecision(item.getRbDecision());
-     finalProfGroupVOS.add(finalProfGroupVO);
- });
+        for (FinalInvalidStatue finalInvalidStatue : finalInvalidStatues) {
+            Integer id = finalInvalidStatue.getId();
+            List<FinalProofGroup> statueGroups = finalProofGroups.stream().filter(item -> item.getFinalInvalidStatueId().equals(id)).collect(Collectors.toList());
+            statueGroups.forEach(item -> {
+                FinalProfGroupVO finalProfGroupVO = new FinalProfGroupVO();
+                if (finalInvalidStatue != null) {
+                    finalProfGroupVO.setInvalidStatue(finalInvalidStatue);
+                }
+                finalProfGroupVO.setId(item.getId());
+                finalProfGroupVO.setPresentOpinions(item.getPresentOpinions());
+                finalProfGroupVO.setInvalidReason(item.getInvalidReason());
+                finalProfGroupVO.setRbDecision(item.getRbDecision());
+                finalProfGroupVOS.add(finalProfGroupVO);
+            });
         }
         return finalProfGroupVOS;
     }
@@ -215,6 +234,221 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
         finalProofGroupService.remove(queryWrapper1);
 
     }
+
+    /**
+     * 添加无效理由
+     * @param vo
+     * @return
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public Integer addInvalidReason(InvalidReasonDTO vo) {
+        final Integer claimSort = vo.getClaimSort();
+        final Integer statuteId = vo.getStatuteId();
+        final String claimText = vo.getClaimText();
+        final Long count = invalidStatueMapper.selectCount(new LambdaQueryWrapper<FinalInvalidStatue>()
+                .eq(FinalInvalidStatue::getStatuteId, statuteId)
+                .eq(FinalInvalidStatue::getClaimOrder, claimSort)
+                .eq(FinalInvalidStatue::getProjectId, vo.getProjectId()));
+        if (count > 0) {
+            throw new XiaoShiException("该法条下已存在相同权利要求");
+        }
+        FinalInvalidStatue statue = new FinalInvalidStatue();
+        statue.setStatuteId(statuteId);
+        statue.setClaimOrder(claimSort);
+        statue.setClaimText(claimText);
+        statue.setProjectId(vo.getProjectId());
+        //获取登陆人信息 用于设置创建人
+        PersonnelVO personnelVO = new PersonnelVO();
+        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        if (ObjectUtils.isEmpty(personnelVO)) {
+            throw new XiaoShiException("未获取到创建人");
+        }
+        statue.setCreateId(personnelVO.getId());
+        statue.setCreateTime(new Date());
+        statue.insert();
+
+        FinalProofGroup proofGroup = new FinalProofGroup();
+        proofGroup.setFinalInvalidStatueId(statue.getId());
+        proofGroup.setProjectId(vo.getProjectId());
+        proofGroup.setFeatureSort(1);
+        proofGroup.setCreateId(personnelVO.getId());
+        proofGroup.setCreateTime(new Date());
+        proofGroup.insert();
+        return statue.getId();
+    }
+
+    /**
+     * 查询三性/非三性无效理由
+     * @param vo
+     * @return
+     */
+    public List<GetInvalidReasonClaimsVO> getInvalidReasonClaims(GetInvalidReasonClaimsDTO vo) {
+        List<GetInvalidReasonClaimsVO> claimsVOS = new ArrayList<>();
+        Integer projectId = vo.getProjectId();
+        Integer statusType = vo.getStatueType();
+        //根据projectId查询最终无效理由和证据
+        LambdaQueryWrapper<FinalInvalidStatue> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(FinalInvalidStatue::getProjectId, projectId)
+                .orderByAsc(FinalInvalidStatue::getStatuteId)
+                .orderByAsc(FinalInvalidStatue::getClaimOrder);
+        if (statusType != null) {
+            if (statusType == 1) {
+                queryWrapper.in(FinalInvalidStatue::getStatuteId, inStatueIds);
+            } else {
+                queryWrapper.notIn(FinalInvalidStatue::getStatuteId, inStatueIds);
+            }
+        }
+        List<FinalInvalidStatue> statueList = this.list(queryWrapper);
+        if (CollectionUtils.isEmpty(statueList)) {
+            return claimsVOS;
+        }
+        List<Integer> invalidStatueIds = statueList.stream().map(FinalInvalidStatue::getId).collect(Collectors.toList());
+        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
+                .in(FinalProofGroup::getFinalInvalidStatueId, invalidStatueIds)
+                .orderByAsc(FinalProofGroup::getFeatureSort));
+        for (FinalInvalidStatue statue : statueList) {
+             Integer invalidStatueId = statue.getId();
+            List<FinalProofGroup> statueGroups = proofGroups.stream().filter(item -> item.getFinalInvalidStatueId().equals(invalidStatueId)).collect(Collectors.toList());
+            statueGroups.forEach(item -> {
+                GetInvalidReasonClaimsVO claimsVO = new GetInvalidReasonClaimsVO();
+                InvalidReasonDTO invalidReasonDTO = new InvalidReasonDTO();
+                invalidReasonDTO.setInvalidStatueId(statue.getId());
+                invalidReasonDTO.setStatuteId(statue.getStatuteId());
+                invalidReasonDTO.setProjectId(statue.getProjectId());
+                invalidReasonDTO.setClaimSort(statue.getClaimOrder());
+                invalidReasonDTO.setClaimText(statue.getClaimText());
+                claimsVO.setInvalidReasonDTO(invalidReasonDTO);
+                claimsVO.setProofGroupId(item.getId());
+                claimsVO.setInvalidStatueId(statue.getId());
+                claimsVO.setProjectId(item.getProjectId());
+                claimsVO.setInvalidReason(item.getInvalidReason());
+                claimsVO.setPresentOpinions(item.getPresentOpinions());
+                claimsVO.setRbDecision(item.getRbDecision());
+                claimsVO.setFeatureSort(item.getFeatureSort());
+                claimsVO.setFeatureContent(item.getFeatureContent());
+                claimsVO.setCourtOpinions1(item.getCourtOpinions1());
+                claimsVO.setCourtOpinions2(item.getCourtOpinions2());
+                claimsVOS.add(claimsVO);
+            });
+        }
+        return claimsVOS;
+    }
+
+    /**
+     * 修改无效理由
+     * @param vo
+     * @return
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public Integer editInvalidReason(InvalidReasonDTO vo) {
+        final Integer claimSort = vo.getClaimSort();
+        final Integer statuteId = vo.getStatuteId();
+        final String claimText = vo.getClaimText();
+        final Long count = invalidStatueMapper.selectCount(new LambdaQueryWrapper<FinalInvalidStatue>()
+                .eq(FinalInvalidStatue::getStatuteId, statuteId)
+                .eq(FinalInvalidStatue::getClaimOrder, claimSort)
+                .eq(FinalInvalidStatue::getProjectId, vo.getProjectId())
+                .ne(FinalInvalidStatue::getId, vo.getInvalidStatueId()));
+        if (count > 0) {
+            throw new XiaoShiException("该法条下已存在相同权利要求");
+        }
+        FinalInvalidStatue statue = invalidStatueMapper.selectById(vo.getInvalidStatueId());
+        statue.setStatuteId(statuteId);
+        statue.setClaimOrder(claimSort);
+        statue.setClaimText(claimText);
+        statue.setProjectId(vo.getProjectId());
+        statue.updateById();
+        return statue.getId();
+    }
+
+    /**
+     * 删除无效理由
+     * @param vo
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public void delInvalidReason(InvalidReasonDTO vo) {
+        Integer invalidStatueId = vo.getInvalidStatueId();
+        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
+                .eq(FinalProofGroup::getFinalInvalidStatueId, invalidStatueId));
+        if (!CollectionUtils.isEmpty(proofGroups)) {
+            List<Integer> list = proofGroups.stream().map(BaseEntity::getId).collect(Collectors.toList());
+            proofGroupMapper.deleteBatchIds(list);
+        }
+        invalidStatueMapper.deleteById(invalidStatueId);
+    }
+
+    /**
+     * 添加特征
+     * @param vo
+     * @return
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public Integer addFeature(FinalProofGroupDTO vo) {
+        editProofSort(vo.getInvalidStatueId(), vo.getFeatureSort(), 1);
+        FinalProofGroup proofGroup = new FinalProofGroup();
+        proofGroup.setFinalInvalidStatueId(vo.getInvalidStatueId());
+        BeanUtils.copyProperties(vo, proofGroup);
+        //获取登陆人信息 用于设置创建人
+        PersonnelVO personnelVO = new PersonnelVO();
+        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        if (ObjectUtils.isEmpty(personnelVO)) {
+            throw new XiaoShiException("未获取到创建人");
+        }
+        proofGroup.setCreateId(personnelVO.getId());
+        proofGroup.setCreateTime(new Date());
+        proofGroup.insert();
+
+        return proofGroup.getId();
+    }
+
+    /**
+     * 修改特征序号
+     * @param invalidStatueId
+     * @param featureSort
+     * @param type
+     */
+    public void editProofSort(Integer invalidStatueId, Integer featureSort, Integer type) {
+        List<FinalProofGroup> proofGroups = proofGroupMapper.selectList(new LambdaQueryWrapper<FinalProofGroup>()
+                .eq(FinalProofGroup::getFinalInvalidStatueId, invalidStatueId)
+                .ge(FinalProofGroup::getFeatureSort, featureSort));
+        if (!CollectionUtils.isEmpty(proofGroups)) {
+            for (FinalProofGroup proofGroup : proofGroups) {
+                proofGroup.setId(proofGroup.getId());
+                if (type == 1) {
+                    proofGroup.setFeatureSort(proofGroup.getFeatureSort() + 1);
+                } else {
+                    proofGroup.setFeatureSort(proofGroup.getFeatureSort() - 1);
+                }
+                proofGroup.updateById();
+            }
+
+        }
+    }
+
+    /**
+     * 编辑特征
+     * @param vo
+     * @return
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public Integer editFeature(FinalProofGroupDTO vo) {
+        FinalProofGroup proofGroup = proofGroupMapper.selectById(vo.getProofGroupId());
+        proofGroup.setFinalInvalidStatueId(vo.getInvalidStatueId());
+        BeanUtils.copyProperties(vo, proofGroup);
+        proofGroup.updateById();
+        return proofGroup.getId();
+    }
+
+    /**
+     * 删除特征
+     * @param vo
+     */
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public void delFeature(FinalProofGroupDTO vo) {
+        FinalProofGroup proofGroup = proofGroupMapper.selectById(vo.getProofGroupId());
+        editProofSort(proofGroup.getFinalInvalidStatueId(), proofGroup.getFeatureSort(), 2);
+        proofGroupMapper.deleteById(proofGroup.getId());
+    }
 }
 
 

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

@@ -260,8 +260,7 @@ public class PatentClaimService extends ServiceImpl<PatentClaimMapper, PatentCla
         for (PatentClaimDTO patentClaimDTO : patentClaims) {
             if (patentClaimDTO.getIfUpdate() != null && patentClaimDTO.getIfUpdate().equals(0)) {
                 continue;
-            }
-            else {
+            } else {
                 PatentClaim patentClaim = this.dtoToDomain(patentClaimDTO);
                 patentClaim.setCreateId(personnelVO.getId());
                 patentClaim.setClaimMessageId(claimMessageId);
@@ -285,4 +284,67 @@ public class PatentClaimService extends ServiceImpl<PatentClaimMapper, PatentCla
         return patentClaim;
     }
 
+    public List<PatentClaimVO> getVersionPatentClaim(QueryClaimDTO queryClaimDTO) {
+        List<PatentClaimVO> patentClaimVOS = new ArrayList<>();
+        Integer projectId = queryClaimDTO.getProjectId();
+        Integer editVersion = queryClaimDTO.getEditVersion();
+        if (editVersion == null || editVersion != 2) {
+            editVersion = 1;
+        }
+
+        //根据projectId查询出所有权利要求
+        LambdaQueryWrapper<PatentClaim> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(PatentClaim::getProjectId, projectId).orderByAsc(PatentClaim::getSysOrder);
+        List<PatentClaim> patentClaims = this.list(queryWrapper);
+        if (patentClaims == null || patentClaims.size() == 0) {
+            return patentClaimVOS;
+        }
+        List<Integer> claimIds = patentClaims.stream().map(PatentClaim::getId).collect(Collectors.toList());
+
+        // 查询无效历史
+        LambdaQueryWrapper<PatentClaimHistory> queryWrapper1 = new LambdaQueryWrapper<>();
+        queryWrapper1.ne(PatentClaimHistory::getOperateType, 2).
+                in(PatentClaimHistory::getClaimId, claimIds);
+        //如果只查询版本1
+        if (editVersion == 1) {
+            queryWrapper1.eq(PatentClaimHistory::getIfFirst, true);
+        }
+        List<PatentClaimHistory> patentClaimHistoryList = patentClaimHistoryService.list(queryWrapper1);
+
+        Integer index = 0;
+        //遍历权利要求
+        for (PatentClaim patentClaim : patentClaims) {
+            PatentClaimVO patentClaimVO = new PatentClaimVO();
+            patentClaimVO.setContent(patentClaim.getContent());
+            patentClaimVO.setClaimType(patentClaim.getClaimType());
+            patentClaimVO.setSysOrder(index);
+            patentClaimVO.setId(patentClaim.getId());
+            List<PatentClaimHistory> calimHistories = patentClaimHistoryList.stream().filter(item -> item.getClaimId().equals(patentClaim.getId())).collect(Collectors.toList());
+
+            PatentClaimHistory deleteClaimHistory = calimHistories.stream().filter(item -> item.getOperateType().equals(1)).findFirst().orElse(null);
+            //查看是否有删除的历史记录，如果有则直接跳过
+            if (deleteClaimHistory != null) {
+                continue;
+            }
+
+            List<PatentClaimHistory> editClaimHistories = calimHistories.stream().filter(item -> item.getOperateType().equals(0)).collect(Collectors.toList());
+            if (editVersion == 1) {
+                if (editClaimHistories != null && editClaimHistories.size() > 0) {
+                    patentClaimVO.setContent(editClaimHistories.get(0).getContent());
+                }
+            } else if (editVersion == 2) {
+                PatentClaimHistory editClaimHistory = editClaimHistories.stream().filter(item -> item.getIfFirst().equals(false)).findFirst().orElse(null);
+                if (editClaimHistory == null) {
+                    editClaimHistory = editClaimHistories.stream().filter(item -> item.getIfFirst().equals(true)).findFirst().orElse(null);
+                }
+                if (editClaimHistory != null) {
+                    patentClaimVO.setContent(editClaimHistory.getContent());
+                }
+            }
+            patentClaimVOS.add(patentClaimVO);
+            index++;
+        }
+
+        return patentClaimVOS;
+    }
 }

src/main/resources/jsons/claimManage.json

@@ -0,0 +1,44 @@
+[
+  {"name":"第一次修改后权要内容",
+    "type":"String",
+    "value":"historyContent1",
+    "field":"historyContent1",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false"
+  },
+  {"name":"第一次修改说明",
+    "type":"String",
+    "value":"historyDescription1",
+    "field":"historyDescription1",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false"
+  },
+  {"name":"第二次修改后权要内容",
+    "type":"String",
+    "value":"historyContent2",
+    "field":"historyContent2",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "defaultHidden": "true"
+  },
+  {"name":"第二次修改说明",
+    "type":"String",
+    "value":"historyDescription2",
+    "field":"historyDescription2",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "defaultHidden": "true"
+  }
+]

src/main/resources/jsons/finalInvalidReason.json

@@ -0,0 +1,87 @@
+[
+  {"name":"法条",
+    "type":"String",
+    "value":"invalidReasonDTO.statuteId",
+    "field":"invalidReasonDTO.statuteId",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":false
+  },
+  {"name":"权利要求",
+    "type":"String",
+    "value":"invalidReasonDTO.claimText",
+    "field":"invalidReasonDTO.claimText",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  },
+  {"name":"具体理由",
+    "type":"String",
+    "value":"invalidReason",
+    "field":"invalidReason",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  },
+  {"name":"权利人答复",
+    "type":"String",
+    "value":"presentOpinions",
+    "field":"presentOpinions",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"合议组认定",
+    "type":"String",
+    "value":"rbDecision",
+    "field":"rbDecision",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"一审",
+    "type":"String",
+    "value":"courtOpinions1",
+    "field":"courtOpinions1",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"二审",
+    "type":"String",
+    "value":"courtOpinions2",
+    "field":"courtOpinions2",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true,
+    "defaultHidden": "true"
+  }
+]
+
+
+
+

src/main/resources/jsons/finalInvalidReasonInThree.json

@@ -0,0 +1,98 @@
+[
+  {"name":"法条",
+    "type":"String",
+    "value":"invalidReasonDTO.statuteId",
+    "field":"invalidReasonDTO.statuteId",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":false
+  },
+  {"name":"权利要求",
+    "type":"String",
+    "value":"invalidReasonDTO.claimSort",
+    "field":"invalidReasonDTO.claimSort",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":false
+  },
+  {"name":"特征",
+    "type":"String",
+    "value":"featureContent",
+    "field":"featureContent",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  },
+  {"name":"证据公开",
+    "type":"String",
+    "value":"invalidReason",
+    "field":"invalidReason",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  },
+  {"name":"权利人答复",
+    "type":"String",
+    "value":"presentOpinions",
+    "field":"presentOpinions",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"合议组认定",
+    "type":"String",
+    "value":"rbDecision",
+    "field":"rbDecision",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"一审",
+    "type":"String",
+    "value":"courtOpinions1",
+    "field":"courtOpinions1",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true
+  }
+,
+  {"name":"二审",
+    "type":"String",
+    "value":"courtOpinions2",
+    "field":"courtOpinions2",
+    "sqlField": "",
+    "ifSearch":"false",
+    "ifGroup": "false",
+    "ifShow":"true",
+    "ifAsCondition": "false",
+    "editable":true,
+    "defaultHidden": "true"
+  }
+]
+
+
+
+

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

@@ -0,0 +1,162 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.dto.FinalProofGroupDTO;
+import cn.cslg.pas.common.dto.GetInvalidReasonClaimsDTO;
+import cn.cslg.pas.common.dto.InvalidReasonDTO;
+import cn.cslg.pas.common.vo.GetInvalidReasonClaimsVO;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.List;
+
+@SpringBootTest
+public class InvalidStatueTests {
+
+    @Autowired
+    private FinalInvalidStatueService finalInvalidStatueService;
+
+    public static InvalidReasonDTO addInvalid() {
+        InvalidReasonDTO dto = new InvalidReasonDTO();
+        dto.setStatuteId(3);
+        dto.setProjectId(368);
+        dto.setClaimSort(3);
+        dto.setClaimText("uyuyuyuyuuyuyuy");
+        return dto;
+    }
+
+    public static FinalProofGroupDTO addProof() {
+        FinalProofGroupDTO dto = new FinalProofGroupDTO();
+        dto.setProjectId(368);
+        dto.setInvalidReason("123456");
+        dto.setRbDecision("87659");
+        dto.setFeatureSort(1);
+        dto.setFeatureContent("0000000000");
+        dto.setCourtOpinions1("2222222222222");
+        dto.setCourtOpinions2("333333333333333333");
+        dto.setPresentOpinions("545656565");
+        return dto;
+    }
+
+    @Test
+    public void test() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer id = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(id);
+        finalInvalidStatueService.delInvalidReason(dto);
+        Assertions.assertNotNull(id);
+    }
+
+    @Test
+    public void test11() {
+        InvalidReasonDTO dto = addInvalid();
+        try {
+            finalInvalidStatueService.addInvalidReason(dto);
+        } catch (Exception e) {
+            Assertions.assertEquals("该法条下已存在相同权利要求", e.getMessage());
+        }
+    }
+
+    @Test
+    public void test1() {
+        GetInvalidReasonClaimsDTO dto = new GetInvalidReasonClaimsDTO();
+        dto.setProjectId(368);
+        final List<GetInvalidReasonClaimsVO> claims = finalInvalidStatueService.getInvalidReasonClaims(dto);
+        Assertions.assertNotNull(claims);
+    }
+
+    @Test
+    public void test2() {
+        GetInvalidReasonClaimsDTO dto = new GetInvalidReasonClaimsDTO();
+        dto.setProjectId(368);
+        dto.setStatueType(1);
+        final List<GetInvalidReasonClaimsVO> claims = finalInvalidStatueService.getInvalidReasonClaims(dto);
+        Assertions.assertNotNull(claims);
+    }
+
+    @Test
+    public void test3() {
+        GetInvalidReasonClaimsDTO dto = new GetInvalidReasonClaimsDTO();
+        dto.setProjectId(368);
+        dto.setStatueType(2);
+        final List<GetInvalidReasonClaimsVO> claims = finalInvalidStatueService.getInvalidReasonClaims(dto);
+        Assertions.assertNotNull(claims);
+    }
+
+    @Test
+    public void test4() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer statueId = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(statueId);
+        dto.setClaimText("ioioioioioioioiioio");
+        final Integer id = finalInvalidStatueService.editInvalidReason(dto);
+        finalInvalidStatueService.delInvalidReason(dto);
+        Assertions.assertNotNull(id);
+    }
+
+    @Test
+    public void test41() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer statueId = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(statueId);
+        dto.setClaimText("ioioioioioioioiioio");
+        try {
+            finalInvalidStatueService.editInvalidReason(dto);
+        } catch (Exception e) {
+            Assertions.assertEquals("该法条下已存在相同权利要求", e.getMessage());
+        }
+    }
+
+    @Test
+    public void test5() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer id = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(id);
+        finalInvalidStatueService.delInvalidReason(dto);
+        System.out.println("删除成功");
+    }
+
+    @Test
+    public void test6() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer id = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(id);
+        FinalProofGroupDTO proof = addProof();
+        proof.setInvalidStatueId(id);
+        final Integer featureId = finalInvalidStatueService.addFeature(proof);
+        finalInvalidStatueService.delInvalidReason(dto);
+        Assertions.assertNotNull(featureId);
+    }
+
+    @Test
+    public void test7() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer id = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(id);
+        FinalProofGroupDTO proof = addProof();
+        proof.setInvalidStatueId(id);
+        final Integer featureId = finalInvalidStatueService.addFeature(proof);
+        proof.setProofGroupId(featureId);
+        proof.setCourtOpinions1("AAAAAAAAAAAAAAAAAAA");
+        proof.setCourtOpinions2("BBBBBBBBBBBBBB");
+        final Integer feature = finalInvalidStatueService.editFeature(proof);
+        finalInvalidStatueService.delInvalidReason(dto);
+        Assertions.assertNotNull(feature);
+    }
+
+    @Test
+    public void test8() {
+        InvalidReasonDTO dto = addInvalid();
+        final Integer id = finalInvalidStatueService.addInvalidReason(dto);
+        dto.setInvalidStatueId(id);
+        FinalProofGroupDTO proof = addProof();
+        proof.setInvalidStatueId(id);
+        final Integer featureId = finalInvalidStatueService.addFeature(proof);
+        proof.setProofGroupId(featureId);
+        finalInvalidStatueService.delFeature(proof);
+        System.out.println("删除成功");
+        finalInvalidStatueService.delInvalidReason(dto);
+        Assertions.assertNotNull(featureId);
+    }
+}