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

# Conflicts:
#	PAS/src/main/java/cn/cslg/pas/service/ScratchWordsService.java

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

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

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

@@ -31,72 +31,57 @@ public class CreateTaskThread implements InitializingBean {
 
     @Override
     public void afterPropertiesSet() throws Exception {
-        //初始化任务列表数据（taskQueueList)
+        //初始化任务队列
         //查找任务状态为0（队列中）和1（进行中）的任务
         List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().in(Task::getStatus, new ArrayList<>(Arrays.asList(0, 1))));
         if (tasks.size() > 0) {
+            //过滤出任务ids
             List<Integer> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());
-            //将任务ids存入 taskQueueList
-            pantentQueueService.queueAddTask(taskIds);
+            //过滤出进行中的任务的id
+            List<Task> doingTasks = tasks.stream().filter(item -> item.getStatus() == 1).collect(Collectors.toList());
+            List<Integer> doingTaskIds = doingTasks.stream().map(Task::getId).collect(Collectors.toList());
+            if (doingTaskIds.size() > 0) {
+                //先将进行中的任务（项目重启后进行中的任务仅会有1个）的id先存入任务队列，再将其余存入
+                pantentQueueService.taskQueueAddTask(Arrays.asList(doingTaskIds.get(0)));
+                taskIds.removeAll(doingTaskIds);
+            }
+            pantentQueueService.taskQueueAddTask(taskIds);
         }
 
         //生产者线程
         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(() -> {
-            try {
-                pantentQueueService.pushPatentImageToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        Thread threadConsumer1 = new Thread(pantentQueueService::pushPatentImageToDB);
         threadConsumer1.start();
-
-
         //消费者2线程（著录项目）
-        Thread threadConsumer2 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentZhuLuToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        Thread threadConsumer2 = new Thread(pantentQueueService::pushPatentZhuLuToDB);
         threadConsumer2.start();
-
-
         //消费者3线程（权利要求）
-        Thread threadConsumer3 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentRightToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        Thread threadConsumer3 = new Thread(pantentQueueService::pushPatentRightToDB);
         threadConsumer3.start();
-
-
         //消费者4线程（说明书文本消费者）
-        Thread threadConsumer4 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentInstructionTextToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        Thread threadConsumer4 = new Thread(pantentQueueService::pushPatentInstructionTextToDB);
         threadConsumer4.start();
-
-
-        //消费者5线程（与专利关联数据消费者）
-        Thread threadConsumer5 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentAssoToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费者5线程（说明书pdf消费者）
+        Thread threadConsumer5 = new Thread(pantentQueueService::pushPatentInstructionPDFToDB);
         threadConsumer5.start();
 
     }

PAS/src/main/java/cn/cslg/pas/common/model/PatentCell.java

@@ -30,7 +30,14 @@ public class PatentCell {
     private String legal;
     private String url;
     private String abstrc;
+    /**
+     * 附图路径
+     */
     private String picUrl;
+    /**
+     * 附图文件名称
+     */
+    private String fileName;
     /*
     申请号
      */

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

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

PAS/src/main/java/cn/cslg/pas/common/model/dto/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 extends PageDTO2 implements Serializable {
+    /**
+     * 获取专利项（1.权要 2.说明书文本 3.说明书pdf 4.摘要附图 5.同族专利）
+     */
+    private Integer patentCell;
+    /**
+     * 公开号
+     */
+    private String patentNo;
+    /**
+     * 申请号
+     */
+    private String appNo;
+
+}

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

@@ -29,6 +29,10 @@ public class PatentDTO {
     private List<PatentRight> rights;
     private PatentInstructionText instruction;
     private List<String> priorityCountry;
+    /**
+     * 结果集（专利之星检索接口返回同族专利的接口使用）
+     */
+    private Object familyPatentResult;
 
     @Data
     public static class PatentFamily {

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

@@ -1,5 +1,7 @@
 package cn.cslg.pas.common.model.dto;
 
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
@@ -15,23 +17,59 @@ import java.util.List;
 @Data
 public class QrtzTaskAddNewDTO {
     /**
+     * 检索信息
+     */
+    private String conditions;
+    /**
+     * 排序字段：“AD”，“PD”，“GD”，“ID”
+     */
+    private String orderBy;
+    /**
+     * 排序方式：“ASC”，“DESC”
+     */
+    private String orderByType;
+    /**
+     * 需要检索的数据库类型（"CN"/"WD"）
+     */
+    private String DBType;
+    /**
+     * 下载起始条数位置（如2表示从第二个专利开始下载）
+     */
+    private Integer startNumber;
+    /**
+     * 下载终止条数位置（如13表示从第十三个专利开始下载）
+     */
+    private Integer endNumber;
+    /**
+     * 需要额外下载的专利
+     */
+    private List<String> isAddPatentNos;
+    /**
+     * 起止条数中不需要下载的专利
+     */
+    private List<String> isDeletePatentNos;
+    /**
      * 专题库id
      */
     private Integer projectId;
     /**
-     * 任务类型(0普通任务 1定时任务)
+     * 报告id
      */
-    private Integer taskType;
+    private Integer reportId;
     /**
-     * 检索信息
+     * 任务类型2（3.欧专局 4.专利之星）
      */
-    private String conditions;
+    private Integer taskType2;
+    /**
+     * 任务类型1 (0普通任务 1定时任务)
+     */
+    private Integer taskType;
     /**
      * cron表达式
      */
     private String crons;
     /**
-     * 下载字段
+     * 下载字段（1.著录项 2.权要 3.说明书文本 4.说明书pdf 6.摘要附图）
      */
     private List<String> configCells;
     /**
@@ -43,4 +81,59 @@ public class QrtzTaskAddNewDTO {
      */
     private String taskName;
 
+
+    //以下为自定义字段和文件夹信息 ↓
+    /**
+     * 自定义字段ids
+     */
+    private List<ProjectImportPatentVO.Field> fieldList;
+    /**
+     * 文件夹ids
+     */
+    private List<Integer> folderIds;
+
+    /**
+     * 自定义字段信息
+     */
+    @Data
+    public static class Field {
+        /**
+         * 自定义字段id
+         */
+        private Integer fieldId;
+        /**
+         * 自定义字段类型（6为树）
+         */
+        private Integer type;
+        /**
+         * 选项id
+         */
+        private Integer optionId;
+        private String text;
+    }
+
+    /**
+     * 文件夹信息
+     */
+    @Data
+    public static class Folder {
+        /**
+         * 文件夹id
+         */
+        private Integer id;
+        /**
+         * 上级文件夹id
+         */
+        private Integer parentId;
+        /**
+         * 文件夹名称
+         */
+        private String name;
+        private Boolean selected;
+        /**
+         * 子级文件夹们
+         */
+        private List<ProjectImportPatentVO.Folder> children;
+    }
+
 }

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

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

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

@@ -1,22 +1,52 @@
 package cn.cslg.pas.common.model.outApi;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
 import lombok.experimental.Accessors;
+import reactor.util.annotation.NonNull;
+
+import javax.validation.constraints.NotNull;
 
 /**
  * 专利之星检索dto类
  *
  * @author 李仁杰
  */
+
 @Accessors(chain = true)
 @Data
 public class PatentStarListDto {
     /**
      * 检索式
      */
-    String CurrentQuery;
-    String DBType;
-    int PageNum;
-    int RowCount;
+    @JsonProperty(value = "CurrentQuery")
+    private String CurrentQuery;
+    /**
+     * 表示检索中文库或世界库（CN中文专利库 WD世界专利库）
+     */
+    @JsonProperty(value = "DBType")
+    private String DBType;
+    /**
+     * 当前页，最多 200 页
+     */
+    @JsonProperty(value = "PageNum")
+    private Integer PageNum;
+    /**
+     * 每页条数，最多 50 条
+     */
+    @JsonProperty(value = "RowCount")
+    private Integer RowCount;
+    /**
+     * 排序字段：“AD”，“PD”，“GD”, “ID”
+     */
+    @JsonProperty(value = "OrderBy")
+    private String OrderBy;
+    /**
+     * 排序方式：“ASC”，“DESC”
+     */
+    @JsonProperty(value = "OrderByType")
+    private String OrderByType;
+
+
 
 }

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

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

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

@@ -0,0 +1,35 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 装载并返回分页信息的类
+ *
+ * @Author chenyu
+ * @Date 2023/7/4
+ */
+@Accessors(chain = true)
+@Data
+public class PageVO implements Serializable {
+    /**
+     * 当前页
+     */
+    private Integer current;
+    /**
+     * 每页条数
+     */
+    private Integer size;
+    /**
+     * 总条数
+     */
+    private Integer total;
+    /**
+     * 结果集
+     */
+    private Object records;
+
+}

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

@@ -16,6 +16,10 @@ public class ProjectImportPatentVO {
      */
     private Integer projectId;
     /**
+     * 报告id
+     */
+    private Integer reportId;
+    /**
      * 数据来源（1.智慧芽 2.合享 3.Patentics）
      */
     private String sourceId;

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

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

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

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

PAS/src/main/java/cn/cslg/pas/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

@@ -0,0 +1,103 @@
+package cn.cslg.pas.common.model.vo.outApi;
+
+import cn.cslg.pas.domain.PatentAgency;
+import cn.cslg.pas.domain.PatentAgent;
+import cn.cslg.pas.domain.PatentApplicant;
+import cn.cslg.pas.domain.PatentInventor;
+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 implements Serializable {
+    /**
+     * 专利号
+     */
+    @JSONField(name = "PN")
+    private String patentNo;
+
+    /**
+     * 公告号
+     */
+    @JSONField(name = "GN")
+    private String announceNo;
+    /**
+     * 摘要
+     */
+    @JSONField(name = "AB")
+    private String abstractStr;
+    /**
+     * 申请号
+     */
+    @JSONField(name = "AN")
+    private String applicationNo;
+    /**
+     * 标题
+     */
+    @JSONField(name = "TI")
+    private String name;
+    /**
+     * 申请日
+     */
+    @JSONField(name = "AD")
+    private String applicationDate;
+    /**
+     * 申请人
+     */
+    @JSONField(name = "PA")
+    private String applicantStr;
+    /**
+     * IPC分类号
+     */
+    @JSONField(name = "IC")
+    private String ipcListStr;
+    /**
+     * 公开日
+     */
+    @JSONField(name = "PD")
+    private String publicDate;
+    /**
+     * 公开号
+     */
+    @JSONField(name = "PN")
+    private String publicNo;
+    /**
+     * 发明人
+     */
+    @JSONField(name = "IN")
+    private String inventorStr;
+    private List<PatentInventor> inventor;
+    /**
+     * 权利人
+     */
+    @JSONField(name = "PE")
+    private String currentApplicantStr;
+    /**
+     * 代理机构
+     */
+    @JSONField(name = "AGN")
+    private String agencyStr;
+    /**
+     * 代理人
+     */
+    @JSONField(name = "AT")
+    private String agentStr;
+    /**
+     * 法律状态
+     */
+    @JSONField(name = "LG")
+    private Integer LG;
+    private List<String> ipcList;
+    private List<PatentApplicant> applicant;
+    private PatentAgency agency;
+    private List<PatentAgent> agent;
+    private String simpleStatus;
+    /**
+     * 摘要附图路径
+     */
+    private String abstractPath;
+}

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

@@ -123,18 +123,18 @@ public class CacheUtils {
         return uuid;
     }
 
-    public void deleteUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId) {
-        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId);
+    public void deleteUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId,Integer createId) {
+        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId+createId);
         redisUtil.delete(RedisConf.USER_FIELD + RedisConf.SYMBOL_COLON + key);
     }
 
-    public void setUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId, List<PatentField> defaultField) {
-        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId);
+    public void setUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId, List<PatentField> defaultField,Integer createId) {
+        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId+createId);
         redisUtil.set(RedisConf.USER_FIELD + RedisConf.SYMBOL_COLON + key, JsonUtils.objectToJson(defaultField));
     }
 
