专利之星任务导入专利代码

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

@@ -52,6 +52,22 @@ public class CreateTaskThread implements InitializingBean {
         Thread threadProducer = new Thread(pantentQueueService::addPatnetToQueue);
         threadProducer.start();
 
+        //装载专利著录线程
+        Thread threadSetPatentZhuLu = new Thread(pantentQueueService::setPatentZhuLu);
+        threadSetPatentZhuLu.start();
+        //装载权要线程
+        Thread threadSetPatentClaim = new Thread(pantentQueueService::setPatentRight);
+        threadSetPatentClaim.start();
+        //装载说明书文本线程
+        Thread threadSetPatentInstructionText = new Thread(pantentQueueService::setPatentInstructionText);
+        threadSetPatentInstructionText.start();
+        //装载说明书pdf线程
+        Thread threadSetPatentInstructionPDF = new Thread(pantentQueueService::setPatentInstructionPDF);
+        threadSetPatentInstructionPDF.start();
+        //装载摘要附图线程
+        Thread threadSetPatentPicture = new Thread(pantentQueueService::setPatentImage);
+        threadSetPatentPicture.start();
+
 
         //消费者1线程（摘要附图）
         Thread threadConsumer1 = new Thread(() -> {
@@ -96,6 +112,16 @@ public class CreateTaskThread implements InitializingBean {
         });
         threadConsumer4.start();
 
+        //消费者5线程（说明书pdf消费者）
+        Thread threadConsumer5 = new Thread(() -> {
+            try {
+                pantentQueueService.pushPatentInstructionPDFToDB();
+            } catch (InterruptedException | IOException e) {
+                e.printStackTrace();
+            }
+        });
+        threadConsumer5.start();
+
     }
 
 }

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

@@ -1,5 +1,6 @@
 package cn.cslg.pas.common.model.vo;
 
+import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.cslg.pas.domain.*;
 import lombok.Data;
 import lombok.experimental.Accessors;
@@ -121,5 +122,10 @@ public class UploadParamsVO {
      */
     private PictureData pictureData;
 
+    /**
+     * 文件（说明书pdf/摘要附图）
+     */
+    private UploadFileDTO fileDTO;
+
 
 }

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

