无效证据

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

@@ -0,0 +1,11 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class AddEvidenceReasonDTO {
+    private Integer groupId;
+    private List<AddEvidenceReasonsDTO> evidenceReasonList;
+}

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

@@ -0,0 +1,16 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class AddEvidenceReasonsDTO {
+    private Integer featureId;
+    private Integer featureOrder;
+    private String featureText;
+    private List<Integer> literatureId;
+    private String evidenceText;
+    private String evidenceDescription;
+
+}

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

@@ -0,0 +1,14 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+/**
+ * 查询权利要求
+ */
+@Data
+public class QueryClaimSplitHistoryDTO {
+    private  Integer claimId;
+    private Long current;
+    private Long size;
+
+}

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

@@ -0,0 +1,10 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class QueryEvidenceReasonDTO {
+    private Integer groupId;
+}

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

@@ -0,0 +1,13 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import lombok.Data;
+
+/**
+ * 查询权利要求
+ */
+@Data
+public class QueryInvalidHistoryDTO {
+    private  Integer featureId;
+    private Long size;
+    private Long current;
+}

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import cn.cslg.pas.domain.business.CompareLiterature;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class QueryClaimSplitHistoryVO {
+    private Integer sysOrder;
+  private List<GroupFeature> featureSplitContent;
+    @Data
+    public static class GroupFeature {
+        private Integer id;
+        private String featureText;
+        private Integer sysOrder;
+
+    }
+}

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

@@ -0,0 +1,17 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import cn.cslg.pas.domain.business.CompareLiterature;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class QueryEvidenceReasonVO {
+    private Integer groupId;
+    private Integer featureId;
+    private Integer featureOrder;
+    private String featureText;
+    private String evidenceText;
+    private String evidenceDescription;
+    private List<CompareLiterature> literatures;
+}

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

@@ -0,0 +1,16 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import cn.cslg.pas.domain.business.CompareLiterature;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 查询权利要求
+ */
+@Data
+public class QueryInvalidHistoryVO {
+    private List<CompareLiterature> literatures;
+    private String evidenceText;
+    private String evidenceDescription;
+}

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

@@ -0,0 +1,56 @@
+package cn.cslg.pas.controller;
+
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.dto.invalidDTO.AddEvidenceReasonDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryEvidenceReasonDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryInvalidHistoryDTO;
+import cn.cslg.pas.common.model.cronModel.Records;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.invalidVO.QueryEvidenceReasonVO;
+import cn.cslg.pas.service.business.invalidReport.EvidenceReasonService;
+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;
+
+import java.util.List;
+
+@Slf4j
+@RequestMapping(Constants.API_XiaoSHI + "/evidenceReason")
+@RestController
+public class EvidenceReasonController {
+    @Autowired
+    private EvidenceReasonService evidenceReasonService;
+
+    @Operation(summary = "添加或删除无效理由")
+    @PostMapping("/addEvidenceReason")
+    public Response addEvidenceReason(@RequestBody AddEvidenceReasonDTO addEvidenceReasonDTO) {
+        Boolean flag = evidenceReasonService.addEvidenceReason(addEvidenceReasonDTO);
+        if (!flag) {
+            return Response.error("添加失败");
+        }
+        return Response.success("添加成功");
+    }
+
+
+    @Operation(summary = "查询无效理由")
+    @PostMapping("/queryEvidenceReason")
+    public Response queryEvidenceReason(@RequestBody QueryEvidenceReasonDTO queryEvidenceReasonDTO) {
+        List<QueryEvidenceReasonVO> queryEvidenceReasonVOList = evidenceReasonService.queryEvidenceReason(queryEvidenceReasonDTO);
+        Records records = new Records();
+        records.setData(queryEvidenceReasonVOList);
+        return Response.success(records);
+    }
+
+
+    @Operation(summary = "查询无效历史")
+    @PostMapping("/queryInvalidHistory")
+    public Response queryInvalidHistory(@RequestBody QueryInvalidHistoryDTO queryInvalidHistoryDTO) {
+      Records records =  evidenceReasonService.queryInvalidHistory(queryInvalidHistoryDTO);
+        return Response.success(records);
+    }
+}

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

@@ -2,6 +2,7 @@ package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.dto.QuerySplitDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryClaimSplitHistoryDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.vo.business.SplitVO;
@@ -71,6 +72,7 @@ public class FeatureController {
         }
 
     }
+
     @Operation(summary = "查询权要树")
     @GetMapping("/getPatentRightTree")
     public Response getPatentRightTree(String patentNo) throws Exception {
@@ -107,4 +109,16 @@ public class FeatureController {
         }
     }
 
+
+    @Operation(summary = "查询权要拆分历史")
+    @PostMapping("/queryClaimSplitHistory")
+    public Response queryClaimSplitHistory(@RequestBody QueryClaimSplitHistoryDTO queryClaimSplitHistoryDTO) throws Exception {
+        try {
+            Records records = featureService.queryClaimSplitHistory(queryClaimSplitHistoryDTO);
+            return Response.success(records);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+
+    }
 }

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

