Merge remote-tracking branch 'origin/dev2' into dev2

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

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

@@ -0,0 +1,30 @@
+package cn.cslg.pas.common.model.dto;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 获取专利之星专利指定项DTO类
+ *
+ * @Author chenyu
+ * @Date 2023/6/30
+ */
+@Accessors(chain = true)
+@Data
+public class GetPatentStarPartDTO implements Serializable {
+    /**
+     * 获取专利项（1.权要 2.说明书文本 3.说明书pdf 4.摘要附图）
+     */
+    private Integer patentCell;
+    /**
+     * 公开号
+     */
+    private String patentNo;
+    /**
+     * 申请号
+     */
+    private String appNo;
+
+}

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

@@ -23,7 +23,7 @@ public class QrtzTaskAddNewDTO {
      */
     private Integer taskType;
     /**
-     * 任务类型（3.EPO 4.专利之星）
+     * 任务类型（3.欧专局 4.专利之星）
      */
     private Integer taskType2;
     /**

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

@@ -7,11 +7,12 @@ import com.alibaba.fastjson.annotation.JSONField;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
+import java.io.Serializable;
 import java.util.List;
 
 @Accessors(chain = true)
 @Data
-public class StarPatentVO {
+public class StarPatentVO implements Serializable {
     /**
      * 专利号
      */
@@ -23,7 +24,6 @@ public class StarPatentVO {
      */
     @JSONField(name = "GN")
     private String announceNo;
-
     /**
      * 摘要
      */
@@ -64,14 +64,12 @@ public class StarPatentVO {
      */
     @JSONField(name = "PN")
     private String publicNo;
-
     /**
      * 发明人
      */
     @JSONField(name = "IN")
     private String inventorStr;
     private List<String> inventor;
-
     /**
      * 权利人
      */
@@ -80,26 +78,25 @@ public class StarPatentVO {
     /**
      * 代理机构
      */
-
     @JSONField(name = "AGN")
     private String agencyStr;
     /**
      * 代理人
      */
-
     @JSONField(name = "AT")
     private String agentStr;
-
     /**
      * 法律状态
      */
     @JSONField(name = "LG")
     private Integer LG;
-    private List<String>  ipcList;
+    private List<String> ipcList;
     private List<PatentApplicant> applicant;
     private PatentAgency agency;
     private List<PatentAgent> agent;
     private String simpleStatus;
-
-   private String abstractPath;
+    /**
+     * 摘要附图路径
+     */
+    private String abstractPath;
 }

PAS/src/main/java/cn/cslg/pas/common/utils/Response.java

@@ -1,8 +1,5 @@
 package cn.cslg.pas.common.utils;
 
-import lombok.Data;
-import lombok.experimental.Accessors;
-
 public class Response {
 
     private Integer code;

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

@@ -0,0 +1,42 @@
+package cn.cslg.pas.controller;
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.dto.GetPatentStarPartDTO;
+import cn.cslg.pas.common.model.dto.PatentDTO;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.service.getPatentStarPart.GetPatentStarPartService;
+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.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 获取专利之星专利某部分（如权要、说明书等一项）控制层
+ *
+ * @Author chenyu
+ * @Date 2023/6/30
+ */
+@Tag(name = "专利之星")
+@Slf4j
+@RequestMapping(Constants.API_VERSION_V2 + "/patentStar")
+@RestController
+@RequiredArgsConstructor
+public class GetPatentStarPartController {
+
+    private final GetPatentStarPartService getPatentStarPartService;
+
+    @Operation(summary = "根据专利号或申请号获取专利指定部分项")
+    @GetMapping("/getPatentPart")
+    public String getPatentPart(GetPatentStarPartDTO getPatentStarPartDTO) {
+        log.info("开始处理【根据专利号或申请号获取专利指定部分项】的请求，请求参数为：{}", getPatentStarPartDTO);
+
+        PatentDTO patentPart = getPatentStarPartService.getPatentPart(getPatentStarPartDTO);
+        return Response.success(patentPart);
+
+    }
+
+}

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

@@ -57,8 +57,9 @@ public class ProjectImportController {
         if (params == null) {
             return Response.error("参数错误");
         }
-        TaskParams taskParams = projectService.getImportPatentTaskParams(file, params.getProjectId());
-        uploadPatentBatchService.uploadPatentBatch(taskParams, params);
+//        TaskParams taskParams = projectService.getImportPatentTaskParams(file, params.getProjectId());
+//        uploadPatentBatchService.uploadPatentBatch(taskParams, params);
+        //Excel导入专利
         uploadTaskService.addExcelTask(file, json);
         return Response.success(true);
     }

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

@@ -66,13 +66,20 @@ public class TaskController {
         return Response.success(true);
     }
 
-    @PostMapping("add")
+    @PostMapping("addTask")
     @Operation(summary = "新增网站导入专利任务")
     public String add(@RequestBody QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException, SchedulerException {
-        //添加任务
-//        AssoOsTaskQrtzTask assoOsTaskQrtzTask = uploadTaskService.addEpoTask(qrtzTaskAddNewDTO);
-        AssoOsTaskQrtzTask assoOsTaskQrtzTask = uploadTaskService.addPatentStarTask(qrtzTaskAddNewDTO);
-        //任务添加完，判断是定时任务则任务调度添加该定时任务
+        log.info("开始处理【新增网站导入专利任务】的请求，请求参数为：{}", qrtzTaskAddNewDTO);
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = new AssoOsTaskQrtzTask();
+        //新增欧专局网站导入任务
+        if (qrtzTaskAddNewDTO.getTaskType2().equals(3)) {
+            assoOsTaskQrtzTask = uploadTaskService.addEpoTask(qrtzTaskAddNewDTO);
+            //新增专利之星网站导入任务
+        } else if (qrtzTaskAddNewDTO.getTaskType2().equals(4)) {
+            assoOsTaskQrtzTask = uploadTaskService.addPatentStarTask(qrtzTaskAddNewDTO);
+        }
+
+        //若是定时任务，则新增添加定时任务的job
         if (assoOsTaskQrtzTask.getTaskType() == 1) {
             jobService.addJob(assoOsTaskQrtzTask);
         }

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

@@ -225,7 +225,8 @@ public class PatentService extends ServiceImpl<PatentMapper, Patent> {
         List<Patent> patentList = this.list(queryWrapper);
         return StringUtils.join(patentList.stream().map(BaseEntity::getId).distinct().collect(Collectors.toList()), ",");
     }
-   //装载专利查询数据
+
+    //装载专利查询数据
     private void setQueryPatentParams(PatentVO params) {
         params.setSelfField(new ArrayList<>());
         List<String> customIds = new ArrayList<>();
@@ -235,7 +236,7 @@ public class PatentService extends ServiceImpl<PatentMapper, Patent> {
         if (StringUtils.isNotEmpty(params.getName())) {
             params.setNameSql(PatentUtils.formatTextQuerySql(params.getName(), "a.name"));
         }
-       //设置摘要sql
+        //设置摘要sql
         if (StringUtils.isNotEmpty(params.getAbstractStr())) {
             params.setAbstractStrSql(PatentUtils.formatTextQuerySql(params.getAbstractStr(), "a.abstract"));
         }
@@ -287,12 +288,12 @@ public class PatentService extends ServiceImpl<PatentMapper, Patent> {
                         params.setQueryClassNumberLocMethod(params.getField().get(i).getClassId());
                     }
                     break;
-                    //原始申请人筛选
+                //原始申请人筛选
                 case "18-6":
                     params.setQueryApplicantOriginal(true);
                     params.setWhereApplicantOriginal(queryList);
                     break;
-                    //当前申请人筛选
+                //当前申请人筛选
                 case "19-6":
                     params.setQueryApplicantCurrent(true);
                     params.setWhereApplicantCurrent(queryList);
@@ -302,29 +303,29 @@ public class PatentService extends ServiceImpl<PatentMapper, Patent> {
                     params.setQueryInventor(true);
                     params.setWhereInventor(queryList);
                     break;
-                    //合并发明人筛选
+                //合并发明人筛选
                 case "20-1":
                     params.setQueryInventor(true);
                     params.setQueryInventorMerge(true);
                     params.setWhereInventorMerge(queryList);
                     break;
-                    //标准原始申请人筛选
+                //标准原始申请人筛选
                 case "18-7":
                     params.setQueryApplicantOriginalStandard(true);
                     params.setWhereApplicantOriginalStandard(queryList);
                     break;
-                    //标准当前申请人筛选
+                //标准当前申请人筛选
                 case "19-7":
                     params.setQueryApplicantCurrentStandard(true);
                     params.setWhereApplicantCurrentStandard(queryList);
                     break;
-                    //原始申请人筛选
+                //原始申请人筛选
                 case "18-8":
                     params.setQueryApplicantOriginal(true);
                     params.setQueryApplicantOriginalMerge(true);
                     params.setWhereApplicantOriginalMerge(queryList);
                     break;
-                    //当前申请人筛选
+                //当前申请人筛选
                 case "19-8":
                     params.setQueryApplicantCurrent(true);
                     params.setQueryApplicantCurrentMerge(true);
@@ -372,7 +373,7 @@ public class PatentService extends ServiceImpl<PatentMapper, Patent> {
                     params.setQueryLabel(true);
                     params.setWhereLabel(queryList);
                     break;
-                    //自定义字段筛选
+                //自定义字段筛选
                 default:
                     //判断值里面是否含空
                     params.getField().get(i).setIsNull(queryList.stream().anyMatch(item -> item.equals("null")));

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

@@ -166,7 +166,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setProjectId(qrtzTaskAddNewDTO.getProjectId());
         //专利总数量
         task.setTotal(total);
-        //任务类型 （1上传 2导出 3网站导入）
+        //任务类型 （1Excel导入 2导出 3欧专局导入 4专利之星导入）
         task.setType(qrtzTaskAddNewDTO.getTaskType2());
         //导入导出字段数量
         task.setFieldNum(0);
@@ -180,6 +180,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setQrtzTaskId(assoOsTaskQrtzTask.getId());
 
         //数据入任务表
+        log.info("任务表（os_task）新增数据");
         task.insert();
         return task.getId();
     }

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

@@ -48,11 +48,8 @@ public class WebLoginConfigService extends ServiceImpl<WebLoginConfigMapper, Web
     }
 
     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();
+        List<WebLoginConfig> configs = this.list(new LambdaQueryWrapper<WebLoginConfig>().eq(WebLoginConfig::getWebId, webId).eq(WebLoginConfig::getTenantId, tenantId));
+        WebLoginConfig config;
         if (configs.size() > 0) {
             config = configs.get(0);
         } else {

PAS/src/main/java/cn/cslg/pas/service/getPatentStarPart/GetPatentStarPartService.java

@@ -0,0 +1,140 @@
+package cn.cslg.pas.service.getPatentStarPart;
+
+import cn.cslg.pas.common.model.dto.GetPatentStarPartDTO;
+import cn.cslg.pas.common.model.dto.PatentDTO;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
+import cn.cslg.pas.domain.PatentImage;
+import cn.cslg.pas.domain.PatentInstruction;
+import cn.cslg.pas.domain.PatentRight;
+import cn.cslg.pas.service.outApi.PatentStarApiService;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+
+/**
+ * 获取专利之星专利某部分（如权要、说明书等一项）业务层
+ *
+ * @Author chenyu
+ * @Date 2023/6/30
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class GetPatentStarPartService {
+    private final ExcutePatentDataStar excutePatentDataStar;
+    private final PatentStarApiService patentStarApiService;
+
+    /**
+     * 根据专利号或申请号获取专利指定部分项
+     *
+     * @param getPatentStarPartDTO 前端传输DTO对象
+     * @return 返回装载着指定专利项的对象
+     */
+    public PatentDTO getPatentPart(GetPatentStarPartDTO getPatentStarPartDTO) {
+        log.info("开始处理【根据专利号或申请号获取专利指定部分项】的业务，参数为：{}", getPatentStarPartDTO);
+
+        Integer patentCell = getPatentStarPartDTO.getPatentCell();
+        String appNo = getPatentStarPartDTO.getAppNo();
+        String patentNo = getPatentStarPartDTO.getPatentNo();
+        PatentDTO patentDTO;
+        if (patentCell == 1) {
+            patentDTO = getParentRight(appNo);
+        } else if (patentCell == 2) {
+            patentDTO = getInstructionText(appNo);
+        } else if (patentCell == 3) {
+            patentDTO = getInstructionPDF(patentNo);
+        } else if (patentCell == 4) {
+            patentDTO = getPatentImage(appNo);
+        } else {
+            patentDTO = new PatentDTO();
+        }
+
+        return patentDTO;
+    }
+
+    /**
+     * 获取专利之星专利的权要
+     *
+     * @param appNo 申请号
+     * @return 返回装载着权要的对象
+     */
+    public PatentDTO getParentRight(String appNo) {
+        StarPatentVO starPatentVO = new StarPatentVO()
+                .setApplicationNo(appNo);
+        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+        //调用"获得中国专利全文文本"接口，处理xml格式权要
+        excutePatentDataStar.setPatentClaim(starPatentVO, uploadParamsVO);
+
+        PatentDTO patentDTO = new PatentDTO();
+        ArrayList<PatentRight> patentRights = new ArrayList<>();
+        patentRights.add(uploadParamsVO.getPatentRight());
+        patentDTO.setRights(patentRights);
+
+        return patentDTO;
+    }
+
+    /**
+     * 获取专利之星专利的说明书文本
+     *
+     * @param appNo 申请号
+     * @return 返回装载着说明书文本的对象
+     */
+    public PatentDTO getInstructionText(String appNo) {
+        StarPatentVO starPatentVO = new StarPatentVO()
+                .setApplicationNo(appNo);
+        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+        //调用"获得中国专利全文文本"接口，处理xml格式说明书文本
+        excutePatentDataStar.setPatentInstructionText(starPatentVO, uploadParamsVO);
+
+        PatentDTO patentDTO = new PatentDTO();
+        patentDTO.setInstruction(uploadParamsVO.getPatentInstructionText());
+
+        return patentDTO;
+    }
+
+    /**
+     * 获取专利之星专利的说明书pdf
+     *
+     * @param patentNo 专利号
+     * @return 返回装载着说明书pdf的对象
+     */
+    public PatentDTO getInstructionPDF(String patentNo) {
+        //调用"获得世界专利pdf"接口，获得pdf的url地址
+        String pdfUrl = patentStarApiService.getEnPdfApi(patentNo);
+
+        PatentDTO patentDTO = new PatentDTO();
+        ArrayList<PatentInstruction> patentInstructions = new ArrayList<>();
+        PatentInstruction patentInstruction = new PatentInstruction();
+        patentInstruction.setUrl(pdfUrl);
+        patentInstructions.add(patentInstruction);
+        patentDTO.setPdf(patentInstructions);
+
+        return patentDTO;
+    }
+
+    /**
+     * 获取专利之星专利的摘要附图
+     *
+     * @param appNo 申请号
+     * @return 返回装载着摘要附图的对象
+     */
+    public PatentDTO getPatentImage(String appNo) {
+        //以下 ↓调用的是"获得中国专利摘要附图"接口，获得摘要附图的url地址
+        String pictureUrl = patentStarApiService.getPictureApi(appNo);
+
+        PatentDTO patentDTO = new PatentDTO();
+        ArrayList<PatentImage> patentImages = new ArrayList<>();
+        PatentImage patentImage = new PatentImage();
+        patentImage.setUrl(pictureUrl);
+        patentImages.add(patentImage);
+        patentDTO.setImage(patentImages);
+
+        return patentDTO;
+    }
+
+
+}

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

@@ -40,20 +40,18 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
     @Override
     public void startExcute(Task task) throws IOException {
         //从任务中取出文件路径、总条数、成功条数、前台参数json
-        String filePath = task.getUrl();  //相对路径
-        filePath = fileUtils.getPath(filePath);  //绝对路径
+        String filePath = fileUtils.getPath(task.getUrl());
         Integer total = task.getTotal();
+        int lastIndex = task.getSuccessNum();
+        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(task.getPramJson(), ProjectImportPatentVO.class);
 
-        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++) {
-            //判断若任务状态为暂停（4），则不再生产该任务的专利
+            //判断若任务状态为已暂停，则结束生产
             if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
                 return;
             }

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

@@ -6,8 +6,10 @@ import cn.cslg.pas.common.model.vo.UploadParamsVO;
 import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
 import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.RemoveHtmlTagsUtils;
+import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.*;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
@@ -55,23 +57,22 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     @Override
     public void startExcute(Task task) throws IOException {
         //从任务关联网站导入任务表中取出当前任务
-        List<AssoOsTaskQrtzTask> assoOsTaskQrtzTasks = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<AssoOsTaskQrtzTask>().eq(AssoOsTaskQrtzTask::getTaskId, task.getId()));
-        AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTasks.get(0);
+        //List<AssoOsTaskQrtzTask> assoOsTaskQrtzTasks = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<AssoOsTaskQrtzTask>().eq(AssoOsTaskQrtzTask::getTaskId, task.getId()));
+        ///AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTasks.get(0);
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTaskService.getById(task.getQrtzTaskId());
 
-        //从任务数据中获取下载字段、检索式
-        String cellsStr = assoOsTaskQrtzTask.getConfigCells();
-        List<String> cells = Arrays.asList(cellsStr.split(","));
+        //从任务数据中获取专利总数量、检索式、下载字段
+        Integer total = assoOsTaskQrtzTask.getTotal();
         String conditions = assoOsTaskQrtzTask.getConditions();
+        List<String> cells = Arrays.asList(assoOsTaskQrtzTask.getConfigCells().split(","));
 
-        //定义每次检索的专利数量(每次检索50件)
+        //定义每次检索的页码
+        int pageNum = 0;
+        //定义每次检索的专利数量(当前定义每次检索50件)
         int size = 50;
 
-        //获得专利总数量
-        Integer count = task.getTotal();
-
         //1.根据专利总数量count遍历检索专利
-        int pageNum = 0;  //页码
-        for (int i = 1; i <= count; i += size) {
+        for (int i = 1; i <= total; i += size) {
             pageNum++;
             PatentStarListDto patentStarListDto = new PatentStarListDto()
                     .setCurrentQuery(conditions)
@@ -80,21 +81,19 @@ public class ExcutePatentDataStar implements IExcutePatentData {
                     .setPageNum(pageNum)
                     .setRowCount(size)
                     .setDBType("CN");
-            //调用一般接口
+            //调用一般接口返回一批专利著录相关数据
             Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
             if (resultMap == null || (Integer) resultMap.get("total") == 0) {
-                continue;
+                ThrowException.throwXiaoShiException("发生未知错误，一般接口未检索出专利");
             }
 
-            //调用一般接口返回一批专利著录相关数据
             List<StarPatentVO> patents = (List<StarPatentVO>) resultMap.get("records");
-
-            //遍历50个专利
+            //遍历这一批专利（50个）
             for (StarPatentVO starPatent : patents) {
                 try {
                     UploadParamsVO uploadParamsVO = new UploadParamsVO();
                     setPatentZhuLu(starPatent, uploadParamsVO);
-                    //保存专利基础数据（专利表"os_patent"）
+                    //保存专利基础数据（专利表"os_patent"），因为需要先拿到专利id供其他消费者部分使用
                     uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
                     PQueueData pQueueData = new PQueueData()
@@ -124,8 +123,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
 
                 } catch (Exception e) {
                     e.printStackTrace();
-                    //exceptionNum++;
-                    //跳过当前生产出问题的专利，继续生产下一个专利
+                    //继续下一个专利
                 }
 
             }
@@ -176,7 +174,7 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             uploadParamsVO.setMainIpc(ipcArr[0]);
             uploadParamsVO.setIpcList(Arrays.asList(ipcArr));
         }
-        //装载法律状态
+        //装载法律状态（os_patent表status字段值）
         Integer status = starPatent.getLG();
         if (status != null) {
             //有效（有权）
@@ -290,34 +288,39 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      * @param starPatent     专利之星著录对象
      * @param uploadParamsVO 专利实体类对象
      */
-    public void setPatentClaim(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
-        String appNo;
-        if (starPatent.getApplicationNo().contains(".")) {
-            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
-        } else {
-            appNo = starPatent.getApplicationNo();
-        }
-        //根据申请号调用"获得中国专利全文文本"接口，获得包含各种xml标签的专利全文内容的长字符串 cnFullXmlStr
-        String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(appNo);
-
-        //使用正则表达式拼接出权要原文
-        String regex = "(?<=<claim-text>)[\\w\\W]+?(?=</claim-text>)";
-        Pattern compile = Pattern.compile(regex);
-        Matcher matcher = compile.matcher(cnFullXmlStr);
-        StringBuilder builder = new StringBuilder();
-        while (matcher.find()) {
-            builder.append(matcher.group()).append("\r\n");
-        }
+    public void setPatentClaim(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        try {
+            String appNo;
+            if (starPatent.getApplicationNo().contains(".")) {
+                appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+            } else {
+                appNo = starPatent.getApplicationNo();
+            }
+            //根据申请号调用"获得中国专利全文文本"接口，获得包含各种xml标签的专利全文内容的长字符串 cnFullXmlStr
+            String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(appNo);
+
+            //使用正则表达式拼接出权要原文
+            String regex = "(?<=<claim-text>)[\\w\\W]+?(?=</claim-text>)";
+            Pattern compile = Pattern.compile(regex);
+            Matcher matcher = compile.matcher(cnFullXmlStr);
+            StringBuilder builder = new StringBuilder();
+            while (matcher.find()) {
+                builder.append(matcher.group()).append("\r\n");
+            }
 
-        String patentRightText = builder + "";
+            String patentRightText = builder + "";
 
-        //使用工具类去除字符串文本中的所有HTML格式标签
-        patentRightText = RemoveHtmlTagsUtils.removeHtmlTags(patentRightText);
+            //使用工具类去除字符串文本中的所有HTML格式标签
+            patentRightText = RemoveHtmlTagsUtils.removeHtmlTags(patentRightText);
 
-        //装载权利要求原文
-        PatentRight patentRight = new PatentRight();
-        patentRight.setContent(patentRightText);
-        uploadParamsVO.setPatentRight(patentRight);
+            //装载权利要求原文
+            PatentRight patentRight = new PatentRight();
+            patentRight.setContent(patentRightText);
+            uploadParamsVO.setPatentRight(patentRight);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
 
     }
 
@@ -327,46 +330,51 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      * @param starPatent     专利之星著录对象
      * @param uploadParamsVO 专利实体类对象
      */
-    public void setPatentInstructionText(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
-        String appNo;
-        if (starPatent.getApplicationNo().contains(".")) {
-            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
-        } else {
-            appNo = starPatent.getApplicationNo();
-        }
-        //根据申请号调用"获得中国专利全文文本"接口，获得包含各种xml标签的专利全文内容的长字符串 cnFullXmlStr
-        String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(appNo);
-
-        //使用正则表达式拼接出说明书文本全文
-        String regex = "(?<=<p id=\"p)[\\w\\W]+?(?=</p>)";
-        Pattern compile = Pattern.compile(regex);
-        Matcher matcher = compile.matcher(cnFullXmlStr);
-        StringBuilder builder = new StringBuilder();
-        while (matcher.find()) {
-            String oldRow = matcher.group();
-            if (oldRow.contains("num=\"n")) {
-                oldRow = oldRow.substring(oldRow.indexOf("num=\"n") + 6);
-                oldRow = "[" + oldRow;
-                oldRow = oldRow.replace("\">", "]");
-            } else if (oldRow.contains("num=")) {
-                oldRow = oldRow.substring(oldRow.indexOf("num=") + 5);
-                oldRow = "[" + oldRow;
-                oldRow = oldRow.replace("\">", "]");
+    public void setPatentInstructionText(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        try {
+            String appNo;
+            if (starPatent.getApplicationNo().contains(".")) {
+                appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
             } else {
-                oldRow = oldRow.substring(oldRow.indexOf("\">") + 2);
+                appNo = starPatent.getApplicationNo();
+            }
+            //根据申请号调用"获得中国专利全文文本"接口，获得包含各种xml标签的专利全文内容的长字符串 cnFullXmlStr
+            String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(appNo);
+
+            //使用正则表达式拼接出说明书文本全文
+            String regex = "(?<=<p id=\"p)[\\w\\W]+?(?=</p>)";
+            Pattern compile = Pattern.compile(regex);
+            Matcher matcher = compile.matcher(cnFullXmlStr);
+            StringBuilder builder = new StringBuilder();
+            while (matcher.find()) {
+                String oldRow = matcher.group();
+                if (oldRow.contains("num=\"n")) {
+                    oldRow = oldRow.substring(oldRow.indexOf("num=\"n") + 6);
+                    oldRow = "[" + oldRow;
+                    oldRow = oldRow.replace("\">", "]");
+                } else if (oldRow.contains("num=")) {
+                    oldRow = oldRow.substring(oldRow.indexOf("num=") + 5);
+                    oldRow = "[" + oldRow;
+                    oldRow = oldRow.replace("\">", "]");
+                } else {
+                    oldRow = oldRow.substring(oldRow.indexOf("\">") + 2);
+                }
+                builder.append(oldRow).append("\r\n");
             }
-            builder.append(oldRow).append("\r\n");
-        }
 
-        String instructionText = builder + "";
+            String instructionText = builder + "";
 
-        //使用工具类去除字符串文本中的所有HTML格式标签
-        instructionText = RemoveHtmlTagsUtils.removeHtmlTags(instructionText);
+            //使用工具类去除字符串文本中的所有HTML格式标签
+            instructionText = RemoveHtmlTagsUtils.removeHtmlTags(instructionText);
 
-        //装载说明书文本全文
-        PatentInstructionText patentInstructionText = new PatentInstructionText();
-        patentInstructionText.setManual(instructionText);
-        uploadParamsVO.setPatentInstructionText(patentInstructionText);
+            //装载说明书文本全文
+            PatentInstructionText patentInstructionText = new PatentInstructionText();
+            patentInstructionText.setManual(instructionText);
+            uploadParamsVO.setPatentInstructionText(patentInstructionText);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
 
     }
 
@@ -427,14 +435,17 @@ public class ExcutePatentDataStar implements IExcutePatentData {
      * @param uploadParamsVO 专利实体类对象
      */
     public void setPatentPicture(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
-        String appNo = null;
-        if (starPatent.getApplicationNo().contains(".")) {
-            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
-        } else {
-            appNo = starPatent.getApplicationNo();
-        }
-        //根据申请号调用"获得中国专利摘要附图"接口，获得摘要附图的url地址
-        String pictureUrl = patentStarApiService.getPictureApi(appNo);
+//        String appNo;
+//        if (starPatent.getApplicationNo().contains(".")) {
+//            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+//        } else {
+//            appNo = starPatent.getApplicationNo();
+//        }
+//        //以下 ↓调用的是"获得中国专利摘要附图"接口，获得摘要附图的url地址
+//        String pictureUrl = patentStarApiService.getPictureApi(appNo);
+
+        //直接取出一般接口返回的摘要附图路径
+        String pictureUrl = starPatent.getAbstractPath();
 
         try {
             URL url = new URL(pictureUrl);  //想要读取的url地址

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

@@ -22,8 +22,9 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * 1.生产专利（生产者从任务队列取出任务并解析任务生成专利数据，分配给消费者，唤醒消费者）
- * 2.消费专利（消费者从专利队列中取出专利并保存专利入库）
+ * 1.生产者线程生产专利（根据任务类型调用对应工厂方法执行获取专利数据）
+ * 2.装载者线程装载专利（将专利数据装载到专利实体类）
+ * 3.消费者线程消费专利（将专利入库）
  */
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
@@ -78,7 +79,7 @@ public class PantentQueueService {
         while (true) {
             Task task = new Task();
             try {
-                //判断任务队列是否有任务，若没有则该生产者线程睡眠
+                //判断任务队列是否有任务，若没有则线程等待唤醒
                 if (taskQueueList.size() == 0) {
                     taskLock.lock();
                     taskCondition.await();
@@ -86,29 +87,25 @@ public class PantentQueueService {
 
                 //线程被唤醒后 ↓
                 if (taskQueueList.size() > 0) {
-                    //1.从任务队列中取出一个task任务
-                    //2.同时将其从任务队列中剔除
-                    //3.查询任务，判断任务不存在或状态为已暂停，则直接跳过进行下一个任务
-                    task = taskService.getById(taskQueueList.get(0));
-                    taskQueueList.remove(0);
+                    //从任务队列中取出第一个task任务，同时将其从任务队列中剔除
+                    task = taskService.getById(taskQueueList.remove(0));
+                    //判断任务状态，若已不存在或已暂停，则跳过继续取下一个任务
                     if (task == null || task.getStatus() == 4) {
                         continue;
                     }
 
-                    //TODO 调用工厂方法并将任务扔进去，工厂方法会根据任务的类型创建并返回对应的生产专利方法的对象
-                    //1.用工厂方法根据任务类型创建对应的获取专利数据的对象
+                    //TODO 调用工厂方法，工厂方法会根据任务类型创建并返回对应的生产专利方法的对象
                     IExcutePatentData excutePatentDataObject = createObject(task);
-                    //2.对象调用执行生产专利方法（解析任务生产专利并丢入消费者专利队列，唤醒消费者线程）
-                    if (excutePatentDataObject == null) {
-                        throw new Exception();
+                    if (excutePatentDataObject != null) {
+                        //执行方法
+                        excutePatentDataObject.startExcute(task);
                     }
-                    excutePatentDataObject.startExcute(task);
 
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
-                //任务表更新状态为失败
+                //任务表更新状态失败
                 task.setStatus(2);
                 task.setEndTime(DateUtils.getDateTime());
                 taskService.updateById(task);
@@ -301,9 +298,9 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者1：将专利从队列取出，摘要附图入库
+     * 消费者1：摘要附图入库
      */
-    public void pushPatentImageToDB() throws InterruptedException, IOException {
+    public void pushPatentImageToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -336,7 +333,7 @@ public class PantentQueueService {
     /**
      * 消费者2：将专利从队列取出，著录项目入库
      */
-    public void pushPatentZhuLuToDB() throws InterruptedException, IOException {
+    public void pushPatentZhuLuToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -369,7 +366,7 @@ public class PantentQueueService {
     /**
      * 消费者3：将专利从队列取出，权利要求文本入库
      */
-    public void pushPatentRightToDB() throws InterruptedException, IOException {
+    public void pushPatentRightToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -396,7 +393,7 @@ public class PantentQueueService {
     /**
      * 消费者4：将专利从队列取出，说明书文本入库
      */
-    public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionTextToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -423,7 +420,7 @@ public class PantentQueueService {
     /**
      * 消费者5：将专利从队列取出，说明书pdf地址入库
      */
-    public void pushPatentInstructionPDFToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionPDFToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -477,7 +474,6 @@ public class PantentQueueService {
                     task.setStartTime(DateUtils.getDateTime());
                     taskService.updateById(task);
                 }
-                //num达到4了就在patentIdMap中将其删除
                 patentIdMap.remove(currentPatent);
                 long percentage = Math.round((task.getSuccessNum() + 1D) / total * 100D);
                 //任务表更新数据（这里只更新成功条数和失败条数，注意不能更新状态等其他信息）
@@ -490,7 +486,7 @@ public class PantentQueueService {
                 taskService.updateById(updateTask);
 
                 //当全部完成时
-                if (task.getSuccessNum() + task.getExceptionNum() == total) {
+                if (task.getSuccessNum().equals(total)) {
                     percentage = 100L;
                     //设置任务状态为成功
                     task.setStatus(2);
@@ -664,9 +660,9 @@ public class PantentQueueService {
     private IExcutePatentData createObject(Task task) {
         //根据任务的类型创建并返回对应的解析获取专利数据的对象
         switch (task.getType()) {
-            case 1:  //Excel导入专利任务
+            case 1:  //Excel导入专利
                 return excutePatentDataExcel;
-            case 3:  //Epo欧专局网站导入
+            case 3:  //欧专局网站导入
                 return excutePatentDataEpo;
             case 4:  //专利之星网站导入
                 return excutePatentDataStar;

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

@@ -32,11 +32,16 @@ public class TaskAddJob extends QuartzJobBean {
     public void executeInternal(JobExecutionContext context) throws JobExecutionException {
         JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
         AssoOsTaskQrtzTask assoOsTaskQrtzTask = (AssoOsTaskQrtzTask) jobDataMap.get("assoOsTaskQrtzTask");
-
+        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getQrtzTaskId, assoOsTaskQrtzTask.getId()));
         Task task = new Task();
+        if (list != null && list.size() > 0) {
+            task.setType(list.get(0).getType());
+        }
         task.setQrtzTaskId(assoOsTaskQrtzTask.getId());
         task.setTotal(assoOsTaskQrtzTask.getTotal());
         task.setStatus(0);
+        task.setSuccessNum(0);
+        task.setDefaultNum(0);
         taskService.save(task);
         //任务存入生产者任务队列并唤醒生产者线程（判断若没有进行中的任务则唤醒）
         pantentQueueService.taskQueueAddTask(Arrays.asList(task.getId()));

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

@@ -17,6 +17,7 @@ import cn.cslg.pas.service.WebLoginConfigService;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
@@ -32,6 +33,7 @@ import java.util.Map;
  * @Author 李仁杰
  * 导入任务类
  */
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class UploadTaskService {
@@ -131,8 +133,7 @@ public class UploadTaskService {
             ThrowException.throwXiaoShiException("未配置网站登录信息");
         }
 
-        //检查任务合法性（检查当前检索式能否检索出专利）
-        //根据检索式conditions检索一件专利著录信息
+        //检查任务合法性（根据检索式conditions先检索1页10条专利著录信息）
         PatentStarListDto patentStarListDto = new PatentStarListDto()
                 .setCurrentQuery(qrtzTaskAddNewDTO.getConditions())
                 .setOrderBy("AD")
@@ -148,9 +149,10 @@ public class UploadTaskService {
         //专利总数量
         Integer total = (Integer) resultMap.get("total");
 
-        //任务与任务条件关联表新增数据
+        //新增任务与任务条件关联表（"asso_osTask_qrtzTask"）数据
         AssoOsTaskQrtzTask assoOsTaskQrtzTask = new AssoOsTaskQrtzTask();
         assoOsTaskQrtzTask
+                .setTaskName(qrtzTaskAddNewDTO.getTaskName())
                 .setTaskType(qrtzTaskAddNewDTO.getTaskType())
                 .setConditions(qrtzTaskAddNewDTO.getConditions())
                 .setCrons(qrtzTaskAddNewDTO.getCrons())
@@ -163,14 +165,17 @@ public class UploadTaskService {
         } else {
             assoOsTaskQrtzTask.setConfigCells(String.join(",", cells));
         }
+        log.info("任务与任务条件关联表（asso_osTask_qrtzTask）新增数据");
         assoOsTaskQrtzTaskService.save(assoOsTaskQrtzTask);
 
         //任务表新增任务
         Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, total, assoOsTaskQrtzTask);
 
-        //任务与任务条件关联表更新数据
-        assoOsTaskQrtzTask.setTaskId(taskId);
-        assoOsTaskQrtzTaskService.updateById(assoOsTaskQrtzTask);
+        //任务与任务条件关联表（asso_osTask_qrtzTask）更新数据（普通任务）
+        if (qrtzTaskAddNewDTO.getTaskType().equals(0)) {
+            assoOsTaskQrtzTask.setTaskId(taskId);
+            assoOsTaskQrtzTaskService.updateById(assoOsTaskQrtzTask);
+        }
 
         //任务存入生产者任务队列并唤醒生产者线程
         pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));