Merge remote-tracking branch 'origin/master' into prod_test

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/utils/PatentNoUtil.java

@@ -25,4 +25,21 @@ public class PatentNoUtil {
             throw new IllegalArgumentException("Invalid patent number format: " + patentNo);
         }
     }
+
+
+    public static String formatApNo(String patentNo){
+        Pattern patternEn = Pattern.compile("^[A-Za-z]{2}.*");
+        Matcher matcher = patternEn.matcher(patentNo);
+        if(!matcher.find()){
+            patentNo ="CN"+patentNo;
+        }
+        String numbers = patentNo.replaceAll("[^\\d]", "");
+        char secondLastChar = patentNo.charAt(patentNo.length() - 2);
+        if(numbers.length()==13&&secondLastChar!='.'){
+            StringBuilder stringBuilder =new StringBuilder(patentNo);
+            stringBuilder.insert(patentNo.length() - 1,".");
+            patentNo =stringBuilder.toString();
+        }
+        return patentNo;
+    }
 }

src/main/java/cn/cslg/pas/common/utils/commonUtils/ReflectionUtil.java

@@ -0,0 +1,42 @@
+package cn.cslg.pas.common.utils.commonUtils;
+
+
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ReflectionUtil {
+
+    public static Object getClassObject(String typeName, String jarOrClassPath) {
+
+        if (jarOrClassPath != null) {
+            try {
+                //用路径创建Url
+                URL url = new URL("file:" + jarOrClassPath);
+                //通过Url加载外部的jar包
+                URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});
+                Class<?> clazz = urlClassLoader.loadClass(typeName);
+                return clazz.newInstance();
+            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | MalformedURLException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                return Class.forName(typeName).newInstance();
+            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+}

src/main/java/cn/cslg/pas/common/utils/parseQueryToTree/expressManager.java

@@ -43,13 +43,6 @@ public class expressManager {
         oOR.operateValue = 2;
         hSymbols.put(oOR.Code, oOR);
 
-        oOR = new operate();
-        oOR.Code = "~";
-        oOR.ShowName = "TO";
-        oOR.type = enuType.Logic;
-        oOR.priorityVale = 21;
-        oOR.operateValue = 2;
-        hSymbols.put(oOR.Code, oOR);
 
         oOR = new operate();
         oOR.Code = "=";
@@ -398,7 +391,6 @@ public class expressManager {
                         }
                         break;
                     case '=':
-                    case '~':
                     case '>':
                     case '＞':
                     case '<':

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

@@ -31,10 +31,13 @@ public class PatentRightTree {
      */
     private List<PatentRightTree> children;
 
-    public PatentRightTree(Integer sort, List<Integer> parentSorts, String content) {
+    private String translateContent;
+
+    public PatentRightTree(Integer sort, List<Integer> parentSorts, String content,String translateContent) {
         this.sort = sort;
         this.parentSorts = parentSorts;
         this.content = content;
+        this.translateContent = translateContent;
     }
 
 }

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

@@ -98,7 +98,6 @@ public class InvalidStatutesController {
     public Response importFinalInvalidStatues(Integer id) {
         try {
            finalInvalidStatueService.importFinalInvalidStatutes(id);
-
         } catch (Exception e) {
             return Response.error(e.getMessage());
         }

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/factorys/EsBuilderFactory/DateQueryBuilder.java

@@ -25,9 +25,239 @@ public class DateQueryBuilder implements IQueryBuilder {
     public static final String EQ = "=";
 
 
+    //  @Override
+//    public Query creteQuery() throws ParseException {
+//        Query query = null;
+//        if (value != null && !"".equals(value)) {
+//            Calendar calendar = Calendar.getInstance();
+//            if (value.length() == YEAR) {
+//                SimpleDateFormat format = new SimpleDateFormat("yyyy");
+//                Date year = format.parse(value);
+//                calendar.setTime(year);
+//                String yearTime = String.valueOf(calendar.getTime().getTime());
+//                calendar.add(Calendar.YEAR, 1);
+//                String yearNextTime = String.valueOf(calendar.getTime().getTime());
+//                switch (operator) {
+//                    case NumberQueryBuilder.LT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lt(JsonData.of(yearTime)));
+//                        break;
+//                    case NumberQueryBuilder.LTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lte(JsonData.of(yearTime)));
+//                        break;
+//                    case NumberQueryBuilder.GT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gt(JsonData.of(yearTime)));
+//                        break;
+//                    case NumberQueryBuilder.GTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(yearTime)));
+//                        break;
+//                    default:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(yearTime)).lt(JsonData.of(yearNextTime)));
+//                        break;
+//                }
+//            } else if (value.length() == MONTH || value.length() == MONTHONE) {
+//                Date month = new Date();
+//                if (value.contains("-")) {
+//                    SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM");
+//                    month = format2.parse(value);
+//                } else if (value.contains("/")) {
+//                    SimpleDateFormat format3 = new SimpleDateFormat("yyyy/MM");
+//                    month = format3.parse(value);
+//                } else {
+//                    SimpleDateFormat format1 = new SimpleDateFormat("yyyyMM");
+//                    month = format1.parse(value);
+//                }
+//                calendar.setTime(month);
+//                String monthTime = String.valueOf(calendar.getTime().getTime());
+//                calendar.add(Calendar.MONTH, 1);
+//                String monthNextTime = String.valueOf(calendar.getTime().getTime());
+//                switch (operator) {
+//                    case NumberQueryBuilder.LT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lt(JsonData.of(monthTime)));
+//                        break;
+//                    case NumberQueryBuilder.LTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lte(JsonData.of(monthTime)));
+//                        break;
+//                    case NumberQueryBuilder.GT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gt(JsonData.of(monthTime)));
+//                        break;
+//                    case NumberQueryBuilder.GTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(monthTime)));
+//                        break;
+//                    default:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(monthTime)).lt(JsonData.of(monthNextTime)));
+//                        break;
+//                }
+//            } else if (value.length() == DAY || value.length() == DAYONE) {
+//                Date day = new Date();
+//                if (value.contains("-")) {
+//                    SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
+//                    day = format2.parse(value);
+//                } else if (value.contains("/")) {
+//                    SimpleDateFormat format3 = new SimpleDateFormat("yyyy/MM/dd");
+//                    day = format3.parse(value);
+//                } else {
+//                    SimpleDateFormat format1 = new SimpleDateFormat("yyyyMMdd");
+//                    day = format1.parse(value);
+//                }
+//                calendar.setTime(day);
+//                String dayTime = String.valueOf(day.getTime());
+//                calendar.add(Calendar.DAY_OF_MONTH, 1);
+//                String nextDayTime = String.valueOf(calendar.getTime().getTime());
+//                switch (operator) {
+//                    case NumberQueryBuilder.LT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lt(JsonData.of(dayTime)));
+//                        break;
+//                    case NumberQueryBuilder.LTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).lte(JsonData.of(dayTime)));
+//                        break;
+//                    case NumberQueryBuilder.GT:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gt(JsonData.of(dayTime)));
+//                        break;
+//                    case NumberQueryBuilder.GTE:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(dayTime)));
+//                        break;
+//                    default:
+//                        query = QueryBuilders
+//                                .range(range -> range.field(field).gte(JsonData.of(dayTime)).lt(JsonData.of(nextDayTime)));
+//                        break;
+//                }
+//            } else {
+//                query = QueryBuilders
+//                        .range(range -> range.field(field).gte(JsonData.of(1)).lte(JsonData.of(2)));
+//            }
+//        }
+//        return query;
+//    }
+
     @Override
     public Query creteQuery() throws ParseException {
         Query query = null;
+        if (value.contains("~")) {
+            String[] dates = value.split("~");
+            String date1 = dates[0];
+            String date2 = dates[1];
+          String  findate1=this.formatDateString(date1);
+         String    findate2 =this.formatDateString(date2);
+           query = QueryBuilders
+                    .range(range -> range.field(field).gte(JsonData.of(findate1)).lte(JsonData.of(findate2)));
+
+        } else {
+            query = this.getSingle();
+        }
+        return query;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    @Override
+    public String getOperator() {
+        return operator;
+    }
+
+    @Override
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Integer getProjectId() {
+        return projectId;
+    }
+
+    @Override
+    public void setProjectId(Integer projectId) {
+        this.projectId = projectId;
+    }
+
+    private String formatDateString(String dateStr) throws ParseException {
+        Calendar calendar = Calendar.getInstance();
+        String formatedTime = "";
+        if (dateStr.length() == YEAR) {
+            SimpleDateFormat format = new SimpleDateFormat("yyyy");
+            Date year = format.parse(dateStr);
+            calendar.setTime(year);
+            String yearTime = String.valueOf(calendar.getTime().getTime());
+            formatedTime = yearTime;
+        } else if (dateStr.length() == MONTH || dateStr.length() == MONTHONE) {
+            Date month = new Date();
+            if (dateStr.contains("-")) {
+                SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM");
+                month = format2.parse(dateStr);
+            } else if (dateStr.contains("/")) {
+                SimpleDateFormat format3 = new SimpleDateFormat("yyyy/MM");
+                month = format3.parse(dateStr);
+            } else {
+                SimpleDateFormat format1 = new SimpleDateFormat("yyyyMM");
+                month = format1.parse(dateStr);
+            }
+            calendar.setTime(month);
+            String monthTime = String.valueOf(calendar.getTime().getTime());
+            formatedTime = monthTime;
+        } else if (dateStr.length() == DAY || dateStr.length() == DAYONE) {
+            Date day = new Date();
+            if (dateStr.contains("-")) {
+                SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
+                day = format2.parse(dateStr);
+            } else if (dateStr.contains("/")) {
+                SimpleDateFormat format3 = new SimpleDateFormat("yyyy/MM/dd");
+                day = format3.parse(dateStr);
+            } else {
+                SimpleDateFormat format1 = new SimpleDateFormat("yyyyMMdd");
+                day = format1.parse(dateStr);
+            }
+            calendar.setTime(day);
+            String dayTime = String.valueOf(day.getTime());
+            formatedTime = dayTime;
+        }
+        return formatedTime;
+    }
+
+
+    private Query getSingle() throws ParseException {
+        Query query = null;
+
         if (value != null && !"".equals(value)) {
             Calendar calendar = Calendar.getInstance();
             if (value.length() == YEAR) {
@@ -141,55 +371,6 @@ public class DateQueryBuilder implements IQueryBuilder {
             }
         }
         return query;
-    }
-
-    @Override
-    public String getField() {
-        return field;
-    }
-
-    @Override
-    public void setField(String field) {
-        this.field = field;
-    }
-
-    @Override
-    public String getValue() {
-        return value;
-    }
-
-    @Override
-    public void setValue(String value) {
-        this.value = value;
-    }
 
-    @Override
-    public String getOperator() {
-        return operator;
-    }
-
-    @Override
-    public void setOperator(String operator) {
-        this.operator = operator;
-    }
-
-    @Override
-    public String getPath() {
-        return path;
-    }
-
-    @Override
-    public void setPath(String path) {
-        this.path = path;
-    }
-
-    @Override
-    public Integer getProjectId() {
-        return projectId;
-    }
-
-    @Override
-    public void setProjectId(Integer projectId) {
-        this.projectId = projectId;
     }
 }

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

@@ -0,0 +1,36 @@
+package cn.cslg.pas.factorys.getSqlFactorys;
+
+import cn.cslg.pas.common.model.cronModel.SqlObject;
+import cn.cslg.pas.common.utils.PatentNoUtil;
+import cn.cslg.pas.factorys.getSqlFactorys.GetSqlObject;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+
+@Slf4j
+@Component
+public class GetWebAppNoSql implements GetSqlObject {
+
+    private SqlObject sqlObject;
+
+    @Override
+    public String getSql(String value) {
+        String filed = sqlObject.getSqlField();
+        String option = sqlObject.getOption();
+        String reQuery = "";
+        if (option.equals("=")) {
+            option = "/";
+        }
+         value = PatentNoUtil.formatApNo(value);
+        reQuery =value + option + filed;
+        return reQuery;
+    }
+
+    public void setSqlObject(SqlObject sqlObject) {
+        this.sqlObject = sqlObject;
+    }
+
+    public SqlObject getSqlObject() {
+        return sqlObject;
+    }
+}

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

@@ -0,0 +1,38 @@
+package cn.cslg.pas.factorys.getSqlFactorys;
+
+import cn.cslg.pas.common.model.cronModel.SqlObject;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+
+@Slf4j
+@Component
+public class GetWebDateSql implements GetSqlObject {
+
+    private SqlObject sqlObject;
+
+    @Override
+    public String getSql(String value) {
+        String filed = sqlObject.getSqlField();
+        String option = sqlObject.getOption();
+        String reQuery = "";
+        if (option.equals("=")) {
+            option = "/";
+        }
+        if (value.trim().contains("~")) {
+            value = value.replace("~", ">");
+            reQuery = value + option + filed;
+        } else {
+            reQuery = value + option + filed;
+        }
+        return reQuery;
+    }
+
+    public void setSqlObject(SqlObject sqlObject) {
+        this.sqlObject = sqlObject;
+    }
+
+    public SqlObject getSqlObject() {
+        return sqlObject;
+    }
+}

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

@@ -121,7 +121,7 @@ public class FinalInvalidStatueService extends ServiceImpl<FinalInvalidStatueMap
 
         List<FinalProofGroup> finalProofGroups = new ArrayList<>();
         LambdaQueryWrapper<FinalProofGroup> queryWrapper1 = new LambdaQueryWrapper<>();
-        queryWrapper1.in(FinalProofGroup::getFinalInvalidStatueId, ids).orderByDesc(FinalProofGroup::getFinalInvalidStatueId);
+        queryWrapper1.in(FinalProofGroup::getFinalInvalidStatueId, ids);
         finalProofGroups = finalProofGroupService.list(queryWrapper1);
 
         for(FinalInvalidStatue finalInvalidStatue:finalInvalidStatues)

src/main/java/cn/cslg/pas/service/business/FeatureService.java

@@ -15,6 +15,7 @@ import cn.cslg.pas.common.vo.*;
 import cn.cslg.pas.common.vo.business.SplitVO;
 import cn.cslg.pas.common.vo.invalidVO.QueryClaimSplitHistoryVO;
 import cn.cslg.pas.domain.business.*;
+import cn.cslg.pas.domain.es.PatentTranslate;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.FeatureMapper;
 import cn.cslg.pas.service.ClaimMessageService;
@@ -22,12 +23,18 @@ import cn.cslg.pas.service.business.es.EsService;
 import cn.cslg.pas.service.business.invalidReport.AssoGroupFeatureService;
 import cn.cslg.pas.service.business.invalidReport.PatentClaimService;
 import cn.cslg.pas.service.common.PatentStarApiService;
+import cn.cslg.pas.service.common.TranslateService;
+import co.elastic.clients.elasticsearch._types.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import co.elastic.clients.elasticsearch.core.SearchRequest;
+import co.elastic.clients.elasticsearch.core.SearchResponse;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 
 import java.io.IOException;
 import java.util.*;
@@ -66,6 +73,9 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
     @Autowired
     private PatentClaimService patentClaimService;
 
+    @Autowired
+    private TranslateService translateService;
+
     @Transactional(rollbackFor = Exception.class)
     public List<PatentRightVo> splitPatentFeature(SplitVO splitVO) throws IOException {
         String patentNo = splitVO.getPatentNo();
@@ -285,13 +295,24 @@ public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
 
             //判断若处理后的权要集合只有1个元素并且类型type=-1、排序号sort=-1，则表示本次拆分失败，则直接返回整个权要
             if (patentRights.size() == 1 && patentRights.get(0).getType() == -1 && patentRights.get(0).getSort() == -1) {
-                treeNodeList.add(new PatentRightTree(patentRights.get(0).getSort(), null, patentRights.get(0).getContent()));
+                List<String> list = translateService.getTranslateOrder(patentNo, patentRights.get(0).getSort());
+                String translateContent = "";
+                if (!CollectionUtils.isEmpty(list)) {
+                    translateContent = list.get(0);
+                }
+                treeNodeList.add(new PatentRightTree(patentRights.get(0).getSort(), null, patentRights.get(0).getContent(),translateContent));
                 return treeNodeList;
             }
             List<PatentRightContent> patentRightContents = this.loadPatentRightContent(patentRights);
             for (PatentRightContent patentRightContent : patentRightContents) {
-                treeNodeList.add(new PatentRightTree(patentRightContent.getSort(), patentRightContent.getParentSorts(), patentRightContent.getContent()));
+                List<String> list = translateService.getTranslateOrder(patentNo, patentRightContent.getSort());
+                String translateContent = "";
+                if (!CollectionUtils.isEmpty(list)) {
+                    translateContent = list.get(0);
+                }
+                treeNodeList.add(new PatentRightTree(patentRightContent.getSort(), patentRightContent.getParentSorts(), patentRightContent.getContent(), translateContent));
             }
+
             //开始进行权要树装载
             try {
                 TreeBuild treeBuild = new TreeBuild(treeNodeList);

src/main/java/cn/cslg/pas/service/business/ProductCategoryService.java

@@ -101,6 +101,13 @@ public class ProductCategoryService extends ServiceImpl<ProductCategoryMapper, P
      */
     @Override
     public Object addMessage(Object object, List<MultipartFile> files) {
+        //获取登陆人信息 用于设置创建人
+        PersonnelVO personnelVO = new PersonnelVO();
+        try {
+            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+        } catch (Exception e) {
+            throw new UnLoginException("未登录");
+        }
         //object to productCategoryDTO
         ProductCategoryDTO productCategoryDTO = (ProductCategoryDTO)object;
         //检测名称是否不规范
@@ -108,18 +115,12 @@ public class ProductCategoryService extends ServiceImpl<ProductCategoryMapper, P
         //根据名称查询数据库中是否存在
         String name = productCategoryDTO.getName();
         LambdaQueryWrapper<ProductCategory> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(ProductCategory::getName, name);
+        queryWrapper.eq(ProductCategory::getName, name)
+                .eq(ProductCategory::getTenant,personnelVO.getTenantId());
         List<ProductCategory> productCategories = this.list(queryWrapper);
         if (productCategories != null && productCategories.size() != 0) {
             throw new XiaoShiException("参数错误");
         }
-        //获取登陆人信息 用于设置创建人
-        PersonnelVO personnelVO = new PersonnelVO();
-        try {
-            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
-        } catch (Exception e) {
-            throw new UnLoginException("未登录");
-        }
         //产品类别入表
         ProductCategory productCategory = new ProductCategory();
         BeanUtils.copyProperties(productCategoryDTO, productCategory);

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

@@ -351,6 +351,12 @@ public class EsService {
     public PatentColumnDTO getPatentColumnDTO(Patent patent, Integer projectId, String id) {
         PatentColumnDTO columnDTO = new PatentColumnDTO();
         BeanUtils.copyProperties(patent, columnDTO);
+        if (!CollectionUtils.isEmpty(patent.getIpc())){
+            boolean b = patent.getIpc().stream().allMatch(Objects::isNull);
+            if (b) {
+                columnDTO.setIpc(new ArrayList<>());
+            }
+        }
         if (projectId != null) {
             try {
                 columnDTO.setMergeApplicant(esPatentService.getMergeApp(projectId, id));

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,413 @@ 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) {
+                    if (rePatentClaim.getContent().contains("&nbsp;")) {
+                        String replace = rePatentClaim.getContent().replace("&nbsp;", " ");
+                        rePatentClaim.setContent(replace);
+                    }
+                    //原文
+                    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(tVO.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;
+    }
+
+    public List<String> getTranslateOrder(String patentNo, Integer sort) throws IOException {
+        List<String> list = new ArrayList<>();
+        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("3"));
+        Query q3 = QueryBuilders.term(t -> t.field("content.order").value(sort));
+        Query q4 = QueryBuilders.term(i -> i.field("language").value("CN"));
+        Query bool = QueryBuilders.bool(i -> i.must(q1, q2, q3,q4));
+        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();
+        for (Hit<PatentTranslate> hit : hits) {
+            PatentTranslate source = hit.source();
+            String content = source.getContent().getTextContent();
+            if (StringUtils.isNotEmpty(content)) {
+                list.add(content);
+            }
+        }
+        return list;
+    }
 }

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

@@ -11,12 +11,14 @@ import cn.cslg.pas.common.utils.StringUtils;
 import cn.cslg.pas.common.utils.parseQueryToTree.*;
 import cn.cslg.pas.common.vo.EsConfigVO;
 import cn.cslg.pas.exception.ConditionException;
+import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.factorys.EsBuilderFactory.EsBuilderFactory;
 import cn.cslg.pas.factorys.EsBuilderFactory.IQueryBuilder;
 import cn.cslg.pas.factorys.getOrderFactory.GetOrderFactory;
 import cn.cslg.pas.factorys.getOrderFactory.GetOrderObject;
 import cn.cslg.pas.factorys.getSqlFactorys.GetSqlFactory;
 import cn.cslg.pas.factorys.getSqlFactorys.GetSqlObject;
+import cn.cslg.pas.factorys.getSqlFactorys.GetWebQuerySql;
 import cn.cslg.pas.service.business.CommonService;
 import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import com.alibaba.fastjson.JSON;
@@ -340,27 +342,6 @@ public class FormatQueryService {
             }
         }
 
-//        if ((operate1.getShowName() != null)) {
-//            if (operate1.getShowName().equals("AND")) {
-//                operate1.setShowName("*");
-//            } else if (operate1.getShowName().equals("OR")) {
-//                operate1.setShowName("+");
-//            } else if (operate1.getShowName().equals("NOT")) {
-//                operate1.setShowName("-");
-//            }
-//            strCode = operate1.getShowName();
-//            optionName = operate1.getShowName();
-//        } else {
-//            if (operate1.getCode().equals("AND")) {
-//                operate1.setCode("*");
-//            } else if (operate1.getCode().equals("OR")) {
-//                operate1.setCode("+");
-//            } else if (operate1.getCode().equals("NOT")) {
-//                operate1.setCode("-");
-//            }
-//            strCode = operate1.getCode();
-//            optionName = operate1.getCode();
-//        }
         GetSqlObject getSqlObjectLocal = null;
         if (Left != null) {
             if ((operate1.gettype() == enuType.Logic || operate1.gettype() == enuType.Assignment) && (Left instanceof operateNode)) {
@@ -428,7 +409,7 @@ public class FormatQueryService {
             e.printStackTrace();
         }
         //格式化检索式
-        String reQuery = this.webQueryToString((operateNode) tree, null, configName);
+        String reQuery = this.webQueryToString2( tree,  configName);
         reQuery = "F XX (" + reQuery + ")";
         return reQuery;
     }
@@ -542,4 +523,84 @@ public class FormatQueryService {
         }
     }
 
+
+
+    public String webQueryToString2(treeNode treenode, String tableName) {
+        operateNode node =(operateNode)treenode;
+        treeNode Left = node.getLeft();
+        treeNode Right = node.getRight();
+        operate operate1 =  node.getoperate();
+        if(operate1.gettype() == enuType.Assignment)
+        {
+           if(!(Left instanceof valueNode)) {
+               throw new XiaoShiException("检索式错误");
+           }
+           valueNode leftValue = (valueNode) Left;
+       return   this.getQueryValue(Right,tableName,leftValue.getvalue(),this.getNodeStrCode(operate1));
+        }
+      else if(operate1.gettype()==enuType.Logic)
+        {
+      return "("+ this.webQueryToString2(Left,tableName)+" "+this.getNodeStrCode(operate1)+" "+this.webQueryToString2(Right,tableName)+")";
+        }
+      return null;
+    }
+
+
+    public String getQueryValue(treeNode node, String tableName,String field,String option){
+        if(node instanceof valueNode){
+            valueNode valuenode =(valueNode) node;
+            String json = CommonService.readJsonFile(tableName + ".json");
+            List<SqlObject> sqlObjects = JSON.parseArray(json, SqlObject.class);
+            SqlObject sqlObject = sqlObjects.stream().filter(item -> item.getField().equals(field)).findFirst().orElse(null);
+            sqlObject.setOption(option);
+            GetSqlObject getSqlObject =getSqlFactory.getClass(sqlObject.getSqlClass());
+            getSqlObject.setSqlObject(sqlObject);
+           return getSqlObject.getSql(valuenode.getvalue());
+        }
+        else {
+            operateNode operatenode =(operateNode)node;
+            treeNode Left = operatenode.getLeft();
+            treeNode Right = operatenode.getRight();
+            operate operate1 =  operatenode.getoperate();
+      return "("+this.getQueryValue(Left,tableName,field,option)+" "+this.getNodeStrCode(operate1)+" "+this.getQueryValue(Right,tableName,field,option)+")";
+        }
+
+    }
+
+    public  String getNodeStrCode(operate operate1){
+        String strCode = "";
+        String optionName = "";
+        if ((operate1.getShowName() != null)) {
+            if (operate1.getShowName().equals("AND")) {
+                strCode="*";
+                optionName="*";
+            } else if (operate1.getShowName().equals("OR")) {
+                strCode="+";
+                optionName="+";
+            } else if (operate1.getShowName().equals("NOT")) {
+                strCode="-";
+                optionName="-";
+            }
+            else {
+                strCode=operate1.getShowName();
+                optionName=operate1.getShowName();
+            }
+        } else {
+            if (operate1.getCode().equals("AND")) {
+                strCode="*";
+                optionName="*";
+            } else if (operate1.getCode().equals("OR")) {
+                strCode="+";
+                optionName="+";
+            } else if (operate1.getCode().equals("NOT")) {
+                strCode="-";
+                optionName="-";
+            }
+            else {
+                strCode=operate1.getShowName();
+                optionName=operate1.getShowName();
+            }
+        }
+        return strCode;
+    }
 }

src/main/resources/jsons/webSearchConfig.json

@@ -188,7 +188,7 @@
     "value": "AD",
     "field": "AD",
     "sqlField": "AD",
-    "sqlClass": "getWebQuerySql",
+    "sqlClass": "getWebDateSql",
     "orderClass": "",
     "groupClass": "",
     "ifSearch": "true",
@@ -201,7 +201,7 @@
     "value": "GD",
     "field": "GD",
     "sqlField": "GD",
-    "sqlClass": "getWebQuerySql",
+    "sqlClass": "getWebDateSql",
     "orderClass": "",
     "groupClass": "",
     "ifSearch": "true",
@@ -214,7 +214,7 @@
     "value": "PD",
     "field": "PD",
     "sqlField": "PD",
-    "sqlClass": "getWebQuerySql",
+    "sqlClass": "getWebDateSql",
     "orderClass": "",
     "groupClass": "",
     "ifSearch": "true",
@@ -365,5 +365,18 @@
     "ifSearch": "true",
     "ifGroup": "false",
     "ifShow": "false"
+  },
+  {
+    "name": "GJ",
+    "type": "Integer",
+    "value": "GJ",
+    "field": "GJ",
+    "sqlField": "GJ",
+    "sqlClass": "getWebQuerySql",
+    "orderClass": "",
+    "groupClass": "",
+    "ifSearch": "true",
+    "ifGroup": "false",
+    "ifShow": "false"
   }
 ]

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

@@ -3,10 +3,7 @@ package cn.cslg.pas.service;
 import cn.cslg.pas.common.model.common.QueryCondition;
 import cn.cslg.pas.common.model.request.QueryRequest;
 import cn.cslg.pas.common.model.request.StringRequest;
-import cn.cslg.pas.common.utils.FormatUtil;
-import cn.cslg.pas.common.utils.MathUtils;
-import cn.cslg.pas.common.utils.RabbitMQUtils;
-import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.utils.esDataForm.AddressSplitter;
 import cn.cslg.pas.common.vo.DepartmentVO;
 import cn.cslg.pas.common.vo.ImportTaskAMVO;
@@ -61,6 +58,9 @@ public class CommonServiceTests {
 
     @Autowired
     private PatentImportFactory patentImportFactory;
+    @Autowired
+    private PatentNoUtil patentNoUtil;
+
     @Test
     void test() throws Exception {
         String aa = permissionService.getPersonIdByNamePCS("朱", false);
@@ -141,11 +141,20 @@ public class CommonServiceTests {
         PersonAddress personAddress = AddressSplitter.splitAddress(te, "91(上海)");
         System.out.println(personAddress);
     }
-//李仁杰<2232723707@qq.com>"
+
+    //李仁杰<2232723707@qq.com>"
     @Test
-    public void testEmail() throws Exception{
-          String  a ="多功能应用\\烟熏模块";
-         String[] ab =a.split("\\\\");
-          System.out.println(ab);
+    public void testEmail() throws Exception {
+        String a = "多功能应用\\烟熏模块";
+        String[] ab = a.split("\\\\");
+        System.out.println(ab);
+
     }
+
+    @Test
+    public void testPatentNo() throws Exception {
+
+        String patentNo = PatentNoUtil.formatApNo("2023306875789");
+        System.out.println(patentNo);
     }
+}

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