@@ -0,0 +1,15 @@
+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;
+
+@Data
+@TableName("asso_feature_reason")
+public class AssoFeatureReason extends BaseEntity<AssoFeatureReason> {
+    @TableField(value = "reason_id")
+    private Integer reasonId;
+    @TableField(value = "feature_id")
+    private Integer featureId;
+}

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

@@ -0,0 +1,36 @@
+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;
+
+@Data
+@TableName("asso_group_feature")
+public class AssoGroupFeature  extends BaseEntity<AssoGroupFeature> {
+    @TableField(value = "feature_order")
+    private Integer featureOrder;
+    //0原始 1拆分过
+    @TableField(value = "feature_gen")
+    private Integer featureGen;
+    //特征id
+    @TableField(value = "feature_id")
+    private Integer featureId;
+    //特征id
+    @TableField(value = "feature_pre_id")
+    private Integer featurePreId;
+    @TableField(value = "group_id")
+    private Integer groupId;
+    //陈述意见
+    @TableField(value = "present_opinions")
+    private String presentOpinions;
+
+    //特征修改说明
+    @TableField(value = "common")
+    private Integer common;
+
+    @TableField(value = "rb_decision")
+    private String rbDecision;
+    @TableField(value = "rb_decision_key")
+    private String rbDecisionKey;
+}

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

@@ -0,0 +1,16 @@
+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;
+
+@Data
+@TableName("asso_reason_literature")
+public class AssoReasonLiterature  extends BaseEntity<AssoReasonLiterature> {
+
+    @TableField(value = "reason_id")
+    private Integer reasonId;
+    @TableField(value = "literature_id")
+    private Integer literatureId;
+}

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

@@ -18,7 +18,18 @@ import java.util.Date;
 @Data
 @TableName("evidence_reason")
 public class EvidenceReason extends BaseEntity<EvidenceReason> {
+    @TableField(value = "evidence_text")
     private String evidenceText;
-    private String Description;
-    
+    @TableField(value = "description")
+    private String description;
+    @TableField(value = "present_options")
+    private String presentOptions;
+    @TableField(value = "rb_decision")
+    private String rbDecision;
+    @TableField(value = "rb_decision_key")
+    private String rbDecisionKey;
+    @TableField(value = "create_id")
+    private  String createId;
+    @TableField(value = "create_time")
+    private String createTime;
 }

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

@@ -0,0 +1,15 @@
+package cn.cslg.pas.mapper.InvalidReport;
+
+import cn.cslg.pas.domain.business.AssoFeatureReason;
+import cn.cslg.pas.domain.business.PatentClaim;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+
+/**
+ *
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Repository
+public interface AssoFeatureReasonMapper extends BaseMapper<AssoFeatureReason> {
+}

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

@@ -0,0 +1,16 @@
+package cn.cslg.pas.mapper.InvalidReport;
+
+import cn.cslg.pas.domain.business.AssoGroupFeature;
+import cn.cslg.pas.domain.business.PatentClaim;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+
+/**
+ * 权利要求
+ *
+ * @author lrj
+ * @date 2023/12/22
+ */
+@Repository
+public interface AssoGroupFeatureMapper extends BaseMapper<AssoGroupFeature> {
+}

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

