合并代码

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

@@ -42,10 +42,10 @@ public class CreateTaskThread implements InitializingBean {
             List<Integer> doingTaskIds = doingTasks.stream().map(Task::getId).collect(Collectors.toList());
             if (doingTaskIds.size() > 0) {
                 //先将进行中的任务（项目重启后进行中的任务仅会有1个）的id先存入任务队列，再将其余存入
-                pantentQueueService.taskQueueAddTask(doingTaskIds);
+                pantentQueueService.taskQueueListAddTask(doingTaskIds);
                 taskIds.removeAll(doingTaskIds);
             }
-            pantentQueueService.taskQueueAddTask(taskIds);
+            pantentQueueService.taskQueueListAddTask(taskIds);
         }
 
         //生产者线程

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

@@ -0,0 +1,22 @@
+package cn.cslg.pas.common.model.dto;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 查询定时任务更新日志DTO类
+ *
+ * @Author chenyu
+ * @Date 2023/7/10
+ */
+@Accessors(chain = true)
+@Data
+public class QueryQrtzTaskLogsDTO extends PageDTO2 implements Serializable {
+    /**
+     * 某定时任务条件最新一条任务的id
+     */
+    private Integer taskId;
+
+}

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

@@ -10,6 +10,7 @@ public class TaskWebSocketDTO {
     private Integer total;
     private Integer index;
     private Integer taskId;
+    private Integer taskStatus;
     private Boolean complete;
     private String url;
     private String fileName;

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

@@ -84,24 +84,32 @@ public class QueryTaskVO implements Serializable {
      * 所属任务条件id
      */
     private Integer taskConditionId;
-
-    //以上若是网站导入的任务，则以下为关联任务条件表数据；以上若是Excel导入的任务，则以下都是null
+    /**
+     * 任务名称
+     */
+    private String taskName;
     /**
      * 任务类型1 (0普通任务 1定时任务)
      */
     private Integer taskType;
     /**
+     * 最近更新时间（即上面的结束时间endTime）
+     */
+    private Integer modifiedTime;
+
+    //以上若是网站导入的任务，则以下为关联任务条件表数据；以上若是Excel导入的任务，则以下都是null
+    /**
      * 检索式
      */
     private String conditions;
     /**
-     * 下载字段
+     * cron表达式
      */
-    private String configCells;
+    private String crons;
     /**
-     * 任务名称
+     * 下载字段
      */
-    private String taskName;
+    private String configCells;
     /**
      * 排序字段
      */

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

@@ -1,6 +1,7 @@
 package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.dto.QueryQrtzTaskLogsDTO;
 import cn.cslg.pas.common.model.dto.TaskAddNewDTO;
 import cn.cslg.pas.common.model.dto.QueryTaskDTO;
 import cn.cslg.pas.common.model.vo.TaskVO;
@@ -19,6 +20,7 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
 
 import java.io.IOException;
+import java.util.List;
 
 /**
  * <p>
@@ -38,39 +40,8 @@ public class TaskController {
     private final UploadTaskService uploadTaskService;
     private final JobService jobService;
 
-    @GetMapping("list")
-    @Operation(summary = "任务列表")
-    public String getPageList(TaskVO params) throws IOException {
-        return Response.success(taskService.getPageList(params));
-    }
-
-    @PostMapping("/queryTasks")
-    @Operation(summary = "查询任务列表")
-    public String queryTasks(@RequestBody QueryTaskDTO queryTaskDTO) throws IOException {
-        return Response.success(taskService.queryTasks(queryTaskDTO));
-    }
-
-    @PostMapping("delete")
-    @Operation(summary = "删除任务")
-    public String delete(Integer id) {
-        return taskService.delete(id);
-    }
-
-    @GetMapping("queue")
-    @Operation(summary = "获取进行中的任务")
-    public String getQueueList(Integer type, Integer projectId, Integer productId) {
-        return Response.success(taskService.getQueueList(type, projectId, productId));
-    }
-
-    @PostMapping("update")
-    @Operation(summary = "更新任务")
-    public String update(@RequestBody Task task) {
-        taskService.updateStatus(task.getId(), task.getStatus(), task.getEndTime());
-        return Response.success(true);
-    }
-
-    @PostMapping("addTask")
-    @Operation(summary = "新增网站导入专利任务")
+    @PostMapping("/addTask")
+    @Operation(summary = "新增网站导入任务")
     public String add(@RequestBody TaskAddNewDTO taskAddNewDTO) throws IOException, SchedulerException {
         log.info("开始处理【新增网站导入专利任务】的请求，请求参数为：{}", taskAddNewDTO);
 
@@ -90,20 +61,72 @@ public class TaskController {
         return Response.success("添加任务完成");
     }
 
-    @PostMapping("/pause")
+    @PostMapping("/addPatentNoTask")
+    @Operation(summary = "根据专利号导入专利任务")
+    public String addPatentNoTask(@RequestBody TaskAddNewDTO taskAddNewDTO) throws IOException {
+        uploadTaskService.addPatentNoTask(taskAddNewDTO);
+        return Response.success();
+    }
+
+    @PostMapping("/queryTasks")
+    @Operation(summary = "查询任务列表")
+    public String queryTasks(@RequestBody QueryTaskDTO queryTaskDTO) throws IOException {
+        return Response.success(taskService.queryTasks(queryTaskDTO));
+    }
+
+    @PostMapping("/queryQrtzTaskLogs")
+    @Operation(summary = "查询定时任务执行日志")
+    public String queryQrtzTaskLogs(@RequestBody QueryQrtzTaskLogsDTO queryQrtzTaskLogsDTO) {
+        return Response.success(taskService.queryQrtzTaskLogs(queryQrtzTaskLogsDTO));
+    }
+
+    @GetMapping("/pause")
     @Operation(summary = "暂停任务")
     public Response pauseTask(Integer taskId) throws InterruptedException {
         log.info("开始处理【暂停任务】的请求，请求参数为：taskId={}", taskId);
-        taskService.pauseTask(taskId);
-        return Response.ok("暂停任务成功");
+        Integer taskStatus = taskService.pauseTask(taskId);
+        return Response.ok(taskStatus);
     }
 
-    @PostMapping("/continue")
+    @GetMapping("/continue")
     @Operation(summary = "继续任务")
     public Response continueTask(Integer taskId) {
         log.info("开始处理【继续任务】的请求，请求参数为：taskId={}", taskId);
-        taskService.continueTask(taskId);
-        return Response.ok("继续任务成功");
+        Integer taskStatus = taskService.continueTask(taskId);
+        return Response.ok(taskStatus);
+    }
+
+    @GetMapping("/cancelTask")
+    @Operation(summary = "取消任务")
+    public String cancelTask(Integer taskId) throws SchedulerException, InterruptedException {
+        log.info("开始处理【取消任务】的请求，请求参数为：taskId={}", taskId);
+        taskService.cancelTask(taskId);
+        return Response.success("任务取消成功");
+    }
+
+    @GetMapping("list")
+    @Operation(summary = "任务列表")
+    public String getPageList(TaskVO params) throws IOException {
+        return Response.success(taskService.getPageList(params));
+    }
+
+    @PostMapping("delete")
+    @Operation(summary = "删除任务")
+    public String delete(Integer id) {
+        return taskService.delete(id);
+    }
+
+    @GetMapping("queue")
+    @Operation(summary = "获取进行中的任务")
+    public String getQueueList(Integer type, Integer projectId, Integer productId) {
+        return Response.success(taskService.getQueueList(type, projectId, productId));
+    }
+
+    @PostMapping("update")
+    @Operation(summary = "更新任务")
+    public String update(@RequestBody Task task) {
+        taskService.updateStatus(task.getId(), task.getStatus(), task.getEndTime());
+        return Response.success(true);
     }
 
 }

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

@@ -23,7 +23,7 @@ import java.util.List;
 public class Task extends BaseEntity<Task> {
 
     /**
-     * 任务类型 1.Excel导入专利任务 2.导出 3.Epo欧专局导入 4.专利之星导入
+     * 任务类型 1.Excel导入 2.导出 3.EPO欧专局导入 4.专利之星导入
      */
     @TableField("type")
     private Integer type;
@@ -70,7 +70,7 @@ public class Task extends BaseEntity<Task> {
     private Integer endTime;
 
     /**
-     * 0.队列中 1.进行中 2.已完成 4.已暂停
+     * 任务状态（0.队列中 1.进行中 2.已完成 4.已暂停 5.已取消）
      */
     @TableField("status")
     private Integer status;
@@ -134,6 +134,16 @@ public class Task extends BaseEntity<Task> {
      */
     @TableField("create_time")
     private Date createTime;
+    /**
+     * 任务名称（Excel任务默认为文件原名称old_name）
+     */
+    @TableField("task_name")
+    private String taskName;
+    /**
+     * 任务类型1（0普通任务 1定时任务）
+     */
+    @TableField("task_type")
+    private Integer taskType;
 
 
     @TableField(exist = false)

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

@@ -24,11 +24,11 @@ public interface TaskMapper extends BaseMapper<Task> {
 
     /**
      * 根据条件查询任务列表
+     *
      * @param queryTaskDTO 查询条件
      * @return 返回查询到的数据列表
      */
     List<QueryTaskVO> queryTasks(QueryTaskDTO queryTaskDTO);
 
 
-
 }

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

@@ -11,14 +11,15 @@ public interface ITaskService {
      * 暂停任务
      *
      * @param taskId 任务id
+     * @return
      */
-    void pauseTask(Integer taskId) throws InterruptedException;
+    Integer pauseTask(Integer taskId) throws InterruptedException;
 
     /**
      * 继续任务
      *
      * @param taskId 任务id
      */
-    void continueTask(Integer taskId);
+    Integer continueTask(Integer taskId);
 
 }

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

@@ -548,8 +548,11 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
         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）数据
-        taskConditionService.removeByIds(tasks.stream().map(Task::getTaskConditionId).collect(Collectors.toList()));
+        //陈宇 ↓ 若是网站导入任务则还要删除任务条件关联表（asso_osTask_qrtzTask）数据
+        List<Integer> taskConditionIds = tasks.stream().filter(item -> item.getTaskConditionId() != null).map(Task::getTaskConditionId).collect(Collectors.toList());
+        if (taskConditionIds.size() > 0) {
+            taskConditionService.removeByIds(taskConditionIds);
+        }
 
         return Response.success();
     }

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

@@ -1,6 +1,8 @@
 package cn.cslg.pas.service;
 
 
+import cn.cslg.pas.common.JsonPage;
+import cn.cslg.pas.common.model.dto.QueryQrtzTaskLogsDTO;
 import cn.cslg.pas.common.model.dto.TaskAddNewDTO;
 
 import cn.cslg.pas.common.model.dto.QueryTaskDTO;
@@ -14,10 +16,7 @@ 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.TaskConditionService;
-import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataEpo;
-import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataExcel;
-import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
-import cn.cslg.pas.service.upLoadPatent.PantentQueueService;
+import cn.cslg.pas.service.upLoadPatent.*;
 
 import cn.hutool.core.io.FileUtil;
 import com.alibaba.fastjson.JSON;
@@ -27,8 +26,11 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.quartz.SchedulerException;
 import org.springframework.beans.BeanUtils;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -61,6 +63,8 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final ExcutePatentDataStar excutePatentDataStar;
     private final TaskConditionService taskConditionService;
+    private final JobService jobService;
+    private final TaskMapper taskMapper;
 
 
     public String getFileUrl(Integer id) {
@@ -153,6 +157,10 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setDefaultNum(0);
         //前台参数json格式
         task.setPramJson(json);
+        //任务名称
+        task.setTaskName(task.getOldName());
+        //任务类型1（0普通任务 1定时任务）
+        task.setTaskType(0);
 
         //数据入任务表
         task.insert();
@@ -195,10 +203,15 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setDefaultNum(0);
         //所属任务条件id
         task.setTaskConditionId(taskCondition.getId());
+        //与专题库关联信息（自定义字段、文件夹）
         ProjectImportPatentVO projectImportPatentVO = new ProjectImportPatentVO();
         BeanUtils.copyProperties(taskAddNewDTO, projectImportPatentVO);
         String pramJson = JSONObject.toJSONString(projectImportPatentVO);
         task.setPramJson(pramJson);
+        //任务名称
+        task.setTaskName(taskAddNewDTO.getTaskName());
+        //任务类型1（0普通任务 1定时任务）
+        task.setTaskType(taskAddNewDTO.getTaskType());
 
         //数据入任务表
         log.info("任务表（os_task）新增数据");
@@ -271,132 +284,133 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public PageVO queryTasks(QueryTaskDTO queryTaskDTO) throws IOException {
         log.info("开始处理【查询任务】的业务，参数为：{}", queryTaskDTO);
 
-        //根据专题库id查询
-        LambdaQueryWrapper<Task> wrapper = new LambdaQueryWrapper<>();
-        if (queryTaskDTO.getProjectId() != null) {
-            wrapper.eq(Task::getProjectId, queryTaskDTO.getProjectId());
-        }
-        //根据报告id查询
-        if (queryTaskDTO.getReportId() != null) {
-            wrapper.eq(Task::getReportId, queryTaskDTO.getReportId());
-        }
-        //专题库id和报告id都没有时，根据当前登陆人id查询）
+        //专题库id和报告id都没有时，根据当前登陆人id查询
         if (queryTaskDTO.getProjectId() == null && queryTaskDTO.getReportId() == null) {
-            wrapper.eq(Task::getCreateBy, loginUtils.getId());
+            queryTaskDTO.setCreateId(loginUtils.getId());
         }
         //根据创建人名称模糊查询
         if (queryTaskDTO.getCreateName() != null && !queryTaskDTO.getCreateName().equals("")) {
             String res = outInterfaceService.getPersonIdByNamePCS(queryTaskDTO.getCreateName());
             List<Integer> personIds = JSON.parseArray(res, Integer.class);
-            //若没有，则ids集合添加一个元素-1（防止执行时sql报错：where uid in ()）
-            if (personIds == null || personIds.size() == 0) {
+            if (personIds.size() == 0) {  //若根据该名称查询不到任何人员，则将人员ids集合添加一个元素-1（防止sql报错）
                 personIds.add(-1);
             }
-            wrapper.in(Task::getCreateBy, personIds);
-        }
-        //根据任务类型1（0普通任务 1定时任务）查询
-        if (queryTaskDTO.getTaskType() != null) {
-            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) {
-                assoOsTaskQrtzTaskIds.add(-1);
-            }
-            wrapper.in(Task::getTaskConditionId, assoOsTaskQrtzTaskIds);
-        }
-        //根据任务类型2（1Excel导入 3欧专局导入 4专利之星导入）查询
-        if (queryTaskDTO.getTaskType2() != null) {
-            wrapper.eq(Task::getType, queryTaskDTO.getTaskType2());
+            queryTaskDTO.setPersonIds(personIds);
         }
-        //根据任务状态查询
-        if (queryTaskDTO.getTaskStatus() != null && queryTaskDTO.getTaskStatus().size() > 0) {
-            wrapper.in(Task::getStatus, queryTaskDTO.getTaskStatus());
+        //若有排序，则根据创建时间排
+        if (queryTaskDTO.getOrderBy() != null) {
+            queryTaskDTO.setOrderBy("create_time");
         }
-
-
-        List<Task> tasks;
-        Page<Task> pageList = new Page<>();
-        //若要分页查询
+        //若要分页
         if (queryTaskDTO.getCurrent() != null) {
-            //若要排序
-            if (queryTaskDTO.getOrderBy() != null && !queryTaskDTO.getOrderBy().equals("")) {
-                wrapper.last("order by create_time " + queryTaskDTO.getOrderType() + ", id " + queryTaskDTO.getOrderType());
-                pageList = this.page(new Page<>(queryTaskDTO.getCurrent(), queryTaskDTO.getSize()), wrapper);
-            } else {
-                //若不要排序
-                pageList = this.page(new Page<>(queryTaskDTO.getCurrent(), queryTaskDTO.getSize()), wrapper);
-            }
-            tasks = pageList.getRecords();
-        } else {
-            //若不要分页查询
-            pageList.setCurrent(0).setSize(0).setTotal(0);
-            //若要排序
-            if (queryTaskDTO.getOrderBy() != null && !queryTaskDTO.getOrderBy().equals("")) {
-                wrapper.last("order by create_time " + queryTaskDTO.getOrderType() + ", id " + queryTaskDTO.getOrderType());
-            }
-            tasks = this.list(wrapper);
+            PageHelper.startPage(queryTaskDTO.getCurrent(), queryTaskDTO.getSize());
         }
+        List<QueryTaskVO> tasks = taskMapper.queryTasks(queryTaskDTO);
+        PageInfo<QueryTaskVO> pageInfo = new PageInfo<>(tasks);
 
         //装载创建人名称（调用权限系统接口，根据创建人ids查询出人员列表）
-        List<Integer> createPersonIds = tasks.stream().map(Task::getCreateBy).collect(Collectors.toList());
-        String res = outInterfaceService.getPersonnelByIdsFromPCS(createPersonIds);
-        com.alibaba.fastjson.JSONObject jsonObject = com.alibaba.fastjson.JSONObject.parseObject(res);
-        List<Personnel> personnels = com.alibaba.fastjson.JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
-        //遍历任务列表和人员列表，根据创建人id和人员id匹配，装载人员名称
-        for (Task task : tasks) {
-            for (Personnel personnel : personnels) {
-                if (personnel.getId().equals(task.getCreateBy())) {
-                    task.setCreateName(personnel.getPersonnelName());
-                    break;
+        if (tasks.size() > 0) {
+            List<Integer> createPersonIds = tasks.stream().map(QueryTaskVO::getCreateBy).collect(Collectors.toList());
+            String res = outInterfaceService.getPersonnelByIdsFromPCS(createPersonIds);
+            com.alibaba.fastjson.JSONObject jsonObject = com.alibaba.fastjson.JSONObject.parseObject(res);
+            List<Personnel> personnels = com.alibaba.fastjson.JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
+            //遍历任务列表和人员列表，根据创建人id和人员id匹配，装载人员名称
+            for (QueryTaskVO task : tasks) {
+                for (Personnel personnel : personnels) {
+                    if (personnel.getId().equals(task.getCreateBy())) {
+                        task.setCreateName(personnel.getPersonnelName());
+                        break;
+                    }
                 }
             }
         }
 
-        List<QueryTaskVO> queryTaskVOS = new ArrayList<>();
-        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 = taskConditionService.list(new LambdaQueryWrapper<TaskCondition>().in(TaskCondition::getId, assoOsTaskQrtzTaskIds));
-            //遍历装载
-            for (Task task : tasks) {
-                QueryTaskVO queryTaskVO = new QueryTaskVO();
-                if (!task.getType().equals(3) && !task.getType().equals(4)) {  //若不是网站导入任务
-                    BeanUtils.copyProperties(task, queryTaskVO);
-                    queryTaskVO.setTaskName(task.getOldName());  //将Excel文件原名称赋值给taskName
-                    queryTaskVO.setTaskType(0);  //将任务类型1设置为普通任务（所有Excel任务默认为普通任务）
-                    queryTaskVOS.add(queryTaskVO);
-                } else {  //若是网站导入任务
-                    for (TaskCondition taskCondition : taskConditions) {
-                        //找到当前外层遍历到的 task任务的所属任务条件 assoOsTaskQrtzTask
-                        if (taskCondition.getId().equals(task.getTaskConditionId())) {
-                            BeanUtils.copyProperties(taskCondition, queryTaskVO);
-                            BeanUtils.copyProperties(task, queryTaskVO);
-                            //当前任务条件与当前任务匹配完成，结束当前这层任务条件循环，继续下一次循环跟下一个任务匹配
-                            queryTaskVOS.add(queryTaskVO);
-                            break;
-                        }
-                    }
-                }
+        //手动创建分页信息返回对象
+        PageVO pageVO = new PageVO()
+                .setCurrent(pageInfo.getPageNum())
+                .setSize(pageInfo.getPageSize())
+                .setTotal((int) pageInfo.getTotal())
+                .setRecords(tasks);
+        return pageVO;
+    }
+
+    public Page<Task> queryQrtzTaskLogs(QueryQrtzTaskLogsDTO queryQrtzTaskLogsDTO) {
+        log.info("开始处理【查询定时任务执行日志】的业务，参数为：taskId={}", queryQrtzTaskLogsDTO.getTaskId());
+
+        //检查任务是否存在，若不存在则提示用户"该定时任务已不存在，请尝试刷新页面"
+        Task task = this.getById(queryQrtzTaskLogsDTO.getTaskId());
+        if (task == null) {
+            ThrowException.throwXiaoShiException("该定时任务已不存在，请尝试刷新页面");
+        }
+
+        //检查任务是否为定时任务，若不是则提示用户"该任务不为定时任务，暂无更新日志"
+        TaskCondition taskCondition = taskConditionService.getById(task.getTaskConditionId());
+        if (!taskCondition.getTaskType().equals(1)) {
+            ThrowException.throwXiaoShiException("该任务不为定时任务，暂无更新日志");
+        }
 
+        Page<Task> pageList = this.page(new Page<>(queryQrtzTaskLogsDTO.getCurrent(), queryQrtzTaskLogsDTO.getSize()), new LambdaQueryWrapper<Task>().eq(Task::getTaskConditionId, task.getTaskConditionId()).orderByDesc(Task::getCreateTime));
+
+        return pageList;
+    }
+
+    public void cancelTask(Integer taskId) throws SchedulerException, InterruptedException {
+        log.info("开始处理【取消任务】的业务，参数为：taskId={}", taskId);
+
+        //检查任务是否存在，若不存在则提示用户"取消任务失败，当前任务已不存在，请尝试刷新页面"
+        Task task = this.getById(taskId);
+        if (task == null) {
+            ThrowException.throwXiaoShiException("取消任务失败，当前任务已不存在，请尝试刷新页面");
+            return;
+        }
+
+        //检查任务状态是否为已完成，若是则提示用户"取消任务失败，已完成的任务无法取消"
+        if (task.getStatus().equals(2)) {
+            ThrowException.throwXiaoShiException("取消任务失败，已完成的任务无法取消");
+        }
+
+        //若该任务是定时任务中最新的一条任务（即本次请求目的是取消该定时任务），则要删除job中的该定时任务条件
+        if (task.getType().equals(3) || task.getType().equals(4)) {
+            TaskCondition taskCondition = taskConditionService.getById(task.getTaskConditionId());
+            if (taskCondition.getTaskType().equals(1)) {
+                //删除job中的该定时任务条件
+                jobService.deleteJob(taskCondition.getId());
+            }
+        }
+
+        //若该任务处于进行中
+        if (task.getStatus().equals(1)) {
+            //将生产者生产专利中的公共任务状态改为暂停
+            if (task.getType() == 1) {
+                excutePatentDataExcel.setTaskStatus(taskId, 4);
+            } else if (task.getType() == 3) {
+                excutePatentDataEpo.setTaskStatus(taskId, 4);
+            } else if (task.getType() == 4) {
+                excutePatentDataStar.setTaskStatus(taskId, 4);
             }
-        } else {  //若没有网站导入任务
-            //若查询的不是网站导入的任务（即是Excel导入任务的话）
-            String tasksStr = JSONObject.toJSONString(tasks);
-            queryTaskVOS = JSON.parseArray(tasksStr, QueryTaskVO.class);
-            //遍历，将Excel文件原名称赋值给taskName，将任务类型1设置为普通任务（所有Excel任务默认为普通任务）
-            for (QueryTaskVO queryTaskVO : queryTaskVOS) {
-                queryTaskVO.setTaskName(queryTaskVO.getOldName());
-                queryTaskVO.setTaskType(0);
+            if (task.getType().equals(3) || task.getType().equals(4)) {
+                Thread.sleep(500);
+                //将专利各部分装载线程队列中该任务的专利清空
+                pantentQueueService.setQueueRemoveTasks(taskId);
             }
+            Thread.sleep(1000);
+            //将消费者的专利队列中所有该任务的专利剔除
+            pantentQueueService.consumerQueueRemoveTasks(taskId);
         }
 
-        //手动创建分页信息返回对象
-        PageVO pageVO = new PageVO()
-                .setCurrent((int) pageList.getCurrent())
-                .setSize((int) pageList.getSize())
-                .setTotal((int) pageList.getTotal())
-                .setRecords(queryTaskVOS);
-        return pageVO;
+        //若该任务处于等待中
+        if (task.getStatus().equals(0)) {
+            //将生产者任务队列中该任务剔除
+            pantentQueueService.taskQueueListRemoveTask(Arrays.asList(task.getId()));
+        }
+
+        //最后修改任务状态为5已取消
+        Task updateTask = new Task();
+        updateTask.setId(task.getId());
+        updateTask.setStatus(5);
+        log.info("os_task表修改任务状态为取消");
+        this.updateById(updateTask);
+
     }
 
     public List<Task> getQueueList(Integer type, Integer projectId, Integer productId) {
@@ -472,9 +486,10 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
      * 暂停任务
      *
      * @param taskId 任务id
+     * @return
      */
     @Override
-    public void pauseTask(Integer taskId) throws InterruptedException {
+    public Integer pauseTask(Integer taskId) throws InterruptedException {
         log.info("开始处理【暂停任务】的业务，参数为：taskId={}", taskId);
 
         //检查任务是否存在，若不存在则提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
@@ -482,7 +497,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         Task task = this.getById(taskId);
         if (task == null) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已不存在，请尝试刷新页面");
-            return;
+            return null;
         }
 
         //检查任务是否处于进行中状态，若不是则提示用户 "暂停失败，当前任务不处于进行中状态，请尝试刷新页面"
@@ -509,19 +524,20 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             excutePatentDataStar.setTaskStatus(taskId, 4);
         }
 
-
+        //若是网站导入任务，则还要将专利各部分装载线程队列中该任务的专利清空
         if (task.getType().equals(3) || task.getType().equals(4)) {
-            //等上2秒（上述代码虽然使得生产暂停，但是生产暂停前正在存入生产队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
-            Thread.sleep(2000);
+            //等上半秒（上述代码虽然使得生产暂停，但是生产暂停前正在存入生产队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
+            Thread.sleep(500);
             pantentQueueService.setQueueRemoveTasks(taskId);
         }
 
-        //等上2秒（上述代码虽然使得生产暂停，但是生产暂停前已生产的专利正在存入消费者队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
-        Thread.sleep(2000);
+        //等上一秒（上述代码虽然使得生产暂停，但是生产暂停前已生产的专利正在存入消费者队列的过程中，等2秒使得这些放入消费者队列后再清空消费者）
+        Thread.sleep(1000);
         //将消费者的专利队列中所有该任务的专利剔除
         pantentQueueService.consumerQueueRemoveTasks(taskId);
 
         log.info("暂停任务成功");
+        return updateTask.getStatus();
 
     }
 
@@ -531,7 +547,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
      * @param taskId 任务id
      */
     @Override
-    public void continueTask(Integer taskId) {
+    public Integer continueTask(Integer taskId) {
         log.info("开始处理【继续任务】的业务，参数为：taskId={}", taskId);
 
         //检查任务是否存在，若不存在则提示用户 "继续任务失败，当前任务已不存在，请尝试刷新页面"
@@ -539,7 +555,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         Task task = this.getById(taskId);
         if (task == null) {
             ThrowException.throwXiaoShiException("继续任务失败，当前任务已不存在，请尝试刷新页面");
-            return;
+            return null;
         }
 
         //检查任务是否处于暂停状态，若不是则提示用户 "继续任务失败，当前任务未暂停，请尝试刷新页面"
@@ -558,7 +574,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         }
 
         //将当前任务添加进生产者任务队列进行排队，并唤醒生产者线程
-        pantentQueueService.taskQueueAddTask(new ArrayList<>(Arrays.asList(taskId)));
+        pantentQueueService.taskQueueListAddTask(new ArrayList<>(Arrays.asList(taskId)));
 
         //将生产者生产专利类中的公共任务状态从暂停改为0
         if (task.getType().equals(1) && excutePatentDataExcel.getpTaskId().equals(task.getId())) {
@@ -573,6 +589,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
 
         log.info("继续任务成功");
 
+        return updateTask.getStatus();
     }
 
 

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

@@ -55,6 +55,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     @Override
     public void startExcute(Task task) throws IOException {
         try {
+            Integer total = task.getTotal();  //总条数
             Integer successNum = task.getSuccessNum();  //成功条数（即上一次下载到的位置）
             String conditions = task.getConditions();  //检索式
             String orderBy = task.getOrderBy();  //排序字段
@@ -66,14 +67,22 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             List<String> isAddPatentNos = task.getIsAddPatentNos();  //需要额外下载的专利号
             List<String> isDeletePatentNos = task.getIsDeletePatentNos();  //起止条数中不需要下载的专利号
 
-            //下载起止条数中的专利 ↓
-            //若成功条数不为0，即表示此次任务为暂停后继续执行，则起始条数 startNumber为成功条数 + 1
-            //endNumber - startNumber + 1 - isDeletePatentNos.size()
+            //startToEndNum：起止条数中需要下载的专利总数量
+            int startToEndNum = 0;
+            if (endNumber > 0) {
+                startToEndNum = endNumber - startNumber + 1;
+                if (isDeletePatentNos != null && isDeletePatentNos.size() > 0) {
+                    startToEndNum = startToEndNum - isDeletePatentNos.size();
+                }
+            }
+
+            //若有完成条数，即表示此次任务为暂停后的继续执行，则将起始条数 startNumber重置为成功条数 + 1
             if (successNum > 0) {
                 startNumber = successNum + 1;
             }
 
-            if (endNumber > 0) {
+            //若有起止条数，并且完成条数在起止条数内（即起止条数的专利还没有下载完）
+            if (endNumber > 0 && startNumber <= endNumber && successNum < startToEndNum) {
                 int startPage;  //检索开始页数
                 int startNum;  //检索开始页数的开始专利位置
                 int endPage;  //检索结束页数
@@ -166,9 +175,24 @@ public class ExcutePatentDataStar implements IExcutePatentData {
                 }
             }
 
+            //若是暂停后继续的任务，若 successNum > startToEndNum，即上一次执行不仅下载完了起止条数中的专利，还下载了isAdd中的部分专利
+            int fromIndex = 0;
+            if (successNum > 0 && successNum > startToEndNum) {
+                fromIndex = successNum - startToEndNum;
+            }
             //下载isAdd中的专利 ↓
             if (isAddPatentNos != null && isAddPatentNos.size() > 0) {
-                downLoadIsAddPatentNos(isAddPatentNos, task, orderBy, orderByType, dbType, cells);
+                //fromIndex > 0 表示上一次执行已经下载了isAdd中的部分专利，则此次需要把已完成的专利号截取掉
+                if (fromIndex > 0) {
+                    isAddPatentNos = isAddPatentNos.subList(fromIndex, isAddPatentNos.size() - 1);
+                }
+                //若是检索页面网站导入，则isAddPatentNos里是前台传的多个申请号
+                if (isAddPatentNos.contains(".")) {
+                    downLoadIsAddPatentNos(isAddPatentNos, task, orderBy, orderByType, dbType, cells, null);
+                } else {
+                    //若是多个专利号导入，则isAddPatentNos里是多个专利号
+                    downLoadIsAddPatentNos(isAddPatentNos, task, orderBy, orderByType, dbType, cells, conditions);
+                }
             }
 
         } catch (IOException e) {
@@ -556,8 +580,10 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      *
      * @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 ") + "))";
+    public void downLoadIsAddPatentNos(List<String> isAddPatentNos, Task task, String orderBy, String orderByType, String dbType, List<String> cells, String conditions) throws IOException {
+        if (conditions == null) {
+            conditions = "(AN=(" + StringUtils.join(isAddPatentNos, " OR ") + "))";
+        }
 
         int pageNum = 1;
         for (int i = 0; i < isAddPatentNos.size(); i += 50) {

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

@@ -29,18 +29,20 @@ public class JobService {
      *
      * @throws SchedulerException
      */
-    public void deleteJob(Integer taskId) throws SchedulerException {
-        QuartzVO quartzVO = this.generateQuartzVO(taskId);
+    public void deleteJob(Integer taskConditionId) throws SchedulerException {
+        //删除job中的该定时任务条件
+        QuartzVO quartzVO = this.generateQuartzVO(taskConditionId);
         TriggerKey triggerKey = TriggerKey.triggerKey(quartzVO.getTriggerName(), quartzVO.getTriggerGroupName());
         scheduler.pauseTrigger(triggerKey);
         scheduler.unscheduleJob(triggerKey);
         JobKey jobKey = JobKey.jobKey(quartzVO.getJobName(), quartzVO.getJobGroupName());
         scheduler.deleteJob(jobKey);
-        qrTaskService.removeById(taskId);
-        //同时删除该任务条件的所有任务执行情况记录
-        LambdaQueryWrapper<Task> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(Task::getTaskConditionId, taskId);
-        taskService.remove(queryWrapper);
+
+//        qrTaskService.removeById(taskId);
+//        //同时删除该任务条件的所有任务执行情况记录
+//        LambdaQueryWrapper<Task> queryWrapper = new LambdaQueryWrapper<>();
+//        queryWrapper.eq(Task::getTaskConditionId, taskId);
+//        taskService.remove(queryWrapper);
     }
 
     /**
@@ -100,7 +102,7 @@ public class JobService {
         //添加一条任务记录
         QuartzVO quartzVO = this.generateQuartzVO(taskCondition.getId());
         JobDataMap jobDataMap = new JobDataMap();
-        jobDataMap.put("assoOsTaskQrtzTask", taskCondition);
+        jobDataMap.put("taskCondition", taskCondition);
         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(taskCondition.getCrons());
         JobDetail jobDetail = JobBuilder
                 .newJob(TaskAddJob.class)

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

@@ -33,6 +33,7 @@ public class MessageService {
         boolean flag = task.getStatus().equals(2);
         WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
                 .setTaskId(task.getId())
+                .setTaskStatus(task.getStatus())
                 .setProjectId(task.getProjectId())
                 .setComplete(flag)
                 .setIndex(i)

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

@@ -98,8 +98,8 @@ public class PantentQueueService {
                 if (taskQueueList.size() > 0) {
                     //从任务队列中取出第一个task任务，同时将其从任务队列中剔除
                     task = taskService.getById(taskQueueList.remove(0));
-                    //判断任务状态，若已不存在或已暂停，则跳过继续取下一个任务
-                    if (task == null || task.getStatus() == 4) {
+                    //判断任务状态，若不存在或已完成或已暂停或已取消，则跳过继续取下一个任务
+                    if (task == null || task.getStatus().equals(2) || task.getStatus().equals(4) || task.getStatus().equals(5)) {
                         continue;
                     }
 
@@ -549,7 +549,7 @@ public class PantentQueueService {
                 patentIdMap.put(currentPatent, ++num);
             } else {  //表示当前这个任务这个专利的消费者全都消费结束
 
-                //若是第一次进来，即任务状态是等待中时， 将状态置为进行中
+                //若任务状态是等待中（即该任务的第一个专利消费完时）， 将状态置为进行中
                 if (task.getStatus() == 0) {
                     task.setStatus(1);
                     task.setStartTime(DateUtils.getDateTime());
@@ -566,7 +566,7 @@ public class PantentQueueService {
                 updateTask.setSuccessNum(task.getSuccessNum());
                 taskService.updateById(updateTask);
 
-                long percentage = Math.round((task.getSuccessNum() + 0D) / total * 100D);
+                long percentage = (long) Math.floor((task.getSuccessNum() + 0D) / total * 100D);
 
                 //当全部完成时
                 if (task.getSuccessNum().equals(total)) {
@@ -594,9 +594,11 @@ public class PantentQueueService {
      */
     public void zhuluToPQueue(PQueueData pQueueData) {
         setPatentZhuluQueueList.add(pQueueData);
-        setPatentZhuluLock.lock();
-        setPatentZhuluCondition.signalAll();
-        setPatentZhuluLock.unlock();
+        if (setPatentZhuluLock.tryLock()) {
+            //setPatentZhuluLock.lock();
+            setPatentZhuluCondition.signalAll();
+            setPatentZhuluLock.unlock();
+        }
     }
 
     /**
@@ -606,9 +608,11 @@ public class PantentQueueService {
      */
     public void rightToPQueue(PQueueData pQueueData) {
         setPatentRightQueueList.add(pQueueData);
-        setPatentRightLock.lock();
-        setPatentRightCondition.signalAll();
-        setPatentRightLock.unlock();
+        if (setPatentRightLock.tryLock()) {
+            //setPatentRightLock.lock();
+            setPatentRightCondition.signalAll();
+            setPatentRightLock.unlock();
+        }
     }
 
     /**
@@ -618,9 +622,11 @@ public class PantentQueueService {
      */
     public void instructionTextToPQueue(PQueueData pQueueData) {
         setPatentInstructionTextQueueList.add(pQueueData);
-        setPatentInstructionTextLock.lock();
-        setPatentInstructionTextCondition.signalAll();
-        setPatentInstructionTextLock.unlock();
+        if (setPatentInstructionTextLock.tryLock()) {
+            //setPatentInstructionTextLock.lock();
+            setPatentInstructionTextCondition.signalAll();
+            setPatentInstructionTextLock.unlock();
+        }
     }
 
     /**
@@ -630,9 +636,11 @@ public class PantentQueueService {
      */
     public void instructionPDFToPQueue(PQueueData pQueueData) {
         setPatentInstructionPDFQueueList.add(pQueueData);
-        setPatentInstructionPDFLock.lock();
-        setPatentInstructionPDFCondition.signalAll();
-        setPatentInstructionPDFLock.unlock();
+        if (setPatentInstructionPDFLock.tryLock()) {
+            //setPatentInstructionPDFLock.lock();
+            setPatentInstructionPDFCondition.signalAll();
+            setPatentInstructionPDFLock.unlock();
+        }
     }
 
     /**
@@ -642,9 +650,11 @@ public class PantentQueueService {
      */
     public void imageToPQueue(PQueueData pQueueData) {
         setPatentImageQueueList.add(pQueueData);
-        setPatentImageLock.lock();
-        setPatentImageCondition.signalAll();
-        setPatentImageLock.unlock();
+        if (setPatentImageLock.tryLock()) {
+            //setPatentImageLock.lock();
+            setPatentImageCondition.signalAll();
+            setPatentImageLock.unlock();
+        }
     }
 
     /**
@@ -670,22 +680,29 @@ public class PantentQueueService {
 
         //通知消费者线程
         //1.著录项目
-        patentZhuluLock.lock();
-        patentZhuluCondition.signalAll();
-        patentZhuluLock.unlock();
+        if (patentZhuluLock.tryLock()) {
+            //patentZhuluLock.lock();
+            patentZhuluCondition.signalAll();
+            patentZhuluLock.unlock();
+        }
         //2.权利要求文本
-        patentRightLock.lock();
-        patentRightCondition.signalAll();
-        patentRightLock.unlock();
+        if (patentRightLock.tryLock()) {
+            //patentRightLock.lock();
+            patentRightCondition.signalAll();
+            patentRightLock.unlock();
+        }
         //3.说明书文本
-        patentInstructionTextLock.lock();
-        patentInstructionTextCondition.signalAll();
-        patentInstructionTextLock.unlock();
+        if (patentInstructionTextLock.tryLock()) {
+            //patentInstructionTextLock.lock();
+            patentInstructionTextCondition.signalAll();
+            patentInstructionTextLock.unlock();
+        }
         //5.摘要附图
-        patentImageLock.lock();
-        patentImageCondition.signalAll();
-        patentImageLock.unlock();
-
+        if (patentImageLock.tryLock()) {
+            //patentImageLock.lock();
+            patentImageCondition.signalAll();
+            patentImageLock.unlock();
+        }
 
     }
 
@@ -694,10 +711,14 @@ public class PantentQueueService {
      *
      * @param taskQueueList 生产者任务队列
      */
-    public void taskQueueAddTask(List<Integer> taskQueueList) {
+    public void taskQueueListAddTask(List<Integer> taskQueueList) {
         this.taskQueueList.addAll(taskQueueList);
     }
 
+    public void taskQueueListRemoveTask(List<Integer> taskQueueList) {
+        this.taskQueueList.removeAll(taskQueueList);
+    }
+
     /**
      * 生产者生产队列剔除指定任务的所有专利
      *
@@ -740,10 +761,11 @@ public class PantentQueueService {
      * 唤醒生产者线程
      */
     public void awakeTasktch() {
-        taskLock.lock();
-        taskCondition.signalAll();
-        taskLock.unlock();
-
+        if (taskLock.tryLock()) {
+            //taskLock.lock();
+            taskCondition.signalAll();
+            taskLock.unlock();
+        }
     }
 
     /**

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

@@ -31,21 +31,28 @@ public class TaskAddJob extends QuartzJobBean {
     @Override
     public void executeInternal(JobExecutionContext context) throws JobExecutionException {
         JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
-        TaskCondition taskCondition = (TaskCondition) jobDataMap.get("assoOsTaskQrtzTask");
-        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskConditionId, taskCondition.getId()));
+        TaskCondition taskCondition = (TaskCondition) jobDataMap.get("taskCondition");
         Task task = new Task();
-        if (list != null && list.size() > 0) {
-            task.setType(list.get(0).getType());
+        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getTaskConditionId, taskCondition.getId()));
+        if (tasks != null && tasks.size() > 0) {
+            task.setProjectId(tasks.get(0).getProjectId());
+            task.setCreateBy(tasks.get(0).getCreateBy());
+            task.setPramJson(tasks.get(0).getPramJson());
         }
+        task.setTaskName(taskCondition.getTaskName());
+        task.setType(taskCondition.getTaskType2());
+        task.setTaskType(taskCondition.getTaskType());
         task.setTaskConditionId(taskCondition.getId());
         task.setTotal(taskCondition.getTotal());
         task.setStatus(0);
         task.setSuccessNum(0);
+        task.setTrueSuccessNum(0);
         task.setDefaultNum(0);
         taskService.save(task);
-        //任务存入生产者任务队列并唤醒生产者线程（判断若没有进行中的任务则唤醒）
-        pantentQueueService.taskQueueAddTask(Arrays.asList(task.getId()));
+        //任务存入生产者任务队列并唤醒生产者线程
+        pantentQueueService.taskQueueListAddTask(Arrays.asList(task.getId()));
         pantentQueueService.awakeTasktch();
+
         logger.info("添加任务" + "信息是" + task);
     }
 

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

@@ -36,7 +36,7 @@ public class UploadPatentToDBService {
     public void uploadPatentImage(UploadParamsVO uploadParamsVO) throws IOException {
         //摘要附图数据装配及入库（摘要附图表"os_patent_img"）
         if (uploadParamsVO.getPatent() != null) {
-            if (uploadParamsVO.getPatent().getId() != null) {
+            if (uploadParamsVO.getPatent().getId() != null && uploadParamsVO.getPictureData() != null) {
                 uploadParamsVO.getPatent().setAbstractPath(patentImageService.updatePatentImage(uploadParamsVO.getPatent().getId(), uploadParamsVO.getPictureData()));
                 //专利表"os_patent"更新数据（更新摘要附图路径）
                 patentService.updateById(uploadParamsVO.getPatent());

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

@@ -6,15 +6,9 @@ import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.cslg.pas.common.model.outApi.PatentStarListDto;
 import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
-import cn.cslg.pas.domain.Patent;
-import cn.cslg.pas.domain.Project;
-import cn.cslg.pas.domain.SerachBiblioData;
-import cn.cslg.pas.domain.WebLoginConfig;
+import cn.cslg.pas.domain.*;
 import cn.cslg.pas.domain.asso.TaskCondition;
-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.*;
 import cn.cslg.pas.service.asso.TaskConditionService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -23,6 +17,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;
@@ -50,6 +45,8 @@ public class UploadTaskService {
     private final PatentStarApiService patentStarApiService;
     private final ProjectService projectService;
     private final PatentService patentService;
+    private final ReportService reportService;
+
     /**
      * 新增Excel导入任务
      *
@@ -66,9 +63,10 @@ public class UploadTaskService {
         //新增任务（专利导入导出任务表）
         Integer taskId = taskService.addTask2(fileDTO, total, json);
         //任务存入生产者任务队列并唤醒生产者线程
-        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
+        pantentQueueService.taskQueueListAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
     }
+
     /**
      * 新增Epo网站导入任务
      *
@@ -114,7 +112,7 @@ public class UploadTaskService {
         taskConditionService.updateById(taskCondition);
 
         //任务存入生产者任务队列并唤醒生产者线程
-        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
+        pantentQueueService.taskQueueListAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
 
         return taskCondition;
@@ -135,9 +133,13 @@ public class UploadTaskService {
                 ThrowException.throwXiaoShiException("该专题库已不存在，请尝试刷新页面");
             }
         }
-        if (taskAddNewDTO.getReportId() != null) {
-            //查询报告是否存在，若不存在则抛出异常信息 "该报告已不存在，请尝试刷新页面"
-        }
+        //TODO 检查报告是否被删除
+//        if (taskAddNewDTO.getReportId() != null) {
+//            Report report = reportService.getById(taskAddNewDTO.getReportId());
+//            if (report == null) {
+//                ThrowException.throwXiaoShiException("该报告已不存在，请尝试刷新页面");
+//            }
+//        }
 
         //检查任务合法性2（根据网站配置id和登陆人所属租户id，看是否有网站导入任务的权限）
         Integer webId = taskAddNewDTO.getConfigId();
@@ -160,9 +162,10 @@ public class UploadTaskService {
             ThrowException.throwXiaoShiException("未检索到相关专利，请尝试更改检索式或检索条件信息");
         }
 
+
         //获取专利总数量
         Integer total;
-        if (taskAddNewDTO.getEndNumber() != 0) {
+        if (taskAddNewDTO.getEndNumber() > 0) {
             total = taskAddNewDTO.getEndNumber() - taskAddNewDTO.getStartNumber() + 1;
             if (taskAddNewDTO.getIsDeletePatentNos() != null) {
                 total = total - taskAddNewDTO.getIsDeletePatentNos().size();
@@ -177,7 +180,6 @@ public class UploadTaskService {
         //新增任务与任务条件关联表（"asso_osTask_qrtzTask"）数据
         TaskCondition taskCondition = new TaskCondition();
         taskCondition
-                .setTaskName(taskAddNewDTO.getTaskName())
                 .setTaskType(taskAddNewDTO.getTaskType())
                 .setTaskType2(taskAddNewDTO.getTaskType2())
                 .setConditions(taskAddNewDTO.getConditions())
@@ -215,60 +217,78 @@ public class UploadTaskService {
         }
 
         //任务存入生产者任务队列并唤醒生产者线程
-        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
+        pantentQueueService.taskQueueListAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
 
         return taskCondition;
     }
 
-    public String addPatentNoTask(TaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
-        //校验参数
-        if (qrtzTaskAddNewDTO == null || qrtzTaskAddNewDTO.getConditions() == null) {
-            return Response.error("请输入专利号");
+    public void addPatentNoTask(TaskAddNewDTO taskAddNewDTO) throws IOException {
+        log.info("开始处理【根据专利号导入专利任务】的业务，参数为：{}", taskAddNewDTO);
+
+        //检查合法性
+        if (taskAddNewDTO == null || taskAddNewDTO.getConditions() == null) {
+            ThrowException.throwXiaoShiException("请输入专利号");
         }
 
-        String condition = this.setPatentNosToCondition(qrtzTaskAddNewDTO.getConditions());
-        if(condition==null){
-            return Response.success("所有专利都已存在");
+        String isAddPatentNosStr = taskAddNewDTO.getConditions();
+
+        //根据专利号生成检索式
+        String condition = this.setPatentNosToCondition(taskAddNewDTO.getConditions());
+        if (condition == null) {
+            ThrowException.throwXiaoShiException("本批专利都已存在");
         }
-        qrtzTaskAddNewDTO.setConditions(condition);
-       TaskCondition assoOsTaskQrtzTask = new TaskCondition();
-        //新增欧专局网站导入任务
-        if (qrtzTaskAddNewDTO.getTaskType2().equals(3)) {
-            assoOsTaskQrtzTask = this.addEpoTask(qrtzTaskAddNewDTO);
-            //新增专利之星网站导入任务
-        } else if (qrtzTaskAddNewDTO.getTaskType2().equals(4)) {
-            assoOsTaskQrtzTask = this.addPatentStarTask(qrtzTaskAddNewDTO);
+
+        taskAddNewDTO
+                .setConditions(condition)
+                .setEndNumber(0)
+                .setIsAddPatentNos(Arrays.asList(isAddPatentNosStr.split("[,|，]")))
+                .setDBType("CN")
+                .setOrderBy("ID")
+                .setOrderByType("DESC")
+                .setConfigCells(Arrays.asList("1", "2", "3", "4", "6"))
+                .setConfigId(2)
+                .setReportId(taskAddNewDTO.getReportId())
+                .setTaskName("多个专利号导入方式任务")
+                .setTaskType(0)
+                .setTaskType2(4);
+
+        //判断网站类型
+        if (taskAddNewDTO.getTaskType2().equals(3)) {
+            this.addEpoTask(taskAddNewDTO);
+        } else if (taskAddNewDTO.getTaskType2().equals(4)) {
+            this.addPatentStarTask(taskAddNewDTO);
         }
 
-        return Response.success("添加任务完成");
 
     }
 
     public String setPatentNosToCondition(String patentNosStr) {
         String[] patentNo = patentNosStr.split("[,|，]");
         List<String> patentNos = Arrays.asList(patentNo);
+        if (patentNos.size() == 0) {
+            ThrowException.throwXiaoShiException("请按照格式要求正确输入专利号");
+        }
         //根据专利号从本数据库中查找专利
         LambdaQueryWrapper<Patent> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.in(Patent::getPatentNo,patentNos);
+        queryWrapper.in(Patent::getPatentNo, patentNos);
         Function<Object, String> f = (o -> o.toString());
         List<String> dbPatentNos = patentService.listObjs(queryWrapper, f);
-        //获得本系统不包含的专利
+        //去除掉所有查询到的专利，若去除后没有专利了则表示所有这批专利都已存在数据库中
         patentNos.removeAll(dbPatentNos);
-        if(patentNos.size()==0){
+        if (patentNos.size() == 0) {
             return null;
         }
         //将本系统不包含的专利拼接成条件
-        String patentNoCondition =StringUtils.join(patentNos," OR ");
-        StringBuilder stringBuilder =new StringBuilder();
-        stringBuilder.append("(PN=(")
+        String patentNoCondition = StringUtils.join(patentNos, " OR ");
+        StringBuilder builder = new StringBuilder();
+        builder.append("(PN=(")
                 .append(patentNoCondition)
                 .append(")")
-                .append("OR GN=(")
+                .append(" OR GN=(")
                 .append(patentNoCondition)
                 .append("))");
-        String conditions =stringBuilder.toString();
-        return conditions;
+        return builder + "";
     }
 
 }

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

@@ -36,9 +36,23 @@
     <!--根据条件查询任务列表-->
     <!--List<QueryTaskVO> queryTasks(QueryTaskDTO queryTaskDTO);-->
     <select id="queryTasks" resultMap="queryTasksMap">
-        select tas.*, max(tas.create_time)
+        select tas.id tas_id, tas.type tas_type, tas.uid tas_uid, tas.ctime tas_ctime, tas.tid tas_tid,
+        tas.report_id tas_report_id, tas.mfields tas_mfields, tas.mun tas_mun, tas.onmun tas_onmun, tas.endtime
+        tas_endtime,
+        tas.status tas_status, tas.filename tas_filename, tas.filesize tas_filesize, tas.loadtime tas_loadtime, tas.main
+        tas_main,
+        tas.islook tas_islook, tas.downexcel tas_downexcel, tas.old_name tas_old_name, tas.product_id tas_product_id,
+        tas.success_num tas_success_num,
+        tas.true_success_num tas_true_success_num, tas.default_num tas_default_num, tas.pram_json tas_pram_json,
+        tas.task_condition_id tas_task_condition_id, tas.create_time tas_create_time,
+        tas.task_name tas_task_name, tas.task_type tas_task_type,
+        con.id, con.task_id, con.task_type, con.task_type2, con.conditions,
+        con.crons, con.config_cells, con.config_id, con.task_name, con.total,
+        con.orderby, con.orderby_type, con.db_type, con.start_number, con.end_number,
+        con.isadd_patentnos, con.isdelete_patentnos
         from os_task tas
-        left join task_condition ass on tas.task_condition_id = ass.id
+        left join os_task tas2 on tas.task_condition_id = tas2.task_condition_id and tas.ctime &lt; tas2.ctime
+        left join task_condition con on tas.task_condition_id = con.id
         <where>
             <if test="projectId != null">
                 and tas.tid = #{projectId}
@@ -49,30 +63,32 @@
             <if test="projectId == null and reportId == null">
                 and tas.uid = #{createId}
             </if>
-            <if test="createName != null and createName != ''">
+            <if test="personIds != null and personIds.size > 0">
                 and tas.uid in
-                <foreach collection="personIds" separator="," open="(" close=")">
-                    #{personIds}
+                <foreach collection="personIds" item="n" separator="," open="(" close=")">
+                    #{n}
                 </foreach>
             </if>
             <if test="taskType != null">
-                and ass.task_type = #{taskType}
+                and tas.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 collection="taskStatus" item="n" separator="," open="(" close=")">
+                    #{n}
                 </foreach>
             </if>
+            <if test="true">
+                and tas2.id is null
+            </if>
         </where>
-        group by tas.task_condition_id
         order by
         <choose>
             <when test="orderBy != null">
-                ${orderBy} ${orderType}
+                tas.${orderBy} ${orderType}
             </when>
             <otherwise>
                 tas.id
@@ -81,7 +97,36 @@
     </select>
 
     <resultMap id="queryTasksMap" type="cn.cslg.pas.common.model.vo.QueryTaskVO">
-
+        <id column="tas_id" property="id"/>
+        <result column="tas_type" property="type"/>
+        <result column="tas_uid" property="createBy"/>
+        <result column="tas_ctime" property="startTime"/>
+        <result column="tas_tid" property="projectId"/>
+        <result column="tas_report_id" property="reportId"/>
+        <result column="tas_mun" property="total"/>
+        <result column="tas_endtime" property="endTime"/>
+        <result column="tas_status" property="status"/>
+        <result column="tas_filename" property="fileName"/>
+        <result column="tas_filesize" property="fileSize"/>
+        <result column="tas_success_num" property="successNum"/>
+        <result column="tas_true_success_num" property="trueSuccessNum"/>
+        <result column="tas_default_num" property="defaultNum"/>
+        <result column="tas_old_name" property="oldName"/>
+        <result column="tas_create_time" property="createTime"/>
+        <result column="tas_task_condition_id" property="taskConditionId"/>
+        <result column="tas_task_name" property="taskName"/>
+        <result column="tas_task_type" property="taskType"/>
+        <result column="tas_endtime" property="modifiedTime"/>
+        <result column="conditions" property="conditions"/>
+        <result column="crons" property="crons"/>
+        <result column="config_cells" property="configCells"/>
+        <result column="orderby" property="orderBy"/>
+        <result column="orderby_type" property="orderByType"/>
+        <result column="db_type" property="DBType"/>
+        <result column="start_number" property="startNumber"/>
+        <result column="end_number" property="endNumber"/>
+        <result column="isadd_patentnos" property="isAddPatentNos"/>
+        <result column="isdelete_patentnos" property="isDeletePatentNos"/>
     </resultMap>