特征历史模块/根据栏位名称添加栏位值方法

pom.xml

@@ -246,7 +246,11 @@
             <artifactId>poi-tl-ext</artifactId>
             <version>0.4.2</version>
         </dependency>
-
+        <dependency>
+            <groupId>commons-beanutils</groupId>
+            <artifactId>commons-beanutils</artifactId>
+            <version>1.9.3</version>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -0,0 +1,24 @@
+package cn.cslg.pas.common.dto;
+
+
+
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+
+/**
+ * <p>
+ * 委托方表
+ * </p>
+ *
+ * @author 王岩
+ * @since 2022-02-17
+ */
+@Data
+
+public class DomainFieldDTO {
+
+    private String field;
+
+    private String value;
+}

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

@@ -16,4 +16,5 @@ public class UpdateGroupFeatureDTO {
     private String common;
     //是否第一次修改
     private Boolean ifFirstEdit;
+
 }

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

@@ -0,0 +1,12 @@
+package cn.cslg.pas.common.dto.invalidDTO;
+
+import cn.cslg.pas.common.dto.DomainFieldDTO;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class UpdateMessageDTO {
+    private Integer id;
+    private List<DomainFieldDTO> fieldList;
+}

src/main/java/cn/cslg/pas/common/utils/GenerateObjectUtil.java

@@ -0,0 +1,41 @@
+package cn.cslg.pas.common.utils;
+
+import cn.cslg.pas.common.dto.DomainFieldDTO;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.beanutils.BeanUtils;
+import org.springframework.cglib.beans.BeanGenerator;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class GenerateObjectUtil {
+
+    public static Object generateObjectByField(List<DomainFieldDTO> domainFieldDTOS) throws Exception {
+        BeanGenerator generator = new BeanGenerator();
+        for (DomainFieldDTO domainFieldDTO : domainFieldDTOS) {
+            generator.addProperty(domainFieldDTO.getField(), java.lang.String.class);
+        }
+        // 构建对象
+        Object obj = generator.create();
+        // 赋值
+        for (DomainFieldDTO domainFieldDTO : domainFieldDTOS) {
+            BeanUtils.setProperty(obj, domainFieldDTO.getField(), domainFieldDTO.getValue());
+        }
+
+        // json转换去掉前缀
+        String gsonString = JSONObject.toJSONString(obj).replace("$cglib_prop_", "");
+        return JSON.parseObject(gsonString, Object.class);
+
+    }
+
+    public static void setObjectProperty(Object obj, String propertyName, Object value) throws Exception {
+        String setMethodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
+        Method method = obj.getClass().getMethod(setMethodName, value.getClass());
+        method.invoke(obj, value);
+    }
+
+}

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

@@ -0,0 +1,14 @@
+package cn.cslg.pas.common.vo.invalidVO;
+
+import lombok.Data;
+
+@Data
+public class GroupFeatureHistoryVO {
+    private Integer featureId;
+    private String featureContent;
+    private Integer featureGen;
+    private String common;
+    private Integer featureOrder;
+    private Integer featureGroupId;
+    private Integer operateMode;
+}

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

@@ -14,4 +14,6 @@ public class QueryEvidenceReasonVO {
     private String evidenceText;
     private String evidenceDescription;
     private List<CompareLiterature> literatures;
+   private  Integer   featureGroupId;
+   private   List<GroupFeatureHistoryVO> featureHistories;
 }

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

@@ -3,6 +3,7 @@ package cn.cslg.pas.controller;
 import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.dto.QueryFeatureHistoryDTO;
 import cn.cslg.pas.common.dto.invalidDTO.RemoveGroupFeatureDTO;
+import cn.cslg.pas.common.dto.invalidDTO.UpdateMessageDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.dto.invalidDTO.UpdateGroupFeatureDTO;
@@ -70,13 +71,18 @@ public class AssoGroupFeatureController {
     @PostMapping("/updateFeature")
     public Response updateFeature(@RequestBody UpdateGroupFeatureDTO updateGroupFeatureDTO) throws Exception {
         try {
-            Records records = new Records();
-            records.setData(assoGroupFeatureService.updateFeature(updateGroupFeatureDTO));
-            return Response.success(records);
+           assoGroupFeatureService.updateFeature(updateGroupFeatureDTO);
+            return Response.success("更新成功");
 
         } catch (Exception e) {
             return Response.error(e.getMessage());
         }
     }
 
+    @Operation(summary = "更新信息")
+    @PostMapping("/updateMessage")
+    public Response updateMessage(@RequestBody UpdateMessageDTO updateMessageDTO) {
+        Records records =  new Records();
+        return Response.success(records);
+    }
 }

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