@@ -0,0 +1,16 @@
+package cn.cslg.pas.mapper.InvalidReport;
+
+import cn.cslg.pas.domain.business.AssoReasonLiterature;
+import cn.cslg.pas.domain.business.EvidenceReason;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+
+
+/**
+ *
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Repository
+public interface AssoReasonLiteratureMapper  extends BaseMapper<AssoReasonLiterature> {
+}

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

@@ -0,0 +1,15 @@
+package cn.cslg.pas.mapper.InvalidReport;
+
+import cn.cslg.pas.domain.business.EvidenceReason;
+import cn.cslg.pas.domain.business.PatentClaim;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+
+/**
+ *
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Repository
+public interface EvidenceReasonMapper extends BaseMapper<EvidenceReason> {
+}

src/main/java/cn/cslg/pas/service/business/CompareLiteratureService.java

@@ -167,7 +167,8 @@ public class CompareLiteratureService extends ServiceImpl<CompareLiteratureMappe
         Records records = new Records();
         //根据对比projectId 查询对比文献
         LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(CompareLiterature::getProjectId, projectId);
+        queryWrapper.eq(CompareLiterature::getProjectId, projectId)
+                    .orderByAsc(CompareLiterature::getSysOrder);
         List<CompareLiterature> compareLiteratures = new ArrayList<>();
 
         if (literatureQueryDTO.getCurrent() != null && literatureQueryDTO.getSize() != null) {
@@ -417,7 +418,7 @@ public class CompareLiteratureService extends ServiceImpl<CompareLiteratureMappe
     public Integer saveOrUpdatePatent(UpdateBatchLiteraturesDTO updateBatchLiteratureDTO) {
         PersonnelVO personnelVO = new PersonnelVO();
         Integer projectId = updateBatchLiteratureDTO.getProjectId();
-        String literatureNo = updateBatchLiteratureDTO.getName();
+        String literatureNo = updateBatchLiteratureDTO.getLiteratureNo();
         Integer id = updateBatchLiteratureDTO.getId();
         try {
             personnelVO = new PersonnelVO();

src/main/java/cn/cslg/pas/service/business/FeatureService.java

@@ -3,20 +3,24 @@ package cn.cslg.pas.service.business;
 import cn.cslg.pas.common.TreeBuild;
 import cn.cslg.pas.common.dto.QuerySplitDTO;
 import cn.cslg.pas.common.dto.business.SelectClaimDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryClaimSplitHistoryDTO;
 import cn.cslg.pas.common.model.cronModel.PersonnelVO;
+import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.PatentRightUtils;
 import cn.cslg.pas.common.vo.*;
 import cn.cslg.pas.common.vo.business.SplitVO;
-import cn.cslg.pas.domain.business.Feature;
-import cn.cslg.pas.domain.business.PatentSplitMessage;
-import cn.cslg.pas.domain.business.ReportProject;
+import cn.cslg.pas.common.vo.invalidVO.QueryClaimSplitHistoryVO;
+import cn.cslg.pas.domain.business.*;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.FeatureMapper;
 import cn.cslg.pas.service.business.es.EsService;
+import cn.cslg.pas.service.business.invalidReport.AssoGroupFeatureService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -39,6 +43,14 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
 
     @Autowired
     private PatentSplitMessageService patentSplitMessageService;
+    @Autowired
+    @Lazy
+    private InvalidStatutesService invalidStatutesService;
+    @Autowired
+    private ProofGroupService proofGroupService;
+    @Autowired
+    @Lazy
+    private AssoGroupFeatureService assoGroupFeatureService;
 
     @Transactional(rollbackFor = Exception.class)
     public List<PatentRightVo> splitPatentFeature(SplitVO splitVO) throws IOException {
@@ -94,16 +106,16 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
                 patentSplitMessage.setProjectId(projectId);
                 patentSplitMessage.setTenantId(personnelVO.getTenantId());
                 patentSplitMessage.setCreateId(personnelVO.getId());
-                if(taskId!=null) {
+                if (taskId != null) {
                     patentSplitMessage.setTaskId(taskId);
                 }
                 patentSplitMessage.insert();
-                allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId,taskId, patentRights,patentSplitMessage.getId());
+                allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId, taskId, patentRights, patentSplitMessage.getId());
             }
         }
         //当重拆时新建
         else {
-            if(patentSplitMessage==null) {
+            if (patentSplitMessage == null) {
                 throw new XiaoShiException("未拆分过，请重新选择拆分方式");
             }
 
@@ -113,7 +125,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
             patentSplitMessage.updateById();
             //清除原本的
             this.remove(wrapper);
-            allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId,taskId, patentRights, patentSplitMessage.getId());
+            allFeatures = this.splitFeature(splitBy, splitType, patentNo, projectId, taskId, patentRights, patentSplitMessage.getId());
 
         }
         //装载信息并返回
@@ -264,7 +276,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
     }
 
 
-    public List<Feature> splitFeature(Integer splitBy, Integer splitType, String patentNo, Integer projectId,Integer taskId, List<RePatentClaim> patentRights,Integer splitMessageId) throws IOException {
+    public List<Feature> splitFeature(Integer splitBy, Integer splitType, String patentNo, Integer projectId, Integer taskId, List<RePatentClaim> patentRights, Integer splitMessageId) throws IOException {
         List<Feature> allFeatures = new ArrayList<>();
         PersonnelVO personnelVO = new PersonnelVO();
         personnelVO.setId("1");
@@ -310,7 +322,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
                 feature.setRightType(patentRights.get(i).getType());
                 feature.setTenantId(personnelVO.getTenantId());
                 feature.setSplitMessageId(splitMessageId);
-                if(taskId!=null){
+                if (taskId != null) {
                     feature.setProjectTaskId(taskId);
                 }
                 featureList.add(feature);
@@ -346,4 +358,65 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
         }
         return patentRightVos;
     }
+
+
+    public Records queryClaimSplitHistory(QueryClaimSplitHistoryDTO queryClaimSplitHistoryDTO) {
+        List<QueryClaimSplitHistoryVO> queryClaimSplitHistoryVOS = new ArrayList<>();
+        Integer claimId = queryClaimSplitHistoryDTO.getClaimId();
+        Long current = queryClaimSplitHistoryDTO.getCurrent();
+        Long size = queryClaimSplitHistoryDTO.getSize();
+        //根据id查询无效发条
+        LambdaQueryWrapper<InvalidStatutes> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(InvalidStatutes::getClaimId, claimId);
+        List<InvalidStatutes> invalidStatutes = invalidStatutesService.list(queryWrapper);
+        //根据无效发条查询证据组合
+        if (invalidStatutes.size() != 0) {
+            List<Integer> statutesIds = invalidStatutes.stream().map(InvalidStatutes::getId).collect(Collectors.toList());
+            //根据无效法条id查询证据组合
+            LambdaQueryWrapper<ProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
+            queryWrapper1.in(ProofGroup::getInvalidStatutesId, statutesIds);
+            List<ProofGroup> proofGroups = proofGroupService.list(queryWrapper1);
+            if (proofGroups.size() > 0) {
+                proofGroups.forEach(item -> {
+                    //根据id 查询特征
+                    Integer groupId = item.getId();
+                    LambdaQueryWrapper<AssoGroupFeature> queryWrapper2 = new LambdaQueryWrapper<>();
+                    queryWrapper2.eq(AssoGroupFeature::getGroupId, groupId);
+                    List<AssoGroupFeature> assoGroupFeatures = assoGroupFeatureService.list(queryWrapper2);
+
+                    if (assoGroupFeatures != null && assoGroupFeatures.size() != 0) {
+                        List<Integer> featureIds = assoGroupFeatures.stream().map(AssoGroupFeature::getFeatureId).collect(Collectors.toList());
+
+                        if (featureIds.size() != 0) {
+                            LambdaQueryWrapper<Feature> queryWrapper3 = new LambdaQueryWrapper<>();
+                            queryWrapper3.in(Feature::getId, featureIds);
+                            List<Feature> featureList = this.list(queryWrapper3);
+
+                            if (featureList.size() != 0) {
+                                QueryClaimSplitHistoryVO queryClaimSplitHistoryVO = new QueryClaimSplitHistoryVO();
+                                List<QueryClaimSplitHistoryVO.GroupFeature> features = new ArrayList<>();
+                                featureList.forEach(i -> {
+                                    QueryClaimSplitHistoryVO.GroupFeature tem = new QueryClaimSplitHistoryVO.GroupFeature();
+                                    tem.setFeatureText(i.getContent());
+                                    tem.setId(i.getId());
+                                    AssoGroupFeature assoGroupFeature = assoGroupFeatures.stream().filter(t -> t.getFeatureId().equals(i.getId())).findFirst().orElse(null);
+                                    if (assoGroupFeature != null) {
+                                        tem.setSysOrder(assoGroupFeature.getFeatureOrder());
+                                    }
+                                    features.add(tem);
+                                });
+                                queryClaimSplitHistoryVO.setFeatureSplitContent(features);
+                                queryClaimSplitHistoryVOS.add(queryClaimSplitHistoryVO);
+                            }
+                        }
+                    }
+                });
+            }
+        }
+
+        Records records = new Records();
+        records.setData(queryClaimSplitHistoryVOS);
+        return records;
+    }
+
 }

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.service.business.invalidReport;
+
+import cn.cslg.pas.domain.business.AssoEventFile;
+import cn.cslg.pas.domain.business.AssoFeatureReason;
+import cn.cslg.pas.mapper.AssoEventFileMapper;
+import cn.cslg.pas.mapper.InvalidReport.AssoFeatureReasonMapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+
+/**
+ *
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Service
+public class AssoFeatureReasonService extends ServiceImpl<AssoFeatureReasonMapper, AssoFeatureReason> {
+}

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

@@ -0,0 +1,41 @@
+package cn.cslg.pas.service.business.invalidReport;
+
+import cn.cslg.pas.domain.business.AssoEventFile;
+import cn.cslg.pas.domain.business.AssoGroupFeature;
+import cn.cslg.pas.mapper.AssoEventFileMapper;
+import cn.cslg.pas.mapper.InvalidReport.AssoGroupFeatureMapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * 权利要求
+ *
+ * @author lrj
+ * @date 2023/12/22
+ */
+@Service
+public class AssoGroupFeatureService extends ServiceImpl<AssoGroupFeatureMapper, AssoGroupFeature> {
+
+
+    //根据证据组合id查询特征id
+    public List<Integer> getFeatureIdsByGroupId(Integer groupId) {
+        List<Integer> featureIds = new ArrayList<>();
+        //根据证据组合id查询
+        LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.select(AssoGroupFeature::getFeatureId);
+        queryWrapper.eq(AssoGroupFeature::getGroupId, groupId);
+        Function<Object, Integer> f = (o -> Integer.parseInt(o.toString()));
+        List<Integer> ids = this.listObjs(queryWrapper, f);
+        if (ids != null && ids.size() != 0) {
+            return ids;
+        }
+        return featureIds;
+    }
+}

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

