Merge remote-tracking branch 'origin/master'

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.common.dto;
+
+import lombok.Data;
+
+@Data
+public class TranslateDTO {
+
+    //专利号
+    private String patentNo;
+
+    //翻译标题、摘要   1标题 2摘要 3权要 4说明书
+    private String patentField;
+
+    //翻译权利要求、说明书---段落项
+    private Integer order;
+
+    //翻译文本
+    private String content;
+}

src/main/java/cn/cslg/pas/common/dto/es/EsTranslateDTO.java

@@ -0,0 +1,18 @@
+package cn.cslg.pas.common.dto.es;
+
+import cn.cslg.pas.domain.es.Content;
+import lombok.Data;
+
+@Data
+public class EsTranslateDTO {
+
+    private String patentNo;
+
+    private String patentField;
+
+    private String language;
+
+    private Boolean ifOrigin;
+
+    private Content content;
+}

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

@@ -0,0 +1,21 @@
+package cn.cslg.pas.common.vo;
+
+import lombok.Data;
+
+@Data
+public class TranslateVO {
+
+    private String patentNo;
+
+    private String originalContent;
+
+    private String translationContent;
+
+    private Integer order;
+
+    private String patentField;
+
+    private String language;
+
+    private String parentSort;
+}

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

@@ -0,0 +1,74 @@
+package cn.cslg.pas.controller;
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.dto.TranslateDTO;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.TranslateVO;
+import cn.cslg.pas.service.common.TranslateService;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@RequestMapping(Constants.API_XiaoSHI + "/translate")
+@RestController
+public class TranslateController {
+
+    @Autowired
+    private TranslateService translateService;
+
+    @Operation(summary = "根据标题和摘要获取翻译内容")
+    @PostMapping("/getTranslateByTIAndAb")
+    public Response getTranslateByTIAndAb(@RequestBody TranslateDTO vo) throws Exception {
+        TranslateVO translateVO = null;
+        try {
+            translateVO = translateService.getTranslateByTIAndAb(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(translateVO);
+    }
+
+    @Operation(summary = "根据权利要求或说明书获取翻译内容")
+    @PostMapping("/getTranslate")
+    public Response getTranslate(@RequestBody TranslateDTO vo) throws Exception {
+        List<TranslateVO> translateVOS = new ArrayList<>();
+        try {
+            translateVOS = translateService.getTranslate(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(translateVOS);
+    }
+
+    @Operation(summary = "翻译权利要求/说明书段落")
+    @PostMapping("/getTranslateOrder")
+    public Response getTranslateOrder(@RequestBody TranslateDTO vo) throws Exception {
+        List<TranslateVO> translateVOS = new ArrayList<>();
+        try {
+            translateVOS = translateService.getTranslateOrder(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(translateVOS);
+    }
+
+    @Operation(summary = "根据文本获取翻译内容")
+    @PostMapping("/getTranslateByText")
+    public Response getTranslateByText(@RequestBody TranslateDTO vo) throws Exception {
+        TranslateVO translateVO = null;
+        try {
+            translateVO = translateService.getTranslateByText(vo);
+        } catch (Exception e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success(translateVO);
+    }
+}

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

@@ -0,0 +1,26 @@
+package cn.cslg.pas.domain.es;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Content {
+
+    //排序
+    @JsonProperty("order")
+    private Integer order;
+
+    //父排序
+    @JsonProperty("parent_sort")
+    private String parentSort;
+
+    //内容
+    @JsonProperty("text_content")
+    private String textContent;
+}

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

@@ -0,0 +1,33 @@
+package cn.cslg.pas.domain.es;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class PatentTranslate {
+
+    //专利号
+    @JsonProperty("patent_no")
+    private String patentNo;
+
+    //专利栏位      1标题 2摘要 3权要 4说明书
+    @JsonProperty("patent_field")
+    private String patentField;
+
+    //语言
+    @JsonProperty("language")
+    private String language;
+
+    //是否是原始
+    @JsonProperty("if_origin")
+    private Boolean ifOrigin;
+
+    @JsonProperty("content")
+    private Content content;
+}

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

@@ -1,33 +1,50 @@
 package cn.cslg.pas.service.common;
 
-import cn.cslg.pas.common.dto.OPS.GetSearchBiblioParamsDTO;
-import cn.cslg.pas.common.utils.DataUtils;
-import cn.cslg.pas.common.utils.DateUtils;
-import cn.hutool.crypto.SecureUtil;
-import cn.hutool.crypto.digest.HMac;
+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 okhttp3.MediaType;
-import okhttp3.OkHttpClient;
-import okhttp3.Request;
-import okhttp3.RequestBody;
-import org.springframework.beans.factory.annotation.Value;
+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;
+import org.springframework.util.CollectionUtils;
 
 import java.io.IOException;
-import java.util.Base64;
-import java.util.Date;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
-import java.util.Base64.Encoder;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @Service
+@RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class TranslateService {
+    private final ElasticsearchClient client;
 
-
+    //---------------------外部翻译接口------------------------
     public static com.aliyun.alimt20181012.Client createClient() throws Exception {
-
         String key = "LTAI5tGyG1Q7fKprgg1nWhXj";
         String sercet = "Y6Erboh5lEFiRPR4XK8oCPMvUzYGLN";
         // 工程代码泄露可能会导致 AccessKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考。
@@ -42,19 +59,19 @@ public class TranslateService {
         return new com.aliyun.alimt20181012.Client(config);
     }
 
-    public String translateGeneral() throws Exception {
+    public String getTranslateContent(String content) throws Exception {
         com.aliyun.alimt20181012.Client client = TranslateService.createClient();
         com.aliyun.alimt20181012.models.TranslateGeneralRequest translateGeneralRequest = new com.aliyun.alimt20181012.models.TranslateGeneralRequest()
                 .setFormatType("text")
                 .setSourceLanguage("auto")
                 .setTargetLanguage("zh")
-                .setSourceText("my name is limeimei")
+                .setSourceText(content)
                 .setScene("general");
         com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
         try {
             // 复制代码运行请自行打印 API 的返回值
             TranslateGeneralResponse translateGeneralResponse = client.translateGeneralWithOptions(translateGeneralRequest, runtime);
-      String re= translateGeneralResponse.getBody().getData().translated;
+            String re = translateGeneralResponse.getBody().getData().translated;
             return re;
         } catch (TeaException error) {
             // 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
@@ -74,4 +91,384 @@ public class TranslateService {
         }
         return "";
     }
+
+    //根据专利号获取专利信息
+    public PatentColumnDTO getPatentByPatentNo(String patentNo) throws IOException {
+        PatentColumnDTO patentColumnDTO = new PatentColumnDTO();
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        //设置查询索引
+        builder.index("patent");
+        Query query = QueryBuilders.term(t -> t.field("patent_no.keyword").value(patentNo));
+        builder.query(query);
+        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+        List<Hit<Patent>> hits = response.hits().hits();
+        for (Hit<Patent> hit : hits) {
+            Patent patent = hit.source();
+            BeanUtils.copyProperties(patent, patentColumnDTO);
+        }
+        return patentColumnDTO;
+    }
+
+    //根据专利号、字段栏位、序号获取专利翻译信息
+    public List<EsTranslateDTO> getPatentTranslateByPatentNo(TranslateDTO vo) throws IOException {
+        String patentNo = vo.getPatentNo();
+        String patentField = vo.getPatentField();
+        Integer order = vo.getOrder();
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        //设置查询索引
+        builder.index("translate");
+        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 (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<>();
+        for (Hit<PatentTranslate> hit : hits) {
+            PatentTranslate translate = hit.source();
+            EsTranslateDTO translateDTO = new EsTranslateDTO();
+            BeanUtils.copyProperties(translate, translateDTO);
+            translateDTOS.add(translateDTO);
+        }
+        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 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();
+        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> 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 claim
+     * @param patentNo
+     * @param patentField
+     * @throws Exception
+     */
+    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,
+                            i, 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
+     */
+    public TranslateVO getTranslateByText(TranslateDTO vo) throws Exception {
+        String translateContent = this.getTranslateContent(vo.getContent());
+        TranslateVO translateVO = new TranslateVO();
+        translateVO.setOriginalContent(vo.getContent());
+        translateVO.setTranslationContent(translateContent);
+        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);
@@ -91,7 +91,7 @@ public class ClaimTextTests {
     @Test
     public void testTranslate() {
         try {
-            String a = translateService.translateGeneral();
+            String a = translateService.getTranslateContent("where are you from");
             System.out.println(a);
         } catch (Exception e) {
             e.printStackTrace();

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());
     }
 
 }