实时推送代码

PAS/src/main/java/cn/cslg/pas/common/core/CreateTaskThread.java

@@ -68,20 +68,20 @@ public class CreateTaskThread implements InitializingBean {
         Thread threadSetPatentPicture = new Thread(pantentQueueService::setPatentImage);
         threadSetPatentPicture.start();
 
-        //消费者1线程（摘要附图）
-        Thread threadConsumer1 = new Thread(pantentQueueService::pushPatentImageToDB);
+        //消费者1线程（著录项目）
+        Thread threadConsumer1 = new Thread(pantentQueueService::pushPatentZhuLuToDB);
         threadConsumer1.start();
-        //消费者2线程（著录项目）
-        Thread threadConsumer2 = new Thread(pantentQueueService::pushPatentZhuLuToDB);
+        //消费者2线程（权利要求）
+        Thread threadConsumer2 = new Thread(pantentQueueService::pushPatentRightToDB);
         threadConsumer2.start();
-        //消费者3线程（权利要求）
-        Thread threadConsumer3 = new Thread(pantentQueueService::pushPatentRightToDB);
+        //消费者3线程（说明书文本）
+        Thread threadConsumer3 = new Thread(pantentQueueService::pushPatentInstructionTextToDB);
         threadConsumer3.start();
-        //消费者4线程（说明书文本消费者）
-        Thread threadConsumer4 = new Thread(pantentQueueService::pushPatentInstructionTextToDB);
+        //消费者4线程（说明书pdf）
+        Thread threadConsumer4 = new Thread(pantentQueueService::pushPatentInstructionPDFToDB);
         threadConsumer4.start();
-        //消费者5线程（说明书pdf消费者）
-        Thread threadConsumer5 = new Thread(pantentQueueService::pushPatentInstructionPDFToDB);
+        //消费者5线程（摘要附图）
+        Thread threadConsumer5 = new Thread(pantentQueueService::pushPatentImageToDB);
         threadConsumer5.start();
 
     }

PAS/src/main/java/cn/cslg/pas/common/model/dto/QueryTaskDTO.java