@@ -5,6 +5,7 @@ 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.dto.invalidDTO.UpdateMessageDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.vo.invalidVO.QueryEvidenceReasonVO;
@@ -53,4 +54,12 @@ public class EvidenceReasonController {
       Records records =  evidenceReasonService.queryInvalidHistory(queryInvalidHistoryDTO);
         return Response.success(records);
     }
+
+    @Operation(summary = "更新信息")
+    @PostMapping("/updateMessage")
+    public Response updateMessage(@RequestBody UpdateMessageDTO updateMessageDTO) {
+        Records records =  new Records();
+        return Response.success(records);
+    }
+
 }

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

@@ -4,6 +4,7 @@ import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.dto.business.InvalidStatutesDTO;
 import cn.cslg.pas.common.dto.invalidDTO.AddProofGroupDTO;
 import cn.cslg.pas.common.dto.invalidDTO.GetProofGroupDTO;
+import cn.cslg.pas.common.dto.invalidDTO.UpdateMessageDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.vo.invalidVO.InvalidStatutesVO;
@@ -51,4 +52,11 @@ public class ProofGroupController {
         return Response.success(records);
     }
 
+
+    @Operation(summary = "更新信息")
+    @PostMapping("/updateMessage")
+    public Response updateMessage(@RequestBody UpdateMessageDTO updateMessageDTO) {
+        Records records =  new Records();
+        return Response.success(records);
+    }
 }

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

@@ -27,10 +27,14 @@ public class AssoGroupFeature  extends BaseEntity<AssoGroupFeature> {
 
     //特征修改说明
     @TableField(value = "common")
-    private Integer common;
+    private String common;
 
     @TableField(value = "rb_decision")
     private String rbDecision;
     @TableField(value = "rb_decision_key")
     private String rbDecisionKey;
+
+    @TableField(value = "operate_mode")
+    private Integer operateMode;
+
 }

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

@@ -1,6 +1,7 @@
 package cn.cslg.pas.mapper.InvalidReport;
 
 import cn.cslg.pas.domain.business.AssoFeatureReason;
+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;
@@ -12,4 +13,5 @@ import org.springframework.stereotype.Repository;
  */
 @Repository
 public interface AssoFeatureReasonMapper extends BaseMapper<AssoFeatureReason> {
+
 }

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

@@ -5,6 +5,8 @@ import cn.cslg.pas.domain.business.PatentClaim;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 /**
  * 权利要求
  *
@@ -13,4 +15,5 @@ import org.springframework.stereotype.Repository;
  */
 @Repository
 public interface AssoGroupFeatureMapper extends BaseMapper<AssoGroupFeature> {
+    public List<AssoGroupFeature> selectLastGroupFeature(Integer groupId,Integer order,Integer gen);
 }

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

@@ -4,16 +4,22 @@ import cn.cslg.pas.common.dto.QueryFeatureHistoryDTO;
 import cn.cslg.pas.common.dto.invalidDTO.QueryClaimSplitHistoryDTO;
 import cn.cslg.pas.common.dto.invalidDTO.RemoveGroupFeatureDTO;
 import cn.cslg.pas.common.dto.invalidDTO.UpdateGroupFeatureDTO;
+import cn.cslg.pas.common.vo.invalidVO.GroupFeatureHistoryVO;
 import cn.cslg.pas.domain.business.AssoGroupFeature;
 import cn.cslg.pas.domain.business.Feature;
