7/30 外部检索逻辑更改

src/main/java/cn/cslg/pas/controller/PatentProjectController.java

@@ -4,16 +4,21 @@ import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.dto.business.PatentProjectDTO;
 import cn.cslg.pas.common.dto.business.UpdateEventDTO;
 import cn.cslg.pas.common.dto.business.UpdatePatentProjectDTO;
+import cn.cslg.pas.common.importTask.ProjectQuartzQueryDTO;
+import cn.cslg.pas.common.importTask.ProjectQuartzSetDTO;
 import cn.cslg.pas.common.model.addPatentToReport.AddProjectPatentToReportDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.model.request.StringGroupRequest;
 import cn.cslg.pas.common.model.request.StringRequest;
+import cn.cslg.pas.common.patentProject.ProjectQuartzDTO;
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.domain.business.PatentProject;
 import cn.cslg.pas.exception.ConditionException;
 import cn.cslg.pas.exception.UnLoginException;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.factorys.businessFactory.Business;
 import cn.cslg.pas.factorys.businessFactory.BusinessFactory;
+import cn.cslg.pas.service.business.PatentProjectService;
 import cn.cslg.pas.service.business.ProjectService;
 import com.alibaba.fastjson.JSONObject;
 import io.swagger.v3.oas.annotations.Operation;
@@ -40,7 +45,8 @@ public class PatentProjectController {
     private BusinessFactory businessFactory;
     @Autowired
     private ProjectService projectService;
-
+    @Autowired
+    private PatentProjectService patentProjectService;
     @Operation(summary = "查询专利数据库")
     @PostMapping("/queryPatentProject")
     public Response queryPatentProject(@RequestBody StringRequest stringRequest) throws Exception {
@@ -126,4 +132,18 @@ public class PatentProjectController {
         projectService.addProjectPatentToReport(addProjectPatentToReportDTO);
         return Response.success();
     }
+
+    @Operation(summary = "设置更新周期")
+    @PostMapping("/setProjectQuartz")
+    public Response setProjectQuartz(@RequestBody ProjectQuartzSetDTO projectQuartzSetDTO) throws Exception {
+        patentProjectService.setProjectQuartz(projectQuartzSetDTO);
+        return  Response.success(true);
+    }
+
+    @Operation(summary = "查询更新周期")
+    @PostMapping("/queryProjectQuartz")
+    public Response queryProjectQuartz(@RequestBody ProjectQuartzQueryDTO projectQuartzDTO) throws Exception {
+        PatentProject patentProject= patentProjectService.queryProjectQuartz(projectQuartzDTO);
+        return  Response.success(patentProject);
+    }
 }

src/main/java/cn/cslg/pas/domain/es/Patent.java

@@ -420,4 +420,19 @@ public class Patent {
     PatentJoin patentJoin;
 
 
+
+    /**
+     * 权要数量
+     */
+    @JsonProperty("right_num")
+    private Integer rightNum;
+
+
+    /**
+     * 专题库或报告id
+     */
+    @JsonProperty("main_right_num")
+    private Integer mainRightNum;
+
+
 }

src/main/java/cn/cslg/pas/service/MailSendService.java

@@ -142,8 +142,5 @@ public class MailSendService {
             map.put("value3",taskName);
             rabbitMQUtils.sendEmailMessage(map);
         }
-
-
-
 }
 }

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

@@ -1,5 +1,6 @@
 package cn.cslg.pas.service.business.es;
 
+import cn.cslg.pas.common.core.base.FamilyType;
 import cn.cslg.pas.common.core.base.IfConstant;
 import cn.cslg.pas.common.dto.PatentDetailDTO;
 import cn.cslg.pas.common.dto.PatentKinDTO;
