12/16

src/main/java/cn/cslg/pas/common/dto/business/GetFeatureSplitDTO.java

@@ -16,6 +16,9 @@ public class GetFeatureSplitDTO {
 
     private String patentNo;
 
+    /**
+     * 任务id
+     */
     private Integer taskId;
 
     /**

src/main/java/cn/cslg/pas/common/dto/business/TortTaskDTO.java

@@ -59,4 +59,6 @@ public class TortTaskDTO {
      * 备注
      */
     private String description;
+
+    private List<String> patentNos;
 }

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

@@ -33,8 +33,6 @@ import java.util.List;
 @RequestMapping(Constants.API_XiaoSHI + "/fto")
 @RestController
 public class FTOController {
-    @Autowired
-    private TortCompareRecordService tortCompareRecordService;
 
     @Autowired
     private FTOCompareRecordService ftoCompareRecordService;
@@ -42,7 +40,7 @@ public class FTOController {
     @Autowired
     private ProjectTaskService projectTaskService;
 
-    @Operation(summary = "发起人查询侵权分析对比结果（包含拆分特征）")
+    @Operation(summary = "查询某个任务下的某件专利的对比结果（包含拆分特征）")
     @PostMapping("/getFTOCompareRecord")
     public Response getFTOCompareRecord(@RequestBody GetFeatureSplitDTO getFeatureSplitDTO) throws Exception {
         TortCompareRecordVO tortCompareRecordVO = ftoCompareRecordService.getTortCompareRecord(getFeatureSplitDTO);
@@ -55,7 +53,7 @@ public class FTOController {
         if (tortCompareRecordDTO != null) {
             List<Integer> ids = new ArrayList<>();
             try {
-                ids = tortCompareRecordService.addTortCompareRecord(tortCompareRecordDTO);
+                ids = ftoCompareRecordService.addFTOCompareRecord(tortCompareRecordDTO);
             } catch (Exception e) {
                 if (e instanceof XiaoShiException) {
                     return Response.error(e.getMessage());
@@ -73,48 +71,46 @@ public class FTOController {
         }
     }
 
-
-
-    @Operation(summary = "添加侵权分析协同任务")
-    @PostMapping("/addTortTask")
-    public Response addTortTask(@RequestBody TortTaskDTO tortTaskDTO){
-        Integer id = projectTaskService.addTortTask(tortTaskDTO);
+    @Operation(summary = "添加FTO协同任务")
+    @PostMapping("/addFTOAssitTask")
+    public Response addFTOAssitTask(@RequestBody TortTaskDTO tortTaskDTO){
+        Integer id = projectTaskService.addFTOAssitTask(tortTaskDTO);
         Records records = new Records();
         records.setData(id);
         return Response.success(records);
     }
 
-    @Operation(summary = "保存侵权分析协同任务对比结果")
-    @PostMapping("/addTortTaskResult")
-    public Response addTortTaskResult(@RequestBody TortCompareRecordDTO tortCompareRecordDTO){
-        List<Integer> ids = tortCompareRecordService.addTortTaskResult(tortCompareRecordDTO);
+    @Operation(summary = "保存FTO协同任务对比结果")
+    @PostMapping("/addFTOAssitTaskResult")
+    public Response addFTOAssitTaskResult(@RequestBody TortCompareRecordDTO tortCompareRecordDTO){
+        List<Integer> ids = ftoCompareRecordService.addFTOAssitTaskResult(tortCompareRecordDTO);
         Records records = new Records();
         records.setData(ids);
         return Response.success(records);
     }
 
-    @Operation(summary = "查询侵权分析协同前后对比结果")
-    @GetMapping("/getAllTortTaskResult")
-    public Response getAllTortTaskResult(Integer taskId){
+    @Operation(summary = "查询fto协同前后对比结果")
+    @GetMapping("/getFTOAssitResult")
+    public Response getFTOAssitResult(String patentNo, Integer taskId){
         Integer type = 1;
-        TortCompareRecordVO tortCompareRecordVO = tortCompareRecordService.getAllTortTaskResult(null, taskId, type);
+        TortCompareRecordVO tortCompareRecordVO = ftoCompareRecordService.getFTOAssitResult(patentNo, null, taskId, type);
         return Response.success(tortCompareRecordVO);
     }
 
-    @Operation(summary = "确认侵权分析对比结果")
-    @PostMapping("/addFinalTortResult")
-    public Response addFinalTortResult(@RequestBody TortCompareRecordDTO tortCompareRecordDTO){
-        List<Integer> ids = tortCompareRecordService.addFinalTortResult(tortCompareRecordDTO);
+    @Operation(summary = "保存最终对比结果")
+    @PostMapping("/addFinalAssitResult")
+    public Response addFinalAssitResult(@RequestBody TortCompareRecordDTO tortCompareRecordDTO){
+        List<Integer> ids = ftoCompareRecordService.addFinalAssitResult(tortCompareRecordDTO);
         Records records = new Records();
         records.setData(ids);
         return Response.success(records);
     }
 
     @Operation(summary = "查询最终结果")
-    @GetMapping("/getTortFinalResult")
-    public Response getTortFinalResult(Integer projectId, Integer taskId){
+    @GetMapping("/getFTOFinalResult")
+    public Response getFTOFinalResult(String patentNo, Integer projectId, Integer taskId){
         Integer type = 2;
-        TortCompareRecordVO tortCompareRecordVO = tortCompareRecordService.getAllTortTaskResult(projectId, taskId, type);
+        TortCompareRecordVO tortCompareRecordVO = ftoCompareRecordService.getFTOAssitResult(patentNo, projectId, taskId, type);
         return Response.success(tortCompareRecordVO);
     }
 }

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

@@ -1,17 +1,25 @@
 package cn.cslg.pas.service.business;
 
 import cn.cslg.pas.common.dto.business.GetFeatureSplitDTO;
+import cn.cslg.pas.common.dto.business.TortCompareRecordDTO;
+import cn.cslg.pas.common.dto.business.TortDTO;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
 import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.common.utils.StringUtils;
 import cn.cslg.pas.common.vo.PatentRightVo;
+import cn.cslg.pas.common.vo.RePatentClaim;
 import cn.cslg.pas.common.vo.business.*;
 import cn.cslg.pas.domain.business.CompareLiterature;
 import cn.cslg.pas.domain.business.FTOCompareRecord;
 import cn.cslg.pas.domain.business.Feature;
+import cn.cslg.pas.domain.business.ProjectTask;
+import cn.cslg.pas.exception.UnLoginException;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.FTOCompareRecordMapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.spire.pdf.packages.sprcxq;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -20,6 +28,8 @@ import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * FTO
@@ -48,17 +58,20 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
     @Autowired
     private CompareLiteratureService compareLiteratureService;
 
+    @Autowired
+    private TortCompareRecordService tortCompareRecordService;
+
     /**
-     * 查询侵权分析对比结果VO
+     * 查询FTO对比结果VO
      * @param getFeatureSplitDTO
      * @return
      */
     public TortCompareRecordVO getTortCompareRecord(GetFeatureSplitDTO getFeatureSplitDTO){
         // 判断参数不能为空
         // 分配任务id
-        Integer projectTaskId = getFeatureSplitDTO.getTaskId();
-        if (projectTaskId == null) {
-            throw new XiaoShiException("taskId不能为空");
+        Integer taskId = getFeatureSplitDTO.getTaskId();
+        if (taskId == null) {
+            throw new XiaoShiException("任务id不能为空");
         }
         // 专利号
         String patentNo = getFeatureSplitDTO.getPatentNo();
@@ -74,15 +87,13 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
         if (getFeatureSplitDTO.getSplitType() == null) {
             throw new XiaoShiException("splitType不能为空");
         }
-        // 根据分配任务id和专利号查询projectId
-        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(CompareLiterature::getLiteratureNo, patentNo)
-                .eq(CompareLiterature::getProjectTaskId, projectTaskId);
-        CompareLiterature compareLiterature = compareLiteratureService.getOne(queryWrapper, false);
-        Integer projectId = getFeatureSplitDTO.getProjectId();
-        if (compareLiterature != null) {
-            projectId = compareLiterature.getProjectId();
+        LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(ProjectTask::getId, taskId);
+        ProjectTask projectTask = projectTaskService.getOne(queryWrapper, false);
+        if (projectTask != null) {
+            getFeatureSplitDTO.setProjectId(projectTask.getProjectId());
         }
+        Integer projectId = getFeatureSplitDTO.getProjectId();
         //返回的VO类
         TortCompareRecordVO tortCompareRecordVO = new TortCompareRecordVO();
         tortCompareRecordVO.setProjectId(projectId);
@@ -95,8 +106,7 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
             //重拆需要清空原有对比结果表
             // 根据分配任务id和报告id删除对比结果
             LambdaQueryWrapper<FTOCompareRecord> deleteWrapper = new LambdaQueryWrapper<>();
-            deleteWrapper.eq(FTOCompareRecord::getProjectId, projectId)
-                    .eq(FTOCompareRecord::getProjectTaskId, projectTaskId)
+            deleteWrapper.eq(FTOCompareRecord::getProjectTaskId, taskId)
                     .eq(FTOCompareRecord::getCompareFileNumber, patentNo);
             this.remove(deleteWrapper);
         }
@@ -109,7 +119,7 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
         }
         //装载权要部分
         if (!patentRightVos.isEmpty()) {
-            List<TortRightVO> tortRightVOS = this.loadTortRightVO(patentNo, projectTaskId, patentRightVos);
+            List<TortRightVO> tortRightVOS = this.loadTortRightVO(patentNo, taskId, patentRightVos);
             tortCompareRecordVO.setTortRightVOS(tortRightVOS);
         } else {
             throw new XiaoShiException("特征查询错误");
@@ -122,22 +132,21 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
      * @param patentRightVos
      * @return
      */
-    public List<TortRightVO> loadTortRightVO(String patentNo, Integer projectTaskId, List<PatentRightVo> patentRightVos){
-        //根据projectId查询
+    public List<TortRightVO> loadTortRightVO(String patentNo, Integer taskId, List<PatentRightVo> patentRightVos){
         //新建权要层信息
         List<TortRightVO> tortRightVOS = new ArrayList<>();
         //遍历装载权要层信息
         patentRightVos.forEach(item -> {
             TortRightVO tortRightVO = new TortRightVO();
             BeanUtils.copyProperties(item, tortRightVO);
-            //根据projectId获取对比记录
+            //根据taskId获取对比记录
             List<Feature> features = item.getFeatures();
             LambdaQueryWrapper<FTOCompareRecord> queryWrapper = new LambdaQueryWrapper<>();
             queryWrapper.eq(FTOCompareRecord::getCompareFileNumber, patentNo)
-                    .eq(FTOCompareRecord::getProjectTaskId, projectTaskId);
+                    .eq(FTOCompareRecord::getProjectTaskId, taskId);
             List<FTOCompareRecord> ftoCompareRecords = this.list(queryWrapper);
             //装载特征与对比记录
-            List<TortVO> tortVOS = this.loadTortVO2(null, features, ftoCompareRecords);
+            List<TortVO> tortVOS = this.loadAllTortVO(taskId, features, ftoCompareRecords);
             tortRightVO.setTortVOS(tortVOS);
             tortRightVOS.add(tortRightVO);
         });
@@ -152,31 +161,35 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
      * @param ftoCompareRecords
      * @return
      */
-    public List<TortVO> loadTortVO2(Integer taskId, List<Feature> features, List<FTOCompareRecord> ftoCompareRecords){
+    public List<TortVO> loadAllTortVO(Integer taskId, List<Feature> features, List<FTOCompareRecord> ftoCompareRecords){
         List<TortVO> tortVOS = new ArrayList<>();
         for (Feature feature : features) {
             //新建特征与侵权分析对比结果VO
             //装载特征部分的信息
-            TortVO tortVO = this.loadFeature(feature);
+            TortVO tortVO = tortCompareRecordService.loadFeature(feature);
             //装载侵权分析对比结果的部分
             FTOCompareRecordVO originalRecordVO = new FTOCompareRecordVO();
             FTOCompareRecordVO currentRecordVO = new FTOCompareRecordVO();
             FTOCompareRecordVO finalRecordVO = new FTOCompareRecordVO();
             //对比结果集合不为空
             if (!ftoCompareRecords.isEmpty()) {
-                //原始数据or最终数据
+                //原始数据
                 FTOCompareRecord originalRecord = ftoCompareRecords
                         .stream()
-                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfFinal().equals(true))
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfOriginal().equals(true))
                         .findFirst()
                         .orElse(null);
-
                 if (originalRecord != null) {
-                    //装载
-                    originalRecordVO.setId(originalRecord.getId());
-                    originalRecordVO.setCompareResult(originalRecord.getCompareResult());
-                    originalRecordVO.setCompareDescription(originalRecord.getCompareDescription());
-                    originalRecordVO.setTargetDescription(originalRecord.getTargetDescription());
+                    originalRecordVO = tortCompareRecordService.loadVO(originalRecord);
+                } else {
+                    FTOCompareRecord record = ftoCompareRecords
+                            .stream()
+                            .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfFinal().equals(true))
+                            .findFirst()
+                            .orElse(null);
+                    if (record != null) {
+                        originalRecordVO = tortCompareRecordService.loadVO(record);
+                    }
                 }
                 //协同人处理的数据
                 FTOCompareRecord currentRecord = ftoCompareRecords
@@ -185,11 +198,7 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
                         .findFirst()
                         .orElse(null);
                 if (currentRecord != null) {
-                    //装载
-                    currentRecordVO.setId(currentRecord.getId());
-                    currentRecordVO.setCompareResult(currentRecord.getCompareResult());
-                    currentRecordVO.setCompareDescription(currentRecord.getCompareDescription());
-                    currentRecordVO.setTargetDescription(currentRecord.getTargetDescription());
+                    currentRecordVO = tortCompareRecordService.loadVO(currentRecord);
                 }
 
                 FTOCompareRecord finalRecord = ftoCompareRecords
@@ -198,11 +207,7 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
                         .findFirst()
                         .orElse(null);
                 if (finalRecord != null) {
-                    //装载
-                    finalRecordVO.setId(finalRecord.getId());
-                    finalRecordVO.setCompareResult(finalRecord.getCompareResult());
-                    finalRecordVO.setCompareDescription(finalRecord.getCompareDescription());
-                    finalRecordVO.setTargetDescription(finalRecord.getTargetDescription());
+                    finalRecordVO = tortCompareRecordService.loadVO(finalRecord);
                 }
             }
             tortVO.setOriginalRecordVO(originalRecordVO);
@@ -214,20 +219,512 @@ public class FTOCompareRecordService extends ServiceImpl<FTOCompareRecordMapper,
     }
 
     /**
-     * 装载特征
-     * @param feature
+     * 新增侵权对比结果
+     *
+     * @param tortCompareRecordDTO
+     * @return
+     */
+    public List<Integer> addFTOCompareRecord(TortCompareRecordDTO tortCompareRecordDTO) {
+        Integer taskId = tortCompareRecordDTO.getTaskId();
+        if (taskId == null) {
+            throw new XiaoShiException("taskId不能为空");
+        }
+        String patentNo = tortCompareRecordDTO.getPatentNo();
+        if (patentNo == null || patentNo.equals("")) {
+            throw new XiaoShiException("patentNo不能为空");
+        }
+        List<TortDTO> tortDTOS = tortCompareRecordDTO.getTortDTOS();
+        //不能将特征一次性全部删除，使用处理特征方法
+        if (!tortDTOS.isEmpty()) {
+            throw new XiaoShiException("传入特征集合不能为空");
+        }
+        //查询出原来的特征id集合
+        LambdaQueryWrapper<Feature> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.select(Feature::getId)
+                .eq(Feature::getProjectTaskId, taskId);
+        Function<Object,Integer> f = (o -> Integer.parseInt(o.toString()));
+        List<Integer> featureIds = featureService.listObjs(queryWrapper,f);
+        // 删除特征
+        List<Integer> ids = new ArrayList<>();
+        if (!featureIds.isEmpty()) {
+            tortCompareRecordService.deleteFeatures(tortDTOS, featureIds);
+            // 删除对比记录
+            LambdaQueryWrapper<FTOCompareRecord> deleteWrapper = new LambdaQueryWrapper<>();
+            deleteWrapper.eq(FTOCompareRecord::getProjectTaskId, taskId)
+                    .eq(FTOCompareRecord::getCompareFileNumber, patentNo)
+                    .eq(FTOCompareRecord::getIfFinal, true);
+            this.remove(deleteWrapper);
+            // 更新剩余特征和对比结果
+            ids = this.updateFeatures(patentNo, taskId, featureIds, tortDTOS);
+        }
+        return ids;
+    }
+
+    /**
+     * 更新剩余特征和对比结果
+     * @param patentNo
+     * @param taskId
+     * @param featureIds
+     * @param tortDTOS
+     */
+    public List<Integer> updateFeatures(String patentNo, Integer taskId, List<Integer> featureIds, List<TortDTO> tortDTOS){
+        // 获取登录人信息
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
+        // 根据taskId查询报告id
+        Integer projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
+        // 重新排序
+        Integer order = 1;
+        List<Integer> ftoIds = new ArrayList<>();
+        for (TortDTO item : tortDTOS) {
+            Integer currentFeatureId = item.getFeatureId();
+            // 新的特征id不为空，并且数据库中是有这个特征的
+            if (item.getFeatureId() != null && featureIds.contains(currentFeatureId)) {
+                // 执行更新操作
+                Feature feature = featureService.getById(item.getFeatureId());
+                feature.setRightSort(item.getRightSort());
+                feature.setContent(item.getContent());
+                feature.setExplainText(item.getExplainText());
+                feature.setRightType(item.getRightType());
+                feature.setSysOrder(order);
+                feature.updateById();
+                // 新增对比结果
+                Integer id = this.addCompareRecords(patentNo, projectId, item);
+                if (id != null) {
+                    ftoIds.add(id);
+                }
+            } else {
+                Feature feature = new Feature();
+                feature.setRightSort(item.getRightSort());
+                feature.setPatentNo(patentNo);
+                feature.setProjectId(projectId);
+                feature.setContent(item.getContent());
+                feature.setExplainText(item.getExplainText());
+                feature.setCreateId(personnelVO.getId());
+                feature.setRightType(item.getRightType());
+                feature.setSysOrder(order);
+                feature.insert();
+                item.setFeatureId(feature.getId());
+                // 新增对比结果
+                Integer id = this.addCompareRecords(patentNo, projectId, item);
+                if (id != null) {
+                    ftoIds.add(id);
+                }
+            }
+            order++ ;
+        }
+        return ftoIds;
+    }
+
+    /**
+     * 对比结果入库
+     * @param patentNo
+     * @param projectId
+     * @param tortDTO
+     */
+    public Integer addCompareRecords(String patentNo, Integer projectId, TortDTO tortDTO){
+        Integer featureId = tortDTO.getFeatureId();
+        //获取登录人信息
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
+        if (tortDTO.getCompareResult() != null || StringUtils.isNotBlank(tortDTO.getCompareDescription()) || StringUtils.isNotBlank(tortDTO.getTargetDescription())) {
+            //插入对比结果
+            FTOCompareRecord ftoCompareRecord = new FTOCompareRecord();
+            ftoCompareRecord.setProjectId(projectId);
+            ftoCompareRecord.setFeatureId(featureId);
+            ftoCompareRecord.setCompareFileNumber(patentNo);
+            ftoCompareRecord.setCompareResult(tortDTO.getCompareResult());
+            ftoCompareRecord.setCompareDescription(tortDTO.getCompareDescription());
+            ftoCompareRecord.setTargetDescription(tortDTO.getTargetDescription());
+            ftoCompareRecord.setCreateId(personnelVO.getId());
+            ftoCompareRecord.insert();
+            return ftoCompareRecord.getId();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * 保存协同任务对比结果
+     * @param tortCompareRecordDTO
+     */
+    public List<Integer> addFTOAssitTaskResult(TortCompareRecordDTO tortCompareRecordDTO){
+        if (tortCompareRecordDTO == null) {
+            throw new XiaoShiException("入参不能为空");
+        }
+        String patentNo = tortCompareRecordDTO.getPatentNo();
+        if (patentNo == null) {
+            throw new XiaoShiException("专利号不能为空");
+        }
+        Integer projectId = null;
+        Integer taskId = tortCompareRecordDTO.getTaskId();
+        //根据taskId查询报告id
+        if (taskId != null) {
+            projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
+        } else {
+            throw new XiaoShiException("任务id不能为空");
+        }
+        //获取登录人信息
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
+        List<TortDTO> tortDTOS = tortCompareRecordDTO.getTortDTOS();
+        List<Integer> ids = new ArrayList<>();
+        //传入对比结果不为空
+        if (tortDTOS != null && !tortDTOS.isEmpty()) {
+            List<FTOCompareRecord> ftoCompareRecords = new ArrayList<>();
+            //遍历传入对比结果
+            for (TortDTO item : tortDTOS) {
+                //由于传入的集合中有部分特征是没有对比结果的，所以选择有的部分添加到表中
+                if (item.getCompareResult() != null || StringUtils.isNotBlank(item.getCompareDescription()) || StringUtils.isNotBlank(item.getTargetDescription())) {
+                    //装载处理人处理过的对比记录
+                    FTOCompareRecord ftoCompareRecord = new FTOCompareRecord();
+                    ftoCompareRecord.setCompareResult(item.getCompareResult());
+                    ftoCompareRecord.setCompareDescription(item.getCompareDescription());
+                    ftoCompareRecord.setTargetDescription(item.getTargetDescription());
+                    ftoCompareRecord.setFeatureId(item.getFeatureId());
+                    ftoCompareRecord.setProjectId(projectId);
+                    ftoCompareRecord.setProjectTaskId(taskId);
+                    ftoCompareRecord.setCompareFileNumber(patentNo);
+                    ftoCompareRecord.setCreateId(personnelVO.getId());
+                    ftoCompareRecord.setIfOriginal(false);
+                    ftoCompareRecord.setIfFinal(false);
+                    ftoCompareRecords.add(ftoCompareRecord);
+                }
+            }
+            if (!ftoCompareRecords.isEmpty()) {
+                //先删除表中原有的协同后的对比记录
+                LambdaQueryWrapper<FTOCompareRecord> deleteWrapper = new LambdaQueryWrapper<>();
+                deleteWrapper.eq(FTOCompareRecord::getIfOriginal, false)
+                        .eq(FTOCompareRecord::getCreateId, personnelVO.getId())
+                        .eq(FTOCompareRecord::getProjectTaskId, taskId)
+                        .eq(FTOCompareRecord::getCompareFileNumber, patentNo);
+                this.remove(deleteWrapper);
+                //更新
+                this.saveBatch(ftoCompareRecords);
+                ids = ftoCompareRecords.stream().map(FTOCompareRecord::getId).collect(Collectors.toList());
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * 查询侵权分析协同前后对比结果
+     * 三份结果：原始、协同处理、最终
+     * @param taskId
      * @return
      */
-    public TortVO loadFeature(Feature feature){
-        TortVO tortVO = new TortVO();
-        tortVO.setFeatureId(feature.getId());
-        tortVO.setContent(feature.getContent());
-        tortVO.setPatentNo(feature.getPatentNo());
-        tortVO.setRightSort(feature.getRightSort());
-        tortVO.setRightType(feature.getRightType());
-        tortVO.setExplainText(feature.getExplainText());
-        tortVO.setFormId(feature.getFromId());
-        tortVO.setSysOrder(feature.getSysOrder());
-        return tortVO;
+    public TortCompareRecordVO getFTOAssitResult(String patentNo, Integer projectId, Integer taskId, Integer type) {
+        TortCompareRecordVO tortCompareRecordVO = new TortCompareRecordVO();
+        // 发起人从任务进入，没有报告id，有taskId
+        // 根据taskId查询报告id
+        if (projectId == null && taskId != null) {
+            projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
+        }
+        tortCompareRecordVO.setProjectId(projectId);
+        try {
+            List<PatentRightVo> patentRightVos = new ArrayList<>();
+            //根据专利号和报告id查询权要
+            List<RePatentClaim> patentRights = featureService.getRightListByNo(patentNo);
+            LambdaQueryWrapper<Feature> wrapper = new LambdaQueryWrapper<>();
+            wrapper.eq(Feature::getProjectTaskId, taskId)
+                    .eq(Feature::getPatentNo, patentNo);
+            List<Feature> allFeatures = featureService.list(wrapper);
+            patentRightVos = featureService.loadPatentRightVO(patentRights, allFeatures, projectId, patentNo);
+            //装载权要层下的特征与对比结果
+            List<TortRightVO> tortRightVOS = new ArrayList<>();
+            if (type == 1) {//查询协同前后对比结果
+                tortRightVOS = this.loadBeforeAndAfter(taskId, patentNo, patentRightVos);
+            } else if (type == 2) {//发起人的查询
+                tortRightVOS = this.loadTortRightVOS2(taskId, projectId, patentRightVos);
+            }
+            tortCompareRecordVO.setTortRightVOS(tortRightVOS);
+        } catch (Exception e) {
+            throw new XiaoShiException("未查询到拆分下的权要");
+        }
+        return tortCompareRecordVO;
     }
+
+    /**
+     * 协同前后对比结果
+     * @param patentNo
+     * @param taskId
+     * @param patentRightVos
+     * @return
+     */
+    public List<TortRightVO> loadBeforeAndAfter(Integer taskId, String patentNo, List<PatentRightVo> patentRightVos){
+        if (patentRightVos != null && !patentRightVos.isEmpty()) {
+            //新建权要层信息
+            List<TortRightVO> tortRightVOS = new ArrayList<>();
+            //遍历装载权要层信息
+            patentRightVos.forEach(item -> {
+                TortRightVO tortRightVO = new TortRightVO();
+                BeanUtils.copyProperties(item, tortRightVO);
+                //新建特征与侵权分析对比结果VOS
+                List<Feature> features = item.getFeatures();
+                LambdaQueryWrapper<FTOCompareRecord> queryWrapper = new LambdaQueryWrapper<>();
+                queryWrapper.eq(FTOCompareRecord::getCompareFileNumber, patentNo)
+                        .eq(FTOCompareRecord::getProjectTaskId, taskId);
+                List<FTOCompareRecord> ftoCompareRecords = this.list(queryWrapper);
+                List<TortVO> tortVOS = this.loadBeforeAndAfterTortVO(features, ftoCompareRecords);
+                tortRightVO.setTortVOS(tortVOS);
+                tortRightVOS.add(tortRightVO);
+            });
+            return tortRightVOS;
+        } else {
+            throw new XiaoShiException("传入权要为空");
+        }
+    }
+
+    /**
+     * 协同前后对比结果
+     * 装载特征与对比结果
+     * @param features
+     * @param ftoCompareRecords
+     * @return
+     */
+    public List<TortVO> loadBeforeAndAfterTortVO(List<Feature> features, List<FTOCompareRecord> ftoCompareRecords){
+        List<TortVO> tortVOS = new ArrayList<>();
+        for (Feature feature : features) {
+            //新建特征与侵权分析对比结果VO
+            //装载特征部分的信息
+            TortVO tortVO = tortCompareRecordService.loadFeature(feature);
+            //装载侵权分析对比结果的部分
+            FTOCompareRecordVO originalRecordVO = new FTOCompareRecordVO();
+            FTOCompareRecordVO currentRecordVO = new FTOCompareRecordVO();
+            if (!ftoCompareRecords.isEmpty()) {
+                //协同前
+                FTOCompareRecord originalRecord = ftoCompareRecords
+                        .stream()
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfOriginal().equals(true))
+                        .findFirst()
+                        .orElse(null);
+                if (originalRecord != null) {
+                    originalRecordVO = tortCompareRecordService.loadVO(originalRecord);
+                }
+                //协同后
+                FTOCompareRecord currentRecord = ftoCompareRecords
+                        .stream()
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfOriginal().equals(false) && item.getIfFinal().equals(false))
+                        .findFirst()
+                        .orElse(null);
+                if (currentRecord != null) {
+                    currentRecordVO = tortCompareRecordService.loadVO(currentRecord);
+                } else {
+                    currentRecordVO = originalRecordVO;
+                }
+            }
+            tortVO.setOriginalRecordVO(originalRecordVO);
+            tortVO.setCurrentRecordVO(currentRecordVO);
+            tortVOS.add(tortVO);
+        }
+        return tortVOS;
+    }
+
+    /**
+     * 根据projectId和权要集合装载返回侵权分析对比结果页面VO
+     * @param taskId
+     * @param projectId
+     * @param patentRightVos
+     * @return
+     */
+    public List<TortRightVO> loadTortRightVOS2(Integer taskId, Integer projectId, List<PatentRightVo> patentRightVos){
+        if (patentRightVos != null && !patentRightVos.isEmpty()) {
+            //新建权要层信息
+            List<TortRightVO> tortRightVOS = new ArrayList<>();
+            //遍历装载权要层信息
+            patentRightVos.forEach(item -> {
+                TortRightVO tortRightVO = new TortRightVO();
+                BeanUtils.copyProperties(item, tortRightVO);
+                //新建特征与侵权分析对比结果VOS
+                List<Feature> features = item.getFeatures();
+                LambdaQueryWrapper<FTOCompareRecord> queryWrapper = new LambdaQueryWrapper<>();
+                queryWrapper.eq(FTOCompareRecord::getProjectTaskId, taskId);
+                List<FTOCompareRecord> ftoCompareRecords = this.list(queryWrapper);
+                List<TortVO> tortVOS = this.loadTortVO2(taskId, features, ftoCompareRecords);
+                tortRightVO.setTortVOS(tortVOS);
+                tortRightVOS.add(tortRightVO);
+            });
+            return tortRightVOS;
+        } else {
+            throw new XiaoShiException("传入权要为空");
+        }
+    }
+
+    /**
+     * 发起人查询
+     * 装载特征与对比结果
+     * @param taskId
+     * @param features
+     * @param ftoCompareRecords
+     * @return
+     */
+    public List<TortVO> loadTortVO2(Integer taskId, List<Feature> features, List<FTOCompareRecord> ftoCompareRecords){
+        List<TortVO> tortVOS = new ArrayList<>();
+        for (Feature feature : features) {
+            //新建特征与侵权分析对比结果VO
+            //装载特征部分的信息
+            TortVO tortVO = tortCompareRecordService.loadFeature(feature);
+            //装载侵权分析对比结果的部分
+            FTOCompareRecordVO originalRecordVO = new FTOCompareRecordVO();
+            FTOCompareRecordVO currentRecordVO = new FTOCompareRecordVO();
+            FTOCompareRecordVO finalRecordVO = new FTOCompareRecordVO();
+            if (!ftoCompareRecords.isEmpty()) {
+                // 原始数据的装载
+                // 原始数据应该是ifOriginal为true的数据
+                FTOCompareRecord originalRecord = ftoCompareRecords
+                        .stream()
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfOriginal().equals(true))
+                        .findFirst()
+                        .orElse(null);
+                if (originalRecord != null) {
+                    originalRecordVO = tortCompareRecordService.loadVO(originalRecord);
+                } else {
+                    FTOCompareRecord record = ftoCompareRecords
+                            .stream()
+                            .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfFinal().equals(true))
+                            .findFirst()
+                            .orElse(null);
+                    if (record != null) {
+                        originalRecordVO = tortCompareRecordService.loadVO(record);
+                    }
+                }
+                //协同人处理的数据
+                FTOCompareRecord currentRecord = ftoCompareRecords
+                        .stream()
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfOriginal().equals(false) && item.getIfFinal().equals(false))
+                        .findFirst()
+                        .orElse(null);
+                if (currentRecord != null) {
+                    currentRecordVO = tortCompareRecordService.loadVO(currentRecord);
+                }
+                //最终数据
+                FTOCompareRecord finalRecord = ftoCompareRecords
+                        .stream()
+                        .filter(item -> item.getFeatureId() != null && item.getFeatureId().equals(feature.getId()) && item.getIfFinal().equals(true))
+                        .findFirst()
+                        .orElse(null);
+                if (finalRecord != null) {
+                    finalRecordVO = tortCompareRecordService.loadVO(finalRecord);
+                }
+            }
+            tortVO.setOriginalRecordVO(originalRecordVO);
+            tortVO.setCurrentRecordVO(currentRecordVO);
+            tortVO.setFinalRecordVO(finalRecordVO);
+            tortVOS.add(tortVO);
+        }
+        return tortVOS;
+    }
+
+    /**
+     * 保存最终对比结果接口
+     * @param tortCompareRecordDTO
+     * @return
+     */
+    public List<Integer> addFinalAssitResult(TortCompareRecordDTO tortCompareRecordDTO){
+        List<Integer> ids = new ArrayList<>();
+        Integer taskId = tortCompareRecordDTO.getTaskId();
+        if (taskId == null) {
+            throw new XiaoShiException("taskId不能为空");
+        }
+        String patentNo = tortCompareRecordDTO.getPatentNo();
+        if (patentNo == null) {
+            throw new XiaoShiException("patentNo不能为空");
+        }
+        Integer projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
+        if (projectId == null) {
+            throw new XiaoShiException("查询报告错误");
+        }
+        //获取登录人信息
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
+        try {
+            //首先是根据projectId，以及ifOriginal为false、ifFinal为true这几个条件删除表中的最终数据（最开始的数据）
+            LambdaQueryWrapper<FTOCompareRecord> removeWrapper = new LambdaQueryWrapper<>();
+            removeWrapper.eq(FTOCompareRecord::getProjectTaskId, taskId)
+                    .eq(FTOCompareRecord::getCompareFileNumber, patentNo)
+                    .eq(FTOCompareRecord::getIfOriginal, false)
+                    .eq(FTOCompareRecord::getIfFinal, true);
+            this.remove(removeWrapper);
+            //其次是添加一批新的数据
+            List<FTOCompareRecord> ftoCompareRecords = new ArrayList<>();
+            List<TortDTO> tortDTOS = tortCompareRecordDTO.getTortDTOS();
+            if (tortDTOS != null && !tortDTOS.isEmpty()) {
+                for (TortDTO item : tortDTOS) {
+                    if (item.getCompareResult() != null || StringUtils.isNotBlank(item.getCompareDescription()) || StringUtils.isNotBlank(item.getTargetDescription())) {
+                        FTOCompareRecord tortFinal = new FTOCompareRecord();
+                        tortFinal.setFeatureId(item.getFeatureId());
+                        tortFinal.setProjectId(projectId);
+                        tortFinal.setCompareFileNumber(patentNo);
+                        tortFinal.setProjectTaskId(taskId);
+                        tortFinal.setCompareResult(item.getCompareResult());
+                        tortFinal.setCompareDescription(item.getCompareDescription());
+                        tortFinal.setTargetDescription(item.getTargetDescription());
+                        tortFinal.setCreateId(personnelVO.getId());
+                        ftoCompareRecords.add(tortFinal);
+                    }
+                }
+            }
+            if (!ftoCompareRecords.isEmpty()) {
+                this.saveBatch(ftoCompareRecords);
+                ids = ftoCompareRecords.stream().map(FTOCompareRecord::getId).collect(Collectors.toList());
+            }
+            return ids;
+        } catch (Exception e) {
+            throw new XiaoShiException("添加错误");
+        }
+    }
+
+    /**
+     * 从侵权分析中获得对比结果，并复制保存
+     * @param projectId
+     * @param taskId
+     * @param createId
+     * @param patentNo
+     */
+    public void copyTortCompareRecords(Integer projectId, Integer taskId, String createId, String patentNo){
+        if (projectId != null && taskId != null) {
+            LambdaQueryWrapper<FTOCompareRecord> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(FTOCompareRecord::getProjectTaskId, taskId)
+                    .eq(FTOCompareRecord::getCompareFileNumber, patentNo);
+            List<FTOCompareRecord> ftoCompareRecords = this.list(queryWrapper);
+            if (!ftoCompareRecords.isEmpty()) {
+                List<FTOCompareRecord> newTorts = new ArrayList<>();
+                ftoCompareRecords.forEach(item -> {
+                    FTOCompareRecord newTort = new FTOCompareRecord();
+                    newTort.setCompareResult(item.getCompareResult());
+                    newTort.setCompareDescription(item.getCompareDescription());
+                    newTort.setProjectId(projectId);
+                    newTort.setProjectTaskId(taskId);
+                    newTort.setCompareFileNumber(patentNo);
+                    newTort.setFeatureId(item.getFeatureId());
+                    newTort.setTargetDescription(item.getTargetDescription());
+                    newTort.setIfOriginal(true);
+                    newTort.setIfFinal(false);
+                    newTort.setCreateId(createId);
+                    newTorts.add(newTort);
+                });
+                this.saveBatch(newTorts);
+            }
+        } else {
+            throw new XiaoShiException("projectId不能为空");
+        }
+    }
+
+
 }

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

@@ -89,8 +89,14 @@ public class ProjectTaskService extends ServiceImpl<ProjectTaskMapper, ProjectTa
 
     @Autowired
     private EsPatentService esPatentService;
+
     @Autowired
     private CompareLiteratureService compareLiteratureService;
+
+    @Autowired
+    private FTOCompareRecordService ftoCompareRecordService;
+
+
     /**
      * 项目开卷审核任务
      *
@@ -937,4 +943,73 @@ public class ProjectTaskService extends ServiceImpl<ProjectTaskMapper, ProjectTa
         }
         compareLiteratureService.saveBatch(compareLiteratures);
     }
+
+
+    /**
+     * 添加侵权分析协同任务
+     */
+    public Integer addFTOAssitTask(TortTaskDTO tortTaskDTO) {
+        //1.保存任务信息 project_task表
+        if (tortTaskDTO == null) {
+            throw new XiaoShiException("入参不能为空！");
+        }
+        //判断报告id不为空
+        Integer projectId = tortTaskDTO.getProjectId();
+        if (projectId == null) {
+            throw new XiaoShiException("报告id不能为空!");
+        }
+        //判断协同人员类型不为空
+        if (tortTaskDTO.getHandlerType() == null) {
+            throw new XiaoShiException("协同人员类型不能为空!");
+        }
+        //判断任务名称不为空
+        tortTaskDTO.setName(tortTaskDTO.getName().trim());
+        String name = tortTaskDTO.getName();
+        if (name == null || name.equals("")) {
+            throw new XiaoShiException("任务名称不能为空!");
+        }
+        tortTaskDTO.setType(4);
+        //获取登录人信息
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
+        ProjectTask projectTask = new ProjectTask();
+        BeanUtils.copyProperties(tortTaskDTO, projectTask);
+        projectTask.setCreateId(personnelVO.getId());
+        projectTask.setStatus(2);
+        projectTask.insert();
+        Integer taskId = projectTask.getId();
+        //2.保存任务和人员关联表信息
+        if (taskId != null) {
+            List<CCPerson> ccPeople = tortTaskDTO.getCcPeople();
+            this.addTaskAndCCPeople(personnelVO.getId(), taskId, ccPeople);
+        } else {
+            throw new XiaoShiException("创建任务失败，未读取到任务id");
+        }
+        List<String> patentNos = tortTaskDTO.getPatentNos();
+        if (!patentNos.isEmpty()) {
+            List<CompareLiterature> compareLiteratures = new ArrayList<>();
+            //3.从侵权分析中获得对比结果，并复制保存
+            for (String patentNo : patentNos) {
+                ftoCompareRecordService.copyTortCompareRecords(projectId, taskId, personnelVO.getId(), patentNo);
+                //4.新增CompareLi
+                CompareLiterature compareLiterature = new CompareLiterature();
+                compareLiterature.setLiteratureNo(patentNo);
+                compareLiterature.setType(1);
+                compareLiterature.setProjectId(projectId);
+                compareLiterature.setProjectTaskId(taskId);
+                compareLiterature.setCreateId(personnelVO.getId());
+                compareLiteratures.add(compareLiterature);
+            }
+            if (!compareLiteratures.isEmpty()) {
+                compareLiteratureService.saveBatch(compareLiteratures);
+            }
+        }
+        //4.发送邮件通知协同人和抄送人
+        //TODO
+        return projectTask.getId();
+    }
 }

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

@@ -152,18 +152,24 @@ public class TortCompareRecordService extends ServiceImpl<FTOCompareRecordMapper
         // 删除特征
         List<Integer> ids = new ArrayList<>();
         if (!featureIds.isEmpty()) {
-            ids = this.deleteFeatures(projectId, tortDTOS, featureIds);
+            this.deleteFeatures(tortDTOS, featureIds);
+            // 删除对比记录
+            LambdaQueryWrapper<FTOCompareRecord> deleteWrapper2 = new LambdaQueryWrapper<>();
+            deleteWrapper2.eq(FTOCompareRecord::getProjectId, projectId)
+                    .eq(FTOCompareRecord::getIfFinal, true);
+            this.remove(deleteWrapper2);
+            // 更新剩余特征和对比结果
+            ids = this.updateFeatures(projectId, featureIds, tortDTOS);
         }
         return ids;
     }
 
     /**
      * 删除特征
-     * @param projectId
      * @param tortDTOS
      * @param featureIds
      */
-    public List<Integer> deleteFeatures(Integer projectId,  List<TortDTO> tortDTOS, List<Integer> featureIds){
+    public void deleteFeatures(List<TortDTO> tortDTOS, List<Integer> featureIds){
         //新的特征和对比结果集合过滤出新的特征id
         List<Integer> currentIds = tortDTOS.stream().map(TortDTO::getFeatureId).collect(Collectors.toList());
         // 比对并删除featureIds中多余的数据（featureIds比currentIds多的）
@@ -177,14 +183,6 @@ public class TortCompareRecordService extends ServiceImpl<FTOCompareRecordMapper
             deleteWrapper.in(Feature::getId, idsToDelete);
             featureService.remove(deleteWrapper);
         }
-        // 删除对比记录
-        LambdaQueryWrapper<FTOCompareRecord> deleteWrapper2 = new LambdaQueryWrapper<>();
-        deleteWrapper2.eq(FTOCompareRecord::getProjectId, projectId)
-                .eq(FTOCompareRecord::getIfFinal, true);
-        this.remove(deleteWrapper2);
-        // 更新剩余特征和对比结果
-        List<Integer> ids = this.updateFeatures(projectId, featureIds, tortDTOS);
-        return ids;
     }
 
     /**