@@ -0,0 +1,20 @@
+package cn.cslg.pas.service.business.invalidReport;
+
+import cn.cslg.pas.domain.business.AssoEventFile;
+import cn.cslg.pas.domain.business.AssoReasonLiterature;
+import cn.cslg.pas.mapper.AssoEventFileMapper;
+import cn.cslg.pas.mapper.InvalidReport.AssoReasonLiteratureMapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+
+
+/**
+ *
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Service
+public class AssoReasonLiteratureService extends ServiceImpl<AssoReasonLiteratureMapper,AssoReasonLiterature> {
+}

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

@@ -0,0 +1,334 @@
+package cn.cslg.pas.service.business.invalidReport;
+
+import cn.cslg.pas.common.dto.invalidDTO.AddEvidenceReasonDTO;
+import cn.cslg.pas.common.dto.invalidDTO.AddEvidenceReasonsDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryEvidenceReasonDTO;
+import cn.cslg.pas.common.dto.invalidDTO.QueryInvalidHistoryDTO;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
+import cn.cslg.pas.common.model.cronModel.Records;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.common.vo.invalidVO.QueryEvidenceReasonVO;
+import cn.cslg.pas.common.vo.invalidVO.QueryInvalidHistoryVO;
+import cn.cslg.pas.domain.business.*;
+import cn.cslg.pas.mapper.InvalidReport.EvidenceReasonMapper;
+import cn.cslg.pas.service.business.CompareLiteratureService;
+import cn.cslg.pas.service.business.FeatureService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author lrj
+ * @date 2023/12/25
+ */
+@Service
+public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, EvidenceReason> {
+    @Autowired
+    private CacheUtils cacheUtils;
+    @Autowired
+    private LoginUtils loginUtils;
+    @Autowired
+    private AssoGroupFeatureService assoGroupFeatureService;
+    @Autowired
+    private AssoFeatureReasonService assoFeatureReasonService;
+    @Autowired
+    private AssoReasonLiteratureService assoReasonLiteratureService;
+    @Autowired
+    private FeatureService featureService;
+    @Autowired
+    private CompareLiteratureService compareLiteratureService;
+
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean addEvidenceReason(AddEvidenceReasonDTO addEvidenceReasonDTO) {
+        PersonnelVO personnelVO = new PersonnelVO();
+        personnelVO.setId("1");
+        Integer groupId = addEvidenceReasonDTO.getGroupId();
+        List<AddEvidenceReasonsDTO> addEvidenceReasonsDTOs = addEvidenceReasonDTO.getEvidenceReasonList();
+        // 遍历装载
+        List<AddEvidenceReasonsDTO> addEvidenceReasonsDTOList = new ArrayList<>();
+        addEvidenceReasonsDTOs.forEach(item -> {
+            AddEvidenceReasonsDTO tem = addEvidenceReasonsDTOList.stream().filter(i -> i.getFeatureOrder().equals(item.getFeatureOrder())).findFirst().orElse(null);
+            if (tem == null) {
+                addEvidenceReasonsDTOList.add(item);
+            }
+
+        });
+        //获得所有的特征id
+        List<Integer> featureIds = addEvidenceReasonsDTOs.stream()
+                .filter(item -> item.getFeatureId() != null)
+                .map(AddEvidenceReasonsDTO::getFeatureId).collect(Collectors.toList());
+        this.deleteAssoByFeatureIds(featureIds,groupId);
+
+
+        for (AddEvidenceReasonsDTO addEvidenceReasonsDTO : addEvidenceReasonsDTOs) {
+            //获得特征信息
+            Integer featureId = addEvidenceReasonsDTO.getFeatureId();
+            Integer featureOrder = addEvidenceReasonsDTO.getFeatureOrder();
+            if (featureId == null) {
+                //判断
+                AddEvidenceReasonsDTO tem = addEvidenceReasonsDTOList.stream()
+                        .filter(item -> addEvidenceReasonsDTO.equals(item.getFeatureOrder())).findFirst().orElse(null);
+                if (tem == null) {
+                    //添加特征
+                    Feature feature = new Feature();
+                    feature.setContent(addEvidenceReasonsDTO.getFeatureText());
+                    feature.insert();
+                    featureId = feature.getId();
+                    //添加特征和证据组合关联
+                    addEvidenceReasonsDTOList.add(addEvidenceReasonsDTO);
+                }
+            }
+
+            //添加无效理由
+            Integer reasonId = this.addEvidenceReason(addEvidenceReasonsDTO, personnelVO.getId());
+            //添加无效理由和特征关联
+            AssoFeatureReason assoFeatureReason = new AssoFeatureReason();
+            assoFeatureReason.setReasonId(reasonId);
+            assoFeatureReason.setFeatureId(featureId);
+            assoFeatureReason.insert();
+
+            //添加特征和证据组合关联
+            AssoGroupFeature assoGroupFeature = new AssoGroupFeature();
+            assoGroupFeature.setFeatureId(featureId);
+            assoGroupFeature.setFeatureOrder(featureOrder);
+            assoGroupFeature.setGroupId(groupId);
+            assoGroupFeature.insert();
+        }
+        return true;
+
+    }
+
+
+    public Boolean deleteAssoByFeatureIds(List<Integer> featureIds, Integer groupId) {
+        //根据groupId 删除特征和group关联
+        LambdaQueryWrapper<AssoGroupFeature> assoWrapper =new LambdaQueryWrapper<>();
+        assoWrapper.eq(AssoGroupFeature::getGroupId,groupId);
+        List<AssoGroupFeature> assoGroupFeatures=assoGroupFeatureService.list(assoWrapper);
+        List<Integer> inFeatureIds =assoGroupFeatures.stream().map(AssoGroupFeature::getFeatureId).collect(Collectors.toList());
+
+        if(inFeatureIds!=null&&inFeatureIds.size()>0){
+
+
+            //根据特征id 查询无效理由
+            LambdaQueryWrapper<AssoFeatureReason> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.in(AssoFeatureReason::getFeatureId, inFeatureIds);
+
+            List<AssoFeatureReason> assoFeatureReasons = assoFeatureReasonService.list(queryWrapper);
+            //获得无效理由id
+            if (assoFeatureReasons.size() > 0) {
+                //删除无效理由和证据文献关联
+                List<Integer> reasonIds = assoFeatureReasons.stream().map(AssoFeatureReason::getReasonId).collect(Collectors.toList());
+                //根据无效理由id删除和证据文献关联
+                LambdaQueryWrapper<AssoReasonLiterature> queryWrapper1 = new LambdaQueryWrapper<>();
+                queryWrapper1.in(AssoReasonLiterature::getReasonId, reasonIds);
+                assoReasonLiteratureService.remove(queryWrapper1);
+
+                //删除无效理由和特征关联
+                assoFeatureReasonService.remove(queryWrapper);
+
+                this.removeBatchByIds(reasonIds);
+
+            }
+
+            //删除证据组合和特征关联
+            LambdaQueryWrapper<AssoGroupFeature> queryWrapper3 = new LambdaQueryWrapper<>();
+            queryWrapper3.eq(AssoGroupFeature::getGroupId, groupId)
+                    .in(AssoGroupFeature::getFeatureId, inFeatureIds);
+            assoGroupFeatureService.remove(queryWrapper3);
+
+
+            //删除关联关系
+            assoGroupFeatures.remove(assoWrapper);
+            LambdaQueryWrapper<AssoGroupFeature> temWrapper =new LambdaQueryWrapper<>();
+            assoWrapper.ne(AssoGroupFeature::getGroupId,groupId)
+                    .in(AssoGroupFeature::getFeatureId,inFeatureIds);
+            List<AssoGroupFeature> tem=assoGroupFeatureService.list(temWrapper);
+            List<Integer> temIds =tem.stream().map(AssoGroupFeature::getFeatureId).collect(Collectors.toList());
+            inFeatureIds.remove(temIds);
+            if(featureIds.size()>0){
+                inFeatureIds.remove(featureIds);
+            }
+            //删除特征
+            if(inFeatureIds.size()>0){
+                featureService.removeBatchByIds(inFeatureIds);
+            }
+        }
+
+
+        return true;
+
+    }
+
+    private Integer addEvidenceReason(AddEvidenceReasonsDTO addEvidenceReasonsDTO, String createId) {
+        //添加无效理由
+        EvidenceReason evidenceReason = new EvidenceReason();
+        evidenceReason.setEvidenceText(addEvidenceReasonsDTO.getEvidenceText());
+        evidenceReason.setCreateId(createId);
+        evidenceReason.setDescription(addEvidenceReasonsDTO.getEvidenceDescription());
+        evidenceReason.insert();
+        Integer id = evidenceReason.getId();
+        //添加无效理由和证据关联
+        this.addAssoReasonLiterature(addEvidenceReasonsDTO.getLiteratureId(), id);
+        return id;
+    }
+
+    private void addAssoReasonLiterature(List<Integer> literatureIds, Integer reasonId) {
+        List<AssoReasonLiterature> assoReasonLiteratures = new ArrayList<>();
+        if (literatureIds == null || literatureIds.size() == 0) {
+            return;
+        }
+        literatureIds.forEach(item -> {
+            AssoReasonLiterature assoReasonLiterature = new AssoReasonLiterature();
+            assoReasonLiterature.setLiteratureId(item);
+            assoReasonLiterature.setReasonId(reasonId);
+            assoReasonLiteratures.add(assoReasonLiterature);
+        });
+        if (assoReasonLiteratures.size() != 0) {
+            assoReasonLiteratureService.saveBatch(assoReasonLiteratures);
+        }
+    }
+
+    //查询无效理由
+    public List<QueryEvidenceReasonVO> queryEvidenceReason(@RequestBody QueryEvidenceReasonDTO queryEvidenceReasonDTO) {
+        Integer groupId = queryEvidenceReasonDTO.getGroupId();
+        //根据证据组合id 查询特征
+        LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoGroupFeature::getGroupId, groupId);
+        List<AssoGroupFeature> assoGroupFeatures = assoGroupFeatureService.list(queryWrapper);
+        List<QueryEvidenceReasonVO> queryEvidenceReasonVOS = new ArrayList<>();
+        if (assoGroupFeatures != null && assoGroupFeatures.size() != 0) {
+            assoGroupFeatures.forEach(item -> {
+                //查询特征
+                Integer featureId = item.getFeatureId();
+                //根据特征id查询特征
+                Feature feature = featureService.getById(featureId);
+
+                //根据特征id 查询无效理由
+                LambdaQueryWrapper<AssoFeatureReason> queryWrapper1 = new LambdaQueryWrapper<>();
+                queryWrapper1.eq(AssoFeatureReason::getFeatureId, featureId);
+                List<AssoFeatureReason> assoFeatureReasons = assoFeatureReasonService.list(queryWrapper1);
+
+                if (assoFeatureReasons.size() != 0) {
+                    for (AssoFeatureReason assoFeatureReason : assoFeatureReasons) {
+
+                        //装载特征信息
+                        QueryEvidenceReasonVO queryEvidenceReasonVO = new QueryEvidenceReasonVO();
+                        queryEvidenceReasonVO.setFeatureId(featureId);
+                        queryEvidenceReasonVO.setFeatureOrder(item.getFeatureOrder());
+                        queryEvidenceReasonVO.setFeatureText(feature.getContent());
+                        queryEvidenceReasonVO.setGroupId(groupId);
+                        //根据无效理由id 查询无效理由
+                        EvidenceReason evidenceReason = this.getById(assoFeatureReason.getReasonId());
+                        queryEvidenceReasonVO.setEvidenceText(evidenceReason.getEvidenceText());
+                        queryEvidenceReasonVO.setEvidenceDescription(evidenceReason.getDescription());
+
+                        //根据无效理由id查询对比文献
+                        LambdaQueryWrapper<AssoReasonLiterature> queryWrapper2 = new LambdaQueryWrapper<>();
+                        queryWrapper2.eq(AssoReasonLiterature::getReasonId, assoFeatureReason.getReasonId());
+                        List<AssoReasonLiterature> assoReasonLiteratures = assoReasonLiteratureService.list(queryWrapper2);
+                        if (assoReasonLiteratures.size() > 0) {
+                            List<Integer> literatureIds = assoReasonLiteratures.stream().map(AssoReasonLiterature::getLiteratureId).collect(Collectors.toList());
+
+                            //根据证据文献id 查询文献
+                            LambdaQueryWrapper<CompareLiterature> queryWrapper3 = new LambdaQueryWrapper<>();
+                            queryWrapper3.in(CompareLiterature::getId, literatureIds);
+                            List<CompareLiterature> compareLiteratures = compareLiteratureService.list(queryWrapper3);
+                            if (literatureIds.contains(0)) {
+                                CompareLiterature compareLiterature = new CompareLiterature();
+                                compareLiterature.setName("公知常识");
+                                compareLiterature.setId(0);
+                                compareLiteratures.add(compareLiterature);
+                            }
+                            if (literatureIds.contains(-1)) {
+                                CompareLiterature compareLiterature = new CompareLiterature();
+                                compareLiterature.setName("惯用技术手段");
+                                compareLiterature.setId(-1);
+                                compareLiteratures.add(compareLiterature);
+                            }
+                            queryEvidenceReasonVO.setLiteratures(compareLiteratures);
+                        }
+
+                        queryEvidenceReasonVOS.add(queryEvidenceReasonVO);
+                    }
+                }
+
+            });
+
+
+        }
+        return queryEvidenceReasonVOS;
+
+    }
+
+    //查询无效历史
+    public Records queryInvalidHistory( QueryInvalidHistoryDTO queryInvalidHistoryDTO) {
+        List<QueryInvalidHistoryVO> queryInvalidHistoryVOS = new ArrayList<>();
+        Integer featureId = queryInvalidHistoryDTO.getFeatureId();
+        Long current = queryInvalidHistoryDTO.getCurrent();
+        Long size = queryInvalidHistoryDTO.getSize();
+        //根据featureId 查询无效理由
+        LambdaQueryWrapper<AssoFeatureReason> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoFeatureReason::getFeatureId, featureId);
+        Page<AssoFeatureReason> page = assoFeatureReasonService.page(new Page<>(current, size), queryWrapper);
+        Long total = page.getTotal();
+        List<AssoFeatureReason> assoFeatureReasons = page.getRecords();
+
+        if (assoFeatureReasons.size() > 0) {
+            //根据无效理由id 查询无效理由
+            assoFeatureReasons.forEach(item -> {
+                QueryInvalidHistoryVO reVo = new QueryInvalidHistoryVO();
+                Integer reasonId = item.getReasonId();
+                EvidenceReason evidenceReason = this.getById(item.getReasonId());
+                reVo.setEvidenceText(evidenceReason.getEvidenceText());
+                reVo.setEvidenceDescription(evidenceReason.getDescription());
+                //根据无效理由id查询对比文献
+                LambdaQueryWrapper<AssoReasonLiterature> queryWrapper2 = new LambdaQueryWrapper<>();
+                queryWrapper2.eq(AssoReasonLiterature::getReasonId, reasonId);
+                List<AssoReasonLiterature> assoReasonLiteratures = assoReasonLiteratureService.list(queryWrapper2);
+                if (assoReasonLiteratures.size() > 0) {
+                    List<Integer> literatureIds = assoReasonLiteratures.stream().map(AssoReasonLiterature::getLiteratureId).collect(Collectors.toList());
+
+                    //根据证据文献id 查询文献
+                    LambdaQueryWrapper<CompareLiterature> queryWrapper3 = new LambdaQueryWrapper<>();
+                    queryWrapper3.in(CompareLiterature::getId, literatureIds);
+                    List<CompareLiterature> compareLiteratures = compareLiteratureService.list(queryWrapper3);
+                    if (literatureIds.contains(0)) {
+                        CompareLiterature compareLiterature = new CompareLiterature();
+                        compareLiterature.setName("公知常识");
+                        compareLiterature.setId(0);
+                        compareLiteratures.add(compareLiterature);
+                    }
+                    if (literatureIds.contains(-1)) {
+                        CompareLiterature compareLiterature = new CompareLiterature();
+                        compareLiterature.setName("惯用技术手段");
+                        compareLiterature.setId(-1);
+                        compareLiteratures.add(compareLiterature);
+                    }
+                    reVo.setLiteratures(compareLiteratures);
+                    queryInvalidHistoryVOS.add(reVo);
+                }
+
+            });
+
+
+        }
+        Records records = new Records();
+        records.setTotal(total);
+        records.setCurrent(current);
+        records.setSize(size);
+        records.setData(queryInvalidHistoryVOS);
+        return records;
+
+    }
+}

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

