add translate

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

@@ -0,0 +1,15 @@
+package cn.cslg.pas.common.vo;
+
+import lombok.Data;
+
+@Data
+public class EsExplainTextVO {
+
+    private String content;
+
+    private Integer sort;
+
+    private String language;
+
+    private Boolean ifOrigin;
+}

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

@@ -14,4 +14,8 @@ public class TranslateVO {
     private Integer order;
 
     private String patentField;
+
+    private String language;
+
+    private String parentSort;
 }

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

@@ -36,24 +36,24 @@ public class TranslateController {
         return Response.success(translateVO);
     }
 
-    @Operation(summary = "根据权利要求获取翻译内容")
-    @PostMapping("/getTranslateByClaim")
-    public Response getTranslateByClaim(@RequestBody TranslateDTO vo) throws Exception {
+    @Operation(summary = "根据权利要求或说明书获取翻译内容")
+    @PostMapping("/getTranslate")
+    public Response getTranslate(@RequestBody TranslateDTO vo) throws Exception {
         List<TranslateVO> translateVOS = new ArrayList<>();
         try {
-            translateVOS = translateService.getTranslateByClaim(vo);
+            translateVOS = translateService.getTranslate(vo);
         } catch (Exception e) {
             return Response.error(e.getMessage());
         }
         return Response.success(translateVOS);
     }
 
-    @Operation(summary = "根据说明书获取翻译内容")
-    @PostMapping("/getTranslateByPFT")
-    public Response getTranslateByPFT(@RequestBody TranslateDTO vo) throws Exception {
+    @Operation(summary = "翻译权利要求/说明书段落")
+    @PostMapping("/getTranslateOrder")
+    public Response getTranslateOrder(@RequestBody TranslateDTO vo) throws Exception {
         List<TranslateVO> translateVOS = new ArrayList<>();
         try {
-            translateVOS = translateService.getTranslateByPFT(vo);
+            translateVOS = translateService.getTranslateOrder(vo);
         } catch (Exception e) {
             return Response.error(e.getMessage());
         }

src/main/java/cn/cslg/pas/service/common/TranslateService.java

@@ -4,18 +4,31 @@ import cn.cslg.pas.common.dto.PatentColumnDTO;
 import cn.cslg.pas.common.dto.TranslateDTO;
 import cn.cslg.pas.common.dto.business.SelectClaimDTO;
 import cn.cslg.pas.common.dto.es.EsTranslateDTO;
+import cn.cslg.pas.common.utils.ClaimUtils.ClaimSplitUtils;
+import cn.cslg.pas.common.vo.EsExplainTextVO;
+import cn.cslg.pas.common.vo.PatentRightParams;
+import cn.cslg.pas.common.vo.RePatentClaim;
 import cn.cslg.pas.common.vo.TranslateVO;
+import cn.cslg.pas.domain.es.Content;
 import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.domain.es.PatentTranslate;
+import cn.cslg.pas.domain.es.Text;
+import cn.cslg.pas.exception.XiaoShiException;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch._types.InlineScript;
+import co.elastic.clients.elasticsearch._types.Script;
 import co.elastic.clients.elasticsearch._types.query_dsl.Query;
 import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
 import co.elastic.clients.elasticsearch.core.SearchRequest;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
+import co.elastic.clients.elasticsearch.core.UpdateByQueryRequest;
 import co.elastic.clients.elasticsearch.core.search.Hit;
 import com.aliyun.alimt20181012.models.TranslateGeneralResponse;
 import com.aliyun.tea.TeaException;
 import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -23,6 +36,7 @@ import org.springframework.util.CollectionUtils;
 
 import java.io.IOException;
 import java.util.*;
+import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
@@ -106,13 +120,15 @@ public class TranslateService {
         Query q1 = QueryBuilders.term(t -> t.field("patent_no").value(patentNo));
         Query q2 = QueryBuilders.term(t -> t.field("patent_field").value(patentField));
         Query bool = null;
-        if (patentField.equals("3") || patentField.equals("4")) {
+        if (order != null && (patentField.equals("3") || patentField.equals("4"))) {
             Query q3 = QueryBuilders.term(t -> t.field("content.order").value(order));
             bool = QueryBuilders.bool(i -> i.must(q1, q2, q3));
         } else {
             bool = QueryBuilders.bool(i -> i.must(q1, q2));
         }
         builder.query(bool);
+        builder.size(1000);
+        builder.trackTotalHits(i -> i.enabled(true));
         SearchResponse<PatentTranslate> response = client.search(builder.build(), PatentTranslate.class);
         List<Hit<PatentTranslate>> hits = response.hits().hits();
         List<EsTranslateDTO> translateDTOS = new ArrayList<>();
@@ -125,49 +141,302 @@ public class TranslateService {
         return translateDTOS;
     }
 
-    //添加专利翻译
+    //添加
+    public String addPatentTranslate(PatentTranslate translate) throws Exception {
+        IndexResponse indexResponse = client.index(i -> i
+                .index("translate")
+                //传入user对象
+                .document(translate)
+        );
+        return indexResponse.id();
+    }
+
+    //封装添加参数
+    public String loadingTranslate(String patentNo, String patentField,String language,Boolean ifOrigin,Integer order,String parentSort,String textContent) throws Exception {
+        PatentTranslate translate = new PatentTranslate();
+        translate.setLanguage(language);
+        translate.setPatentNo(patentNo);
+        translate.setPatentField(patentField);
+        translate.setIfOrigin(ifOrigin);
+        Content content = new Content();
+        content.setOrder(order);
+        content.setParentSort(parentSort);
+        content.setTextContent(textContent);
+        translate.setContent(content);
+        return this.addPatentTranslate(translate);
+    }
 
+    //添加标题、摘要原/译文
+    public Integer addTranslate(Text text, String patentNo,String patentField) throws Exception {
+        int i = 0;
+        String textContent = text.getTextContent();
+        //原文
+        String s = this.loadingTranslate(patentNo, patentField, text.getLanguage(), true, 0, "-1", textContent);
+        if (StringUtils.isNotEmpty(s)) {
+            i += 1;
+        }
+        //译文
+        String translateContent = this.getTranslateContent(textContent);
+        String s1 = this.loadingTranslate(patentNo, patentField, "CN", false, 0, "-1", translateContent);
+        if (StringUtils.isNotEmpty(s1)) {
+            i += 1;
+        }
+        return i;
+    }
 
     //------------------------------------返回翻译内容--------------------------
 
     /**
      * 根据标题和摘要获取翻译内容
+     *
      * @param vo
      * @return
      */
-    public TranslateVO getTranslateByTIAndAb(TranslateDTO vo) throws IOException {
+    public TranslateVO getTranslateByTIAndAb(TranslateDTO vo) throws Exception {
+        String patentNo = vo.getPatentNo();
+        String patentField = vo.getPatentField();
+        TranslateVO translateVO = new TranslateVO();
         List<EsTranslateDTO> translateDTOS = this.getPatentTranslateByPatentNo(vo);
         if (CollectionUtils.isEmpty(translateDTOS)) {
-
+            PatentColumnDTO columnDTO = this.getPatentByPatentNo(patentNo);
+            if (patentField.equals("1")) {
+                List<Text> title = columnDTO.getTitle();
+                if (!CollectionUtils.isEmpty(title)) {
+                    Text titleText = title.get(0);
+                    Integer translateNum = this.addTranslate(titleText, patentNo,patentField);
+                    if (translateNum < 1) {
+                        throw new XiaoShiException("添加标题翻译失败");
+                    }
+                }
+            } else if (patentField.equals("2")) {
+                List<Text> abstractStr = columnDTO.getAbstractStr();
+                if (!CollectionUtils.isEmpty(abstractStr)) {
+                    Text abstractText = abstractStr.get(0);
+                    Integer translateNum = this.addTranslate(abstractText, patentNo,patentField);
+                    if (translateNum < 1) {
+                        throw new XiaoShiException("添加摘要翻译失败");
+                    }
+                }
+            }
+            try {
+                Thread.sleep(800);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            translateDTOS = this.getPatentTranslateByPatentNo(vo);
+            translateVO = this.loadTIAndAbTranslate(translateDTOS);
+        } else {
+            translateVO = this.loadTIAndAbTranslate(translateDTOS);
         }
+        return translateVO;
+    }
+
+    //加载标题、摘要的翻译返回内容
+    public TranslateVO loadTIAndAbTranslate(List<EsTranslateDTO> translateDTOS) {
         TranslateVO translateVO = new TranslateVO();
-        translateVO.setOriginalContent(vo.getContent());
-        translateVO.setTranslationContent("");
+        List<EsTranslateDTO> tList = translateDTOS.stream().filter(EsTranslateDTO::getIfOrigin).collect(Collectors.toList());
+        if (!CollectionUtils.isEmpty(tList)) {
+            EsTranslateDTO translateDTO = tList.get(0);
+            translateVO.setOriginalContent(translateDTO.getContent().getTextContent());
+        }
+        List<EsTranslateDTO> fList = translateDTOS.stream().filter(i -> !i.getIfOrigin()).collect(Collectors.toList());
+        if (!CollectionUtils.isEmpty(fList)) {
+            EsTranslateDTO translateDTO = fList.get(0);
+            translateVO.setPatentNo(translateDTO.getPatentNo());
+            translateVO.setPatentField(translateDTO.getPatentField());
+            translateVO.setLanguage(translateDTO.getLanguage());
+            translateVO.setTranslationContent(translateDTO.getContent().getTextContent());
+        }
         return translateVO;
     }
 
     /**
      * 根据权利要求获取翻译内容
+     *
      * @param vo
      * @return
      */
-    public List<TranslateVO> getTranslateByClaim(TranslateDTO vo) {
+    public List<TranslateVO> getTranslate(TranslateDTO vo) throws Exception {
         List<TranslateVO> translateVOS = new ArrayList<>();
+        String patentNo = vo.getPatentNo();
+        String patentField = vo.getPatentField();
+        List<EsTranslateDTO> translateDTOS = this.getPatentTranslateByPatentNo(vo);
+        if (CollectionUtils.isEmpty(translateDTOS)) {
+            PatentColumnDTO columnDTO = this.getPatentByPatentNo(patentNo);
+            if (patentField.equals("3")) {
+                List<Text> claim = columnDTO.getClaim();
+                this.addOldClaimTranslate(claim, patentNo, patentField);
+            } else if (patentField.equals("4")) {
+                List<Text> explainText = columnDTO.getPublicFullText();
+                this.addOldPFTTranslate(explainText, patentNo, patentField);
+            }
+            try {
+                Thread.sleep(800);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            translateDTOS = this.getPatentTranslateByPatentNo(vo);
+            translateVOS = this.loadTranslate(translateDTOS);
+        } else {
+            translateVOS = this.loadTranslate(translateDTOS);
+        }
+
         return translateVOS;
     }
 
     /**
-     * 根据说明书获取翻译内容
-     * @param vo
-     * @return
+     * 添加权利要求原文
+     * @param claim
+     * @param patentNo
+     * @param patentField
+     * @throws Exception
      */
-    public List<TranslateVO> getTranslateByPFT(TranslateDTO vo) {
+    public void addOldClaimTranslate(List<Text> claim, String patentNo, String patentField) throws Exception {
+        if (!CollectionUtils.isEmpty(claim)) {
+            int i = 0;
+            List<Text> tList = claim.stream().filter(Text::getIfOrigin).collect(Collectors.toList());
+            if (!CollectionUtils.isEmpty(tList)) {
+                Text text = tList.get(0);
+                PatentRightParams params = new PatentRightParams();
+                params.setContent(text.getTextContent());
+                params.setCountry(text.getLanguage());
+                List<RePatentClaim> rePatentClaims = ClaimSplitUtils.formatPatentRight(params);
+                for (RePatentClaim rePatentClaim : rePatentClaims) {
+                    //原文
+                    String s = this.loadingTranslate(patentNo, patentField, text.getLanguage(), true,
+                            rePatentClaim.getSort(), rePatentClaim.getParentSort(), rePatentClaim.getContent());
+                    if (StringUtils.isNotEmpty(s)) {
+                        i += 1;
+                    }
+                }
+                if (i < 1) {
+                    throw new XiaoShiException("添加权利要求原文失败");
+                }
+            }
+        }
+    }
+
+    /**
+     * 添加原文说明书
+     * @param text
+     * @param patentNo
+     * @param patentField
+     * @throws Exception
+     */
+    public void addOldPFTTranslate(List<Text> text, String patentNo, String patentField) throws Exception {
+        if (!CollectionUtils.isEmpty(text)) {
+            int i = 0;
+            List<EsExplainTextVO> explainTextVOS = this.splitPatentExplainText(text);
+            for (EsExplainTextVO explainTextVO : explainTextVOS) {
+                //原文
+                String s = this.loadingTranslate(patentNo, patentField, explainTextVO.getLanguage(), explainTextVO.getIfOrigin(),
+                        explainTextVO.getSort(), "-1", explainTextVO.getContent());
+                if (StringUtils.isNotEmpty(s)) {
+                    i += 1;
+                }
+            }
+            if (i < 1) {
+                throw new XiaoShiException("添加说明书原文失败");
+            }
+        }
+    }
+
+    //封装说明书、权利要求数据
+    public List<TranslateVO> loadTranslate(List<EsTranslateDTO> translateDTOS) {
+        List<TranslateVO> VOS = new ArrayList<>();
+        if (!CollectionUtils.isEmpty(translateDTOS)) {
+            List<TranslateVO> list = new ArrayList<>();
+            List<TranslateVO> tVOS = new ArrayList<>();
+            List<EsTranslateDTO> tList = translateDTOS.stream().filter(EsTranslateDTO::getIfOrigin).collect(Collectors.toList());
+            for (EsTranslateDTO translateDTO : tList) {
+                Content content = translateDTO.getContent();
+                TranslateVO translateVO = new TranslateVO();
+                translateVO.setPatentNo(translateDTO.getPatentNo());
+                translateVO.setLanguage(translateDTO.getLanguage());
+                translateVO.setPatentField(translateDTO.getPatentField());
+                translateVO.setOrder(content.getOrder());
+                translateVO.setOriginalContent(content.getTextContent());
+                translateVO.setParentSort(content.getParentSort());
+                tVOS.add(translateVO);
+            }
+            List<EsTranslateDTO> fList = translateDTOS.stream().filter(i -> !i.getIfOrigin()).collect(Collectors.toList());
+            if (!CollectionUtils.isEmpty(fList)) {
+                List<TranslateVO> fVOS = new ArrayList<>();
+                for (EsTranslateDTO translateDTO : fList) {
+                    Content content = translateDTO.getContent();
+                    TranslateVO translateVO = new TranslateVO();
+                    translateVO.setPatentNo(translateDTO.getPatentNo());
+                    translateVO.setLanguage(translateDTO.getLanguage());
+                    translateVO.setPatentField(translateDTO.getPatentField());
+                    translateVO.setOrder(content.getOrder());
+                    translateVO.setTranslationContent(content.getTextContent());
+                    translateVO.setParentSort(content.getParentSort());
+                    fVOS.add(translateVO);
+                }
+                Map<Integer, TranslateVO> fVOMap = new HashMap<>();
+                for (TranslateVO fVO : fVOS) {
+                    fVOMap.put(fVO.getOrder(), fVO);
+                }
+
+                for (TranslateVO tVO : tVOS) {
+                    TranslateVO fVO = fVOMap.get(tVO.getOrder());
+                    if (fVO != null) {
+                        TranslateVO translateVO = new TranslateVO();
+                        translateVO.setPatentNo(tVO.getPatentNo());
+                        translateVO.setLanguage(fVO.getLanguage());
+                        translateVO.setPatentField(tVO.getPatentField());
+                        translateVO.setOriginalContent(tVO.getOriginalContent());
+                        translateVO.setParentSort(tVO.getParentSort());
+                        translateVO.setOrder(tVO.getOrder());
+                        translateVO.setTranslationContent(fVO.getTranslationContent());
+                        list.add(translateVO);
+                    } else {
+                        list.add(tVO);
+                    }
+                }
+            } else {
+                list.addAll(tVOS);
+            }
+            List<TranslateVO> translateVOS = list.stream().sorted(Comparator.comparing(TranslateVO::getOrder)).collect(Collectors.toList());
+            VOS.addAll(translateVOS);
+        }
+        return VOS;
+    }
+
+    public List<TranslateVO> getTranslateOrder(TranslateDTO vo) throws Exception {
         List<TranslateVO> translateVOS = new ArrayList<>();
+        List<EsTranslateDTO> translateDTOS = this.getPatentTranslateByPatentNo(vo);
+        List<EsTranslateDTO> fList = translateDTOS.stream().filter(i -> !i.getIfOrigin()).collect(Collectors.toList());
+        if (!CollectionUtils.isEmpty(translateDTOS) && CollectionUtils.isEmpty(fList)) {
+            int i = 0;
+            for (EsTranslateDTO translateDTO : translateDTOS) {
+                Content content = translateDTO.getContent();
+                String translateContent = this.getTranslateContent(content.getTextContent());
+                String s = this.loadingTranslate(translateDTO.getPatentNo(), translateDTO.getPatentField(), "CN", false,
+                        content.getOrder(), content.getParentSort(), translateContent);
+                if (StringUtils.isNotEmpty(s)) {
+                    i++;
+                }
+            }
+            if (i < 1) {
+                throw new XiaoShiException("添加译文失败");
+            }
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            translateDTOS = this.getPatentTranslateByPatentNo(vo);
+            translateVOS = this.loadTranslate(translateDTOS);
+        } else {
+            translateVOS = this.loadTranslate(translateDTOS);
+        }
         return translateVOS;
     }
 
     /**
      * 根据文本获取翻译内容
+     *
      * @param vo
      * @return
      */
@@ -179,5 +448,27 @@ public class TranslateService {
         return translateVO;
     }
 
-
+    //拆分说明书
+    public List<EsExplainTextVO> splitPatentExplainText(List<Text> list) {
+        List<EsExplainTextVO> explainTextVOS = new ArrayList<>();
+        List<Text> collect = list.stream().filter(Text::getIfOrigin).collect(Collectors.toList());
+        if (!CollectionUtils.isEmpty(collect)) {
+            Text text = collect.get(0);
+            int j = 0;
+            String content = text.getTextContent();
+            String[] split = content.split("(\r\n){1,}");
+            for (String s1 : split) {
+                if (StringUtils.isNotEmpty(s1) && !s1.equals(" ")) {
+                    EsExplainTextVO textVO = new EsExplainTextVO();
+                    textVO.setSort(j);
+                    textVO.setContent(s1);
+                    textVO.setLanguage(text.getLanguage());
+                    textVO.setIfOrigin(text.getIfOrigin());
+                    explainTextVOS.add(textVO);
+                    j++;
+                }
+            }
+        }
+        return explainTextVOS;
+    }
 }

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

@@ -54,7 +54,7 @@ public class ClaimTextTests {
     @Test
     public void testTotal() throws Exception {
         StringRequest stringRequest = new StringRequest();
-        stringRequest.setProjectId(323);
+        stringRequest.setProjectId(330);
         stringRequest.setCurrent(1L);
         stringRequest.setSize(10L);
         PatentDTO patentDTO = esService.esSearch(stringRequest);

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

@@ -13,6 +13,7 @@ import cn.cslg.pas.common.utils.StringUtils;
 import cn.cslg.pas.common.utils.parseQueryToTree.expressManager;
 import cn.cslg.pas.common.utils.parseQueryToTree.operateNode;
 import cn.cslg.pas.common.utils.parseQueryToTree.treeNode;
+import cn.cslg.pas.common.vo.EsExplainTextVO;
 import cn.cslg.pas.common.vo.business.*;
 import cn.cslg.pas.controller.EventController;
 import cn.cslg.pas.controller.PatentController;
@@ -25,6 +26,7 @@ import cn.cslg.pas.service.business.ProductMarketDataService;
 import cn.cslg.pas.service.business.ReportTempleService;
 import cn.cslg.pas.service.business.es.*;
 import cn.cslg.pas.service.common.FileManagerService;
+import cn.cslg.pas.service.common.TranslateService;
 import co.elastic.clients.elasticsearch._types.query_dsl.Query;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.http.entity.ContentType;
@@ -74,6 +76,8 @@ public class EventServiceTests {
     private ProductMarketDataService productMarketDataService;
     @Autowired
     private AssoProjectEventMapper assoProjectEventMapper;
+    @Autowired
+    private TranslateService translateService;
 
     @Test
     void test() throws Exception {
@@ -558,31 +562,8 @@ public class EventServiceTests {
 
     @Test
     public void test106() throws Exception {
-//        String condition = "AGN = (\"深圳市瑞方达知识产权事务所(普通合伙) 44314\")";
-//        ArrayList<String> list = expressManager.getInstance().get(condition);
-//        System.out.println(list);
-        //3. 从es中检索数据
-//        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent", projectId);
-//        List<String> list = Arrays.asList("87K5hY8BdwlBaY8vibM3","DLK3hY8BdwlBaY8vfLLP","FLK3hY8BdwlBaY8vibLp","G7K5hY8BdwlBaY8vkrR7","I7K5hY8BdwlBaY8vnbTN",
-//                "K7K5hY8BdwlBaY8vqLSM","K7LEhY8BdwlBaY8vP72K","M7K5hY8BdwlBaY8vsbRD","ObK3hY8BdwlBaY8vk7Ko","TbIWhY8BdwlBaY8vhS1O",
-//                "XrK2hY8BdwlBaY8v37E8","Bt6xvo8BdwlBaY8vQe2a","Y7K3hY8BdwlBaY8vwLL8","ZrK2hY8BdwlBaY8v7LEH","i7K2hY8BdwlBaY8v9bHY",
-//                "k7LJhY8BdwlBaY8vq8Fi","lLK3hY8BdwlBaY8vAbFG","m7LJhY8BdwlBaY8vtcGx","nLK3hY8BdwlBaY8vGLFD","q7K5hY8BdwlBaY8vUrOz","s7K5hY8BdwlBaY8vX7MV",
-//                "u7LBhY8BdwlBaY8vn7qI","wbLJhY8BdwlBaY8vvcEH","xLK3hY8BdwlBaY8vIrH6","y7LEhY8BdwlBaY8vE7wT","y7LJhY8BdwlBaY8vxsG6");
-//        list.forEach(System.out::println);
-//        List<String> collect = list.stream().distinct().collect(Collectors.toList());
-//        System.out.println(collect.size());
-        List<BigDecimal> list = new ArrayList<>();
-        list.add(new BigDecimal(2.3));
-        list.add(new BigDecimal(3));
-        list.add(new BigDecimal(45));
-        list.add(new BigDecimal(13));
-        list.add(new BigDecimal(1));
-        BigDecimal init = new BigDecimal(0);
-        for (BigDecimal bigDecimal : list) {
-            init = init.compareTo(bigDecimal) >= 0 ? init : bigDecimal;
-        }
-        System.out.println(init);
-
+//        List<EsExplainTextVO> explainTextVOS = translateService.splitPatentExplainText("TH95370B");
+//        System.out.println(explainTextVOS.size());
     }
 
 }