+import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.InvalidReport.AssoGroupFeatureMapper;
+import cn.cslg.pas.service.business.FeatureService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * 权利要求
@@ -24,6 +30,8 @@ import java.util.function.Function;
 @Service
 public class AssoGroupFeatureService extends ServiceImpl<AssoGroupFeatureMapper, AssoGroupFeature> {
 
+    @Autowired
+    private FeatureService featureService;
 
     //根据证据组合id查询特征id
     public List<Integer> getFeatureIdsByGroupId(Integer groupId) {
@@ -41,7 +49,12 @@ public class AssoGroupFeatureService extends ServiceImpl<AssoGroupFeatureMapper,
     }
 
 
-    //
+    /**
+     * 修改证据组合特征
+     *
+     * @param updateGroupFeatureVO
+     * @return
+     */
     public Boolean updateGroupFeature(UpdateGroupFeatureDTO updateGroupFeatureVO) {
         Integer featureId = updateGroupFeatureVO.getFeatureId();
         Boolean ifFirstEdit = updateGroupFeatureVO.getIfFirstEdit();
@@ -50,14 +63,56 @@ public class AssoGroupFeatureService extends ServiceImpl<AssoGroupFeatureMapper,
         if (ifFirstEdit != null && ifFirstEdit.equals(false)) {
             featureGen = 2;
         }
+        //获得上一个世代值
+        Integer lastGen = featureGen - 1;
         //根据特征id查询证据组合和特征关联
         LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(AssoGroupFeature::getFeatureId, featureId);
+        queryWrapper.eq(AssoGroupFeature::getFeatureId, featureId).eq(AssoGroupFeature::getFeatureGen, lastGen);
         List<AssoGroupFeature> assoGroupFeatures = this.list(queryWrapper);
         Integer newFeatureId = this.addFeature(featureContent);
         //更新特征内容
-        if(assoGroupFeatures.size()!=0){
-            //查询是否有第一世代
+        if (assoGroupFeatures.size() != 0) {
+            for (AssoGroupFeature assoGroupFeature : assoGroupFeatures) {
+                //查询是否存在世代
+                Integer genFeatureId = assoGroupFeature.getFeatureId();
+                Integer genGroupId = assoGroupFeature.getGroupId();
+                Integer featureOrder = assoGroupFeature.getFeatureOrder();
+
+                AssoGroupFeature assoGroupFeature1 = this.getGenGroupFeature(genGroupId, genFeatureId, featureGen);
+                //当世代不存在时新建并插入
+                if (assoGroupFeature1 == null) {
+                    assoGroupFeature1 = new AssoGroupFeature();
+                    //设置组合id
+                    assoGroupFeature1.setGroupId(genGroupId);
+                    //设置特征id
+                    assoGroupFeature1.setFeatureId(newFeatureId);
+                    //设置排序
+                    assoGroupFeature1.setFeatureOrder(featureOrder);
+                    //设置上一个特征id
+                    if (genFeatureId != null) {
+                        assoGroupFeature1.setFeaturePreId(genFeatureId);
+                    } else {
+                        assoGroupFeature1.setFeaturePreId(assoGroupFeature.getFeaturePreId());
+                    }
+                    //设置世代
+                    assoGroupFeature1.setFeatureGen(featureGen);
+                    assoGroupFeature1.setOperateMode(0);
+                    assoGroupFeature1.insert();
+                }
+                //否则更新
+                else {
+                    //设置组合id
+                    assoGroupFeature1.setGroupId(genGroupId);
+                    //设置特征id
+                    assoGroupFeature1.setFeatureId(newFeatureId);
+                    //设置排序
+                    assoGroupFeature1.setFeatureOrder(featureOrder);
+                    //设置世代
+                    assoGroupFeature1.setFeatureGen(featureGen);
+                    assoGroupFeature1.setOperateMode(0);
+                    assoGroupFeature1.updateById();
+                }
+            }
 
 
         }
@@ -65,32 +120,208 @@ public class AssoGroupFeatureService extends ServiceImpl<AssoGroupFeatureMapper,
         return true;
     }
 
-
+    /**
+     * 删除证据组合历史
+     *
+     * @param removeGroupFeatureDTO
+     * @return
+     */
     public Boolean removeGroupFeature(RemoveGroupFeatureDTO removeGroupFeatureDTO) {
         Integer featureId = removeGroupFeatureDTO.getFeatureId();
+        Boolean ifFirstEdit = removeGroupFeatureDTO.getIfFirstEdit();
+        Integer featureGen = 1;
+        if (ifFirstEdit != null && ifFirstEdit.equals(false)) {
+            featureGen = 2;
+        }
+        //获得上一个世代值
+        Integer lastGen = featureGen - 1;
+
         //根据特征id查询证据组合和特征关联
         LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoGroupFeature::getFeatureId, featureId).eq(AssoGroupFeature::getFeatureGen, lastGen);
+        List<AssoGroupFeature> assoGroupFeatures = this.list(queryWrapper);
+        if (assoGroupFeatures.size() != 0) {
+            for (AssoGroupFeature assoGroupFeature : assoGroupFeatures) {
+                //查询是否存在世代
+                Integer genFeatureId = assoGroupFeature.getFeatureId();
+                Integer genGroupId = assoGroupFeature.getGroupId();
+                Integer featureOrder = assoGroupFeature.getFeatureOrder();
+                AssoGroupFeature assoGroupFeature1 = this.getGenGroupFeature(genGroupId, genFeatureId, featureGen);
+                if (assoGroupFeature1 == null) {
+                    assoGroupFeature1 = new AssoGroupFeature();
+                    assoGroupFeature1.setGroupId(genGroupId);
+                    assoGroupFeature1.setFeatureGen(featureGen);
+                    assoGroupFeature1.setOperateMode(1);
+                    assoGroupFeature1.setFeaturePreId(genFeatureId);
+                    assoGroupFeature1.insert();
+                } else {
+                    assoGroupFeature1.setGroupId(genGroupId);
+                    assoGroupFeature1.setFeatureGen(featureGen);
+                    assoGroupFeature1.setOperateMode(1);
+                    assoGroupFeature1.setFeaturePreId(genFeatureId);
+                    assoGroupFeature1.updateById();
+                }
+                this.updateGroupFeatureOrder(genGroupId, featureOrder, featureGen);
+            }
+        }
         return true;
     }
 
-    public Boolean queryFeatureHistory(QueryFeatureHistoryDTO queryFeatureHistoryDTO) {
+    public List<GroupFeatureHistoryVO> queryFeatureHistory(QueryFeatureHistoryDTO queryFeatureHistoryDTO) {
+        List<AssoGroupFeature> assoGroupFeatures = new ArrayList<>();
         Integer featureGroupId = queryFeatureHistoryDTO.getFeatureGroupId();
         //根据特征id查询证据组合和特征关联
-        LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
-        return true;
+        AssoGroupFeature assoGroupFeature = this.getById(featureGroupId);
+        assoGroupFeatures.add(assoGroupFeature);
+        Integer groupId = assoGroupFeature.getGroupId();
+        Integer featureId = assoGroupFeature.getFeatureId();
+        //查询第一次历史
+        LambdaQueryWrapper<AssoGroupFeature> query1 = new LambdaQueryWrapper<>();
+        query1.eq(AssoGroupFeature::getFeatureGen, 1)
+                .eq(AssoGroupFeature::getFeaturePreId, featureId)
+                .eq(AssoGroupFeature::getGroupId, groupId);
+        AssoGroupFeature assoGroupFeature1 = this.getOne(query1, false);
+        if (assoGroupFeature1 != null) {
+            assoGroupFeatures.add(assoGroupFeature1);
+        }
+
+        //查询第二次历史
+        LambdaQueryWrapper<AssoGroupFeature> query2 = new LambdaQueryWrapper<>();
+        query2.eq(AssoGroupFeature::getFeatureGen, 2)
+                .eq(AssoGroupFeature::getGroupId, groupId);
+        if (assoGroupFeature1 != null) {
+            query2.and(i -> i.eq(AssoGroupFeature::getFeaturePreId, assoGroupFeature1.getFeatureId())
+                    .or().eq(AssoGroupFeature::getFeaturePreId, featureId));
+        } else {
+            query2.eq(AssoGroupFeature::getFeaturePreId, featureId);
+        }
+        AssoGroupFeature assoGroupFeature2 = this.getOne(query2, false);
+        if (assoGroupFeature2 != null) {
+            assoGroupFeatures.add(assoGroupFeature2);
+        }
+        //装载历史
+        List<GroupFeatureHistoryVO> groupFeatureHistoryVOS = this.loadFeatureHistory(assoGroupFeatures);
+        return groupFeatureHistoryVOS;
     }
 
     public Boolean updateFeature(UpdateGroupFeatureDTO updateGroupFeatureDTO) {
         Integer featureId = updateGroupFeatureDTO.getFeatureId();
+        Boolean ifFirstEdit = updateGroupFeatureDTO.getIfFirstEdit();
+        String featureContent = updateGroupFeatureDTO.getFeatureContent();
+        String common = updateGroupFeatureDTO.getCommon();
+        Integer featureGen = 1;
+        if (ifFirstEdit != null && ifFirstEdit.equals(false)) {
+            featureGen = 2;
+        }
+
+        //更新特征
+        Boolean flag = this.updateFeatureContent(featureId, featureContent);
+        if (flag.equals(false)) {
+            throw new XiaoShiException("特征不存在");
+        }
         //根据特征id查询证据组合和特征关联
         LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoGroupFeature::getFeatureId, featureId)
+                .eq(AssoGroupFeature::getFeatureGen, featureGen);
+        List<AssoGroupFeature> assoGroupFeatures = this.list(queryWrapper);
+        if (assoGroupFeatures.size() > 0) {
+            assoGroupFeatures.forEach(item -> {
+                item.setCommon(common);
+                item.updateById();
+            });
+        }
         return true;
     }
 
+    //根据内容添加特征
     public Integer addFeature(String featureContent) {
         Feature feature = new Feature();
         feature.setContent(featureContent);
         feature.insert();
         return feature.getId();
     }
+
+    //根据分组id和特征id以及世代查询是否存在
+    public AssoGroupFeature getGenGroupFeature(Integer groupId, Integer featureId, Integer gen) {
+        LambdaQueryWrapper<AssoGroupFeature> queryWrapper1 = new LambdaQueryWrapper<>();
+        queryWrapper1.eq(AssoGroupFeature::getFeatureGen, gen)
+                .eq(AssoGroupFeature::getGroupId, groupId)
+                .eq(AssoGroupFeature::getFeaturePreId, featureId);
+
+        AssoGroupFeature assoGroupFeature1 = this.getOne(queryWrapper1, false);
+        return assoGroupFeature1;
+    }
+
+
+    //更新顺序
+    public void updateGroupFeatureOrder(Integer groupId, Integer fromOrder, Integer gen) {
+        Integer lastGen = gen - 1;
+        //根据groupId查询所有删除特征之后的特征组合关联
+        List<AssoGroupFeature> assoGroupFeatures = this.baseMapper.selectLastGroupFeature(groupId, fromOrder, lastGen);
+
+        if (assoGroupFeatures.size() > 0) {
+            //遍历添加世代
+            for (AssoGroupFeature assoGroupFeature : assoGroupFeatures) {
+                Integer featureId = assoGroupFeature.getFeatureId();
+                //查询是否世代已存在
+                AssoGroupFeature tem = this.getGenGroupFeature(groupId, featureId, gen);
+                if (tem == null) {
+                    tem = new AssoGroupFeature();
+                    BeanUtils.copyProperties(assoGroupFeature, tem);
+                    tem.setFeatureOrder(tem.getFeatureOrder() - 1);
+                    tem.setFeatureGen(gen);
+                    tem.setId(null);
+                    tem.setOperateMode(0);
+                    tem.insert();
+                } else {
+                    tem.setFeatureOrder(tem.getFeatureOrder() - 1);
+                    tem.updateById();
+                }
+
+            }
+
+        }
+
+    }
+
+    //更新特征内容
+    public Boolean updateFeatureContent(Integer featureId, String featureContent) {
+        Feature feature = featureService.getById(featureId);
+        if (feature == null) {
+            return false;
+        }
+        feature.setContent(featureContent);
+        feature.updateById();
+        return true;
+    }
+
+
+    public List<GroupFeatureHistoryVO> loadFeatureHistory(List<AssoGroupFeature> assoGroupFeatures) {
+        List<GroupFeatureHistoryVO> groupFeatureHistoryVOS = new ArrayList<>();
+        if (assoGroupFeatures == null || assoGroupFeatures.size() == 0) {
+            return groupFeatureHistoryVOS;
+        }
+        List<Integer> featureIds = assoGroupFeatures.stream().filter(item -> item.getFeatureId() != null).map(AssoGroupFeature::getFeatureId).collect(Collectors.toList());
+        //根据特征id查询特征
+        List<Feature> features = new ArrayList<>();
+        LambdaQueryWrapper<Feature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(Feature::getId, featureIds);
+        features = featureService.list(queryWrapper);
+
+
+        for (AssoGroupFeature item : assoGroupFeatures) {
+            Feature feature = features.stream().filter(i -> i.getId().equals(item.getFeatureId())).findFirst().orElse(null);
+
+            GroupFeatureHistoryVO groupFeatureHistoryVO = new GroupFeatureHistoryVO();
+            groupFeatureHistoryVO.setFeatureGroupId(item.getId());
+            if (feature != null) {
+                groupFeatureHistoryVO.setFeatureId(item.getFeatureId());
+                groupFeatureHistoryVO.setFeatureContent(feature.getContent());
+            }
+            groupFeatureHistoryVO.setFeatureGen(item.getFeatureGen());
+            groupFeatureHistoryVO.setOperateMode(item.getOperateMode());
+            groupFeatureHistoryVOS.add(groupFeatureHistoryVO);
+        }
+        return groupFeatureHistoryVOS;
+    }
 }

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

