Excel导入专利接口代码升级

PAS/src/main/java/cn/cslg/pas/common/config/QuartzConfig.java

@@ -1,35 +0,0 @@
-package cn.cslg.pas.common.config;
-
-import cn.cslg.pas.service.upLoadPatent.PatentToDbTaskJob;
-import org.quartz.*;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * job定义任务（任务描述和任务执行时间）
- */
-@Configuration
-public class QuartzConfig {
-    @Bean
-    public JobDetail jobDetail() {
-        //指定任务描述具体的实现类
-        return JobBuilder.newJob(PatentToDbTaskJob.class)
-                // 指定任务的名称
-                .withIdentity("webUploadJob", "Default")
-                // 每次任务执行后进行存储
-                .storeDurably()
-                .build();
-    }
-
-    @Bean
-    public Trigger trigger() {
-        //创建触发器
-        return TriggerBuilder.newTrigger()
-                // 绑定工作任务
-                .forJob(jobDetail())
-                // 每隔 5 秒执行一次 job
-                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5))
-                .withIdentity("webUploadTrigger", "Default")
-                .build();
-    }
-}

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

@@ -31,12 +31,20 @@ public class CreateTaskThread implements InitializingBean {
 
     @Override
     public void afterPropertiesSet() throws Exception {
-        //初始化任务列表数据（taskQueueList)
+        //初始化任务队列
         //查找任务状态为0（队列中）和1（进行中）的任务
         List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().in(Task::getStatus, new ArrayList<>(Arrays.asList(0, 1))));
         if (tasks.size() > 0) {
+            //过滤出任务的ids
             List<Integer> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());
-            //将任务ids存入 taskQueueList
+            //过滤出进行中的任务的id
+            List<Task> doingTasks = tasks.stream().filter(item -> item.getStatus() == 1).collect(Collectors.toList());
+            List<Integer> doingTaskIds = doingTasks.stream().map(Task::getId).collect(Collectors.toList());
+            if (doingTaskIds.size() > 0) {
+                //先将进行中的任务的id存入任务队列，再将其余存入
+                pantentQueueService.queueAddTask(Arrays.asList(doingTaskIds.get(0)));
+                taskIds.removeAll(doingTaskIds);
+            }
             pantentQueueService.queueAddTask(taskIds);
         }
 

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

@@ -0,0 +1,17 @@
+package cn.cslg.pas.common.model.dto;
+
+import lombok.Data;
+
+@Data
+public class ConfigDTO {
+
+    private String loginAccount;
+
+    private String loginPassword;
+
+    private Integer tenantId;
+
+    private Integer webId;
+
+
+}

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

@@ -0,0 +1,35 @@
+package cn.cslg.pas.common.model.dto;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+@Accessors(chain = true)
+@Data
+public class WebQueryDTO {
+    /**
+     * 专题库id
+     */
+    private Integer projectId;
+    /**
+     * 检索信息
+     */
+    private String conditions;
+    /**
+     * 网站id
+     */
+    private Integer webConfigId;
+    /**
+     * 任务id
+     */
+    private Integer taskId;
+    /**
+     * 报告id
+     */
+    private Integer reportId;
+    /**
+     * 下载字段
+     */
+    private List<String> conCells;
+}

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

@@ -0,0 +1,17 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+
+@Data
+public class ConfigVO {
+
+    private String loginAccount;
+
+    private String loginPassword;
+
+    private String webAddress;
+
+    private String webName;
+    private Integer id;
+    private Integer webId;
+}

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

@@ -0,0 +1,14 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+
+@Data
+public class QuartzVO {
+    /**
+     * 任务名称
+     */
+    private String jobName;
+    private String jobGroupName;
+    private String triggerName;
+    private String triggerGroupName;
+}

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+/**
+ * @author 沈永艺
+ * @date 2022-8-3
+ * @description VO基类
+ */
+
+@Data
+@Accessors(chain = true)
+public class QueryConfigVO extends BaseVO {
+    private Integer tenantId;
+    private Integer webId;
+    private String loginAccount;
+
+}

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

@@ -10,11 +10,13 @@ import cn.cslg.pas.domain.QrtzTask;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.service.TaskService;
+import cn.cslg.pas.service.upLoadPatent.JobService;
 import cn.cslg.pas.service.upLoadPatent.UploadTaskService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.quartz.SchedulerException;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
