11

pom.xml

@@ -219,6 +219,16 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
         </dependency>
+        <dependency>
+            <groupId>dom4j</groupId>
+            <artifactId>dom4j</artifactId>
+            <version>1.6.1</version>
+        </dependency>
+        <dependency>
+            <groupId>jaxen</groupId>
+            <artifactId>jaxen</artifactId>
+            <version>1.2.0</version> <!-- 使用你需要的版本 -->
+        </dependency>
     </dependencies>
 
 

src/main/java/cn/cslg/pas/common/core/IgnoreDTDEntityResolver.java

@@ -0,0 +1,21 @@
+package cn.cslg.pas.common.core;
+
+
+
+
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+public class IgnoreDTDEntityResolver implements EntityResolver {
+
+ @Override
+ public InputSource resolveEntity(String publicId, String systemId)
+   throws SAXException, IOException {
+        return new InputSource(new ByteArrayInputStream("<?xml version='1.0' encoding='UTF-8'?>".getBytes()));
+ }
+
+}

src/main/java/cn/cslg/pas/common/dto/UploadPatentWebDTO.java

@@ -0,0 +1,13 @@
+package cn.cslg.pas.common.dto;
+
+import cn.cslg.pas.common.vo.StarPatentVO;
+import cn.cslg.pas.common.vo.UploadParamsVO;
+import cn.cslg.pas.domain.es.Patent;
+import lombok.Data;
+
+@Data
+public class UploadPatentWebDTO {
+    private StarPatentVO starPatentVO;
+    private Patent patent;
+    private Integer counter;
+}

src/main/java/cn/cslg/pas/common/model/importTaskModel/PatentRight.java

@@ -17,10 +17,10 @@ public class PatentRight  {
     /**
      * 权利要求原文
      */
-    private String content;
+    private String name;
     /**
      * 权利要求译文
      */
-    private String contentOut;
+    private String nameOut;
 
 }

src/main/java/cn/cslg/pas/common/vo/ImportTaskAMVO.java

@@ -74,4 +74,6 @@ public class ImportTaskAMVO {
     private  String orderByType;
     private String dBType;
     private Integer doneNum;
+
+    private ProgressVO progressVO;
 }

src/main/java/cn/cslg/pas/common/vo/ProgressVO.java

@@ -0,0 +1,21 @@
+package cn.cslg.pas.common.vo;
+
+import cn.cslg.pas.common.model.importTaskModel.PatentAgent;
+import cn.cslg.pas.common.model.importTaskModel.PatentApplicant;
+import cn.cslg.pas.common.model.importTaskModel.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 ProgressVO implements Serializable {
+    /**
+     * 专利类型（0）
+     */
+    @JSONField(name = "PT")
+    private Integer state;
+}

src/main/java/cn/cslg/pas/common/vo/StarPatentVO.java

@@ -142,4 +142,6 @@ public class StarPatentVO implements Serializable {
      * 摘要附图路径
      */
     private String abstractPath;
+
+    private Integer counter;
 }

src/main/java/cn/cslg/pas/factorys/businessFactory/BusinessFactory.java

@@ -13,7 +13,6 @@ public class BusinessFactory {
 
     public Business getClass(String shapeType) {
         Business bean1 = businessMap.get(shapeType);
-
         return bean1;
     }
 }

src/main/java/cn/cslg/pas/factorys/getSqlFactorys/GetLikeSql.java

@@ -19,7 +19,6 @@ public class GetLikeSql implements GetSqlObject{
       if(option.equals("=")){
           re= filed+" like '%"+value+"%'";
       }
-
        return re;
     }
 

src/main/java/cn/cslg/pas/service/business/es/EsService.java

@@ -2,10 +2,12 @@ package cn.cslg.pas.service.business.es;
 
 import cn.cslg.pas.common.vo.PatentWithIdVO;
 import cn.cslg.pas.domain.es.Patent;
+import cn.cslg.pas.service.query.Query;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import co.elastic.clients.elasticsearch._types.SortOrder;
 import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
 import co.elastic.clients.elasticsearch._types.query_dsl.HasChildQuery;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import co.elastic.clients.elasticsearch.core.*;
 import co.elastic.clients.elasticsearch.core.search.Hit;
 import lombok.RequiredArgsConstructor;
@@ -114,9 +116,9 @@ public class EsService {
         }
 
         //排序