@@ -28,6 +28,14 @@ public class QueryTaskDTO extends PageDTO2 implements Serializable {
      */
     private String createName;
     /**
+     * 当前登陆人id
+     */
+    private Integer createId;
+    /**
+     * 创建人ids
+     */
+    private List<Integer> personIds;
+    /**
      * 任务类型1（0普通任务 1定时任务）
      */
     private Integer taskType;

PAS/src/main/java/cn/cslg/pas/common/model/vo/QueryTaskVO.java

@@ -1,5 +1,6 @@
 package cn.cslg.pas.common.model.vo;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
@@ -60,10 +61,14 @@ public class QueryTaskVO implements Serializable {
      */
     private Long fileSize;
     /**
-     * 成功条数
+     * 完成条数（非成功条数）
      */
     private Integer successNum;
     /**
+     * 成功条数
+     */
+    private Integer trueSuccessNum;
+    /**
      * 失败条数
      */
     private Integer defaultNum;
@@ -75,6 +80,10 @@ public class QueryTaskVO implements Serializable {
      * 创建时间
      */
     private Date createTime;
+    /**
+     * 所属任务条件id
+     */
+    private Integer taskConditionId;
 
     //以上若是网站导入的任务，则以下为关联任务条件表数据；以上若是Excel导入的任务，则以下都是null
     /**

PAS/src/main/java/cn/cslg/pas/controller/TaskController.java

@@ -92,7 +92,7 @@ public class TaskController {
 
     @PostMapping("/pause")
     @Operation(summary = "暂停任务")
-    public Response pauseTask(Integer taskId) {
+    public Response pauseTask(Integer taskId) throws InterruptedException {
         log.info("开始处理【暂停任务】的请求，请求参数为：taskId={}", taskId);
         taskService.pauseTask(taskId);
         return Response.ok("暂停任务成功");

PAS/src/main/java/cn/cslg/pas/domain/QuestionRecord.java

@@ -0,0 +1,43 @@
+package cn.cslg.pas.domain;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 问题记录表实体类
+ *
+ * @Author chenyu
+ * @Date 2023/7/8
+ */
+@TableName(value = "question_records")
+@Accessors(chain = true)
+@Data
+public class QuestionRecord implements Serializable {
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+    /**
+     * 失败的专利号
+     */
+    @TableField(value = "patent_no")
+    private String patentNo;
+    /**
+     * 所属任务id
+     */
+    @TableField(value = "task_id")
+    private Integer taskId;
+    /**
+     * 失败字段
+     */
+    @TableField(value = "cell")
+    private Integer cell;
+
+}

PAS/src/main/java/cn/cslg/pas/domain/Task.java

@@ -87,11 +87,16 @@ public class Task extends BaseEntity<Task> {
     @TableField("filesize")
     private Long fileSize;
     /**
-     * 成功条数
+     * 完成条数（非成功条数）
      */
     @TableField("success_num")
     private Integer successNum;
     /**
+     * 成功条数
+     */
+    @TableField("true_success_num")
+    private Integer trueSuccessNum;
+    /**
      * 失败条数
      */
     @TableField("default_num")

PAS/src/main/java/cn/cslg/pas/mapper/QuestionRecordMapper.java

@@ -0,0 +1,21 @@
+package cn.cslg.pas.mapper;
+
+import cn.cslg.pas.domain.QuestionRecord;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * 问题记录表的Mapper层接口
+ *
+ * @Author chenyu
+ * @Date 2023/7/8
+ */
+public interface QuestionRecordMapper extends BaseMapper<QuestionRecord> {
+    /**
+     * 根据任务id查询并统计失败专利数量
+     *
+     * @param taskId 任务id
+     * @return 返回统计到的数量
+     */
+    int selectDefaultNum(Integer taskId);
+
+}

PAS/src/main/java/cn/cslg/pas/mapper/TaskMapper.java

@@ -1,11 +1,15 @@
 package cn.cslg.pas.mapper;
 
+import cn.cslg.pas.common.model.dto.QueryTaskDTO;
+import cn.cslg.pas.common.model.vo.QueryTaskVO;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.common.model.vo.TaskVO;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 
+import java.util.List;
+
 /**
  * <p>
  * 任务表 Mapper 接口
@@ -17,4 +21,14 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 public interface TaskMapper extends BaseMapper<Task> {
 
     IPage<Task> getPageList(Page<Task> page, TaskVO params);
+
+    /**
+     * 根据条件查询任务列表
+     * @param queryTaskDTO 查询条件
+     * @return 返回查询到的数据列表
+     */
+    List<QueryTaskVO> queryTasks(QueryTaskDTO queryTaskDTO);
+
+
+
 }

PAS/src/main/java/cn/cslg/pas/mapper/asso/AssoOsTaskQrtzTaskMapper.java

@@ -11,6 +11,6 @@ import org.springframework.stereotype.Repository;
  * @Date 2023/6/12
  */
 @Repository
-public interface AssoOsTaskQrtzTaskMapper extends BaseMapper<TaskCondition> {
+public interface TaskConditionMapper extends BaseMapper<TaskCondition> {
 
 }

PAS/src/main/java/cn/cslg/pas/service/ITaskService.java

@@ -12,7 +12,7 @@ public interface ITaskService {
      *
      * @param taskId 任务id
      */
-    void pauseTask(Integer taskId);
+    void pauseTask(Integer taskId) throws InterruptedException;
 
     /**
      * 继续任务

PAS/src/main/java/cn/cslg/pas/service/ProjectService.java

@@ -12,7 +12,7 @@ import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.ProductMapper;
 import cn.cslg.pas.mapper.ProjectMapper;
 import cn.cslg.pas.mapper.asso.AssoStructurePatentMapper;
-import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import cn.cslg.pas.service.asso.TaskConditionService;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.IterUtil;
 import cn.hutool.core.date.DateField;
@@ -81,7 +81,7 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
     private final PatentClassNumberLinkService patentClassNumberLinkService;
     private final ProjectPatentLinkService projectPatentLinkService;
     private final TaskService taskService;
-    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final TaskConditionService taskConditionService;
     private final PatentImageService patentImageService;
     private final ProjectFieldPatentLinkService projectFieldPatentLinkService;
     private final ProjectFolderService projectFolderService;
@@ -544,11 +544,12 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
         patentApplicantMergeLinkService.deleteByProjectId(id);
         //陈宇 ↓ 删除专题库产品架构标引表（asso_structure_patent）数据
         assoStructurePatentMapper.deleteByProjectId(id);
-        //陈宇 ↓ 删除任务表（os_task）数据
+        //陈宇 ↓ 删除任务表（os_task）和任务条件关联表（asso_osTask_qrtzTask）数据
         List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getProjectId, id));
+        //陈宇 ↓ 删除任务表（os_task）数据
         taskService.removeByIds(tasks.stream().map(Task::getId).collect(Collectors.toList()));
-        //陈宇 ↓ 删除任务和任务条件关联表（asso_osTask_qrtzTask）数据
-        assoOsTaskQrtzTaskService.removeByIds(tasks.stream().map(Task::getTaskConditionId).collect(Collectors.toList()));
+        //陈宇 ↓ 删除任务条件关联表（asso_osTask_qrtzTask）数据
+        taskConditionService.removeByIds(tasks.stream().map(Task::getTaskConditionId).collect(Collectors.toList()));
 
         return Response.success();
     }

PAS/src/main/java/cn/cslg/pas/service/TaskService.java

@@ -13,7 +13,7 @@ import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.domain.asso.TaskCondition;
 import cn.cslg.pas.mapper.TaskMapper;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
-import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import cn.cslg.pas.service.asso.TaskConditionService;
 import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataEpo;
 import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataExcel;
 import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
@@ -60,7 +60,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     private final ExcutePatentDataExcel excutePatentDataExcel;
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final ExcutePatentDataStar excutePatentDataStar;
-    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final TaskConditionService taskConditionService;
 
 
     public String getFileUrl(Integer id) {
@@ -223,6 +223,32 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         return Response.success(true);
     }
 
+    public void deleteTask(Integer taskId) {
+        log.info("开始处理【删除任务】的业务，参数为：id={}", taskId);
+
+        //检查任务是否存在，若不存在则提示用户"删除失败，当前任务已不存在，请尝试刷新页面"
+        Task task = this.getById(taskId);
+        if (task == null) {
+            ThrowException.throwXiaoShiException("删除失败，当前任务已不存在，请尝试刷新页面");
+        }
+
+        //检查任务状态
+        //若是已完成或已暂停，则直接删除
+        if (task.getStatus().equals(2) || task.getStatus().equals(4)) {
+            this.removeById(task);
+            //若是网站导入任务，则还要删除任务条件表对应数据
+            if (task.getType().equals(3) || task.getType().equals(4)) {
+                taskConditionService.removeById(task.getTaskConditionId());
+            }
+        }
+
+        //若是等待中，则先要将生产者队列中的该任务剔除，再删除
+
+        //若是进行中，则不允许删除，并提示用户"当前任务正在进行中，无法删除"
+
+
+    }
+
     public IPage<Task> getPageList(TaskVO params) throws IOException {
         String createName = params.getCreateName();
         //如果此次查询是要根据创建人名称查询则👇
@@ -270,7 +296,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         }
         //根据任务类型1（0普通任务 1定时任务）查询
         if (queryTaskDTO.getTaskType() != null) {
-            List<TaskCondition> taskConditions = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<TaskCondition>().eq(TaskCondition::getTaskType, queryTaskDTO.getTaskType()));
+            List<TaskCondition> taskConditions = taskConditionService.list(new LambdaQueryWrapper<TaskCondition>().eq(TaskCondition::getTaskType, queryTaskDTO.getTaskType()));
             List<Integer> assoOsTaskQrtzTaskIds = taskConditions.stream().map(TaskCondition::getId).collect(Collectors.toList());
             //若没有，则ids集合添加一个元素-1（防止执行时sql报错：where qrtz_task_id in ()）
             if (assoOsTaskQrtzTaskIds.size() == 0) {
@@ -330,7 +356,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         List<Integer> assoOsTaskQrtzTaskIds = tasks.stream().filter(item -> item.getType().equals(3) || item.getType().equals(4)).map(Task::getTaskConditionId).collect(Collectors.toList());
         //若有网站导入的任务
         if (assoOsTaskQrtzTaskIds.size() > 0) {
-            List<TaskCondition> taskConditions = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<TaskCondition>().in(TaskCondition::getId, assoOsTaskQrtzTaskIds));
+            List<TaskCondition> taskConditions = taskConditionService.list(new LambdaQueryWrapper<TaskCondition>().in(TaskCondition::getId, assoOsTaskQrtzTaskIds));
             //遍历装载
             for (Task task : tasks) {
                 QueryTaskVO queryTaskVO = new QueryTaskVO();
@@ -448,27 +474,23 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
      * @param taskId 任务id
      */
     @Override
-    public void pauseTask(Integer taskId) {
+    public void pauseTask(Integer taskId) throws InterruptedException {
         log.info("开始处理【暂停任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试暂停的任务是否存在，若不存在则提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
+        //检查任务是否存在，若不存在则提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试暂停的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已不存在，请尝试刷新页面");
             return;
         }
-        //2.检查尝试暂停的任务是否已处于暂停状态，若是则提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
-        if (task.getStatus().equals(4)) {
-            ThrowException.throwXiaoShiException("暂停失败，当前任务已处于暂停状态，请尝试刷新页面");
-        }
 
-        //3.检查尝试暂停的任务是否处于进行中状态，若不是则提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
+        //检查任务是否处于进行中状态，若不是则提示用户 "暂停失败，当前任务不处于进行中状态，请尝试刷新页面"
         if (!task.getStatus().equals(1)) {
-            ThrowException.throwXiaoShiException("暂停失败，当前任务已结束或未开始，请尝试刷新页面");
+            ThrowException.throwXiaoShiException("暂停失败，当前任务未进行，请尝试刷新页面");
         }
 
-        //4.任务表将任务状态修改为4暂停
+        //任务表将任务状态修改为4暂停
         Task updateTask = new Task();
         updateTask.setId(taskId);
         updateTask.setStatus(4);
@@ -478,7 +500,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             ThrowException.throwXiaoShiException("暂停失败，服务器忙请稍后再试");
         }
 
-        //5.将生产者生产专利中的公共任务状态改为暂停
+        //将生产者生产专利中的公共任务状态改为暂停
         if (task.getType() == 1) {
             excutePatentDataExcel.setTaskStatus(taskId, 4);
         } else if (task.getType() == 3) {
@@ -487,13 +509,17 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             excutePatentDataStar.setTaskStatus(taskId, 4);
         }
 
-        try {
+
+        if (task.getType().equals(3) || task.getType().equals(4)) {
+            //等上2秒（上述代码虽然使得生产暂停，但是生产暂停前正在存入生产队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
             Thread.sleep(2000);
-        } catch (InterruptedException e) {
-            ThrowException.throwXiaoShiException("暂停失败，未知错误");
+            pantentQueueService.setQueueRemoveTasks(taskId);
         }
-        //6.将消费者的专利队列中所有该任务的专利剔除
-        pantentQueueService.consumerQueueDeleteTasks(taskId);
+
+        //等上2秒（上述代码虽然使得生产暂停，但是生产暂停前已生产的专利正在存入消费者队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
+        Thread.sleep(2000);
+        //将消费者的专利队列中所有该任务的专利剔除
+        pantentQueueService.consumerQueueRemoveTasks(taskId);
 
         log.info("暂停任务成功");
 
@@ -508,33 +534,41 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public void continueTask(Integer taskId) {
         log.info("开始处理【继续任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试继续的任务是否存在，若不存在则提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
+        //检查任务是否存在，若不存在则提示用户 "继续任务失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试继续的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
-            ThrowException.throwXiaoShiException("继续失败，当前任务已不存在，请尝试刷新页面");
+            ThrowException.throwXiaoShiException("继续任务失败，当前任务已不存在，请尝试刷新页面");
             return;
         }
 
-        //2.检查尝试继续的任务是否处于暂停状态，若不是则提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
+        //检查任务是否处于暂停状态，若不是则提示用户 "继续任务失败，当前任务未暂停，请尝试刷新页面"
         if (!task.getStatus().equals(4)) {
-            ThrowException.throwXiaoShiException("继续失败，当前任务未暂停，请尝试刷新页面");
+            ThrowException.throwXiaoShiException("继续任务失败，当前任务未暂停，请尝试刷新页面");
         }
 
-        //3.继续任务（将任务状态改为0即等待中）
+        //继续任务（将任务状态改为0即等待中）
         Task updateTask = new Task();
         updateTask.setId(taskId);
         updateTask.setStatus(0);
         log.info("任务表修改数据，继续任务，任务id={}", taskId);
         boolean updateResult = this.updateById(updateTask);
         if (!updateResult) {
-            ThrowException.throwXiaoShiException("继续失败，服务器忙请稍后再试");
+            ThrowException.throwXiaoShiException("继续任务失败，服务器忙请稍后再试");
         }
 
-        //4.将当前任务添加进生产者任务队列进行排队，并唤醒生产者线程
+        //将当前任务添加进生产者任务队列进行排队，并唤醒生产者线程
         pantentQueueService.taskQueueAddTask(new ArrayList<>(Arrays.asList(taskId)));
-        //5.将生产者生产专利类中的公共任务状态改为暂停
-        excutePatentDataExcel.setTaskStatus(taskId, 0);
+
+        //将生产者生产专利类中的公共任务状态从暂停改为0
+        if (task.getType().equals(1) && excutePatentDataExcel.getpTaskId().equals(task.getId())) {
+            excutePatentDataExcel.setTaskStatus(taskId, 0);
+        } else if (task.getType().equals(3) && excutePatentDataEpo.getpTaskId().equals(task.getId())) {
+            excutePatentDataEpo.setTaskStatus(taskId, 0);
+        } else if (task.getType().equals(4) && excutePatentDataStar.getpTaskId().equals(task.getId())) {
+            excutePatentDataStar.setTaskStatus(taskId, 0);
+        }
+
         pantentQueueService.awakeTasktch();
 
         log.info("继续任务成功");

PAS/src/main/java/cn/cslg/pas/service/asso/AssoOsTaskQrtzTaskService.java

@@ -1,7 +1,7 @@
 package cn.cslg.pas.service.asso;
 
 import cn.cslg.pas.domain.asso.TaskCondition;
-import cn.cslg.pas.mapper.asso.AssoOsTaskQrtzTaskMapper;
+import cn.cslg.pas.mapper.asso.TaskConditionMapper;
 import cn.cslg.pas.service.IAssoOsTaskQrtzTaskService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.extern.slf4j.Slf4j;
@@ -15,7 +15,7 @@ import org.springframework.stereotype.Service;
  */
 @Slf4j
 @Service
-public class AssoOsTaskQrtzTaskService extends ServiceImpl<AssoOsTaskQrtzTaskMapper, TaskCondition> implements IAssoOsTaskQrtzTaskService {
+public class TaskConditionService extends ServiceImpl<TaskConditionMapper, TaskCondition> implements IAssoOsTaskQrtzTaskService {
 
 
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/ExcutePatentDataEpo.java

@@ -10,7 +10,7 @@ import cn.cslg.pas.domain.*;
 import cn.cslg.pas.domain.asso.TaskCondition;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.service.*;
-import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import cn.cslg.pas.service.asso.TaskConditionService;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.spire.pdf.FileFormat;
@@ -44,7 +44,7 @@ import java.util.List;
 public class ExcutePatentDataEpo implements IExcutePatentData {
     private final FileUtils fileUtils;
     private final PantentQueueService pantentQueueService;
-    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final TaskConditionService taskConditionService;
     private final OutInterfaceService outInterfaceService;
     private final PatentInstructionService patentInstructionService;
     private final PatentAgencyService patentAgencyService;
@@ -63,7 +63,7 @@ public class ExcutePatentDataEpo implements IExcutePatentData {
     @Override
     public void startExcute(Task task) throws IOException {
         //从任务关联网站导入任务表中取出当前任务
-        List<TaskCondition> taskConditions = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<TaskCondition>().eq(TaskCondition::getTaskId, task.getId()));
+        List<TaskCondition> taskConditions = taskConditionService.list(new LambdaQueryWrapper<TaskCondition>().eq(TaskCondition::getTaskId, task.getId()));
         TaskCondition taskCondition = taskConditions.get(0);
 
         //从任务数据中获取下载字段、检索式
@@ -581,4 +581,12 @@ public class ExcutePatentDataEpo implements IExcutePatentData {
         this.pTaskStatus = taskStatus;
     }
 
+    public Integer getpTaskId() {
+        return pTaskId;
+    }
+
+    public Integer getpTaskStatus() {
+        return pTaskStatus;
+    }
+
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/ExcutePatentDataExcel.java

@@ -8,6 +8,7 @@ import cn.cslg.pas.common.utils.JsonUtils;
 import cn.cslg.pas.common.utils.ReadExcelUtils;
 import cn.cslg.pas.domain.PatentData;
 import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.service.TaskService;
 import lombok.RequiredArgsConstructor;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.springframework.stereotype.Service;
@@ -28,6 +29,7 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
     private final ExcuteUploadSettingService excuteUploadSettingService;
     private final ExcuteDataToVOService excuteDataToVOService;
     private final PantentQueueService pantentQueueService;
+    private final TaskService taskService;
     private Integer pTaskId = 0;
     private Integer pTaskStatus = 0;
 
@@ -39,28 +41,38 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
      */
     @Override
     public void startExcute(Task task) throws IOException {
-        //从任务中取出文件路径、总条数、成功条数、前台参数json
-        String filePath = fileUtils.getPath(task.getUrl());
-        Integer total = task.getTotal();
-        int lastIndex = task.getSuccessNum();
-        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(task.getPramJson(), ProjectImportPatentVO.class);
+        try {
+            //从任务中取出文件路径、总条数、成功条数、前台参数json
+            String filePath = fileUtils.getPath(task.getUrl());
+            Integer total = task.getTotal();
+            int lastIndex = task.getSuccessNum();
+            ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(task.getPramJson(), ProjectImportPatentVO.class);
 
-        //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
-        List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
-        //解析Excel文件获得工作簿
-        Sheet sheet = ReadExcelUtils.readExcel(filePath);
-        //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
-        for (int i = lastIndex; i < total; i++) {
-            //判断若任务状态为已暂停，则结束生产
-            if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
-                return;
-            }
-            PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
-            //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
-            UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
+            //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
+            List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
+            //解析Excel文件获得工作簿
+            Sheet sheet = ReadExcelUtils.readExcel(filePath);
+            //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
+            for (int i = lastIndex; i < total; i++) {
+                //判断若任务状态为已暂停，则结束生产
+                if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
+                    return;
+                }
+                PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
+                //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
+                UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
 
-            //专利丢入5个消费者队列，并唤醒5个消费者线程
-            pantentQueueService.patentToQueue(task, uploadParamsVO);
+                //专利丢入消费者队列，并唤醒消费者线程
+                pantentQueueService.patentToQueue(task, uploadParamsVO);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            //生产消费到一半时，发生错误异常，将任务状态置为完成
+            task = taskService.getById(task.getId());
+            if (task.getStatus().equals(1)) {
+                task.setStatus(2);
+                taskService.updateById(task);
+            }
         }
     }
 
@@ -69,4 +81,12 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
         this.pTaskStatus = taskStatus;
     }
 
+    public Integer getpTaskId() {
+        return pTaskId;
+    }
+
+    public Integer getpTaskStatus() {
+        return pTaskStatus;
+    }
+
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/ExcutePatentDataStar.java

@@ -9,6 +9,7 @@ import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.RemoveHtmlTagsUtils;
 import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.*;
+import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
 import com.alibaba.fastjson.JSON;
@@ -42,6 +43,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     private final FileUtils fileUtils;
     private final PantentQueueService pantentQueueService;
     private final UploadPatentBatchService uploadPatentBatchService;
+    private final TaskService taskService;
     private Integer pTaskId = 0;
     private Integer pTaskStatus = 0;
 
@@ -52,117 +54,130 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      */
     @Override
     public void startExcute(Task task) throws IOException {
-        Integer successNum = task.getSuccessNum();  //成功条数（即上一次下载到的位置）
-        Integer total = task.getTotal();  //专利总数量
-        String conditions = task.getConditions();  //检索式
-        String orderBy = task.getOrderBy();  //排序字段
-        String orderByType = task.getOrderByType();  //排序类型
-        String dbType = task.getDBType();  //检索数据库类型
-        List<String> cells = task.getConfigCells();  //下载字段
-        Integer startNumber = task.getStartNumber();  //下载起始条数位置
-        Integer endNumber = task.getEndNumber();  //下载终止条数位置
-        List<String> isAddPatentNos = task.getIsAddPatentNos();  //需要额外下载的专利号
-        List<String> isDeletePatentNos = task.getIsDeletePatentNos();  //起止条数中不需要下载的专利号
-
-        //下载isAdd中的专利 ↓
-        if (isAddPatentNos != null && isAddPatentNos.size() > 0) {
-            downLoadIsAddPatentNos(isAddPatentNos, task, orderBy, orderByType, dbType, cells);
-        }
-
-        //下载起止条数中的专利 ↓
-        if (endNumber != 0) {
-            int startPage;  //检索开始页数
-            int startNum;  //检索开始页数的开始专利位置
-            int endPage;  //检索结束页数
-            int endNum;  //检索结束页数的结束专利位置
-            if (startNumber % 50 != 0) {
-                startPage = startNumber / 50 + 1;
-                startNum = startNumber % 50;
-            } else {
-                startPage = startNumber / 50;
-                startNum = 50;
-            }
-            if (endNumber % 50 != 0) {
-                endPage = endNumber / 50 + 1;
-                endNum = endNumber % 50;
-            } else {
-                endPage = endNumber / 50;
-                endNum = 50;
+        try {
+            Integer successNum = task.getSuccessNum();  //成功条数（即上一次下载到的位置）
+            String conditions = task.getConditions();  //检索式
+            String orderBy = task.getOrderBy();  //排序字段
+            String orderByType = task.getOrderByType();  //排序类型
+            String dbType = task.getDBType();  //检索数据库类型
+            List<String> cells = task.getConfigCells();  //下载字段
+            Integer startNumber = task.getStartNumber();  //下载起始条数位置
+            Integer endNumber = task.getEndNumber();  //下载终止条数位置
+            List<String> isAddPatentNos = task.getIsAddPatentNos();  //需要额外下载的专利号
+            List<String> isDeletePatentNos = task.getIsDeletePatentNos();  //起止条数中不需要下载的专利号
+
+            //下载起止条数中的专利 ↓
+            //若成功条数不为0，即表示此次任务为暂停后继续执行，则起始条数 startNumber为成功条数 + 1
+            //endNumber - startNumber + 1 - isDeletePatentNos.size()
+            if (successNum > 0) {
+                startNumber = successNum + 1;
             }
 
-            //根据计算出的起止页数，一页一页检索
-            int pageNum = startPage;
-            for (int i = startPage; i <= endPage; i++) {
-                PatentStarListDto patentStarListDto = new PatentStarListDto()
-                        .setCurrentQuery(conditions)
-                        .setOrderBy(orderBy)
-                        .setOrderByType(orderByType)
-                        .setPageNum(pageNum++)
-                        .setRowCount(50)
-                        .setDBType(dbType);
-                //调用一般接口返回一批专利著录相关数据
-                Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
-                if (resultMap == null || (Integer) resultMap.get("total") == 0) {
-                    ThrowException.throwXiaoShiException("未检索到相关专利");
+            if (endNumber > 0) {
+                int startPage;  //检索开始页数
+                int startNum;  //检索开始页数的开始专利位置
+                int endPage;  //检索结束页数
+                int endNum;  //检索结束页数的结束专利位置
+                if (startNumber % 50 != 0) {
+                    startPage = startNumber / 50 + 1;
+                    startNum = startNumber % 50;
+                } else {
+                    startPage = startNumber / 50;
+                    startNum = 50;
+                }
+                if (endNumber % 50 != 0) {
+                    endPage = endNumber / 50 + 1;
+                    endNum = endNumber % 50;
+                } else {
+                    endPage = endNumber / 50;
+                    endNum = 50;
                 }
 
-                List<StarPatentVO> starPatents = (List<StarPatentVO>) resultMap.get("records");
-                //遍历这一页的专利
-                for (int j = 0; j < starPatents.size(); j++) {
-                    //判断若任务状态为已暂停，则结束生产
-                    if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
-                        return;
-                    }
-                    //若是第一页，并且还没遍历到所需起始专利位置，则跳过，继续遍历下一个，直到遍历到起所需起始专利，才开始下载
-                    if (i == startPage && j < startNum - 1) {
-                        continue;
-                    }
-                    //若是最后一页，并且遍历到了所需终止专利位置，则下载结束
-                    if (i == endPage && j == endNum) {
-                        return;
+                //根据计算出的起止页数，一页一页检索
+                int pageNum = startPage;
+                for (int i = startPage; i <= endPage; i++) {
+                    PatentStarListDto patentStarListDto = new PatentStarListDto()
+                            .setCurrentQuery(conditions)
+                            .setOrderBy(orderBy)
+                            .setOrderByType(orderByType)
+                            .setPageNum(pageNum++)
+                            .setRowCount(50)
+                            .setDBType(dbType);
+                    //调用一般接口返回一批专利著录相关数据
+                    Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
+                    if (resultMap == null || (Integer) resultMap.get("total") == 0) {
+                        ThrowException.throwXiaoShiException("未检索到相关专利");
                     }
-                    //若当前遍历到的专利号是需要删除的专利，则跳过，不下载它
-                    if (isDeletePatentNos != null && isDeletePatentNos.size() > 0 && isDeletePatentNos.contains(starPatents.get(j).getApplicationNo())) {
-                        continue;
-                    }
-                    try {
+
+                    List<StarPatentVO> starPatents = (List<StarPatentVO>) resultMap.get("records");
+                    //遍历这一页的专利
+                    for (int j = 0; j < starPatents.size(); j++) {
+                        //若任务状态为已暂停，则结束生产
+                        if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
+                            return;
+                        }
+                        //若还没到开始页的开始位置，则跳过，不下载它
+                        if (i == startPage && j < startNum - 1) {
+                            continue;
+                        }
+                        //若到了结束页的结束位置
+                        if (i == endPage && j == endNum) {
+                            break;
+                        }
+                        //若当前遍历到的专利号是需要删除的专利，则跳过，不下载它
+                        if (isDeletePatentNos != null && isDeletePatentNos.size() > 0 && isDeletePatentNos.contains(starPatents.get(j).getApplicationNo())) {
+                            continue;
+                        }
+
                         UploadParamsVO uploadParamsVO = new UploadParamsVO();
-                        setPatentZhuLu(starPatents.get(j), uploadParamsVO);
-                        //保存专利基础数据（专利表"os_patent"），因为需要先拿到专利id供其他消费者部分使用
+                        Patent patent = new Patent();
+                        uploadParamsVO.setPatent(patent);
+                        uploadParamsVO.getPatent().setPatentNo(starPatents.get(j).getPatentNo());
                         uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
                         PQueueData pQueueData = new PQueueData()
                                 .setTask(task)
                                 .setStarPatent(starPatents.get(j))
                                 .setUploadParamsVO(uploadParamsVO);
-                        //装载专利著录
+
+                        //专利丢入著录生产者队列，并唤醒著录生产者线程
                         if (cells.contains("1")) {
                             pantentQueueService.zhuluToPQueue(pQueueData);
                         }
-                        //装载权要
+                        //专利丢入权要生产者队列，并唤醒权要生产者线程
                         if (cells.contains("2")) {
                             pantentQueueService.rightToPQueue(pQueueData);
                         }
-                        //装载说明书文本
+                        //专利丢入说明书文本生产者队列，并唤醒说明书文本生产者线程
                         if (cells.contains("3")) {
                             pantentQueueService.instructionTextToPQueue(pQueueData);
                         }
-                        //装载说明书pdf
+                        //专利丢入说明书pdf生产者队列，并唤醒说明书pdf生产者线程
                         if (cells.contains("4")) {
                             pantentQueueService.instructionPDFToPQueue(pQueueData);
                         }
-                        //装载摘要附图
+                        //专利丢入摘要附图生产者队列，并唤醒摘要附图生产者线程
                         if (cells.contains("6")) {
                             pantentQueueService.imageToPQueue(pQueueData);
                         }
 
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                        //继续下一个专利
                     }
 
                 }
+            }
+
+            //下载isAdd中的专利 ↓
+            if (isAddPatentNos != null && isAddPatentNos.size() > 0) {
+                downLoadIsAddPatentNos(isAddPatentNos, task, orderBy, orderByType, dbType, cells);
+            }
 
+        } catch (IOException e) {
+            e.printStackTrace();
+            //生产消费到一半时，发生错误异常，将任务状态置为完成
+            task = taskService.getById(task.getId());
+            if (task.getStatus().equals(1)) {
+                task.setStatus(2);
+                taskService.updateById(task);
             }
         }
 
@@ -177,24 +192,24 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      */
     public void setPatentZhuLu(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
         //以下 ↓装载的是调用"一般检索"接口返回的专利相关数据
-        Patent patent = new Patent();
+        //Patent patent = new Patent();
         //装载专利号
-        patent.setPatentNo(starPatent.getPatentNo());
+        uploadParamsVO.getPatent().setPatentNo(starPatent.getPatentNo());
         //装载摘要
-        patent.setAbstractStr(starPatent.getAbstractStr());
+        uploadParamsVO.getPatent().setAbstractStr(starPatent.getAbstractStr());
         //装载标题
-        patent.setName(starPatent.getName());
+        uploadParamsVO.getPatent().setName(starPatent.getName());
         //装载申请号
-        patent.setApplicationNo(starPatent.getApplicationNo());
+        uploadParamsVO.getPatent().setApplicationNo(starPatent.getApplicationNo());
         //装载申请日
         if (starPatent.getApplicationDate() != null && !starPatent.getApplicationDate().equals("")) {
-            patent.setApplicationDate(Integer.parseInt(starPatent.getApplicationDate()));
+            uploadParamsVO.getPatent().setApplicationDate(Integer.parseInt(starPatent.getApplicationDate()));
         }
         //装载公开号
-        patent.setPublicNo(starPatent.getPublicNo());
+        uploadParamsVO.getPatent().setPublicNo(starPatent.getPublicNo());
         //装载公开日
         if (starPatent.getPublicDate() != null && !starPatent.getPublicDate().equals(""))
-            patent.setPublicDate(Integer.parseInt(starPatent.getPublicDate()));
+            uploadParamsVO.getPatent().setPublicDate(Integer.parseInt(starPatent.getPublicDate()));
         //装载申请人
         if (starPatent.getApplicantStr() != null && !starPatent.getApplicantStr().equals("")) {
             uploadParamsVO.setPatentApplicantOriginalName(Arrays.asList(starPatent.getApplicantStr().split(";")));
@@ -215,13 +230,13 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         if (status != null) {
             //有效（有权）
             if (status == 1) {
-                patent.setSimpleStatus(3);
+                uploadParamsVO.getPatent().setSimpleStatus(3);
                 //失效（无权）
             } else if (status == 2) {
-                patent.setSimpleStatus(2);
+                uploadParamsVO.getPatent().setSimpleStatus(2);
                 //审中（审中）
             } else if (status == 3) {
-                patent.setSimpleStatus(1);
+                uploadParamsVO.getPatent().setSimpleStatus(1);
             }
         }
         uploadParamsVO.setPatentSimpleStatus(starPatent.getSimpleStatus());
@@ -237,56 +252,55 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         }
         //调用中国专利著录接口返回的专利相关数据最外层是一个集合"[]"，但是集合中只有一个对象"{}"，以下方式处理
         String chinaPatentZhuLuStr = patentStarApiService.getCnBibApi(appNo);
-        //chinaPatentZhuLuStr = chinaPatentZhuLuStr.substring(chinaPatentZhuLuStr.indexOf("["), chinaPatentZhuLuStr.lastIndexOf("[")).trim();
-        //ChinaPatentZhuLu chinaPatentZhuLu = JSONObject.parseObject(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
-        //以上暂无需处理 ↑ 以下 ↓有现成的json数组字符串转为集合方法
-        List<ChinaPatentZhuLu> chinaPatentZhuLus = JSON.parseArray(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
-        ChinaPatentZhuLu chinaPatentZhuLu = chinaPatentZhuLus.get(0);
-
-        //装载申请人地址
-        if (chinaPatentZhuLu.getDZ() != null && !chinaPatentZhuLu.getDZ().equals("")) {
-            ArrayList<String> patentApplicantOriginalAddresss = new ArrayList<>();
-            if (chinaPatentZhuLu.getDZ().contains(" ")) {
-                patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ().substring(chinaPatentZhuLu.getDZ().indexOf(" ") + 1));
-            } else {
-                patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ());
+        if (chinaPatentZhuLuStr != null && !chinaPatentZhuLuStr.trim().equals("")) {
+            List<ChinaPatentZhuLu> chinaPatentZhuLus = JSON.parseArray(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
+            ChinaPatentZhuLu chinaPatentZhuLu = chinaPatentZhuLus.get(0);
+
+            //装载申请人地址
+            if (chinaPatentZhuLu.getDZ() != null && !chinaPatentZhuLu.getDZ().equals("")) {
+                ArrayList<String> patentApplicantOriginalAddresss = new ArrayList<>();
+                if (chinaPatentZhuLu.getDZ().contains(" ")) {
+                    patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ().substring(chinaPatentZhuLu.getDZ().indexOf(" ") + 1));
+                } else {
+                    patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ());
+                }
+                uploadParamsVO.setPatentApplicantOriginalAddress(patentApplicantOriginalAddresss);
             }
-            uploadParamsVO.setPatentApplicantOriginalAddress(patentApplicantOriginalAddresss);
-        }
-        //装载代理人
-        if (chinaPatentZhuLu.getAT() != null && !chinaPatentZhuLu.getAT().equals("")) {
-            List<String> patentAgents = Arrays.asList(chinaPatentZhuLu.getAT().split(";"));
-            ArrayList<PatentAgent> patentAgentList = new ArrayList<>();
-            for (String n : patentAgents) {
-                PatentAgent patentAgent = new PatentAgent();
-                patentAgent.setName(n);
-                patentAgentList.add(patentAgent);
+            //装载代理人
+            if (chinaPatentZhuLu.getAT() != null && !chinaPatentZhuLu.getAT().equals("")) {
+                List<String> patentAgents = Arrays.asList(chinaPatentZhuLu.getAT().split(";"));
+                ArrayList<PatentAgent> patentAgentList = new ArrayList<>();
+                for (String n : patentAgents) {
+                    PatentAgent patentAgent = new PatentAgent();
+                    patentAgent.setName(n);
+                    patentAgentList.add(patentAgent);
+                }
+                uploadParamsVO.setPatentAgentList(patentAgentList);
             }
-            uploadParamsVO.setPatentAgentList(patentAgentList);
-        }
-        //装载代理机构地址
-        if (chinaPatentZhuLu.getAGN() != null && !chinaPatentZhuLu.getAGN().equals("")) {
-            String agencyAddress;
-            if (chinaPatentZhuLu.getAGN().contains(" ")) {
-                agencyAddress = chinaPatentZhuLu.getAGN().substring(0, chinaPatentZhuLu.getAGN().lastIndexOf(" "));
-            } else {
-                agencyAddress = chinaPatentZhuLu.getAGN();
+            //装载代理机构地址
+            if (chinaPatentZhuLu.getAGN() != null && !chinaPatentZhuLu.getAGN().equals("")) {
+                String agencyAddress;
+                if (chinaPatentZhuLu.getAGN().contains(" ")) {
+                    agencyAddress = chinaPatentZhuLu.getAGN().substring(0, chinaPatentZhuLu.getAGN().lastIndexOf(" "));
+                } else {
+                    agencyAddress = chinaPatentZhuLu.getAGN();
+                }
+                uploadParamsVO.getPatent().setAgencyId(agencyAddress);
             }
-            patent.setAgencyId(agencyAddress);
-        }
-        //装载发明人
-        if (chinaPatentZhuLu.getIV() != null && !chinaPatentZhuLu.getIV().equals("")) {
-            List<String> patentInventorNames = Arrays.asList(chinaPatentZhuLu.getIV().split(";"));
-            ArrayList<PatentInventor> patentInventors = new ArrayList<>();
-            for (String patentInventorName : patentInventorNames) {
-                PatentInventor patentInventor = new PatentInventor();
-                patentInventor.setName(patentInventorName);
-                patentInventors.add(patentInventor);
+            //装载发明人
+            if (chinaPatentZhuLu.getIV() != null && !chinaPatentZhuLu.getIV().equals("")) {
+                List<String> patentInventorNames = Arrays.asList(chinaPatentZhuLu.getIV().split(";"));
+                ArrayList<PatentInventor> patentInventors = new ArrayList<>();
+                for (String patentInventorName : patentInventorNames) {
+                    PatentInventor patentInventor = new PatentInventor();
+                    patentInventor.setName(patentInventorName);
+                    patentInventors.add(patentInventor);
+                }
+                uploadParamsVO.setPatentInventorList(patentInventors);
             }
-            uploadParamsVO.setPatentInventorList(patentInventors);
+            //装载优先权号、优先权国家、优先权日
+            uploadParamsVO.getPatent().setPriorityNo(chinaPatentZhuLu.getPR());
         }
-        //装载优先权号、优先权国家、优先权日
-        patent.setPriorityNo(chinaPatentZhuLu.getPR());
 
         //以下 ↓装载的是调用"获得同族专利"接口返回的专利相关数据
         if (starPatent.getPatentNo() != null && !starPatent.getPatentNo().equals("")) {
@@ -305,38 +319,39 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         PatentAffair patentAffair = new PatentAffair();
         String cnLegalApiStr = patentStarApiService.getCnLegalApi(appNo);
         List<ChinaLeagalStatus> chinaLeagalStatuses = JSON.parseArray(cnLegalApiStr, ChinaLeagalStatus.class);
-        ArrayList<KeyValueVO> lst = new ArrayList<>();
-        HashMap<Integer, String> nameMap = new HashMap<>();
-        HashMap<Integer, String> contentMap = new HashMap<>();
-        nameMap.put(0, "发生日期");
-        nameMap.put(1, "法律状态");
-        nameMap.put(2, "详细法律状态");
-        nameMap.put(3, "详细信息");
-        for (int i = 0; i < chinaLeagalStatuses.size(); i++) {
-            if (i == 0) {
-                patentAffair.setStatus(chinaLeagalStatuses.get(i).getLegalStatus());
-            }
-            contentMap.put(0, chinaLeagalStatuses.get(i).getLegalDate());
-            contentMap.put(1, chinaLeagalStatuses.get(i).getLegalStatus());
-            contentMap.put(2, chinaLeagalStatuses.get(i).getLegalStatusInfo());
-            contentMap.put(3, chinaLeagalStatuses.get(i).getDETAIL());
-            ArrayList<KeyValueVO.InpadocData> inpadocDatas = new ArrayList<>();
-            for (int j = 0; j < 4; j++) {
-                KeyValueVO.InpadocData inpadocData = new KeyValueVO.InpadocData();
-                inpadocData.setName(nameMap.get(j));
-                inpadocData.setContent(contentMap.get(j));
-                inpadocDatas.add(inpadocData);
+        if (chinaLeagalStatuses != null && chinaLeagalStatuses.size() > 0) {
+            ArrayList<KeyValueVO> lst = new ArrayList<>();
+            HashMap<Integer, String> nameMap = new HashMap<>();
+            HashMap<Integer, String> contentMap = new HashMap<>();
+            nameMap.put(0, "发生日期");
+            nameMap.put(1, "法律状态");
+            nameMap.put(2, "详细法律状态");
+            nameMap.put(3, "详细信息");
+            for (int i = 0; i < chinaLeagalStatuses.size(); i++) {
+                if (i == 0) {
+                    patentAffair.setStatus(chinaLeagalStatuses.get(i).getLegalStatus());
+                }
+                contentMap.put(0, chinaLeagalStatuses.get(i).getLegalDate());
+                contentMap.put(1, chinaLeagalStatuses.get(i).getLegalStatus());
+                contentMap.put(2, chinaLeagalStatuses.get(i).getLegalStatusInfo());
+                contentMap.put(3, chinaLeagalStatuses.get(i).getDETAIL());
+                ArrayList<KeyValueVO.InpadocData> inpadocDatas = new ArrayList<>();
+                for (int j = 0; j < 4; j++) {
+                    KeyValueVO.InpadocData inpadocData = new KeyValueVO.InpadocData();
+                    inpadocData.setName(nameMap.get(j));
+                    inpadocData.setContent(contentMap.get(j));
+                    inpadocDatas.add(inpadocData);
+                }
+                KeyValueVO keyValueVO = new KeyValueVO();
+                keyValueVO.setInpadocData(inpadocDatas);
+                lst.add(keyValueVO);
             }
-            KeyValueVO keyValueVO = new KeyValueVO();
-            keyValueVO.setInpadocData(inpadocDatas);
-            lst.add(keyValueVO);
+            //装载事务表的status（公开|授权|驳回|权力转移。。。）
+            String content = JSONObject.toJSONString(lst);
+            patentAffair.setContent(content);
+            uploadParamsVO.setPatentAffair(patentAffair);
         }
-        //装载事务表的status（公开|授权|驳回|权力转移。。。）
-        //最后将 patent装载到 uploadParamsVO
-        uploadParamsVO.setPatent(patent);
-        String content = JSONObject.toJSONString(lst);
-        patentAffair.setContent(content);
-        uploadParamsVO.setPatentAffair(patentAffair);
+
 
     }
 
@@ -494,16 +509,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      * @param uploadParamsVO 专利实体类对象
      */
     public void setPatentPicture(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
-//        String appNo;
-//        if (starPatent.getApplicationNo().contains(".")) {
-//            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
-//        } else {
-//            appNo = starPatent.getApplicationNo();
-//        }
-//        //以下 ↓调用的是"获得中国专利摘要附图"接口，获得摘要附图的url地址
-//        String pictureUrl = patentStarApiService.getPictureApi(appNo);
-
-        //直接取出一般接口返回的摘要附图路径
+        //取出一般接口返回的摘要附图路径
         String pictureUrl = starPatent.getAbstractPath();
 
         try {
@@ -548,7 +554,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     /**
      * 下载指定多个专利号专利
      *
-     * @param isAddPatentNos 多个专利号
+     * @param isAddPatentNos 起止条数以外，用户手动勾选的多个专利号
      */
     public void downLoadIsAddPatentNos(List<String> isAddPatentNos, Task task, String orderBy, String orderByType, String dbType, List<String> cells) throws IOException {
         String conditions = "(AN=(" + StringUtils.join(isAddPatentNos, " OR ") + "))";
@@ -576,8 +582,9 @@ public class ExcutePatentDataStar implements IExcutePatentData {
                 }
                 try {
                     UploadParamsVO uploadParamsVO = new UploadParamsVO();
-                    setPatentZhuLu(starPatent, uploadParamsVO);
-                    //保存专利基础数据（专利表"os_patent"），因为需要先拿到专利id供其他消费者部分使用
+                    Patent patent = new Patent();
+                    uploadParamsVO.setPatent(patent);
+                    uploadParamsVO.getPatent().setPatentNo(starPatent.getPatentNo());
                     uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
                     PQueueData pQueueData = new PQueueData()
@@ -607,7 +614,6 @@ public class ExcutePatentDataStar implements IExcutePatentData {
 
                 } catch (Exception e) {
                     e.printStackTrace();
-                    //继续下一个专利
                 }
 
             }
@@ -621,5 +627,13 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         this.pTaskStatus = taskStatus;
     }
 
+    public Integer getpTaskId() {
+        return pTaskId;
+    }
+
+    public Integer getpTaskStatus() {
+        return pTaskStatus;
+    }
+
 
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/MessageService.java

@@ -29,12 +29,14 @@ public class MessageService {
     public void sendWebsocketMessage(Task task, Integer total, Integer i, Long percentage) {
         //通过WebSocket 在每一次循环结束后 向前端发送完成进度
         //percentage：total == 0 ? 0 : Math.round((total.equals(i) ? (i * 1D) : (i + 1D)) / total * 100D)
+        //当任务状态为完成时，flag为true
+        boolean flag = task.getStatus().equals(2);
         WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
                 .setTaskId(task.getId())
                 .setProjectId(task.getProjectId())
-                .setComplete(false)
+                .setComplete(flag)
                 .setIndex(i)
-                .setTaskType(Constants.TASK_IMPORT_PATENT)
+                .setTaskType(task.getType())
                 .setPercentage(percentage)
                 .setFileName("")
                 .setOldName(task.getOldName())

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/PantentQueueService.java

@@ -5,15 +5,18 @@ import cn.cslg.pas.common.model.vo.UploadParamsVO;
 import cn.cslg.pas.common.utils.DateUtils;
 import cn.cslg.pas.common.utils.JsonUtils;
 import cn.cslg.pas.domain.PQueueData;
+import cn.cslg.pas.domain.QuestionRecord;
 import cn.cslg.pas.domain.QueueData;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.domain.asso.TaskCondition;
+import cn.cslg.pas.mapper.QuestionRecordMapper;
 import cn.cslg.pas.service.OutInterfaceService;
 import cn.cslg.pas.service.PatentInstructionService;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
-import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import cn.cslg.pas.service.asso.TaskConditionService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 
@@ -27,6 +30,7 @@ import java.util.concurrent.locks.ReentrantLock;
  * 2.装载者线程装载专利（将专利数据装载到专利实体类）
  * 3.消费者线程消费专利（将专利入库）
  */
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PantentQueueService {
@@ -34,12 +38,14 @@ public class PantentQueueService {
     private final UploadPatentBatchService uploadPatentBatchService;
     private final MessageService messageService;
     private final TaskService taskService;
-    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final TaskConditionService taskConditionService;
     private final ExcutePatentDataExcel excutePatentDataExcel;
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final ExcutePatentDataStar excutePatentDataStar;
     private final PatentInstructionService patentInstructionService;
     private final OutInterfaceService outInterfaceService;
+    private final QuestionRecordService questionRecordService;
+    private final QuestionRecordMapper questionRecordMapper;
     private final List<Integer> taskQueueList = new ArrayList<>();
     private final List<PQueueData> setPatentImageQueueList = new ArrayList<>();
     private final List<PQueueData> setPatentZhuluQueueList = new ArrayList<>();
@@ -99,7 +105,7 @@ public class PantentQueueService {
 
                     //若是网站导入任务，则将网站导入相关信息存入task对象中（方便生产与消费时使用）
                     if (task.getType().equals(3) || task.getType().equals(4)) {
-                        TaskCondition taskCondition = assoOsTaskQrtzTaskService.getById(task.getTaskConditionId());
+                        TaskCondition taskCondition = taskConditionService.getById(task.getTaskConditionId());
                         List<String> configCells = Arrays.asList(taskCondition.getConfigCells().split(","));
                         task.setConfigCellsNum(configCells.size());  //将下载字段数量存入task对象中（为了在后面发送进度时可以根据下载字段的数量来对应消费者数量，从而确定是否完成了一个专利的下载）
                         task.setConfigCells(configCells);
@@ -108,7 +114,6 @@ public class PantentQueueService {
                         task.setDBType(taskCondition.getDBType());
                         task.setStartNumber(taskCondition.getStartNumber());
                         task.setEndNumber(taskCondition.getEndNumber());
-                        task.setEndTime(taskCondition.getEndNumber());
                         if (taskCondition.getIsAddPatentNos() != null && !taskCondition.getIsAddPatentNos().equals("")) {
                             task.setIsAddPatentNos(Arrays.asList(taskCondition.getIsAddPatentNos().split(",")));
                         }
@@ -129,7 +134,7 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-                //任务表更新状态失败
+                //任务表更新状态完成
                 task.setStatus(2);
                 task.setEndTime(DateUtils.getDateTime());
                 taskService.updateById(task);
@@ -143,17 +148,21 @@ public class PantentQueueService {
      */
     public void setPatentZhuLu() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
                 if (setPatentZhuluQueueList.size() > 0) {
                     PQueueData pQueueData = setPatentZhuluQueueList.remove(0);
                     Task task = pQueueData.getTask();
-                    //专利之星
-                    //if (task.getType() == 4) {
-                    //excutePatentDataStar.setPatentZhuLu(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
-                    //}
-                    QueueData queueData = new QueueData()
+                    queueData
                             .setTask(task)
                             .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentZhuLu(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    }
+
+                    queueData.setUploadParamsVO(pQueueData.getUploadParamsVO());
                     //装载完成，将其丢入著录消费者队列，并唤醒著录消费者线程
                     patentZhuluQueueList.add(queueData);
                     patentZhuluLock.lock();
@@ -168,64 +177,35 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-
-            }
-
-        }
-    }
-
-    /**
-     * 装载线程2：摘要附图
-     */
-    public void setPatentImage() {
-        while (true) {
-            try {
-                if (setPatentImageQueueList.size() > 0) {
-                    PQueueData pQueueData = setPatentImageQueueList.remove(0);
-                    Task task = pQueueData.getTask();
-                    //专利之星
-                    if (task.getType() == 4) {
-                        excutePatentDataStar.setPatentPicture(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
-                    }
-                    QueueData queueData = new QueueData()
-                            .setTask(task)
-                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
-                    //装载完成，将其丢入摘要附图消费者队列，并唤醒摘要附图消费者线程
-                    patentImageQueueList.add(queueData);
-                    patentImageLock.lock();
-                    patentImageCondition.signalAll();
-                    patentImageLock.unlock();
-
-                } else {
-                    setPatentImageLock.lock();
-                    setPatentImageCondition.await();
-                    setPatentImageLock.unlock();
-                }
-
-            } catch (Exception e) {
-                e.printStackTrace();
-
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 1);
+                sendMessage(queueData);
             }
 
         }
     }
 
     /**
-     * 装载线程3：权要
+     * 装载线程2：权要
      */
     public void setPatentRight() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
                 if (setPatentRightQueueList.size() > 0) {
                     PQueueData pQueueData = setPatentRightQueueList.remove(0);
                     Task task = pQueueData.getTask();
+                    queueData
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //专利之星
                     if (task.getType() == 4) {
                         excutePatentDataStar.setPatentClaim(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
                     }
-                    QueueData queueData = new QueueData()
-                            .setTask(task)
-                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    queueData.setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //装载完成，将其丢入权要消费者队列，并唤醒权要消费者线程
                     patentRightQueueList.add(queueData);
                     patentRightLock.lock();
@@ -240,28 +220,35 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 2);
+                sendMessage(queueData);
             }
 
         }
     }
 
     /**
-     * 装载线程4：说明书文本
+     * 装载线程3：说明书文本
      */
     public void setPatentInstructionText() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
                 if (setPatentInstructionTextQueueList.size() > 0) {
                     PQueueData pQueueData = setPatentInstructionTextQueueList.remove(0);
                     Task task = pQueueData.getTask();
+                    queueData
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //专利之星
                     if (task.getType() == 4) {
                         excutePatentDataStar.setPatentInstructionText(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
                     }
-                    QueueData queueData = new QueueData()
-                            .setTask(task)
-                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    queueData.setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //装载完成，将其丢入说明书文本消费者队列，并唤醒说明书文本消费者线程
                     patentInstructionTextQueueList.add(queueData);
                     patentInstructionTextLock.lock();
@@ -276,28 +263,35 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 3);
+                sendMessage(queueData);
             }
 
         }
     }
 
     /**
-     * 装载线程5：说明书pdf
+     * 装载线程4：说明书pdf
      */
     public void setPatentInstructionPDF() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
                 if (setPatentInstructionPDFQueueList.size() > 0) {
                     PQueueData pQueueData = setPatentInstructionPDFQueueList.remove(0);
                     Task task = pQueueData.getTask();
+                    queueData
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //专利之星
                     if (task.getType() == 4) {
                         excutePatentDataStar.setPatentInstructionPDF(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
                     }
-                    QueueData queueData = new QueueData()
-                            .setTask(task)
-                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    queueData.setUploadParamsVO(pQueueData.getUploadParamsVO());
+
                     //装载完成，将其丢入说明书pdf消费者队列，并唤醒说明书pdf消费者线程
                     patentInstructionPDFQueueList.add(queueData);
                     patentInstructionPDFLock.lock();
@@ -312,47 +306,59 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 4);
+                sendMessage(queueData);
             }
 
         }
     }
 
     /**
-     * 消费者1：摘要附图入库
+     * 装载线程5：摘要附图
      */
-    public void pushPatentImageToDB() {
+    public void setPatentImage() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
-                if (patentImageQueueList.size() > 0) {
-                    queueData = patentImageQueueList.remove(0);
-                    UploadParamsVO uploadParamsVO = queueData.getUploadParamsVO();
-                    //摘要附图入库（两种方式：1.Excel摘要附图方式 2.网站导入摘要附图方式）
-                    if (queueData.getTask().getType().equals(1)) {
-                        uploadPatentToDBService.uploadPatentImage(uploadParamsVO);
-                    } else {
-                        uploadPatentToDBService.uploadPatentImage2(uploadParamsVO);
+                if (setPatentImageQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentImageQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    queueData
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentPicture(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
                     }
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData);
-                } else {
+
+                    queueData.setUploadParamsVO(pQueueData.getUploadParamsVO());
+
+                    //装载完成，将其丢入摘要附图消费者队列，并唤醒摘要附图消费者线程
+                    patentImageQueueList.add(queueData);
                     patentImageLock.lock();
-                    patentImageCondition.await();
+                    patentImageCondition.signalAll();
                     patentImageLock.unlock();
+
+                } else {
+                    setPatentImageLock.lock();
+                    setPatentImageCondition.await();
+                    setPatentImageLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 5);
                 sendMessage(queueData);
-
             }
 
         }
     }
 
     /**
-     * 消费者2：将专利从队列取出，著录项目入库
+     * 消费者1：著录项目入库
      */
     public void pushPatentZhuLuToDB() {
         while (true) {
@@ -377,7 +383,7 @@ public class PantentQueueService {
                         //文件夹与专利关联入库
                         uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), projectImportPatentVO);
                     }
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+
                     sendMessage(queueData);
                 } else {
                     patentZhuluLock.lock();
@@ -387,6 +393,8 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 1);
                 sendMessage(queueData);
             }
 
@@ -394,7 +402,7 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者3：将专利从队列取出，权利要求文本入库
+     * 消费者2：权利要求入库
      */
     public void pushPatentRightToDB() {
         while (true) {
@@ -404,7 +412,7 @@ public class PantentQueueService {
                     queueData = patentRightQueueList.remove(0);
                     //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+
                     sendMessage(queueData);
                 } else {
                     patentRightLock.lock();
@@ -414,6 +422,8 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 2);
                 sendMessage(queueData);
             }
 
@@ -421,7 +431,7 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者4：将专利从队列取出，说明书文本入库
+     * 消费者3：说明书文本入库
      */
     public void pushPatentInstructionTextToDB() {
         while (true) {
@@ -431,7 +441,7 @@ public class PantentQueueService {
                     queueData = patentInstructionTextQueueList.remove(0);
                     //说明书文本入库
                     uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+
                     sendMessage(queueData);
                 } else {
                     patentInstructionTextLock.lock();
@@ -441,6 +451,8 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 3);
                 sendMessage(queueData);
             }
 
@@ -448,7 +460,7 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者5：将专利从队列取出，说明书pdf地址入库
+     * 消费者4：说明书pdf入库
      */
     public void pushPatentInstructionPDFToDB() {
         while (true) {
@@ -458,7 +470,7 @@ public class PantentQueueService {
                     queueData = patentInstructionPDFQueueList.remove(0);
                     //说明书pdf入库
                     patentInstructionService.edit(queueData.getUploadParamsVO().getPatent().getPatentNo(), queueData.getUploadParamsVO().getFileDTO());
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+
                     sendMessage(queueData);
                 } else {
                     patentInstructionPDFLock.lock();
@@ -468,6 +480,8 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 4);
                 sendMessage(queueData);
             }
 
@@ -475,6 +489,41 @@ public class PantentQueueService {
     }
 
     /**
+     * 消费者5：摘要附图入库
+     */
+    public void pushPatentImageToDB() {
+        while (true) {
+            QueueData queueData = new QueueData();
+            try {
+                if (patentImageQueueList.size() > 0) {
+                    queueData = patentImageQueueList.remove(0);
+                    UploadParamsVO uploadParamsVO = queueData.getUploadParamsVO();
+                    //摘要附图入库（两种方式：1.Excel摘要附图方式 2.网站导入摘要附图方式）
+                    if (queueData.getTask().getType().equals(1)) {
+                        uploadPatentToDBService.uploadPatentImage(uploadParamsVO);
+                    } else {
+                        uploadPatentToDBService.uploadPatentImage2(uploadParamsVO);
+                    }
+
+                    sendMessage(queueData);
+                } else {
+                    patentImageLock.lock();
+                    patentImageCondition.await();
+                    patentImageLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                //记录该任务该专利该部分的失败记录
+                saveQuestionRecord(queueData, 5);
+                sendMessage(queueData);
+
+            }
+
+        }
+    }
+
+    /**
      * 当一个消费者消费完其负责的专利部分，修改成功条数，计算发送进度
      *
      * @param queueData 任务专利队列对象
@@ -490,7 +539,7 @@ public class PantentQueueService {
             //将任务id + "|" + 专利id，拼接成专利的标识（作为当前某一个消费者消费完的这个专利的数量标识）
             String currentPatent = task.getId() + "|" + queueData.getUploadParamsVO().getPatent().getId();
             Integer num = patentIdMap.get(currentPatent);
-            int needNum = 4;  //临界默认设为4（即Excel导入任务默认使用5个消费者）
+            int needNum = 3;  //临界默认设为4（即Excel导入任务默认使用5个消费者）
             if (task.getType().equals(3) || task.getType().equals(4)) {  //若是网站导入任务，则临界默认设为下载字段类型数量 - 1
                 needNum = task.getConfigCellsNum() - 1;
             }
@@ -498,54 +547,45 @@ public class PantentQueueService {
                 patentIdMap.put(currentPatent, 1);
             } else if (num < needNum) {
                 patentIdMap.put(currentPatent, ++num);
-            } else {
-                /*
-                1）若是看当前任务，表示当前这个任务这个专利的4个消费者全都消费结束，即当前这个任务的这个专利已完成
-                2）若是看下一个任务，表示下一个任务的著录项目消费者终于第一次进来了（即表示上一个任务最慢的著录项目消费者也结束了即上一个任务完成了），就将这下一个任务的状态改为 1进行中
-                 */
+            } else {  //表示当前这个任务这个专利的消费者全都消费结束
+
+                //若是第一次进来，即任务状态是等待中时， 将状态置为进行中
                 if (task.getStatus() == 0) {
                     task.setStatus(1);
                     task.setStartTime(DateUtils.getDateTime());
                     taskService.updateById(task);
                 }
                 patentIdMap.remove(currentPatent);
-                long percentage = Math.round((task.getSuccessNum() + 1D) / total * 100D);
-                //任务表更新数据（这里只更新成功条数和失败条数，注意不能更新状态等其他信息）
+
+                //任务表更新 完成条数+1
                 task.setSuccessNum(task.getSuccessNum() + 1);
-                task.setDefaultNum(total - task.getSuccessNum());
                 Task updateTask = new Task();
                 updateTask.setId(task.getId());
+                updateTask.setDefaultNum(questionRecordMapper.selectDefaultNum(task.getId()));
+                updateTask.setTrueSuccessNum(task.getSuccessNum() - task.getDefaultNum());
                 updateTask.setSuccessNum(task.getSuccessNum());
-                updateTask.setDefaultNum(total - task.getSuccessNum());
                 taskService.updateById(updateTask);
 
+                long percentage = Math.round((task.getSuccessNum() + 0D) / total * 100D);
+
                 //当全部完成时
                 if (task.getSuccessNum().equals(total)) {
                     percentage = 100L;
-                    //设置任务状态为成功
+                    //任务表更新最终数据
+                    task.setDefaultNum(questionRecordMapper.selectDefaultNum(task.getId()));
+                    task.setTrueSuccessNum(task.getSuccessNum() - task.getDefaultNum());
                     task.setStatus(2);
-                    //设置任务结束时间为当前时间
                     task.setEndTime(DateUtils.getDateTime());
                     taskService.updateById(task);
                 }
 
+                //websocket发送进度
                 messageService.sendWebsocketMessage(task, total, task.getSuccessNum(), percentage);
 
             }
         }
     }
 
-    /**
-     * 数据丢入摘要附图生产队列并唤醒装载摘要附图线程
-     *
-     * @param pQueueData 装载生产队列实体类
-     */
-    public void imageToPQueue(PQueueData pQueueData) {
-        setPatentImageQueueList.add(pQueueData);
-        setPatentImageLock.lock();
-        setPatentImageCondition.signalAll();
-        setPatentImageLock.unlock();
-    }
 
     /**
      * 数据丢入著录项目生产队列并唤醒装载著录项目线程
@@ -596,7 +636,19 @@ public class PantentQueueService {
     }
 
     /**
-     * 专利丢入5个消费者队列，并唤醒5个消费者线程
+     * 数据丢入摘要附图生产队列并唤醒装载摘要附图线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void imageToPQueue(PQueueData pQueueData) {
+        setPatentImageQueueList.add(pQueueData);
+        setPatentImageLock.lock();
+        setPatentImageCondition.signalAll();
+        setPatentImageLock.unlock();
+    }
+
+    /**
+     * Excel任务专利丢入消费者队列，并唤醒消费者线程
      *
      * @param task           任务对象
      * @param uploadParamsVO 专利实体类对象
@@ -610,34 +662,30 @@ public class PantentQueueService {
                 .setTask(task)
                 .setUploadParamsVO(uploadParamsVO);
 
-        //专利分别加入5个消费者队列
-        patentImageQueueList.add(queueData);
+        //专利分别加入消费者队列
         patentZhuluQueueList.add(queueData);
         patentRightQueueList.add(queueData);
         patentInstructionTextQueueList.add(queueData);
-        patentInstructionPDFQueueList.add(queueData);
+        patentImageQueueList.add(queueData);
 
-        //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、说明书pdf）
-        //1.摘要附图
-        patentImageLock.lock();
-        patentImageCondition.signalAll();
-        patentImageLock.unlock();
-        //2.著录项目
+        //通知消费者线程
+        //1.著录项目
         patentZhuluLock.lock();
         patentZhuluCondition.signalAll();
         patentZhuluLock.unlock();
-        //3.权利要求文本
+        //2.权利要求文本
         patentRightLock.lock();
         patentRightCondition.signalAll();
         patentRightLock.unlock();
-        //4.说明书文本
+        //3.说明书文本
         patentInstructionTextLock.lock();
         patentInstructionTextCondition.signalAll();
         patentInstructionTextLock.unlock();
-        //5.说明书pdf
-        patentInstructionPDFLock.lock();
-        patentInstructionPDFCondition.signalAll();
-        patentInstructionPDFLock.unlock();
+        //5.摘要附图
+        patentImageLock.lock();
+        patentImageCondition.signalAll();
+        patentImageLock.unlock();
+
 
     }
 
@@ -651,18 +699,32 @@ public class PantentQueueService {
     }
 
     /**
+     * 生产者生产队列剔除指定任务的所有专利
+     *
+     * @param taskId 任务id
+     */
+    public void setQueueRemoveTasks(Integer taskId) {
+        //任务暂停时清除生产者队列中已有的该任务的所有专利
+        this.setPatentZhuluQueueList.removeIf(pQueueData -> pQueueData.getTask().getId().equals(taskId));
+        this.setPatentRightQueueList.removeIf(pQueueData -> pQueueData.getTask().getId().equals(taskId));
+        this.setPatentInstructionTextQueueList.removeIf(pQueueData -> pQueueData.getTask().getId().equals(taskId));
+        this.setPatentInstructionPDFQueueList.removeIf(pQueueData -> pQueueData.getTask().getId().equals(taskId));
+        this.setPatentImageQueueList.removeIf(pQueueData -> pQueueData.getTask().getId().equals(taskId));
+    }
+
+    /**
      * 消费者专利队列剔除指定任务的所有专利
      *
      * @param taskId 任务id
      */
-    public void consumerQueueDeleteTasks(Integer taskId) {
-        //任务暂停时清除4个消费者专利队列中该任务的专利
-        this.patentImageQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+    public void consumerQueueRemoveTasks(Integer taskId) {
+        //任务暂停时清除消费者队列中已有的该任务的所有专利
         this.patentZhuluQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
         this.patentRightQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
         this.patentInstructionTextQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
         this.patentInstructionPDFQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
-        //任务暂停时清除 patentIdMap（任务id + "|" + 专利id，拼接而成的专利的数量标识（作为当前某一个消费者消费完的这个专利的数量标识））中该任务的专利的数量标识
+        this.patentImageQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        //任务暂停时清除 patentIdMap（任务id + "|" + 专利id，拼接而成的专利的数量标识（作为辨别某一任务的某一专利消费完成的消费者数量））中该任务的专利数量标识
         Iterator<String> iterator = this.patentIdMap.keySet().iterator();
         while (iterator.hasNext()) {
             String key = iterator.next();
@@ -705,5 +767,18 @@ public class PantentQueueService {
 
     }
 
+    /**
+     * 失败记录方法
+     *
+     * @param queueData 消费者专利队列
+     * @param cell      消费者代表的专利字段部分
+     */
+    public void saveQuestionRecord(QueueData queueData, Integer cell) {
+        QuestionRecord questionRecord = new QuestionRecord()
+                .setPatentNo(queueData.getUploadParamsVO().getPatent().getPatentNo())
+                .setTaskId(queueData.getTask().getId())
+                .setCell(cell);
+        questionRecordService.save(questionRecord);
+    }
 
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/QuestionRecordService.java

@@ -0,0 +1,18 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.domain.QuestionRecord;
+import cn.cslg.pas.mapper.QuestionRecordMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * 问题记录表的Service层实现类
+ *
+ * @Author chenyu
+ * @Date 2023/7/8
+ */
+@Slf4j
+@Service
+public class QuestionRecordService extends ServiceImpl<QuestionRecordMapper, QuestionRecord> {
+}

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/UploadTaskService.java

@@ -15,7 +15,7 @@ import cn.cslg.pas.service.PatentService;
 import cn.cslg.pas.service.ProjectService;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.WebLoginConfigService;
-import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import cn.cslg.pas.service.asso.TaskConditionService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import lombok.RequiredArgsConstructor;
@@ -42,7 +42,7 @@ public class UploadTaskService {
     private final FileUtils fileUtils;
     private final TaskService taskService;
     private final PantentQueueService pantentQueueService;
-    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final TaskConditionService taskConditionService;
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final CacheUtils cacheUtils;
     private final LoginUtils loginUtils;
@@ -104,14 +104,14 @@ public class UploadTaskService {
         } else {
             taskCondition.setConfigCells(String.join(",", cells));
         }
-        assoOsTaskQrtzTaskService.save(taskCondition);
+        taskConditionService.save(taskCondition);
 
         //任务表新增任务
         Integer taskId = taskService.addTask3(taskAddNewDTO, serachBiblioData.getTotals(), taskCondition);
 
         //任务与任务条件关联表更新数据
         taskCondition.setTaskId(taskId);
-        assoOsTaskQrtzTaskService.updateById(taskCondition);
+        taskConditionService.updateById(taskCondition);
 
         //任务存入生产者任务队列并唤醒生产者线程
         pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
@@ -203,7 +203,7 @@ public class UploadTaskService {
             taskCondition.setConfigCells(String.join(",", cells));
         }
         log.info("任务与任务条件关联表（asso_osTask_qrtzTask）新增数据");
-        assoOsTaskQrtzTaskService.save(taskCondition);
+        taskConditionService.save(taskCondition);
 
         //任务表新增任务
         Integer taskId = taskService.addTask3(taskAddNewDTO, total, taskCondition);
@@ -211,7 +211,7 @@ public class UploadTaskService {
         //任务与任务条件关联表（asso_osTask_qrtzTask）更新数据（普通任务）
         if (taskAddNewDTO.getTaskType().equals(0)) {
             taskCondition.setTaskId(taskId);
-            assoOsTaskQrtzTaskService.updateById(taskCondition);
+            taskConditionService.updateById(taskCondition);
         }
 
         //任务存入生产者任务队列并唤醒生产者线程

PAS/src/main/resources/mapper/QuestionRecordMapper.xml

@@ -0,0 +1,14 @@
+<?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.QuestionRecordMapper">
+    <!--根据任务id查询并统计失败专利数量-->
+    <!--int selectDefaultNum(Integer taskId);-->
+    <select id="selectDefaultNum" resultType="int">
+        select count(distinct patent_no)
+        from question_records
+        where task_id = #{taskId}
+    </select>
+
+
+</mapper>

PAS/src/main/resources/mapper/TaskMapper.xml

@@ -33,5 +33,56 @@
         order by a.ctime ${params.order}
     </select>
 
+    <!--根据条件查询任务列表-->
+    <!--List<QueryTaskVO> queryTasks(QueryTaskDTO queryTaskDTO);-->
+    <select id="queryTasks" resultMap="queryTasksMap">
+        select tas.*, max(tas.create_time)
+        from os_task tas
+        left join task_condition ass on tas.task_condition_id = ass.id
+        <where>
+            <if test="projectId != null">
+                and tas.tid = #{projectId}
+            </if>
+            <if test="reportId != null">
+                and tas.report_id = #{reportId}
+            </if>
+            <if test="projectId == null and reportId == null">
+                and tas.uid = #{createId}
+            </if>
+            <if test="createName != null and createName != ''">
+                and tas.uid in
+                <foreach collection="personIds" separator="," open="(" close=")">
+                    #{personIds}
+                </foreach>
+            </if>
+            <if test="taskType != null">
+                and ass.task_type = #{taskType}
+            </if>
+            <if test="taskType2 != null">
+                and tas.type = #{taskType2}
+            </if>
+            <if test="taskStatus != null and taskStatus.size > 0">
+                and tas.status in
+                <foreach collection="taskStatus" separator="," open="(" close=")">
+                    #{taskStatus}
+                </foreach>
+            </if>
+        </where>
+        group by tas.task_condition_id
+        order by
+        <choose>
+            <when test="orderBy != null">
+                ${orderBy} ${orderType}
+            </when>
+            <otherwise>
+                tas.id
+            </otherwise>
+        </choose>
+    </select>
+
+    <resultMap id="queryTasksMap" type="cn.cslg.pas.common.model.vo.QueryTaskVO">
+
+    </resultMap>
+
 
 </mapper>