@@ -102,8 +103,21 @@ public class EsFamilyService {
 
 
     public void updatePatentFamilyByQuery(String patentFamilyType, String patentFamilyId, Integer patentFamilyCount, List<String> nos) {
-        String familyNum = "inpadoc_family_num";
-        String familyName = "inpadoc_family_id";
+        String familyNum = "";
+        String familyName="";
+        if(patentFamilyType.equals(FamilyType.INPADOC)) {
+            familyName = "inpadoc_family_id";
+            familyNum = "inpadoc_family_num";
+        }
+        else if(patentFamilyType.equals(FamilyType.PATSNAP))
+        {
+            familyName = "patsnap_family_id";
+            familyNum = "patsnap_family_num";
+        }
+        else {
+            familyName = "simple_family_id";
+            familyNum = "simple_family_num";
+        }
         String source = "";
         source = "ctx._source." + familyName + "='" + patentFamilyId + "';" + "ctx._source." + familyNum + "=" + patentFamilyCount + ";";
         String finalSource = source;

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

@@ -29,6 +29,7 @@ import java.io.*;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 
 @Configurable
 public class GetPatentFromExcelThread extends Thread {
@@ -85,7 +86,7 @@ public class GetPatentFromExcelThread extends Thread {
                 uploadPatentWebDTO.setPatent(uploadParamsVO.getPatent());
                 if (uploadParamsVO.getCustomerFieldList() != null && uploadParamsVO.getCustomerFieldList().size() != 0) {
                     CustomFieldService customFieldService = applicationContext.getBean(CustomFieldService.class);
-                    List<EsCustomFieldDTO> esCustomFieldDTOList = customFieldService.getFieldDTOByStrings(uploadParamsVO.getCustomerFieldList(), importTaskAMVO.getProjectId(),null);
+                    List<EsCustomFieldDTO> esCustomFieldDTOList = customFieldService.getFieldDTOByStrings(uploadParamsVO.getCustomerFieldList(), importTaskAMVO.getProjectId(), null);
                     uploadPatentWebDTO.setEsCustomFieldDTOList(esCustomFieldDTOList);
                 }
                 //专利丢入消费者队列，并唤醒消费者线程
@@ -113,34 +114,21 @@ public class GetPatentFromExcelThread extends Thread {
 
 
     public void loadPatent(UploadParamsVO uploadParamsVO) {
+        WebVOTransformService webVOTransformService = applicationContext.getBean(WebVOTransformService.class);
+
         Patent patent = uploadParamsVO.getPatent();
-        String patentNo = patent.getPatentNo();
-        String appNo = patent.getAppNo();
-        String publicNo = patent.getPublicNo();
-        String grantNo = patent.getGrantNo();
-        String usedNo = null;
-        if (appNo != null) {
-            usedNo = appNo;
-        } else if (publicNo != null) {
-            usedNo = publicNo;
-        } else if (grantNo != null) {
-            usedNo = grantNo;
-        }
-        //获取专利前缀
-        String contry = usedNo.substring(0, 2);
-        //根据前缀判断如何设置专利号，中国专利为申请号，外国专利为公开号，若公开号不存在则为公告号
-        if (contry.equals("CN")) {
-            patentNo = appNo;
+
+        this.loadPatentType(patent);
+        webVOTransformService.loadGrantNo(patent, patent.getPublicNo(), patent.getGrantNo());
+        webVOTransformService.loadCountry(patent, false);
+        if (patent.getAppCountry() != null && patent.getAppCountry().equals("CN")) {
+            patent.setPatentNo(patent.getAppNo());
         } else {
-            if (publicNo != null) {
-                patentNo = publicNo;
-            } else if (grantNo != null) {
-                patentNo = grantNo;
-            }
+            webVOTransformService.loadWorldPatentNo(patent);
+
         }
-        patent.setPatentNo(patentNo);
-        //装载国家
-        patent.setAppCountry(contry);
+
+
         //装载标题原文
         if (uploadParamsVO.getTitle() != null) {
             List<Text> texts = new ArrayList<>();
@@ -148,7 +136,7 @@ public class GetPatentFromExcelThread extends Thread {
                 Text text = new Text();
                 text.setTextContent(uploadParamsVO.getTitle().getName());
                 text.setIfOrigin(true);
-                text.setLanguage(contry);
+                text.setLanguage(patent.getAppCountry());
                 texts.add(text);
             }
             //装载标题译文
@@ -173,7 +161,7 @@ public class GetPatentFromExcelThread extends Thread {
                 Text text = new Text();
                 text.setTextContent(uploadParamsVO.getAbstractStr().getName());
                 text.setIfOrigin(true);
-                text.setLanguage(contry);
+                text.setLanguage(patent.getAppCountry());
                 texts.add(text);
             }
             //装载摘要译文
@@ -197,7 +185,7 @@ public class GetPatentFromExcelThread extends Thread {
                 Text text = new Text();
                 text.setTextContent(uploadParamsVO.getPatentRight().getName());
                 text.setIfOrigin(true);
-                text.setLanguage(contry);
+                text.setLanguage(patent.getAppCountry());
                 texts.add(text);
             }
             //装载权利要求译文
@@ -252,82 +240,28 @@ public class GetPatentFromExcelThread extends Thread {
             }
         }
 
-        List<String> applicantNames = uploadParamsVO.getPatentApplicantOriginalName();
-
-        //申请人
-        if (applicantNames != null && applicantNames.size() != 0) {
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < applicantNames.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(i + 1);
-                patentPerson.setType("1");
-                patentPerson.setName(applicantNames.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setApplicant(patentPeople);
+        //发明人
+        List<PatentInventor> patentInventorList = uploadParamsVO.getPatentInventorList();
+        if (patentInventorList != null) {
+            List<String> invetorNames = patentInventorList.stream().map(PatentInventor::getName).collect(Collectors.toList());
+            webVOTransformService.loadInventor(patent, invetorNames);
         }
 
+        List<String> applicantNames = uploadParamsVO.getPatentApplicantOriginalName();
+        webVOTransformService.loadApplicant(patent, applicantNames);
+
         //权利人
         List<String> rightNames = uploadParamsVO.getPatentApplicantCurrentName();
-        if (rightNames != null && rightNames.size() != 0) {
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < rightNames.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(i + 1);
-                patentPerson.setType("1");
-                patentPerson.setName(rightNames.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setRightHolder(patentPeople);
-        }
-
-        //发明人
-        List<PatentInventor> patentInventorList = uploadParamsVO.getPatentInventorList();
-        if (patentInventorList != null && patentInventorList.size() > 0) {
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < patentInventorList.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(i + 1);
-                patentPerson.setType("1");
-                patentPerson.setName(patentInventorList.get(i).getName());
-                patentPeople.add(patentPerson);
-            }
-            patent.setInventor(patentPeople);
-        }
+        webVOTransformService.loadRightHolder(patent, rightNames);
 
         List<String> ipcList = uploadParamsVO.getIpcList();
         String mainIpc = uploadParamsVO.getMainIpc();
 
-        //装载IPC分类号
-        if (ipcList == null && mainIpc != null) {
-            ipcList = new ArrayList<>();
-            ipcList.add(uploadParamsVO.getMainIpc());
-        }
-
-        if (ipcList != null && ipcList.size() > 0) {
-            List<PatentClassify> patentClassifies = new ArrayList<>();
-            for (int i = 0; i < ipcList.size(); i++) {
-                PatentClassify patentClassify = PatentClassifySplitter.split(ipcList.get(i));
-                if (patentClassify != null) {
-                    patentClassifies.add(patentClassify);
-                    if (i == 0) {
-                        patent.setMipc(patentClassify);
-                    }
-                }
-            }
-            patent.setIpc(patentClassifies);
-        }
+        webVOTransformService.loadPatentIPC(patent, mainIpc, ipcList);
 
         //装载CPC分类号
         List<String> cpcList = uploadParamsVO.getCpcList();
-        if (cpcList != null && cpcList.size() > 0) {
-            List<PatentClassify> patentClassifies = new ArrayList<>();
-            for (int i = 0; i < cpcList.size(); i++) {
-                PatentClassify patentClassify = PatentClassifySplitter.split(cpcList.get(i));
-                patentClassifies.add(patentClassify);
-            }
-            patent.setCpc(patentClassifies);
-        }
+        webVOTransformService.loadPatentCPC(patent, cpcList);
 
         //装载说明书
         if (uploadParamsVO.getPatentInstructionText() != null) {
@@ -336,7 +270,7 @@ public class GetPatentFromExcelThread extends Thread {
                 Text text = new Text();
                 text.setTextContent(uploadParamsVO.getPatentInstructionText().getManual());
                 text.setIfOrigin(true);
-                text.setLanguage(contry);
+                text.setLanguage(patent.getAppCountry());
                 texts.add(text);
             }
             if (uploadParamsVO.getPatentInstructionText().getManualOut() != null) {
@@ -373,7 +307,7 @@ public class GetPatentFromExcelThread extends Thread {
         }
 
         this.loadLegalStatus(patent);
-        this.loadPatentType(patent);
+
         this.loadLegalStatusBySta(uploadParamsVO);
 
     }

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

@@ -64,8 +64,7 @@ public class GetRightAndFullTextFromWebThread extends Thread {
                     String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(starPatentVO.getANO());
                     WebVOTransformService webVOTransformService = applicationContext.getBean(WebVOTransformService.class);
                     webVOTransformService.loadClaim(patent, cnFullXmlStr);
-                    ImportSinglePatentService importSinglePatentService = applicationContext.getBean(ImportSinglePatentService.class);
-                    importSinglePatentService.loadFullText(uploadPatentWebDTO, cnFullXmlStr);
+                    webVOTransformService.loadFullText(patent, cnFullXmlStr);
                 }
                 //加入es保存队列
                 this.addPatent(uploadPatentWebDTO);

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

@@ -74,6 +74,8 @@ public class ImportSinglePatentService {
     private OPSService opsService;
     @Autowired
     private PatentNoUtil patentNoUtil;
+    @Autowired
+    private WebVOTransformService webVOTransformService;
 
     public StarPatentVO getPatentFromWeb(String patentNo) {
         StarPatentVO starPatentVO = null;
@@ -151,407 +153,17 @@ public class ImportSinglePatentService {
         UploadPatentWebDTO uploadPatentWebDTO = new UploadPatentWebDTO();
         uploadPatentWebDTO.setPatent(new Patent());
         uploadPatentWebDTO.setStarPatentVO(starPatentVO);
-        this.loadPatent(uploadPatentWebDTO);
+
         if (patentZhuLuStr != null && !patentZhuLuStr.trim().equals("") && !patentZhuLuStr.equals("{}") && !patentZhuLuStr.contains("请求不合法")) {
             if (starPatentVO.getAN().startsWith("CN")) {
-                this.loadCNPatent(patentZhuLuStr, uploadPatentWebDTO.getPatent(), starPatentVO);
-                //装载专利号
-                if (uploadPatentWebDTO.getPatent().getAppNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getAppNo());
-                } else if (uploadPatentWebDTO.getPatent().getGrantNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getGrantNo());
-                } else if (uploadPatentWebDTO.getPatent().getPublicNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getPublicNo());
-                }
+                webVOTransformService.loadCNPatent(patentZhuLuStr, uploadPatentWebDTO);
             } else {
-                this.loadWorldPatent(patentZhuLuStr, uploadPatentWebDTO.getPatent());
-                //装载专利号
-                if (uploadPatentWebDTO.getPatent().getGrantNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getGrantNo());
-                } else if (uploadPatentWebDTO.getPatent().getPublicNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getPublicNo());
-                } else if (uploadPatentWebDTO.getPatent().getAppNo() != null) {
-                    uploadPatentWebDTO.getPatent().setPatentNo(uploadPatentWebDTO.getPatent().getAppNo());
-                }
+                webVOTransformService.loadWorldPatent(patentZhuLuStr, uploadPatentWebDTO);
             }
         }
         return uploadPatentWebDTO.getPatent();
     }
 
-    //装载专利信息
-    private void loadPatent(UploadPatentWebDTO uploadPatentWebDTO) {
-
-        String country = "";
-        Patent patent = uploadPatentWebDTO.getPatent();
-        StarPatentVO starPatentVO = uploadPatentWebDTO.getStarPatentVO();
-
-        //装载专利类型
-        Integer patentType = starPatentVO.getPT();
-        if (patentType != null) {
-            if (patentType.equals(2) || patentType.equals(9)) {
-                patent.setPatentType("1");  //实用新型
-            } else if (patentType.equals(1) || patentType.equals(8)) {
-                patent.setPatentType("2");  //发明
-            } else if (patentType.equals(3)) {
-                patent.setPatentType("3");  //外观设计
-            }
-        }
-
-        //装载申请人地址
-        if (starPatentVO.getDZ() != null && !starPatentVO.getDZ().equals("")) {
-            String applicationAddress = starPatentVO.getDZ();
-            PersonAddress personAddress = AddressSplitter.splitAddress(applicationAddress, starPatentVO.getCO());
-            patent.setApplicantAddr(personAddress);
-        }
-
-        //装载IPC分类号
-        if (starPatentVO.getIC() != null && !starPatentVO.getIC().equals("")) {
-            List<PatentClassify> patentClassifies = new ArrayList<>();
-            List<String> ipcArr = Arrays.asList(starPatentVO.getIC().split(";"));
-            for (int i = 0; i < ipcArr.size(); i++) {
-                PatentClassify patentClassify = PatentClassifySplitter.split(ipcArr.get(i));
-                patentClassifies.add(patentClassify);
-                if (i == 0) {
-                    patent.setMipc(patentClassify);
-                }
-            }
-            patent.setIpc(patentClassifies);
-        }
-
-        //装载公告日
-        if (starPatentVO.getGN() != null && !starPatentVO.getGN().equals("")) {
-//
-//            patent.setGrantDate();
-            Date date = DateUtils.strToDate(starPatentVO.getGN());
-            patent.setGrantDate(date);
-        }
-
-        //装载摘要
-        if (starPatentVO.getAB() != null && !starPatentVO.getAB().equals("")) {
-            Text text = new Text();
-            text.setLanguage(patent.getAppCountry());
-            text.setIfOrigin(true);
-            text.setTextContent(starPatentVO.getAB());
-            patent.setAbstractStr(Arrays.asList(text));
-        }
-
-        //装载申请日
-        if (starPatentVO.getAD() != null && !starPatentVO.getAD().equals("")) {
-            Date date = DateUtils.strToDate(starPatentVO.getAD());
-            patent.setAppDate(date);
-
-        }
-
-        //装载发明人
-        if (starPatentVO.getIV() != null && !starPatentVO.getIV().equals("")) {
-            List<String> patentInventorNames = Arrays.asList(starPatentVO.getIV().split(";"));
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < patentInventorNames.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(i + 1);
-                patentPerson.setType("1");
-                patentPerson.setName(patentInventorNames.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setInventor(patentPeople);
-        }
-
-        //装载申请号
-        if (starPatentVO.getAN() != null && !starPatentVO.getAN().equals("")) {
-            patent.setAppNo(starPatentVO.getAN());
-            country = starPatentVO.getAN().substring(0, 2);
-        }
-
-        //装载公开号
-        if (starPatentVO.getPN() != null && !starPatentVO.getPN().equals("")) {
-            patent.setPublicNo(starPatentVO.getPN());
-        }
-
-        if (starPatentVO.getGN() != null && !starPatentVO.getGN().equals("")) {
-            patent.setGrantNo(starPatentVO.getGN());
-        }
-
-        if (patent.getAppNo().startsWith("CN")) {
-            patent.setPatentNo(patent.getAppNo());
-        } else {
-            if (patent.getPublicNo() != null) {
-                patent.setPatentNo(patent.getPublicNo());
-            } else if (patent.getGrantNo() != null) {
-                patent.setPatentNo(patent.getGrantNo());
-            }
-        }
-        //装载申请人
-        if (starPatentVO.getPA() != null && !starPatentVO.getPA().equals("")) {
-            List<String> names = Arrays.asList(starPatentVO.getPA().split(";"));
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < names.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(i + 1);
-                patentPerson.setType("1");
-                patentPerson.setName(names.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setApplicant(patentPeople);
-        }
-
-        //装载代理人
-        if (starPatentVO.getAT() != null && !starPatentVO.getAT().equals("")) {
-            List<String> patentAgents = Arrays.asList(starPatentVO.getAT().split(";"));
-            if (patentAgents != null && patentAgents.size() != 0) {
-                patent.setAgent(patentAgents);
-            }
-        }
-
-        if (starPatentVO.getAGN() != null && !starPatentVO.getAGN().equals("")) {
-            patent.setAgency(starPatentVO.getAGN());
-
-        }
-        //装载公开日
-        if (starPatentVO.getPD() != null && !starPatentVO.getPD().equals("")) {
-            Date date = DateUtils.strToDate(starPatentVO.getPD());
-            patent.setPublicDate(date);
-        }
-
-        //装载标题
-        if (starPatentVO.getTI() != null && !starPatentVO.getTI().equals("")) {
-            Text text = new Text();
-            text.setLanguage(country);
-            text.setIfOrigin(true);
-            text.setTextContent(starPatentVO.getTI());
-            patent.setTitle(Arrays.asList(text));
-        }
-
-        //装载权利人
-        if (starPatentVO.getPE() != null && !starPatentVO.getPE().equals("")) {
-            List<String> names = Arrays.asList(starPatentVO.getPE().split(";"));
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < names.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(0);
-                patentPerson.setType("1");
-                patentPerson.setName(names.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setRightHolder(patentPeople);
-        } else if (patent.getApplicant() != null) {
-            patent.setRightHolder(patent.getApplicant());
-        }
-
-        //装载法律状态（os_patent表status字段值）
-        Integer status = starPatentVO.getLG();
-        if (status != null) {
-            //有效（有权）
-            if (status == 1) {
-                patent.setSimpleStatus("3");
-                //失效（无权）
-            } else if (status == 2) {
-                patent.setSimpleStatus("2");
-                //审中（审中）
-            } else if (status == 3) {
-                patent.setSimpleStatus("1");
-            }
-        }
-
-        //装载优先权
-        if (starPatentVO.getPR() != null && !starPatentVO.getPR().equals("")) {
-            Priorities priorities = new Priorities();
-            priorities.setPriorityNo(starPatentVO.getPR());
-            String pCountry = starPatentVO.getAN().substring(0, 2);
-            priorities.setPriorityCountry(pCountry);
-            //装载优先权日
-            if (starPatentVO.getPRD() != null && !starPatentVO.getPRD().equals("")) {
-                DateUtils.str2Date(starPatentVO.getPRD());
-            }
-            patent.setPriorities(Arrays.asList(priorities));
-        }
-
-        //装载受理局
-        if (starPatentVO.getCO() != null && !starPatentVO.getCO().equals("")) {
-            patent.setAppCountry(starPatentVO.getCO());
-        }
-    }
-
-
-    //装载中国专利
-    private void loadCNPatent(String chinaPatentZhuLuStr, Patent patent, StarPatentVO starPatentVO) {
-        patent.setPatentNo(patent.getAppNo());
-        if (chinaPatentZhuLuStr != null && !chinaPatentZhuLuStr.trim().equals("") && !chinaPatentZhuLuStr.equals("{}") && !chinaPatentZhuLuStr.contains("请求不合法")) {
-            List<ChinaPatentZhuLu> chinaPatentZhuLus = JSON.parseArray(chinaPatentZhuLuStr, ChinaPatentZhuLu.class);
-            ChinaPatentZhuLu chinaPatentZhuLu = chinaPatentZhuLus.get(0);
-            //装载申请人地址
-            if (patent.getApplicantAddr() == null) {
-                if (chinaPatentZhuLu.getDZ() != null && !chinaPatentZhuLu.getDZ().equals("")) {
-                    PersonAddress personAddress = AddressSplitter.splitAddress(chinaPatentZhuLu.getDZ(), starPatentVO.getCO());
-                    patent.setApplicantAddr(personAddress);
-                    patent.setApplicantAddr(personAddress);
-                }
-            }
-            //装载代理人
-            if (patent.getAgent() == null || patent.getAgent().size() == 0) {
-                if (chinaPatentZhuLu.getAT() != null && !chinaPatentZhuLu.getAT().equals("")) {
-                    List<String> patentAgents = Arrays.asList(chinaPatentZhuLu.getAT().split(";"));
-                    if (patentAgents != null && patentAgents.size() != 0) {
-                        patent.setAgent(patentAgents);
-                    }
-                }
-            }
-
-            //装载发明人
-            if (patent.getInventor() == null || patent.getInventor().size() == 0) {
-
-                if (chinaPatentZhuLu.getIV() != null && !chinaPatentZhuLu.getIV().equals("")) {
-                    List<String> patentInventorNames = Arrays.asList(chinaPatentZhuLu.getIV().split(";"));
-                    List<PatentPerson> patentPeople = new ArrayList<>();
-                    for (int i = 0; i < patentInventorNames.size(); i++) {
-                        PatentPerson patentPerson = new PatentPerson();
-                        patentPerson.setOrder(0);
-                        patentPerson.setType("1");
-                        patentPerson.setName(patentInventorNames.get(i));
-                        patentPeople.add(patentPerson);
-                    }
-                    patent.setInventor(patentPeople);
-                }
-            }
-            //装载优先权号、优先权国家、优先权日
-            if (patent.getPriorities() == null && chinaPatentZhuLu.getPR() != null && chinaPatentZhuLu.getPR() != "") {
-                Priorities priorities = new Priorities();
-                priorities.setPriorityNo(chinaPatentZhuLu.getPR());
-                String pCountry = chinaPatentZhuLu.getPR().substring(0, 2);
-                priorities.setPriorityCountry(pCountry);
-                patent.setPriorities(Arrays.asList(priorities));
-            }
-
-        }
-    }
-
-    /**
-     * 装载世界专利著录
-     *
-     * @param worldPatentZhuLuStr
-     * @param patent
-     */
-    private void loadWorldPatent(String worldPatentZhuLuStr, Patent patent) {
-        String country = "";
-        List<WorldPatentZhuLu> worldPatentZhuLus = JSON.parseArray(worldPatentZhuLuStr, WorldPatentZhuLu.class);
-        WorldPatentZhuLu worldPatentZhuLu = worldPatentZhuLus.get(0);
-
-        //装载公开号
-        if (patent.getPublicNo() == null || patent.getPublicNo().equals("")) {
-            patent.setPublicNo(worldPatentZhuLu.getDocdbPubNo());
-        }
-        //装载申请号
-        if (patent.getAppNo() == null || patent.getAppNo().equals("")) {
-            patent.setAppNo(worldPatentZhuLu.getEpoAppNo());
-        }
-        //装载申请日
-        if (patent.getAppDate() == null) {
-            if (worldPatentZhuLu.getAppDate() != null && !worldPatentZhuLu.getAppDate().equals("")) {
-                Date date = DateUtils.strToDate(worldPatentZhuLu.getAppDate());
-                patent.setAppDate(date);
-            }
-
-        }
-        //装载公开日
-        if (patent.getPublicDate() == null) {
-            if (worldPatentZhuLu.getPubDate() != null && !worldPatentZhuLu.getPubDate().equals("")) {
-                Date date = DateUtils.strToDate(worldPatentZhuLu.getPubDate());
-                patent.setPublicDate(date);
-            }
-
-        }
-        //装载IPC分类号
-        if (patent.getIpc() == null || patent.getIpc().size() == 0) {
-            List<PatentClassify> patentClassifies = new ArrayList<>();
-            List<String> ipcArr = Arrays.asList(worldPatentZhuLu.getIpc().split(";"));
-            for (int i = 0; i < ipcArr.size(); i++) {
-                PatentClassify patentClassify = PatentClassifySplitter.split(ipcArr.get(i));
-                patentClassifies.add(patentClassify);
-                if (i == 0) {
-                    patent.setMipc(patentClassify);
-                }
-            }
-            patent.setIpc(patentClassifies);
-        }
-
-        //装载CPC分类号
-        if (patent.getCpc() == null || patent.getCpc().size() == 0) {
-            if (worldPatentZhuLu.getCpc() != null && !worldPatentZhuLu.getCpc().equals("")) {
-                List<PatentClassify> patentClassifies = new ArrayList<>();
-                List<String> cpcArr = Arrays.asList(worldPatentZhuLu.getCpc().split(";"));
-                for (int i = 0; i < cpcArr.size(); i++) {
-                    PatentClassify patentClassify = PatentClassifySplitter.split(cpcArr.get(i));
-                    patentClassifies.add(patentClassify);
-                    if (i == 0) {
-                        patent.setMipc(patentClassify);
-                    }
-                }
-                patent.setCpc(patentClassifies);
-            }
-        }
-
-        //装载申请人
-        if (patent.getApplicant() == null || patent.getApplicant().size() == 0) {
-            List<String> names = Arrays.asList(worldPatentZhuLu.getPa().split(";"));
-            List<PatentPerson> patentPeople = new ArrayList<>();
-            for (int i = 0; i < names.size(); i++) {
-                PatentPerson patentPerson = new PatentPerson();
-                patentPerson.setOrder(0);
-                patentPerson.setType("1");
-                patentPerson.setName(names.get(i));
-                patentPeople.add(patentPerson);
-            }
-            patent.setApplicant(patentPeople);
-            if (patent.getRightHolder() == null || patent.getRightHolder().size() == 0) {
-                patent.setRightHolder(patent.getApplicant());
-            }
-        }
-
-
-        //装载发明人
-        if (patent.getInventor() == null || patent.getInventor().size() == 0) {
-            if (worldPatentZhuLu.getIv() != null && !worldPatentZhuLu.getIv().equals("")) {
-                List<String> patentInventorNames = Arrays.asList(worldPatentZhuLu.getIv().split(";"));
-                List<PatentPerson> patentPeople = new ArrayList<>();
-                for (int i = 0; i < patentInventorNames.size(); i++) {
-                    PatentPerson patentPerson = new PatentPerson();
-                    patentPerson.setOrder(0);
-                    patentPerson.setType("1");
-                    patentPerson.setName(patentInventorNames.get(i));
-                    patentPeople.add(patentPerson);
-                }
-                patent.setInventor(patentPeople);
-            }
-        }
-
-        //装载优先权号、优先权国家、优先权日
-        if (patent.getPriorities() == null && worldPatentZhuLu.getPr() != null && worldPatentZhuLu.getPr() != "") {
-            Priorities priorities = new Priorities();
-            priorities.setPriorityNo(worldPatentZhuLu.getPr());
-            String pCountry = worldPatentZhuLu.getPr().substring(0, 2);
-            priorities.setPriorityCountry(pCountry);
-            patent.setPriorities(Arrays.asList(priorities));
-        }
-
-        //装载标题
-        if (patent.getTitle() == null || patent.getTitle().size() != 0) {
-            Text text = new Text();
-            text.setLanguage(country);
-            text.setIfOrigin(true);
-            text.setTextContent(worldPatentZhuLu.getTitle());
-            patent.setTitle(Arrays.asList(text));
-        }
-        //装载摘要
-        if (patent.getAbstractStr() == null || patent.getAbstractStr().equals("")) {
-            Text text = new Text();
-            text.setLanguage(patent.getAppCountry());
-            text.setIfOrigin(true);
-            text.setTextContent(worldPatentZhuLu.getAbstract());
-            patent.setAbstractStr(Arrays.asList(text));
-        }
-
-
-    }
-
 
     public void getFullXmlStr(Patent patent, StarPatentVO starPatentVO, List<Integer> contents) throws Exception {
         String cnFullXmlStr = patentStarApiService.getCnFullXmlApi(starPatentVO.getANO());
@@ -733,8 +345,6 @@ public class ImportSinglePatentService {
     }
 
     public void getPictureFromWeb(StarPatentVO starPatentVO) throws Exception {
-
-
         String pictureUrl = patentStarApiService.getPictureApi(starPatentVO.getANO());
         if (pictureUrl != null && pictureUrl != "{}") {
             File file = FileUtils.getPictureFileByUrl(pictureUrl);

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

@@ -136,8 +136,7 @@ public class TaskThread extends Thread {
             task.setState(2);
             importTaskAMVO.setState(2);
             MailSendService mailSendService = applicationContext.getBean(MailSendService.class);
-
-//            mailSendService.sendImportTaskDoneEmail("导入任务",task.getName(),task.getCreateId());
+            mailSendService.sendImportTaskDoneEmail("导入任务",task.getName(),task.getCreateId());
 
         } else {
             task.setState(importTaskAMVO.getState());

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

@@ -288,6 +288,24 @@ public class WebVOTransformService {
         }
     }
 
+    public void loadInventor(Patent patent, List<String> patentInventorNames) {
+        if (patent.getInventor() == null || patent.getInventor().size() == 0) {
+
+            if (patentInventorNames != null && patentInventorNames.size()!=0) {
+
+                List<PatentPerson> patentPeople = new ArrayList<>();
+                for (int i = 0; i < patentInventorNames.size(); i++) {
+                    PatentPerson patentPerson = new PatentPerson();
+                    patentPerson.setOrder(0);
+                    patentPerson.setType("1");
+                    patentPerson.setName(patentInventorNames.get(i));
+                    patentPeople.add(patentPerson);
+                }
+                patent.setInventor(patentPeople);
+            }
+        }
+    }
+
     /**
      * 装载ipc分类号
      *
@@ -322,6 +340,33 @@ public class WebVOTransformService {
         }
     }
 
+    public void loadPatentIPC(Patent patent, String mainIpc,  List<String> ipcArr ) {
+        //装载IPC分类号
+        if (ipcArr != null && ipcArr.size()>0) {
+            List<PatentClassify> patentClassifies = new ArrayList<>();
+            for (int i = 0; i < ipcArr.size(); i++) {
+                PatentClassify patentClassify = PatentClassifySplitter.split(ipcArr.get(i));
+                patentClassifies.add(patentClassify);
+            }
+            patent.setIpc(patentClassifies);
+            if (mainIpc == null || mainIpc.equals("")) {
+                if (patentClassifies.size() > 0) {
+                    patent.setMipc(patentClassifies.get(0));
+                }
+            } else {
+                PatentClassify patentClassify = PatentClassifySplitter.split(mainIpc);
+                patent.setMipc(patentClassify);
+            }
+        } else {
+            if (mainIpc != null || !mainIpc.equals("")) {
+                PatentClassify patentClassify = PatentClassifySplitter.split(mainIpc);
+                patent.setMipc(patentClassify);
+                patent.setIpc(Arrays.asList(patentClassify));
+            }
+        }
+    }
+
+
     /**
      * 装载loc分类号
      *
@@ -382,6 +427,16 @@ public class WebVOTransformService {
         }
     }
 
+    public void loadPatentCPC(Patent patent, List<String> cpcArr) {
+        //装载IPC分类号
+            List<PatentClassify> patentClassifies = new ArrayList<>();
+            for (int i = 0; i < cpcArr.size(); i++) {
+                PatentClassify patentClassify = PatentClassifySplitter.split(cpcArr.get(i));
+                patentClassifies.add(patentClassify);
+            }
+            patent.setIpc(patentClassifies);
+
+    }
     /**
      * 装载摘要
      *
@@ -480,7 +535,7 @@ public class WebVOTransformService {
     public void loadGrantNo(Patent patent, String publicNo, String grantNo) {
         if (grantNo != null && !grantNo.equals("")) {
             patent.setGrantNo(grantNo);
-        } else if (!patent.getPatentType().equals("1") && !patent.getPatentType().equals("8")) {
+        } else if (patent.getPatentType()!=null&&!patent.getPatentType().equals("1") && !patent.getPatentType().equals("8")) {
             if (publicNo != null && !publicNo.equals("")) {
                 patent.setGrantNo(publicNo);
             }
@@ -526,6 +581,24 @@ public class WebVOTransformService {
         }
     }
 
+    public void loadRightHolder(Patent patent, List<String> names) {
+        //装载权利人
+        if (names != null && names.size()>0) {
+            List<PatentPerson> patentPeople = new ArrayList<>();
+            for (int i = 0; i < names.size(); i++) {
+                String name = names.get(i);
+                String type = this.getPersonType(name, patent.getInventor());
+                PatentPerson patentPerson = new PatentPerson();
+                patentPerson.setOrder(0);
+                patentPerson.setType(type);
+                patentPerson.setName(names.get(i));
+                patentPeople.add(patentPerson);
+            }
+            patent.setRightHolder(patentPeople);
+        } else if (patent.getApplicant() != null) {
+            patent.setRightHolder(patent.getApplicant());
+        }
+    }
     /**
      * 装载代理机构
      *
@@ -562,6 +635,23 @@ public class WebVOTransformService {
         }
     }
 
+    public void loadApplicant(Patent patent, List<String> names) {
+        if (names != null && names.size()>0) {
+            List<PatentPerson> patentPeople = new ArrayList<>();
+            for (int i = 0; i < names.size(); i++) {
+                String name = names.get(i);
+                String type = this.getPersonType(name, patent.getInventor());
+                PatentPerson patentPerson = new PatentPerson();
+                patentPerson.setOrder(i + 1);
+                patentPerson.setType(type);
+                patentPerson.setName(names.get(i));
+                patentPeople.add(patentPerson);
+            }
+            patent.setApplicant(patentPeople);
+        }
+    }
+
+
     /**
      * 装载申请日
      *
@@ -639,7 +729,7 @@ public class WebVOTransformService {
      * @param patent
      * @param cnFullXmlStr
      */
-    private void loadFullText(Patent patent, String cnFullXmlStr) {
+    public void loadFullText(Patent patent, String cnFullXmlStr) {
         try {
             //若没有取到全文文本，即取不到说明书文本，则将当前申请号或专利号和备注信息记录到问题记录表
             if (cnFullXmlStr.equals("")) {
@@ -729,8 +819,6 @@ public class WebVOTransformService {
                     if (elements.size() == 0) {
                         elements = element.elements("ClaimText");
                     }
-
-//                     elements = (List<Element>) xpath.selectNodes(element);
                     StringBuilder stringBuilder = new StringBuilder();
 
                     elements.forEach(item -> {
@@ -756,7 +844,13 @@ public class WebVOTransformService {
                 params.setContent(reClaim);
                 params.setPatentNo(patent.getPatentNo());
                 List<RePatentClaim> rePatentClaims = ClaimSplitUtils.formatPatentRight(params);
-                System.out.println(rePatentClaims);
+            List<RePatentClaim> mainClaims =rePatentClaims.stream().filter(item->item.getParentSort()!=null&&item.getParentSort().equals("-1")).collect(Collectors.toList());
+                if(rePatentClaims!=null){
+                    patent.setRightNum(rePatentClaims.size());
+                }
+                if(mainClaims!=null){
+                    patent.setMainRightNum(mainClaims.size());
+                }
             }
         } catch (Exception e) {
             e.printStackTrace();