@@ -1,5 +1,6 @@
 package cn.cslg.pas.service.business.invalidReport;
 
+import cn.cslg.pas.common.dto.QueryFeatureHistoryDTO;
 import cn.cslg.pas.common.dto.invalidDTO.AddEvidenceReasonDTO;
 import cn.cslg.pas.common.dto.invalidDTO.AddEvidenceReasonsDTO;
 import cn.cslg.pas.common.dto.invalidDTO.QueryEvidenceReasonDTO;
@@ -8,6 +9,7 @@ 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.GroupFeatureHistoryVO;
 import cn.cslg.pas.common.vo.invalidVO.QueryEvidenceReasonVO;
 import cn.cslg.pas.common.vo.invalidVO.QueryInvalidHistoryVO;
 import cn.cslg.pas.domain.business.*;
@@ -49,6 +51,7 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
     @Autowired
     private CompareLiteratureService compareLiteratureService;
 
+
     @Transactional(rollbackFor = Exception.class)
     public Boolean addEvidenceReason(AddEvidenceReasonDTO addEvidenceReasonDTO) {
         PersonnelVO personnelVO = new PersonnelVO();
@@ -66,12 +69,12 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
         });
 
         //遍历插入无id特征
-        addEvidenceReasonsDTOList.forEach(item->{
-            if(item.getFeatureId()==null){
+        addEvidenceReasonsDTOList.forEach(item -> {
+            if (item.getFeatureId() == null) {
                 Feature feature = new Feature();
                 feature.setContent(item.getFeatureText());
                 feature.insert();
-              item.setFeatureId(feature.getId());
+                item.setFeatureId(feature.getId());
             }
 
         });
@@ -79,19 +82,19 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
         List<Integer> featureIds = addEvidenceReasonsDTOs.stream()
                 .filter(item -> item.getFeatureId() != null)
                 .map(AddEvidenceReasonsDTO::getFeatureId).collect(Collectors.toList());
-        this.deleteAssoByFeatureIds(featureIds,groupId);
+        this.deleteAssoByFeatureIds(featureIds, groupId);
 
 
         for (AddEvidenceReasonsDTO addEvidenceReasonsDTO : addEvidenceReasonsDTOs) {
             //获得特征信息
             Integer featureId = addEvidenceReasonsDTO.getFeatureId();
             Integer featureOrder = addEvidenceReasonsDTO.getFeatureOrder();
-                //判断
-                AddEvidenceReasonsDTO tem = addEvidenceReasonsDTOList.stream()
-                        .filter(item -> addEvidenceReasonsDTO.getFeatureOrder().equals(item.getFeatureOrder())).findFirst().orElse(null);
-                if (tem == null) {
-                   featureId = tem.getFeatureId();
-                }
+            //判断
+            AddEvidenceReasonsDTO tem = addEvidenceReasonsDTOList.stream()
+                    .filter(item -> addEvidenceReasonsDTO.getFeatureOrder().equals(item.getFeatureOrder())).findFirst().orElse(null);
+            if (tem == null) {
+                featureId = tem.getFeatureId();
+            }
 
 
             //添加无效理由
@@ -116,13 +119,12 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
 
     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){
+        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<>();
@@ -147,26 +149,9 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
 
             //删除证据组合和特征关联
             LambdaQueryWrapper<AssoGroupFeature> queryWrapper3 = new LambdaQueryWrapper<>();
-            queryWrapper3.eq(AssoGroupFeature::getGroupId, groupId)
-                    .in(AssoGroupFeature::getFeatureId, inFeatureIds);
+            queryWrapper3.eq(AssoGroupFeature::getGroupId, groupId);
             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);
-            }
         }
 
 
@@ -209,6 +194,7 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
         //根据证据组合id 查询特征
         LambdaQueryWrapper<AssoGroupFeature> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(AssoGroupFeature::getGroupId, groupId);
+        queryWrapper.eq(AssoGroupFeature::getFeatureGen, 0);
         List<AssoGroupFeature> assoGroupFeatures = assoGroupFeatureService.list(queryWrapper);
         List<QueryEvidenceReasonVO> queryEvidenceReasonVOS = new ArrayList<>();
         if (assoGroupFeatures != null && assoGroupFeatures.size() != 0) {
@@ -217,6 +203,12 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
                 Integer featureId = item.getFeatureId();
                 //根据特征id查询特征
                 Feature feature = featureService.getById(featureId);
+                Integer featureGroupId = item.getId();
+
+                //查询特征历史
+                QueryFeatureHistoryDTO queryFeatureHistoryDTO = new QueryFeatureHistoryDTO();
+                queryFeatureHistoryDTO.setFeatureGroupId(featureGroupId);
+                List<GroupFeatureHistoryVO> queryFeatureHistories = assoGroupFeatureService.queryFeatureHistory(queryFeatureHistoryDTO);
 
                 //根据特征id 查询无效理由
                 LambdaQueryWrapper<AssoFeatureReason> queryWrapper1 = new LambdaQueryWrapper<>();
@@ -232,6 +224,8 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
                         queryEvidenceReasonVO.setFeatureOrder(item.getFeatureOrder());
                         queryEvidenceReasonVO.setFeatureText(feature.getContent());
                         queryEvidenceReasonVO.setGroupId(groupId);
+                        queryEvidenceReasonVO.setFeatureGroupId(featureGroupId);
+                        queryEvidenceReasonVO.setFeatureHistories(queryFeatureHistories);
                         //根据无效理由id 查询无效理由
                         EvidenceReason evidenceReason = this.getById(assoFeatureReason.getReasonId());
                         queryEvidenceReasonVO.setEvidenceText(evidenceReason.getEvidenceText());
@@ -276,7 +270,7 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
     }
 
     //查询无效历史
-    public Records queryInvalidHistory( QueryInvalidHistoryDTO queryInvalidHistoryDTO) {
+    public Records queryInvalidHistory(QueryInvalidHistoryDTO queryInvalidHistoryDTO) {
         List<QueryInvalidHistoryVO> queryInvalidHistoryVOS = new ArrayList<>();
         Integer featureId = queryInvalidHistoryDTO.getFeatureId();
         Long current = queryInvalidHistoryDTO.getCurrent();

src/main/resources/mapper/AssoGroupFeatureMapper.xml

@@ -0,0 +1,16 @@
+<?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.pas.mapper.InvalidReport.AssoGroupFeatureMapper">
+    <select id="selectLastGroupFeature" resultType="cn.cslg.pas.domain.business.AssoGroupFeature">
+        select *
+        from (select *
+              from asso_group_feature f
+              where f.group_id = #{groupId}
+                and feature_order &gt; #{order}
+                and feature_gen &lt;= #{gen}
+              order by feature_gen desc limit 9999) a
+        group by a.group_id, a.feature_pre_id
+    </select>
+
+
+</mapper>

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

@@ -1,9 +1,12 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.dto.DomainFieldDTO;
 import cn.cslg.pas.common.dto.business.AvoidDesignDTO;
 import cn.cslg.pas.common.dto.business.AvoidDesignInsertDTO;
+import cn.cslg.pas.common.utils.GenerateObjectUtil;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.controller.AvoidDesignController;
+import cn.cslg.pas.domain.business.FollowUp;
 import cn.cslg.pas.service.business.AvoidDesignService;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -24,6 +27,9 @@ public class AvoidDesignServiceTests {
     @Autowired
     private AvoidDesignController avoidDesignController;
 
+    @Autowired
+    private GenerateObjectUtil generateObjectUtil;
+
     @Test
     public void test() throws Exception {
 
@@ -31,6 +37,18 @@ public class AvoidDesignServiceTests {
 
     @Test
     public void testUpdate() {
+        List<DomainFieldDTO> domainFieldDTOs = new ArrayList<>();
+        DomainFieldDTO domainFieldDTO = new DomainFieldDTO();
+        domainFieldDTO.setField("description");
+        domainFieldDTO.setValue("1234");
+        domainFieldDTOs.add(domainFieldDTO);
+        try {
+            FollowUp followUp =new FollowUp();
+            GenerateObjectUtil.setObjectProperty(followUp,"description","1234");
+            System.out.println(followUp);
+        } catch (Exception e) {
+            System.out.println(e);
+        }
 
     }