@@ -37,6 +39,7 @@ import java.io.IOException;
 public class TaskController {
     private final TaskService taskService;
     private final UploadTaskService uploadTaskService;
+    private final JobService jobService;
 
     @GetMapping("list")
     @Operation(summary = "任务列表")
@@ -65,17 +68,13 @@ public class TaskController {
 
     @PostMapping("add")
     @Operation(summary = "新增网站导入专利任务")
-    public String add(@RequestBody QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+    public String add(@RequestBody QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException, SchedulerException {
         //添加任务
-        uploadTaskService.addEpoTask(qrtzTaskAddNewDTO);
-
-//        if(qrtzTask==null){
-//            return Response.error("未配置网站登录信息");
-//        }
-//        //任务添加完，判断是定时任务则任务调度添加该定时任务
-//        if (qrtzTask.getTaskType() == 1) {
-//            jobService.addJob(qrtzTask);
-//        }
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = uploadTaskService.addEpoTask(qrtzTaskAddNewDTO);
+        //任务添加完，判断是定时任务则任务调度添加该定时任务
+        if (assoOsTaskQrtzTask.getTaskType() == 1) {
+            jobService.addJob(assoOsTaskQrtzTask);
+        }
         return Response.success("添加任务完成");
     }
 

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

@@ -17,6 +17,10 @@ import java.io.Serializable;
 @Data
 public class QueueData implements Serializable {
     /**
+     * 任务
+     */
+    private Task task;
+    /**
      * 专利实体类
      */
     private UploadParamsVO uploadParamsVO;

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

@@ -118,4 +118,10 @@ public class Task extends BaseEntity<Task> {
     @TableField(exist = false)
     private Integer lastIndex;
 
+    /**
+     * 所属任务条件id
+     */
+    @TableField("qrtz_task_id")
+    private Integer qrtzTaskId;
+
 }

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

@@ -0,0 +1,39 @@
+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 java.io.Serializable;
+
+/**
+ * 网站配置
+ * @TableName web_config
+ */
+@Data
+@TableName(value ="web_login_config")
+public class WebLoginConfig implements Serializable {
+    /**
+     * ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+    @TableField(value = "login_account")
+    private String loginAccount;
+
+    @TableField(value = "login_password")
+    private String loginPassword;
+
+    /**
+     * 账号
+     */
+    @TableField(value = "tenant_id")
+    private Integer tenantId;
+
+    @TableField(value = "web_Id")
+    private Integer webId;
+
+
+}

PAS/src/main/java/cn/cslg/pas/domain/asso/AssoOsTaskQrtzTask.java

@@ -60,5 +60,10 @@ public class AssoOsTaskQrtzTask implements Serializable {
      */
     @TableField(value = "task_name")
     private String taskName;
+    /**
+     * 专利总数量
+     */
+    @TableField(value = "total")
+    private Integer total;
 
 }

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

@@ -0,0 +1,16 @@
+package cn.cslg.pas.mapper;
+
+import cn.cslg.pas.domain.QrtzTask;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * @author admin
+ * @description 针对表【qrtz_task(定时任务表)】的数据库操作Mapper
+ * @createDate 2023-03-15 13:40:32
+ * @Entity com.example.demo.domain.entity.QrtzTask
+ */
+@Mapper
+public interface QrtzTaskMapper extends BaseMapper<QrtzTask> {
+}
+

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

@@ -0,0 +1,26 @@
+package cn.cslg.pas.mapper;
+
+
+import cn.cslg.pas.common.model.vo.ConfigVO;
+import cn.cslg.pas.common.model.vo.QueryConfigVO;
+import cn.cslg.pas.domain.WebLoginConfig;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+/**
+* @author admin
+* @description 针对表【web_config(网站配置)】的数据库操作Mapper
+* @createDate 2023-03-08 18:51:17
+* @Entity cn.cslg.pas.domain.WebConfig
+*/
+@Mapper
+public interface WebLoginConfigMapper extends BaseMapper<WebLoginConfig> {
+    IPage<ConfigVO> getPageList(Page<ConfigVO> page, @Param("params") QueryConfigVO params);
+}
+
+
+
+

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

@@ -12,6 +12,7 @@ import cn.cslg.pas.domain.Project;
 import cn.cslg.pas.domain.SystemDict;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.common.model.vo.TaskVO;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.mapper.TaskMapper;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.dev33.satoken.stp.StpUtil;
@@ -111,7 +112,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         Task task = new Task();
 
         //任务开始时间
-        task.setStartTime(DateUtils.getDateTime());
+        //task.setStartTime(DateUtils.getDateTime());
         //任务状态（0.队列中 1.进行中 2.成功 3.失败）
         task.setStatus(0);
         if (projectImportPatentVO.getProjectId() != null) {
@@ -152,16 +153,16 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
      * @param qrtzTaskAddNewDTO 前台参数
      * @return 返回任务id
      */
-    public Integer addTask3(QrtzTaskAddNewDTO qrtzTaskAddNewDTO, Integer total) {
+    public Integer addTask3(QrtzTaskAddNewDTO qrtzTaskAddNewDTO, Integer total, AssoOsTaskQrtzTask assoOsTaskQrtzTask) {
         //创建任务表实体类，准备装载数据 ↓
         Task task = new Task();
 
         //任务开始时间
-        task.setStartTime(DateUtils.getDateTime());
+        //task.setStartTime(DateUtils.getDateTime());
         //任务状态（0.队列中 1.进行中 2.成功 3.失败）
         task.setStatus(0);
         //专题库id
-        task.setProductId(qrtzTaskAddNewDTO.getProjectId());
+        task.setProjectId(qrtzTaskAddNewDTO.getProjectId());
         //专利总数量
         task.setTotal(total);
         //任务类型 （1上传 2导出 3网站导入）
@@ -174,6 +175,8 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setSuccessNum(0);
         //失败条数
         task.setDefaultNum(0);
+        //所属任务条件id
+        task.setQrtzTaskId(assoOsTaskQrtzTask.getId());
 
         //数据入任务表
         task.insert();

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

@@ -750,7 +750,6 @@ public class UploadPatentBatchService {
         if (patentCell.getPdf() != null) {
             patentInstructionService.edit(patentCell.getPatentNo(), patentCell.getPdf());
         }
-        getOneOrInsertOne(uploadParamsVO);
         //设置公开号
         patent.setPublicNo(patentCell.getPublicNo());
         uploadParamsVO.setSimpleStatus(patentCell.getStatue());

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

@@ -0,0 +1,75 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.model.PersonnelVO;
+import cn.cslg.pas.common.model.dto.ConfigDTO;
+import cn.cslg.pas.common.model.vo.ConfigVO;
+import cn.cslg.pas.common.model.vo.QueryConfigVO;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
+import cn.cslg.pas.domain.WebLoginConfig;
+import cn.cslg.pas.mapper.WebLoginConfigMapper;
+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 lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author admin
+ * @description 针对表【web_config(网站配置)】的数据库操作Service实现
+ * @createDate 2023-03-08 18:51:17
+ */
+@Service
+@RequiredArgsConstructor(onConstructor_ = {@Lazy})
+public class WebLoginConfigService extends ServiceImpl<WebLoginConfigMapper, WebLoginConfig> {
+    private final CacheUtils cacheUtils;
+    private final LoginUtils loginUtils;
+
+    //添加配置
+    public void addLoginConfig(ConfigDTO configDTO) {
+        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+        LambdaQueryWrapper<WebLoginConfig> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(WebLoginConfig::getWebId, configDTO.getWebId())
+                .eq(WebLoginConfig::getTenantId, personnelVO.getTenantId());
+        List<WebLoginConfig> configs = this.list(wrapper);
+        WebLoginConfig config = new WebLoginConfig();
+        if (configs.size() > 0) {
+            config = configs.get(0);
+        }
+        config.setWebId(configDTO.getWebId());
+        config.setTenantId(personnelVO.getTenantId());
+        config.setLoginAccount(configDTO.getLoginAccount());
+        config.setLoginPassword(configDTO.getLoginPassword());
+        this.saveOrUpdate(config);
+    }
+
+    public WebLoginConfig getLoginConfig(Integer webId, Integer tenantId) {
+        LambdaQueryWrapper<WebLoginConfig> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(WebLoginConfig::getWebId, webId)
+                .eq(WebLoginConfig::getTenantId, tenantId);
+        List<WebLoginConfig> configs = this.list(wrapper);
+        WebLoginConfig config = new WebLoginConfig();
+        if (configs.size() > 0) {
+            config = configs.get(0);
+        } else {
+            config = null;
+        }
+        return config;
+    }
+
+    public IPage<ConfigVO> queryLoginConfig(QueryConfigVO queryConfigVO) {
+        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+        queryConfigVO.setTenantId(personnelVO.getTenantId());
+        IPage<ConfigVO> dataPage = baseMapper.getPageList(new Page<>(queryConfigVO.getCurrent(), queryConfigVO.getSize()), queryConfigVO);
+        return dataPage;
+    }
+
+    public Boolean deleteConfig(List<Integer> ids) {
+        return this.removeByIds(ids);
+    }
+
+}

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

@@ -0,0 +1,658 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.common.model.PatentCell;
+import cn.cslg.pas.common.model.dto.*;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.utils.FileUtils;
+import cn.cslg.pas.common.utils.StringUtils;
+import cn.cslg.pas.common.utils.ThrowException;
+import cn.cslg.pas.domain.*;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.exception.XiaoShiException;
+import cn.cslg.pas.service.*;
+import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.spire.pdf.FileFormat;
+import com.spire.pdf.PdfDocument;
+import com.spire.pdf.PdfDocumentBase;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.fileupload.FileItem;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.commons.CommonsMultipartFile;
+
+import java.io.*;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Epo类型任务解析获取专利类
+ *
+ * @Author chenyu
+ * @Date 2023/6/16
+ */
+@Slf4j
+@RequiredArgsConstructor
+@Service
+public class ExcutePatentDataEpo implements IExcutePatentData {
+    private final FileUtils fileUtils;
+    private final PantentQueueService pantentQueueService;
+    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final OutInterfaceService outInterfaceService;
+    private final PatentInstructionService patentInstructionService;
+    private final PatentAgencyService patentAgencyService;
+    private final PatentAffairService patentAffairService;
+    private final ProjectPatentLinkService projectPatentLinkService;
+    private final PatentService patentService;
+
+    /**
+     * 解析获取专利数据
+     *
+     * @param task 任务
+     * @throws IOException 抛出IO异常
+     */
+    @Override
+    public void startExcute(Task task) throws IOException {
+        Integer taskId = task.getId();
+        List<AssoOsTaskQrtzTask> assoOsTaskQrtzTasks = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<AssoOsTaskQrtzTask>().eq(AssoOsTaskQrtzTask::getTaskId, taskId));
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTasks.get(0);
+
+        Integer successNum = task.getSuccessNum();
+
+        //从任务关联网站导入任务对象中取出下载字段、检索信息
+        String cellsStr = assoOsTaskQrtzTask.getConfigCells();
+        List<String> cells = Arrays.asList(cellsStr.split(","));
+        String conditions = assoOsTaskQrtzTask.getConditions();
+
+        //定义每次检索的专利数量(每次检索50件)
+        int size = 50;
+
+        //获得专利总数量
+        Integer count = task.getTotal();
+
+        //计算进度值
+//        double percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
+//        percentage = MathUtils.saveTwoDecimal(percentage);
+        //1.根据专利总数量count遍历检索专利
+        for (int i = 1; i <= count; i += size) {
+            //查看任务状态
+//            QrtzTaskDetail qrtzTaskDetail1 = qrTaskDetailService.getById(webQueryDTO.getTaskId());
+//            if (qrtzTaskDetail1.getTaskDetailState().equals(7)) {
+//                qrtzTaskDetail1.setTaskDetailState(5);
+//                qrtzTaskDetail1.setSuccessNum(successNum);
+//                qrtzTaskDetail1.setTaskProcess(percentage);
+//                qrtzTaskDetail1.updateById();
+//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
+//                        .setId(webQueryDTO.getTaskId())
+//                        .setProjectId(task.getProjectId())
+//                        .setComplete(false)
+//                        .setIndex(successNum)
+//                        .setTaskDetailState(5)
+//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
+//                return null;
+//            } else if (qrtzTaskDetail1.getTaskDetailState().equals(8)) {
+//                qrtzTaskDetail1.setTaskDetailState(6);
+//                qrtzTaskDetail1.setSuccessNum(successNum);
+//                qrtzTaskDetail1.setTaskProcess(percentage);
+//                qrtzTaskDetail1.updateById();
+//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
+//                        .setId(webQueryDTO.getTaskId())
+//                        .setProjectId(task.getProjectId())
+//                        .setComplete(false)
+//                        .setIndex(successNum)
+//                        .setTaskDetailState(6)
+//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
+//                return null;
+//            }
+            //根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
+            SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, i, i + size - 1);
+            //获取检索结果中的所有专利著录信息
+            if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
+                continue;
+            }
+            List<PatentZhuLu> patents = serachBiblioData.getPatents();
+            //2.遍历专利
+            for (PatentZhuLu patent : patents) {
+                PatentCell patentCell = new PatentCell();
+                patentCell.setProjectId(task.getProjectId());
+                PubNo pubNO = new PubNo();
+                //装载专利著录
+                if (cells.contains("1")) {
+                    setPatentZhuLu(patentCell, patent, pubNO);
+                }
+                //装载权要
+                if (cells.contains("2")) {
+                    setPatentClaim(patentCell, pubNO);
+                }
+                //装载说明书文本
+                if (cells.contains("3")) {
+                    setPatentInstructionText(patentCell, pubNO);
+                }
+
+                //以下代码是在准备一会要调用拿取各种附图的接口所需的参数(FullDocument->说明书pdf、Drawing->其他附图、FirstPageClipping->摘要附图)
+                String fullDocumentLink = "", fullDocumentType = "", drawingLink = "", drawingType = "", firstPageClippingLink = "", firstPageClippingType = "";
+                Integer fullDocumentPage = 0, drawingPage = 0, firstPageClippingPage = 0;
+                //根据当前专利号调用接口获取一会调用拿取各种附图的接口的参数
+                try {
+                    ImageInfo imageInfo = getImage(pubNO);
+                    for (Image image : imageInfo.getImages()) {
+                        //如果附件类型是说明书
+                        if (image.getImageType().equals("FullDocument")) {
+                            fullDocumentLink = image.getUrlLink();
+                            fullDocumentPage = image.getNumberOfPages();
+                            for (String formatOption : image.getFormatOptions()) {
+                                if (formatOption.contains("pdf")) {
+                                    fullDocumentType = formatOption;
+                                }
+                            }
+                        }
+                        //如果附件类型是其他附件
+                        if (image.getImageType().equals("Drawing")) {
+                            drawingLink = image.getUrlLink();
+                            drawingPage = image.getNumberOfPages();
+                            for (String formatOption : image.getFormatOptions()) {
+                                if (formatOption.contains("tiff")) {
+                                    drawingType = formatOption;
+                                }
+                            }
+                        }
+                        //如果附件类型是摘要附图
+                        if (image.getImageType().equals("FirstPageClipping")) {
+                            firstPageClippingLink = image.getUrlLink();
+                            firstPageClippingPage = image.getNumberOfPages();
+                            for (String formatOption : image.getFormatOptions()) {
+                                if (formatOption.contains("jpeg")) {
+                                    firstPageClippingType = formatOption;
+                                }
+                            }
+                        }
+                    }
+
+                    //装载说明书pdf
+                    if (cells.contains("4")) {
+                        setFuJian(fullDocumentLink, fullDocumentPage, fullDocumentType, patentCell, ".pdf");
+                    }
+                    //装载摘要附图
+                    if (cells.contains("6")) {
+                        setFuJian(firstPageClippingLink, firstPageClippingPage, firstPageClippingType, patentCell, ".jpeg");
+                    }
+                    //装载其他附图
+                    if (cells.contains("7")) {
+                        setFuJian(drawingLink, drawingPage, drawingType, patentCell, ".tiff");
+                    }
+
+                    //将专利发送到分析系统（保存专利入库）
+                    if (patentCell.getPatentNo() != null) {
+//                        String res = outInterfaceService.importPatents(patentCell);
+//                        JSONObject jsonObject = JSONObject.parseObject(res);
+//                        if (jsonObject.get("code").toString().equals("500")) {
+//                            //舍弃这个专利，继续下一个专利
+//                            continue;
+//                        }
+                        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+                        Patent patent2 = new Patent();
+                        //设置专利号
+                        patent2.setPatentNo(patentCell.getPatentNo());
+                        //设置摘要
+                        patent2.setAbstractStr(patentCell.getAbstrText());
+                        //设置标题
+                        patent2.setName(patentCell.getTitle());
+                        //设置公开日
+                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+                        if (patentCell.getPubilcDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getPubilcDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setPublicDate(ts);
+                        }
+                        //设置申请号
+                        patent2.setApplicationNo(patentCell.getApplicationNo());
+                        //设置申请日
+                        if (patentCell.getApplicationDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getApplicationDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setApplicationDate(ts);
+                        }
+                        //设置摘要附图
+                        patent2.setAbstractPath(patentCell.getPicUrl());
+                        //设置pdf文档
+                        if (patentCell.getPdf() != null) {
+                            patentInstructionService.edit(patentCell.getPatentNo(), patentCell.getPdf());
+                        }
+                        //设置公开号
+                        patent2.setPublicNo(patentCell.getPublicNo());
+                        uploadParamsVO.setSimpleStatus(patentCell.getStatue());
+                        uploadParamsVO.setPatent(patent2);
+                        getOneOrInsertOne(uploadParamsVO);
+                        if (patentCell.getAgency() != null && !patentCell.getAgency().equals("")) {
+                            uploadParamsVO.getPatent().setAgencyId(patentAgencyService.getAgencyStringIdByName(patentCell.getAgency()));
+                        }
+                        uploadParamsVO.setPatentRight(new PatentRight());
+                        uploadParamsVO.getPatentRight().setContent(StringUtils.join(patentCell.getRights(), ""));
+                        uploadParamsVO.setSelfContent(patentCell.getMainRignt());
+                        uploadParamsVO.setPatentInstructionText(new PatentInstructionText());
+                        uploadParamsVO.getPatentInstructionText().setManual(patentCell.getPatentInstructionText());
+                        //发明人
+                        List<String> inventors = patentCell.getInventors();
+                        if (inventors != null && inventors.size() > 0) {
+                            ArrayList<PatentInventor> patentInventors = new ArrayList<>();
+                            for (String inventor : inventors) {
+                                PatentInventor patentInventor = new PatentInventor();
+                                patentInventor.setName(inventor);
+                                patentInventors.add(patentInventor);
+                            }
+                            uploadParamsVO.setPatentInventorList(patentInventors);
+                        }
+                        uploadParamsVO.setPatentApplicantCurrentName(patentCell.getApplicationCurrents());
+                        uploadParamsVO.setPatentApplicantOriginalName(patentCell.getApplicationPersons());
+                        uploadParamsVO.setPatentApplicantOriginalAddress(patentCell.getApplicationAddress());
+                        uploadParamsVO.setIpcList(patentCell.getIpc());
+                        uploadParamsVO.setMainIpc(patentCell.getMainIpc());
+                        //代理人
+                        List<String> agencyPersons = patentCell.getAgencyPersons();
+                        if (agencyPersons != null && agencyPersons.size() > 0) {
+                            ArrayList<PatentAgent> patentAgents = new ArrayList<>();
+                            for (String agencyPerson : agencyPersons) {
+                                PatentAgent patentAgent = new PatentAgent();
+                                patentAgent.setName(agencyPerson);
+                                patentAgents.add(patentAgent);
+                            }
+                            uploadParamsVO.setPatentAgentList(patentAgents);
+                        }
+                        //事务信息 OS_PATENT_AFFAIR
+                        if (patentCell.getPatentAffairs() != null && patentCell.getPatentAffairs().size() > 0) {
+                            patentAffairService.updatePatientAffairs(patentCell.getPatentAffairs(), uploadParamsVO.getPatent().getId());
+                        }
+                        //当专题库id不为null时添加专利到专题库
+                        if (patentCell.getProjectId() != null) {
+                            projectPatentLinkService.updateProjectPatent(patentCell.getProjectId(), uploadParamsVO.getPatent().getId());
+                        }
+                        pantentQueueService.patentToQueue(task, uploadParamsVO, null);
+                    }
+
+//                    QrtzTaskDetail qrtzTaskDetail11 = qrTaskDetailService.getById(qrtzTaskDetail.getId());
+//                    percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
+//                    percentage = MathUtils.saveTwoDecimal(percentage);
+//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
+//                            .setId(webQueryDTO.getTaskId())
+//                            .setProjectId(task.getProjectId())
+//                            .setComplete(false)
+//                            .setIndex(successNum)
+//                            .setPercentage(percentage)
+//                            .setTaskDetailState(qrtzTaskDetail11.getTaskDetailState())
+//                            .setFileName("")
+//                            .setUrl("")
+//                            .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
+                } catch (XiaoShiException e) {
+                    //虽然拿不到所有附图，但已经拿到了专利著录，能拿到啥是啥
+                    log.info(e.getMessage());
+                } catch (Exception e) {
+//                    qrtzTaskDetail.setTaskDetailState(3);
+//                    qrtzTaskDetail.setSuccessNum(successNum);
+//                    qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
+//                    qrtzTaskDetail.setFailure("拉取节点失败");
+//                    qrtzTaskDetail.setEndTime(new Date());
+//                    qrtzTaskDetail.updateById();
+//                    if (qrtzTask.getTaskType() == 1) {
+//                        qrtzTask.setTaskState(4);
+//                    } else {
+//                        qrtzTask.setTaskState(3);
+//                    }
+//                    qrtzTask.updateById();
+//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
+//                            .setId(webQueryDTO.getTaskId())
+//                            .setProjectId(task.getProjectId())
+//                            .setComplete(true)
+//                            .setIndex(successNum)
+//                            .setPercentage(100D)
+//                            .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
+//                            .setFileName("")
+//                            .setUrl("")
+//                            .setTotal(successNum), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
+                }
+
+            }
+        }
+//        WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
+//                .setId(webQueryDTO.getTaskId())
+//                .setProjectId(task.getProjectId())
+//                .setComplete(true)
+//                .setIndex(count)
+//                .setPercentage(100D)
+//                .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
+//                .setFileName("")
+//                .setUrl("")
+//                .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
+//        //任务执行情况状态设为成功，任务条件状态设为已完成(若是任务条件是定时任务则设为等待下一次执行)
+//        qrtzTaskDetail.setTaskDetailState(2);
+//        qrtzTaskDetail.setSuccessNum(successNum);
+//        qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
+//        qrtzTaskDetail.setTaskProcess(100);
+//        qrtzTaskDetail.setEndTime(new Date());
+//        qrtzTaskDetail.updateById();
+//        if (qrtzTask.getTaskType() == 1) {
+//            qrtzTask.setTaskState(4);
+//        } else {
+//            qrtzTask.setTaskState(2);
+//        }
+//        qrtzTask.updateById();
+//        return patentCells;
+    }
+
+    //调用外部接口获取一批专利著录信息
+    public SerachBiblioData getSerachBiblioData(String conditions, Integer start, Integer size) throws IOException {
+        GetSearchBiblioParamsDTO getSearchBiblioParamsDTO = new GetSearchBiblioParamsDTO()
+                .setQuery(conditions)
+                .setStart(start)
+                .setEnd(size);
+        String res = outInterfaceService.getSearchBiblio(getSearchBiblioParamsDTO);
+        if (res == null || res.equals("")) {
+            return null;
+        }
+        JSONObject jsonObject = JSONObject.parseObject(res);
+        if (!jsonObject.get("status").toString().equals("200")) {
+            //若发生类似400、500等异常(杰哥处理)
+            return null;
+        }
+        //返回检索结果data
+        return JSONObject.parseObject(jsonObject.get("data").toString(), SerachBiblioData.class);
+    }
+
+    /**
+     * 装载著录方法
+     *
+     * @param patentCell 实体类对象
+     * @param patent     专利对象
+     * @param pubNo      公开号对象
+     */
+    private void setPatentZhuLu(PatentCell patentCell, PatentZhuLu patent, PubNo pubNo) {
+        //装载申请号
+        for (AppNo appNo : patent.getAppNos()) {
+            if (appNo.getType().equals("docdb")) {
+                patentCell.setApplicationNo(appNo.getCountry() + appNo.getNumber() + appNo.getKind());
+            }
+        }
+        //装载申请日
+        patentCell.setApplicationDate(patent.getAppDate());
+        //装载国家/省市
+        patentCell.setCountry(patent.getAppCountry());
+        //装载公开号
+        for (PubNo n : patent.getPubNos()) {
+            if (n.getType().equals("docdb")) {
+                BeanUtils.copyProperties(n, pubNo);
+                patentCell.setPublicNo(n.getCountry() + n.getNumber() + n.getKind());
+            }
+        }
+        //装载专利号
+        patentCell.setPatentNo(patentCell.getPublicNo());
+        //装载公开日
+        patentCell.setPubilcDate(patent.getPubDate());
+        //装载授权公告号(未找到)
+        //装载授权公告日(未找到)
+        //装载主分类号
+        List<String> ipCs = patent.getIpCs();
+        List<String> cpCs = patent.getCpCs();
+        ipCs.addAll(cpCs);
+        if (ipCs != null && ipCs.size() > 0) {
+            patentCell.setMainIpc(ipCs.get(0));
+        }
+        //装载分类号
+        if (ipCs != null && ipCs.size() > 0) {
+            patentCell.setIpc(ipCs);
+        }
+        //装载申请人
+        ArrayList<String> applicationPersons = new ArrayList<>();
+        for (Application application : patent.getApplications()) {
+            if (application.getOriginalName().contains("(标：)")) {
+                application.setOriginalName(application.getOriginalName().substring(0, application.getOriginalName().indexOf("(标：)")));
+            }
+            applicationPersons.add(application.getOriginalName());
+        }
+        patentCell.setApplicationPersons(applicationPersons);
+        //装载申请人地址(未找到)
+        //装载发明人
+        ArrayList<String> inventors = new ArrayList<>();
+        for (Inventor inventor : patent.getInventors()) {
+            inventors.add(inventor.getOriginalName());
+        }
+        patentCell.setInventors(inventors);
+        //装载当前权利人(未找到)
+        //装载代理人(未找到)
+        //装载代理机构(未找到)
+        //装载范畴分类(未找到)
+        //装载当前状态(未找到)
+        //装载同族号
+        patentCell.setFamilyId(patent.getFamilyId());
+        //装载著录标题
+        String olTitle = patent.getOlTitle();
+        String enTitle = patent.getEnTitle();
+        if (olTitle == null) {
+            patentCell.setTitle(enTitle);
+        } else {
+            patentCell.setTitle(olTitle);
+        }
+        //装载摘要
+        String olAbstract = patent.getOlAbstract();
+        String enAbstract = patent.getEnAbstract();
+        if (olAbstract == null) {
+            patentCell.setAbstrText(enAbstract);
+        } else {
+            patentCell.setAbstrText(olAbstract);
+        }
+        //装载优先权号、优先权国家、优先权日
+        ArrayList<Priority> priorities = new ArrayList<>();
+        List<Priorityy> priorties = patent.getPriorties();
+        for (Priorityy priorty : priorties) {
+            for (PriorityNumber number : priorty.getNumbers()) {
+                if (number.getType().equals("epodoc")) {
+                    Priority priority = new Priority()
+                            .setPriorityNo(number.getNumber().substring(2))
+                            .setPriorityCountry(number.getNumber().substring(0, 2))
+                            .setPriorityDate(priorty.getDate());
+                    priorities.add(priority);
+                }
+            }
+        }
+        patentCell.setPriorities(priorities);
+    }
+
+    /**
+     * 装载权要方法
+     *
+     * @param patentCell 实体类对象
+     * @param pubNo      公开号对象
+     */
+    private void setPatentClaim(PatentCell patentCell, PubNo pubNo) throws IOException {
+        GetClaimsInfoParamsDTO getClaimsInfoParamsDTO = new GetClaimsInfoParamsDTO()
+                .setCc(pubNo.getCountry())
+                .setNumber(pubNo.getNumber())
+                .setKind(pubNo.getKind());
+        String res = outInterfaceService.getClaimsInfo(getClaimsInfoParamsDTO);
+        JSONObject jsonObject = JSONObject.parseObject(res);
+        if (!jsonObject.get("status").toString().equals("200")) {
+            //若发生类似400、500等异常(杰哥处理)
+            //ThrowException.throwXiaoShiException("权要接口无法检索该国家专利");
+            log.info("权要接口无法检索该国家专利");
+            return;
+        }
+        //拿到检索结果(未格式化的含有页面等标签的权要)并格式化权要
+        //String unformatRight = JSONObject.parseObject(jsonObject.get("data").toString(), String.class);
+        ArrayList<String> unformatRights = JSONObject.parseObject(jsonObject.get("data").toString(), ArrayList.class);
+        //String[] rightArr = unformatRight.split("\n");
+        //ArrayList<String> rights = new ArrayList<>(Arrays.asList(rightArr));
+        patentCell.setRights(unformatRights);
+    }
+
+    /**
+     * 装载说明书方法
+     *
+     * @param patentCell 实体类对象
+     * @param pubNo      公开号对象
+     */
+    private void setPatentInstructionText(PatentCell patentCell, PubNo pubNo) throws IOException {
+        GetDescriptionInfoParamsDTO getDescriptionInfoParamsDTO = new GetDescriptionInfoParamsDTO()
+                .setCc(pubNo.getCountry())
+                .setNumber(pubNo.getNumber())
+                .setKind(pubNo.getKind());
+        String res = outInterfaceService.getDescriptionInfo(getDescriptionInfoParamsDTO);
+        JSONObject jsonObject = JSONObject.parseObject(res);
+        if (!jsonObject.get("status").toString().equals("200")) {
+            //若发生类似400、500等异常(杰哥处理)
+            //ThrowException.throwXiaoShiException("说明书接口无法检索该国家专利");
+            log.info("说明书接口无法检索该国家专利");
+            return;
+        }
+        //拿到检索结果(未格式化的含有页面等标签的说明书)
+        //String unformatInstructionText = JSONObject.parseObject(jsonObject.get("data").toString(), String.class);
+        List<String> unformatInstructionText = JSONObject.parseObject(jsonObject.get("data").toString(), List.class);
+        StringBuilder builder = new StringBuilder();
+        for (String n : unformatInstructionText) {
+            builder.append(n);
+        }
+//        String regex = "<p>(.+?)</p>";
+//        Matcher matcher = Pattern.compile(regex).matcher(unformatInstructionText);
+//        if (matcher.find()) {
+//            patentCell.setPatentInstructionText(matcher.group());
+//        }
+        patentCell.setPatentInstructionText(builder + "");
+    }
+
+    /**
+     * 获取Image信息方法(从信息中获取三种附图的检索参数)
+     *
+     * @param pubNo 公开号对象
+     */
+    private ImageInfo getImage(PubNo pubNo) throws IOException {
+        String res = outInterfaceService.getImagesInfo(pubNo);
+        JSONObject jsonObject = JSONObject.parseObject(res);
+        if (!jsonObject.get("status").toString().equals("200")) {
+            //若发生类似400、500等异常(杰哥处理)
+            ThrowException.throwXiaoShiException("Image信息接口无法检索该国家专利");
+        }
+        //拿到检索结果(未格式化的含有页面等标签的说明书)
+        String unFormatData = jsonObject.get("data").toString();
+        String data = unFormatData.substring(unFormatData.indexOf("[") + 1, unFormatData.lastIndexOf("]"));
+        ImageInfo imageInfo = JSONObject.parseObject(data, ImageInfo.class);
+        return imageInfo;
+    }
+
+    /**
+     * 装载说明书附件pdf方法
+     *
+     * @param link       附件链接
+     * @param page       附件页数
+     * @param type       附件类型
+     * @param patentCell 实体类对象
+     */
+    private void setFuJian(String link, Integer page, String type, PatentCell patentCell, String FuJianSuffix) throws Exception {
+        //合并说明书pdf文档时所需的读取流数组
+        InputStream[] streams = new InputStream[page];
+        //其他附图url数组
+        ArrayList<String> otherUrls = new ArrayList<>();
+        //遍历附件页数
+        for (int i = 1; i <= page; i++) {
+            GetFuTuParamsDTO getFuTuParamsDTO = new GetFuTuParamsDTO()
+                    .setLink(link)
+                    .setPage(i)
+                    .setType(type);
+            byte[] buffer = outInterfaceService.getPatentFile(getFuTuParamsDTO);
+            InputStream inputStream = new ByteArrayInputStream(buffer);
+            streams[i - 1] = inputStream;
+            //如果不是说明书pdf
+            if (!FuJianSuffix.equals(".pdf")) {
+                File file = File.createTempFile("new_url", FuJianSuffix);
+                FileOutputStream out = new FileOutputStream(file);
+                out.write(buffer);
+                out.close();
+                streams[i - 1] = new FileInputStream(file);
+                DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
+                FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
+                int bytesRead = 0;
+                buffer = new byte[8192];
+                try {
+                    FileInputStream fis = new FileInputStream(file);
+                    OutputStream os = item.getOutputStream();
+                    int len = 8192;
+                    while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
+                        os.write(buffer, 0, bytesRead);
+                    }
+                    os.close();
+                    fis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                MultipartFile multipartFile = new CommonsMultipartFile(item);
+                UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
+                //如果是摘要附图
+                if (FuJianSuffix.equals(".jpeg")) {
+                    patentCell.setPicUrl(fileDTO.getPath());
+                }
+                //如果是其他附图
+                if (FuJianSuffix.equals(".tiff")) {
+                    otherUrls.add(fileDTO.getPath());
+                }
+            }
+        }
+
+        //如果是说明书pdf
+        if (FuJianSuffix.equals(".pdf")) {
+            //合并说明书多个pdf文件
+            PdfDocumentBase doc = PdfDocument.mergeFiles(streams);
+            //保存结果文件
+            doc.save("merge.pdf", FileFormat.PDF);
+            doc.close();
+
+            //手动将合并后的pdf文件转成MultipartFile，上传文件并获取path装载到patentCell
+            File file = new File("merge.pdf");
+            DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
+            FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
+            int bytesRead = 0;
+            byte[] buffer = new byte[8192];
+            try {
+                FileInputStream fis = new FileInputStream(file);
+                OutputStream os = item.getOutputStream();
+                int len = 8192;
+                while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
+                    os.write(buffer, 0, bytesRead);
+                }
+                os.close();
+                fis.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            MultipartFile multipartFile = new CommonsMultipartFile(item);
+            UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
+            patentCell.setPdf(fileDTO);
+        } else if (FuJianSuffix.equals(".tiff")) {
+            patentCell.setOtherUrls(otherUrls);
+        }
+
+    }
+
+    /**
+     * @param uploadParamsVO 全局类
+     * @date 2022-7-11
+     * @name 工具方法
+     * @description 查询数据是否存在 如果存在 返回该条数据 如果不存在 新增一条数据
+     */
+    public void getOneOrInsertOne(UploadParamsVO uploadParamsVO) {
+        if (uploadParamsVO.getPatent() != null) {
+            uploadParamsVO.getPatent().setPatentNo(uploadParamsVO.getPatent().getPatentNo().trim());
+            //用专利号查询该条数据是否存在
+            Patent patent = patentService.getByPatentNo(uploadParamsVO.getPatent().getPatentNo());
+            //如果不存在就新增一条
+            if (patent == null) {
+                uploadParamsVO.getPatent().insert();
+            } else {
+                uploadParamsVO.getPatent().setId(patent.getId());
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,64 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.model.vo.UploadSettingVO;
+import cn.cslg.pas.common.utils.FileUtils;
+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 lombok.RequiredArgsConstructor;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Excel类型任务解析获取专利类
+ *
+ * @Author chenyu
+ * @Date 2023/6/16
+ */
+@Service
+@RequiredArgsConstructor
+public class ExcutePatentDataExcel implements IExcutePatentData {
+    private final FileUtils fileUtils;
+    private final ExcuteUploadSettingService excuteUploadSettingService;
+    private final ExcuteDataToVOService excuteDataToVOService;
+    private final PantentQueueService pantentQueueService;
+
+    /**
+     * 解析获取专利数据
+     *
+     * @param task 任务
+     * @throws IOException 抛出IO异常
+     */
+    @Override
+    public void startExcute(Task task) throws IOException {
+        //从任务中取出文件路径、总条数、成功条数、前台参数json
+        String filePath = task.getUrl();  //相对路径
+        filePath = fileUtils.getPath(filePath);  //绝对路径
+        Integer total = task.getTotal();
+
+        int lastIndex = task.getSuccessNum();
+        String json = task.getPramJson();
+        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(json, 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++) {
+            PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
+            //调用装载数据类，专利数据转换为VO对象
+            UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
+
+            //专利入消费者队列，并唤醒消费者执行专利入库
+            //patentToQueueAwakeConsumer(uploadParamsVO, projectImportPatentVO);
+            pantentQueueService.patentToQueue(task, uploadParamsVO, projectImportPatentVO);
+        }
+    }
+
+}

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

@@ -9,9 +9,7 @@ import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.domain.*;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.exception.XiaoShiException;
-import cn.cslg.pas.service.OutInterfaceService;
-import cn.cslg.pas.service.TaskService;
-import cn.cslg.pas.service.UploadPatentBatchService;
+import cn.cslg.pas.service.*;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -29,6 +27,7 @@ import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.multipart.commons.CommonsMultipartFile;
 
 import java.io.*;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
@@ -50,6 +49,11 @@ public class ExcuteTaskToPatentService implements Serializable {
     private final PantentQueueService pantentQueueService;
     private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
     private final OutInterfaceService outInterfaceService;
+    private final PatentInstructionService patentInstructionService;
+    private final PatentAgencyService patentAgencyService;
+    private final PatentAffairService patentAffairService;
+    private final ProjectPatentLinkService projectPatentLinkService;
+    private final PatentService patentService;
     private final TaskService taskService;
 
     //TODO 工厂类
@@ -90,7 +94,7 @@ public class ExcuteTaskToPatentService implements Serializable {
 
             //专利入消费者队列，并唤醒消费者执行专利入库
             //patentToQueueAwakeConsumer(uploadParamsVO, projectImportPatentVO);
-            pantentQueueService.patentToQueue(uploadParamsVO, projectImportPatentVO);
+            pantentQueueService.patentToQueue(task, uploadParamsVO, projectImportPatentVO);
         }
     }
 
@@ -113,22 +117,14 @@ public class ExcuteTaskToPatentService implements Serializable {
 
         //定义每次检索的专利数量(每次检索50件)
         int size = 50;
-        //2.根据检索式conditions先检索一件专利著录信息【此操作主要是为了获得专利总数量count】
-//        SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, 1, 1);
-//        if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
-//            //conditions没有检索到任何相关专利(杰哥处理)
-//            ThrowException.throwXiaoShiException("检索失败，根据检索条件未检索出任何相关专利信息");
-//            return;
-//        }
 
         //获得专利总数量
-//        Integer count = serachBiblioData.getTotals();
         Integer count = task.getTotal();
 
         //计算进度值
 //        double percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
 //        percentage = MathUtils.saveTwoDecimal(percentage);
-        //3.根据专利总数量count遍历检索专利
+        //1.根据专利总数量count遍历检索专利
         for (int i = 1; i <= count; i += size) {
             //查看任务状态
 //            QrtzTaskDetail qrtzTaskDetail1 = qrTaskDetailService.getById(webQueryDTO.getTaskId());
@@ -159,14 +155,14 @@ public class ExcuteTaskToPatentService implements Serializable {
 //                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
 //                return null;
 //            }
-            //3.1根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
+            //根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
             SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, i, i + size - 1);
             //获取检索结果中的所有专利著录信息
             if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
                 continue;
             }
             List<PatentZhuLu> patents = serachBiblioData.getPatents();
-            //3.2遍历专利
+            //2.遍历专利
             for (PatentZhuLu patent : patents) {
                 PatentCell patentCell = new PatentCell();
                 patentCell.setProjectId(task.getProjectId());
@@ -238,12 +234,90 @@ public class ExcuteTaskToPatentService implements Serializable {
 
                     //将专利发送到分析系统（保存专利入库）
                     if (patentCell.getPatentNo() != null) {
-                        String res = outInterfaceService.importPatents(patentCell);
-                        JSONObject jsonObject = JSONObject.parseObject(res);
-                        if (jsonObject.get("code").toString().equals("500")) {
-                            //舍弃这个专利，继续下一个专利
-                            continue;
+//                        String res = outInterfaceService.importPatents(patentCell);
+//                        JSONObject jsonObject = JSONObject.parseObject(res);
+//                        if (jsonObject.get("code").toString().equals("500")) {
+//                            //舍弃这个专利，继续下一个专利
+//                            continue;
+//                        }
+                        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+                        Patent patent2 = new Patent();
+                        //设置专利号
+                        patent2.setPatentNo(patentCell.getPatentNo());
+                        //设置摘要
+                        patent2.setAbstractStr(patentCell.getAbstrText());
+                        //设置标题
+                        patent2.setName(patentCell.getTitle());
+                        //设置公开日
+                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+                        if (patentCell.getPubilcDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getPubilcDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setPublicDate(ts);
+                        }
+                        //设置申请号
+                        patent2.setApplicationNo(patentCell.getApplicationNo());
+                        //设置申请日
+                        if (patentCell.getApplicationDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getApplicationDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setApplicationDate(ts);
+                        }
+                        //设置摘要附图
+                        patent2.setAbstractPath(patentCell.getPicUrl());
+                        //设置pdf文档
+                        if (patentCell.getPdf() != null) {
+                            patentInstructionService.edit(patentCell.getPatentNo(), patentCell.getPdf());
+                        }
+                        //设置公开号
+                        patent2.setPublicNo(patentCell.getPublicNo());
+                        uploadParamsVO.setSimpleStatus(patentCell.getStatue());
+                        uploadParamsVO.setPatent(patent2);
+                        getOneOrInsertOne(uploadParamsVO);
+                        if (patentCell.getAgency() != null && !patentCell.getAgency().equals("")) {
+                            uploadParamsVO.getPatent().setAgencyId(patentAgencyService.getAgencyStringIdByName(patentCell.getAgency()));
+                        }
+                        uploadParamsVO.setPatentRight(new PatentRight());
+                        uploadParamsVO.getPatentRight().setContent(StringUtils.join(patentCell.getRights(), ""));
+                        uploadParamsVO.setSelfContent(patentCell.getMainRignt());
+                        uploadParamsVO.setPatentInstructionText(new PatentInstructionText());
+                        uploadParamsVO.getPatentInstructionText().setManual(patentCell.getPatentInstructionText());
+                        //发明人
+                        List<String> inventors = patentCell.getInventors();
+                        if (inventors != null && inventors.size() > 0) {
+                            ArrayList<PatentInventor> patentInventors = new ArrayList<>();
+                            for (String inventor : inventors) {
+                                PatentInventor patentInventor = new PatentInventor();
+                                patentInventor.setName(inventor);
+                                patentInventors.add(patentInventor);
+                            }
+                            uploadParamsVO.setPatentInventorList(patentInventors);
+                        }
+                        uploadParamsVO.setPatentApplicantCurrentName(patentCell.getApplicationCurrents());
+                        uploadParamsVO.setPatentApplicantOriginalName(patentCell.getApplicationPersons());
+                        uploadParamsVO.setPatentApplicantOriginalAddress(patentCell.getApplicationAddress());
+                        uploadParamsVO.setIpcList(patentCell.getIpc());
+                        uploadParamsVO.setMainIpc(patentCell.getMainIpc());
+                        //代理人
+                        List<String> agencyPersons = patentCell.getAgencyPersons();
+                        if (agencyPersons != null && agencyPersons.size() > 0) {
+                            ArrayList<PatentAgent> patentAgents = new ArrayList<>();
+                            for (String agencyPerson : agencyPersons) {
+                                PatentAgent patentAgent = new PatentAgent();
+                                patentAgent.setName(agencyPerson);
+                                patentAgents.add(patentAgent);
+                            }
+                            uploadParamsVO.setPatentAgentList(patentAgents);
                         }
+                        //事务信息 OS_PATENT_AFFAIR
+                        if (patentCell.getPatentAffairs() != null && patentCell.getPatentAffairs().size() > 0) {
+                            patentAffairService.updatePatientAffairs(patentCell.getPatentAffairs(), uploadParamsVO.getPatent().getId());
+                        }
+                        //当专题库id不为null时添加专利到专题库
+                        if (patentCell.getProjectId() != null) {
+                            projectPatentLinkService.updateProjectPatent(patentCell.getProjectId(), uploadParamsVO.getPatent().getId());
+                        }
+                        pantentQueueService.patentToQueue(task, uploadParamsVO, null);
                     }
 
 //                    QrtzTaskDetail qrtzTaskDetail11 = qrTaskDetailService.getById(qrtzTaskDetail.getId());
@@ -603,7 +677,26 @@ public class ExcuteTaskToPatentService implements Serializable {
             patentCell.setOtherUrls(otherUrls);
         }
 
+    }
 
+    /**
+     * @param uploadParamsVO 全局类
+     * @date 2022-7-11
+     * @name 工具方法
+     * @description 查询数据是否存在 如果存在 返回该条数据 如果不存在 新增一条数据
+     */
+    public void getOneOrInsertOne(UploadParamsVO uploadParamsVO) {
+        if (uploadParamsVO.getPatent() != null) {
+            uploadParamsVO.getPatent().setPatentNo(uploadParamsVO.getPatent().getPatentNo().trim());
+            //用专利号查询该条数据是否存在
+            Patent patent = patentService.getByPatentNo(uploadParamsVO.getPatent().getPatentNo());
+            //如果不存在就新增一条
+            if (patent == null) {
+                uploadParamsVO.getPatent().insert();
+            } else {
+                uploadParamsVO.getPatent().setId(patent.getId());
+            }
+        }
     }
 
 }

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

@@ -0,0 +1,23 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.domain.Task;
+
+import javax.annotation.PostConstruct;
+import java.io.IOException;
+
+/**
+ * 解析获取专利数据的超类接口
+ *
+ * @Author chenyu
+ * @Date 2023/6/16
+ */
+public interface IExcutePatentData {
+    /**
+     * 解析获取专利数据
+     *
+     * @param task 任务
+     * @throws IOException 抛出IO异常
+     */
+    void startExcute(Task task) throws IOException;
+
+}

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

@@ -0,0 +1,140 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.common.model.vo.QuartzVO;
+import cn.cslg.pas.domain.QrtzTask;
+import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.TaskService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.*;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor(onConstructor_ = {@Lazy})
+public class JobService {
+
+    private final Scheduler scheduler;
+
+    private final QrTaskService qrTaskService;
+    private final TaskService taskService;
+    //private final QrTaskDetailService qrTaskDetailService;
+
+    /**
+     * 删除job
+     *
+     * @throws SchedulerException
+     */
+    public void deleteJob(Integer taskId) throws SchedulerException {
+        QuartzVO quartzVO = this.generateQuartzVO(taskId);
+        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::getQrtzTaskId, taskId);
+        taskService.remove(queryWrapper);
+    }
+
+    /**
+     * 暂停job
+     *
+     * @throws SchedulerException
+     */
+//    public void pauseJob(Integer taskId) throws SchedulerException {
+//        QuartzVO quartzVO = this.generateQuartzVO(taskId);
+//        //更新任务条件状态
+//        qrTaskService.updateState(taskId, 6);
+//        JobKey jobKey = JobKey.jobKey(quartzVO.getJobName(), quartzVO.getJobGroupName());
+//        scheduler.pauseJob(jobKey);
+//    }
+
+    /**
+     * 恢复job
+     *
+     * @throws SchedulerException
+     */
+//    public void resumeJob(Integer taskId) throws SchedulerException {
+//        QuartzVO quartzVO = this.generateQuartzVO(taskId);
+//        qrTaskService.updateState(taskId, 1);
+//        JobKey jobKey = JobKey.jobKey(quartzVO.getJobName(), quartzVO.getJobGroupName());
+//        scheduler.resumeJob(jobKey);
+//    }
+
+    /**
+     * 修改定时任务
+     *
+     * @param
+     */
+    public void updateJob(QrtzTask qrtzTask) {
+        //更新任务
+
+        QuartzVO quartzVO = this.generateQuartzVO(qrtzTask.getId());
+        JobDataMap jobDataMap = new JobDataMap();
+        jobDataMap.put("qrtzTask", qrtzTask);
+        TriggerKey oldTriggerKey = TriggerKey.triggerKey(quartzVO.getTriggerName(), quartzVO.getTriggerGroupName());
+        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(qrtzTask.getCrons());
+        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
+                .withIdentity(oldTriggerKey).usingJobData(jobDataMap).withSchedule(scheduleBuilder).build();
+        try {
+            scheduler.rescheduleJob(oldTriggerKey, cronTrigger);
+        } catch (SchedulerException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 新增job任务
+     *
+     * @throws SchedulerException
+     */
+    @Transactional
+    public void addJob(AssoOsTaskQrtzTask assoOsTaskQrtzTask) throws SchedulerException {
+        //添加一条任务记录
+        QuartzVO quartzVO = this.generateQuartzVO(assoOsTaskQrtzTask.getId());
+        JobDataMap jobDataMap = new JobDataMap();
+        jobDataMap.put("assoOsTaskQrtzTask", assoOsTaskQrtzTask);
+        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(assoOsTaskQrtzTask.getCrons());
+        JobDetail jobDetail = JobBuilder
+                .newJob(TaskAddJob.class)
+                .withIdentity(quartzVO.getJobName(), quartzVO.getJobGroupName())
+                .build();
+        Trigger trigger = TriggerBuilder
+                .newTrigger()
+                .withIdentity(quartzVO.getTriggerName(), quartzVO.getTriggerGroupName())
+                .withSchedule(cronScheduleBuilder)
+                .usingJobData(jobDataMap)
+                .build();
+        scheduler.scheduleJob(jobDetail, trigger);
+
+    }
+
+
+    public QuartzVO generateQuartzVO(Integer taskId) {
+        QuartzVO quartzVO = new QuartzVO();
+        quartzVO.setJobName("Job_" + taskId);
+        quartzVO.setJobGroupName("Default");
+        quartzVO.setTriggerName("Trigger_" + taskId);
+        quartzVO.setTriggerGroupName("Default");
+        return quartzVO;
+
+    }
+
+    /**
+     * 停止正在进行的job
+     *
+     * @throws SchedulerException
+     */
+    public void interruptJob(Integer taskId) throws SchedulerException {
+        QuartzVO quartzVO = this.generateQuartzVO(taskId);
+        JobKey jobKey = JobKey.jobKey(quartzVO.getJobName(), quartzVO.getJobGroupName());
+        scheduler.interrupt(jobKey);
+    }
+}

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

@@ -7,6 +7,7 @@ import cn.cslg.pas.domain.QueueData;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -25,16 +26,18 @@ import java.util.concurrent.locks.ReentrantLock;
 public class PantentQueueService {
     private final UploadPatentToDBService uploadPatentToDBService;
     private final UploadPatentBatchService uploadPatentBatchService;
-    private final ExcuteTaskToPatentService excuteTaskToPatentService;
     private final MessageService messageService;
     private final TaskService taskService;
+    private final ExcutePatentDataExcel excutePatentDataExcel;
+    private final ExcutePatentDataEpo excutePatentDataEpo;
+    private final List<Integer> taskQueueList = new ArrayList<>();
+    //private Task task = null;
+    private Boolean flag = false;
     private final Queue<QueueData> patentImageQueue = new LinkedList<>();
     private final Queue<QueueData> patentZhuluQueue = new LinkedList<>();
     private final Queue<QueueData> patentRightQueue = new LinkedList<>();
     private final Queue<QueueData> patentInstructionTextQueue = new LinkedList<>();
     private final Queue<QueueData> patentAssoQueue = new LinkedList<>();
-    private final List<Integer> taskQueueList = new ArrayList<>();
-    private Boolean flag = false;
     private final Lock taskLock = new ReentrantLock();
     private final Lock patentImageLock = new ReentrantLock();
     private final Lock patentZhuluLock = new ReentrantLock();
@@ -47,31 +50,39 @@ public class PantentQueueService {
     private final Condition patentRightCondition = patentRightLock.newCondition();
     private final Condition patentInstructionTextCondition = patentInstructionTextLock.newCondition();
     private final Condition patentAssoCondition = patentAssoLock.newCondition();
-    private final HashMap<Integer, Integer> patentIdMap = new HashMap<>();
-    private Task task = null;
-    private Integer patentFinishNum = 0;
+    private final HashMap<String, Integer> patentIdMap = new HashMap<>();
 
     /**
      * 生产者：从任务队列取出任务解析专利，将专利分配给消费者消费
      */
     public void addPatnetToQueue() {
+        Task task = null;
         try {
             while (true) {
-                //检查任务队列
+                //判断任务队列是否有任务，若没有则生产者线程睡眠
                 if (taskQueueList.size() == 0) {
                     taskLock.lock();
                     taskCondition.await();
                 }
-                //1.从taskQueueList中取出第一个task，将其状态改为进行中，并将其从任务队列taskQueueList中删除
-                task = taskService.getById(taskQueueList.get(0));
-                task.setStatus(1);
-                taskService.updateById(task);
-                taskQueueList.remove(0);
 
-                patentIdMap.put(0, task.getTotal());
+                //线程被唤醒后 ↓
+                //List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
+                //if (taskQueueList.size() > 0 && (tasks == null || tasks.size() == 0)) {
+                if (taskQueueList.size() > 0) {
+                    //1.从任务队列中取出一个task
+                    task = taskService.getById(taskQueueList.get(0));
+                    //从队列中剔除该任务
+                    taskQueueList.remove(0);
+
+                    //TODO 调用工厂方法，将任务扔进去，工厂方法根据任务类型返回对应的生产专利方法对象
+                    //1.用工厂方法根据任务类型创建对应的获取专利数据的对象
+                    IExcutePatentData excutePatentDataObject = createObject(task);
+                    //2.开始执行方法（解析获取专利并丢入消费者专利队列，唤醒消费者线程）
+                    if (excutePatentDataObject != null) {
+                        excutePatentDataObject.startExcute(task);
+                    }
 
-                //TODO 调用工厂方法，将任务传入，解析任务类型匹配对应的生产专利方法
-                excuteTaskToPatentService.taskToPatentQueue(task);
+                }
 
             }
 
@@ -105,7 +116,7 @@ public class PantentQueueService {
                     //摘要附图入库
                     uploadPatentToDBService.uploadPatentImage(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
                 }
 
             } catch (Exception e) {
@@ -136,7 +147,7 @@ public class PantentQueueService {
                     //著录项目入库
                     uploadPatentToDBService.uploadPatentZhulu(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
                 }
 
             } catch (Exception e) {
@@ -166,7 +177,7 @@ public class PantentQueueService {
                     //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
                 }
 
             } catch (Exception e) {
@@ -196,7 +207,7 @@ public class PantentQueueService {
                     //说明书文本入库
                     uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
                 }
 
             } catch (Exception e) {
@@ -230,7 +241,7 @@ public class PantentQueueService {
                     //文件夹与专利关联入库
                     uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
                 }
 
             } catch (Exception e) {
@@ -243,39 +254,62 @@ public class PantentQueueService {
     public void sendMessage(QueueData queueData, Integer total, Task task) {
         //每完成一个专利，通过计算，发送进度
         synchronized ("此为同步锁") {
+            //上一个任务的一个消费者结束，开始消费下一个任务的专利，即下一个任务的第一个消费者进来，将当前任务的状态改为4待进行
+//            if (task.getStatus() == 0) {
+//                task.setStatus(4);
+//                taskService.updateById(task);
+//            }
             Integer currentPatentId = queueData.getUploadParamsVO().getPatent().getId();
-            Integer num = patentIdMap.get(currentPatentId);
+            Integer taskId = task.getId();
+            String currentPatent = taskId + "|" + currentPatentId;
+            Integer num = patentIdMap.get(currentPatent);
             if (num == null) {
-                patentIdMap.put(currentPatentId, 1);
+                patentIdMap.put(currentPatent, 1);
             } else if (num < 4) {
-                patentIdMap.put(currentPatentId, ++num);
+                patentIdMap.put(currentPatent, ++num);
             } else {
-                //num达到3了就从patentIdMap中删除
-                patentIdMap.remove(currentPatentId);
-                patentFinishNum++;
-                long percentage = Math.round((patentFinishNum + 1D) / total * 100D);
+                //下一个任务的第5个消费者进来（即表示上一个任务的5个消费者都结束了），就将这个任务的状态正式改为1进行中
+                if (task.getStatus() == 0) {
+                    task.setStatus(1);
+                    task.setStartTime(DateUtils.getDateTime());
+                    taskService.updateById(task);
+                }
+                //num达到4了就从patentIdMap中删除
+                patentIdMap.remove(currentPatent);
+                long percentage = Math.round((task.getSuccessNum() + 1D) / total * 100D);
                 //当全部完成时
-                if (patentFinishNum.equals(total)) {
+                if (task.getSuccessNum().equals(total)) {
                     percentage = 100L;
-                    //任务表更新状态为成功
-                    task.setStatus(2);
-                    taskService.updateById(task);
                 }
-                messageService.sendWebsocketMessage(task, total, patentFinishNum, percentage);
+                messageService.sendWebsocketMessage(task, total, task.getSuccessNum(), percentage);
                 //任务表更新数据
-                task.setSuccessNum(patentFinishNum);
+                task.setSuccessNum(task.getSuccessNum() + 1);
                 task.setDefaultNum(total - task.getSuccessNum());
                 taskService.updateById(task);
+                //当全部完成时
+                if (task.getSuccessNum().equals(total)) {
+                    //设置任务状态为成功
+                    task.setStatus(2);
+                    //设置任务结束时间为当前时间
+                    task.setEndTime(DateUtils.getDateTime());
+                    taskService.updateById(task);
+//                    //判断若没有进行中的任务则唤醒生产者线程
+//                    List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
+//                    if (tasks == null || tasks.size() == 0) {
+//                        awakeTasktch();
+//                    }
+                }
             }
         }
     }
 
-    public void patentToQueue(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+    public void patentToQueue(Task task, UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
         //保存专利基础数据（专利表"os_patent"）
         uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
         //专利分别加入5个消费者队列
         QueueData queueData = new QueueData()
+                .setTask(task)
                 .setUploadParamsVO(uploadParamsVO)
                 .setProjectImportPatentVO(projectImportPatentVO);
         patentImageQueue.add(queueData);
@@ -318,4 +352,23 @@ public class PantentQueueService {
 
     }
 
+    /**
+     * 工厂方法，根据任务类型创建对应的获取专利数据的对象
+     *
+     * @param task 任务
+     * @return 返回获取专利数据的对象
+     */
+    private IExcutePatentData createObject(Task task) {
+        //根据任务的类型创建并返回对应的解析获取专利数据的对象
+        switch (task.getType()) {
+            case 1:
+                return excutePatentDataExcel;
+            case 3:
+                return excutePatentDataEpo;
+            default:
+                return null;
+        }
+
+    }
+
 }

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

@@ -0,0 +1,237 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.common.model.PersonnelVO;
+import cn.cslg.pas.common.model.dto.QrtzTaskAddNewDTO;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
+import cn.cslg.pas.domain.QrtzTask;
+import cn.cslg.pas.domain.WebLoginConfig;
+import cn.cslg.pas.mapper.QrtzTaskMapper;
+import cn.cslg.pas.service.OutInterfaceService;
+import cn.cslg.pas.service.WebLoginConfigService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+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;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * @author admin
+ * @description 针对表【qrtz_task(定时任务表)】的数据库操作Service实现
+ * @createDate 2023-03-15 13:40:32
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor(onConstructor_ = {@Lazy})
+public class QrTaskService extends ServiceImpl<QrtzTaskMapper, QrtzTask> {
+//    private final JobService jobService;
+//    //private final QrTaskDetailService qrTaskDetailService;
+//    private final LoginUtils loginUtils;
+//    private final WebLoginConfigService webLoginConfigService;
+//    private final CacheUtils cacheUtils;
+//    private final OutInterfaceService outInterfaceService;
+//
+//    /**
+//     * 新增任务
+//     *
+//     * @param qrtzTaskAddNewDTO 新增条件任务DTO对象
+//     */
+//    public QrtzTask addQuartzTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) {
+//        log.info("开始处理【新增任务条件】的业务，参数为：{}", qrtzTaskAddNewDTO);
+//        Integer webId = qrtzTaskAddNewDTO.getConfigId();
+//        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+//        //根据网站id获得配置
+//        WebLoginConfig webLoginConfig = webLoginConfigService.getLoginConfig(webId, personnelVO.getTenantId());
+//        if (webLoginConfig == null) {
+//            return null;
+//        }
+//        //DTO数据赋值给任务条件实体类
+//        QrtzTask qrtzTask = new QrtzTask();
+//        BeanUtils.copyProperties(qrtzTaskAddNewDTO, qrtzTask);
+//        qrtzTask.setCreatePersonId(loginUtils.getId());
+//        qrtzTask.setTenantId(personnelVO.getTenantId());
+//        List<String> cells = qrtzTaskAddNewDTO.getConfigCells();
+//        if (cells == null) {
+//            qrtzTask.setConfigCells("");
+//        } else {
+//            qrtzTask.setConfigCells(String.join(",", cells));
+//        }
+//        qrtzTask.setTaskState(0);
+//
+//        log.info("数据入任务条件表");
+//        qrtzTask.insert();
+//        //若是定时任务则新增一条任务执行情况
+//        if (qrtzTask.getTaskType() != 1) {
+//            QrtzTaskDetail qrtzTaskDetail = new QrtzTaskDetail()
+//                    .setTaskId(qrtzTask.getId())
+//                    .setTaskDetailState(0);
+//            log.info("新增一条普通任务入任务执行情况表");
+//            qrtzTaskDetail.insert();
+//        }
+//        return qrtzTask;
+//    }
+//
+//    public QrtzTask updateQuartzTask(QrtzTaskUpdateDTO qrtzTaskUpdateDTO) {
+//        log.info("开始处理【更新任务条件】的业务，参数为：{}", qrtzTaskUpdateDTO);
+//
+//        //DTO数据赋值给实体类
+//        QrtzTask qrtzTask = new QrtzTask();
+//        BeanUtils.copyProperties(qrtzTaskUpdateDTO, qrtzTask);
+//        List<String> cells = qrtzTaskUpdateDTO.getConfigCells();
+//        if (cells == null) {
+//            qrtzTask.setConfigCells("");
+//        } else {
+//            qrtzTask.setConfigCells(String.join(",", cells));
+//        }
+//        //更新任务条件数据
+//        log.info("更新任务条件数据");
+//        qrtzTask.updateById();
+//        return qrtzTask;
+//    }
+//
+//    public QrtzTask updateState(Integer taskId, Integer state) {
+//        QrtzTask qrtzTask = this.getById(taskId);
+//        qrtzTask.setTaskState(state);
+//        qrtzTask.updateById();
+//        return qrtzTask;
+//    }
+//
+//    /**
+//     * 删除任务
+//     *
+//     * @param taskIds
+//     */
+//    @Transactional(rollbackFor = Exception.class)
+//    public List<Integer> deleteQuartzTask(List<Integer> taskIds) throws SchedulerException {
+//        List<Integer> reIds = new ArrayList<>();
+//        LambdaQueryWrapper<QrtzTask> wrapper = new LambdaQueryWrapper<>();
+//        wrapper.in(QrtzTask::getId, taskIds);
+//        List<QrtzTask> qrtzTaskList = this.list(wrapper);
+//        for (QrtzTask qrtzTask : qrtzTaskList) {
+//            //根据任务条件id查找是否有正在进行的任务
+//            LambdaQueryWrapper<QrtzTaskDetail> queryWrapper = new LambdaQueryWrapper<>();
+//            queryWrapper.eq(QrtzTaskDetail::getTaskId, qrtzTask.getId())
+//                    .in(QrtzTaskDetail::getTaskDetailState, Arrays.asList(1, 7, 8));
+//            List<QrtzTaskDetail> qrtzTaskDetails = qrTaskDetailService.list(queryWrapper);
+//            if (qrtzTaskDetails.size() == 0) {
+//                Boolean flag = this.removeById(qrtzTask.getId());
+//                LambdaQueryWrapper<QrtzTaskDetail> deleteWrapper = new LambdaQueryWrapper<>();
+//                deleteWrapper.eq(QrtzTaskDetail::getTaskId, qrtzTask.getId());
+//                qrTaskDetailService.remove(deleteWrapper);
+//                if (!flag) {
+//                    reIds.add(qrtzTask.getId());
+//                }
+//                if (qrtzTask.getTaskType().equals(1)) {
+//                    jobService.deleteJob(qrtzTask.getId());
+//                }
+//            } else {
+//                reIds.add(qrtzTask.getId());
+//            }
+//
+//        }
+//        return reIds;
+//    }
+//
+//    public Page<QrtzTask> getTasks(QueryPageDTO queryPageDTO) throws IOException {
+//        log.info("开始处理【查询任务条件列表】的业务，参数为：{}", queryPageDTO);
+//
+//        String orderBy = queryPageDTO.getOrderBy();
+//        String orderType = queryPageDTO.getOrderType();
+//        QueryWrapper<QrtzTask> queryWrapper = new QueryWrapper<>();
+//        if (orderBy != null && !orderBy.equals("")) {
+//            String regex = "[A-Z]+";
+//            Pattern pattern = Pattern.compile(regex);
+//            Matcher matcher = pattern.matcher(orderBy);
+//            while (matcher.find()) {
+//                orderBy = orderBy.replaceFirst(matcher.group(), "_" + matcher.group().toLowerCase());
+//            }
+//            if (orderType.equals("asc")) {
+//                queryWrapper.orderByAsc(orderBy);
+//            } else {
+//                queryWrapper.orderByDesc(orderBy);
+//            }
+//        } else {
+//            queryWrapper.orderByDesc("modified_time");
+//        }
+//        Page<QrtzTask> page = this.page(new Page<>(queryPageDTO.getCurrent(), queryPageDTO.getSize()), queryWrapper.orderByDesc("modified_time"));
+//        this.setDataList(page.getRecords());
+//        return page;
+//    }
+//
+//
+//    private void setDataList(List<QrtzTask> qrtzTasks) throws IOException {
+//        //获得创建人的id集合
+//        List<Integer> createIds = qrtzTasks.stream().map(QrtzTask::getCreatePersonId).collect(Collectors.toList());
+//        //根据人员Id获得人员信息
+//        String res1 = outInterfaceService.getPersonnelByIdsFromPCS(createIds);
+//        JSONObject jsonObject1 = JSONObject.parseObject(res1);
+//        //解析jason获得标的专利的权要
+//        List<Personnel> personnels = JSON.parseArray(jsonObject1.getString("data"), Personnel.class);
+//        for (QrtzTask project : qrtzTasks) {
+//            //装载负责人名
+//            List<Personnel> mapCre = personnels.stream().filter(tem -> tem.getId().equals(project.getCreatePersonId())).collect(Collectors.toList());
+//            if (mapCre.size() > 0) {
+//                project.setCreateName(mapCre.get(0).getPersonnelName());
+//            }
+//        }
+//
+//    }
+//
+//    public Page<QrtzTaskDetail> getTaskDetails(QueryTaskDetailsDTO queryTaskDetailsDTO) {
+//        log.info("开始处理【查询任务执行情况列表】的业务，参数为：{}", queryTaskDetailsDTO);
+//        LambdaQueryWrapper<QrtzTaskDetail> queryWrapper = new LambdaQueryWrapper<>();
+//
+//        //根据所属任务条件id查询列表
+//        if (queryTaskDetailsDTO.getTaskId() != null) {
+//            queryWrapper.eq(QrtzTaskDetail::getTaskId, queryTaskDetailsDTO.getTaskId());
+//        }
+//        //根据任务状态查询列表
+//        if (queryTaskDetailsDTO.getTaskDetailStates() != null && queryTaskDetailsDTO.getTaskDetailStates().size() != 0) {
+//            queryWrapper.in(QrtzTaskDetail::getTaskDetailState, queryTaskDetailsDTO.getTaskDetailStates());
+//        }
+//        if (queryTaskDetailsDTO.getOrderBy() != null) {
+//            queryTaskDetailsDTO.setOrderBy(this.formatOrder(queryTaskDetailsDTO.getOrderBy()));
+//            if (queryTaskDetailsDTO.getOrderBy().equals("state")) {
+//                queryWrapper.last(" order by  FIELD(task_detail_state,1,7,8,0,2,3,4,5,6)");
+//            } else {
+//                queryWrapper.last(" order by " + queryTaskDetailsDTO.getOrderBy());
+//                if (queryTaskDetailsDTO.getOrderType() != null) {
+//                    queryWrapper.last(" order by " + queryTaskDetailsDTO.getOrderBy() + " " + queryTaskDetailsDTO.getOrderType());
+//                }
+//            }
+//        }
+//
+//        Page<QrtzTaskDetail> page = qrTaskDetailService.page(new Page<>(queryTaskDetailsDTO.getCurrent(), queryTaskDetailsDTO.getSize()), queryWrapper);
+//        return page;
+//    }
+//
+//    public String formatOrder(String order) {
+//        switch (order) {
+//            case "createTime":
+//                order = "create_time";
+//                break;
+//
+//        }
+//        return order;
+//    }
+}
+
+
+
+

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

@@ -0,0 +1,50 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.TaskService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 定义任务
+ */
+@RequiredArgsConstructor
+@DisallowConcurrentExecution
+public class TaskAddJob extends QuartzJobBean {
+
+    private static final Log logger = LogFactory.getLog(TaskAddJob.class);
+    private boolean flag = true;
+    private final PantentQueueService pantentQueueService;
+    private final TaskService taskService;
+
+    @Override
+    public void executeInternal(JobExecutionContext context) throws JobExecutionException {
+        JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = (AssoOsTaskQrtzTask) jobDataMap.get("assoOsTaskQrtzTask");
+
+        Task task = new Task();
+        task.setQrtzTaskId(assoOsTaskQrtzTask.getId());
+        task.setTotal(assoOsTaskQrtzTask.getTotal());
+        task.setStatus(0);
+        taskService.save(task);
+        //任务存入生产者任务队列并唤醒生产者线程（判断若没有进行中的任务则唤醒）
+        pantentQueueService.queueAddTask(Arrays.asList(task.getId()));
+        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
+        if (tasks == null || tasks.size() == 0) {
+            pantentQueueService.awakeTasktch();
+        }
+        logger.info("添加任务" + "信息是" + task);
+    }
+
+}

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

@@ -128,7 +128,9 @@ public class UploadPatentToDBService {
         uploadPatentBatchService.patentTypeNoBusiness(uploadParamsVO);
 
         //保存事务信息（表"os_patent_affair"）
-        uploadPatentBatchService.patentAffairBusiness(uploadParamsVO);
+        if (uploadParamsVO.getPatentAffair() != null) {
+            uploadPatentBatchService.patentAffairBusiness(uploadParamsVO);
+        }
     }
 
     /**

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

@@ -1,19 +1,26 @@
 package cn.cslg.pas.service.upLoadPatent;
 
+import cn.cslg.pas.common.model.PersonnelVO;
 import cn.cslg.pas.common.model.dto.QrtzTaskAddNewDTO;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.ReadExcelUtils;
+import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
 import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.SerachBiblioData;
+import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.domain.WebLoginConfig;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.service.IAssoOsTaskQrtzTaskService;
 import cn.cslg.pas.service.TaskService;
+import cn.cslg.pas.service.WebLoginConfigService;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import cn.hutool.core.collection.IterUtil;
 import cn.hutool.poi.excel.ExcelUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -40,6 +47,9 @@ public class UploadTaskService {
     private final PantentQueueService pantentQueueService;
     private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
     private final ExcuteTaskToPatentService excuteTaskToPatentService;
+    private final CacheUtils cacheUtils;
+    private final LoginUtils loginUtils;
+    private final WebLoginConfigService webLoginConfigService;
 
     /**
      * 新增Excel导入任务
@@ -56,9 +66,13 @@ public class UploadTaskService {
         Integer total = ReadExcelUtils.textExcel(filePath);
         //新增任务（专利导入导出任务表）
         Integer taskId = taskService.addTask2(fileDTO, total, json);
-        //任务存入生产者任务队列并唤醒生产者线程
+        //任务存入生产者任务队列并唤醒生产者线程（判断若没有进行中的任务则唤醒）
         pantentQueueService.queueAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
+//        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
+//        if (tasks == null || tasks.size() == 0) {
+//            pantentQueueService.awakeTasktch();
+//        }
     }
 
     /**
@@ -66,26 +80,31 @@ public class UploadTaskService {
      *
      * @param qrtzTaskAddNewDTO 前台参数（检索信息conditions、专题库id、下载字段configCells等）
      */
-    public void addEpoTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+    public AssoOsTaskQrtzTask addEpoTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+        Integer webId = qrtzTaskAddNewDTO.getConfigId();
+        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+        //根据网站id获得配置
+        WebLoginConfig webLoginConfig = webLoginConfigService.getLoginConfig(webId, personnelVO.getTenantId());
+        if (webLoginConfig == null) {
+            ThrowException.throwXiaoShiException("未配置网站登录信息");
+        }
+
         //检查任务合法性（检查当前检索式能否检索出专利）
-        //先根据检索式conditions检索一件专利著录信息
+        //根据检索式conditions检索一件专利著录信息
         SerachBiblioData serachBiblioData = excuteTaskToPatentService.getSerachBiblioData(qrtzTaskAddNewDTO.getConditions(), 1, 1);
         if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
-            ThrowException.throwXiaoShiException("检索失败，根据检索条件未检索出任何相关专利信息");
-            return;
+            ThrowException.throwXiaoShiException("根据检索信息未检索到相关专利，请尝试更换检索信息");
         }
 
-        //新增任务
-        Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, serachBiblioData.getTotals());
-        //新增任务与网站导入任务关联表数据
+        //任务与任务条件关联表新增数据
         AssoOsTaskQrtzTask assoOsTaskQrtzTask = new AssoOsTaskQrtzTask();
         assoOsTaskQrtzTask
-                .setTaskId(taskId)
-                .setTaskType(0)
+                .setTaskType(qrtzTaskAddNewDTO.getTaskType())
                 .setConditions(qrtzTaskAddNewDTO.getConditions())
                 .setCrons(qrtzTaskAddNewDTO.getCrons())
                 .setConfigId(qrtzTaskAddNewDTO.getConfigId())
-                .setTaskName(qrtzTaskAddNewDTO.getTaskName());
+                .setTaskName(qrtzTaskAddNewDTO.getTaskName())
+                .setTotal(serachBiblioData.getTotals());
         List<String> cells = qrtzTaskAddNewDTO.getConfigCells();
         if (cells == null) {
             assoOsTaskQrtzTask.setConfigCells("");
@@ -94,9 +113,22 @@ public class UploadTaskService {
         }
         assoOsTaskQrtzTaskService.save(assoOsTaskQrtzTask);
 
-        //任务存入生产者任务队列并唤醒生产者线程
+        //任务表新增任务
+        Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, serachBiblioData.getTotals(), assoOsTaskQrtzTask);
+
+        //任务与任务条件关联表更新数据
+        assoOsTaskQrtzTask.setTaskId(taskId);
+        assoOsTaskQrtzTaskService.updateById(assoOsTaskQrtzTask);
+
+        //任务存入生产者任务队列并唤醒生产者线程（判断若没有进行中的任务则唤醒）
         pantentQueueService.queueAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
+//        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
+//        if (tasks == null || tasks.size() == 0) {
+//            pantentQueueService.awakeTasktch();
+//        }
+
+        return assoOsTaskQrtzTask;
     }
 
     public void pauseTask() {

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

@@ -0,0 +1,23 @@
+<?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.WebLoginConfigMapper">
+    <select id="getPageList" parameterType="cn.cslg.pas.common.model.vo.QueryConfigVO"
+            resultType="cn.cslg.pas.common.model.vo.ConfigVO">
+        select web_name as webName,web_address as webAddress ,login_account as loginAccount ,login_password as
+        loginPassword,b.id as id
+        ,a.id as webId
+        from web_config a
+        left join web_login_config b
+        on a.id=b.web_id
+        <where>
+            b.tenant_id=#{params.tenantId}
+            <if test="params.webId !=null">
+                and a.id =#{params.webId}
+            </if>
+            <if test="params.loginAccount!=null and params.loginAccount!='' ">
+                and b.login_account like concat('%',#{params.loginAccount}, '%')
+            </if>
+        </where>
+    </select>
+</mapper>