-        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
-                .field(fieldSortBuilder -> fieldSortBuilder
-                        .field("createTime").order(SortOrder.Desc)));
+//        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
+//                .field(fieldSortBuilder -> fieldSortBuilder
+//                        .field("createTime").order(SortOrder.Desc)));
         SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
         List<Patent> list = new ArrayList<>();
         List<Hit<Patent>> hits = response.hits().hits();

src/main/java/cn/cslg/pas/service/importPatent/GetCataloguingFromWebThread.java

@@ -0,0 +1,65 @@
+package cn.cslg.pas.service.importPatent;
+
+import cn.cslg.pas.common.model.cronModel.SystemFile;
+import cn.cslg.pas.common.utils.ReadExcelUtils;
+import cn.cslg.pas.common.vo.ImportTaskAMVO;
+import cn.cslg.pas.common.vo.PatentData;
+import cn.cslg.pas.common.vo.UploadParamsVO;
+import cn.cslg.pas.common.vo.UploadSettingVO;
+import cn.cslg.pas.domain.es.Patent;
+import cn.cslg.pas.domain.es.Text;
+import cn.cslg.pas.service.common.ExcuteDataToVOService;
+import cn.cslg.pas.service.common.ExcuteUploadSettingService;
+import cn.cslg.pas.service.common.FileManagerService;
+import com.alibaba.fastjson.JSONArray;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.springframework.beans.factory.annotation.Configurable;
+import org.springframework.context.ApplicationContext;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Configurable
+public class GetCataloguingFromWebThread extends Thread {
+
+    private ImportTaskAMVO importTaskAMVO;
+    private ApplicationContext applicationContext;
+    private SavePatentToEsThread savePatentToEsThread;
+    @Override
+    public void run() {
+        try {
+
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public GetCataloguingFromWebThread(TaskThread taskThread, SavePatentToEsThread savePatentToEsThread) {
+        this.importTaskAMVO =taskThread.getImportTaskAMVO();
+        this.savePatentToEsThread = savePatentToEsThread;
+        this.applicationContext = taskThread.getApplicationContext();
+    }
+//    public void awakeTask(Patent patent) {
+//        patents.add(patent);
+//        if (taskLock.tryLock()) {
+//            taskCondition.signalAll();
+//            taskLock.unlock();
+//        }
+//    }
+        //如果是中国专利，就将申请号作为专利号
+//        if (patent.getPatentNo().contains("CN")) {
+//            patent.setPatentNo(patent.getAppNo());  //将申请号设为专利号patentNo
+//        }
+
+
+        //装载权利要求
+
+
+}

src/main/java/cn/cslg/pas/service/importPatent/GetPatentFromExcelThread.java

@@ -61,6 +61,11 @@ public class GetPatentFromExcelThread extends Thread {
             Sheet sheet = ReadExcelUtils.readExcel(tempFile);
             //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
             for (int i = lastIndex; i < total; i++) {
+                if(importTaskAMVO.getProgressVO().getState().equals(1)){
+                    System.out.println(importTaskAMVO.getId());
+                    break;
+                }
+                Thread.sleep(10000);
                 PatentData patentData = ReadExcelUtils.readExcelOneRow(tempFile, sheet, i + 1);
                 //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
                 UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
@@ -111,7 +116,7 @@ public class GetPatentFromExcelThread extends Thread {
 
         }
 
-        //装载
+        //装载摘要
         if (uploadParamsVO.getAbstractStr() != null) {
             List<Text> texts = new ArrayList<>();
             if (uploadParamsVO.getAbstractStr().getName() != null) {
@@ -132,11 +137,30 @@ public class GetPatentFromExcelThread extends Thread {
                 patent.setAbstractStr(texts);
             }
         }
+
+        //装载权利要求
+        if (uploadParamsVO.getPatentRight() != null) {
+            List<Text> texts = new ArrayList<>();
+            if (uploadParamsVO.getPatentRight().getName() != null) {
+                Text text = new Text();
+                text.setTextContent(uploadParamsVO.getPatentRight().getName());
+                text.setIfOrigin(true);
+                text.setLanguage(contry);
+                texts.add(text);
+            }
+            if (uploadParamsVO.getPatentRight().getNameOut() != null) {
+                Text text = new Text();
+                text.setTextContent(uploadParamsVO.getPatentRight().getNameOut());
+                text.setIfOrigin(false);
+                text.setLanguage("CN");
+                texts.add(text);
+            }
+            if (texts.size() != 0) {
+                patent.setClaim(texts);
+            }
         }
-        //如果是中国专利，就将申请号作为专利号
-//        if (patent.getPatentNo().contains("CN")) {
-//            patent.setPatentNo(patent.getAppNo());  //将申请号设为专利号patentNo
-//        }
+        }
+
 
 
         //装载权利要求

src/main/java/cn/cslg/pas/service/importPatent/ImportFromWebToEsService.java

@@ -1,6 +1,7 @@
 package cn.cslg.pas.service.importPatent;
 
 import cn.cslg.pas.common.dto.PatentStarListDTO;
+import cn.cslg.pas.common.dto.UploadPatentWebDTO;
 import cn.cslg.pas.common.model.cronModel.Calculate;
 import cn.cslg.pas.common.utils.DateUtils;
 import cn.cslg.pas.common.utils.MathUtils;
@@ -24,139 +25,41 @@ import java.util.Map;
 @Scope("prototype")
 @Service
 public class ImportFromWebToEsService implements PatentImportImp {
+
     private TaskThread taskThread;
+    @Autowired
     private PatentStarApiService patentStarApiService;
 
     @Override
     public void startPatentThread() {
         ImportTaskAMVO importTaskAMVO = new ImportTaskAMVO();
+        //十进制转二进制
+        String imContents = MathUtils.fun(2, importTaskAMVO.getImportContent());
+        //下载字段
+        char[] importCells = imContents.toCharArray();
+        char ifCataloguing = importCells[0];
+        char ifAddPicture =  importCells[1];
+        char ifClaim = importCells[2];
+        char ifFullText =importCells[3];
+        char ifPdf =importCells[4];
         //若本次下载任务是超过一万条专利的全部下载任务
         int patentNum = 10000;
         if (importTaskAMVO.getEndNum() <= patentNum) {
-//            excuteLessThan10000(task);
+            excuteLessThan10000(importTaskAMVO);
         } else {
-            //                Integer total = importTaskAMVO.getAllNum();  //任务专利总数量
-//                Integer successNum = importTaskAMVO.getSuccessNum();
-//                String orderBy = importTaskAMVO.getOrderBy();  //排序字段
-//                String orderByType = importTaskAMVO.getOrderByType();  //排序类型
-//                String dbType = importTaskAMVO.getDBType();  //检索数据库类型
-//                List<String> cells = importTaskAMVO.getConfigCells();  //下载字段
-//                Integer startNumber = importTaskAMVO.getStartNumber();  //下载起始条数位置
-//                List<String> isDeletePatentNos = task.getIsDeletePatentNos();  //起止条数中不需要下载的专利号
-//
-//                //如果完成数量大于0，则当前下载任务为暂停后的继续下载，则开始位置更新
-//                if (successNum > 0) {
-//                    startNumber += successNum;
-//                }
-//
-//                //获得返回的的多个检索式 patentStarListDtos
-//                List<PatentStarListDto> patentStarListDtos = patentStarApiService.getSplitedConditions(new PatentStarListDto()
-//                        .setCurrentQuery(task.getConditions())
-//                        .setOrderBy(orderBy)
-//                        .setOrderByType(orderByType)
-//                        .setDBType(dbType), patentNum);
-//
-//                int produceSuccessNum = 0;
-//                int countForStart = 0;  //定义变量countForStart，记录检索式的专利总数量（目的是找出下载开始位置专利所属的那个检索式）
-//                //第1层：遍历多个检索式
-//                for (PatentStarListDto patentStarListDto : patentStarListDtos) {
-//                    //还没有到开始位置，则跳过，继续判断下一个检索式
-//                    countForStart += patentStarListDto.getTotal();
-//                    if (countForStart < startNumber) {
-//                        continue;
-//                    }
-//
-//
-//                    //至此，即找到了当前检索式即为要下载的专利开始位置所属的检索式，重新计算开始位置startNumber（即要下载的专利的开始位置，对应了当前检索式中该专利位置）
-//                    startNumber = startNumber - (countForStart - patentStarListDto.getTotal());
-//                    //第一个检索式下载完成后，从第二个检索式开始 startNumber都是从1开始下载
-//                    if (startNumber < 0) {
-//                        startNumber = 1;
-//                    }
-//                    //调用方法，入参为开始位置和结束位置（即当前检索式最后一个专利的位置，即当前检索式的专利总数量total），获得开始页数、结束页数、开始页数的开始位置、结束页数的结束位置
-//                    Calculate calculate = calculateFromStartAndEndNumber(startNumber, patentStarListDto.getTotal());
-//                    Integer startPage = calculate.getStartPage();
-//                    Integer startNum = calculate.getStartNum();
-//                    Integer endPage = calculate.getEndPage();
-//
-//                    //第2层：遍历检索页数
-//                    for (Integer i = startPage; i <= endPage; i++) {
-//                        //调用一般检索接口，返回一批专利著录相关数据
-//                        patentStarListDto
-//                                .setPageNum(i)
-//                                .setRowCount(50)
-//                                .setFormed(true);
-//                        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");
-//                        //第3层：遍历专利
-//                        for (int j = 0; j < starPatents.size(); j++) {
-//                            //若任务状态为已暂停，则结束本次任务的下载
-//                            if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
-//                                return;
-//                            }
-//                            //若生产的数量达到了总数，则结束本次任务的下载
-//                            if (produceSuccessNum == total) {
-//                                return;
-//                            }
-//                            //如果还没到要下载的专利的开始位置，则跳过，继续判断下一个专利
-//                            if (i.equals(startPage) && j < startNum - 1) {
-//                                continue;
-//                            }
-//                            //如果当前遍历到的专利号是需要删除的专利，则跳过，不下载它
-//                            if (isDeletePatentNos != null && isDeletePatentNos.size() > 0 && isDeletePatentNos.contains(starPatents.get(j).getApplicationNo())) {
-//                                continue;
-//                            }
-//
-//                            //将专利丢入各生产线程，进行生产和消费
-//                            UploadParamsVO uploadParamsVO = new UploadParamsVO();
-//                            uploadParamsVO.setPatent(new Patent());
-//                            uploadParamsVO.getPatent().setPatentNo(starPatents.get(j).getPatentNo());
-//                            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生产者队列，并唤醒说明书pdf生产者线程
-//                            if (cells.contains("4")) {
-//                                pantentQueueService.instructionPDFToPQueue(pQueueData);
-//                            }
-//                            //专利丢入摘要附图生产者队列，并唤醒摘要附图生产者线程
-//                            if (cells.contains("6")) {
-//                                pantentQueueService.imageToPQueue(pQueueData);
-//                            }
-//
-//                            produceSuccessNum++;  //计数，每生产完一个，生产完成数量++
-//
-//                        }
-//                    }
-//
-//                }
-
         }
         SavePatentToEsThread savePatentToEsThread = new SavePatentToEsThread(taskThread, taskThread.getApplicationContext());
+        if(ifCataloguing==1){
+            GetCataloguingFromWebThread getCataloguingFromWebThread =new GetCataloguingFromWebThread(taskThread,savePatentToEsThread);
+                getCataloguingFromWebThread.start();
+        }
+
         GetPatentFromExcelThread getPatentFromExcelThread = new GetPatentFromExcelThread(taskThread.getImportTaskAMVO(), savePatentToEsThread, taskThread.getApplicationContext());
         savePatentToEsThread.start();
         getPatentFromExcelThread.start();
     }
 
+
     private void excuteLessThan10000(ImportTaskAMVO importTaskAMVO) {
         try {
             Integer successNum = importTaskAMVO.getSuccessNum();  //成功条数（即上一次下载到的位置）
@@ -165,42 +68,44 @@ public class ImportFromWebToEsService implements PatentImportImp {
             String orderByType = importTaskAMVO.getOrderByType();  //排序类型
             String dbType = importTaskAMVO.getDBType();  //检索数据库类型
             Integer importContent = importTaskAMVO.getImportContent();  //下载字段
-            Integer doneNum =importTaskAMVO.getDoneNum();
+            Integer doneNum = importTaskAMVO.getDoneNum();
             //十进制转二进制
             String imContents = MathUtils.fun(2, importContent);
             //下载字段
             char[] importCells = imContents.toCharArray();
-            Calculate calculate = DateUtils.calculateFromStartAndEndNumber(doneNum, importTaskAMVO.getAllNum(),50);
+            Calculate calculate = DateUtils.calculateFromStartAndEndNumber(doneNum, importTaskAMVO.getAllNum(), 50);
             Integer startPage = calculate.getStartPage();
             Integer startNum = calculate.getStartNum();
             Integer endPage = calculate.getEndPage();
 
 
-                //根据计算出的起止页数，一页一页检索
-                for (int i = startPage; i <= endPage; i++) {
-                    PatentStarListDTO patentStarListDto = new PatentStarListDTO()
-                            .setCurrentQuery(conditions)
-                            .setOrderBy(orderBy)
-                            .setOrderByType(orderByType)
-                            .setPageNum(i)
-                            .setRowCount(50)
-                            .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");
-                    //遍历这一页的专利
-                    for (int j = 0; j < starPatents.size(); j++) {
-
+            //根据计算出的起止页数，一页一页检索
+            for (int i = startPage; i <= endPage; i++) {
+                PatentStarListDTO patentStarListDto = new PatentStarListDTO()
+                        .setCurrentQuery(conditions)
+                        .setOrderBy(orderBy)
+                        .setOrderByType(orderByType)
+                        .setPageNum(i)
+                        .setRowCount(50)
+                        .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");
+                //遍历这一页的专利
+                for (int j = 0; j < starPatents.size(); j++) {
+                    UploadPatentWebDTO uploadPatentWebDTO = new UploadPatentWebDTO();
+                    uploadPatentWebDTO.setStarPatentVO(starPatents.get(0));
+                    Patent patent = new Patent();
+                    uploadPatentWebDTO.setPatent(patent);
+                    uploadPatentWebDTO.setCounter(0);
 
                 }
 
-
+            }
 
         } catch (Exception e) {
             e.printStackTrace();

src/main/java/cn/cslg/pas/service/importPatent/SavePatentToEsThread.java

@@ -26,11 +26,12 @@ public class SavePatentToEsThread extends Thread {
     private final Lock taskLock = new ReentrantLock();
     private final Condition taskCondition = taskLock.newCondition();
     private TaskThread taskThread;
+    private ImportTaskAMVO importTaskAMVO;
     private Boolean ifProductAll = false;
 
     @Override
     public void run() {
-        while (!ifProductAll || patents.size() > 0) {
+        while (!ifProductAll || patents.size() > 0||importTaskAMVO.getProgressVO().equals(1)) {
             try {
 
                 //判断任务队列是否有任务，若没有则线程等待唤醒
@@ -89,6 +90,7 @@ public class SavePatentToEsThread extends Thread {
     public SavePatentToEsThread(TaskThread taskThread, ApplicationContext applicationContext) {
         this.taskThread = taskThread;
         this.applicationContext = applicationContext;
+        this.importTaskAMVO =taskThread.getImportTaskAMVO();
     }
 
 

src/main/java/cn/cslg/pas/service/importPatent/SchedulingTaskService.java

@@ -2,6 +2,7 @@ package cn.cslg.pas.service.importPatent;
 
 import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.vo.ImportTaskAMVO;
+import cn.cslg.pas.common.vo.ProgressVO;
 import cn.cslg.pas.domain.business.ImportTask;
 import cn.cslg.pas.domain.business.ImportTaskCondition;
 import cn.cslg.pas.service.business.ImportTaskConditionService;
@@ -29,6 +30,7 @@ public class SchedulingTaskService {
     @Autowired
     private ImportTaskConditionService importTaskConditionService;
 
+    private    List<ImportTaskAMVO> importTaskAMVOS;
     public void startTask() {
         Integer freeCount = Constants.MAX_IMPORT_TASK_COUNT - executor.getActiveCount();
 
@@ -41,7 +43,7 @@ public class SchedulingTaskService {
             List<ImportTask> importTaskList = importTaskService.list(queryWrapper);
             if (importTaskList.size() > 0) {
                 // 装载任务信息
-                List<ImportTaskAMVO> importTaskAMVOS = this.loadTaskAMVOS(importTaskList);
+              importTaskAMVOS = this.loadTaskAMVOS(importTaskList);
                 importTaskAMVOS.forEach(item -> {
                     TaskThread taskThread = new TaskThread(item,applicationContext);
                     executor.execute(taskThread);
@@ -49,11 +51,13 @@ public class SchedulingTaskService {
             }
 
         }
-
     }
 
 
     public List<ImportTaskAMVO> loadTaskAMVOS(List<ImportTask> importTaskList) {
+
+
+
         List<ImportTaskAMVO> importTaskAMVOS = new ArrayList<>();
         List<Integer> taskConditionIds = new ArrayList<>();
         List<ImportTaskCondition> importTaskConditions = new ArrayList<>();
@@ -76,11 +80,20 @@ public class SchedulingTaskService {
                 importTaskAMVO.setProductId(importTaskCondition.getProductId());
                 importTaskAMVO.setImportContent(1);
             }
+            ProgressVO progressVO =new ProgressVO();
+            progressVO.setState(0);
+            importTaskAMVO.setProgressVO(progressVO);
             importTaskAMVOS.add(importTaskAMVO);
 
+
         }
         return importTaskAMVOS;
 
+    }
 
+    public void pauseTask(Integer taskId){
+//根据id获得
+        ImportTaskAMVO  importTaskAMVO  =  importTaskAMVOS.stream().filter(item->item.getId().equals(taskId)).findFirst().orElse(null);
+        importTaskAMVO.getProgressVO().setState(1);
     }
 }

src/main/java/cn/cslg/pas/service/importPatent/TaskThread.java

@@ -40,7 +40,7 @@ public class TaskThread extends Thread {
 
     @Override
     public void run() {
-        //TODO 判断任务的类型 调用不同线程（可做工厂类）
+        //TODO 判断任务的类型
         String json = CommonService.readJsonFile(Constants.IMPORT_TASK_CONFIG + ".json");
         List<ImportTaskConfig> configs = JSON.parseArray(json, ImportTaskConfig.class);
         PatentImportFactory patentImportFactory =applicationContext.getBean(PatentImportFactory.class);

src/main/java/cn/cslg/pas/service/query/FormatQueryService.java

@@ -104,6 +104,7 @@ public class FormatQueryService {
         return strCode;
     }
 
+
     /**
      * 排序转sql排序语句
      *
@@ -127,7 +128,6 @@ public class FormatQueryService {
         if (orders.size() == 0) {
             return "";
         }
-
         String orderStr = StringUtils.join(orders, ",");
         re += orderStr;
         return re;

src/main/resources/mapper/Event.xml

@@ -1,52 +1,50 @@
 <?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.EventMapper">
-  <select id="getEvent"  resultType="cn.cslg.pas.common.vo.business.EventVO">
-   select id,name,description,client_id as clientId,scenario_id as scenarioId,event_date as eventDate,create_id as createId,create_time as createTime from event
-
-
+    <select id="getEvent" resultType="cn.cslg.pas.common.vo.business.EventVO">
+        select id,name,description,client_id as clientId,scenario_id as scenarioId,event_date as eventDate,create_id as
+        createId,create_time as createTime from event
         <if test="sql1!=''">
 
-        where    ${sql1}
+            where ${sql1}
         </if>
 
 
-      ${sql2} ${sql3}
-  </select>
+        ${sql2} ${sql3}
+    </select>
 
     <select id="getEventCount" resultType="java.lang.Long">
         select count(*) from event
         <if test="sql!=''">
 
-            where    ${sql}
+            where ${sql}
         </if>
     </select>
-    <select id="getGroups"  resultType="cn.cslg.pas.common.vo.GroupReVO">
-        select ${selectField} as value ,count(*) as num from  ${tableName}
+    <select id="getGroups" resultType="cn.cslg.pas.common.vo.GroupReVO">
+        select ${selectField} as value ,count(*) as num from ${tableName}
         <if test="sqls.get(0)!=''">
-            where    ${sqls.get(0)}
+            where ${sqls.get(0)}
         </if>
-          group by ${groupField} ${sqls.get(1)}  ${sqls.get(2)}
+        group by ${groupField} ${sqls.get(1)} ${sqls.get(2)}
     </select>
 
-    <select id="getGroupsCount"  resultType="java.lang.Long">
+    <select id="getGroupsCount" resultType="java.lang.Long">
         select count(*) from (select ${selectField} from ${tableName}
         <if test="sqls.get(0)!=''">
             where ${sqls.get(0)}
-        and ${selectField} is not null
+            and ${selectField} is not null
         </if>
         <if test="sqls.get(0)==''">
-            where  ${selectField} is not null
+            where ${selectField} is not null
         </if>
-         group by ${groupField}
+        group by ${groupField}
         ) as c
     </select>
 
 
-
-    <select id="getEventOrder"  resultType="java.lang.Integer">
+    <select id="getEventOrder" resultType="java.lang.Integer">
         select id from event
-            order  by name
+        order by name
         <if test="orderType==0">
             asc
         </if>
@@ -56,23 +54,23 @@
     </select>
 
 
-    <select id="getEntrustGroup"  resultType="cn.cslg.pas.common.vo.EntrustVO">
-        select distinct ${selectField} ,p.id,count(*) as num from  ${tableName}
+    <select id="getEntrustGroup" resultType="cn.cslg.pas.common.vo.EntrustVO">
+        select distinct ${selectField} ,p.id,count(*) as num from ${tableName}
         <if test="sqls.get(0)!=''">
-            where    ${sqls.get(0)}
+            where ${sqls.get(0)}
         </if>
-        group by ${groupField} ${sqls.get(1)}  ${sqls.get(2)}
+        group by ${groupField} ${sqls.get(1)} ${sqls.get(2)}
     </select>
 
 
-    <select id="getEntrustGroupCount"  resultType="java.lang.Long">
+    <select id="getEntrustGroupCount" resultType="java.lang.Long">
         select count(*) from (select ${selectField} from ${tableName}
         <if test="sqls.get(0)!=''">
             where ${sqls.get(0)}
             and p.entrust_type is not null
         </if>
         <if test="sqls.get(0)==''">
-            where  p.entrust_type  is not null
+            where p.entrust_type is not null
         </if>
         group by ${groupField}
         ) as c

src/test/java/cn/cslg/pas/service/CommonServiceTests.java

@@ -81,6 +81,8 @@ public class CommonServiceTests {
     @Test
     void testImportTask() throws IOException, InterruptedException {
         schedulingTaskService.startTask();
+        Thread.sleep(10000);
+        schedulingTaskService.pauseTask(1);
          Thread.sleep(1000000);
     }
     @Test

src/test/java/cn/cslg/pas/service/EsServiceTests.java

@@ -7,11 +7,13 @@ import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.service.business.es.EsService;
 
 import cn.cslg.pas.service.importPatent.SchedulingTaskService;
+import cn.hutool.core.util.XmlUtil;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import javax.swing.text.Document;
 import java.util.List;
 
 /**
@@ -49,11 +51,13 @@ public class EsServiceTests {
     }
 
     @Test
-    void updatePatent() throws Exception{}
+    void updatePatent() throws Exception{
+
+    }
 
     @Test
     void addImportTask() throws  Exception {
-        List<Patent> patentList = esService.searchChild("1",1,10);
+        List<Patent> patentList = esService.search("1",1,10);
         System.out.println(patentList);
         Thread.sleep(1000000);
     }

src/test/java/cn/cslg/pas/service/PatentStarServiceTests.java

@@ -1,19 +1,28 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.core.IgnoreDTDEntityResolver;
 import cn.cslg.pas.common.dto.PatentStarListDTO;
 import cn.cslg.pas.common.utils.FormatUtil;
 import cn.cslg.pas.common.utils.RedisUtil;
+import cn.cslg.pas.common.utils.StringUtils;
 import cn.cslg.pas.common.vo.PatentWithIdVO;
-import cn.cslg.pas.controller.outApi.PatentStarController;
 import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.service.business.es.EsService;
 import cn.cslg.pas.service.common.PatentStarApiService;
 import cn.cslg.pas.service.importPatent.SchedulingTaskService;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.XPath;
+import org.dom4j.io.SAXReader;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -33,36 +42,106 @@ public class PatentStarServiceTests {
     private SchedulingTaskService importTaskAdd;
     @Autowired
     private PatentStarApiService patentStarApiService;
+
     @Test
     void addPatent() throws Exception {
-        PatentStarListDTO patentStarListDTO =new PatentStarListDTO();
-        patentStarListDTO.setCurrentQuery(" GD=(A OR B OR C)");
+        PatentStarListDTO patentStarListDTO = new PatentStarListDTO();
+        patentStarListDTO.setCurrentQuery(" TI=计算机");
         patentStarListDTO.setDBType("CN");
         patentStarListDTO.setOrderBy("AD");
         patentStarListDTO.setPageNum(1);
         patentStarListDTO.setRowCount(10);
         patentStarListDTO.setOrderByType("DESC");
-     Map<String,Object> map = patentStarApiService.patentStarSearchLocal(patentStarListDTO);
-     System.out.println(map);
+        Map<String, Object> map = patentStarApiService.patentStarSearchLocal(patentStarListDTO);
+        System.out.println(map);
     }
 
     @Test
-    void getPatentByPatentNo() throws  Exception {
+    void getPatentByPatentNo() throws Exception {
         //根据专利号获得id
-        PatentWithIdVO patentWithIdVO  = esService.getIdByPatentNo("CN201114765Y");
-        Patent patent =new Patent();
+        PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo("CN201114765Y");
+        Patent patent = new Patent();
         patent.setAgency("张三");
-        Patent orgPatent =patentWithIdVO.getPatent();
-        BeanUtils.copyProperties(patent,orgPatent, FormatUtil.getNullPropertyNames(patent));
-          esService.updateDocument(orgPatent,patentWithIdVO.getId());
+        Patent orgPatent = patentWithIdVO.getPatent();
+        BeanUtils.copyProperties(patent, orgPatent, FormatUtil.getNullPropertyNames(patent));
+        esService.updateDocument(orgPatent, patentWithIdVO.getId());
+    }
+
+    @Test
+    void updatePatent() throws Exception {
+        String a = patentStarApiService.getCnFullXmlApi("201410391729");
+        SAXReader reader = new SAXReader();
+        reader.setEntityResolver(new IgnoreDTDEntityResolver());
+        Reader stringReader = new StringReader(a);
+        Document document = reader.read(stringReader);
+        XPath xpath = document.createXPath("//claim-text");
+        List<Element> element = (List<Element>) xpath.selectNodes(document);
+        if (element.size() == 0) {
+            xpath = document.createXPath("//business:ClaimText");
+            element = (List<Element>) xpath.selectNodes(document);
+        }
+        List<String> reStrs = new ArrayList<>();
+        element.forEach(item -> {
+            String claim = item.getText();
+            reStrs.add(claim);
+        });
+        String reStr = "";
+        if (reStrs.size() != 0) {
+            reStr = StringUtils.join(reStrs, "\r\n");
+        }
+
+
+        System.out.println(reStr);
+        Element root = document.getRootElement();
+        //获取根元素的名称
+        String rootName = root.getName();
+        System.out.println(rootName);
     }
 
     @Test
-    void updatePatent() throws Exception{}
+    void updatePatent1() throws Exception {
+        String a = patentStarApiService.getCnFullXmlApi("201210398357");
+        SAXReader reader = new SAXReader();
+        reader.setEntityResolver(new IgnoreDTDEntityResolver());
+        Reader stringReader = new StringReader(a);
+        Document document = reader.read(stringReader);
+        XPath xpath = document.createXPath("//description//p");
+        List<Element> elements = (List<Element>) xpath.selectNodes(document);
+        if (elements.size() == 0) {
+            xpath = document.createXPath("//business:Description//base:Paragraphs");
+            elements = (List<Element>) xpath.selectNodes(document);
+        }
+        List<String> reStrs = new ArrayList<>();
+        Integer count=1;
+        for (Element item:elements){
+            String claim = item.getText().replaceAll("<br/>", "");
+            if (!claim.trim().equals("技术领域")
+                    && !claim.trim().equals("发明内容")
+                    && !claim.trim().equals("附图说明")
+                    && !claim.trim().equals("具体实施方式")
+                     &&!claim.trim().equals("背景技术"))
+            {String formattedNum = String.format("%04d", count);
+                claim ="["+formattedNum+"]"+claim;
+                count++;
+            }
+                reStrs.add(claim);
+        }
+        String reStr = "";
+        if (reStrs.size() != 0) {
+            reStr = StringUtils.join(reStrs, "\r\n");
+        }
+
+        System.out.println(reStr);
+        Element root = document.getRootElement();
+        //获取根元素的名称
+        String rootName = root.getName();
+        System.out.println(rootName);
+    }
+
 
     @Test
-    void addImportTask() throws  Exception {
-        List<Patent> patentList = esService.searchChild("1",1,10);
+    void addImportTask() throws Exception {
+        List<Patent> patentList = esService.searchChild("1", 1, 10);
         System.out.println(patentList);
         Thread.sleep(1000000);
     }