代码合并

RMS/src/main/java/cn/cslg/report/common/model/dto/FeaturesDTO.java

@@ -57,4 +57,6 @@ public class FeaturesDTO {
 
     private Integer featuresOrder;
 
+    private Integer position;
+
 }

RMS/src/main/java/cn/cslg/report/common/model/dto/invalidReReport/InvalidReasonDTO.java

@@ -30,7 +30,7 @@ public class InvalidReasonDTO {
     /**
      * 选择特征
      */
-    private List<featuresIn> features;
+    private List<FeaturesIn> features;
 
     /**
      * 相关证据
@@ -55,28 +55,27 @@ public class InvalidReasonDTO {
     /**
      * 证据组合
      */
-    private List<proofGroupIn> proofGroups;
+    private List<ProofGroupIn> proofGroups;
 
+    private List<InvalidReasonFieldValueDTO> fields ;
 
     @Data
-    public static class proofGroupIn{
-
+    public static class ProofGroupIn{
         private Integer id;
         /**
          * 描述
          */
         private String description;
-
         /**
          * 陈述意见
          */
-        private String argument_str;
+        private String argumentStr;
 
-        private List<Integer> proofIds;
+        private List<GroupDetail> groupDetails;
     }
 
     @Data
-    public static class featuresIn{
+    public static class FeaturesIn{
         private Integer id;
         /**
          * 特征内容
@@ -87,4 +86,6 @@ public class InvalidReasonDTO {
          */
         private Integer position;
     }
+
+
 }

RMS/src/main/java/cn/cslg/report/common/model/dto/invalidReReport/InvalidReasonFieldValueDTO.java

@@ -12,7 +12,6 @@ import lombok.Data;
  * @Date 2023/7/28
  */
 @Data
-@TableName(value = "ARGUMENTS")
 public class InvalidReasonFieldValueDTO  {
     @Schema(description = "无效理由id")
     private Integer invalidReasonId;
@@ -22,4 +21,7 @@ public class InvalidReasonFieldValueDTO  {
 
    @Schema(description ="栏位值")
     private String fieldValue;
+
+    @Schema(description ="栏位键值")
+    private String fieldKey;
 }

RMS/src/main/java/cn/cslg/report/common/model/dto/invalidReReport/ProofGroupDTO.java

@@ -25,8 +25,10 @@ public class ProofGroupDTO {
     /**
      * 陈述意见
      */
-    private String argument_str;
+    private String argumentStr;
+
+    private List<GroupDetail> groupDetails;
+
 
-    private List<Integer> proofIds;
 
 }

RMS/src/main/java/cn/cslg/report/common/model/vo/invalidReReport/QueryInvalidReasonVO.java

@@ -1,7 +1,7 @@
 package cn.cslg.report.common.model.vo.invalidReReport;
 
 import cn.cslg.report.common.model.dto.invalidReReport.InvalidReasonDTO;
-import cn.cslg.report.entity.invalidReReport.Proof;
+import cn.cslg.report.common.model.dto.invalidReReport.InvalidReasonFieldValueDTO;
 import com.baomidou.mybatisplus.annotation.TableField;
 import lombok.Data;
 
@@ -58,6 +58,7 @@ public class QueryInvalidReasonVO {
      */
     private List<featuresIn> features;
 
+    private List<InvalidReasonFieldValueDTO> fields;
 
     @Data
     public static class proofGroupIn{

RMS/src/main/java/cn/cslg/report/controller/InvalidReReport/InvalidReasonController.java

@@ -84,4 +84,11 @@ public class InvalidReasonController {
         Boolean isFlag = invalidReasonService.checkReFeatures(checkReFeaturesDTO);
         return Response.success(isFlag);
     }
+
+    @Operation(summary = "测试检测插入特征是否重复")
+    @PostMapping("/testCheckReFeature")
+    public String addOrUpdateValue(@RequestBody CheckReFeaturesDTO checkReFeaturesDTO) throws IOException {
+        Boolean isFlag = invalidReasonService.checkReFeatures(checkReFeaturesDTO);
+        return Response.success(isFlag);
+    }
 }

RMS/src/main/java/cn/cslg/report/controller/InvalidReReport/ProofGroupController.java

@@ -3,6 +3,7 @@ package cn.cslg.report.controller.InvalidReReport;
 import cn.cslg.report.common.core.base.Constants;
 import cn.cslg.report.common.model.dto.ShareReportDTO;
 import cn.cslg.report.common.model.dto.invalidReReport.ProofGroupDTO;
+import cn.cslg.report.common.model.dto.invalidReReport.ProofGroupUpdateDTO;
 import cn.cslg.report.common.model.vo.invalidReReport.ProofGroupVO;
 import cn.cslg.report.common.utils.Response;
 import cn.cslg.report.exception.XiaoShiException;
@@ -12,10 +13,7 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-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 org.springframework.web.bind.annotation.*;
 
 import java.io.IOException;
 import java.util.List;
@@ -58,9 +56,9 @@ public class ProofGroupController {
 
     @Operation(summary = "修改证据组合")
     @PostMapping("/update")
-    public String addPatentFile(@RequestBody ProofGroupDTO proofGroupDTO) throws IOException {
-        if (proofGroupDTO != null) {
-            proofGroupService.updateProofGroup(proofGroupDTO);
+    public String addPatentFile(@RequestBody ProofGroupUpdateDTO proofGroupUpdateDTO) throws IOException {
+        if (proofGroupUpdateDTO != null) {
+            proofGroupService.updateProofGroup(proofGroupUpdateDTO);
             return Response.success("更新成功");
         } else {
             return Response.error("更新失败");
@@ -81,4 +79,11 @@ public class ProofGroupController {
             return Response.error("查询失败");
         }
     }
+
+    @Operation(summary = "查询证据组合详情")
+    @GetMapping("/queryDetailByInvalidId")
+    public String queryDetailByInvalidId(Integer invalidReasonId) throws IOException {
+        return Response.success( proofGroupService.queryDetailByInvalidId(invalidReasonId));
+
+    }
 }

RMS/src/main/java/cn/cslg/report/entity/invalidReReport/ProofGroup.java

@@ -33,7 +33,7 @@ public class ProofGroup extends BaseEntity<ProofGroup> {
      * 陈述意见
      */
     @TableField("ARGUMENT_STR")
-    private String argument_str;
+    private String argumentStr;
 
     /**
      * 创建人

RMS/src/main/java/cn/cslg/report/mapper/InvalidReReport/InvalidReasonFiledValueMapper.java

@@ -18,5 +18,7 @@ import java.util.List;
 @Repository
 public interface InvalidReasonFiledValueMapper extends BaseMapper<InvalidReasonFieldValue> {
     public List<InvalidReasonFieldValue> getValues(List<InvalidReasonFieldValueDTO> values);
+
+   public List<InvalidReasonFieldValueDTO> getListByReasonIds(List<Integer>invalidReasonsIds);
 }
 

RMS/src/main/java/cn/cslg/report/service/business/FeatureService.java

@@ -17,13 +17,13 @@ import cn.cslg.report.entity.asso.AssoRecordsFeature;
 import cn.cslg.report.entity.asso.AssoTaskPatentSplit;
 import cn.cslg.report.entity.asso.AssoTaskPersonel;
 import cn.cslg.report.entity.invalidReReport.Arguments;
-import cn.cslg.report.entity.invalidReReport.AssoFeatureProof;
+import cn.cslg.report.entity.invalidReReport.ProofStr;
 import cn.cslg.report.entity.invalidReReport.AssoPositionFeatures;
-import cn.cslg.report.entity.invalidReReport.Proof;
 import cn.cslg.report.mapper.FeatureMapper;
 import cn.cslg.report.service.OutInterfaceService;
 import cn.cslg.report.service.business.InvalidReReport.ArgumentsService;
-import cn.cslg.report.service.business.InvalidReReport.AssoFeatureProofService;
+import cn.cslg.report.service.business.InvalidReReport.AssoPositionFeaturesService;
+import cn.cslg.report.service.business.InvalidReReport.ProofStrService;
 import cn.cslg.report.service.business.InvalidReReport.InvalidReasonService;
 import cn.dev33.satoken.stp.StpUtil;
 import com.alibaba.fastjson.JSON;
@@ -32,7 +32,6 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -60,9 +59,9 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
     private final CompareMessageService compareMessageService;
     private final PatentRightUtils patentRightUtils;
     private final InvalidReasonService invalidReasonService;
-    private final AssoFeatureProofService assoFeatureProofService;
+    private final ProofStrService assoFeatureProofService;
     private final ArgumentsService argumentsService;
-
+    private final AssoPositionFeaturesService assoPositionFeaturesService;
     /**
      * @param patentRights(专利权利要求)
      * @return List<PatentRight>
@@ -70,22 +69,17 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
      */
 
     public List<PatentRight> FormatPatentRights(List<PatentRight> patentRights, String patentNo) {
+
+
         StringBuilder stringBuilder = new StringBuilder();
         patentRights.forEach(item -> {
             stringBuilder.append(item.getContent());
         });
-
-        StringBuilder stringBuilder2 = new StringBuilder();
-        patentRights.forEach(item -> {
-            stringBuilder2.append(item.getContentOut());
-        });
-
         PatentRightParams params = new PatentRightParams();
         params.setPatentNo(patentNo);
         params.setPatentId(-1);
         params.setContent(stringBuilder.toString());
-        params.setContentOut(stringBuilder2.toString());
-        patentRights = patentRightUtils.formatPatentRight(params);
+        patentRightUtils.formatPatentRight(params);
         return patentRights;
     }
 
@@ -98,7 +92,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
      * @throws IOException
      * @function 从PAS系统上获得权要并拆分
      */
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class, timeout = 10)
     public String splitPatentRight(SplitVO splitVO) throws IOException {
         String patentNo = splitVO.getPatentNo();
         Integer reportId = splitVO.getReportId();
@@ -174,17 +168,14 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
         List<PatentRight> patentRightsOrgin = JSON.parseArray(jsonObject.getString("data"), PatentRight.class);
         //给权要进行格式更改
         List<PatentRight> patentRights = FormatPatentRights(patentRightsOrgin, patentNo);
-        //List<Integer> partRightIds = new ArrayList<>();  //权要ids
-        List<Integer> partRightSorts = new ArrayList<>();  //权要sorts
-        List<String> flags = new ArrayList<>();  //拆分方式字符
+        List<Integer> partRightIds = new ArrayList<>();
+        List<String> flags = new ArrayList<>();
         // 当splitType=0仅拆解主权要
         if (splitType.equals(0)) {
-            //partRightIds = patentRights.stream().filter(item -> item.getType().equals(1)).map(PatentRight::getId).collect(Collectors.toList());
-            partRightSorts = patentRights.stream().filter(item -> item.getType().equals(1)).map(PatentRight::getSort).collect(Collectors.toList());
+            partRightIds = patentRights.stream().filter(item -> item.getType().equals(1)).map(PatentRight::getId).collect(Collectors.toList());
         }// 当splitType=1拆解全部权要
         else if (splitType.equals(1)) {
-            //partRightIds = patentRights.stream().map(PatentRight::getId).collect(Collectors.toList());
-            partRightSorts = patentRights.stream().map(PatentRight::getSort).collect(Collectors.toList());
+            partRightIds = patentRights.stream().map(PatentRight::getId).collect(Collectors.toList());
         }
         //当splitBy=0时仅仅根据“,”拆解
         if (splitBy == 0) {
@@ -245,7 +236,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
                 List<String> contentOuts = Arrays.asList(patentRights.get(i).getContentOut());
                 List<String> contents = Arrays.asList(patentRights.get(i).getContent());
                 //如果是需要拆解的权要
-                if (partRightSorts.contains(patentRights.get(i).getSort())) {
+                if (partRightIds.contains(patentRights.get(i).getId())) {
                     //获得权要的译文并且拆解
                     contentOuts = this.splitStringByFlags(patentRights.get(i).getContentOut(), flags);
                     //获得权要的原文并且拆解
@@ -580,7 +571,6 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
 
     /**
      * 添加单个特征
-     *
      * @param featuresDTO
      * @return
      * @throws IOException
@@ -599,13 +589,16 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
         checkReFeaturesDTO.setRightSort(featuresDTO.getRightId());
         CheckReFeaturesDTO.featuresIn featuresIn = new CheckReFeaturesDTO.featuresIn();
         featuresIn.setFeatureStr(featuresDTO.getContent());
+        featuresIn.setPosition(featuresDTO.getPosition());
         checkReFeaturesDTO.setFeatures(Arrays.asList(featuresIn));
-        //检查权要是否有此特征
-        checkReFeaturesDTO = this.getFeaturePosition(checkReFeaturesDTO, patentNo);
-        if (checkReFeaturesDTO == null) {
-            return Response.error("权要里无此特征");
-        } else if (checkReFeaturesDTO.getFeatures().get(0).getPosition() == null) {
-            return Response.error("特征已被添加");
+        if(checkReFeaturesDTO.getFeatures().get(0).getPosition()==null) {
+            //检查权要是否有此特征
+            checkReFeaturesDTO = this.getFeaturePosition(checkReFeaturesDTO, patentNo);
+            if (checkReFeaturesDTO == null) {
+                return Response.error("权要里无此特征");
+            } else if (checkReFeaturesDTO.getFeatures().get(0).getPosition() == null) {
+                return Response.error("特征已被添加");
+            }
         }
         Boolean flag = invalidReasonService.checkReFeatures(checkReFeaturesDTO);
 
@@ -619,7 +612,7 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
         if (featuresList == null || featuresList.size() == 0) {
             biggestSort = 1;
         } else {
-            biggestSort = featuresList.get(0).getFeaturesOrder() + 1;
+            biggestSort = featuresList.get(0).getFeaturesOrder()+1;
         }
         Features features = new Features();
         features.setContent(featuresDTO.getContent());
@@ -655,15 +648,15 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
         }
         //获得已经保存的特征
         List<QueryAllFeaturesVO> queryAllFeaturesVOS = featureMapper.queryAllFeatures(checkReFeaturesDTO.getReportId(), checkReFeaturesDTO.getRightSort());
-        if (indexs.size() == 0 || (indexs.size() == 1 && indexs.get(0).equals(-1))) {
+        if (indexs.size() == 0||(indexs.size()==1&&indexs.get(0).equals(-1))) {
             return null;
         }
         //遍历寻找未选择的特征
-        for (Integer item : indexs) {
+        for (Integer item :indexs){
             QueryAllFeaturesVO queryAllFeaturesVO = queryAllFeaturesVOS.stream().filter(tem -> tem.getFeatureStr().equals(featureStr) && tem.getPosition().equals(item)).findFirst().orElse(null);
-            if (queryAllFeaturesVO == null && item != -1) {
+            if (queryAllFeaturesVO == null&&item!=-1) {
                 checkReFeaturesDTO.getFeatures().get(0).setPosition(item);
-                break;
+                break ;
             }
         }
         return checkReFeaturesDTO;
@@ -683,50 +676,64 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Features> {
 
     /**
      * 添加单个特征
-     *
      * @param featuresDTO
      * @return
      * @throws IOException
      */
     @Transactional(rollbackFor = Exception.class)
     public String deleteSingleFeature(Integer featureId) throws IOException {
-        if (featureId == null) {
-            return Response.error("请选择特征");
+        if(featureId==null){
+return Response.error("请选择特征");
         }
         //检查陈述意见是否有关联的特征
-        LambdaQueryWrapper<Arguments> argumentsWrapper = new LambdaQueryWrapper<>();
-        argumentsWrapper.eq(Arguments::getFeatureId, featureId);
-        List<Arguments> arguments = argumentsService.list(argumentsWrapper);
-        if (arguments.size() > 0) {
+        LambdaQueryWrapper<Arguments> argumentsWrapper=new LambdaQueryWrapper<>();
+        argumentsWrapper.eq(Arguments::getFeatureId,featureId);
+        List<Arguments> arguments =argumentsService.list(argumentsWrapper);
+        if(arguments.size()>0){
             return Response.error("此特征和陈述意见有关联");
         }
-        this.removeById(featureId);
-        LambdaQueryWrapper<AssoFeatureProof> wrapper = new LambdaQueryWrapper<>();
-        wrapper.eq(AssoFeatureProof::getFeatureId, featureId);
+        LambdaQueryWrapper<ProofStr> wrapper =new LambdaQueryWrapper<>();
+        wrapper.eq(ProofStr::getFeatureId,featureId);
         assoFeatureProofService.remove(wrapper);
+        LambdaQueryWrapper<AssoPositionFeatures> wrapper1 =new LambdaQueryWrapper<>();
+        wrapper1.eq(AssoPositionFeatures::getFeaturesID,featureId);
+        assoPositionFeaturesService.remove(wrapper1);
+        this.removeById(featureId);
         return Response.success();
     }
 
-    //获得特征列表
-    public String getFeatureList(Integer reportId, Integer rightSort) {
-        List<Map<String, Object>> mapList = new ArrayList<>();
-        if (reportId == null || rightSort == null) {
+ //获得特征列表
+    public String getFeatureList(Integer reportId,Integer rightSort){
+        List<Map<String,Object>> mapList =new ArrayList<>();
+        if(reportId==null||rightSort==null){
             return Response.error("请输入报告id和权要序号");
         }
-        Report report = reportService.getById(reportId);
-        LambdaQueryWrapper<Features> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(Features::getRightId, rightSort)
-                .eq(Features::getReportId, reportId)
-                .eq(Features::getSignPatentNo, report.getSignPatentNo())
+        Report report =reportService.getById(reportId);
+        LambdaQueryWrapper<Features> queryWrapper =new LambdaQueryWrapper<>();
+        queryWrapper.eq(Features::getRightId,rightSort)
+                .eq(Features::getReportId,reportId)
+                .eq(Features::getSignPatentNo,report.getSignPatentNo())
                 .orderByAsc(Features::getFeaturesOrder);
-        List<Features> features = this.list(queryWrapper);
-        features.forEach(item -> {
-            Map<String, Object> map = new HashMap<>();
-            map.put("featureId", item.getId());
-            map.put("content", item.getContent());
-            map.put("featureName", "特征" + item.getFeaturesOrder());
-            mapList.add(map);
-        });
+        List<Features> features =this.list(queryWrapper);
+        //过滤获得特征id
+        List<Integer> ids =features.stream().map(Features::getId).collect(Collectors.toList());
+        List<AssoPositionFeatures> assoPositionFeatures =new ArrayList<>();
+        if(ids.size()>0){
+            LambdaQueryWrapper<AssoPositionFeatures> queryWrapper1 =new LambdaQueryWrapper<>();
+            queryWrapper1.in(AssoPositionFeatures::getFeaturesID,ids);
+            assoPositionFeatures=  assoPositionFeaturesService.list(queryWrapper1);
+
+        }
+            for(Features item:features) {
+            AssoPositionFeatures assoPositionFeature =    assoPositionFeatures.stream().filter(tem->tem.getFeaturesID().equals(item.getId())).findFirst().orElse(new AssoPositionFeatures());
+                Map<String, Object> map = new HashMap<>();
+                map.put("featureId", item.getId());
+                map.put("content", item.getContent());
+                map.put("featureName", "特征" + item.getFeaturesOrder());
+                map.put("position",assoPositionFeature.getPosition());
+                mapList.add(map);
+            }
+
         return Response.success(mapList);
     }
 }

RMS/src/main/java/cn/cslg/report/service/business/InvalidReReport/InvalidReasonFieldValueService.java

@@ -26,9 +26,8 @@ public class InvalidReasonFieldValueService extends ServiceImpl<InvalidReasonFil
 
     public Boolean addOrUpdate(List<InvalidReasonFieldValueDTO> invalidReasonFieldValueDTOs) {
           //根据无效理由id和栏位id查询
-        if(invalidReasonFieldValueDTOs==null&&invalidReasonFieldValueDTOs.size()==0){
+        if(invalidReasonFieldValueDTOs==null||invalidReasonFieldValueDTOs.size()==0){
             return false;
-
         }
 List<InvalidReasonFieldValue> invalidReasonFieldValues =this.baseMapper.getValues(invalidReasonFieldValueDTOs);
         List<InvalidReasonFieldValue> addValues =new ArrayList<>();
@@ -44,7 +43,31 @@ for (InvalidReasonFieldValueDTO fieldDTO:invalidReasonFieldValueDTOs){
     addValues.add(invalidReasonFieldValue);
 }
 this.saveOrUpdateBatch(addValues);
-        return  true;
+        return true;
     }
 
+
+
+    public Boolean addOrUpdateLists(List<InvalidReasonFieldValueDTO> invalidReasonFieldValueDTOs) {
+        //根据无效理由id和栏位id查询
+        if(invalidReasonFieldValueDTOs==null||invalidReasonFieldValueDTOs.size()==0){
+            return false;
+
+        }
+        List<InvalidReasonFieldValue> invalidReasonFieldValues =this.baseMapper.getValues(invalidReasonFieldValueDTOs);
+        List<InvalidReasonFieldValue> addValues =new ArrayList<>();
+        for (InvalidReasonFieldValueDTO fieldDTO:invalidReasonFieldValueDTOs){
+            InvalidReasonFieldValue invalidReasonFieldValue= invalidReasonFieldValues.stream()
+                    .filter(item->item.getInvalidReasonId().equals(fieldDTO.getInvalidReasonId())&&item.getInvalidReasonFieldId().equals(fieldDTO.getFieldId()))
+                    .findFirst().orElse(new InvalidReasonFieldValue());
+            if(invalidReasonFieldValue.getId()==null){
+                invalidReasonFieldValue.setFieldValue(fieldDTO.getFieldValue());
+                invalidReasonFieldValue.setInvalidReasonId(fieldDTO.getInvalidReasonId());
+                invalidReasonFieldValue.setInvalidReasonFieldId(fieldDTO.getFieldId());
+            }
+            addValues.add(invalidReasonFieldValue);
+        }
+        this.saveOrUpdateBatch(addValues);
+        return  true;
+    }
 }

RMS/src/main/java/cn/cslg/report/service/business/InvalidReReport/InvalidReasonService.java

@@ -1,14 +1,8 @@
 package cn.cslg.report.service.business.InvalidReReport;
 
-import cn.cslg.report.common.model.dto.invalidReReport.CheckReFeaturesDTO;
-import cn.cslg.report.common.model.dto.invalidReReport.InvalidReasonDTO;
-import cn.cslg.report.common.model.dto.invalidReReport.ProofGroupDTO;
-import cn.cslg.report.common.model.dto.invalidReReport.QueryInvalidReasonDTO;
+import cn.cslg.report.common.model.dto.invalidReReport.*;
 import cn.cslg.report.common.model.vo.PersonnelVO;
-import cn.cslg.report.common.model.vo.invalidReReport.ExportInvalidReasonVO;
-import cn.cslg.report.common.model.vo.invalidReReport.PagingVO;
-import cn.cslg.report.common.model.vo.invalidReReport.QueryAllFeaturesVO;
-import cn.cslg.report.common.model.vo.invalidReReport.QueryInvalidReasonVO;
+import cn.cslg.report.common.model.vo.invalidReReport.*;
 import cn.cslg.report.common.utils.CacheUtils;
 import cn.cslg.report.common.utils.DataUtils;
 import cn.cslg.report.common.utils.Response;
@@ -54,25 +48,28 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
     private final CacheUtils cacheUtils;
     private final LoginUtils loginUtils;
     private final CompareFilesService compareFilesService;
+    private final InvalidReasonFieldValueService invalidReasonFieldValueService;
+
     /**
      * 判断特征是否有重复的方法
+     *
      * @param checkReFeaturesDTO
      */
     public Boolean checkReFeatures(CheckReFeaturesDTO checkReFeaturesDTO) {
         //查出表中制定报告和权要的全部特征内容和位置
-         List<QueryAllFeaturesVO> queryAllFeaturesVOS = featureMapper.queryAllFeatures(checkReFeaturesDTO.getReportId(), checkReFeaturesDTO.getRightSort());
+        List<QueryAllFeaturesVO> queryAllFeaturesVOS = featureMapper.queryAllFeatures(checkReFeaturesDTO.getReportId(), checkReFeaturesDTO.getRightSort());
         //List<QueryAllFeaturesVO> list = queryAllFeaturesVOS.stream().sorted(Comparator.comparing(QueryAllFeaturesVO::getPosition)).collect(Collectors.toList());
         //取出需要插入的特征内容和位置
         List<CheckReFeaturesDTO.featuresIn> features = checkReFeaturesDTO.getFeatures();
         //定义一个map装载所有的特征内容和位置
         Map<Integer, Integer> map = new HashMap<>();
         //遍历装载查询出来的全部特征内容和位置
-        for(QueryAllFeaturesVO queryAllFeaturesVO:queryAllFeaturesVOS){
+        for (QueryAllFeaturesVO queryAllFeaturesVO : queryAllFeaturesVOS) {
             //位置
             Integer position = queryAllFeaturesVO.getPosition();
             //特征内容字符串的长度
             Integer length = queryAllFeaturesVO.getFeatureStr().length();
-            if(position != null && length > 0) {
+            if (position != null && length > 0) {
                 //如果map中已经有了初始位置，无论长度如何都重复
                 if (map.containsKey(position)) {
                     return false;
@@ -84,9 +81,9 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             }
         }
         //遍历装载需要插入的特征内容和位置
-        for(CheckReFeaturesDTO.featuresIn featuresIn:features){
+        for (CheckReFeaturesDTO.featuresIn featuresIn : features) {
             //如果map中已经有了初始位置，无论长度如何都重复
-            if(map.containsKey(featuresIn.getPosition())) {
+            if (map.containsKey(featuresIn.getPosition())) {
                 return false;
             } else {
                 map.put(featuresIn.getPosition(), featuresIn.getFeatureStr().length());
@@ -98,7 +95,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
         List<Integer> positions = new ArrayList<>(keySet);
         Collections.sort(positions);
         //遍历需要插入的特征内容和位置
-        for(CheckReFeaturesDTO.featuresIn featuresIn:features) {
+        for (CheckReFeaturesDTO.featuresIn featuresIn : features) {
             //需检查是否重复的特征内容的初始位置 在集合中的位置
             Integer index = positions.indexOf(featuresIn.getPosition());
             //需检查是否重复的特征内容的末尾位置
@@ -108,20 +105,22 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             //前面一个特征内容的长度
             Integer preLength = index > 0 ? map.get(preFeaInitialPos) : -1;
             //前面一个特征的末尾位置
-            Integer preEndPosition = preFeaInitialPos + preLength -1;
+            Integer preEndPosition = preFeaInitialPos + preLength - 1;
             //后面一个特征内容的初始位置
             Integer nextFeaInitialPos = index < positions.size() - 1 ? positions.get(index + 1) : -1;
             //判断是否与前面一个特征内容重复（前面一个特征内容的末尾位置如果比插入的特征内容的初始位置大，则重复了）
-            if(index > 0 && preEndPosition > featuresIn.getPosition()){
+            if (index > 0 && preEndPosition > featuresIn.getPosition()) {
                 return false;
-            } else if( index < (positions.size() - 1) && endPosition > nextFeaInitialPos){//判断是否与后面一个特征内容重复（如果插入的特征内容的末尾位置，比后面一个特征内容的初始位置大，则重复）
+            } else if (index < (positions.size() - 1) && endPosition > nextFeaInitialPos) {//判断是否与后面一个特征内容重复（如果插入的特征内容的末尾位置，比后面一个特征内容的初始位置大，则重复）
                 return false;
             }
         }
         return true;
     }
+
     /**
      * 添加无效理由和证据
+     *
      * @param invalidReasonDTO 无效理由和证据Dto类
      * @return
      */
@@ -130,16 +129,16 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
         InvalidReason invalidReason = new InvalidReason();
         //判断invalidName的类型
         Integer invalidName = invalidReasonDTO.getInvalidName();
-        if(invalidName.equals(1)) {//若类型为1，则为说明书公开不充分,涉及内容为说明书，手动输入无效证据
+        if (invalidName.equals(1)) {//若类型为1，则为说明书公开不充分,涉及内容为说明书，手动输入无效证据
             BeanUtils.copyProperties(invalidReasonDTO, invalidReason);
             //获取当前登陆人信息
             PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
             invalidReason.setCreateId(personnelVO.getId());
             //说明书公开不充分入表
             invalidReason.insert();
-        } else if(invalidName.equals(0)){//若类型为0，则为“权利要求不清楚”，需要选择涉及内容（content）并输入相关证据（proofStr）
-            if(invalidReasonDTO.getProofStr() != null && invalidReasonDTO.getProofStr() != ""){
-                if(invalidReasonDTO.getInvalidName()==1){
+        } else if (invalidName.equals(0)) {//若类型为0，则为“权利要求不清楚”，需要选择涉及内容（content）并输入相关证据（proofStr）
+            if (invalidReasonDTO.getProofStr() != null && invalidReasonDTO.getProofStr() != "") {
+                if (invalidReasonDTO.getInvalidName() == 1) {
                     invalidReasonDTO.setContent(-1);
                 }
                 //复制DTO类字段到InvalidReason实体类并保存入库
@@ -153,20 +152,20 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 invalidReason.insert();
                 //有可能为特征不清楚
                 //判断是否传入特征集合
-                if(invalidReasonDTO.getFeatures() != null && invalidReasonDTO.getFeatures().size() > 0) {
+                if (invalidReasonDTO.getFeatures() != null && invalidReasonDTO.getFeatures().size() > 0) {
                     //若类型为0检查features是否有交集（根据位置和字符串长度判断）若有则返回
                     Features features = new Features();
                     //特征内容
-                    List<InvalidReasonDTO.featuresIn> featuresIns = invalidReasonDTO.getFeatures();
+                    List<InvalidReasonDTO.FeaturesIn> featuresIns = invalidReasonDTO.getFeatures();
                     //检查特征内容是否有交集（根据位置和字符串长度判断）若有则返回
                     //装载检查重复需要的类
                     CheckReFeaturesDTO checkReFeaturesDTO = new CheckReFeaturesDTO();
                     checkReFeaturesDTO.setReportId(invalidReasonDTO.getReportId());
                     checkReFeaturesDTO.setRightSort(invalidReasonDTO.getContent());
                     List<CheckReFeaturesDTO.featuresIn> checkFeatureIns = new ArrayList<>();
-                    for(InvalidReasonDTO.featuresIn featuresIn : featuresIns){
+                    for (InvalidReasonDTO.FeaturesIn featuresIn : featuresIns) {
                         CheckReFeaturesDTO.featuresIn featuresIn1 = new CheckReFeaturesDTO.featuresIn();
-                        BeanUtils.copyProperties(featuresIn,featuresIn1);
+                        BeanUtils.copyProperties(featuresIn, featuresIn1);
                         checkFeatureIns.add(featuresIn1);
                     }
                     checkReFeaturesDTO.setFeatures(checkFeatureIns);
@@ -190,7 +189,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                     //遍历特征内容集合，保存到表（类型为0）
                     for (int i = 0; i < featuresIns.size(); i++) {
                         //若类型为0,保存到特征表
-                        InvalidReasonDTO.featuresIn featuresIn = featuresIns.get(i);
+                        InvalidReasonDTO.FeaturesIn featuresIn = featuresIns.get(i);
                         features.setContent(featuresIn.getFeatureStr());
                         features.insert();
                         //若类型为0,保存到特征与位置关联表(特征id,位置)
@@ -203,8 +202,8 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             } else {
                 return Response.error("相关证据不能为空");
             }
-        } else if(invalidName.equals(2) || invalidName.equals(3)){//若类型为2,3则proofGroups不能为空
-            if(invalidReasonDTO.getProofGroups()!= null){
+        } else if (invalidName.equals(2) || invalidName.equals(3)) {//若类型为2,3则proofGroups不能为空
+            if (invalidReasonDTO.getProofGroups() != null) {
                 //复制DTO类字段到InvalidReason实体类并保存入库
                 BeanUtils.copyProperties(invalidReasonDTO, invalidReason);
                 //获取当前登陆人信息
@@ -213,12 +212,12 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 invalidReason.insert();
                 //根据proofGroups保存proofGroup
                 List<ProofGroupDTO> proofGroupDTOS = new ArrayList<>();
-                for(InvalidReasonDTO.proofGroupIn proofGroupIn:invalidReasonDTO.getProofGroups()){
+                for (InvalidReasonDTO.ProofGroupIn proofGroupIn : invalidReasonDTO.getProofGroups()) {
                     ProofGroupDTO proofGroupDTO = new ProofGroupDTO();
                     proofGroupDTO.setInvalidReasonId(invalidReason.getId());//无效理由id
                     proofGroupDTO.setDescription(proofGroupIn.getDescription());//描述
-                    proofGroupDTO.setArgument_str(proofGroupIn.getArgument_str());//陈述意见
-                    proofGroupDTO.setProofIds(proofGroupIn.getProofIds());//证据ids
+                    proofGroupDTO.setArgumentStr(proofGroupIn.getArgumentStr());//陈述意见
+                    proofGroupDTO.setGroupDetails(proofGroupIn.getGroupDetails());//证据ids
                     proofGroupDTOS.add(proofGroupDTO);
                 }
                 proofGroupService.addProofGroup(proofGroupDTOS);
@@ -226,11 +225,19 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 return Response.error("证据组合不能为空");
             }
         }
+        //添加自定义字段值
+        if (invalidReasonDTO.getFields() != null) {
+            invalidReasonDTO.getFields().forEach(item -> {
+                item.setInvalidReasonId(invalidReason.getId());
+            });
+        }
+        invalidReasonFieldValueService.addOrUpdate(invalidReasonDTO.getFields());
         return Response.success("添加成功");
     }
 
     /**
      * 删除无效理由
+     *
      * @param ids 无效理由id
      * @return
      * @throws IOException
@@ -249,23 +256,24 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
 
     /**
      * 更新无效理由和证据
+     *
      * @param invalidReasonDTO
      * @return
      */
     @Transactional(rollbackFor = Exception.class)
-    public  String updateInvalidReason(InvalidReasonDTO invalidReasonDTO) {
-        if(invalidReasonDTO.getId() == null){
-            return  Response.error("请选择无效理由");
+    public String updateInvalidReason(InvalidReasonDTO invalidReasonDTO) {
+        if (invalidReasonDTO.getId() == null) {
+            return Response.error("请选择无效理由");
         }
-        Integer invalidName =invalidReasonDTO.getInvalidName();
+        Integer invalidName = invalidReasonDTO.getInvalidName();
         InvalidReason invalidReason = this.getById(invalidReasonDTO.getId());
-        if(invalidName.equals(1)) {//若类型为1，则为说明书公开不充分,涉及内容为说明书，手动输入无效证据
+        if (invalidName.equals(1)) {//若类型为1，则为说明书公开不充分,涉及内容为说明书，手动输入无效证据
             BeanUtils.copyProperties(invalidReasonDTO, invalidReason);
             //说明书公开不充分入表
             invalidReason.updateById();
-        } else if(invalidName.equals(0)){//若类型为0，则为“权利要求不清楚”，需要选择涉及内容（content）并输入相关证据（proofStr）
-            if(invalidReasonDTO.getProofStr() != null && invalidReasonDTO.getProofStr() != ""){
-                if(invalidReasonDTO.getInvalidName() == 1){
+        } else if (invalidName.equals(0)) {//若类型为0，则为“权利要求不清楚”，需要选择涉及内容（content）并输入相关证据（proofStr）
+            if (invalidReasonDTO.getProofStr() != null && invalidReasonDTO.getProofStr() != "") {
+                if (invalidReasonDTO.getInvalidName() == 1) {
                     invalidReasonDTO.setContent(-1);
                 }
                 //复制DTO类字段到InvalidReason实体类并保存入库
@@ -276,22 +284,22 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 invalidReason.updateById();
                 //有可能为特征不清楚
                 //判断是否传入特征集合 (更新无特征更新，可取消）
-                if(invalidReasonDTO.getFeatures() != null && invalidReasonDTO.getFeatures().size() > 0) {
+                if (invalidReasonDTO.getFeatures() != null && invalidReasonDTO.getFeatures().size() > 0) {
                     //若类型为0检查features是否有交集（根据位置和字符串长度判断）若有则返回
                     Features features = new Features();
                     //特征内容
-                    List<InvalidReasonDTO.featuresIn> featuresIns = invalidReasonDTO.getFeatures();
+                    List<InvalidReasonDTO.FeaturesIn> featuresIns = invalidReasonDTO.getFeatures();
                     //过滤带有不带有特征id的特征
-                    featuresIns = featuresIns.stream().filter(item->item.getId() == null).collect(Collectors.toList());
+                    featuresIns = featuresIns.stream().filter(item -> item.getId() == null).collect(Collectors.toList());
                     //检查特征内容是否有交集（根据位置和字符串长度判断）若有则返回
                     //装载检查重复需要的类
                     CheckReFeaturesDTO checkReFeaturesDTO = new CheckReFeaturesDTO();
                     checkReFeaturesDTO.setReportId(invalidReasonDTO.getReportId());
                     checkReFeaturesDTO.setRightSort(invalidReasonDTO.getContent());
                     List<CheckReFeaturesDTO.featuresIn> checkFeatureIns = new ArrayList<>();
-                    for(InvalidReasonDTO.featuresIn featuresIn : featuresIns){
+                    for (InvalidReasonDTO.FeaturesIn featuresIn : featuresIns) {
                         CheckReFeaturesDTO.featuresIn featuresIn1 = new CheckReFeaturesDTO.featuresIn();
-                        BeanUtils.copyProperties(featuresIn,featuresIn1);
+                        BeanUtils.copyProperties(featuresIn, featuresIn1);
                         checkFeatureIns.add(featuresIn1);
                     }
                     checkReFeaturesDTO.setFeatures(checkFeatureIns);
@@ -315,7 +323,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                     //遍历特征内容集合，保存到表（类型为0）
                     for (int i = 0; i < featuresIns.size(); i++) {
                         //若类型为0,保存到特征表
-                        InvalidReasonDTO.featuresIn featuresIn = featuresIns.get(i);
+                        InvalidReasonDTO.FeaturesIn featuresIn = featuresIns.get(i);
                         features.setContent(featuresIn.getFeatureStr());
                         features.insert();
                         //若类型为0,保存到特征与位置关联表(特征id,位置)
@@ -329,8 +337,8 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             } else {
                 return Response.error("相关证据不能为空");
             }
-        } else if(invalidName.equals(2) || invalidName.equals(3)){//若类型为2,3则proofGroups不能为空
-            if(invalidReasonDTO.getProofGroups()!= null){
+        } else if (invalidName.equals(2) || invalidName.equals(3)) {//若类型为2,3则proofGroups不能为空
+            if (invalidReasonDTO.getProofGroups() != null) {
                 //复制DTO类字段到InvalidReason实体类并保存入库
                 BeanUtils.copyProperties(invalidReasonDTO, invalidReason);
                 invalidReason.updateById();
@@ -338,12 +346,12 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 proofGroupService.deleteProofGroupByInvalid(invalidReason.getId());
                 //根据proofGroups保存proofGroup
                 List<ProofGroupDTO> proofGroupDTOS = new ArrayList<>();
-                for(InvalidReasonDTO.proofGroupIn proofGroupIn:invalidReasonDTO.getProofGroups()){
+                for (InvalidReasonDTO.ProofGroupIn proofGroupIn : invalidReasonDTO.getProofGroups()) {
                     ProofGroupDTO proofGroupDTO = new ProofGroupDTO();
                     proofGroupDTO.setInvalidReasonId(invalidReason.getId());//无效理由id
                     proofGroupDTO.setDescription(proofGroupIn.getDescription());//描述
-                    proofGroupDTO.setArgument_str(proofGroupIn.getArgument_str());//陈述意见
-                    proofGroupDTO.setProofIds(proofGroupIn.getProofIds());//证据ids
+                    proofGroupDTO.setArgumentStr(proofGroupIn.getArgumentStr());//陈述意见
+                    proofGroupDTO.setGroupDetails(proofGroupIn.getGroupDetails());//证据ids
                     proofGroupDTOS.add(proofGroupDTO);
                 }
                 proofGroupService.addProofGroup(proofGroupDTOS);
@@ -351,11 +359,19 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 return Response.error("证据组合不能为空");
             }
         }
+        //添加自定义字段值
+        if (invalidReasonDTO.getFields() != null) {
+            invalidReasonDTO.getFields().forEach(item -> {
+                item.setInvalidReasonId(invalidReason.getId());
+            });
+        }
+        invalidReasonFieldValueService.addOrUpdate(invalidReasonDTO.getFields());
         return Response.success("更新成功");
     }
 
     /**
      * 查找无效理由和证据列表
+     *
      * @param
      * @return
      */
@@ -364,239 +380,278 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
         List<QueryInvalidReasonVO> queryInvalidReasonVOS = new ArrayList<>();
         //根据报告id查询无效理由
         List<InvalidReason> invalidReasons = new ArrayList<>();
-        if(reportId != null) {
+        if (reportId != null) {
             LambdaQueryWrapper<InvalidReason> queryWrapper = new LambdaQueryWrapper<>();
             queryWrapper.eq(InvalidReason::getReportId, reportId);
             invalidReasons = this.list(queryWrapper);
         }
-        for(InvalidReason invalidReason:invalidReasons) {
+        for (InvalidReason invalidReason : invalidReasons) {
             QueryInvalidReasonVO queryInvalidReasonVO = new QueryInvalidReasonVO();
-            BeanUtils.copyProperties(invalidReason,queryInvalidReasonVO);
+            BeanUtils.copyProperties(invalidReason, queryInvalidReasonVO);
             queryInvalidReasonVOS.add(queryInvalidReasonVO);
         }
-        if(queryInvalidReasonVOS.size()>0) {
+        if (queryInvalidReasonVOS.size() > 0) {
             List<QueryInvalidReasonVO> queryInvalidReasonVOs = this.loadInvalidReason(queryInvalidReasonVOS);
             return queryInvalidReasonVOs;
         }
         return null;
     }
 
-                    /**查找无效理由和证据列表
-                     *
-                     * 把无效理由集合装载到要返回的列表集合中
-                     * @param queryInvalidReasonVOS
-                     */
-                    public List<QueryInvalidReasonVO> loadInvalidReason(List<QueryInvalidReasonVO> queryInvalidReasonVOS){
-                        //若类型为2,3,则查询证据组合
-                        //查询出类型为2,3时的无效理由ids
-                        List<Integer> invalidReasonsIds = queryInvalidReasonVOS.stream()
-                                .filter(item -> item.getInvalidName() == 2 || item.getInvalidName() == 3)
-                                .map(QueryInvalidReasonVO::getId)
-                                .collect(Collectors.toList());
-                        //根据无效理由ids查询出所有的证据组合c
-                        List<ProofGroup> proofGroups  =new ArrayList<>();
-                        if(invalidReasonsIds.size() > 0) {
-                            LambdaQueryWrapper<ProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
-                            queryWrapper1.in(ProofGroup::getInvalidReasonId, invalidReasonsIds);
-                            proofGroups = proofGroupService.list(queryWrapper1);
-                        }
-                        //由于查出来的proofGroups中没有proofIds这个字段，于是采用下面的方法装载成proofGroupVOS
-                        List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = this.loadProofGroupVO(proofGroups);
-                            for(QueryInvalidReasonVO queryInvalidReasonVO:queryInvalidReasonVOS) {
-                                //比对无效理由id，把能匹配上的进行装载
-                                List<QueryInvalidReasonVO.proofGroupIn> proofGroupIn = proofGroupIns.stream()
-                                        .filter(item -> item.getInvalidReasonId().equals(queryInvalidReasonVO.getId()))
-                                        .collect(Collectors.toList());
-                                queryInvalidReasonVO.setProofGroups(proofGroupIn);
-                            }
-                        return queryInvalidReasonVOS;
-                    }
+    /**
+     * 查找无效理由和证据列表
+     * <p>
+     * 把无效理由集合装载到要返回的列表集合中
+     *
+     * @param queryInvalidReasonVOS
+     */
+    public List<QueryInvalidReasonVO> loadInvalidReason(List<QueryInvalidReasonVO> queryInvalidReasonVOS) {
+        //若类型为2,3,则查询证据组合
+        //查询出类型为2,3时的无效理由ids
+        List<Integer> invalidReasonsIds = queryInvalidReasonVOS.stream()
+                .map(QueryInvalidReasonVO::getId)
+                .collect(Collectors.toList());
+        //根据无效理由ids查询出所有的证据组合c
+        List<ProofGroup> proofGroups = new ArrayList<>();
+        if (invalidReasonsIds.size() > 0) {
+            LambdaQueryWrapper<ProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
+            queryWrapper1.in(ProofGroup::getInvalidReasonId, invalidReasonsIds);
+            proofGroups = proofGroupService.list(queryWrapper1);
+        }
+        //由于查出来的proofGroups中没有proofIds这个字段，于是采用下面的方法装载成proofGroupVOS
+        List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = this.loadProofGroupVO(proofGroups);
+        //根据无效理由id查询自定义字段
 
-                    /**查找无效理由和证据列表
-                     *
-                     * 把查出来的所有证据组合实体类集合转成VO类集合
-                     * @param proofGroups
-                     */
-                    public List<QueryInvalidReasonVO.proofGroupIn> loadProofGroupVO(List<ProofGroup> proofGroups){
-                        List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = new ArrayList<>();
-                        //根据传入的proofGroups对象集合，过滤出所有的ids
-                        List<Integer> proofGroupIds = proofGroups.stream()
-                                .map(ProofGroup::getId)
-                                .collect(Collectors.toList());
-                        //根据组合ids查询出每一个groupId对应的proofIds
-                        //首先批量查出来所有的证据和证据组合关联对象
-                        List<AssoProofGroup> assoProofGroups = new ArrayList<>();
-                        if(proofGroupIds.size() > 0) {
-                            LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
-                            queryWrapper.in(AssoProofGroup::getGroupId, proofGroupIds);
-                            assoProofGroups = assoProofGroupService.list(queryWrapper);
-                        }
-                        //证据组合的装载
-                        for (ProofGroup proofGroup : proofGroups) {
-                            QueryInvalidReasonVO.proofGroupIn proofGroupIn = new QueryInvalidReasonVO.proofGroupIn();
-                            //基本信息装载
-                            proofGroupIn.setInvalidReasonId(proofGroup.getInvalidReasonId());
-                            proofGroupIn.setDescription(proofGroup.getDescription());
-                            proofGroupIn.setArgument_str(proofGroup.getArgument_str());
-                            List<Integer> proofIds = assoProofGroups.stream().filter(item->item.getGroupId().equals(proofGroup.getId())).map(AssoProofGroup::getProofId).collect(Collectors.toList());
-                           //根据证据id查询证据
-                            List<CompareFiles> proofs =new ArrayList<>();
-                            if(proofIds.size()>0) {
-                                LambdaQueryWrapper<CompareFiles> proofLambdaQueryWrapper = new LambdaQueryWrapper<CompareFiles>();
-                                proofLambdaQueryWrapper.in(CompareFiles::getId, proofIds);
-                               proofs =compareFilesService.list(proofLambdaQueryWrapper);
-                            }
-                            List<QueryInvalidReasonVO.proofIn> proofIns =new ArrayList<>();
-                            proofs.forEach(item->{
-                                QueryInvalidReasonVO.proofIn proof=new QueryInvalidReasonVO.proofIn();
-                                proof.setId(item.getId());
-                                proof.setSort(item.getSysOrder());
-                                proof.setPatentNo(item.getPatentNo());
-                                proof.setFileId(item.getFileId());
-                                proof.setFileType(item.getFileType());
-                                proofIns.add(proof);
-                            });
-                            proofGroupIn.setProofIds(proofIds);
-                            proofGroupIn.setProofs(proofIns);
-                            proofGroupIns.add(proofGroupIn);
-                        }
-                        return proofGroupIns;
-                    }
+        //根据无效理由id查询自定义字段值
+        LambdaQueryWrapper<InvalidReasonFieldValue> wrapper = new LambdaQueryWrapper<>();
+        wrapper.in(InvalidReasonFieldValue::getInvalidReasonId, invalidReasonsIds);
+        List<InvalidReasonFieldValueDTO> invalidReasonFieldValues = invalidReasonFieldValueService.getBaseMapper().getListByReasonIds(invalidReasonsIds);
+        for (QueryInvalidReasonVO queryInvalidReasonVO : queryInvalidReasonVOS) {
+            //比对无效理由id，把能匹配上的进行装载
+            List<QueryInvalidReasonVO.proofGroupIn> proofGroupIn = proofGroupIns.stream()
+                    .filter(item -> item.getInvalidReasonId().equals(queryInvalidReasonVO.getId()))
+                    .collect(Collectors.toList());
+            queryInvalidReasonVO.setProofGroups(proofGroupIn);
+            List<InvalidReasonFieldValueDTO> valuesTem = invalidReasonFieldValues.stream().filter(item -> item.getInvalidReasonId().equals(queryInvalidReasonVO.getId())).collect(Collectors.toList());
+            queryInvalidReasonVO.setFields(valuesTem);
+        }
+        return queryInvalidReasonVOS;
+    }
+
+    /**
+     * 查找无效理由和证据列表
+     * <p>
+     * 把查出来的所有证据组合实体类集合转成VO类集合
+     *
+     * @param proofGroups
+     */
+    public List<QueryInvalidReasonVO.proofGroupIn> loadProofGroupVO(List<ProofGroup> proofGroups) {
+        List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = new ArrayList<>();
+        //根据传入的proofGroups对象集合，过滤出所有的ids
+        List<Integer> proofGroupIds = proofGroups.stream()
+                .map(ProofGroup::getId)
+                .collect(Collectors.toList());
+        //根据组合ids查询出每一个groupId对应的proofIds
+        //首先批量查出来所有的证据和证据组合关联对象
+        List<AssoProofGroup> assoProofGroups = new ArrayList<>();
+        if (proofGroupIds.size() > 0) {
+            LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.in(AssoProofGroup::getGroupId, proofGroupIds);
+            assoProofGroups = assoProofGroupService.list(queryWrapper);
+        }
+        //证据组合的装载
+        for (ProofGroup proofGroup : proofGroups) {
+            QueryInvalidReasonVO.proofGroupIn proofGroupIn = new QueryInvalidReasonVO.proofGroupIn();
+            //基本信息装载
+            proofGroupIn.setInvalidReasonId(proofGroup.getInvalidReasonId());
+            proofGroupIn.setDescription(proofGroup.getDescription());
+            proofGroupIn.setArgument_str(proofGroup.getArgumentStr());
+            List<Integer> proofIds = assoProofGroups.stream().filter(item -> item.getGroupId().equals(proofGroup.getId())).map(AssoProofGroup::getProofId).collect(Collectors.toList());
+            //根据证据id查询证据
+            List<CompareFiles> proofs = new ArrayList<>();
+            if (proofIds.size() > 0) {
+                LambdaQueryWrapper<CompareFiles> proofLambdaQueryWrapper = new LambdaQueryWrapper<CompareFiles>();
+                proofLambdaQueryWrapper.in(CompareFiles::getId, proofIds);
+                proofs = compareFilesService.list(proofLambdaQueryWrapper);
+            }
+            List<QueryInvalidReasonVO.proofIn> proofIns = new ArrayList<>();
+            proofs.forEach(item -> {
+                QueryInvalidReasonVO.proofIn proof = new QueryInvalidReasonVO.proofIn();
+                proof.setId(item.getId());
+                proof.setSort(item.getSysOrder());
+                proof.setPatentNo(item.getPatentNo());
+                proof.setFileId(item.getFileId());
+                proof.setFileType(item.getFileType());
+                proofIns.add(proof);
+            });
+            proofGroupIn.setProofIds(proofIds);
+            proofIns.sort(Comparator.comparing(QueryInvalidReasonVO.proofIn::getSort));
+            proofGroupIn.setProofs(proofIns);
+            proofGroupIns.add(proofGroupIn);
+        }
+        return proofGroupIns;
+    }
 
     /**
      * 查询无效理由和证据的详情
+     *
      * @param id
      * @return
      * @throws IOException
      */
     public String queryInvalidReasonDetail(Integer id) throws IOException {
         QueryInvalidReasonVO queryInvalidReasonVO = new QueryInvalidReasonVO();
-        if(id != null && id > 0){
+        if (id != null && id > 0) {
             //根据id查询无效理由
             InvalidReason invalidReason = this.getById(id);
-            if(invalidReason == null){
+            if (invalidReason == null) {
                 return Response.error("没查到无效理由");
             }
             //将初步查出来的无效理由赋值给要返回的VO类
-            BeanUtils.copyProperties(invalidReason,queryInvalidReasonVO);
+            BeanUtils.copyProperties(invalidReason, queryInvalidReasonVO);
             Integer invalidName = invalidReason.getInvalidName();
-            if(invalidName == null){
+            if (invalidName == null) {
                 return Response.error("没查到类型");
             }
             //若类型为0，则查询出特征并且装载
-            if(invalidName.equals(0)){
+            if (invalidName.equals(0)) {
                 //获取报告id和权要排序字段
                 Integer reportId = invalidReason.getReportId();
                 Integer rightSort = invalidReason.getRightSort();
-                if(reportId != null && rightSort != null){
+                if (reportId != null && rightSort != null) {
                     //调用装载特征的方法
-                    List<QueryInvalidReasonVO.featuresIn> featuresIns = this.loadFeature(reportId,rightSort);
+                    List<QueryInvalidReasonVO.featuresIn> featuresIns = this.loadFeature(reportId, rightSort);
                     //赋值
                     queryInvalidReasonVO.setFeatures(featuresIns);
-                    return Response.success(queryInvalidReasonVO);
                 }
-            } else if(invalidName.equals(2)||invalidName.equals(3)){//若类型为2,3则查询证据组合并装载
+            } else if (invalidName.equals(2) || invalidName.equals(3)) { //若类型为2,3则查询证据组合并装载
                 //根据无效理由id查询出proofGroup集合
                 Integer invalidReasonId = invalidReason.getId();
                 //调用装载证据组合方法
                 List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = this.loadProofGroup(invalidReasonId);
                 queryInvalidReasonVO.setProofGroups(proofGroupIns);
-                return Response.success(queryInvalidReasonVO);
-            } else if(invalidName.equals(1)){
-                //查出来的无效理由可以直接返回
-                return Response.success(queryInvalidReasonVO);
             } else {
                 return Response.error("无效类型错误");
             }
-            return Response.success();
+            //根据无效理由id查询自定义字段值
+            LambdaQueryWrapper<InvalidReasonFieldValue> wrapper = new LambdaQueryWrapper<>();
+            wrapper.eq(InvalidReasonFieldValue::getInvalidReasonId, id);
+            List<InvalidReasonFieldValue> invalidReasonFieldValues = invalidReasonFieldValueService.list(wrapper);
+            List<InvalidReasonFieldValueDTO> list = new ArrayList<>();
+            invalidReasonFieldValues.forEach(item -> {
+                InvalidReasonFieldValueDTO invalidReasonFieldValueDTO = new InvalidReasonFieldValueDTO();
+                invalidReasonFieldValueDTO.setInvalidReasonId(item.getInvalidReasonId());
+                invalidReasonFieldValueDTO.setFieldValue(item.getFieldValue());
+                invalidReasonFieldValueDTO.setFieldId(item.getInvalidReasonFieldId());
+                list.add(invalidReasonFieldValueDTO);
+            });
+            queryInvalidReasonVO.setFields(list);
+            //查出来的无效理由可以直接返回
+            return Response.success(queryInvalidReasonVO);
         } else {
             return Response.error("未传入参数");
         }
     }
 
-                /**
-                 * 装载特征集合
-                 * @param reportId
-                 * @param rightSort
-                 * @return
-                 */
-                public List<QueryInvalidReasonVO.featuresIn> loadFeature(Integer reportId, Integer rightSort){
-                    //需要装载的某个无效理由的特征集合
-                    List<QueryInvalidReasonVO.featuresIn> featuresIns = new ArrayList<>();
-                    //通过报告id查询标的专利号
-                    LambdaQueryWrapper<Report> queryWrapper = new LambdaQueryWrapper<>();
-                    queryWrapper.eq(Report::getId, reportId);
-                    Report report = reportService.getOne(queryWrapper);
-                    //获取标的专利号
-                    String signPatentNo = report.getSignPatentNo();
-                    //根据标的专利号、报告id、权要排序查询出特征集合
-                    LambdaQueryWrapper<Features> queryWrapper1 = new LambdaQueryWrapper<>();
-                    queryWrapper1.eq(Features::getReportId,reportId)
-                            .eq(Features::getSignPatentNo,signPatentNo)
-                            .eq(Features::getRightId,rightSort);
-                    List<Features> featuress= featureService.list(queryWrapper1);
-                    //遍历特征集合
-                    for(Features features:featuress){
-                        //需要装载的某个无效理由的每个特征
-                        QueryInvalidReasonVO.featuresIn featuresIn = new QueryInvalidReasonVO.featuresIn();
-                        featuresIn.setFeatureStr(features.getContent());
-                        //需要根据特征id查询出它的初始位置
-                        Integer featureId = features.getId();
-                        LambdaQueryWrapper<AssoPositionFeatures> queryWrapper2 = new LambdaQueryWrapper<>();
-                        queryWrapper2.eq(AssoPositionFeatures::getFeaturesID,featureId);
-                        AssoPositionFeatures assoPositionFeatures = assoPositionFeaturesService.getOne(queryWrapper2);
-                        featuresIn.setPosition(assoPositionFeatures.getPosition());
-                        featuresIns.add(featuresIn);
-                    }
-                    return featuresIns;
-                }
+    /**
+     * 装载特征集合
+     *
+     * @param reportId
+     * @param rightSort
+     * @return
+     */
+    public List<QueryInvalidReasonVO.featuresIn> loadFeature(Integer reportId, Integer rightSort) {
+        //需要装载的某个无效理由的特征集合
+        List<QueryInvalidReasonVO.featuresIn> featuresIns = new ArrayList<>();
+        //通过报告id查询标的专利号
+        LambdaQueryWrapper<Report> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(Report::getId, reportId);
+        Report report = reportService.getOne(queryWrapper);
+        //获取标的专利号
+        String signPatentNo = report.getSignPatentNo();
+        //根据标的专利号、报告id、权要排序查询出特征集合
+        LambdaQueryWrapper<Features> queryWrapper1 = new LambdaQueryWrapper<>();
+        queryWrapper1.eq(Features::getReportId, reportId)
+                .eq(Features::getSignPatentNo, signPatentNo)
+                .eq(Features::getRightId, rightSort);
+        List<Features> featuress = featureService.list(queryWrapper1);
+        //遍历特征集合
+        for (Features features : featuress) {
+            //需要装载的某个无效理由的每个特征
+            QueryInvalidReasonVO.featuresIn featuresIn = new QueryInvalidReasonVO.featuresIn();
+            featuresIn.setFeatureStr(features.getContent());
+            //需要根据特征id查询出它的初始位置
+            Integer featureId = features.getId();
+            LambdaQueryWrapper<AssoPositionFeatures> queryWrapper2 = new LambdaQueryWrapper<>();
+            queryWrapper2.eq(AssoPositionFeatures::getFeaturesID, featureId);
+            AssoPositionFeatures assoPositionFeatures = assoPositionFeaturesService.getOne(queryWrapper2);
+            featuresIn.setPosition(assoPositionFeatures.getPosition());
+            featuresIns.add(featuresIn);
+        }
+        return featuresIns;
+    }
 
-                /**
-                 * 装载证据组合
-                 * @param invalidReasonId
-                 * @return
-                 */
-                public List<QueryInvalidReasonVO.proofGroupIn> loadProofGroup(Integer invalidReasonId){
-                    List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = new ArrayList<>();
-                    //根据无效理由id查询出证据组合集合
-                    LambdaQueryWrapper<ProofGroup> queryWrapper = new LambdaQueryWrapper<>();
-                    queryWrapper.eq(ProofGroup::getInvalidReasonId,invalidReasonId);
-                    List<ProofGroup> proofGroups = proofGroupService.list(queryWrapper);
-                    if(proofGroups != null && proofGroups.size() > 0){
-                        //遍历证据组合集合
-                        for(ProofGroup proofGroup:proofGroups){
-                            QueryInvalidReasonVO.proofGroupIn proofGroupIn = new QueryInvalidReasonVO.proofGroupIn();
-                            proofGroupIn.setDescription(proofGroup.getDescription());
-                            proofGroupIn.setArgument_str(proofGroup.getArgument_str());
-                            //组合id
-                            Integer groupId = proofGroup.getId();
-                            LambdaQueryWrapper<AssoProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
-                            queryWrapper1.eq(AssoProofGroup::getGroupId,groupId);
-                            List<AssoProofGroup> assoProofGroups = assoProofGroupService.list(queryWrapper1);
-                            //取出证据ids
-                            List<Integer> proofIds = assoProofGroups.stream().map(AssoProofGroup::getProofId).collect(Collectors.toList());
-                            proofGroupIn.setProofIds(proofIds);
-                            proofGroupIns.add(proofGroupIn);
-                        }
-                        return proofGroupIns;
-                    } else {
-                        return null;
-                    }
-                }
+    /**
+     * 装载证据组合
+     *
+     * @param invalidReasonId
+     * @return
+     */
+    public List<QueryInvalidReasonVO.proofGroupIn> loadProofGroup(Integer invalidReasonId) {
+        List<QueryInvalidReasonVO.proofGroupIn> proofGroupIns = new ArrayList<>();
+        //根据无效理由id查询出证据组合集合
+        LambdaQueryWrapper<ProofGroup> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(ProofGroup::getInvalidReasonId, invalidReasonId);
+        List<ProofGroup> proofGroups = proofGroupService.list(queryWrapper);
+        if (proofGroups != null && proofGroups.size() > 0) {
+            //遍历证据组合集合
+            for (ProofGroup proofGroup : proofGroups) {
+                QueryInvalidReasonVO.proofGroupIn proofGroupIn = new QueryInvalidReasonVO.proofGroupIn();
+                proofGroupIn.setDescription(proofGroup.getDescription());
+                proofGroupIn.setArgument_str(proofGroup.getArgumentStr());
+                //组合id
+                Integer groupId = proofGroup.getId();
+                LambdaQueryWrapper<AssoProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
+                queryWrapper1.eq(AssoProofGroup::getGroupId, groupId);
+                List<AssoProofGroup> assoProofGroups = assoProofGroupService.list(queryWrapper1);
+                //取出证据ids
+                List<Integer> proofIds = assoProofGroups.stream().map(AssoProofGroup::getProofId).collect(Collectors.toList());
+                proofGroupIn.setProofIds(proofIds);
+                proofGroupIns.add(proofGroupIn);
+            }
+            return proofGroupIns;
+        } else {
+            return null;
+        }
+    }
+
+
+    @Transactional(rollbackFor = Exception.class)
+    public String updateArgumentStr(UpdateArgumentStrDTO updateArgumentStrDTO) {
+        Integer invalidReasonId = updateArgumentStrDTO.getId();
+        String argumentStr = updateArgumentStrDTO.getArgumentStr();
+        if (invalidReasonId == null) {
 
+            return Response.error("请选择无效理由");
+        }
+        InvalidReason invalidReason = this.getById(invalidReasonId);
+        invalidReason.setArgumentStr(argumentStr);
+        invalidReason.updateById();
+        return Response.success("修改成功");
+    }
     /**
      * 导出无效理由所需的查询
+     *
      * @param reportId
      * @return
      */
-    public List<ExportInvalidReasonVO> exportInvalidReason(Integer reportId){
+    public List<ExportInvalidReasonVO> exportInvalidReason(Integer reportId) {
         List<ExportInvalidReasonVO> exportInvalidReasonVOS = new ArrayList<>();
         //根据报告id查询出所有无效理由,无效理由(0权利要求不清楚 1说明书公开不充分 2不具备创造性 3不具备新颖性）
         LambdaQueryWrapper<InvalidReason> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(InvalidReason::getReportId,reportId);
+        queryWrapper.eq(InvalidReason::getReportId, reportId);
         List<InvalidReason> invalidReasons = this.list(queryWrapper);
-        for(InvalidReason invalidReason : invalidReasons){
-            if(invalidReason != null){
+        for (InvalidReason invalidReason : invalidReasons) {
+            if (invalidReason != null) {
                 ExportInvalidReasonVO exportInvalidReasonVO = this.invalidReasonToExport(invalidReason);
                 exportInvalidReasonVOS.add(exportInvalidReasonVO);
             }
@@ -606,16 +661,17 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
 
     /**
      * 根据无效理由对象转换成返回的VO类
+     *
      * @param invalidReason
      * @return
      */
-    public ExportInvalidReasonVO invalidReasonToExport(InvalidReason invalidReason){
+    public ExportInvalidReasonVO invalidReasonToExport(InvalidReason invalidReason) {
         ExportInvalidReasonVO exportInvalidReasonVO = new ExportInvalidReasonVO();
         //陈述意见
         exportInvalidReasonVO.setArgumentStr(invalidReason.getArgumentStr());
         Integer invalidName = invalidReason.getInvalidName();
         //无效理由类型为0，为权利要求不清楚
-        if(invalidName.equals(0)){
+        if (invalidName.equals(0)) {
             //无效理由
             exportInvalidReasonVO.setInvalidName(invalidName);
             //涉及内容(权要排序)
@@ -624,7 +680,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             exportInvalidReasonVO.setProofStr(invalidReason.getProofStr());
 
             return exportInvalidReasonVO;
-        } else if(invalidName.equals(1)){//无效理由类型为1，为说明书公开不充分
+        } else if (invalidName.equals(1)) {//无效理由类型为1，为说明书公开不充分
             //无效理由
             exportInvalidReasonVO.setInvalidName(invalidName);
             //涉及内容(说明书为-1)
@@ -632,7 +688,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
             //相关证据
             exportInvalidReasonVO.setProofStr(invalidReason.getProofStr());
             return exportInvalidReasonVO;
-        } else if(invalidName.equals(2) || invalidName.equals(3)){//无效理由类型为2，为不具备创造性；无效理由类型为3，为不具备新颖性
+        } else if (invalidName.equals(2) || invalidName.equals(3)) {//无效理由类型为2，为不具备创造性；无效理由类型为3，为不具备新颖性
             //无效理由
             exportInvalidReasonVO.setInvalidName(invalidName);
             //涉及内容(权要排序)
@@ -649,10 +705,11 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
 
     /**
      * 根据无效理由id，返回相关证据的字符串
+     *
      * @param invalidReasonId
      * @return
      */
-    public String proofGroupToString(Integer invalidReasonId){
+    public String proofGroupToString(Integer invalidReasonId) {
         //1.根据无效理由id查询出多个证据组合id
         LambdaQueryWrapper<ProofGroup> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(ProofGroup::getInvalidReasonId, invalidReasonId);
@@ -664,17 +721,17 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
         List<AssoProofGroup> assoProofGroups = assoProofGroupService.list(queryWrapper1);
         List<String> results = new ArrayList<>();
         StringBuilder SB = new StringBuilder();
-        for(Integer proofGroupId : proofGroupIds){
-            List<Integer> proofIds = assoProofGroups.stream().filter(item->item.getGroupId().equals(proofGroupId)).map(AssoProofGroup::getProofId).collect(Collectors.toList());
+        for (Integer proofGroupId : proofGroupIds) {
+            List<Integer> proofIds = assoProofGroups.stream().filter(item -> item.getGroupId().equals(proofGroupId)).map(AssoProofGroup::getProofId).collect(Collectors.toList());
             //3.根据证据ids，到证据表中查询出所有证据，并拼接成字符串
-            if(proofIds.size() > 0){
+            if (proofIds.size() > 0) {
                 //根据证据ids查询证据排序字段
                 LambdaQueryWrapper<CompareFiles> queryWrapper2 = new LambdaQueryWrapper<CompareFiles>();
                 queryWrapper2.in(CompareFiles::getId, proofIds);
                 List<CompareFiles> proofs = compareFilesService.list(queryWrapper2);
                 List<Integer> sysorders = proofs.stream().map(CompareFiles::getSysOrder).collect(Collectors.toList());
                 StringBuilder sb = new StringBuilder();
-                for(Integer sysorder : sysorders){
+                for (Integer sysorder : sysorders) {
                     sb.append("证据").append(sysorder).append("+");
                 }
                 sb.deleteCharAt(sb.length() - 1);
@@ -683,7 +740,7 @@ public class InvalidReasonService extends ServiceImpl<InvalidReasonMapper, Inval
                 results.add(result);
             }
         }
-        for(String resultStr : results){
+        for (String resultStr : results) {
             SB.append(resultStr);
         }
         String STR = SB.toString();

RMS/src/main/java/cn/cslg/report/service/business/InvalidReReport/ProofGroupService.java

@@ -1,22 +1,21 @@
 package cn.cslg.report.service.business.InvalidReReport;
 
-import cn.cslg.report.common.model.dto.invalidReReport.ProofDetailDTO;
 import cn.cslg.report.common.model.dto.invalidReReport.ProofGroupDTO;
+import cn.cslg.report.common.model.dto.invalidReReport.ProofGroupUpdateDTO;
 import cn.cslg.report.common.model.vo.PersonnelVO;
+import cn.cslg.report.common.model.vo.invalidReReport.ProofGroupDetailVO;
 import cn.cslg.report.common.model.vo.invalidReReport.ProofGroupVO;
 import cn.cslg.report.common.utils.CacheUtils;
-import cn.cslg.report.common.utils.Response;
 import cn.cslg.report.common.utils.SecurityUtils.LoginUtils;
-import cn.cslg.report.entity.Personnel;
-import cn.cslg.report.entity.invalidReReport.AssoProofGroup;
-import cn.cslg.report.entity.invalidReReport.ProofDetail;
-import cn.cslg.report.entity.invalidReReport.ProofGroup;
+import cn.cslg.report.entity.CompareFiles;
+import cn.cslg.report.entity.Features;
+import cn.cslg.report.entity.invalidReReport.*;
 import cn.cslg.report.exception.XiaoShiException;
-import cn.cslg.report.mapper.InvalidReReport.ProofDetailMapper;
 import cn.cslg.report.mapper.InvalidReReport.ProofGroupMapper;
+import cn.cslg.report.service.business.CompareFilesService;
+import cn.cslg.report.service.business.FeatureService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
@@ -24,6 +23,7 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -31,39 +31,57 @@ import java.util.stream.Collectors;
 @Service
 @Slf4j
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
-public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup> {
+public class ProofGroupService extends ServiceImpl<ProofGroupMapper, ProofGroup> {
     private final CacheUtils cacheUtils;
     private final LoginUtils loginUtils;
     private final AssoProofGroupService assoProofGroupService;
+    private final ProofGroupService proofGroupService;
+    private final CompareFilesService compareFilesService;
+    private final ArgumentsService argumentsService;
+    private final FeatureService featureService;
+    private final ProofStrService assoFeatureProofService;
+    private final AssoProofGroupStrService assoProofGroupStrService;
 
     /**
      * 批量添加证据组合
+     *
      * @param proofGroupDTOS
      */
     public void addProofGroup(List<ProofGroupDTO> proofGroupDTOS) {
-        for(ProofGroupDTO proofGroupDTO:proofGroupDTOS){
+        for (ProofGroupDTO proofGroupDTO : proofGroupDTOS) {
             //判断proofIds是否为空，若为空则返回
-            if (proofGroupDTO.getProofIds() != null && proofGroupDTO.getProofIds().size() != 0) {
+            if (proofGroupDTO.getGroupDetails() != null && proofGroupDTO.getGroupDetails().size() != 0) {
                 //添加证据组合
                 ProofGroup proofGroup = new ProofGroup();
                 BeanUtils.copyProperties(proofGroupDTO, proofGroup);
                 //获取当前登录人信息
                 PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
                 proofGroup.setCreateId(personnelVO.getId());
-    //            proofGroup.setCreateId(1);
+                //            proofGroup.setCreateId(1);
                 proofGroup.insert();
                 //添加证据组合和证据关联
-                //批量插入
+                //批量插入组合和专利关联表
                 List<AssoProofGroup> assoProofGroups = new ArrayList<>();
-                for (int i = 0; i < proofGroupDTO.getProofIds().size(); i++) {
+                //批量查出组合和无效证据关联表
+                List<AssoProofGroupStr> assoProofGroupStrs = new ArrayList<>();
+                for (int i = 0; i < proofGroupDTO.getGroupDetails().size(); i++) {
+                    Integer compareFileId = proofGroupDTO.getGroupDetails().get(i).getCompareFileId();
                     AssoProofGroup assoProofGroup = new AssoProofGroup();
                     assoProofGroup.setGroupId(proofGroup.getId());
-                    assoProofGroup.setProofId(proofGroupDTO.getProofIds().get(i));
+                    assoProofGroup.setProofId(compareFileId);
                     assoProofGroup.setCreateId(personnelVO.getId());
-    //
                     assoProofGroups.add(assoProofGroup);
+                    List<Integer> proofStrIds = proofGroupDTO.getGroupDetails().get(i).getProofStrIds();
+                    proofStrIds.forEach(item -> {
+                        AssoProofGroupStr assoProofGroupStr = new AssoProofGroupStr();
+                        assoProofGroupStr.setProofGroupId(proofGroup.getId());
+                        assoProofGroupStr.setProofStrId(item);
+                        assoProofGroupStr.setCompareFileId(compareFileId);
+                        assoProofGroupStrs.add(assoProofGroupStr);
+                    });
                 }
                 assoProofGroupService.saveBatch(assoProofGroups);
+                assoProofGroupStrService.saveBatch(assoProofGroupStrs);
             } else {
                 throw new XiaoShiException("传入数据不能为空");
             }
@@ -72,12 +90,13 @@ public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup>
 
 
     /**
-     *批量删除证据组合
+     * 批量删除证据组合
+     *
      * @param ids 证据组合ids
      * @return
      */
     public void deleteProofGroup(List<Integer> ids) {
-        if(ids != null && ids.size() != 0) {
+        if (ids != null && ids.size() != 0) {
             //根据证据组合id批量删除证据组合-证据关联
             LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
             queryWrapper.in(AssoProofGroup::getGroupId, ids);
@@ -90,79 +109,79 @@ public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup>
     }
 
     /**
-     *批量删除证据组合
+     * 批量删除证据组合
+     *
      * @param
      * @return
      */
     public void deleteProofGroupByInvalid(Integer invalidId) {
         //根据无效理由id获得证据组合
-        LambdaQueryWrapper<ProofGroup> wrapper =new LambdaQueryWrapper<>();
-        wrapper.eq(ProofGroup::getInvalidReasonId,invalidId);
-        List<ProofGroup> proofGroups =this.list(wrapper);
-        List<Integer> ids =proofGroups.stream().map(ProofGroup::getId).collect(Collectors.toList());;
-        if(ids != null && ids.size() != 0) {
+        LambdaQueryWrapper<ProofGroup> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(ProofGroup::getInvalidReasonId, invalidId);
+        List<ProofGroup> proofGroups = this.list(wrapper);
+        List<Integer> ids = proofGroups.stream().map(ProofGroup::getId).collect(Collectors.toList());
+        ;
+        if (ids != null && ids.size() != 0) {
             //根据证据组合id批量删除证据组合-证据关联
             LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
             queryWrapper.in(AssoProofGroup::getGroupId, ids);
             assoProofGroupService.remove(queryWrapper);
             //根据ids批量删除证据组合
             this.removeByIds(ids);
+            //根据证据组合id批量删除证据组合-无效证据关联
+            LambdaQueryWrapper<AssoProofGroupStr> strWrapper = new LambdaQueryWrapper<>();
+            strWrapper.in(AssoProofGroupStr::getProofGroupId, ids);
+            assoProofGroupStrService.remove(strWrapper);
+            //根据ids批量删除证据组合
+            this.removeByIds(ids);
         }
+
     }
+
     /**
      * 更新证据组合
-     * @param proofGroupDTO
+     *
+     * @param proofGroupUpdateDTO
      * @return
      */
-    public void updateProofGroup(ProofGroupDTO proofGroupDTO) {
-        //判断proofIds是否为空，若为空则返回
-        if (proofGroupDTO.getProofIds() != null && proofGroupDTO.getProofIds().size() != 0){
+    public void updateProofGroup(ProofGroupUpdateDTO proofGroupUpdateDTO) {
+             List<Integer> newProofIds = proofGroupUpdateDTO.getProofStrIds();
             //查出证据组合数据
-            ProofGroup proofGroup = this.getById(proofGroupDTO.getId());
-            BeanUtils.copyProperties(proofGroupDTO, proofGroup);
-            //获取当前登录人信息
-            PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
-            proofGroup.setCreateId(personnelVO.getId());
-//            proofGroup.setCreateId(1);
-            //更新证据组合信息
+            ProofGroup proofGroup = this.getById(proofGroupUpdateDTO.getId());
+            proofGroup.setArgumentStr(proofGroupUpdateDTO.getArgumentStr());
+            proofGroup.setDescription(proofGroupUpdateDTO.getDescription());
             proofGroup.updateById();
             //证据组合id
             Integer groupId = proofGroup.getId();
+            Integer compareFileId =proofGroupUpdateDTO.getCompareFileId();
             //根据证据组合id查找 证据组合和证据关联ids
-            LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
-            queryWrapper.select(AssoProofGroup::getProofId);
-            queryWrapper.eq(AssoProofGroup::getGroupId, groupId);
-            List<AssoProofGroup> assoProofGroups = assoProofGroupService.list(queryWrapper);
-            List<Integer> oldProofIds = assoProofGroups.stream().map(AssoProofGroup::getProofId).collect(Collectors.toList());
-            List<Integer> newProofIds = proofGroupDTO.getProofIds();
-            //寻找proofIds比关联ids少的id并从证据组合和证据关联表中删除
-            List<Integer> needDelIds = new ArrayList<>(oldProofIds);
-            needDelIds.removeAll(newProofIds);
-            LambdaQueryWrapper<AssoProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
-            queryWrapper1.in(AssoProofGroup::getProofId, needDelIds);
-            List<AssoProofGroup> needDelete = assoProofGroupService.list(queryWrapper1);
-            List<Integer> ids = needDelete.stream().map(AssoProofGroup::getId).collect(Collectors.toList());
-            assoProofGroupService.removeByIds(ids);
-            //寻找proofIds比关联ids多的id并插入到证据组合和证据关联表中
-            newProofIds.removeAll(oldProofIds);
-            //批量插入
-            List<AssoProofGroup> needInsert = new ArrayList<>();
-            for(int i = 0; i < newProofIds.size(); i++) {
-                AssoProofGroup assoProofGroup = new AssoProofGroup();
-                assoProofGroup.setGroupId(groupId);
-                assoProofGroup.setProofId(newProofIds.get(i));
-                assoProofGroup.setCreateId(personnelVO.getId());
-//                assoProofGroup.setCreateId(1);
-                needInsert.add(assoProofGroup);
+            if(compareFileId!=null) {
+                LambdaQueryWrapper<AssoProofGroupStr> queryWrapper = new LambdaQueryWrapper<>();
+                queryWrapper.eq(AssoProofGroupStr::getProofGroupId, groupId)
+                        .eq(AssoProofGroupStr::getCompareFileId, compareFileId);
+                List<AssoProofGroupStr> assoProofGroupStrs = assoProofGroupStrService.list(queryWrapper);
+                List<Integer> oldProofStrIds = assoProofGroupStrs.stream().map(AssoProofGroupStr::getId).collect(Collectors.toList());
+                if (oldProofStrIds.size() > 0) {
+                    assoProofGroupStrService.removeByIds(oldProofStrIds);
+                }
+                //寻找proofIds比关联ids多的id并插入到证据组合和证据关联表中
+                //批量插入
+                List<AssoProofGroupStr> needInsert = new ArrayList<>();
+                for (int i = 0; i < newProofIds.size(); i++) {
+                    AssoProofGroupStr assoProofGroupStr = new AssoProofGroupStr();
+                    assoProofGroupStr.setProofGroupId(groupId);
+                    assoProofGroupStr.setProofStrId(newProofIds.get(i));
+                    assoProofGroupStr.setCompareFileId(proofGroupUpdateDTO.getCompareFileId());
+                    needInsert.add(assoProofGroupStr);
+                }
+                assoProofGroupStrService.saveBatch(needInsert);
             }
-            assoProofGroupService.saveBatch(needInsert);
-        } else {
-            throw new XiaoShiException("传入证据id不能为空");
-        }
+
     }
 
     /**
      * 查询证据组合详情
+     *
      * @param id 证据组合id
      * @return
      */
@@ -170,11 +189,11 @@ public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup>
         //根据证据组合id查询证据组合并装载到ProofGroupVO类里
         ProofGroupVO proofGroupVO = new ProofGroupVO();
         ProofGroup proofGroup = this.getById(id);
-        if(proofGroup == null){
+        if (proofGroup == null) {
             throw new XiaoShiException("没有这一条数据");
         }
         proofGroupVO.setInvalidReasonId(proofGroup.getInvalidReasonId());
-        proofGroupVO.setArgument_str(proofGroup.getArgument_str());
+        proofGroupVO.setArgument_str(proofGroup.getArgumentStr());
         proofGroupVO.setDescription(proofGroup.getDescription());
         LambdaQueryWrapper<AssoProofGroup> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.select(AssoProofGroup::getProofId);
@@ -187,6 +206,7 @@ public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup>
 
     /**
      * 查询证据组合
+     *
      * @param invalidId 无效理由Id
      * @return proofGroups
      */
@@ -197,4 +217,116 @@ public class ProofGroupService extends ServiceImpl<ProofGroupMapper,ProofGroup>
         List<ProofGroup> proofGroups = this.list(queryWrapper);
         return proofGroups;
     }
+
+
+    /**
+     * 根据无效理由id查询证据组合及证据详情
+     *
+     * @param invalidReasonId 无效理由id
+     * @return
+     */
+    public List<ProofGroupDetailVO> queryDetailByInvalidId(Integer invalidReasonId) {
+        List<ProofGroupDetailVO> proofDetailVOS = new ArrayList<>();
+        //根据无效理由和证据id查询证据组合
+        LambdaQueryWrapper<ProofGroup> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(ProofGroup::getInvalidReasonId, invalidReasonId);
+        List<ProofGroup> proofGroups = proofGroupService.list(lambdaQueryWrapper);
+        if (proofGroups.size() == 0) {
+            return new ArrayList<>();
+        }
+        //根据证据组合id查询证据id
+        List<Integer> groupIds = proofGroups.stream().map(ProofGroup::getId).collect(Collectors.toList());
+        LambdaQueryWrapper<AssoProofGroup> assoWrapper = new LambdaQueryWrapper<>();
+        assoWrapper.in(AssoProofGroup::getGroupId, groupIds);
+        List<AssoProofGroup> assoProofGroups = assoProofGroupService.list(assoWrapper);
+        List<Integer> proofIds = assoProofGroups.stream().map(AssoProofGroup::getProofId).collect(Collectors.toList());
+        //根据证据id查询证据
+        LambdaQueryWrapper<CompareFiles> comFileWrapper = new LambdaQueryWrapper<>();
+        comFileWrapper.in(CompareFiles::getId, proofIds);
+        List<CompareFiles> compareFiles = compareFilesService.list(comFileWrapper);
+        //根据证据id查询陈述意见
+        List<Arguments> arguments = new ArrayList<>();
+        LambdaQueryWrapper<Arguments> argumentsWrapper = new LambdaQueryWrapper<>();
+        argumentsWrapper.in(Arguments::getProofId, proofIds);
+        arguments = argumentsService.list(argumentsWrapper);
+        //根据特征id获得特征列表
+        List<Features> features = new ArrayList<>();
+        List<Integer> featureIds = arguments.stream().map(Arguments::getFeatureId).collect(Collectors.toList());
+        if (featureIds.size() != 0) {
+            LambdaQueryWrapper<Features> featuresWrapper = new LambdaQueryWrapper<>();
+            featuresWrapper.in(Features::getId, featureIds);
+            features = featureService.list(featuresWrapper);
+        }
+        //根据证据组合id查找组合和无效证据关联
+        LambdaQueryWrapper<AssoProofGroupStr> wrapper = new LambdaQueryWrapper<>();
+        wrapper.in(AssoProofGroupStr::getProofGroupId, groupIds);
+        List<AssoProofGroupStr> assoProofGroupStrs = assoProofGroupStrService.list(wrapper);
+        //根据特征id获得无效证据
+        List<ProofStr> proofStrs = new ArrayList<>();
+        if (featureIds.size() != 0) {
+            LambdaQueryWrapper<ProofStr> assoFPWrapper = new LambdaQueryWrapper<>();
+            assoFPWrapper.in(ProofStr::getFeatureId, featureIds);
+            proofStrs = assoFeatureProofService.list(assoFPWrapper);
+        }
+        //装载列表
+        for (ProofGroup proofGroup : proofGroups) {
+            ProofGroupDetailVO proofGroupDetailVO = new ProofGroupDetailVO();
+            proofGroupDetailVO.setId(proofGroup.getId());
+            proofGroupDetailVO.setInvalidReasonId(proofGroup.getInvalidReasonId());
+            proofGroupDetailVO.setArgumentStr(proofGroup.getArgumentStr());
+            proofGroupDetailVO.setDescription(proofGroup.getDescription());
+            List<ProofGroupDetailVO.ProofIn> proofIns = new ArrayList<>();
+            //根据组合id获得该组合下的证据
+            List<AssoProofGroup> assoProofGroupPart = assoProofGroups.stream().filter(item -> item.getGroupId().equals(proofGroup.getId())).collect(Collectors.toList());
+            List<Integer> proofIdsPart = assoProofGroupPart.stream().map(AssoProofGroup::getProofId).collect(Collectors.toList());
+            List<CompareFiles> compareFilesPart = compareFiles.stream().filter(item -> proofIdsPart.contains(item.getId())).collect(Collectors.toList());
+            //装载证据信息
+            for (CompareFiles compareFile : compareFilesPart) {
+                ProofGroupDetailVO.ProofIn proofIn = new ProofGroupDetailVO.ProofIn();
+                proofIn.setId(compareFile.getId());
+                proofIn.setFileId(compareFile.getFileId());
+                proofIn.setSort(compareFile.getSysOrder());
+                proofIn.setFileType(compareFile.getFileType());
+                proofIn.setPatentNo(compareFile.getPatentNo());
+                proofIns.add(proofIn);
+            }
+           //获得证据组合里的无效证据
+            List<Integer> proofStrIdsPart =assoProofGroupStrs.stream().filter(item->item.getProofGroupId().equals(proofGroup.getId())).map(AssoProofGroupStr::getProofStrId).collect(Collectors.toList());
+            List<ProofStr> proofStrsPart =proofStrs.stream().filter(item->proofStrIdsPart.contains(item.getId())).collect(Collectors.toList());
+           //遍历无效证据
+            List<ProofGroupDetailVO.ProofDetailIn> proofDetailIns = new ArrayList<>();
+            for (ProofStr proofStr : proofStrsPart) {
+                CompareFiles tenCom=   compareFilesPart.stream().filter(item->proofStr.getCompareFileId().equals(item.getId())).findFirst().orElse(new CompareFiles());
+                ProofGroupDetailVO.ProofDetailIn proofDetailIn =new ProofGroupDetailVO.ProofDetailIn();
+                //获得对应特征信息
+                Features features1 =features.stream().filter(item->item.getId().equals(proofStr.getFeatureId())).findFirst().orElse(new Features());
+                //装载无效证据
+                proofDetailIn.setProofStrId(proofStr.getId());
+                proofDetailIn.setProofStr(proofStr.getProofStr());
+                proofDetailIn.setProofId(proofStr.getCompareFileId());
+                proofDetailIn.setSort(tenCom.getSysOrder());
+                proofDetailIn.setFeaturesOrder(features1.getFeaturesOrder());
+                proofDetailIn.setFeatureContent(features1.getContent());
+                proofDetailIn.setFeatureId(features1.getId());
+            List<Arguments> argumentsParts =arguments.stream().filter(item->proofStr.getId().equals(item.getProofStrId())).collect(Collectors.toList());
+            List<ProofGroupDetailVO.ArgumentIn> argumentIns = new ArrayList<>();
+           //遍历陈述意见
+            for(Arguments arguments1: argumentsParts){
+                ProofGroupDetailVO.ArgumentIn argumentIn =new ProofGroupDetailVO.ArgumentIn();
+                argumentIn.setId(arguments1.getId());
+                argumentIn.setArgumentStr(arguments1.getArgumentStr());
+                argumentIns.add(argumentIn);
+            }
+                proofDetailIn.setArguments(argumentIns);
+                proofDetailIns.add(proofDetailIn);
+            }
+            proofIns.sort(Comparator.comparing(ProofGroupDetailVO.ProofIn::getSort));
+            proofGroupDetailVO.setProofs(proofIns);
+            proofDetailIns.sort(Comparator.comparing(ProofGroupDetailVO.ProofDetailIn::getFeaturesOrder));
+            proofGroupDetailVO.setProofDetails(proofDetailIns);
+            proofDetailVOS.add(proofGroupDetailVO);
+        }
+        return proofDetailVOS;
+    }
+
 }

RMS/src/main/resources/mapper/InvalidReasonFieldValueMapper.xml

@@ -1,15 +1,27 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="cn.cslg.report.mapper.InvalidReReport.InvalidReasonFiledValueMapper">
-<select id="getValues" resultType="cn.cslg.report.entity.invalidReReport.InvalidReasonFieldValue">
-    select * from INVALID_REASON_FIELD_VALUE
- <where>
-     <foreach collection="values" index="item" separator=" or ">
-         (INVALID_REASON_FIELD_ID=#{item.} and INVALID_REASON_ID=#{item})
-     </foreach>
- </where>
-
-
-</select>
+    <select id="getValues" resultType="cn.cslg.report.entity.invalidReReport.InvalidReasonFieldValue"
+            parameterType="cn.cslg.report.common.model.dto.invalidReReport.InvalidReasonFieldValueDTO">
+        select * from INVALID_REASON_FIELD_VALUE
+        <where>
+            <foreach collection="values" index="index" separator=" or " item="item">
+                (INVALID_REASON_FIELD_ID=#{item.fieldId} and INVALID_REASON_ID=#{item.invalidReasonId})
+            </foreach>
+        </where>
+    </select>
 
+    <select id="getListByReasonIds"
+            resultType="cn.cslg.report.common.model.dto.invalidReReport.InvalidReasonFieldValueDTO"
+            parameterType="java.lang.Integer">
+        select a.INVALID_REASON_ID as invalidReasonId ,a.INVALID_REASON_FIELD_ID as fieldId ,a.FIELD_VALUE as
+        fieldValue,b.FIELD_KEY as fieldKey  from RMS_TEST.INVALID_REASON_FIELD_VALUE a left join RMS_TEST.INVALID_REASON_FIELD b on
+        a.INVALID_REASON_FIELD_ID=b.ID
+        <where>
+            a.INVALID_REASON_ID in
+            <foreach collection="invalidReasonsIds" index="index" separator="," item="item" open="(" close=")">
+                #{item}
+            </foreach>
+        </where>
+    </select>
 </mapper>