@@ -23,6 +23,7 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.experimental.Accessors;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
@@ -34,6 +35,7 @@ public class PatentClaimService extends ServiceImpl<PatentClaimMapper, PatentCla
     @Autowired
     private ReportProjectService reportProjectService;
     @Autowired
+    @Lazy
     private FeatureService featureService;
     @Autowired
     private CacheUtils cacheUtils;

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

@@ -0,0 +1,88 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.dto.invalidDTO.*;
+import cn.cslg.pas.common.model.cronModel.Records;
+import cn.cslg.pas.common.utils.MathUtils;
+import cn.cslg.pas.common.utils.RabbitMQUtils;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.utils.esDataForm.AddressSplitter;
+import cn.cslg.pas.common.vo.DepartmentVO;
+import cn.cslg.pas.common.vo.invalidVO.QueryEvidenceReasonVO;
+import cn.cslg.pas.controller.CommonController;
+import cn.cslg.pas.domain.es.PersonAddress;
+import cn.cslg.pas.service.business.FeatureService;
+import cn.cslg.pas.service.business.invalidReport.EvidenceReasonService;
+import cn.cslg.pas.service.common.FileManagerService;
+import cn.cslg.pas.service.importPatent.SchedulingTaskService;
+import cn.cslg.pas.service.permissions.PermissionService;
+import cn.cslg.pas.service.query.FormatQueryService;
+import com.alibaba.fastjson.JSON;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author chenyu
+ * @date 2023/9/6
+ */
+@SpringBootTest
+public class EvidenceReasonServiceTests {
+    @Autowired
+    private EvidenceReasonService evidenceReasonService;
+
+    @Autowired
+    private FeatureService featureService;
+    @Test
+  public   void test() throws Exception {
+        AddEvidenceReasonDTO addEvidenceReasonDTO = new AddEvidenceReasonDTO();
+        addEvidenceReasonDTO.setGroupId(1);
+        List<AddEvidenceReasonsDTO> addEvidenceReasonsDTOList = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            AddEvidenceReasonsDTO addEvidenceReasonsDTO = new AddEvidenceReasonsDTO();
+            addEvidenceReasonsDTO.setEvidenceText("证据" + i);
+            addEvidenceReasonsDTO.setEvidenceDescription("证据描述" + i);
+            addEvidenceReasonsDTO.setFeatureOrder(i);
+            addEvidenceReasonsDTO.setFeatureText("特征" + i);
+            addEvidenceReasonsDTO.setLiteratureId(new ArrayList<Integer>(){{add(61);add(62);add(0);add(-1);}});
+            addEvidenceReasonsDTOList.add(addEvidenceReasonsDTO);
+        }
+        addEvidenceReasonDTO.setEvidenceReasonList(addEvidenceReasonsDTOList);
+
+     Boolean a= evidenceReasonService.addEvidenceReason(addEvidenceReasonDTO);
+        System.out.println(a);
+    }
+
+
+    @Test
+    public   void queryEvidenceReason(){
+        QueryEvidenceReasonDTO queryEvidenceReasonDTO =new QueryEvidenceReasonDTO();
+        queryEvidenceReasonDTO.setGroupId(1);
+        List<QueryEvidenceReasonVO> a=    evidenceReasonService.queryEvidenceReason(queryEvidenceReasonDTO);
+System.out.println(a);
+    }
+
+    @Test
+    public void queryInvalidHistory(){
+        QueryInvalidHistoryDTO queryInvalidHistoryDTO =new QueryInvalidHistoryDTO();
+        queryInvalidHistoryDTO.setFeatureId(13498);
+        queryInvalidHistoryDTO.setCurrent(Long.parseLong(0+""));
+        queryInvalidHistoryDTO.setSize(Long.parseLong(10+""));
+       Records records= evidenceReasonService.queryInvalidHistory(queryInvalidHistoryDTO);
+       System.out.println(records);
+    }
+
+    @Test
+    public void query(){
+        QueryClaimSplitHistoryDTO queryClaimSplitHistoryDTO =new QueryClaimSplitHistoryDTO();
+        queryClaimSplitHistoryDTO.setClaimId(56);
+        Records records =featureService.queryClaimSplitHistory(queryClaimSplitHistoryDTO);
+        System.out.println(records);
+    }
+
+}