-    public List<PatentField> getUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId) {
-        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId);
+    public List<PatentField> getUserSystemFieldSetting(Integer projectId, String type, String view, Integer userId,Integer createId) {
+        String key = SecureUtil.md5(projectId + RedisConf.SYMBOL_COLON + type + RedisConf.SYMBOL_COLON + view + RedisConf.SYMBOL_COLON + userId+createId);
         String json = redisUtil.get(RedisConf.USER_FIELD + RedisConf.SYMBOL_COLON + key);
         if (StringUtils.isNotEmpty(json)) {
             return JsonUtils.jsonToList(json, PatentField.class);

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/FileUtils.java

@@ -149,7 +149,35 @@ public class FileUtils {
         }
         return last.toString();
     }
+    public String analysisJsonFile(String fileName) {
+        ApplicationHome ah = new ApplicationHome(BackupUtils.class);
+        File file = ah.getSource();
+        String settingFilePath = file.getParentFile().toString() + FileUtils.FILE_SEPARATOR + "uploadSetting.json";
+        BufferedReader reader = null;
+        StringBuilder last = new StringBuilder();
+        InputStreamReader inputStreamReader;
+        try (FileInputStream fileInputStream = new FileInputStream(settingFilePath)) {
+            inputStreamReader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
 
+            reader = new BufferedReader(inputStreamReader);
+            String tempString;
+            while ((tempString = reader.readLine()) != null) {
+                last.append(tempString);
+            }
+            reader.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return last.toString();
+    }
 
     public static MultipartFile fileToMultipartFile(File file) {
         DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory(16, null);

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

@@ -1,7 +1,36 @@
 package cn.cslg.pas.common.utils;
 
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
 public class FormatUtil {
     public static String toString(Object o) {
         return o == null ? "" : o.toString();
     }
+
+    public static String MD5(String src) {
+        // 需要加密的字符串
+        try {
+            // 加密对象，指定加密方式
+            MessageDigest md5 = MessageDigest.getInstance("md5");
+            // 准备要加密的数据
+            byte[] b = src.getBytes();
+            // 加密
+            byte[] digest = md5.digest(b);
+            // 十六进制的字符
+            char[] chars = new char[]{'0', '1', '2', '3', '4', '5',
+                    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+            StringBuffer sb = new StringBuffer();
+            // 处理成十六进制的字符串(通常)
+            for (byte bb : digest) {
+                sb.append(chars[(bb >> 4) & 15]);
+                sb.append(chars[bb & 15]);
+            }
+            return sb.toString();
+        } catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+
 }

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/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,41 @@
+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.*;
+
+import java.io.IOException;
+
+/**
+ * 获取专利之星专利某部分（如权要、说明书等一项）控制层
+ *
+ * @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 = "根据专利号或申请号获取专利指定部分项")
+    @PostMapping("/getPatentPart")
+    public String getPatentPart(@RequestBody GetPatentStarPartDTO getPatentStarPartDTO) throws IOException {
+        log.info("开始处理【根据专利号或申请号获取专利指定部分项】的请求，请求参数为：{}", getPatentStarPartDTO);
+
+        PatentDTO patentPart = getPatentStarPartService.getPatentPart(getPatentStarPartDTO);
+        return Response.success(patentPart);
+
+    }
+
+}

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

@@ -87,17 +87,20 @@ public class PatentController {
         PatentDTO patentDTO =patentService.getPatentDTOById(patentNo,projectId);
         return Response.success(patentDTO);
     }
+
     @GetMapping("id")
     @Operation(summary = "根据专利号获取专利")
     public String getPatentByPatentNo(String patentNo) {
         Patent patent = patentService.getByPatentNo(patentNo);
         return Response.success(patent);
     }
+
     @PostMapping("ids")
     @Operation(summary = "根据范围获取专利ID")
     public String getPatentListIds(@RequestBody PatentVO params) {
         return Response.success(patentService.getPatentListIds(params));
     }
+
     @checkAuth(FunId = "/workspace/folder/exportPatent")
     @PostMapping("export")
     @Operation(summary = "导出专利")
@@ -130,6 +133,7 @@ public class PatentController {
         return Response.success(patentService.getPatentQuerySourcePageList(params));
     }
 
+
     @PostMapping("/save/select")
     @Operation(summary = "保存选择的专利")
     public String saveSelectPatentIds(@RequestBody PatentVO params) {
@@ -138,7 +142,7 @@ public class PatentController {
     }
 
     @checkAuth(FunId = "/workspace/folder/batchOperation/batchIndexing")
-    @Permission(roles = {2})
+    @Permission(roles = {1,2})
     @PostMapping("/batch/index")
     @Operation(summary = "批量批量专利标引")
     public String patentBatchIndex(@RequestBody PatentBatchIndexVO params) {
@@ -159,7 +163,7 @@ public class PatentController {
     }
 
     @checkAuth(FunId = "/workspace/details/indexing")
-    @Permission(roles = {2})
+    @Permission(roles = {1,2})
     @PostMapping("/index/setting")
     @Operation(summary = "修改专利标引")
     public String updatePatentIndexSetting(@RequestBody PatentIndexSettingVO params) {

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

@@ -27,7 +27,6 @@ import org.springframework.web.bind.annotation.*;
 @RestController
 public class ProductMarketDataController {
     private final IProductMarketDataService productMarketDataService;
-
     @Operation(summary = "新增产品营销数据")
     @PostMapping("/addNew")
     public String addNew(@RequestBody ProductMarketDataAddNewDTO productMarketDataAddNewDTO) {
@@ -40,6 +39,7 @@ public class ProductMarketDataController {
         return Response.success("新增产品营销数据完成");
     }
 
+
     @Operation(summary = "修改产品营销数据")
     @PostMapping("/update")
     public String update(@RequestBody ProductMarketDataUpdateDTO productMarketDataUpdateDTO) {
@@ -52,6 +52,7 @@ public class ProductMarketDataController {
         return Response.success("修改产品营销数据完成");
     }
 
+
     @Operation(summary = "分页查询产品营销数据")
     @PostMapping("/query")
     public String update(@RequestBody ProductMarketDataQueryPageDTO productMarketDataQueryPageDTO) {
@@ -60,6 +61,7 @@ public class ProductMarketDataController {
         return Response.success(jsonPage);
     }
 
+
     @Operation(summary = "删除产品营销数据")
     @GetMapping("/delete")
     public String delete(Integer id) {

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

@@ -88,6 +88,7 @@ public class ProjectController {
         return projectService.delete(id);
     }
 
+
     @checkAuth(FunId = "/workspace/project/delete")
     @PostMapping("/patent/delete")
     @Operation(summary = "删除专题库专利")

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/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/TaskController.java

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

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

@@ -0,0 +1,97 @@
+package cn.cslg.pas.controller.outApi;
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.outApi.PatentStarListDto;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.service.OAuth2Service;
+import cn.cslg.pas.service.outApi.PatentStarApiService;
+import cn.dev33.satoken.stp.StpUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Map;
+
+@Tag(name = "专利之星接口服务类")
+@RestController
+@RequestMapping(Constants.API_VERSION_V2 + "/patentStar")
+@RequiredArgsConstructor(onConstructor_ = {@Lazy})
+public class PatentStarController {
+    private final PatentStarApiService patentStarApiService;
+
+    @PostMapping("/select")
+    @Operation(summary = "一般检索接口")
+    public String getAreaList(@RequestBody @Validated PatentStarListDto patentStarListDto) throws IOException {
+          Map<String,Object> map =  patentStarApiService.patentStarSearchApi(patentStarListDto);
+        if(map==null){
+            return Response.error("检索失败,请检查检索式");
+        }
+        return Response.success(map);
+    }
+
+    @GetMapping("/getCnBib")
+    @Operation(summary = "获得中国专利著录")
+    public String getCnBib(String appNo) {
+        return patentStarApiService.getCnBibApi(appNo);
+    }
+
+    @GetMapping("/getPicture")
+    @Operation(summary = "获得中国专利摘要附图")
+    public String getPicture(String appNo) {
+        return patentStarApiService.getPictureApi(appNo);
+    }
+
+    @GetMapping("/getWGPicture")
+    @Operation(summary = "获得中国专利外观图")
+    public String getWGPicture(String appNo) throws IOException {
+        return patentStarApiService.getWGPictureApi(appNo);
+    }
+
+    @GetMapping("/getCnLegal")
+    @Operation(summary = "获得中国专利法律状态")
+    public String getCnLegal(String appNo) {
+        return patentStarApiService.getCnLegalApi(appNo);
+    }
+
+    @GetMapping("/getCnPdf")
+    @Operation(summary = "获得中国专利pdf全文")
+    public String getCnPdf(String appNo) throws IOException {
+        return patentStarApiService.getCnPdfApi(appNo);
+    }
+
+    @GetMapping("/getCnFullXml")
+    @Operation(summary = "获得中国专利全文文本")
+    public String getCnFullXml(String appNo) throws IOException {
+        return patentStarApiService.getCnFullXmlApi(appNo);
+    }
+
+    @GetMapping("/getEnPdf")
+    @Operation(summary = "获得世界专利pdf")
+    public String getEnPdf(String patentNo) throws IOException {
+        return patentStarApiService.getEnPdfApi(patentNo);
+    }
+
+    @GetMapping("/getENBib")
+    @Operation(summary = "获得世界专利著录信息")
+    public String getENBib(String patentNo) throws IOException {
+        return Response.success(patentStarApiService.getENBibApi(patentNo));
+    }
+
+    @GetMapping("/getFamilyByPubNo")
+    @Operation(summary = "获得同族专利")
+    public String getFamilyByPubNo(String patentNo) {
+        return patentStarApiService.getFamilyByPubNoApi(patentNo);
+    }
+
+    @GetMapping("/getCitedNumByPubNo")
+    @Operation(summary = "获得被引用次数")
+    public String getCitedNumByPubNo(String patentNo) throws IOException {
+        return patentStarApiService.getCitedNumByPubNoApi(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/ChinaPatentZhuLu.java

@@ -0,0 +1,99 @@
+package cn.cslg.pas.domain;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 专利之星中国专利著录实体类
+ *
+ * @Author chenyu
+ * @Date 2023/6/25
+ */
+@Accessors(chain = true)
+@Data
+public class ChinaPatentZhuLu implements Serializable {
+    /**
+     * 申请号
+     */
+    private String AN;
+    /**
+     * 申请日
+     */
+    private String AD;
+    private String CPT;
+    /**
+     * 公开日
+     */
+    private String PD;
+    private String CGT;
+    /**
+     * 公告日
+     */
+    private String GD;
+    private String ZLTP;
+    /**
+     * 标题
+     */
+    private String TI;
+    /**
+     * 国省代码
+     */
+    private String CO;
+    private String MingCheng;
+    /**
+     * 代理人
+     */
+    private String AT;
+    /**
+     * 代理机构代码
+     */
+    private String AG;
+    /**
+     * 代理机构名称
+     */
+    private String AGN;
+    /**
+     * 主分类号
+     */
+    private String MC;
+    /**
+     * 分类号
+     */
+    private String IC;
+    /**
+     * 范畴分类
+     */
+    private String CT;
+    /**
+     * 申请人
+     */
+    private String PA;
+    /**
+     * 发明人
+     */
+    private String IV;
+    /**
+     * 申请人地址
+     */
+    private String DZ;
+    private String ZipCode;
+    /**
+     * 优先权号
+     */
+    private String PR;
+    private String PRD;
+    private String Examiner;
+    private String CiteInfo;
+    private String NoCiteInfo;
+    /**
+     * 摘要
+     */
+    private String AB;
+    /**
+     * 主权要
+     */
+    private String CL1;
+
+}

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/Patent.java

@@ -151,7 +151,7 @@ public class Patent extends BaseEntity<Patent> {
     private Integer selfRightNum;
 
     /**
-     * 权利要求
+     * 权利要求原文
      */
     @TableField("content")
     private String rightContent;

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

@@ -17,12 +17,12 @@ import java.io.Serializable;
 @Data
 public class QueueData implements Serializable {
     /**
-     * 专利实体类
+     * 任务
      */
-    private UploadParamsVO uploadParamsVO;
+    private Task task;
     /**
-     * 前台参数实体类
+     * 专利实体类
      */
-    private ProjectImportPatentVO projectImportPatentVO;
+    private UploadParamsVO uploadParamsVO;
 
 }

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

@@ -6,6 +6,8 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
+import java.util.List;
+
 /**
  * <p>
  * 任务表
@@ -20,7 +22,7 @@ import lombok.experimental.Accessors;
 public class Task extends BaseEntity<Task> {
 
     /**
-     * 任务类型 1上传 2导出 3网站导入
+     * 任务类型 1.Excel导入专利任务 2.导出 3.Epo欧专局导入 4.专利之星导入
      */
     @TableField("type")
     private Integer type;
@@ -38,10 +40,15 @@ public class Task extends BaseEntity<Task> {
     private Integer startTime;
 
     /**
-     * 专题库
+     * 专题库id
      */
     @TableField("tid")
     private Integer projectId;
+    /**
+     * 报告id
+     */
+    @TableField("rid")
+    private Integer reportId;
 
     /**
      * 导入导出字段数量
@@ -62,7 +69,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,7 +96,12 @@ public class Task extends BaseEntity<Task> {
     @TableField("default_num")
     private Integer defaultNum;
     /**
-     * 前台参数json格式
+     * 生产过程中出错抛异常的专利数量
+     */
+    @TableField(exist = false)
+    private int exceptionNum;
+    /**
+     * 自定义字段文件夹信息json格式
      */
     @TableField("pram_json")
     private String pramJson;
@@ -106,10 +118,15 @@ public class Task extends BaseEntity<Task> {
      */
     @TableField("old_name")
     private String oldName;
+    /**
+     * 所属任务条件id
+     */
+    @TableField("qrtz_task_id")
+    private Integer qrtzTaskId;
+
 
     @TableField(exist = false)
     private String createName;
-
     @TableField(exist = false)
     private String projectName;
     /**
@@ -117,5 +134,55 @@ public class Task extends BaseEntity<Task> {
      */
     @TableField(exist = false)
     private Integer lastIndex;
+    /**
+     * 下载字段类型数量
+     */
+    @TableField(exist = false)
+    private Integer configCellsNum;
+    /**
+     * 下载字段
+     */
+    @TableField(exist = false)
+    private List<String> configCells;
+    /**
+     * 排序字段
+     */
+    @TableField(exist = false)
+    private String orderBy;
+    /**
+     * 排序类型
+     */
+    @TableField(exist = false)
+    private String orderByType;
+    /**
+     * 检索数据库类型
+     */
+    @TableField(exist = false)
+    private String DBType;
+    /**
+     * 下载起始条数位置
+     */
+    @TableField(exist = false)
+    private Integer startNumber;
+    /**
+     * 下载终止条数位置
+     */
+    @TableField(exist = false)
+    private Integer endNumber;
+    /**
+     * 需要额外下载的专利
+     */
+    @TableField(exist = false)
+    private List<String> isAddPatentNos;
+    /**
+     * 起止条数中不需要下载的专利
+     */
+    @TableField(exist = false)
+    private List<String> isDeletePatentNos;
+    /**
+     * 检索式
+     */
+    @TableField(exist = false)
+    private String conditions;
 
 }

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

@@ -0,0 +1,39 @@
+package cn.cslg.pas.domain;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 网站配置
+ * @TableName web_config
+ */
+@Data
+@TableName(value ="web_login_config")
+public class WebLoginConfig implements Serializable {
+    /**
+     * ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+    @TableField(value = "login_account")
+    private String loginAccount;
+
+    @TableField(value = "login_password")
+    private String loginPassword;
+
+    /**
+     * 账号
+     */
+    @TableField(value = "tenant_id")
+    private Integer tenantId;
+
+    @TableField(value = "web_Id")
+    private Integer webId;
+
+
+}

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

@@ -31,12 +31,17 @@ public class AssoOsTaskQrtzTask implements Serializable {
     @TableField(value = "task_id")
     private Integer taskId;
     /**
-     * 任务类型(0普通任务 1定时任务)
+     * 任务类型1 (0普通任务 1定时任务)
      */
     @TableField(value = "task_type")
     private Integer taskType;
     /**
-     * 检索信息
+     * 任务类型2（3.EPO欧专局导入 4.专利之星导入）
+     */
+    @TableField(value = "task_type2")
+    private Integer taskType2;
+    /**
+     * 检索式
      */
     @TableField(value = "conditions")
     private String conditions;
@@ -60,5 +65,46 @@ public class AssoOsTaskQrtzTask implements Serializable {
      */
     @TableField(value = "task_name")
     private String taskName;
+    /**
+     * 专利总数量
+     */
+    @TableField(value = "total")
+    private Integer total;
+
+    /**
+     * 排序字段
+     */
+    @TableField(value = "orderby")
+    private String orderBy;
+    /**
+     * 排序类型
+     */
+    @TableField(value = "orderby_type")
+    private String orderByType;
+    /**
+     * 检索数据库类型
+     */
+    @TableField(value = "db_type")
+    private String DBType;
+    /**
+     * 下载起始条数位置
+     */
+    @TableField(value = "start_number")
+    private Integer startNumber;
+    /**
+     * 下载终止条数位置
+     */
+    @TableField(value = "end_number")
+    private Integer endNumber;
+    /**
+     * 需要额外下载的专利
+     */
+    @TableField(value = "isadd_patentnos")
+    private List<String> isAddPatentNos;
+    /**
+     * 起止条数中不需要下载的专利
+     */
+    @TableField(value = "isdelete_patentnos")
+    private List<String> isDeletePatentNos;
 
 }

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

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

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

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

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

@@ -37,6 +37,8 @@ public class OutInterfaceService {
     private String OPSUrl;
     @Value("${PASUrl}")
     private String PASUrl;
+    @Value("${RMSUrl}")
+    private String RMSUrl;
 
     /**
      * 根据人员名称模糊查询人员ids
@@ -60,7 +62,6 @@ public class OutInterfaceService {
      * @return 返回装载着人员列表数据的data的String
      */
     public String getPersonnelByIdsFromPCS(List<Integer> ids) throws IOException {
-
         String param = new Gson().toJson(ids);
         RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
         OkHttpClient okHttpClient = new OkHttpClient.Builder()
@@ -198,4 +199,17 @@ public class OutInterfaceService {
         return Objects.requireNonNull(httpClient.newCall(request).execute().body()).string();
     }
 
+    public String importAssoReportPatentNo(Integer reportId, String patentNo,String name) throws IOException {
+        OkHttpClient httpClient = new OkHttpClient.Builder()
+                .pingInterval(400, TimeUnit.SECONDS) // 设置 PING 帧发送间隔
+                .connectTimeout(300, TimeUnit.SECONDS)//设置连接超时时间
+                .readTimeout(300, TimeUnit.SECONDS)//设置读取超时时间
+                .build();
+        Request request = new Request.Builder()
+                .url(RMSUrl + "/api/report/api/compare/addSingle?reportId=" + reportId + "&patentNo=" + patentNo+"&name="+name)
+                .get()
+                .build();
+        return Objects.requireNonNull(httpClient.newCall(request).execute().body()).string();
+    }
+
 }

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/PatentFieldService.java

@@ -1,6 +1,7 @@
 package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
 import cn.cslg.pas.domain.PatentField;
 import cn.cslg.pas.domain.ProjectField;
 import cn.cslg.pas.common.core.base.Constants;
@@ -36,7 +37,7 @@ public class PatentFieldService {
     private final List<String> finalDefaultList = Arrays.asList("name", "ipcList", "applicationNo", "applicationDate", "applicant2", "applicant4");
     private final List<String> finalDefaultQuery = Arrays.asList("13", "18-6", "19-6", "25-12");
     private final List<String> finalProjectField = Arrays.asList("clientName", "scenarioid", "typeid", "technicalTheme");
-
+    private final LoginUtils loginUtils;
     public List<PatentField> getUserFieldDataList(Integer projectId, String from) {
         List<PatentField> patentFieldList = this.getList(from);
         List<ProjectField> projectField = projectFieldService.getProjectFieldByProjectId(projectId);
@@ -55,11 +56,12 @@ public class PatentFieldService {
 
 
     public List<PatentField> getUserSetting(SystemFieldVO params) {
+        Integer createId =loginUtils.getId();
         if (params.getRefresh() != null && params.getRefresh()) {
-            cacheUtils.deleteUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3);
+            cacheUtils.deleteUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3,createId);
         }
         List<PatentField> dataList = this.getUserFieldDataList(params.getProjectId(), params.getType());
-        List<PatentField> userSetting = cacheUtils.getUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3);
+        List<PatentField> userSetting = cacheUtils.getUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3,createId);
         if (userSetting == null || userSetting.size() == 0) {
             List<PatentField> defaultList = new ArrayList<>();
             List<PatentField> patentFieldList = this.getList(params.getType());
@@ -74,7 +76,7 @@ public class PatentFieldService {
                     defaultList = patentFieldList.stream().filter(item -> finalProjectField.contains(item.getKey())).collect(Collectors.toList());
                     break;
             }
-            cacheUtils.setUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3, defaultList);
+            cacheUtils.setUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3, defaultList,createId);
             userSetting = defaultList;
         }
         List<PatentField> finalUserSetting = userSetting;
@@ -92,7 +94,8 @@ public class PatentFieldService {
             patentFieldList.get(i).setHidden(null);
             patentFieldList.get(i).setOrder(i);
         }
-        cacheUtils.setUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3, patentFieldList);
+        Integer createId =loginUtils.getId();
+        cacheUtils.setUserSystemFieldSetting(params.getProjectId(), params.getType(), params.getView(), 3, patentFieldList,createId);
         params.setRefresh(false);
         return this.getUserSetting(params);
     }

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,8 +438,6 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
             List<PatentRight> patentRights = PatentRightUtils.formatPatentRight(params);
 
             if (patentRights.size() > 0) {
-                //TODO 先根据专利id查询库中原权要，与当前权要比对，若不同则更新，若相同则不更新
-
                 //删除库表中原有该权要
                 this.deleteByPatentId(params.getPatentId());
                 //权要数据入表"os_patent_right"

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/PatentSimpleFamilyLinkService.java

@@ -41,11 +41,11 @@ public class PatentSimpleFamilyLinkService extends ServiceImpl<PatentSimpleFamil
         }
         queryWrapper.eq(PatentSimpleFamilyLink::getFamilyId, params.getFamilyId());
         IPage<PatentSimpleFamilyLink> pageList = this.page(new Page<>(params.getCurrent(), params.getSize()), queryWrapper);
-        //根据从关联信息里获得的专利号获得专利
+        //根据从关联信息里获得的专利号获得专利列表
         List<Patent> patentList = patentService.getPatentListByPatentNo(pageList.getRecords().stream().map(PatentSimpleFamilyLink::getPatentNo).collect(Collectors.toList()));
-        //根据专利号获得申请人信息
+        //根据专利ids获得申请人信息
         List<PatentApplicant> patentApplicantList = patentApplicantService.getPatentApplicantByPatentIds(patentList.stream().map(Patent::getId).collect(Collectors.toList()));
-         //遍历关联信息
+        //遍历关联信息
         pageList.getRecords().forEach(patentSimpleFamily -> {
             //根据专利号从专利列表中获得专利
             Patent patent = patentList.stream().filter(item -> item.getPatentNo().equals(patentSimpleFamily.getPatentNo())).findFirst().orElse(null);

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;
@@ -541,8 +544,15 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
         projectUserService.deleteByProjectId(id);
         projectFileService.deleteByProjectId(id);
         patentApplicantMergeLinkService.deleteByProjectId(id);
-        //陈宇 ↓ 删除专题库id关联产品id关联架构id(asso_structure_patent表)数据
+        //陈宇 ↓ 删除专题库产品架构标引表（asso_structure_patent）数据
         assoStructurePatentMapper.deleteByProjectId(id);
+        //陈宇 ↓ 删除任务表（os_task）数据
+        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/TaskService.java

@@ -1,30 +1,34 @@
 package cn.cslg.pas.service;
 
-import cn.cslg.pas.common.core.base.Constants;
-import cn.cslg.pas.common.model.dto.ClientDTO;
+
 import cn.cslg.pas.common.model.dto.QrtzTaskAddNewDTO;
-import cn.cslg.pas.common.model.vo.ProductVO;
+
 import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.ProjectVO;
 import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
-import cn.cslg.pas.domain.Project;
-import cn.cslg.pas.domain.SystemDict;
+
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.common.model.vo.TaskVO;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.mapper.TaskMapper;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
-import cn.dev33.satoken.stp.StpUtil;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataEpo;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataExcel;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
+import cn.cslg.pas.service.upLoadPatent.PantentQueueService;
+
 import cn.hutool.core.io.FileUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
-import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
@@ -52,6 +56,10 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     private final LoginUtils loginUtils;
     private final RequestService requestService;
     private final OutInterfaceService outInterfaceService;
+    private final PantentQueueService pantentQueueService;
+    private final ExcutePatentDataExcel excutePatentDataExcel;
+    private final ExcutePatentDataEpo excutePatentDataEpo;
+    private final ExcutePatentDataStar excutePatentDataStar;
 
     public String getFileUrl(Integer id) {
         Task task = this.getById(id);
@@ -111,12 +119,16 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         Task task = new Task();
 
         //任务开始时间
-        task.setStartTime(DateUtils.getDateTime());
+        //task.setStartTime(DateUtils.getDateTime());
         //任务状态（0.队列中 1.进行中 2.成功 3.失败）
         task.setStatus(0);
-        if (projectImportPatentVO.getProjectId() != null) {
+        //判断当前导入专利任务是与专题库关联还是与报告关联
+        if (projectImportPatentVO.getProjectId() != null && projectImportPatentVO.getReportId() == null) {
             //专题库id
             task.setProjectId(projectImportPatentVO.getProjectId());
+        } else if (projectImportPatentVO.getProjectId() == null && projectImportPatentVO.getReportId() != null) {
+            //报告id
+            task.setReportId(projectImportPatentVO.getReportId());
         }
         //文件名称
         task.setFileName(fileDTO.getFileName());
@@ -138,7 +150,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setSuccessNum(0);
         //失败条数
         task.setDefaultNum(0);
-        //前台参数json格式
+        //前台参数json格式（数据源配置、自定义字段、文件夹信息）
         task.setPramJson(json);
 
         //数据入任务表
@@ -152,20 +164,26 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
      * @param qrtzTaskAddNewDTO 前台参数
      * @return 返回任务id
      */
-    public Integer addTask3(QrtzTaskAddNewDTO qrtzTaskAddNewDTO, Integer total) {
+    public Integer addTask3(QrtzTaskAddNewDTO qrtzTaskAddNewDTO, Integer total, AssoOsTaskQrtzTask assoOsTaskQrtzTask) {
         //创建任务表实体类，准备装载数据 ↓
         Task task = new Task();
 
         //任务开始时间
-        task.setStartTime(DateUtils.getDateTime());
+        //task.setStartTime(DateUtils.getDateTime());
         //任务状态（0.队列中 1.进行中 2.成功 3.失败）
         task.setStatus(0);
-        //专题库id
-        task.setProductId(qrtzTaskAddNewDTO.getProjectId());
+        //判断当前导入专利任务是与专题库关联还是与报告关联
+        if (qrtzTaskAddNewDTO.getProjectId() != null && qrtzTaskAddNewDTO.getReportId() == null) {
+            //专题库id
+            task.setProjectId(qrtzTaskAddNewDTO.getProjectId());
+        } else if (qrtzTaskAddNewDTO.getProjectId() == null && qrtzTaskAddNewDTO.getReportId() != null) {
+            //报告id
+            task.setReportId(qrtzTaskAddNewDTO.getReportId());
+        }
         //专利总数量
         task.setTotal(total);
-        //任务类型 （1上传 2导出 3网站导入）
-        task.setType(3);
+        //任务类型 （1Excel导入 2导出 3欧专局导入 4专利之星导入）
+        task.setType(qrtzTaskAddNewDTO.getTaskType2());
         //导入导出字段数量
         task.setFieldNum(0);
         //创建人id
@@ -174,8 +192,16 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
         task.setSuccessNum(0);
         //失败条数
         task.setDefaultNum(0);
+        //所属任务条件id
+        task.setQrtzTaskId(assoOsTaskQrtzTask.getId());
+        //自定义字段和文件夹信息
+        ProjectImportPatentVO projectImportPatentVO = new ProjectImportPatentVO();
+        BeanUtils.copyProperties(qrtzTaskAddNewDTO, projectImportPatentVO);
+        String json = JSONObject.toJSONString(projectImportPatentVO);
+        task.setPramJson(json);
 
         //数据入任务表
+        log.info("任务表（os_task）新增数据");
         task.insert();
         return task.getId();
     }
@@ -293,24 +319,24 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public void pauseTask(Integer taskId) {
         log.info("开始处理【暂停任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试暂停的任务是否存在，若不存在则暂停失败，提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
+        //1.检查尝试暂停的任务是否存在，若不存在则提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试暂停的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已不存在，请尝试刷新页面");
             return;
         }
-        //2.检查尝试暂停的任务是否已处于暂停状态，若是则暂停失败，提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
+        //2.检查尝试暂停的任务是否已处于暂停状态，若是则提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
         if (task.getStatus().equals(4)) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已处于暂停状态，请尝试刷新页面");
         }
 
-        //3.检查尝试暂停的任务是否处于进行中状态，若不是则暂停失败，提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
+        //3.检查尝试暂停的任务是否处于进行中状态，若不是则提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
         if (!task.getStatus().equals(1)) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已结束或未开始，请尝试刷新页面");
         }
 
-        //4.暂停任务
+        //4.任务表将任务状态修改为4暂停
         Task updateTask = new Task();
         updateTask.setId(taskId);
         updateTask.setStatus(4);
@@ -320,6 +346,23 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             ThrowException.throwXiaoShiException("暂停失败，服务器忙请稍后再试");
         }
 
+        //5.将生产者生产专利中的公共任务状态改为暂停
+        if (task.getType() == 1) {
+            excutePatentDataExcel.setTaskStatus(taskId, 4);
+        } else if (task.getType() == 3) {
+            excutePatentDataEpo.setTaskStatus(taskId, 4);
+        } else if (task.getType() == 4) {
+            excutePatentDataStar.setTaskStatus(taskId, 4);
+        }
+
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            ThrowException.throwXiaoShiException("暂停失败，未知错误");
+        }
+        //6.将消费者的专利队列中所有该任务的专利剔除
+        pantentQueueService.consumerQueueDeleteTasks(taskId);
+
         log.info("暂停任务成功");
 
     }
@@ -333,7 +376,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public void continueTask(Integer taskId) {
         log.info("开始处理【继续任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试继续的任务是否存在，若不存在则继续失败，提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
+        //1.检查尝试继续的任务是否存在，若不存在则提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试继续的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
@@ -341,7 +384,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             return;
         }
 
-        //2.检查尝试继续的任务是否处于暂停状态，若不是则继续失败，提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
+        //2.检查尝试继续的任务是否处于暂停状态，若不是则提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
         if (!task.getStatus().equals(4)) {
             ThrowException.throwXiaoShiException("继续失败，当前任务未暂停，请尝试刷新页面");
         }
@@ -356,6 +399,12 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             ThrowException.throwXiaoShiException("继续失败，服务器忙请稍后再试");
         }
 
+        //4.将当前任务添加进生产者任务队列进行排队，并唤醒生产者线程
+        pantentQueueService.taskQueueAddTask(new ArrayList<>(Arrays.asList(taskId)));
+        //5.将生产者生产专利类中的公共任务状态改为暂停
+        excutePatentDataExcel.setTaskStatus(taskId, 0);
+        pantentQueueService.awakeTasktch();
+
         log.info("继续任务成功");
 
     }

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

@@ -253,7 +253,7 @@ public class UploadPatentBatchService {
 
             //保存专题库关联专利信息（表"os_thematic_pid"）
             if (uploadParamsVO.getPatent() != null) {
-                patentThematicPidBusiness(uploadParamsVO, projectImportPatentVO);
+                patentThematicPidBusiness(uploadParamsVO, projectImportPatentVO.getProjectId());
             }
 
             //保存标引内容关联专利信息（表"os_patent_field_patent_link"、"os_patent_field_text"）
@@ -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
@@ -563,8 +563,8 @@ public class UploadPatentBatchService {
         patentApplicantService.updatePatentApplicantAddress(patentApplicantAddressParams);
     }
 
-    public void patentThematicPidBusiness(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
-        projectPatentLinkService.updateProjectPatent(projectImportPatentVO.getProjectId(), uploadParamsVO.getPatent().getId());
+    public void patentThematicPidBusiness(UploadParamsVO uploadParamsVO, Integer projectId) {
+        projectPatentLinkService.updateProjectPatent(projectId, uploadParamsVO.getPatent().getId());
     }
 
     public void patentProjectFieldPatentLinkBusiness(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
@@ -750,7 +750,6 @@ public class UploadPatentBatchService {
         if (patentCell.getPdf() != null) {
             patentInstructionService.edit(patentCell.getPatentNo(), patentCell.getPdf());
         }
-        getOneOrInsertOne(uploadParamsVO);
         //设置公开号
         patent.setPublicNo(patentCell.getPublicNo());
         uploadParamsVO.setSimpleStatus(patentCell.getStatue());

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

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

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

@@ -0,0 +1,318 @@
+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.outApi.PatentStarListDto;
+import cn.cslg.pas.common.model.vo.KeyValueVO;
+import cn.cslg.pas.common.model.vo.PageVO;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
+import cn.cslg.pas.common.utils.ThrowException;
+import cn.cslg.pas.domain.*;
+import cn.cslg.pas.service.outApi.PatentStarApiService;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
+import com.alibaba.fastjson.JSON;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.util.*;
+
+/**
+ * 获取专利之星专利某部分（如权要、说明书等一项）业务层
+ *
+ * @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) throws IOException {
+        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);  //拿说明书pdf
+        } else if (patentCell == 4) {
+            patentDTO = getPatentImage(appNo);  //拿摘要附图
+        } else if (patentCell == 5) {
+            patentDTO = getSimpleFamily(getPatentStarPartDTO);  //拿同族专利信息
+        } else if (patentCell == 6) {
+            patentDTO = getAffair(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地址
+        if (appNo.contains(".")) {
+            appNo = appNo.substring(0, appNo.lastIndexOf("."));
+        }
+        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;
+    }
+
+    /**
+     * 获取专利之星专利的同族专利
+     *
+     * @param getPatentStarPartDTO 获取专利之星专利指定项DTO类
+     * @return 返回装载着同族专利的对象集合
+     */
+    public PatentDTO getSimpleFamily(GetPatentStarPartDTO getPatentStarPartDTO) throws IOException {
+        //从DTO中取出公开号、当前页、每页条数
+        String patentNo = getPatentStarPartDTO.getPatentNo();
+        Integer current = getPatentStarPartDTO.getCurrent();
+        Integer size = getPatentStarPartDTO.getSize();
+
+        PatentDTO patentDTO = new PatentDTO();
+        PageVO pageVO = new PageVO()
+                .setCurrent(current)
+                .setSize(size);
+
+        //以下 ↓装载的是调用"获得同族专利"接口返回的专利相关数据
+        String familyPatentNoStr = patentStarApiService.getFamilyByPubNoApi(patentNo);
+        //若没有同族号，则返回空集合（表示该公开号暂无同族）
+        if (familyPatentNoStr.equals("no data")) {
+            pageVO.setRecords(new ArrayList<>())
+                    .setTotal(0);
+            patentDTO.setFamilyPatentResult(pageVO);
+            return patentDTO;
+        }
+
+        FamilyPatentNo familyPatentNo = JSON.parseObject(familyPatentNoStr, FamilyPatentNo.class);
+        //familyPNStr：以分号;拼接的多个同族公开号字符串
+        String familyPNStr = familyPatentNo.getFamilyinfo();
+        List<String> familyPatentNos = Arrays.asList(familyPNStr.split(";"));
+
+        //防止下标越界的判断（即判断所需当前页是否有数据）
+        if ((current - 1) * size >= familyPatentNos.size()) {
+            pageVO.setRecords(new ArrayList<>())
+                    .setTotal(familyPatentNos.size());
+            patentDTO.setFamilyPatentResult(pageVO);
+            return patentDTO;
+        }
+
+        //根据分页信息，取分页区间内的同族号
+        familyPatentNos = pageBySubList(familyPatentNos, current, size);
+        //集合转成字符串
+        String conditions = "(PN=(" + StringUtils.join(familyPatentNos, " OR ") + "))";
+
+        //调用一般接口返回这些同族号专利的著录相关数据（标题、申请人、权利人、摘要附图）
+        PatentStarListDto patentStarListDto = new PatentStarListDto()
+                .setCurrentQuery(conditions)
+                .setOrderBy("ID")
+                .setOrderByType("DESC")
+                .setPageNum(current)
+                .setRowCount(size)
+                .setDBType("WD");
+        Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
+        if (resultMap == null || (Integer) resultMap.get("total") == 0) {
+            ThrowException.throwXiaoShiException("发生未知错误，一般接口未检索出专利");
+        }
+
+        List<StarPatentVO> patents = (List<StarPatentVO>) resultMap.get("records");
+        List<PatentSimpleFamilyLink> records = new ArrayList<>();
+        for (StarPatentVO starPatent : patents) {
+            PatentSimpleFamilyLink patentSimpleFamilyLink = new PatentSimpleFamilyLink();
+            patentSimpleFamilyLink.setAbstractPath(starPatent.getAbstractPath());  //装载摘要附图
+            patentSimpleFamilyLink.setPatentNo(starPatent.getPatentNo());  //装载公开号
+            patentSimpleFamilyLink.setName(starPatent.getName());  //装载标题
+            //装载申请人和权利人
+            ArrayList<PatentApplicant> patentApplicants = new ArrayList<>();
+            List<String> applicantNames = Arrays.asList(starPatent.getApplicantStr().split(";"));
+            for (String applicantName : applicantNames) {
+                PatentApplicant patentApplicant = new PatentApplicant();
+                patentApplicant.setName(applicantName);
+                patentApplicant.setDataType(1);
+                patentApplicants.add(patentApplicant);  //装载申请人
+                patentApplicant.setDataType(2);
+                patentApplicants.add(patentApplicant);  //装载权利人
+            }
+            patentSimpleFamilyLink.setApplicant(patentApplicants);
+            records.add(patentSimpleFamilyLink);
+        }
+        pageVO.setRecords(records)
+                .setTotal(familyPatentNos.size());
+        patentDTO.setFamilyPatentResult(pageVO);
+        return patentDTO;
+    }
+
+    public PatentDTO getAffair(String appNo) throws IOException {
+        if (appNo.contains(".")) {
+            appNo = appNo.substring(0, appNo.lastIndexOf("."));
+        }
+        //以下 ↓装载的是调用"获得中国专利法律状态"接口返回的专利相关数据
+        String cnLegalApiStr = patentStarApiService.getCnLegalApi(appNo);
+        List<ChinaLeagalStatus> chinaLeagalStatuses = JSON.parseArray(cnLegalApiStr, ChinaLeagalStatus.class);
+        ArrayList<KeyValueVO> lst = new ArrayList<>();
+        HashMap<Integer, String> nameMap = new HashMap<>();
+        HashMap<Integer, String> contentMap = new HashMap<>();
+        nameMap.put(0, "发生日期");
+        nameMap.put(1, "法律状态");
+        nameMap.put(2, "详细法律状态");
+//        nameMap.put(3, "IPC分类");
+//        nameMap.put(4, "申请号");
+//        nameMap.put(5, "申请日");
+//        nameMap.put(6, "变更编号");
+        nameMap.put(3, "详细信息");
+        for (ChinaLeagalStatus chinaLeagalStatus : chinaLeagalStatuses) {
+            contentMap.put(0, chinaLeagalStatus.getLegalDate());
+            contentMap.put(1, chinaLeagalStatus.getLegalStatus());
+            contentMap.put(2, chinaLeagalStatus.getLegalStatusInfo());
+//            contentMap.put(3, chinaLeagalStatus.getIPC());
+//            contentMap.put(4, chinaLeagalStatus.getSHENQINGH());
+//            contentMap.put(5, chinaLeagalStatus.getSHENQINGR());
+//            contentMap.put(6, chinaLeagalStatus.getBIANGENGSXCODE());
+            contentMap.put(3, chinaLeagalStatus.getDETAIL());
+            ArrayList<KeyValueVO.InpadocData> inpadocDatas = new ArrayList<>();
+            for (int i = 0; i < 4; i++) {
+                KeyValueVO.InpadocData inpadocData = new KeyValueVO.InpadocData();
+                inpadocData.setName(nameMap.get(i));
+                inpadocData.setContent(contentMap.get(i));
+                inpadocDatas.add(inpadocData);
+            }
+            KeyValueVO keyValueVO = new KeyValueVO();
+            keyValueVO.setInpadocData(inpadocDatas);
+            lst.add(keyValueVO);
+        }
+        PatentDTO patentDTO = new PatentDTO();
+        ArrayList<PatentAffair> patentAffairs = new ArrayList<>();
+        PatentAffair patentAffair = new PatentAffair();
+        patentAffair.setInpadoc(lst);
+        patentAffairs.add(patentAffair);
+        patentDTO.setAffair(patentAffairs);
+        return patentDTO;
+    }
+
+
+    /**
+     * 根据分页信息，取同族号集合中分页区间内的同族号
+     *
+     * @param list    同族号集合
+     * @param current 当前页
+     * @param size    每页条数
+     * @return 返回需要的同族号集合
+     */
+    public static List<String> pageBySubList(List<String> list, int current, int size) {
+        int totalcount = list.size();
+        int pagecount = 0;
+        List<String> subList;
+
+        int m = totalcount % size;
+        if (m > 0) {
+            pagecount = totalcount / size + 1;
+        } else {
+            pagecount = totalcount / size;
+        }
+
+        if (m == 0) {
+            subList = list.subList((current - 1) * size, size * (current));
+        } else {
+            if (current == pagecount) {
+                subList = list.subList((current - 1) * size, totalcount);
+            } else {
+                subList = list.subList((current - 1) * size, size * (current));
+            }
+        }
+
+        return subList;
+
+    }
+
+}

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

@@ -6,18 +6,30 @@ import cn.cslg.pas.common.model.dto.GetDescriptionInfoParamsDTO;
 import cn.cslg.pas.common.model.dto.GetFuTuParamsDTO;
 import cn.cslg.pas.common.model.dto.GetSearchBiblioParamsDTO;
 import cn.cslg.pas.common.model.outApi.PatentStarListDto;
-import cn.cslg.pas.domain.PubNo;
+import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
+import cn.cslg.pas.common.utils.FormatUtil;
+import cn.cslg.pas.common.utils.JsonUtils;
+import cn.cslg.pas.common.utils.SecurityUtils.SecurityUtils;
+import cn.cslg.pas.domain.*;
+import cn.hutool.crypto.SecureUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.google.gson.Gson;
+import com.google.gson.JsonObject;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import okhttp3.*;
+import org.apache.commons.lang3.StringEscapeUtils;
+import org.junit.Test;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import java.io.IOException;
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * 调用外部接口的Service类 PCS:权限系统
@@ -28,199 +40,646 @@ import java.util.concurrent.TimeUnit;
 @RequiredArgsConstructor
 @Slf4j
 @Service
+
 public class PatentStarApiService {
-    @Value("${authorUrl}")
-    private String PCSUrl;
-    @Value("${OPSUrl}")
-    private String OPSUrl;
-    @Value("${PASUrl}")
-    private String PASUrl;
-
-
-    public String patentStarSearchApi(PatentStarListDto patentStarListDto) throws IOException {
-
-//        // 创建一个OkHttpClient对象
-//        OkHttpClient okHttpClient = new OkHttpClient();
-//
-//        // 创建一个RequestBody(参数1：数据类型 参数2传递的json串)
-//        FormBody.Builder builder = new FormBody.Builder();
-//
-//        for (String key : param.keySet()) {
-//            Object obj = param.get(key);
-//            if (obj != null) {
-//                builder.addEncoded(key, param.get(key).toString());
-//            } else {
-//                builder.addEncoded(key, "");
-//            }
-//        }
-//        FormBody  requestBody = builder.build();
-//
-//        // 创建一个请求对象
-//        Request request = new Request.Builder().url(url).post(requestBody).build();
-//        // 发送请求获取响应
-//        try {
-//            Response response = okHttpClient.newCall(request).execute();
-//            // 判断请求是否成功
-//            if (response.isSuccessful()) {
-//                // 打印服务端返回结果
-//                return response.body().string();
-//            }
-//        } catch (IOException e) {
-//            e.printStackTrace();
-//        }
-//        return "{}";
-//        OkHttpClient okHttpClient = new OkHttpClient();
-//        Request request = new Request.Builder()
-//                .url(PCSUrl + "/permission/api/system/getPersonIdByName?personName=" + personName)
-//                .get()
-//                .build();
-//        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
-   return "";
+
+   public static String formatValue(String value){
+       return  value.replace("~",">");
+   }
+
+   public static String formQuery(String query){
+       query = query
+               .replace(" AND ", "*")
+               .replace(" OR ", "+")
+               .replace(" NOT ", "-");
+
+       //记录偏移量
+       int t =0;
+      StringBuilder query2 =new StringBuilder(query);
+      //匹配形如ab=(cd OR ef);
+       String regexOrg = "([^=^\\+^\\(^\\)]+=\\([^=^\\)]+\\))+?";
+       Pattern patternOrg = Pattern.compile(regexOrg);
+       Matcher matcherOrg = patternOrg.matcher(query);
+       while (matcherOrg.find()){
+           String a = matcherOrg.group();
+         String[] bc =a.split("=");
+         String b =bc[0];
+         b.length();
+         query2.delete(matcherOrg.start()+t,matcherOrg.start()+b.length()+1+t);
+         t=t-b.length()-1;
+         String c= bc[1];
+           String regexOrg1 = "([^\\+^\\*^\\-^\\(^\\)])+";
+           Pattern patternOrg1 = Pattern.compile(regexOrg1);
+           Matcher matcherOrg1 = patternOrg1.matcher(c);
+           while (matcherOrg1.find()){
+               String r =matcherOrg1.group();
+               System.out.println(r);
+        query2.insert(matcherOrg.start()+b.length()+1+matcherOrg1.start()+t,b+"=");
+           t=t+b.length()+1;
+           }
+       }
+       System.out.println(query2);
+       return query2.toString();
+   }
+
+    public static String formatQuery(String query) {
+       query= PatentStarApiService.formQuery(query);
+        StringBuilder sb = new StringBuilder(query);
+        String regex = "(?<=[\\(\\)\\+\\-=\\*])[^\\*^\\-^\\+^\\(^\\)]+?(?=[\\(\\+\\-=\\)\\*])";
+        Pattern pattern = Pattern.compile(regex);
+        Matcher matcher = pattern.matcher(query);
+        Map<Integer, Integer> map = new LinkedHashMap<>();
+        while (matcher.find()) {
+            String a = matcher.group();
+            String regex2 = "[^\\(^\\)^\\+^-^=^*]";
+            Pattern pattern2 = Pattern.compile(regex2);
+            Matcher matcher2 = pattern2.matcher(a);
+            Integer start = matcher.start();
+            if (matcher2.find()) {
+                start += matcher2.start();
+            }
+            map.put(start, matcher.end());
+        }
+        if (map.size() == 0) {
+            return "";
+        }
+        List<Integer> list = new ArrayList<Integer>(map.keySet());
+        for (int i = 0; i < list.size(); i += 2) {
+            int start1 = list.get(i);
+            int end1 = map.get(list.get(i));
+            int len1 = end1 - start1;
+            int start2 = list.get(i + 1);
+            int end2 = map.get(list.get(i + 1));
+            int len2 = end2 - start2;
+            int diff = len2 - len1;
+            if (diff > 0) {
+                sb.replace(start1, end1,formatValue(query.substring(start2, end2)));
+                sb.replace(start2 + diff, end2 + diff, query.substring(start1, end1));
+            } else {
+                sb.replace(start2, end2, query.substring(start1, end1));
+                sb.replace(start1, end1, formatValue(query.substring(start2, end2)));
+            }
+        }
+        String reStr = sb.toString();
+        reStr = "FXX" + reStr.replace("=", "/");
+        return reStr;
     }
 
-    /**
-     * 根据人员ids查询人员列表
-     *
-     * @param ids 人员ids
-     * @return 返回装载着人员列表数据的data的String
-     */
-    public String getPersonnelByIdsFromPCS(List<Integer> ids) throws IOException {
+    //装载专利信息
+    public void loadStarPatentVOS(List<StarPatentVO> starPatentVOS){
+        starPatentVOS.forEach(item->{
+            if(item.getPublicNo()!=null&&!item.getPublicNo().equals("")){
+                item.setPatentNo(item.getPublicNo());
+            }
+            else if(item.getAnnounceNo()!=null&&!item.getAnnounceNo().equals("")){
+                item.setPublicNo(item.getAnnounceNo());
+                item.setPatentNo(item.getAnnounceNo());
+            }
+            item.setApplicant(new ArrayList<>());
+            item.setAgent(new ArrayList<>());
+            item.setIpcList(Arrays.asList(item.getIpcListStr().split(";")));
+            List<String> applicants =   Arrays.asList( item.getApplicantStr().split(";"));
+            //装载申请人
+            applicants.forEach(
+                    tem->{
+                        PatentApplicant patentApplicant =new PatentApplicant();
+                        patentApplicant.setType(2);
+                        patentApplicant.setDataType(2);
+                        patentApplicant.setName(tem);
+                        item.getApplicant().add(patentApplicant);
+                    }
+            );
+            if(item.getCurrentApplicantStr()!=null&&item.getCurrentApplicantStr()!=""){
+                List<String> cApplicants =   Arrays.asList(item.getCurrentApplicantStr().split(";"));
+                cApplicants.forEach(
+                        tem->{
+                            PatentApplicant patentApplicant =new PatentApplicant();
+                            patentApplicant.setType(2);
+                            patentApplicant.setDataType(1);
+                            patentApplicant.setName(tem);
+                            item.getApplicant().add(patentApplicant);
+                        }
+                );
+            }
+            //代理机构
+            if(item.getAgencyStr()!=null&&item.getAgencyStr()!=""){
+                PatentAgency patentAgency =new PatentAgency();
+                patentAgency.setName(item.getAgencyStr().split(" ")[0]);
+                item.setAgency(patentAgency);
+            }
+            //发明人
+            if(item.getInventorStr()!=null&&item.getInventorStr()!=""){
+                item.setInventor(new ArrayList<>());
+                List<String> inventors =   Arrays.asList(item.getInventorStr().split(";"));
+                inventors.forEach(
+                        tem->{
+                            PatentInventor patentInventor =new PatentInventor();
+                            patentInventor.setName(tem);
+                            item.getInventor().add(patentInventor);;
+                        }
+                );
+            }
+            //代理人
+            if(item.getAgentStr()!=null&&item.getAgentStr()!=""){
+                List<String> agent =   Arrays.asList(item.getAgentStr().split(";"));
+                agent.forEach(
+                        tem->{
+                            PatentAgent patentAgent =new PatentAgent();
+                            patentAgent.setName(tem);
+                            item.getAgent().add(patentAgent);
+                        }
+                );
+            }
+            //附图
+            String apN=item.getApplicationNo().replace(".","");
+        item.setAbstractPath(this.getPictureApi(apN.substring(2)));
+            if(item.getLG()!=null){
+             switch (item.getLG()){
+                 case 1:
+                     item.setSimpleStatus("有效");
+                     break;
+                 case 2:
+                     item.setSimpleStatus("失效");
+                     break;
+                 case 3:
+                     item.setSimpleStatus("审中");
+                     break;
+             }
+            }
+            //法律状态
+        });
+    }
 
-        String param = new Gson().toJson(ids);
-        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+
+    public Map<String, Object> patentStarSearchApi(PatentStarListDto patentStarListDto) throws IOException {
+       try {
+           String formQuery = patentStarListDto.getCurrentQuery();
+           patentStarListDto.setCurrentQuery(PatentStarApiService.formatQuery(formQuery));
+       }
+catch (Exception e){
+           return null;
+}
+
+        String json = JSONObject.toJSONString(patentStarListDto);
+        String url = "http://s.patentstar.com.cn/SearchAPI/PatentSearch/ResultGet";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = "FNYJD7902206FFB741E163BE6536C3689D55" + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(PCSUrl + "/permission/api/system/getPersonnelByIds")
-                .post(requestBody)
-                .build();
-        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+        // 创建一个RequestBody(参数1：数据类型 参数2传递的json串)
+        FormBody.Builder builder = new FormBody.Builder();
+        builder.add("AppID", "K8FFB741E163BE6536");
+        builder.add("Stamp", currentTimeMillis.toString());
+        builder.add("Sign", signMd5);
+        builder.add("QueryJson", json);
+        FormBody requestBody = builder.build();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url).post(requestBody).build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                JSONObject jsonObject = JSONObject.parseObject(Objects.requireNonNull(response.body()).string());
+                if(jsonObject.get("Ret").equals(500)){
+                    return null;
+                }
+                JSONObject Data = (JSONObject) jsonObject.get("Data");
+                List<StarPatentVO> starPatentVOS = JSONArray.parseArray(Data.get("List").toString(), StarPatentVO.class);
+                this.loadStarPatentVOS(starPatentVOS);
+                // 打印服务端返回结果
+                //  return Objects.requireNonNull(response.body()).string();
+                Map<String, Object> reMap = new HashMap<>();
+                reMap.put("size", patentStarListDto.getRowCount());
+                reMap.put("current", patentStarListDto.getPageNum());
+                reMap.put("records",starPatentVOS);
+                reMap.put("total", Data.get("HitCount"));
+                return reMap;
+            }
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+            return  null;
+        }
+        return null;
     }
 
     /**
-     * 远程调用获取一批专利著录的接口
-     *
+     * @param appNo
      * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利著录
      */
-    public String getSearchBiblio(GetSearchBiblioParamsDTO getSearchBiblioParamsDTO) throws IOException {
-        //String param = new Gson().toJson(getSearchBiblioParamsDTO);
-        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+    public String getCnBibApi(String appNo) {
+        String url = "https://api.patentstar.com.cn/api/Patent/CnBibo/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(OPSUrl + "/api/OPSQuery/SearchBiblio?query=" + getSearchBiblioParamsDTO.getQuery() + "&start=" + getSearchBiblioParamsDTO.getStart() + "&end=" + getSearchBiblioParamsDTO.getEnd())
-                .get()
-                .build();
-        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
     /**
-     * 远程调用获取权要信息的接口
-     *
+     * @param
      * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利摘要附图
      */
-    public String getClaimsInfo(GetClaimsInfoParamsDTO getClaimsInfoParamsDTO) throws IOException {
-        //String param = new Gson().toJson(getClaimsInfoParamsDTO);
-        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+    public String getPictureApi(String appNo) {
+        String url = "https://api.patentstar.com.cn/api/Patent/CnMainImage/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(OPSUrl + "/api/OPSQuery/GetClaimsInfo?cc=" + getClaimsInfoParamsDTO.getCc() + "&number=" + getClaimsInfoParamsDTO.getNumber() + "&kind=" + getClaimsInfoParamsDTO.getKind())
-                .get()
-                .build();
-        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
     /**
-     * 远程调用获取说明书的接口
-     *
+     * @param appNo
      * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利外观图
      */
-    public String getDescriptionInfo(GetDescriptionInfoParamsDTO getDescriptionInfoParamsDTO) throws IOException {
-        //String param = new Gson().toJson(getDescriptionInfoParamsDTO);
-        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+    public String getWGPictureApi(String appNo) throws IOException {
+
+        String url = "https://api.patentstar.com.cn/api/Patent/CnWGImage/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(OPSUrl + "/api/OPSQuery/GetDescriptionInfo?cc=" + getDescriptionInfoParamsDTO.getCc() + "&number=" + getDescriptionInfoParamsDTO.getNumber() + "&kind=" + getDescriptionInfoParamsDTO.getKind())
-                .get()
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
+    }
+
+    /**
+     * @param appNo
+     * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利法律状态
+     */
+    public String getCnLegalApi(String appNo) {
+        String url = "https://api.patentstar.com.cn/api/Patent/CnLegal/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个OkHttpClient对象
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
                 .build();
-        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
     /**
-     * 远程调用获取Image信息的接口
-     *
+     * @param appNo
      * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利全文图片
      */
-    public String getImagesInfo(PubNo pubNo) throws IOException {
-        String pn = pubNo.getCountry() + pubNo.getNumber() + "." + pubNo.getKind();
-        //String param = new Gson().toJson(pn);
-        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+
+    public String getCnPdfApi(String appNo) throws IOException {
+        String url = "https://api.patentstar.com.cn/api/Patent/CnPdf/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(OPSUrl + "/api/OPSQuery/GetImagesInfo?Pn=" + pn)
-                .get()
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
+    }
+
+    /**
+     * @param appNo
+     * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取中国专利全文文本
+     */
+
+    public String getCnFullXmlApi(String appNo) throws IOException {
+        String url = "https://api.patentstar.com.cn/api/Patent/CnFullXml/" + appNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个OkHttpClient对象
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
                 .build();
-        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
     /**
-     * 远程调用获取附件文件流的接口
-     *
+     * @param patentNo
      * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取世界专利pdf
      */
-    public byte[] getPatentFile(GetFuTuParamsDTO getFuTuParamsDTO) throws IOException {
-        //String param = new Gson().toJson(getFuTuParamsDTO);
-        //RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+    public String getEnPdfApi(String patentNo) {
+        String url = "  https://api.patentstar.com.cn/api/Patent/EnPdf/" + patentNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个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(OPSUrl + "/api/OPSQuery/GetPatentFile?link=" + getFuTuParamsDTO.getLink() + "&page=" + getFuTuParamsDTO.getPage() + "&type=" + getFuTuParamsDTO.getType())
-                .get()
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
+    }
+
+    /**
+     * @param patentNo
+     * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取世界专利著录信息
+     */
+    public String getENBibApi(String patentNo) {
+        String url = "https://api.patentstar.com.cn/api/Patent/ENBib/" + patentNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个OkHttpClient对象
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
                 .build();
-        byte[] buffer = okHttpClient.newCall(request).execute().body().bytes();
-        return buffer;
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
     /**
-     * @params 传对象
-     * @title 导入专利
-     * @description 导入专利
-     * @author lrj
+     * @param patentNo
+     * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 从专利之星获取同族专利
      */
-    public String importPatents(PatentCell patentCell) throws IOException {
-        OkHttpClient httpClient = new OkHttpClient.Builder()
-                .pingInterval(400, TimeUnit.SECONDS) // 设置 PING 帧发送间隔
-                .connectTimeout(300, TimeUnit.SECONDS)//设置连接超时时间
-                .readTimeout(300, TimeUnit.SECONDS)//设置读取超时时间
+    public String getFamilyByPubNoApi(String patentNo) {
+        String url = "https://api.patentstar.com.cn/api/Patent/FamilyByPubNo/" + patentNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个OkHttpClient对象
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
                 .build();
-        String param = new Gson().toJson(patentCell);
-        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
-        Request request = new Request.Builder()
-                .url(PASUrl + "/api/v2/system/patentCellTODb")
-                .post(requestBody)
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
+    }
+
+    /**
+     * @param patentNo
+     * @return
+     * @throws IOException
+     * @author 李仁杰
+     * 获得专利被引用次数api
+     */
+    public String getCitedNumByPubNoApi(String patentNo) throws IOException {
+        String url = "https://api.patentstar.com.cn/api/Patent/CitedNumByPubNo/" + patentNo;
+        String appId = "2000041";
+        String appkey = "F0E183D5F02C48E391F5FADF1B646F54";
+        Long currentTimeMillis = System.currentTimeMillis() / 1000;
+        String Sign = appId + appkey + currentTimeMillis.toString();
+        String signMd5 = FormatUtil.MD5(Sign);
+        // 创建一个OkHttpClient对象
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(60, TimeUnit.SECONDS)
+                .readTimeout(60, TimeUnit.SECONDS)
                 .build();
-        return Objects.requireNonNull(httpClient.newCall(request).execute().body()).string();
+        // 创建一个请求对象
+        Request request = new Request.Builder().url(url)
+                .addHeader("_appid", "2000041")
+                .addHeader("_timestamp", currentTimeMillis.toString())
+                .addHeader("_sign", signMd5)
+                .get().build();
+        // 发送请求获取响应
+        try {
+            Response response = okHttpClient.newCall(request).execute();
+            // 判断请求是否成功
+            if (response.isSuccessful()) {
+                response.body().toString();
+                // 打印服务端返回结果
+                return Objects.requireNonNull(response.body()).string();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "{}";
     }
 
 }

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

@@ -1,9 +1,7 @@
 package cn.cslg.pas.service.upLoadPatent;
 
-import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.UploadParamsVO;
 import cn.cslg.pas.common.model.vo.UploadSettingVO;
-import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.UploadPatentBatchUtil;
 import cn.cslg.pas.domain.PatentData;
 import org.apache.poi.ss.usermodel.PictureData;

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

@@ -2,16 +2,14 @@ package cn.cslg.pas.service.upLoadPatent;
 
 import cn.cslg.pas.common.model.PatentCell;
 import cn.cslg.pas.common.model.dto.*;
-import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.UploadParamsVO;
-import cn.cslg.pas.common.model.vo.UploadSettingVO;
-import cn.cslg.pas.common.utils.*;
+import cn.cslg.pas.common.utils.FileUtils;
+import cn.cslg.pas.common.utils.StringUtils;
+import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.*;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.exception.XiaoShiException;
-import cn.cslg.pas.service.OutInterfaceService;
-import cn.cslg.pas.service.TaskService;
-import cn.cslg.pas.service.UploadPatentBatchService;
+import cn.cslg.pas.service.*;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -22,152 +20,78 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
-import org.apache.poi.ss.usermodel.Sheet;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.multipart.commons.CommonsMultipartFile;
 
 import java.io.*;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
 /**
- * 根据不同类型任务生成专利入消费者队列的业务层
+ * Epo类型任务解析获取专利类
  *
  * @Author chenyu
- * @Date 2023/6/12
+ * @Date 2023/6/16
  */
 @Slf4j
-@Service
 @RequiredArgsConstructor
-public class ExcuteTaskToPatentService implements Serializable {
+@Service
+public class ExcutePatentDataEpo implements IExcutePatentData {
     private final FileUtils fileUtils;
-    private final ExcuteUploadSettingService excuteUploadSettingService;
-    private final ExcuteDataToVOService excuteDataToVOService;
     private final PantentQueueService pantentQueueService;
     private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
     private final OutInterfaceService outInterfaceService;
-    private final TaskService taskService;
-
-    //TODO 工厂类
-    public void taskToPatentQueue(Task task) throws IOException {
-        //Excel导入任务
-        if (task.getType() == 1) {
-            excelTaskToPatentQueue(task);
-            //EPO网站导入任务
-        } else if (task.getType() == 3) {
-            epoTaskToPatentQueue(task);
-        }
-
-    }
+    private final PatentInstructionService patentInstructionService;
+    private final PatentAgencyService patentAgencyService;
+    private final PatentAffairService patentAffairService;
+    private final ProjectPatentLinkService projectPatentLinkService;
+    private final PatentService patentService;
+    private final PatentImageService patentImageService;
+    private Integer pTaskId = 0;
+    private Integer pTaskStatus = 0;
 
     /**
-     * Excel导入专利
+     * 解析获取专利数据
      *
-     * @param task Excel导入专利任务
+     * @param task 任务
      */
-    public void excelTaskToPatentQueue(Task task) throws IOException {
-        //从任务中取出文件路径、总条数、成功条数、前台参数json
-        String filePath = task.getUrl();  //相对路径
-        filePath = fileUtils.getPath(filePath);  //绝对路径
-        Integer total = task.getTotal();
-
-        int lastIndex = task.getSuccessNum();
-        String json = task.getPramJson();
-        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(json, ProjectImportPatentVO.class);
-        //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
-        List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
-        //解析Excel文件获得工作簿
-        Sheet sheet = ReadExcelUtils.readExcel(filePath);
-        //遍历专利总数量，在循环中保存专利
-        for (int i = lastIndex; i < total; i++) {
-            PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
-            //调用装载数据类，专利数据转换为VO对象
-            UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
-
-            //专利入消费者队列，并唤醒消费者执行专利入库
-            //patentToQueueAwakeConsumer(uploadParamsVO, projectImportPatentVO);
-            pantentQueueService.patentToQueue(uploadParamsVO, projectImportPatentVO);
-        }
-    }
-
-    /**
-     * EPO网站导入专利
-     *
-     * @param task EPO网站导入专利
-     */
-    public void epoTaskToPatentQueue(Task task) throws IOException {
-        Integer taskId = task.getId();
-        List<AssoOsTaskQrtzTask> assoOsTaskQrtzTasks = assoOsTaskQrtzTaskService.list(new LambdaQueryWrapper<AssoOsTaskQrtzTask>().eq(AssoOsTaskQrtzTask::getTaskId, taskId));
+    @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);
 
-        Integer successNum = task.getSuccessNum();
-
-        //从任务关联网站导入任务对象中取出下载字段、检索信息
+        //从任务数据中获取下载字段、检索式
         String cellsStr = assoOsTaskQrtzTask.getConfigCells();
         List<String> cells = Arrays.asList(cellsStr.split(","));
         String conditions = assoOsTaskQrtzTask.getConditions();
 
         //定义每次检索的专利数量(每次检索50件)
         int size = 50;
-        //2.根据检索式conditions先检索一件专利著录信息【此操作主要是为了获得专利总数量count】
-//        SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, 1, 1);
-//        if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
-//            //conditions没有检索到任何相关专利(杰哥处理)
-//            ThrowException.throwXiaoShiException("检索失败，根据检索条件未检索出任何相关专利信息");
-//            return;
-//        }
 
         //获得专利总数量
-//        Integer count = serachBiblioData.getTotals();
         Integer count = task.getTotal();
 
-        //计算进度值
-//        double percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
-//        percentage = MathUtils.saveTwoDecimal(percentage);
-        //3.根据专利总数量count遍历检索专利
+        //1.根据专利总数量count遍历检索专利
         for (int i = 1; i <= count; i += size) {
-            //查看任务状态
-//            QrtzTaskDetail qrtzTaskDetail1 = qrTaskDetailService.getById(webQueryDTO.getTaskId());
-//            if (qrtzTaskDetail1.getTaskDetailState().equals(7)) {
-//                qrtzTaskDetail1.setTaskDetailState(5);
-//                qrtzTaskDetail1.setSuccessNum(successNum);
-//                qrtzTaskDetail1.setTaskProcess(percentage);
-//                qrtzTaskDetail1.updateById();
-//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
-//                        .setId(webQueryDTO.getTaskId())
-//                        .setProjectId(task.getProjectId())
-//                        .setComplete(false)
-//                        .setIndex(successNum)
-//                        .setTaskDetailState(5)
-//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
-//                return null;
-//            } else if (qrtzTaskDetail1.getTaskDetailState().equals(8)) {
-//                qrtzTaskDetail1.setTaskDetailState(6);
-//                qrtzTaskDetail1.setSuccessNum(successNum);
-//                qrtzTaskDetail1.setTaskProcess(percentage);
-//                qrtzTaskDetail1.updateById();
-//                WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
-//                        .setId(webQueryDTO.getTaskId())
-//                        .setProjectId(task.getProjectId())
-//                        .setComplete(false)
-//                        .setIndex(successNum)
-//                        .setTaskDetailState(6)
-//                        .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
-//                return null;
-//            }
-            //3.1根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
+            //根据检索式conditions、专利开始数i、专利最后数i + size - 1检索专利著录信息
             SerachBiblioData serachBiblioData = getSerachBiblioData(conditions, i, i + size - 1);
             //获取检索结果中的所有专利著录信息
             if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
                 continue;
             }
             List<PatentZhuLu> patents = serachBiblioData.getPatents();
-            //3.2遍历专利
+            //2.遍历专利
             for (PatentZhuLu patent : patents) {
+                //判断若任务状态为已暂停，则结束生产
+                if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
+                    return;
+                }
                 PatentCell patentCell = new PatentCell();
                 patentCell.setProjectId(task.getProjectId());
                 PubNo pubNO = new PubNo();
@@ -236,86 +160,111 @@ public class ExcuteTaskToPatentService implements Serializable {
                         setFuJian(drawingLink, drawingPage, drawingType, patentCell, ".tiff");
                     }
 
-                    //将专利发送到分析系统（保存专利入库）
+                    //先将部分入库，再将其余扔给消费者来入库（消费者方更改任务状态发送进度通知）
                     if (patentCell.getPatentNo() != null) {
-                        String res = outInterfaceService.importPatents(patentCell);
-                        JSONObject jsonObject = JSONObject.parseObject(res);
-                        if (jsonObject.get("code").toString().equals("500")) {
-                            //舍弃这个专利，继续下一个专利
-                            continue;
+                        UploadParamsVO uploadParamsVO = new UploadParamsVO();
+                        Patent patent2 = new Patent();
+                        //设置专利号
+                        patent2.setPatentNo(patentCell.getPatentNo());
+                        //设置摘要
+                        patent2.setAbstractStr(patentCell.getAbstrText());
+                        //设置标题
+                        patent2.setName(patentCell.getTitle());
+                        //设置公开日
+                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+                        if (patentCell.getPubilcDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getPubilcDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setPublicDate(ts);
+                        }
+                        //设置申请号
+                        patent2.setApplicationNo(patentCell.getApplicationNo());
+                        //设置申请日
+                        if (patentCell.getApplicationDate() != null) {
+                            Date date = simpleDateFormat.parse(patentCell.getApplicationDate());
+                            Integer ts = (int) date.getTime();
+                            patent2.setApplicationDate(ts);
+                        }
+                        //设置摘要附图
+                        patent2.setAbstractPath(patentCell.getPicUrl());
+                        //设置pdf文档
+                        if (patentCell.getPdf() != null) {
+                            patentInstructionService.edit(patentCell.getPatentNo(), patentCell.getPdf());
                         }
+                        //设置公开号
+                        patent2.setPublicNo(patentCell.getPublicNo());
+                        uploadParamsVO.setSimpleStatus(patentCell.getStatue());
+                        uploadParamsVO.setPatent(patent2);
+                        getOneOrInsertOne(uploadParamsVO);
+                        //摘要附图上传专利附图表"os_patent_img"根据专利id删除该专利的摘要图片数据，以免上传重复
+                        patentImageService.deleteByPatentIdAndStatus(uploadParamsVO.getPatent().getId(), 1);
+                        PatentImage patentImage = new PatentImage();
+                        patentImage.setStatus(1);
+                        patentImage.setPatentId(uploadParamsVO.getPatent().getId());
+                        patentImage.setUrl(patentCell.getPicUrl());
+                        patentImage.setFileName(patentCell.getFileName());
+                        //摘要附图数据入库
+                        patentImage.insert();
+
+                        if (patentCell.getAgency() != null && !patentCell.getAgency().equals("")) {
+                            uploadParamsVO.getPatent().setAgencyId(patentAgencyService.getAgencyStringIdByName(patentCell.getAgency()));
+                        }
+                        uploadParamsVO.setPatentRight(new PatentRight());
+                        uploadParamsVO.getPatentRight().setContent(StringUtils.join(patentCell.getRights(), ""));
+                        uploadParamsVO.setSelfContent(patentCell.getMainRignt());
+                        uploadParamsVO.setPatentInstructionText(new PatentInstructionText());
+                        uploadParamsVO.getPatentInstructionText().setManual(patentCell.getPatentInstructionText());
+                        //发明人
+                        List<String> inventors = patentCell.getInventors();
+                        if (inventors != null && inventors.size() > 0) {
+                            ArrayList<PatentInventor> patentInventors = new ArrayList<>();
+                            for (String inventor : inventors) {
+                                PatentInventor patentInventor = new PatentInventor();
+                                patentInventor.setName(inventor);
+                                patentInventors.add(patentInventor);
+                            }
+                            uploadParamsVO.setPatentInventorList(patentInventors);
+                        }
+                        uploadParamsVO.setPatentApplicantCurrentName(patentCell.getApplicationCurrents());
+                        uploadParamsVO.setPatentApplicantOriginalName(patentCell.getApplicationPersons());
+                        uploadParamsVO.setPatentApplicantOriginalAddress(patentCell.getApplicationAddress());
+                        uploadParamsVO.setIpcList(patentCell.getIpc());
+                        uploadParamsVO.setMainIpc(patentCell.getMainIpc());
+                        //代理人
+                        List<String> agencyPersons = patentCell.getAgencyPersons();
+                        if (agencyPersons != null && agencyPersons.size() > 0) {
+                            ArrayList<PatentAgent> patentAgents = new ArrayList<>();
+                            for (String agencyPerson : agencyPersons) {
+                                PatentAgent patentAgent = new PatentAgent();
+                                patentAgent.setName(agencyPerson);
+                                patentAgents.add(patentAgent);
+                            }
+                            uploadParamsVO.setPatentAgentList(patentAgents);
+                        }
+                        //事务信息 OS_PATENT_AFFAIR
+                        if (patentCell.getPatentAffairs() != null && patentCell.getPatentAffairs().size() > 0) {
+                            patentAffairService.updatePatientAffairs(patentCell.getPatentAffairs(), uploadParamsVO.getPatent().getId());
+                        }
+                        //当专题库id不为null时添加专利到专题库
+                        if (patentCell.getProjectId() != null) {
+                            projectPatentLinkService.updateProjectPatent(patentCell.getProjectId(), uploadParamsVO.getPatent().getId());
+                        }
+                        pantentQueueService.patentToQueue(task, uploadParamsVO);
                     }
 
-//                    QrtzTaskDetail qrtzTaskDetail11 = qrTaskDetailService.getById(qrtzTaskDetail.getId());
-//                    percentage = count == 0 ? 0 : (count.equals(successNum) ? (successNum * 1D) : (successNum + 1D) / count * 100D);
-//                    percentage = MathUtils.saveTwoDecimal(percentage);
-//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
-//                            .setId(webQueryDTO.getTaskId())
-//                            .setProjectId(task.getProjectId())
-//                            .setComplete(false)
-//                            .setIndex(successNum)
-//                            .setPercentage(percentage)
-//                            .setTaskDetailState(qrtzTaskDetail11.getTaskDetailState())
-//                            .setFileName("")
-//                            .setUrl("")
-//                            .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "null");
                 } catch (XiaoShiException e) {
                     //虽然拿不到所有附图，但已经拿到了专利著录，能拿到啥是啥
                     log.info(e.getMessage());
                 } catch (Exception e) {
-//                    qrtzTaskDetail.setTaskDetailState(3);
-//                    qrtzTaskDetail.setSuccessNum(successNum);
-//                    qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
-//                    qrtzTaskDetail.setFailure("拉取节点失败");
-//                    qrtzTaskDetail.setEndTime(new Date());
-//                    qrtzTaskDetail.updateById();
-//                    if (qrtzTask.getTaskType() == 1) {
-//                        qrtzTask.setTaskState(4);
-//                    } else {
-//                        qrtzTask.setTaskState(3);
-//                    }
-//                    qrtzTask.updateById();
-//                    WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
-//                            .setId(webQueryDTO.getTaskId())
-//                            .setProjectId(task.getProjectId())
-//                            .setComplete(true)
-//                            .setIndex(successNum)
-//                            .setPercentage(100D)
-//                            .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
-//                            .setFileName("")
-//                            .setUrl("")
-//                            .setTotal(successNum), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
+
                 }
 
             }
         }
-//        WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
-//                .setId(webQueryDTO.getTaskId())
-//                .setProjectId(task.getProjectId())
-//                .setComplete(true)
-//                .setIndex(count)
-//                .setPercentage(100D)
-//                .setTaskDetailState(qrtzTaskDetail.getTaskDetailState())
-//                .setFileName("")
-//                .setUrl("")
-//                .setTotal(count), ResponseEnum.PATENT_IMPORT_TASK_SUCCESS), "");
-//        //任务执行情况状态设为成功，任务条件状态设为已完成(若是任务条件是定时任务则设为等待下一次执行)
-//        qrtzTaskDetail.setTaskDetailState(2);
-//        qrtzTaskDetail.setSuccessNum(successNum);
-//        qrtzTaskDetail.setDefaultNum(qrtzTaskDetail.getAllNum() - successNum);
-//        qrtzTaskDetail.setTaskProcess(100);
-//        qrtzTaskDetail.setEndTime(new Date());
-//        qrtzTaskDetail.updateById();
-//        if (qrtzTask.getTaskType() == 1) {
-//            qrtzTask.setTaskState(4);
-//        } else {
-//            qrtzTask.setTaskState(2);
-//        }
-//        qrtzTask.updateById();
-//        return patentCells;
+
     }
 
-    //调用接口获取一批专利著录信息
+    //调用外部接口获取一批专利著录信息
     public SerachBiblioData getSerachBiblioData(String conditions, Integer start, Integer size) throws IOException {
         GetSearchBiblioParamsDTO getSearchBiblioParamsDTO = new GetSearchBiblioParamsDTO()
                 .setQuery(conditions)
@@ -385,6 +334,7 @@ public class ExcuteTaskToPatentService implements Serializable {
             applicationPersons.add(application.getOriginalName());
         }
         patentCell.setApplicationPersons(applicationPersons);
+
         //装载申请人地址(未找到)
         //装载发明人
         ArrayList<String> inventors = new ArrayList<>();
@@ -562,6 +512,7 @@ public class ExcuteTaskToPatentService implements Serializable {
                 //如果是摘要附图
                 if (FuJianSuffix.equals(".jpeg")) {
                     patentCell.setPicUrl(fileDTO.getPath());
+                    patentCell.setFileName(fileDTO.getFileName());
                 }
                 //如果是其他附图
                 if (FuJianSuffix.equals(".tiff")) {
@@ -603,7 +554,31 @@ public class ExcuteTaskToPatentService implements Serializable {
             patentCell.setOtherUrls(otherUrls);
         }
 
+    }
+
+    /**
+     * @param uploadParamsVO 全局类
+     * @date 2022-7-11
+     * @name 工具方法
+     * @description 查询数据是否存在 如果存在 返回该条数据 如果不存在 新增一条数据
+     */
+    public void getOneOrInsertOne(UploadParamsVO uploadParamsVO) {
+        if (uploadParamsVO.getPatent() != null) {
+            uploadParamsVO.getPatent().setPatentNo(uploadParamsVO.getPatent().getPatentNo().trim());
+            //用专利号查询该条数据是否存在
+            Patent patent = patentService.getByPatentNo(uploadParamsVO.getPatent().getPatentNo());
+            //如果不存在就新增一条
+            if (patent == null) {
+                uploadParamsVO.getPatent().insert();
+            } else {
+                uploadParamsVO.getPatent().setId(patent.getId());
+            }
+        }
+    }
 
+    public void setTaskStatus(Integer taskId, Integer taskStatus) {
+        this.pTaskId = taskId;
+        this.pTaskStatus = taskStatus;
     }
 
 }

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

@@ -0,0 +1,72 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import cn.cslg.pas.common.model.vo.UploadParamsVO;
+import cn.cslg.pas.common.model.vo.UploadSettingVO;
+import cn.cslg.pas.common.utils.FileUtils;
+import cn.cslg.pas.common.utils.JsonUtils;
+import cn.cslg.pas.common.utils.ReadExcelUtils;
+import cn.cslg.pas.domain.PatentData;
+import cn.cslg.pas.domain.Task;
+import lombok.RequiredArgsConstructor;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Excel类型任务解析获取专利类
+ *
+ * @Author chenyu
+ * @Date 2023/6/16
+ */
+@Service
+@RequiredArgsConstructor
+public class ExcutePatentDataExcel implements IExcutePatentData {
+    private final FileUtils fileUtils;
+    private final ExcuteUploadSettingService excuteUploadSettingService;
+    private final ExcuteDataToVOService excuteDataToVOService;
+    private final PantentQueueService pantentQueueService;
+    private Integer pTaskId = 0;
+    private Integer pTaskStatus = 0;
+
+    /**
+     * 解析获取专利数据
+     *
+     * @param task 任务
+     * @throws IOException 抛出IO异常
+     */
+    @Override
+    public void startExcute(Task task) throws IOException {
+        //从任务中取出文件路径、总条数、成功条数、前台参数json
+        String filePath = fileUtils.getPath(task.getUrl());
+        Integer total = task.getTotal();
+        int lastIndex = task.getSuccessNum();
+        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(task.getPramJson(), ProjectImportPatentVO.class);
+
+        //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
+        List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
+        //解析Excel文件获得工作簿
+        Sheet sheet = ReadExcelUtils.readExcel(filePath);
+        //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
+        for (int i = lastIndex; i < total; i++) {
+            //判断若任务状态为已暂停，则结束生产
+            if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
+                return;
+            }
+            PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
+            //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
+            UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
+
+            //专利丢入5个消费者队列，并唤醒5个消费者线程
+            pantentQueueService.patentToQueue(task, uploadParamsVO);
+        }
+    }
+
+    public void setTaskStatus(Integer taskId, Integer taskStatus) {
+        this.pTaskId = taskId;
+        this.pTaskStatus = taskStatus;
+    }
+
+}

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

@@ -0,0 +1,509 @@
+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.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;
+import com.alibaba.fastjson.JSON;
+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.*;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 专利之星类型任务解析获取专利类
+ *
+ * @Author chenyu
+ * @Date 2023/6/25
+ */
+@Slf4j
+@RequiredArgsConstructor
+@Service
+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;
+    private Integer pTaskId = 0;
+    private Integer pTaskStatus = 0;
+
+    /**
+     * 解析获取专利数据
+     *
+     * @param task 任务
+     */
+    @Override
+    public void startExcute(Task task) throws IOException {
+        Integer successNum = task.getSuccessNum();  //成功条数（即上一次下载到的位置）
+        Integer total = task.getTotal();  //专利总数量
+        String conditions = task.getConditions();  //检索式
+        String orderBy = task.getOrderBy();  //排序字段
+        String orderByType = task.getOrderByType();  //排序类型
+        String dbType = task.getDBType();  //检索数据库类型
+        List<String> cells = task.getConfigCells();  //下载字段
+        Integer startNumber = task.getStartNumber();  //下载起始条数位置
+        Integer endNumber = task.getEndNumber();  //下载终止条数位置
+        List<String> isAddPatentNos = task.getIsAddPatentNos();  //需要额外下载的专利号
+        List<String> isDeletePatentNos = task.getIsDeletePatentNos();  //起止条数中不需要下载的专利号
+
+
+
+
+
+
+
+
+
+        //定义每次检索的页码
+        int pageNum = 0;
+        //定义每次检索的专利数量(当前定义每次检索50件)
+        int size = 50;
+        //1.根据专利总数量count遍历检索专利
+        for (int i = successNum; i < total; i += size) {
+            pageNum++;
+            PatentStarListDto patentStarListDto = new PatentStarListDto()
+                    .setCurrentQuery(conditions)
+                    .setOrderBy(orderBy)
+                    .setOrderByType(orderByType)
+                    .setPageNum(pageNum)
+                    .setRowCount(size)
+                    .setDBType(dbType);
+            //调用一般接口返回一批专利著录相关数据
+            Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
+            if (resultMap == null || (Integer) resultMap.get("total") == 0) {
+                ThrowException.throwXiaoShiException("发生未知错误");
+            }
+
+            List<StarPatentVO> starPatents = (List<StarPatentVO>) resultMap.get("records");
+            //遍历这一批专利（50个）
+            for (int j = 0; j < starPatents.size(); j++) {
+                //判断若任务状态为已暂停，则结束生产
+                if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
+                    return;
+                }
+                try {
+                    UploadParamsVO uploadParamsVO = new UploadParamsVO();
+                    setPatentZhuLu(starPatents.get(j), uploadParamsVO);
+                    //保存专利基础数据（专利表"os_patent"），因为需要先拿到专利id供其他消费者部分使用
+                    uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
+
+                    PQueueData pQueueData = new PQueueData()
+                            .setTask(task)
+                            .setStarPatent(starPatents.get(j))
+                            .setUploadParamsVO(uploadParamsVO);
+                    //装载专利著录
+                    if (cells.contains("1")) {
+                        pantentQueueService.zhuluToPQueue(pQueueData);
+                    }
+                    //装载权要
+                    if (cells.contains("2")) {
+                        pantentQueueService.rightToPQueue(pQueueData);
+                    }
+                    //装载说明书文本
+                    if (cells.contains("3")) {
+                        pantentQueueService.instructionTextToPQueue(pQueueData);
+                    }
+                    //装载说明书pdf
+                    if (cells.contains("4")) {
+                        pantentQueueService.instructionPDFToPQueue(pQueueData);
+                    }
+                    //装载摘要附图
+                    if (cells.contains("6")) {
+                        pantentQueueService.imageToPQueue(pQueueData);
+                    }
+
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    //继续下一个专利
+                }
+
+            }
+
+        }
+
+
+    }
+
+    /**
+     * 装载著录方法
+     *
+     * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
+     */
+    public void setPatentZhuLu(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        //以下 ↓装载的是调用"一般检索"接口返回的专利相关数据
+        Patent patent = new Patent();
+        //装载专利号
+        patent.setPatentNo(starPatent.getPatentNo());
+        //装载摘要
+        patent.setAbstractStr(starPatent.getAbstractStr());
+        //装载标题
+        patent.setName(starPatent.getName());
+        //装载申请号
+        patent.setApplicationNo(starPatent.getApplicationNo());
+        //装载申请日
+        if (starPatent.getApplicationDate() != null && !starPatent.getApplicationDate().equals("")) {
+            patent.setApplicationDate(Integer.parseInt(starPatent.getApplicationDate()));
+        }
+        //装载公开号
+        patent.setPublicNo(starPatent.getPublicNo());
+        //装载公开日
+        if (starPatent.getPublicDate() != null && !starPatent.getPublicDate().equals(""))
+            patent.setPublicDate(Integer.parseInt(starPatent.getPublicDate()));
+        //装载申请人
+        if (starPatent.getApplicantStr() != null && !starPatent.getApplicantStr().equals("")) {
+            uploadParamsVO.setPatentApplicantOriginalName(Arrays.asList(starPatent.getApplicantStr().split(";")));
+        }
+        //装载权利人
+        if (starPatent.getCurrentApplicantStr() != null && !starPatent.getCurrentApplicantStr().equals("")) {
+            uploadParamsVO.setPatentApplicantCurrentName(Arrays.asList(starPatent.getCurrentApplicantStr().split(";")));
+        }
+        //装载IPC分类号
+        if (starPatent.getIpcListStr() != null && !starPatent.getIpcListStr().equals("")) {
+            String[] ipcArr = starPatent.getIpcListStr().split(";");
+            //装载主分类号
+            uploadParamsVO.setMainIpc(ipcArr[0]);
+            uploadParamsVO.setIpcList(Arrays.asList(ipcArr));
+        }
+        //装载法律状态（os_patent表status字段值）
+        Integer status = starPatent.getLG();
+        if (status != null) {
+            //有效（有权）
+            if (status == 1) {
+                patent.setSimpleStatus(3);
+                //失效（无权）
+            } else if (status == 2) {
+                patent.setSimpleStatus(2);
+                //审中（审中）
+            } else if (status == 3) {
+                patent.setSimpleStatus(1);
+            }
+        }
+        uploadParamsVO.setPatentSimpleStatus(starPatent.getSimpleStatus());
+        uploadParamsVO.setSimpleStatus(starPatent.getSimpleStatus());
+
+
+        //以下 ↓装载的是调用"获得中国专利著录"接口返回的专利相关数据
+        String appNo;
+        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();
+        //ChinaPatentZhuLu chinaPatentZhuLu = JSONObject.parseObject(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
+        //以上暂无需处理 ↑ 以下 ↓有现成的json数组字符串转为集合方法
+        List<ChinaPatentZhuLu> chinaPatentZhuLus = JSON.parseArray(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
+        ChinaPatentZhuLu chinaPatentZhuLu = chinaPatentZhuLus.get(0);
+
+        //装载申请人地址
+        if (chinaPatentZhuLu.getDZ() != null && !chinaPatentZhuLu.getDZ().equals("")) {
+            ArrayList<String> patentApplicantOriginalAddresss = new ArrayList<>();
+            if (chinaPatentZhuLu.getDZ().contains(" ")) {
+                patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ().substring(chinaPatentZhuLu.getDZ().indexOf(" ") + 1));
+            } else {
+                patentApplicantOriginalAddresss.add(chinaPatentZhuLu.getDZ());
+            }
+            uploadParamsVO.setPatentApplicantOriginalAddress(patentApplicantOriginalAddresss);
+        }
+        //装载代理人
+        if (chinaPatentZhuLu.getAT() != null && !chinaPatentZhuLu.getAT().equals("")) {
+            List<String> patentAgents = Arrays.asList(chinaPatentZhuLu.getAT().split(";"));
+            ArrayList<PatentAgent> patentAgentList = new ArrayList<>();
+            for (String n : patentAgents) {
+                PatentAgent patentAgent = new PatentAgent();
+                patentAgent.setName(n);
+                patentAgentList.add(patentAgent);
+            }
+            uploadParamsVO.setPatentAgentList(patentAgentList);
+        }
+        //装载代理机构地址
+        if (chinaPatentZhuLu.getAGN() != null && !chinaPatentZhuLu.getAGN().equals("")) {
+            String agencyAddress;
+            if (chinaPatentZhuLu.getAGN().contains(" ")) {
+                agencyAddress = chinaPatentZhuLu.getAGN().substring(0, chinaPatentZhuLu.getAGN().lastIndexOf(" "));
+            } else {
+                agencyAddress = chinaPatentZhuLu.getAGN();
+            }
+            patent.setAgencyId(agencyAddress);
+        }
+        //装载发明人
+        if (chinaPatentZhuLu.getIV() != null && !chinaPatentZhuLu.getIV().equals("")) {
+            List<String> patentInventorNames = Arrays.asList(chinaPatentZhuLu.getIV().split(";"));
+            ArrayList<PatentInventor> patentInventors = new ArrayList<>();
+            for (String patentInventorName : patentInventorNames) {
+                PatentInventor patentInventor = new PatentInventor();
+                patentInventor.setName(patentInventorName);
+                patentInventors.add(patentInventor);
+            }
+            uploadParamsVO.setPatentInventorList(patentInventors);
+        }
+        //装载优先权号、优先权国家、优先权日
+        patent.setPriorityNo(chinaPatentZhuLu.getPR());
+
+        //以下 ↓装载的是调用"获得同族专利"接口返回的专利相关数据
+        if (starPatent.getPatentNo() != null && !starPatent.getPatentNo().equals("")) {
+            String familyPatentNoStr = patentStarApiService.getFamilyByPubNoApi(starPatent.getPatentNo());
+            if (!familyPatentNoStr.equals("no data")) {
+                FamilyPatentNo familyPatentNo = JSON.parseObject(familyPatentNoStr, FamilyPatentNo.class);
+                //装载同族号
+                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);
+        //装载事务表的status（公开|授权|驳回|权力转移。。。）
+        PatentAffair patentAffair = new PatentAffair();
+        patentAffair.setStatus(chinaLeagalStatus.getLegalStatus());
+        if (chinaLeagalStatus.getLegalDate() != null && !chinaLeagalStatus.getLegalDate().equals("")) {
+            patentAffair.setDateTime(Integer.parseInt(chinaLeagalStatus.getLegalDate()));
+        }
+        uploadParamsVO.setPatentAffair(patentAffair);
+
+        //最后将 patent装载到 uploadParamsVO
+        uploadParamsVO.setPatent(patent);
+
+    }
+
+    /**
+     * 装载权要方法
+     *
+     * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
+     */
+    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 + "";
+
+            //使用工具类去除字符串文本中的所有HTML格式标签
+            patentRightText = RemoveHtmlTagsUtils.removeHtmlTags(patentRightText);
+
+            //装载权利要求原文
+            PatentRight patentRight = new PatentRight();
+            patentRight.setContent(patentRightText);
+            uploadParamsVO.setPatentRight(patentRight);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 装载说明书文本
+     *
+     * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
+     */
+    public void setPatentInstructionText(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 = "(?<=<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");
+            }
+
+            String instructionText = builder + "";
+
+            //使用工具类去除字符串文本中的所有HTML格式标签
+            instructionText = RemoveHtmlTagsUtils.removeHtmlTags(instructionText);
+
+            //装载说明书文本全文
+            PatentInstructionText patentInstructionText = new PatentInstructionText();
+            patentInstructionText.setManual(instructionText);
+            uploadParamsVO.setPatentInstructionText(patentInstructionText);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * 装载说明书pdf
+     *
+     * @param starPatent     专利之星著录对象
+     * @param uploadParamsVO 专利实体类对象
+     */
+    public void setPatentInstructionPDF(StarPatentVO starPatent, UploadParamsVO uploadParamsVO) {
+        try {
+            //根据专利号调用"获得世界专利pdf"接口，获得pdf的url地址
+            if (starPatent.getPatentNo() != null && !starPatent.getPatentNo().equals("")) {
+                String pdfUrl = patentStarApiService.getEnPdfApi(starPatent.getPatentNo());
+                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;
+//        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地址
+            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();
+        }
+
+    }
+
+    public void setTaskStatus(Integer taskId, Integer taskStatus) {
+        this.pTaskId = taskId;
+        this.pTaskStatus = taskStatus;
+    }
+
+
+}

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

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

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

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

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

@@ -3,10 +3,19 @@ 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.common.utils.JsonUtils;
+import cn.cslg.pas.common.utils.StringUtils;
+import cn.cslg.pas.domain.PQueueData;
 import cn.cslg.pas.domain.QueueData;
 import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.OutInterfaceService;
+import cn.cslg.pas.service.PatentInstructionService;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
+import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -18,94 +27,180 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * 将专利信息存入队列或从队列取出
+ * 1.生产者线程生产专利（根据任务类型调用对应工厂方法执行获取专利数据）
+ * 2.装载者线程装载专利（将专利数据装载到专利实体类）
+ * 3.消费者线程消费专利（将专利入库）
  */
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PantentQueueService {
     private final UploadPatentToDBService uploadPatentToDBService;
     private final UploadPatentBatchService uploadPatentBatchService;
-    private final ExcuteTaskToPatentService excuteTaskToPatentService;
     private final MessageService messageService;
     private final TaskService taskService;
-    private final Queue<QueueData> patentImageQueue = new LinkedList<>();
-    private final Queue<QueueData> patentZhuluQueue = new LinkedList<>();
-    private final Queue<QueueData> patentRightQueue = new LinkedList<>();
-    private final Queue<QueueData> patentInstructionTextQueue = new LinkedList<>();
-    private final Queue<QueueData> patentAssoQueue = new LinkedList<>();
+    private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
+    private final ExcutePatentDataExcel excutePatentDataExcel;
+    private final ExcutePatentDataEpo excutePatentDataEpo;
+    private final ExcutePatentDataStar excutePatentDataStar;
+    private final PatentInstructionService patentInstructionService;
+    private final OutInterfaceService outInterfaceService;
     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 patentAssoLock = 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 patentAssoCondition = patentAssoLock.newCondition();
-    private final HashMap<Integer, Integer> patentIdMap = new HashMap<>();
-    private Task task = null;
-    private Integer patentFinishNum = 0;
+    private final Condition patentInstructionPDFCondition = patentInstructionPDFLock.newCondition();
+    private final HashMap<String, Integer> patentIdMap = new HashMap<>();
 
     /**
-     * 生产者：从任务队列取出任务解析专利，将专利分配给消费者消费
+     * 生产者：从任务队列取出任务，再调用工厂方法根据任务类型返回对应的生产专利方法的对象将专利分配给消费者
      */
     public void addPatnetToQueue() {
-        try {
-            while (true) {
-                //检查任务队列
+        while (true) {
+            Task task = new Task();
+            try {
+                //判断任务队列是否有任务，若没有则线程等待唤醒
                 if (taskQueueList.size() == 0) {
                     taskLock.lock();
                     taskCondition.await();
                 }
-                //1.从taskQueueList中取出第一个task，将其状态改为进行中，并将其从任务队列taskQueueList中删除
-                task = taskService.getById(taskQueueList.get(0));
-                task.setStatus(1);
+
+                //线程被唤醒后 ↓
+                if (taskQueueList.size() > 0) {
+                    //从任务队列中取出第一个task任务，同时将其从任务队列中剔除
+                    task = taskService.getById(taskQueueList.remove(0));
+                    //判断任务状态，若已不存在或已暂停，则跳过继续取下一个任务
+                    if (task == null || task.getStatus() == 4) {
+                        continue;
+                    }
+
+                    //若是网站导入任务，则将网站导入相关信息存入task对象中（方便生产与消费时使用）
+                    if (task.getType().equals(3) || task.getType().equals(4)) {
+                        AssoOsTaskQrtzTask assoOsTaskQrtzTask = assoOsTaskQrtzTaskService.getById(task.getQrtzTaskId());
+                        List<String> configCells = Arrays.asList(assoOsTaskQrtzTask.getConfigCells().split(","));
+                        task.setConfigCellsNum(configCells.size());  //将下载字段数量存入task对象中（为了在后面发送进度时可以根据下载字段的数量来对应消费者数量，从而确定是否完成了一个专利的下载）
+                        task.setConfigCells(configCells);
+                        task.setOrderBy(assoOsTaskQrtzTask.getOrderBy());
+                        task.setOrderByType(assoOsTaskQrtzTask.getOrderByType());
+                        task.setDBType(assoOsTaskQrtzTask.getDBType());
+                        task.setStartNumber(assoOsTaskQrtzTask.getStartNumber());
+                        task.setEndTime(assoOsTaskQrtzTask.getEndNumber());
+                        task.setIsAddPatentNos(assoOsTaskQrtzTask.getIsAddPatentNos());
+                        task.setIsDeletePatentNos(assoOsTaskQrtzTask.getIsDeletePatentNos());
+                        task.setConditions(assoOsTaskQrtzTask.getConditions());
+                    }
+
+                    //TODO 调用工厂方法，工厂方法会根据任务类型创建并返回对应的生产专利方法的对象
+                    IExcutePatentData excutePatentDataObject = createObject(task);
+                    if (excutePatentDataObject != null) {
+                        //执行方法
+                        excutePatentDataObject.startExcute(task);
+                    }
+
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                //任务表更新状态失败
+                task.setStatus(2);
+                task.setEndTime(DateUtils.getDateTime());
                 taskService.updateById(task);
-                taskQueueList.remove(0);
+            }
 
-                patentIdMap.put(0, task.getTotal());
+        }
+    }
 
-                //TODO 调用工厂方法，将任务传入，解析任务类型匹配对应的生产专利方法
-                excuteTaskToPatentService.taskToPatentQueue(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());
+                    //装载完成，将其丢入著录消费者队列，并唤醒著录消费者线程
+                    patentZhuluQueueList.add(queueData);
+                    patentZhuluLock.lock();
+                    patentZhuluCondition.signalAll();
+                    patentZhuluLock.unlock();
+
+                } else {
+                    setPatentZhuluLock.lock();
+                    setPatentZhuluCondition.await();
+                    setPatentZhuluLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
 
             }
 
-        } catch (Exception e) {
-            e.printStackTrace();
-            //任务表更新状态为失败
-            task.setStatus(3);
-            task.setEndTime(DateUtils.getDateTime());
-            taskService.updateById(task);
         }
-        flag = true;
     }
 
     /**
-     * 消费者1：将专利从队列取出，摘要附图入库
+     * 装载线程2：摘要附图
      */
-    public void pushPatentImageToDB() throws InterruptedException, IOException {
+    public void setPatentImage() {
         while (true) {
             try {
-                if (patentImageQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("摘要附图全部完成，退出循环");
-                        return;
-                    } else {
-                        patentImageLock.lock();
-                        patentImageCondition.await();
-                        patentImageLock.unlock();
+                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 {
-                    QueueData queueData = patentImageQueue.remove();
-                    //摘要附图入库
-                    uploadPatentToDBService.uploadPatentImage(queueData.getUploadParamsVO());
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    setPatentImageLock.lock();
+                    setPatentImageCondition.await();
+                    setPatentImageLock.unlock();
                 }
 
             } catch (Exception e) {
@@ -117,30 +212,182 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者2：将专利从队列取出，著录项目入库
+     * 装载线程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 pushPatentZhuLuToDB() throws InterruptedException, IOException {
+    public void setPatentInstructionPDF() {
         while (true) {
             try {
-                if (patentZhuluQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("著录项目全部完成，退出循环");
-                        return;
+                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();
+
+            }
+
+        }
+    }
+
+    /**
+     * 消费者1：摘要附图入库
+     */
+    public void pushPatentImageToDB() {
+        while (true) {
+            QueueData queueData = new QueueData();
+            try {
+                if (patentImageQueueList.size() > 0) {
+                    queueData = patentImageQueueList.remove(0);
+                    UploadParamsVO uploadParamsVO = queueData.getUploadParamsVO();
+                    //摘要附图入库（两种方式：1.Excel摘要附图方式 2.网站导入摘要附图方式）
+                    if (queueData.getTask().getType().equals(1)) {
+                        uploadPatentToDBService.uploadPatentImage(uploadParamsVO);
                     } else {
-                        patentZhuluLock.lock();
-                        patentZhuluCondition.await();
-                        patentZhuluLock.unlock();
+                        uploadPatentToDBService.uploadPatentImage2(uploadParamsVO);
                     }
+                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+                    sendMessage(queueData);
                 } else {
-                    QueueData queueData = patentZhuluQueue.remove();
+                    patentImageLock.lock();
+                    patentImageCondition.await();
+                    patentImageLock.unlock();
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+                sendMessage(queueData);
+
+            }
+
+        }
+    }
+
+    /**
+     * 消费者2：将专利从队列取出，著录项目入库
+     */
+    public void pushPatentZhuLuToDB() {
+        while (true) {
+            QueueData queueData = new QueueData();
+            try {
+                if (patentZhuluQueueList.size() > 0) {
+                    queueData = patentZhuluQueueList.remove(0);
                     //著录项目入库
                     uploadPatentToDBService.uploadPatentZhulu(queueData.getUploadParamsVO());
+                    //判断是与专题库关联还是与报告关联
+                    if (queueData.getTask().getProjectId() != null && !queueData.getTask().getProjectId().equals(0)) {
+                        //与专题库关联入库
+                        uploadPatentToDBService.uploadAssoThemaPat(queueData.getUploadParamsVO(), queueData.getTask().getProjectId());
+                    } else if (queueData.getTask().getReportId() != null && !queueData.getTask().getReportId().equals(0)) {
+                        //与报告关联入库（调用报告系统接口）
+                        outInterfaceService.importAssoReportPatentNo(queueData.getTask().getReportId(), queueData.getUploadParamsVO().getPatent().getPatentNo(), queueData.getUploadParamsVO().getPatent().getName());
+                    }
+
+                    ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(queueData.getTask().getPramJson(), ProjectImportPatentVO.class);
+                    //自定义字段标引与专利关联入库
+                    uploadPatentToDBService.uploadAssoFieldPat(queueData.getUploadParamsVO(), projectImportPatentVO);
+                    //文件夹与专利关联入库
+                    uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), projectImportPatentVO);
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData);
+                } else {
+                    patentZhuluLock.lock();
+                    patentZhuluCondition.await();
+                    patentZhuluLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
@@ -149,28 +396,25 @@ public class PantentQueueService {
     /**
      * 消费者3：将专利从队列取出，权利要求文本入库
      */
-    public void pushPatentRightToDB() throws InterruptedException, IOException {
+    public void pushPatentRightToDB() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentRightQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("权利要求全部完成，退出循环");
-                        return;
-                    } else {
-                        patentRightLock.lock();
-                        patentRightCondition.await();
-                        patentRightLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentRightQueue.remove();
+                if (patentRightQueueList.size() > 0) {
+                    queueData = patentRightQueueList.remove(0);
                     //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData);
+                } else {
+                    patentRightLock.lock();
+                    patentRightCondition.await();
+                    patentRightLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
@@ -179,138 +423,260 @@ public class PantentQueueService {
     /**
      * 消费者4：将专利从队列取出，说明书文本入库
      */
-    public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionTextToDB() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentInstructionTextQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("说明书文本全部完成，退出循环");
-                        return;
-                    } else {
-                        patentInstructionTextLock.lock();
-                        patentInstructionTextCondition.await();
-                        patentInstructionTextLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentInstructionTextQueue.remove();
+                if (patentInstructionTextQueueList.size() > 0) {
+                    queueData = patentInstructionTextQueueList.remove(0);
                     //说明书文本入库
                     uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData);
+                } else {
+                    patentInstructionTextLock.lock();
+                    patentInstructionTextCondition.await();
+                    patentInstructionTextLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
     }
 
     /**
-     * 消费者5：将专利从队列取出，与专利关联数据入库
+     * 消费者5：将专利从队列取出，说明书pdf地址入库
      */
-    public void pushPatentAssoToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionPDFToDB() {
         while (true) {
+            QueueData queueData = new QueueData();
             try {
-                if (patentAssoQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("与专利关联的数据全部完成，退出循环");
-                        return;
-                    } else {
-                        patentAssoLock.lock();
-                        patentAssoCondition.await();
-                        patentAssoLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentAssoQueue.remove();
-                    //专题库与专利关联入库
-                    uploadPatentToDBService.uploadAssoThemaPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
-                    //自定义字段标引与专利关联入库
-                    uploadPatentToDBService.uploadAssoFieldPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
-                    //文件夹与专利关联入库
-                    uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
+                if (patentInstructionPDFQueueList.size() > 0) {
+                    queueData = patentInstructionPDFQueueList.remove(0);
+                    //说明书pdf入库
+                    patentInstructionService.edit(queueData.getUploadParamsVO().getPatent().getPatentNo(), queueData.getUploadParamsVO().getFileDTO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, patentIdMap.get(0), task);
+                    sendMessage(queueData);
+                } else {
+                    patentInstructionPDFLock.lock();
+                    patentInstructionPDFCondition.await();
+                    patentInstructionPDFLock.unlock();
                 }
 
             } catch (Exception e) {
                 e.printStackTrace();
+                sendMessage(queueData);
             }
 
         }
     }
 
-    public void sendMessage(QueueData queueData, Integer total, Task task) {
-        //每完成一个专利，通过计算，发送进度
+    /**
+     * 当一个消费者消费完其负责的专利部分，修改成功条数，计算发送进度
+     *
+     * @param queueData 任务专利队列对象
+     */
+    public void sendMessage(QueueData queueData) {
+        //每完成一个专利(根据计算该任务该专利的所有消费者都完成时)，发送进度
         synchronized ("此为同步锁") {
-            Integer currentPatentId = queueData.getUploadParamsVO().getPatent().getId();
-            Integer num = patentIdMap.get(currentPatentId);
+            //当前进行的任务
+            Task task = queueData.getTask();
+            //当前进行的任务的专利总数量
+            Integer total = task.getTotal();
+
+            //将任务id + "|" + 专利id，拼接成专利的标识（作为当前某一个消费者消费完的这个专利的数量标识）
+            String currentPatent = task.getId() + "|" + queueData.getUploadParamsVO().getPatent().getId();
+            Integer num = patentIdMap.get(currentPatent);
+            int needNum = 4;  //临界默认设为4（即Excel导入任务默认使用5个消费者）
+            if (task.getType().equals(3) || task.getType().equals(4)) {  //若是网站导入任务，则临界默认设为下载字段类型数量 - 1
+                needNum = task.getConfigCellsNum() - 1;
+            }
             if (num == null) {
-                patentIdMap.put(currentPatentId, 1);
-            } else if (num < 4) {
-                patentIdMap.put(currentPatentId, ++num);
+                patentIdMap.put(currentPatent, 1);
+            } else if (num < needNum) {
+                patentIdMap.put(currentPatent, ++num);
             } else {
-                //num达到3了就从patentIdMap中删除
-                patentIdMap.remove(currentPatentId);
-                patentFinishNum++;
-                long percentage = Math.round((patentFinishNum + 1D) / total * 100D);
+                /*
+                1）若是看当前任务，表示当前这个任务这个专利的4个消费者全都消费结束，即当前这个任务的这个专利已完成
+                2）若是看下一个任务，表示下一个任务的著录项目消费者终于第一次进来了（即表示上一个任务最慢的著录项目消费者也结束了即上一个任务完成了），就将这下一个任务的状态改为 1进行中
+                 */
+                if (task.getStatus() == 0) {
+                    task.setStatus(1);
+                    task.setStartTime(DateUtils.getDateTime());
+                    taskService.updateById(task);
+                }
+                patentIdMap.remove(currentPatent);
+                long percentage = Math.round((task.getSuccessNum() + 1D) / total * 100D);
+                //任务表更新数据（这里只更新成功条数和失败条数，注意不能更新状态等其他信息）
+                task.setSuccessNum(task.getSuccessNum() + 1);
+                task.setDefaultNum(total - task.getSuccessNum());
+                Task updateTask = new Task();
+                updateTask.setId(task.getId());
+                updateTask.setSuccessNum(task.getSuccessNum());
+                updateTask.setDefaultNum(total - task.getSuccessNum());
+                taskService.updateById(updateTask);
+
                 //当全部完成时
-                if (patentFinishNum.equals(total)) {
+                if (task.getSuccessNum().equals(total)) {
                     percentage = 100L;
-                    //任务表更新状态为成功
+                    //设置任务状态为成功
                     task.setStatus(2);
+                    //设置任务结束时间为当前时间
+                    task.setEndTime(DateUtils.getDateTime());
                     taskService.updateById(task);
                 }
-                messageService.sendWebsocketMessage(task, total, patentFinishNum, percentage);
-                //任务表更新数据
-                task.setSuccessNum(patentFinishNum);
-                task.setDefaultNum(total - task.getSuccessNum());
-                taskService.updateById(task);
+
+                messageService.sendWebsocketMessage(task, total, task.getSuccessNum(), percentage);
+
             }
         }
     }
 
-    public void patentToQueue(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+    /**
+     * 数据丢入摘要附图生产队列并唤醒装载摘要附图线程
+     *
+     * @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 专利实体类对象
+     */
+    public void patentToQueue(Task task, UploadParamsVO uploadParamsVO) {
         //保存专利基础数据（专利表"os_patent"）
         uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
-        //专利分别加入5个消费者队列
+
         QueueData queueData = new QueueData()
-                .setUploadParamsVO(uploadParamsVO)
-                .setProjectImportPatentVO(projectImportPatentVO);
-        patentImageQueue.add(queueData);
-        patentZhuluQueue.add(queueData);
-        patentRightQueue.add(queueData);
-        patentInstructionTextQueue.add(queueData);
-        patentAssoQueue.add(queueData);
-
-        //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、与专利关联数据）
-        //消费者1摘要附图
+                .setTask(task)
+                .setUploadParamsVO(uploadParamsVO);
+
+        //专利分别加入5个消费者队列
+        patentImageQueueList.add(queueData);
+        patentZhuluQueueList.add(queueData);
+        patentRightQueueList.add(queueData);
+        patentInstructionTextQueueList.add(queueData);
+        patentInstructionPDFQueueList.add(queueData);
+
+        //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、说明书pdf）
+        //1.摘要附图
         patentImageLock.lock();
         patentImageCondition.signalAll();
         patentImageLock.unlock();
-        //消费者2著录项目
+        //2.著录项目
         patentZhuluLock.lock();
         patentZhuluCondition.signalAll();
         patentZhuluLock.unlock();
-        //消费者3权利要求文本
+        //3.权利要求文本
         patentRightLock.lock();
         patentRightCondition.signalAll();
         patentRightLock.unlock();
-        //消费者4说明书文本
+        //4.说明书文本
         patentInstructionTextLock.lock();
         patentInstructionTextCondition.signalAll();
         patentInstructionTextLock.unlock();
-        //消费者5与专利关联数据
-        patentAssoLock.lock();
-        patentAssoCondition.signalAll();
-        patentAssoLock.unlock();
+        //5.说明书pdf
+        patentInstructionPDFLock.lock();
+        patentInstructionPDFCondition.signalAll();
+        patentInstructionPDFLock.unlock();
+
     }
 
-    public void queueAddTask(List<Integer> taskQueueList) {
+    /**
+     * 生产者任务队列新增任务ids
+     *
+     * @param taskQueueList 生产者任务队列
+     */
+    public void taskQueueAddTask(List<Integer> taskQueueList) {
         this.taskQueueList.addAll(taskQueueList);
     }
 
+    /**
+     * 消费者专利队列剔除指定任务的所有专利
+     *
+     * @param taskId 任务id
+     */
+    public void consumerQueueDeleteTasks(Integer taskId) {
+        //任务暂停时清除4个消费者专利队列中该任务的专利
+        this.patentImageQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentZhuluQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentRightQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentInstructionTextQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentInstructionPDFQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        //任务暂停时清除 patentIdMap（任务id + "|" + 专利id，拼接而成的专利的数量标识（作为当前某一个消费者消费完的这个专利的数量标识））中该任务的专利的数量标识
+        Iterator<String> iterator = this.patentIdMap.keySet().iterator();
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            if (key.contains(taskId + "")) {
+                iterator.remove();
+                this.patentIdMap.remove(key);
+            }
+        }
+
+    }
+
+    /**
+     * 唤醒生产者线程
+     */
     public void awakeTasktch() {
         taskLock.lock();
         taskCondition.signalAll();
@@ -318,4 +684,26 @@ public class PantentQueueService {
 
     }
 
+    /**
+     * 工厂方法，根据任务类型返回对应的生产专利数据的对象
+     *
+     * @param task 任务
+     * @return 返回获取专利数据的对象
+     */
+    private IExcutePatentData createObject(Task task) {
+        //根据任务的类型创建并返回对应的解析获取专利数据的对象
+        switch (task.getType()) {
+            case 1:  //Excel导入专利
+                return excutePatentDataExcel;
+            case 3:  //欧专局网站导入
+                return excutePatentDataEpo;
+            case 4:  //专利之星网站导入
+                return excutePatentDataStar;
+            default:
+                return null;
+        }
+
+    }
+
+
 }

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

@@ -1,34 +0,0 @@
-package cn.cslg.pas.service.upLoadPatent;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.quartz.DisallowConcurrentExecution;
-import org.quartz.JobExecutionContext;
-import org.quartz.JobExecutionException;
-import org.springframework.scheduling.quartz.QuartzJobBean;
-
-/**
- * 调度任务类
- */
-@Slf4j
-@DisallowConcurrentExecution
-@RequiredArgsConstructor
-public class PatentToDbTaskJob extends QuartzJobBean {
-
-    @Override
-    public void executeInternal(JobExecutionContext context) throws JobExecutionException {
-        //0.检查全部任务情况
-
-
-        //1.获得任务信息（检查进行中的任务，执行等待中的任务）
-
-
-        //2.根据不同的任务类型，选择不同方法上传任务
-        //2.1 Excel导入专利任务
-        //excuteTaskService.executeExcelTask();
-
-        //2.2 网站导入专利任务
-
-    }
-
-}

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

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

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

@@ -0,0 +1,52 @@
+package cn.cslg.pas.service.upLoadPatent;
+
+import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
+import cn.cslg.pas.service.TaskService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 定义任务
+ */
+@RequiredArgsConstructor
+@DisallowConcurrentExecution
+public class TaskAddJob extends QuartzJobBean {
+
+    private static final Log logger = LogFactory.getLog(TaskAddJob.class);
+    private boolean flag = true;
+    private final PantentQueueService pantentQueueService;
+    private final TaskService taskService;
+
+    @Override
+    public void executeInternal(JobExecutionContext context) throws JobExecutionException {
+        JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = (AssoOsTaskQrtzTask) jobDataMap.get("assoOsTaskQrtzTask");
+        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()));
+        pantentQueueService.awakeTasktch();
+        logger.info("添加任务" + "信息是" + task);
+    }
+
+}

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

@@ -3,29 +3,15 @@ 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.common.model.vo.UploadSettingVO;
-import cn.cslg.pas.common.utils.DateUtils;
-import cn.cslg.pas.common.utils.FileUtils;
-import cn.cslg.pas.common.utils.ReadExcelUtils;
-import cn.cslg.pas.common.utils.UploadPatentBatchUtil;
-import cn.cslg.pas.domain.PatentData;
+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.hutool.core.util.IdUtil;
+import cn.cslg.pas.service.*;
 import lombok.RequiredArgsConstructor;
-import org.apache.poi.ss.usermodel.PictureData;
 import org.springframework.stereotype.Service;
 
-import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * 保存专利及所有与之关联数据入库
@@ -40,38 +26,39 @@ 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 uploadLegalStatus(UploadParamsVO uploadParamsVO) {
-//        //保存法律状态（专利表"os_patent"）
-//        if (uploadParamsVO.getPatent() != null) {
-//            List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Collections.singletonList(Constants.PATENT_SIMPLE_STATUS));
-//            Integer simpleStatus = Integer.parseInt(systemDictList.stream()
-//                    .filter(systemDict -> systemDict.getType().equals(Constants.PATENT_SIMPLE_STATUS) && systemDict.getLabel().equals(uploadParamsVO.getPatentSimpleStatus()))
-//                    .findFirst()
-//                    .orElse(new SystemDict()).getValue());
-//            uploadParamsVO.getPatent().setSimpleStatus(simpleStatus);
-//            uploadParamsVO.getPatent().updateById();
-//        }
-//    }
+    /**
+     * 摘要附图入库（网站导入方式）
+     *
+     * @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());
+            }
+        }
+    }
 
     /**
      * 著录项目
@@ -94,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);
             }
         }
 
@@ -128,7 +120,9 @@ public class UploadPatentToDBService {
         uploadPatentBatchService.patentTypeNoBusiness(uploadParamsVO);
 
         //保存事务信息（表"os_patent_affair"）
-        uploadPatentBatchService.patentAffairBusiness(uploadParamsVO);
+        if (uploadParamsVO.getPatentAffair() != null) {
+            uploadPatentBatchService.patentAffairBusiness(uploadParamsVO);
+        }
     }
 
     /**
@@ -156,13 +150,13 @@ public class UploadPatentToDBService {
     /**
      * 专题库与专利关联
      *
-     * @param uploadParamsVO        专利内容
-     * @param projectImportPatentVO 专题库关联专利内容（专题库id、专利id）
+     * @param uploadParamsVO 专利内容
+     * @param projectId      专题库id
      */
-    public void uploadAssoThemaPat(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+    public void uploadAssoThemaPat(UploadParamsVO uploadParamsVO, Integer projectId) {
         //保存专题库与专利关联（表"os_thematic_pid"）
-        if (uploadParamsVO.getPatent() != null && projectImportPatentVO != null) {
-            uploadPatentBatchService.patentThematicPidBusiness(uploadParamsVO, projectImportPatentVO);
+        if (uploadParamsVO.getPatent() != null && projectId != null) {
+            uploadPatentBatchService.patentThematicPidBusiness(uploadParamsVO, projectId);
         }
     }
 

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

@@ -1,27 +1,28 @@
 package cn.cslg.pas.service.upLoadPatent;
 
+import cn.cslg.pas.common.model.PersonnelVO;
 import cn.cslg.pas.common.model.dto.QrtzTaskAddNewDTO;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
-import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
+import cn.cslg.pas.common.model.outApi.PatentStarListDto;
+import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.ReadExcelUtils;
+import cn.cslg.pas.common.utils.SecurityUtils.LoginUtils;
 import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.SerachBiblioData;
+import cn.cslg.pas.domain.WebLoginConfig;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
-import cn.cslg.pas.exception.XiaoShiException;
-import cn.cslg.pas.service.IAssoOsTaskQrtzTaskService;
 import cn.cslg.pas.service.TaskService;
+import cn.cslg.pas.service.WebLoginConfigService;
 import cn.cslg.pas.service.asso.AssoOsTaskQrtzTaskService;
-import cn.hutool.core.collection.IterUtil;
-import cn.hutool.poi.excel.ExcelUtil;
+import 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;
 
-import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -32,6 +33,7 @@ import java.util.Map;
  * @Author 李仁杰
  * 导入任务类
  */
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class UploadTaskService {
@@ -39,7 +41,11 @@ public class UploadTaskService {
     private final TaskService taskService;
     private final PantentQueueService pantentQueueService;
     private final AssoOsTaskQrtzTaskService assoOsTaskQrtzTaskService;
-    private final ExcuteTaskToPatentService excuteTaskToPatentService;
+    private final ExcutePatentDataEpo excutePatentDataEpo;
+    private final CacheUtils cacheUtils;
+    private final LoginUtils loginUtils;
+    private final WebLoginConfigService webLoginConfigService;
+    private final PatentStarApiService patentStarApiService;
 
     /**
      * 新增Excel导入任务
@@ -57,7 +63,7 @@ public class UploadTaskService {
         //新增任务（专利导入导出任务表）
         Integer taskId = taskService.addTask2(fileDTO, total, json);
         //任务存入生产者任务队列并唤醒生产者线程
-        pantentQueueService.queueAddTask(Arrays.asList(taskId));
+        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
     }
 
@@ -66,26 +72,31 @@ public class UploadTaskService {
      *
      * @param qrtzTaskAddNewDTO 前台参数（检索信息conditions、专题库id、下载字段configCells等）
      */
-    public void addEpoTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+    public AssoOsTaskQrtzTask addEpoTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+        Integer webId = qrtzTaskAddNewDTO.getConfigId();
+        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+        //根据网站id获得配置
+        WebLoginConfig webLoginConfig = webLoginConfigService.getLoginConfig(webId, personnelVO.getTenantId());
+        if (webLoginConfig == null) {
+            ThrowException.throwXiaoShiException("未配置网站登录信息");
+        }
+
         //检查任务合法性（检查当前检索式能否检索出专利）
-        //先根据检索式conditions检索一件专利著录信息
-        SerachBiblioData serachBiblioData = excuteTaskToPatentService.getSerachBiblioData(qrtzTaskAddNewDTO.getConditions(), 1, 1);
+        //根据检索式conditions检索一件专利著录信息
+        SerachBiblioData serachBiblioData = excutePatentDataEpo.getSerachBiblioData(qrtzTaskAddNewDTO.getConditions(), 1, 1);
         if (serachBiblioData == null || serachBiblioData.getTotals() == 0) {
-            ThrowException.throwXiaoShiException("检索失败，根据检索条件未检索出任何相关专利信息");
-            return;
+            ThrowException.throwXiaoShiException("根据检索信息未检索到相关专利，请尝试更换检索信息");
         }
 
-        //新增任务
-        Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, serachBiblioData.getTotals());
-        //新增任务与网站导入任务关联表数据
+        //任务与任务条件关联表新增数据
         AssoOsTaskQrtzTask assoOsTaskQrtzTask = new AssoOsTaskQrtzTask();
         assoOsTaskQrtzTask
-                .setTaskId(taskId)
-                .setTaskType(0)
+                .setTaskType(qrtzTaskAddNewDTO.getTaskType())
                 .setConditions(qrtzTaskAddNewDTO.getConditions())
                 .setCrons(qrtzTaskAddNewDTO.getCrons())
                 .setConfigId(qrtzTaskAddNewDTO.getConfigId())
-                .setTaskName(qrtzTaskAddNewDTO.getTaskName());
+                .setTaskName(qrtzTaskAddNewDTO.getTaskName())
+                .setTotal(serachBiblioData.getTotals());
         List<String> cells = qrtzTaskAddNewDTO.getConfigCells();
         if (cells == null) {
             assoOsTaskQrtzTask.setConfigCells("");
@@ -94,17 +105,92 @@ public class UploadTaskService {
         }
         assoOsTaskQrtzTaskService.save(assoOsTaskQrtzTask);
 
+        //任务表新增任务
+        Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, serachBiblioData.getTotals(), assoOsTaskQrtzTask);
+
+        //任务与任务条件关联表更新数据
+        assoOsTaskQrtzTask.setTaskId(taskId);
+        assoOsTaskQrtzTaskService.updateById(assoOsTaskQrtzTask);
+
         //任务存入生产者任务队列并唤醒生产者线程
-        pantentQueueService.queueAddTask(Arrays.asList(taskId));
+        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
         pantentQueueService.awakeTasktch();
+
+        return assoOsTaskQrtzTask;
     }
 
-    public void pauseTask() {
+    /**
+     * 新增专利之星导入任务
+     *
+     * @param qrtzTaskAddNewDTO 前台参数（检索信息conditions、专题库id、下载字段configCells等）
+     */
+    public AssoOsTaskQrtzTask addPatentStarTask(QrtzTaskAddNewDTO qrtzTaskAddNewDTO) throws IOException {
+        Integer webId = qrtzTaskAddNewDTO.getConfigId();  //取出网站id
 
-    }
+        //检查任务合法性1（根据网站配置id和登陆人所属租户id，看是否有网站导入任务的权限）
+        PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());  //获取登陆人信息
+        WebLoginConfig webLoginConfig = webLoginConfigService.getLoginConfig(webId, personnelVO.getTenantId());  //根据网站id获得配置
+        if (webLoginConfig == null) {
+            ThrowException.throwXiaoShiException("未配置网站登录信息");
+        }
 
-    public void deleteTask() {
-    }
+        //检查任务合法性2（根据检索式信息调用一般检索接口，看是否能检索出专利）
+        PatentStarListDto patentStarListDto = new PatentStarListDto()
+                .setCurrentQuery(qrtzTaskAddNewDTO.getConditions())
+                .setOrderBy(qrtzTaskAddNewDTO.getOrderBy())
+                .setOrderByType(qrtzTaskAddNewDTO.getOrderByType())
+                .setPageNum(1)
+                .setRowCount(10)
+                .setDBType(qrtzTaskAddNewDTO.getDBType());
+        Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
+        if (resultMap == null || (Integer) resultMap.get("total") == 0) {
+            ThrowException.throwXiaoShiException("未检索到相关专利，请尝试更改检索式或检索条件信息");
+        }
+
+        //获取专利总数量
+        Integer total = (Integer) resultMap.get("total");
+
+        //新增任务与任务条件关联表（"asso_osTask_qrtzTask"）数据
+        AssoOsTaskQrtzTask assoOsTaskQrtzTask = new AssoOsTaskQrtzTask();
+        assoOsTaskQrtzTask
+                .setTaskName(qrtzTaskAddNewDTO.getTaskName())
+                .setTaskType(qrtzTaskAddNewDTO.getTaskType())
+                .setTaskType2(qrtzTaskAddNewDTO.getTaskType2())
+                .setConditions(qrtzTaskAddNewDTO.getConditions())
+                .setCrons(qrtzTaskAddNewDTO.getCrons())
+                .setConfigId(qrtzTaskAddNewDTO.getConfigId())
+                .setTaskName(qrtzTaskAddNewDTO.getTaskName())
+                .setTotal(total)
+                .setOrderBy(qrtzTaskAddNewDTO.getOrderBy())
+                .setOrderByType(qrtzTaskAddNewDTO.getOrderByType())
+                .setDBType(qrtzTaskAddNewDTO.getDBType())
+                .setStartNumber(qrtzTaskAddNewDTO.getStartNumber())
+                .setEndNumber(qrtzTaskAddNewDTO.getEndNumber())
+                .setIsAddPatentNos(qrtzTaskAddNewDTO.getIsAddPatentNos())
+                .setIsDeletePatentNos(qrtzTaskAddNewDTO.getIsDeletePatentNos());
+        List<String> cells = qrtzTaskAddNewDTO.getConfigCells();
+        if (cells == null) {
+            assoOsTaskQrtzTask.setConfigCells("");
+        } else {
+            assoOsTaskQrtzTask.setConfigCells(String.join(",", cells));
+        }
+        log.info("任务与任务条件关联表（asso_osTask_qrtzTask）新增数据");
+        assoOsTaskQrtzTaskService.save(assoOsTaskQrtzTask);
+
+        //任务表新增任务
+        Integer taskId = taskService.addTask3(qrtzTaskAddNewDTO, total, assoOsTaskQrtzTask);
+
+        //任务与任务条件关联表（asso_osTask_qrtzTask）更新数据（普通任务）
+        if (qrtzTaskAddNewDTO.getTaskType().equals(0)) {
+            assoOsTaskQrtzTask.setTaskId(taskId);
+            assoOsTaskQrtzTaskService.updateById(assoOsTaskQrtzTask);
+        }
 
+        //任务存入生产者任务队列并唤醒生产者线程
+        pantentQueueService.taskQueueAddTask(Arrays.asList(taskId));
+        pantentQueueService.awakeTasktch();
+
+        return assoOsTaskQrtzTask;
+    }
 
 }

PAS/src/main/resources/application-dev.yml

@@ -59,4 +59,5 @@ authorUrl: http://localhost:8871
 PCSUrl: http://localhost:8871
 #OPSUrl: http://192.168.1.24:5001
 OPSUrl: http://139.224.24.90:5001
-PASUrl: http://localhost:8877
+PASUrl: http://localhost:8877
+RMSUrl: http://localhost:8872

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

@@ -388,9 +388,7 @@
                     </where>
                     )
                 </foreach>
-
             </if>
-
         </where>
         group by a.id
         order by

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

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="cn.cslg.pas.mapper.WebLoginConfigMapper">
+    <select id="getPageList" parameterType="cn.cslg.pas.common.model.vo.QueryConfigVO"
+            resultType="cn.cslg.pas.common.model.vo.ConfigVO">
+        select web_name as webName,web_address as webAddress ,login_account as loginAccount ,login_password as
+        loginPassword,b.id as id
+        ,a.id as webId
+        from web_config a
+        left join web_login_config b
+        on a.id=b.web_id
+        <where>
+            b.tenant_id=#{params.tenantId}
+            <if test="params.webId !=null">
+                and a.id =#{params.webId}
+            </if>
+            <if test="params.loginAccount!=null and params.loginAccount!='' ">
+                and b.login_account like concat('%',#{params.loginAccount}, '%')
+            </if>
+        </where>
+    </select>
+</mapper>

PAS/src/test/java/cn/cslg/pas/domain/FileSource.java

@@ -0,0 +1,38 @@
+package cn.cslg.pas.domain;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * @author 沈永艺
+ * @date 2022-8-12
+ * @description 数据权限类 数据库对应实体
+ */
+
+@Data
+@Accessors(chain = true)
+
+public class FileSource  {
+    /**
+     * 数据字典名字
+     */
+    private String patentNo;
+
+    /**
+     * 数据字典描述
+     */
+    private String pic;
+
+    /**
+     * 数据字典数据库
+     */
+    private String type;
+
+    /**
+     * 数据字典表格
+     */
+    private String url;
+
+
+}