@@ -4,6 +4,9 @@ import com.alibaba.fastjson.annotation.JSONField;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
+/**
+ * 专利之星调用一般接口返回专利数据
+ */
 @Accessors(chain = true)
 @Data
 public class StarPatentVO {
@@ -52,4 +55,5 @@ public class StarPatentVO {
      */
     @JSONField(name = "PNO")
     private String publicNo;
+
 }

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

@@ -116,7 +116,6 @@ public class ExcelUtils {
     /**
      * @param pictureData 图片
      * @return 返回图片的文件路径和文件名称
-     * @throws IOException 抛出IO异常
      */
     public static Map<String, String> savePicture(PictureData pictureData) throws IOException {
         FileUtils fileUtils = SpringUtils.getBean(FileUtils.class);

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

@@ -43,13 +43,15 @@ public class PatentRightUtils {
             //将原文和译文的所有换行符 "\r\n"或是"\n" 替换成 "@"，这样首先可以使得全文连在一起，其次再根据特殊符号@拆分权要
             if (content.contains("\r\n")) {
                 content = content.replaceAll("\r\n", "@");
-            } else {
+            }
+            if (content.contains("\n")) {
                 content = content.replaceAll("\n", "@");
             }
 
             if (contentOut.contains("\r\n")) {
                 contentOut = contentOut.replaceAll("\r\n", "@");
-            } else {
+            }
+            if (contentOut.contains("\n")) {
                 contentOut = contentOut.replaceAll("\n", "@");
             }
 
@@ -79,8 +81,7 @@ public class PatentRightUtils {
                     strs = content.split("。");
                     strsOut = contentOut.split("。");
                     //若匹配到，则根据不同情形拆分
-                }
-                else {
+                } else {
                     Matcher matcher = Pattern.compile(regex).matcher(content);
                     Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
                     while (matcher.find()) {
@@ -133,10 +134,9 @@ public class PatentRightUtils {
                                     .setParentSort(builder + "");
                             if (strsOut.length - 1 >= i) {
                                 //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                                if(strsOut.length>strs.length&&strs.length==(i+1)){
-                                    patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                                }
-                                else {
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
                                     patentRight.setContentOut(strsOut[i]);
                                 }
                             }
@@ -164,10 +164,9 @@ public class PatentRightUtils {
                                 .setParentSort("-1");
                         if (strsOut.length - 1 >= i) {
                             //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                            if(strsOut.length>strs.length&&strs.length==(i+1)){
-                                patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                            }
-                            else {
+                            if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                            } else {
                                 patentRight.setContentOut(strsOut[i]);
                             }
                         }
@@ -244,10 +243,9 @@ public class PatentRightUtils {
                                     .setParentSort(builder + "");
                             if (strsOut.length - 1 >= i) {
                                 //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                                if(strsOut.length>strs.length&&strs.length==(i+1)){
-                                    patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                                }
-                                else {
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
                                     patentRight.setContentOut(strsOut[i]);
                                 }
                             }
@@ -261,10 +259,9 @@ public class PatentRightUtils {
                                     .setSort(i)
                                     .setParentSort((Integer.parseInt(parentNum) - 1) + "");
                             //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                            if(strsOut.length>strs.length&&strs.length==(i+1)){
-                                patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                            }
-                            else {
+                            if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                            } else {
                                 patentRight.setContentOut(strsOut[i]);
                             }
                             patentRights.add(patentRight);
@@ -283,10 +280,9 @@ public class PatentRightUtils {
                                     .setSort(i)
                                     .setParentSort(builder.substring(0, builder.lastIndexOf(",")));
                             //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                            if(strsOut.length>strs.length&&strs.length==(i+1)){
-                                patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                            }
-                            else {
+                            if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                            } else {
                                 patentRight.setContentOut(strsOut[i]);
                             }
                             patentRights.add(patentRight);
@@ -300,10 +296,9 @@ public class PatentRightUtils {
                                 .setSort(i)
                                 .setParentSort("-1");
                         //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
-                        if(strsOut.length>strs.length&&strs.length==(i+1)){
-                            patentRight.setContentOut(String.join(" ",Arrays.copyOfRange(strsOut,i,strsOut.length)));
-                        }
-                        else {
+                        if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                            patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                        } else {
                             patentRight.setContentOut(strsOut[i]);
                         }
                         patentRights.add(patentRight);

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

@@ -0,0 +1,39 @@
+package cn.cslg.pas.common.utils;
+
+/**
+ * @Author chenyu
+ * @Date 2023/6/27
+ */
+public class RemoveHtmlTagsUtils {
+
+    /**
+     * 去除字符串文本中的所有HTML格式标签
+     *
+     * @param xmlText 字符串文本
+     * @return 返回修改后的字符串文本
+     */
+    public static String removeHtmlTags(String xmlText) {
+        //定义script的正则表达式，去除js可以防止注入
+        String scriptRegex = "<script[^>]*?>[\\s\\S]*?</script>";
+        //定义style的正则表达式，去除style样式，防止css代码过多时只截取到css样式代码
+        String styleRegex = "<style[^>]*?>[\\s\\S]*?</style>";
+        //定义HTML标签的正则表达式，去除标签，只提取文字内容
+        String htmlRegex = "<[^>]+>";
+        //定义空格,回车,换行符,制表符
+        //String spaceRegex = "\\s*|\t|\r|\n";
+        // 过滤script标签
+        xmlText = xmlText.replaceAll(scriptRegex, "");
+        // 过滤style标签
+        xmlText = xmlText.replaceAll(styleRegex, "");
+        // 过滤html标签
+        xmlText = xmlText.replaceAll(htmlRegex, "");
+        // 过滤空格,回车,换行符,制表符等
+        //instructionText = instructionText.replaceAll(spaceRegex, "");
+        // 过滤空格&nbsp;、&nbsp、&NBSP
+        xmlText = xmlText.replace("&nbsp;", "");
+        xmlText = xmlText.replace("&nbsp", " ");
+        xmlText = xmlText.replace("&NBSP", " ");
+        return xmlText;
+    }
+
+}

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

@@ -46,7 +46,7 @@ public class SystemController {
 
     @PostMapping("dict")
     @Operation(summary = "根据类型获得字典")
-    public String getPageList(@RequestBody  List<String> dicts) {
+    public String getPageList(@RequestBody List<String> dicts) {
         List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(dicts);
 //        Arrays.asList(Constants.ENTERPRISE_APPLICATION_SCENARIO)
         return Response.success(systemDictList);
@@ -60,7 +60,7 @@ public class SystemController {
 
     @PostMapping("getComPantentNos")
     @Operation(summary = "获得对比专利号")
-    public String getComPantentNos( @RequestBody QueryPatentVO params) {
+    public String getComPantentNos(@RequestBody QueryPatentVO params) {
         return patentService.getComPantentNos(params);
     }
 
@@ -69,6 +69,7 @@ public class SystemController {
     public String getConPantentNos(@RequestBody QueryPatentVO params) {
         return patentService.getConPantentNos(params);
     }
+
     @PostMapping("getConPantents")
     @Operation(summary = "获得条件过滤的专利")
     public String getConPantents(@RequestBody QueryPatentVO params) {
@@ -77,7 +78,7 @@ public class SystemController {
 
     @PostMapping("getPatentDTOListForRMS")
     @Operation(summary = "获得所有对比文件详细信息")
-    public String   getPatentDTOListForRMS(@RequestBody PatentVO params) {
+    public String getPatentDTOListForRMS(@RequestBody PatentVO params) {
         return Response.success(patentService.getPatentDTOListForRMS(params));
     }
 
@@ -89,7 +90,7 @@ public class SystemController {
 
     @PostMapping("/patentCellTODb")
     @Operation(summary = "专利上传到数据库")
-    public String   getPatentDTOListForRMS(@RequestBody PatentCell patentCell) throws ParseException {
+    public String getPatentDTOListForRMS(@RequestBody PatentCell patentCell) throws ParseException {
         uploadPatentBatchService.dataToDBCell(patentCell);
         return Response.success();
 

PAS/src/main/java/cn/cslg/pas/controller/outApi/PatentStarController.java

@@ -38,7 +38,7 @@ public class PatentStarController {
 
     @GetMapping("/getPicture")
     @Operation(summary = "获得中国专利摘要附图")
-    public String getPicture(String appNo) throws IOException {
+    public String getPicture(String appNo) {
         return patentStarApiService.getPictureApi(appNo);
     }
 
@@ -50,7 +50,7 @@ public class PatentStarController {
 
     @GetMapping("/getCnLegal")
     @Operation(summary = "获得中国专利法律状态")
-    public String getCnLegal(String appNo) throws IOException {
+    public String getCnLegal(String appNo) {
         return patentStarApiService.getCnLegalApi(appNo);
     }
 
@@ -80,7 +80,7 @@ public class PatentStarController {
 
     @GetMapping("/getFamilyByPubNo")
     @Operation(summary = "获得同族专利")
-    public String getFamilyByPubNo(String patentNo) throws IOException {
+    public String getFamilyByPubNo(String patentNo) {
         return patentStarApiService.getFamilyByPubNoApi(patentNo);
     }
 

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

@@ -0,0 +1,178 @@
+package cn.cslg.pas.domain;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 专利之星获得中国专利法律状态接口实体类
+ *
+ * @Author chenyu
+ * @Date 2023/6/28
+ */
+@Accessors(chain = true)
+@Data
+public class ChinaLeagalStatus implements Serializable {
+    /**
+     * 流水号
+     */
+    private String ID;
+    /**
+     * 卷期号
+     */
+    private String JUANQI;
+    /**
+     * 专利类型
+     */
+    private String PatentType;
+    /**
+     * 法律状态日期
+     */
+    private String LegalDate;
+    /**
+     * 法律状态
+     */
+    private String LegalStatus;
+    /**
+     * 详细法律状态
+     */
+    private String LegalStatusInfo;
+    /**
+     * 法律状态编码
+     */
+    private String LegalCode;
+    /**
+     * 卷
+     */
+    private String VOL;
+    /**
+     * 期
+     */
+    private String NUM;
+    /**
+     * 页码
+     */
+    private String PAG;
+    /**
+     * IPC分类
+     */
+    private String IPC;
+    /**
+     * 申请号
+     */
+    private String SHENQINGH;
+    /**
+     * 申请日
+     */
+    private String SHENQINGR;
+    /**
+     * 公开日
+     */
+    private String SHENQINGGBR;
+    /**
+     * 公告日
+     */
+    private String SHOUQUANGGR;
+    /**
+     * 无效登记号
+     */
+    private String WUXIAOXGJDH;
+    /**
+     * 无效登记日
+     */
+    private String WUXIAOXGJDR;
+    /**
+     * 终止日
+     */
+    private String ZHONGZHIR;
+    /**
+     * 放弃生效日
+     */
+    private String FANGQISXR;
+    /**
+     * 原名称
+     */
+    private String YUANMINGC;
+    /**
+     * 原公告号
+     */
+    private String YUANGONGGR;
+    /**
+     * 变更编号
+     */
+    private String BIANGENGSXCODE;
+    /**
+     * 变更事项
+     */
+    private String BIANGENGSX;
+    /**
+     * 变更前
+     */
+    private String BIANGENGQ;
+    /**
+     * 变更后
+     */
+    private String BIANGENGH;
+    /**
+     * 登记生效日
+     */
+    private String DENGJISXR;
+    /**
+     * 合同备案号
+     */
+    private String HETONGBAH;
+    /**
+     * 让与人
+     */
+    private String RANGYUR;
+    /**
+     * 受让人
+     */
+    private String SHOURANGR;
+    /**
+     * 专利名称
+     */
+    private String ZHUANLIMC;
+    /**
+     * 许可种类
+     */
+    private String XUKEZL;
+    /**
+     * 备案日期
+     */
+    private String BEIANRQ;
+    /**
+     * 变更日
+     */
+    private String BIANGENGR;
+    /**
+     * 解除日
+     */
+    private String JIECHUR;
+    /**
+     * 登记号
+     */
+    private String DENGJIH;
+    /**
+     * 出质人
+     */
+    private String CHUZHIR;
+    /**
+     * 质权人
+     */
+    private String ZHIQUANR;
+    /**
+     * 收件日
+     */
+    private String SHOUJIANR;
+    /**
+     * 文件名称
+     */
+    private String WENJIANMC;
+    /**
+     * 详细信息
+     */
+    private String DETAIL;
+
+}

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

@@ -0,0 +1,26 @@
+package cn.cslg.pas.domain;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 专利之星获得同族专利接口实体类
+ *
+ * @Author chenyu
+ * @Date 2023/6/27
+ */
+@Accessors(chain = true)
+@Data
+public class FamilyPatentNo implements Serializable {
+    /**
+     * 同族专利（包含自身，以分号;分隔的多个专利号）
+     */
+    private String familyinfo;
+    /**
+     * 同族专利数量
+     */
+    private String familycount;
+
+}

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

@@ -0,0 +1,32 @@
+package cn.cslg.pas.domain;
+
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 装载生产队列实体类
+ *
+ * @Author chenyu
+ * @Date 2023/6/28
+ */
+@Accessors(chain = true)
+@Data
+public class PQueueData implements Serializable {
+    /**
+     * 任务
+     */
+    private Task task;
+    /**
+     * 专利实体类
+     */
+    private UploadParamsVO uploadParamsVO;
+    /**
+     * 专利之星调用一般接口返回专利数据
+     */
+    private StarPatentVO starPatent;
+
+}

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

@@ -62,7 +62,7 @@ public class Task extends BaseEntity<Task> {
     private Integer endTime;
 
     /**
-     * 0.队列中 1.进行中 2.成功 3.失败 4.暂停 5.取消
+     * 0.队列中 1.进行中 2.已完成 4.已暂停
      */
     @TableField("status")
     private Integer status;
@@ -89,6 +89,11 @@ public class Task extends BaseEntity<Task> {
     @TableField("default_num")
     private Integer defaultNum;
     /**
+     * 生产过程中出错抛异常的专利数量
+     */
+    @TableField(exist = false)
+    private int exceptionNum;
+    /**
      * 前台参数json格式
      */
     @TableField("pram_json")

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

@@ -41,11 +41,11 @@ public class PatentAgencyService extends ServiceImpl<PatentAgencyMapper, PatentA
         LambdaQueryWrapper<PatentAgency> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(PatentAgency::getName, name);
         PatentAgency temp = this.getOne(queryWrapper);
-        //若没有，则将该代理机构新增入库
+        //若没有，则将该代理机构新增入库获得该代理机构id
         if (temp == null) {
             temp = this.add(name);
         }
-        //若有，则直接拿到代理机构id，并将id转成String类型返回
+        //将id转成String类型返回
         return String.valueOf(temp.getId());
     }
 

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

@@ -1,6 +1,7 @@
 package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
 import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.cslg.pas.domain.Patent;
@@ -62,12 +63,11 @@ public class PatentImageService extends ServiceImpl<PatentImageMapper, PatentIma
     }
 
     /**
-     * 新增专利摘要附图方法
+     * 摘要附图表"os_patent_img"新增专利摘要附图方法（Excel方式）
      *
      * @param patentId    专利id
      * @param pictureData 摘要附图
      * @return 返回摘要附图路径
-     * @throws IOException 抛出IO异常
      */
     public String updatePatentImage(Integer patentId, PictureData pictureData) throws IOException {
         //专利附图表"os_patent_img"根据专利id删除该专利的摘要图片数据，以免上传重复
@@ -85,6 +85,27 @@ public class PatentImageService extends ServiceImpl<PatentImageMapper, PatentIma
         return patentImage.getUrl();
     }
 
+    /**
+     * 摘要附图表"os_patent_img"新增专利摘要附图方法（网站导入方式）
+     *
+     * @param uploadParamsVO 专利实体类对象
+     * @return 返回摘要附图路径
+     */
+    public String updatePatentImage2(UploadParamsVO uploadParamsVO) throws IOException {
+        //专利附图表"os_patent_img"根据专利id删除该专利的摘要图片数据，以免上传重复
+        this.deleteByPatentIdAndStatus(uploadParamsVO.getPatent().getId(), 1);
+
+        //专利附图表实体类装载数据
+        PatentImage patentImage = new PatentImage();
+        patentImage.setStatus(1);
+        patentImage.setPatentId(uploadParamsVO.getPatent().getId());
+        patentImage.setUrl(uploadParamsVO.getFileDTO().getPath());
+        patentImage.setFileName(uploadParamsVO.getFileDTO().getFileName());
+        //数据入库
+        patentImage.insert();
+        return patentImage.getUrl();
+    }
+
     public void delete(Integer id) {
         PatentImage temp = this.getById(id);
         this.removeById(id);

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

@@ -161,6 +161,13 @@ public class PatentInstructionService extends ServiceImpl<PatentInstructionMappe
         return Response.success(true);
     }
 
+    /**
+     * 说明书pdf表数据入库
+     *
+     * @param patentNo
+     * @param pdf
+     * @return
+     */
     @Transactional
     public String edit(String patentNo, UploadFileDTO pdf) {
         PatentInstruction patentInstruction = new PatentInstruction();

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

@@ -438,14 +438,6 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
             List<PatentRight> patentRights = PatentRightUtils.formatPatentRight(params);
 
             if (patentRights.size() > 0) {
-                PatentRight patentRight = new PatentRight()
-                        .setPatentId(params.getPatentId())
-                        .setType(1)
-                        .setContent(params.getContent())
-                        .setSort(0)
-                        .setParentSort("-1");
-                //TODO 先根据专利id查询库中原权要，与当前权要比对，若不同则更新，若相同则不更新
-
                 //删除库表中原有该权要
                 this.deleteByPatentId(params.getPatentId());
                 //权要数据入表"os_patent_right"
@@ -459,7 +451,6 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
     }
 
 
-
 }
 
 

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

@@ -8,11 +8,13 @@ import cn.cslg.pas.common.model.vo.*;
 import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
 import cn.cslg.pas.domain.*;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.asso.AssoEventProjectMapper;
 import cn.cslg.pas.mapper.ProductMapper;
 import cn.cslg.pas.mapper.ProjectMapper;
 import cn.cslg.pas.mapper.asso.AssoStructurePatentMapper;
+import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.IterUtil;
 import cn.hutool.core.date.DateField;
@@ -81,6 +83,7 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
     private final PatentClassNumberLinkService patentClassNumberLinkService;
     private final ProjectPatentLinkService projectPatentLinkService;
     private final TaskService taskService;
+    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
     private final PatentImageService patentImageService;
     private final ProjectFieldPatentLinkService projectFieldPatentLinkService;
     private final ProjectFolderService projectFolderService;
@@ -544,7 +547,12 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
         //陈宇 ↓ 删除专题库产品架构标引表（asso_structure_patent）数据
         assoStructurePatentMapper.deleteByProjectId(id);
         //陈宇 ↓ 删除任务表（os_task）数据
-        taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getProjectId, id));
+        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getProjectId, id));
+        Task task = tasks.get(0);
+        taskService.removeById(task.getId());
+        //陈宇 ↓ 删除任务和任务条件关联表（asso_osTask_qrtzTask）数据
+        assoOsTaskQrtzTaskService.removeById(task.getQrtzTaskId());
+
         return Response.success();
     }
 

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

@@ -484,11 +484,11 @@ public class UploadPatentBatchService {
             patentSimpleFamilyParams.setSimpleFamily(uploadParamsVO.getSimpleFamily());
         }
         if (uploadParamsVO.getPatSnapFamily() != null) {
-            //装载
+            //装载PatSnap同族
             patentSimpleFamilyParams.setPatSnapFamily(uploadParamsVO.getPatSnapFamily());
         }
         if (uploadParamsVO.getInpadocFamily() != null) {
-            //装载
+            //装载Inpadoc同族
             patentSimpleFamilyParams.setInpadocFamily(uploadParamsVO.getInpadocFamily());
         }
         //装载专利id

PAS/src/main/java/cn/cslg/pas/service/outApi/PatentStarApiService.java

@@ -104,7 +104,11 @@ public class PatentStarApiService {
         String Sign = "FNYJD7902206FFB741E163BE6536C3689D55" + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个RequestBody(参数1：数据类型 参数2传递的json串)
         FormBody.Builder builder = new FormBody.Builder();
         builder.add("AppID", "K8FFB741E163BE6536");
@@ -152,7 +156,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -181,7 +189,7 @@ public class PatentStarApiService {
      * @author 李仁杰
      * 从专利之星获取中国专利摘要附图
      */
-    public String getPictureApi(String patentNo) throws IOException {
+    public String getPictureApi(String patentNo) {
         String url = "https://api.patentstar.com.cn/api/Patent/CnMainImage/" + patentNo;
         String appId = "2000041";
         String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
@@ -189,7 +197,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -227,7 +239,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -256,7 +272,7 @@ public class PatentStarApiService {
      * @author 李仁杰
      * 从专利之星获取中国专利法律状态
      */
-    public String getCnLegalApi(String appNo) throws IOException {
+    public String getCnLegalApi(String appNo) {
         String url = "https://api.patentstar.com.cn/api/Patent/CnLegal/" + appNo;
         String appId = "2000041";
         String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
@@ -264,7 +280,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -302,7 +322,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -340,7 +364,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -369,7 +397,7 @@ public class PatentStarApiService {
      * @author 李仁杰
      * 从专利之星获取世界专利pdf
      */
-    public String getEnPdfApi(String patentNo) throws IOException {
+    public String getEnPdfApi(String patentNo) {
         String url = "  https://api.patentstar.com.cn/api/Patent/EnPdf/" + patentNo;
         String appId = "2000041";
         String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
@@ -377,7 +405,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -406,7 +438,7 @@ public class PatentStarApiService {
      * @author 李仁杰
      * 从专利之星获取世界专利著录信息
      */
-    public String getENBibApi(String patentNo) throws IOException {
+    public String getENBibApi(String patentNo) {
         String url = "https://api.patentstar.com.cn/api/Patent/ENBib/" + patentNo;
         String appId = "2000041";
         String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
@@ -414,7 +446,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -443,7 +479,7 @@ public class PatentStarApiService {
      * @author 李仁杰
      * 从专利之星获取同族专利
      */
-    public String getFamilyByPubNoApi(String patentNo) throws IOException {
+    public String getFamilyByPubNoApi(String patentNo) {
         String url = "https://api.patentstar.com.cn/api/Patent/FamilyByPubNo/" + patentNo;
         String appId = "2000041";
         String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
@@ -451,7 +487,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")
@@ -488,7 +528,11 @@ public class PatentStarApiService {
         String Sign = appId + appkey + currentTimeMillis.toString();
         String signMd5 = FormatUtil.MD5(Sign);
         // 创建一个OkHttpClient对象
-        OkHttpClient okHttpClient = new OkHttpClient();
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
+                .build();
         // 创建一个请求对象
         Request request = new Request.Builder().url(url)
                 .addHeader("_appid", "2000041")

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

@@ -57,7 +57,6 @@ public class ExcutePatentDataEpo implements IExcutePatentData {
      * 解析获取专利数据
      *
      * @param task 任务
-     * @throws IOException 抛出IO异常
      */
     @Override
     public void startExcute(Task task) throws IOException {

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

@@ -61,7 +61,7 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
             //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
             UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
 
-            //专利入消费者队列，并唤醒消费者
+            //专利丢入5个消费者队列，并唤醒5个消费者线程
             pantentQueueService.patentToQueue(task, uploadParamsVO, projectImportPatentVO);
         }
     }

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

@@ -1,20 +1,29 @@
 package cn.cslg.pas.service.upLoadPatent;
 
+import cn.cslg.pas.common.model.dto.UploadFileDTO;
 import cn.cslg.pas.common.model.outApi.PatentStarListDto;
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 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.domain.*;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.UploadPatentBatchService;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import cn.cslg.pas.service.outApi.PatentStarApiService;
 import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.fileupload.FileItem;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.commons.CommonsMultipartFile;
 
-import java.io.IOException;
+import java.io.*;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -34,12 +43,15 @@ import java.util.regex.Pattern;
 public class ExcutePatentDataStar implements IExcutePatentData {
     private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
     private final PatentStarApiService patentStarApiService;
+    private final FileUtils fileUtils;
+    private final PantentQueueService pantentQueueService;
+    private final UploadPatentBatchService uploadPatentBatchService;
+
 
     /**
      * 解析获取专利数据
      *
      * @param task 任务
-     * @throws IOException 抛出IO异常
      */
     @Override
     public void startExcute(Task task) throws IOException {
@@ -58,14 +70,16 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         //获得专利总数量
         Integer count = task.getTotal();
 
-        ArrayList<UploadParamsVO> uploadParamsVOs = new ArrayList<>();
         //1.根据专利总数量count遍历检索专利
+        int pageNum = 0;  //页码
+        //int exceptionNum = 0;  //中途出错未生产完成的专利数量
         for (int i = 1; i <= count; i += size) {
+            pageNum++;
             PatentStarListDto patentStarListDto = new PatentStarListDto()
                     .setCurrentQuery(conditions)
                     .setOrderBy("AD")
                     .setOrderByType("DESC")
-                    .setPageNum(1)
+                    .setPageNum(pageNum)
                     .setRowCount(size)
                     .setDBType("cN");
             //调用一般接口
@@ -73,46 +87,76 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             if (resultMap == null || (Integer) resultMap.get("total") == 0) {
                 continue;
             }
-            //调用一般接口返回专利相关数据
+
+            //调用一般接口返回一批专利著录相关数据
             List<StarPatentVO> patents = (List<StarPatentVO>) resultMap.get("records");
 
             //遍历50个专利
             for (StarPatentVO starPatent : patents) {
-                UploadParamsVO uploadParamsVO = new UploadParamsVO();
-                Patent patent = new Patent();
-                //装载专利著录
-                if (cells.contains("1")) {
-                    setPatentZhuLu(starPatent, uploadParamsVO, patent);
-                }
-
-                //装载权要
-                if (cells.contains("2")) {
-                    setPatentClaim(starPatent, uploadParamsVO);
+                try {
+                    UploadParamsVO uploadParamsVO = new UploadParamsVO();
+                    setPatentZhuLu(starPatent, uploadParamsVO);
+                    //保存专利基础数据（专利表"os_patent"）
+                    uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
+
+                    PQueueData pQueueData = new PQueueData()
+                            .setTask(task)
+                            .setStarPatent(starPatent)
+                            .setUploadParamsVO(uploadParamsVO);
+                    //装载专利著录
+                    if (cells.contains("1")) {
+                        pantentQueueService.zhuluToPQueue(pQueueData);
+                    }
+                    //装载权要
+                    if (cells.contains("2")) {
+                        //setPatentClaim(starPatent, uploadParamsVO);
+                        pantentQueueService.rightToPQueue(pQueueData);
+                    }
+                    //装载说明书文本
+                    if (cells.contains("3")) {
+                        //setPatentInstructionText(starPatent, uploadParamsVO);
+                        pantentQueueService.instructionTextToPQueue(pQueueData);
+                    }
+                    //装载说明书pdf
+                    if (cells.contains("4")) {
+                        //setPatentInstructionPDF(starPatent, uploadParamsVO);
+                        pantentQueueService.instructionPDFToPQueue(pQueueData);
+                    }
+                    //装载摘要附图
+                    if (cells.contains("6")) {
+                        //setPatentPicture(starPatent, uploadParamsVO);
+                        pantentQueueService.imageToPQueue(pQueueData);
+                    }
+
+                    //将该专利存入5个消费者队列
+                    //ProjectImportPatentVO projectImportPatentVO = new ProjectImportPatentVO();
+                    //projectImportPatentVO.setProjectId(task.getProjectId());
+                    //task.setExceptionNum(exceptionNum);
+                    //专利丢入5个消费者队列，并唤醒5个消费者线程
+                    //pantentQueueService.patentToQueue(task, uploadParamsVO, projectImportPatentVO);
+
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    //exceptionNum++;
+                    //跳过当前生产出问题的专利，继续生产下一个专利
                 }
 
-                //装载说明书文本
-                if (cells.contains("3")) {
-                    setPatentInstructionText(starPatent, uploadParamsVO);
-                }
-
-
-                uploadParamsVOs.add(uploadParamsVO);
             }
 
         }
 
-        System.out.println("专利总数量：" + uploadParamsVOs.size());
 
     }
 
     /**
      * 装载著录方法
      *
-     * @param uploadParamsVO 专利实体类对象
-     * @param patent         专利基础数据实体类对象
      * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
      */
-    private void setPatentZhuLu(StarPatentVO starPatent, UploadParamsVO uploadParamsVO, Patent patent) {
+    public void setPatentZhuLu(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        //以下 ↓装载的是调用"一般检索"接口返回的专利相关数据
+        Patent patent = new Patent();
         //装载专利号
         patent.setPatentNo(starPatent.getPatentNo());
         //装载申请号
@@ -123,7 +167,6 @@ public class ExcutePatentDataStar implements IExcutePatentData {
         }
         //装载公开号
         patent.setPublicNo(starPatent.getPublicNo());
-
         //装载公开日
         if (starPatent.getPublicDate() != null && !starPatent.getPublicDate().equals(""))
             patent.setPublicDate(Integer.parseInt(starPatent.getPublicDate()));
@@ -142,10 +185,14 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             uploadParamsVO.setMainIpc(ipcArr[0]);
             uploadParamsVO.setIpcList(Arrays.asList(ipcArr));
         }
-        //以上 ↑装载的是调用"一般接口"返回的专利相关数据
 
-        //以下 ↓装载的是调用"中国专利著录接口"返回的专利相关数据
-        String appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+        //以下 ↓装载的是调用"获得中国专利著录"接口返回的专利相关数据
+        String appNo = null;
+        if (starPatent.getApplicationNo().contains(".")) {
+            appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+        } else {
+            appNo = starPatent.getApplicationNo();
+        }
         //调用中国专利著录接口返回的专利相关数据最外层是一个集合"[]"，但是集合中只有一个对象"{}"，以下方式处理
         String chinaPatentZhuLuStr = patentStarApiService.getCnBibApi(appNo);
         //chinaPatentZhuLuStr = chinaPatentZhuLuStr.substring(chinaPatentZhuLuStr.indexOf("["), chinaPatentZhuLuStr.lastIndexOf("[")).trim();
@@ -156,9 +203,12 @@ public class ExcutePatentDataStar implements IExcutePatentData {
 
         //装载申请人地址
         ArrayList<String> patentApplicantOriginalAddresss = new ArrayList<>();
-        patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ().substring(chinaPatentZhuLu.getDZ().indexOf(" ") + 1));
+        if (chinaPatentZhuLu.getDZ().contains(" ")) {
+            patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ().substring(chinaPatentZhuLu.getDZ().indexOf(" ") + 1));
+        } else {
+            patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ());
+        }
         uploadParamsVO.setPatentApplicantOriginalAddress(patentApplicantOriginalAddresss);
-
         //装载代理人
         List<String> patentAgents = Arrays.asList(chinaPatentZhuLu.getAT().split(";"));
         ArrayList<PatentAgent> patentAgentList = new ArrayList<>();
@@ -168,13 +218,16 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             patentAgentList.add(patentAgent);
         }
         uploadParamsVO.setPatentAgentList(patentAgentList);
-
         //装载代理机构地址
         if (chinaPatentZhuLu.getAGN() != null && !chinaPatentZhuLu.getAGN().equals("")) {
-            String agencyAddress = chinaPatentZhuLu.getAGN().substring(0, chinaPatentZhuLu.getAGN().lastIndexOf(" "));
+            String agencyAddress;
+            if (chinaPatentZhuLu.getAGN().contains(" ")) {
+                agencyAddress = chinaPatentZhuLu.getAGN().substring(0, chinaPatentZhuLu.getAGN().lastIndexOf(" "));
+            } else {
+                agencyAddress = chinaPatentZhuLu.getAGN();
+            }
             patent.setAgencyId(agencyAddress);
         }
-
         //装载发明人
         List<String> patentInventorNames = Arrays.asList(chinaPatentZhuLu.getIV().split(";"));
         ArrayList<PatentInventor> patentInventors = new ArrayList<>();
@@ -184,24 +237,28 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             patentInventors.add(patentInventor);
         }
         uploadParamsVO.setPatentInventorList(patentInventors);
+        //装载优先权号、优先权国家、优先权日
+        String priorityInfo = chinaPatentZhuLu.getPR();
+        patent.setPriorityNo(priorityInfo);
 
+        //以下 ↓装载的是调用"获得同族专利"接口返回的专利相关数据
+        String familyPatentNoStr = patentStarApiService.getFamilyByPubNoApi(starPatent.getPatentNo());
+        FamilyPatentNo familyPatentNo = JSON.parseObject(familyPatentNoStr, FamilyPatentNo.class);
         //装载同族号
-//        patentCell.setFamilyId(patent.getFamilyId());
-//        //装载优先权号、优先权国家、优先权日
-//        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);
+        if (familyPatentNo.getFamilyinfo() != null && !familyPatentNo.getFamilyinfo().equals("")) {
+            List<String> simpleFamily = Arrays.asList(familyPatentNo.getFamilyinfo().split(";"));
+            uploadParamsVO.setSimpleFamily(simpleFamily);
+        }
+
+        //以下 ↓装载的是调用"获得中国专利法律状态"接口返回的专利相关数据
+        String cnLegalApiStr = patentStarApiService.getCnLegalApi(appNo);
+        List<ChinaLeagalStatus> chinaLeagalStatuses = JSON.parseArray(cnLegalApiStr, ChinaLeagalStatus.class);
+        ChinaLeagalStatus chinaLeagalStatus = chinaLeagalStatuses.get(0);
+        //装载法律状态
+        uploadParamsVO.setSimpleStatus(chinaLeagalStatus.getLegalStatus());
+
+
+        //最后将 patent装载到 uploadParamsVO
         uploadParamsVO.setPatent(patent);
 
     }
@@ -209,14 +266,20 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     /**
      * 装载权要方法
      *
+     * @param starPatent     专利之星著录对象
      * @param uploadParamsVO 专利实体类对象
      */
-    private void setPatentClaim(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
-        String appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+    public void setPatentClaim(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
+        String appNo = null;
+        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);
@@ -225,9 +288,14 @@ public class ExcutePatentDataStar implements IExcutePatentData {
             builder.append(matcher.group()).append("\r\n");
         }
 
+        String patentRightText = builder + "";
+
+        //使用工具类去除字符串文本中的所有HTML格式标签
+        patentRightText = RemoveHtmlTagsUtils.removeHtmlTags(patentRightText);
+
         //装载权利要求原文
         PatentRight patentRight = new PatentRight();
-        patentRight.setContent(builder + "");
+        patentRight.setContent(patentRightText);
         uploadParamsVO.setPatentRight(patentRight);
 
     }
@@ -235,26 +303,156 @@ public class ExcutePatentDataStar implements IExcutePatentData {
     /**
      * 装载说明书文本
      *
+     * @param starPatent     专利之星著录对象
      * @param uploadParamsVO 专利实体类对象
      */
-    private void setPatentInstructionText(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
-        String appNo = starPatent.getApplicationNo().substring(0, starPatent.getApplicationNo().lastIndexOf("."));
+    public void setPatentInstructionText(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) throws IOException {
+        String appNo = null;
+        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>)";
+        //使用正则表达式拼接出说明书文本全文
+        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()) {
-            builder.append(matcher.group()).append("\r\n");
+            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");
         }
 
+        String instructionText = builder + "";
+
+        //使用工具类去除字符串文本中的所有HTML格式标签
+        instructionText = RemoveHtmlTagsUtils.removeHtmlTags(instructionText);
+
         //装载说明书文本全文
+        PatentInstructionText patentInstructionText = new PatentInstructionText();
+        patentInstructionText.setManual(instructionText);
+        uploadParamsVO.setPatentInstructionText(patentInstructionText);
+
+    }
+
+    /**
+     * 装载说明书pdf
+     *
+     * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
+     */
+    public void setPatentInstructionPDF(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        String patentNo = starPatent.getPatentNo();
+        //根据专利号调用"获得世界专利pdf"接口，获得pdf的url地址
+        String pdfUrl = patentStarApiService.getEnPdfApi(patentNo);
+
+        try {
+            URL url = new URL(pdfUrl);  //想要读取的url地址
+            InputStream in = url.openStream();
+
+            File file = File.createTempFile("new_url", ".pdf");  //创建文件
+            OutputStream os = new FileOutputStream(file);  //创建文件输出流
+            int bytesRead;
+            byte[] buffer = new byte[8192];
+            int len = 8192;
+            while ((bytesRead = in.read(buffer, 0, len)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            //关闭释放流
+            os.close();
+            in.close();
+
+            DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
+            FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
+            buffer = new byte[8192];
+            FileInputStream fis = new FileInputStream(file);
+            OutputStream fos = item.getOutputStream();
+            len = 8192;
+            while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
+                fos.write(buffer, 0, bytesRead);
+            }
+            //关闭释放流
+            fos.close();
+            fis.close();
+            MultipartFile multipartFile = new CommonsMultipartFile(item);
+            UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
+            uploadParamsVO.setFileDTO(fileDTO);
+
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 装载摘要附图
+     *
+     * @param starPatent     专利之星著录对象
+     * @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);
+
+        try {
+            URL url = new URL(pictureUrl);  //想要读取的url地址
+            InputStream in = url.openStream();
+
+            File file = File.createTempFile("new_url", ".jpg");  //创建文件
+            OutputStream os = new FileOutputStream(file);  //创建文件输出流
+            int bytesRead;
+            byte[] buffer = new byte[8192];
+            int len = 8192;
+            while ((bytesRead = in.read(buffer, 0, len)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            //关闭释放流
+            os.close();
+            in.close();
+
+            DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);
+            FileItem item = diskFileItemFactory.createItem(file.getName(), "text/plain", true, file.getName());
+            buffer = new byte[8192];
+            FileInputStream fis = new FileInputStream(file);
+            OutputStream fos = item.getOutputStream();
+            len = 8192;
+            while ((bytesRead = fis.read(buffer, 0, len)) != -1) {
+                fos.write(buffer, 0, bytesRead);
+            }
+            //关闭释放流
+            fos.close();
+            fis.close();
+            MultipartFile multipartFile = new CommonsMultipartFile(item);
+            UploadFileDTO fileDTO = fileUtils.uploadFile(multipartFile);
+            uploadParamsVO.setFileDTO(fileDTO);
 
 
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
 
     }
 
+
 }

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

@@ -3,8 +3,10 @@ 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.utils.DateUtils;
+import cn.cslg.pas.domain.PQueueData;
 import cn.cslg.pas.domain.QueueData;
 import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.service.PatentInstructionService;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -33,31 +35,49 @@ public class PantentQueueService {
     private final ExcutePatentDataExcel excutePatentDataExcel;
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final ExcutePatentDataStar excutePatentDataStar;
+    private final PatentInstructionService patentInstructionService;
     private final List<Integer> taskQueueList = new ArrayList<>();
-    private Boolean flag = false;
+    private final List<PQueueData> setPatentImageQueueList = new ArrayList<>();
+    private final List<PQueueData> setPatentZhuluQueueList = new ArrayList<>();
+    private final List<PQueueData> setPatentRightQueueList = new ArrayList<>();
+    private final List<PQueueData> setPatentInstructionTextQueueList = new ArrayList<>();
+    private final List<PQueueData> setPatentInstructionPDFQueueList = new ArrayList<>();
     private final List<QueueData> patentImageQueueList = new ArrayList<>();
     private final List<QueueData> patentZhuluQueueList = new ArrayList<>();
     private final List<QueueData> patentRightQueueList = new ArrayList<>();
     private final List<QueueData> patentInstructionTextQueueList = new ArrayList<>();
+    private final List<QueueData> patentInstructionPDFQueueList = new ArrayList<>();
     private final Lock taskLock = new ReentrantLock();
+    private final Lock setPatentImageLock = new ReentrantLock();
+    private final Lock setPatentZhuluLock = new ReentrantLock();
+    private final Lock setPatentRightLock = new ReentrantLock();
+    private final Lock setPatentInstructionTextLock = new ReentrantLock();
+    private final Lock setPatentInstructionPDFLock = new ReentrantLock();
     private final Lock patentImageLock = new ReentrantLock();
     private final Lock patentZhuluLock = new ReentrantLock();
     private final Lock patentRightLock = new ReentrantLock();
     private final Lock patentInstructionTextLock = new ReentrantLock();
+    private final Lock patentInstructionPDFLock = new ReentrantLock();
     private final Condition taskCondition = taskLock.newCondition();
+    private final Condition setPatentImageCondition = setPatentImageLock.newCondition();
+    private final Condition setPatentZhuluCondition = setPatentZhuluLock.newCondition();
+    private final Condition setPatentRightCondition = setPatentRightLock.newCondition();
+    private final Condition setPatentInstructionTextCondition = setPatentInstructionTextLock.newCondition();
+    private final Condition setPatentInstructionPDFCondition = setPatentInstructionPDFLock.newCondition();
     private final Condition patentImageCondition = patentImageLock.newCondition();
     private final Condition patentZhuluCondition = patentZhuluLock.newCondition();
     private final Condition patentRightCondition = patentRightLock.newCondition();
     private final Condition patentInstructionTextCondition = patentInstructionTextLock.newCondition();
+    private final Condition patentInstructionPDFCondition = patentInstructionPDFLock.newCondition();
     private final HashMap<String, Integer> patentIdMap = new HashMap<>();
 
     /**
      * 生产者：从任务队列取出任务，再调用工厂方法根据任务类型返回对应的生产专利方法的对象将专利分配给消费者
      */
     public void addPatnetToQueue() {
-        Task task = null;
-        try {
-            while (true) {
+        while (true) {
+            Task task = new Task();
+            try {
                 //判断任务队列是否有任务，若没有则该生产者线程睡眠
                 if (taskQueueList.size() == 0) {
                     taskLock.lock();
@@ -86,16 +106,198 @@ public class PantentQueueService {
 
                 }
 
+            } catch (Exception e) {
+                e.printStackTrace();
+                //任务表更新状态为失败
+                task.setStatus(2);
+                task.setEndTime(DateUtils.getDateTime());
+                taskService.updateById(task);
+            }
+
+        }
+    }
+
+    /**
+     * 装载线程1：著录项目
+     */
+    public void setPatentZhuLu() {
+        while (true) {
+            try {
+                if (setPatentZhuluQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentZhuluQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    //专利之星
+                    //if (task.getType() == 4) {
+                    //excutePatentDataStar.setPatentZhuLu(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    //}
+                    ProjectImportPatentVO projectImportPatentVO = new ProjectImportPatentVO();
+                    projectImportPatentVO.setProjectId(task.getProjectId());
+                    QueueData queueData = new QueueData()
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO())
+                            .setProjectImportPatentVO(projectImportPatentVO);
+                    //装载完成，将其丢入著录消费者队列，并唤醒著录消费者线程
+                    patentZhuluQueueList.add(queueData);
+                    patentZhuluLock.lock();
+                    patentZhuluCondition.signalAll();
+                    patentZhuluLock.unlock();
+
+                } else {
+                    setPatentZhuluLock.lock();
+                    setPatentZhuluCondition.await();
+                    setPatentZhuluLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+
+            }
+
+        }
+    }
+
+    /**
+     * 装载线程2：摘要附图
+     */
+    public void setPatentImage() {
+        while (true) {
+            try {
+                if (setPatentImageQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentImageQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentPicture(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    }
+                    QueueData queueData = new QueueData()
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+                    //装载完成，将其丢入摘要附图消费者队列，并唤醒摘要附图消费者线程
+                    patentImageQueueList.add(queueData);
+                    patentImageLock.lock();
+                    patentImageCondition.signalAll();
+                    patentImageLock.unlock();
+
+                } else {
+                    setPatentImageLock.lock();
+                    setPatentImageCondition.await();
+                    setPatentImageLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+
+            }
+
+        }
+    }
+
+    /**
+     * 装载线程3：权要
+     */
+    public void setPatentRight() {
+        while (true) {
+            try {
+                if (setPatentRightQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentRightQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentClaim(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    }
+                    QueueData queueData = new QueueData()
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+                    //装载完成，将其丢入权要消费者队列，并唤醒权要消费者线程
+                    patentRightQueueList.add(queueData);
+                    patentRightLock.lock();
+                    patentRightCondition.signalAll();
+                    patentRightLock.unlock();
+
+                } else {
+                    setPatentRightLock.lock();
+                    setPatentRightCondition.await();
+                    setPatentRightLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+
+            }
+
+        }
+    }
+
+    /**
+     * 装载线程4：说明书文本
+     */
+    public void setPatentInstructionText() {
+        while (true) {
+            try {
+                if (setPatentInstructionTextQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentInstructionTextQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentInstructionText(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    }
+                    QueueData queueData = new QueueData()
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+                    //装载完成，将其丢入说明书文本消费者队列，并唤醒说明书文本消费者线程
+                    patentInstructionTextQueueList.add(queueData);
+                    patentInstructionTextLock.lock();
+                    patentInstructionTextCondition.signalAll();
+                    patentInstructionTextLock.unlock();
+
+                } else {
+                    setPatentInstructionTextLock.lock();
+                    setPatentInstructionTextCondition.await();
+                    setPatentInstructionTextLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+
+            }
+
+        }
+    }
+
+    /**
+     * 装载线程5：说明书pdf
+     */
+    public void setPatentInstructionPDF() {
+        while (true) {
+            try {
+                if (setPatentInstructionPDFQueueList.size() > 0) {
+                    PQueueData pQueueData = setPatentInstructionPDFQueueList.remove(0);
+                    Task task = pQueueData.getTask();
+                    //专利之星
+                    if (task.getType() == 4) {
+                        excutePatentDataStar.setPatentInstructionPDF(pQueueData.getStarPatent(), pQueueData.getUploadParamsVO());
+                    }
+                    QueueData queueData = new QueueData()
+                            .setTask(task)
+                            .setUploadParamsVO(pQueueData.getUploadParamsVO());
+                    //装载完成，将其丢入说明书pdf消费者队列，并唤醒说明书pdf消费者线程
+                    patentInstructionPDFQueueList.add(queueData);
+                    patentInstructionPDFLock.lock();
+                    patentInstructionPDFCondition.signalAll();
+                    patentInstructionPDFLock.unlock();
+
+                } else {
+                    setPatentInstructionPDFLock.lock();
+                    setPatentInstructionPDFCondition.await();
+                    setPatentInstructionPDFLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+
             }
 
-        } catch (Exception e) {
-            e.printStackTrace();
-            //任务表更新状态为失败
-            task.setStatus(3);
-            task.setEndTime(DateUtils.getDateTime());
-            taskService.updateById(task);
         }
-        flag = true;
     }
 
     /**
@@ -103,26 +305,28 @@ public class PantentQueueService {
      */
     public void pushPatentImageToDB() throws InterruptedException, IOException {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentImageQueueList.isEmpty()) {
-                    if (flag) {
-                        System.out.println("摘要附图全部完成，退出循环");
-                        return;
+                if (patentImageQueueList.size() > 0) {
+                    queueData = patentImageQueueList.remove(0);
+                    UploadParamsVO uploadParamsVO = queueData.getUploadParamsVO();
+                    //摘要附图入库（两种方式：1.Excel摘要附图方式 2.网站导入摘要附图方式）
+                    if (queueData.getTask().getType().equals(1)) {
+                        uploadPatentToDBService.uploadPatentImage(uploadParamsVO);
                     } else {
-                        patentImageLock.lock();
-                        patentImageCondition.await();
-                        patentImageLock.unlock();
+                        uploadPatentToDBService.uploadPatentImage2(uploadParamsVO);
                     }
-                } else {
-                    QueueData queueData = patentImageQueueList.remove(0);
-                    //摘要附图入库
-                    uploadPatentToDBService.uploadPatentImage(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData);
+                } else {
+                    patentImageLock.lock();
+                    patentImageCondition.await();
+                    patentImageLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
 
             }
 
@@ -134,18 +338,10 @@ public class PantentQueueService {
      */
     public void pushPatentZhuLuToDB() throws InterruptedException, IOException {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentZhuluQueueList.isEmpty()) {
-                    if (flag) {
-                        System.out.println("著录项目全部完成，退出循环");
-                        return;
-                    } else {
-                        patentZhuluLock.lock();
-                        patentZhuluCondition.await();
-                        patentZhuluLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentZhuluQueueList.remove(0);
+                if (patentZhuluQueueList.size() > 0) {
+                    queueData = patentZhuluQueueList.remove(0);
                     //著录项目入库
                     uploadPatentToDBService.uploadPatentZhulu(queueData.getUploadParamsVO());
                     //专题库与专利关联入库
@@ -156,10 +352,15 @@ public class PantentQueueService {
                     uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData);
+                } else {
+                    patentZhuluLock.lock();
+                    patentZhuluCondition.await();
+                    patentZhuluLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
@@ -170,26 +371,23 @@ public class PantentQueueService {
      */
     public void pushPatentRightToDB() throws InterruptedException, IOException {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentRightQueueList.isEmpty()) {
-                    if (flag) {
-                        System.out.println("权利要求全部完成，退出循环");
-                        return;
-                    } else {
-                        patentRightLock.lock();
-                        patentRightCondition.await();
-                        patentRightLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentRightQueueList.remove(0);
+                if (patentRightQueueList.size() > 0) {
+                    queueData = patentRightQueueList.remove(0);
                     //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData);
+                } else {
+                    patentRightLock.lock();
+                    patentRightCondition.await();
+                    patentRightLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
@@ -200,33 +398,62 @@ public class PantentQueueService {
      */
     public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentInstructionTextQueueList.isEmpty()) {
-                    if (flag) {
-                        System.out.println("说明书文本全部完成，退出循环");
-                        return;
-                    } else {
-                        patentInstructionTextLock.lock();
-                        patentInstructionTextCondition.await();
-                        patentInstructionTextLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentInstructionTextQueueList.remove(0);
+                if (patentInstructionTextQueueList.size() > 0) {
+                    queueData = patentInstructionTextQueueList.remove(0);
                     //说明书文本入库
                     uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData);
+                } else {
+                    patentInstructionTextLock.lock();
+                    patentInstructionTextCondition.await();
+                    patentInstructionTextLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
     }
 
+    /**
+     * 消费者5：将专利从队列取出，说明书pdf地址入库
+     */
+    public void pushPatentInstructionPDFToDB() throws InterruptedException, IOException {
+        while (true) {
+            QueueData queueData = new QueueData();
+            try {
+                if (patentInstructionPDFQueueList.size() > 0) {
+                    queueData = patentInstructionPDFQueueList.remove(0);
+                    //说明书pdf入库
+                    patentInstructionService.edit(queueData.getUploadParamsVO().getPatent().getPatentNo(), queueData.getUploadParamsVO().getFileDTO());
+                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+                    sendMessage(queueData);
+                } else {
+                    patentInstructionPDFLock.lock();
+                    patentInstructionPDFCondition.await();
+                    patentInstructionPDFLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                sendMessage(queueData);
+            }
+
+        }
+    }
+
+    /**
+     * 当一个消费者消费完其负责的专利部分，修改成功条数，计算发送进度
+     *
+     * @param queueData 任务专利队列对象
+     */
     public void sendMessage(QueueData queueData) {
-        //每完成一个专利，通过计算，发送进度
+        //每完成一个专利(根据计算该任务该专利的所有消费者都完成时)，发送进度
         synchronized ("此为同步锁") {
             //当前进行的任务
             Task task = queueData.getTask();
@@ -238,7 +465,7 @@ public class PantentQueueService {
             Integer num = patentIdMap.get(currentPatent);
             if (num == null) {
                 patentIdMap.put(currentPatent, 1);
-            } else if (num < 3) {
+            } else if (num < 4) {
                 patentIdMap.put(currentPatent, ++num);
             } else {
                 /*
@@ -263,7 +490,7 @@ public class PantentQueueService {
                 taskService.updateById(updateTask);
 
                 //当全部完成时
-                if (task.getSuccessNum().equals(total)) {
+                if (task.getSuccessNum() + task.getExceptionNum() == total) {
                     percentage = 100L;
                     //设置任务状态为成功
                     task.setStatus(2);
@@ -278,6 +505,73 @@ public class PantentQueueService {
         }
     }
 
+    /**
+     * 数据丢入摘要附图生产队列并唤醒装载摘要附图线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void imageToPQueue(PQueueData pQueueData) {
+        setPatentImageQueueList.add(pQueueData);
+        setPatentImageLock.lock();
+        setPatentImageCondition.signalAll();
+        setPatentImageLock.unlock();
+    }
+
+    /**
+     * 数据丢入著录项目生产队列并唤醒装载著录项目线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void zhuluToPQueue(PQueueData pQueueData) {
+        setPatentZhuluQueueList.add(pQueueData);
+        setPatentZhuluLock.lock();
+        setPatentZhuluCondition.signalAll();
+        setPatentZhuluLock.unlock();
+    }
+
+    /**
+     * 数据丢入权要生产队列并唤醒装载权要线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void rightToPQueue(PQueueData pQueueData) {
+        setPatentRightQueueList.add(pQueueData);
+        setPatentRightLock.lock();
+        setPatentRightCondition.signalAll();
+        setPatentRightLock.unlock();
+    }
+
+    /**
+     * 数据丢入说明书文本生产队列并唤醒装载说明书文本线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void instructionTextToPQueue(PQueueData pQueueData) {
+        setPatentInstructionTextQueueList.add(pQueueData);
+        setPatentInstructionTextLock.lock();
+        setPatentInstructionTextCondition.signalAll();
+        setPatentInstructionTextLock.unlock();
+    }
+
+    /**
+     * 数据丢入说明书pdf生产队列并唤醒装载说明书pdf线程
+     *
+     * @param pQueueData 装载生产队列实体类
+     */
+    public void instructionPDFToPQueue(PQueueData pQueueData) {
+        setPatentInstructionPDFQueueList.add(pQueueData);
+        setPatentInstructionPDFLock.lock();
+        setPatentInstructionPDFCondition.signalAll();
+        setPatentInstructionPDFLock.unlock();
+    }
+
+    /**
+     * 专利丢入5个消费者队列，并唤醒5个消费者线程
+     *
+     * @param task                  任务对象
+     * @param uploadParamsVO        专利实体类对象
+     * @param projectImportPatentVO 专利与专题库关联数据对象
+     */
     public void patentToQueue(Task task, UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
         //保存专利基础数据（专利表"os_patent"）
         uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
@@ -293,8 +587,9 @@ public class PantentQueueService {
         patentZhuluQueueList.add(queueData);
         patentRightQueueList.add(queueData);
         patentInstructionTextQueueList.add(queueData);
+        patentInstructionPDFQueueList.add(queueData);
 
-        //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、与专利关联数据）
+        //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、说明书pdf）
         //1.摘要附图
         patentImageLock.lock();
         patentImageCondition.signalAll();
@@ -311,6 +606,11 @@ public class PantentQueueService {
         patentInstructionTextLock.lock();
         patentInstructionTextCondition.signalAll();
         patentInstructionTextLock.unlock();
+        //5.说明书pdf
+        patentInstructionPDFLock.lock();
+        patentInstructionPDFCondition.signalAll();
+        patentInstructionPDFLock.unlock();
+
     }
 
     /**
@@ -346,7 +646,7 @@ public class PantentQueueService {
     }
 
     /**
-     * 唤醒生产者线程执
+     * 唤醒生产者线程
      */
     public void awakeTasktch() {
         taskLock.lock();
@@ -356,7 +656,7 @@ public class PantentQueueService {
     }
 
     /**
-     * 工厂方法，根据任务类型创建对应的获取专利数据的对象
+     * 工厂方法，根据任务类型返回对应的生产专利数据的对象
      *
      * @param task 任务
      * @return 返回获取专利数据的对象

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

@@ -3,11 +3,9 @@ package cn.cslg.pas.service.upLoadPatent;
 import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.domain.Patent;
 import cn.cslg.pas.domain.SystemDict;
-import cn.cslg.pas.service.PatentAgencyService;
-import cn.cslg.pas.service.PatentImageService;
-import cn.cslg.pas.service.SystemDictService;
-import cn.cslg.pas.service.UploadPatentBatchService;
+import cn.cslg.pas.service.*;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -28,17 +26,36 @@ public class UploadPatentToDBService {
     private final PatentAgencyService patentAgencyService;
     private final UploadPatentBatchService uploadPatentBatchService;
     private final PatentImageService patentImageService;
+    private final PatentService patentService;
 
     /**
-     * 摘要附图
+     * 摘要附图入库（Excel方式）
      *
      * @param uploadParamsVO 专利内容
      */
     public void uploadPatentImage(UploadParamsVO uploadParamsVO) throws IOException {
         //摘要附图数据装配及入库（摘要附图表"os_patent_img"）
         if (uploadParamsVO.getPatent() != null) {
-            if (uploadParamsVO.getPatent().getId() != null && uploadParamsVO.getPictureData() != null) {
+            if (uploadParamsVO.getPatent().getId() != null) {
                 uploadParamsVO.getPatent().setAbstractPath(patentImageService.updatePatentImage(uploadParamsVO.getPatent().getId(), uploadParamsVO.getPictureData()));
+                //专利表"os_patent"更新数据（更新摘要附图路径）
+                patentService.updateById(uploadParamsVO.getPatent());
+            }
+        }
+    }
+
+    /**
+     * 摘要附图入库（网站导入方式）
+     *
+     * @param uploadParamsVO 专利内容
+     */
+    public void uploadPatentImage2(UploadParamsVO uploadParamsVO) throws IOException {
+        //摘要附图数据装配及入库（摘要附图表"os_patent_img"）
+        if (uploadParamsVO.getPatent() != null) {
+            if (uploadParamsVO.getPatent().getId() != null && uploadParamsVO.getFileDTO() != null) {
+                uploadParamsVO.getPatent().setAbstractPath(patentImageService.updatePatentImage2(uploadParamsVO));
+                //专利表"os_patent"更新数据（更新摘要附图路径）
+                patentService.updateById(uploadParamsVO.getPatent());
             }
         }
     }
@@ -64,6 +81,11 @@ public class UploadPatentToDBService {
         if (uploadParamsVO.getPatent() != null) {
             if (uploadParamsVO.getPatent().getAgencyId() != null) {
                 uploadParamsVO.getPatent().setAgencyId(patentAgencyService.getAgencyStringIdByName(uploadParamsVO.getPatent().getAgencyId()));
+                //修改专利表（"os_patent"）agencyid数据
+                Patent patent = new Patent();
+                patent.setId(uploadParamsVO.getPatent().getId());
+                patent.setAgencyId(uploadParamsVO.getPatent().getAgencyId());
+                patentService.updateById(patent);
             }
         }
 

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

@@ -142,8 +142,9 @@ public class UploadTaskService {
                 .setDBType("cN");
         Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
         if (resultMap == null || (Integer) resultMap.get("total") == 0) {
-            ThrowException.throwXiaoShiException("根据检索信息未检索到相关专利，请尝试更换检索信息");
+            ThrowException.throwXiaoShiException("根据该检索信息未检索到相关专利，请尝试更改检索式");
         }
+
         //专利总数量
         Integer total = (Integer) resultMap.get("total");