补充

src/main/java/cn/cslg/pas/common/DataSource.java

@@ -0,0 +1,46 @@
+package cn.cslg.pas.common;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * @author 沈永艺
+ * @date 2022-8-12
+ * @description 数据权限类 数据库对应实体
+ */
+
+@Data
+@Accessors(chain = true)
+
+public class DataSource  {
+    /**
+     * 数据字典名字
+     */
+    private String dataSourceName;
+
+    /**
+     * 数据字典描述
+     */
+    private String dataSourceDescription;
+
+    /**
+     * 数据字典数据库
+     */
+    private String dataSourceDataBase;
+
+    /**
+     * 数据字典表格
+     */
+    private String dataSourceTable;
+
+    /**
+     * 数据字典字段
+     */
+    private String dataSourceField;
+
+    private  Integer id;
+    private Integer isDelete;
+
+
+}

src/main/java/cn/cslg/pas/common/auth/AuthAop.java

@@ -0,0 +1,175 @@
+package cn.cslg.pas.common.auth;
+
+
+import cn.cslg.pas.common.DataSource;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.common.utils.Response;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import io.swagger.v3.oas.annotations.Operation;
+import okhttp3.FormBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Objects;
+
+import static cn.cslg.pas.common.utils.JsonUtils.log;
+
+@Order(2)
+@Aspect
+@Component
+public class AuthAop {
+    @Value("${authorUrl}")
+    private String url;
+
+    @Autowired
+    private CacheUtils cacheUtils;
+    @Autowired
+    private LoginUtils loginUtils;
+
+    /**
+     * 定义切点
+     */
+    @Pointcut("@annotation(cn.cslg.pas.common.auth.checkAuth)")
+    public void annotationPointcut() {
+
+    }
+
+    /**
+     * @param joinPoint 当前执行的方法
+     */
+    @Around("annotationPointcut()")
+    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
+        try {
+            //获得登录人信息
+            PersonnelVO personnelVO = cacheUtils.getLoginUserPersonnel(loginUtils.getId());
+            if (personnelVO.getState() == 0) {
+                return Response.error("登录账号已被禁用，请联系管理员启用");
+            }
+
+
+            // 是否通过切面过滤标记
+            Boolean isPass = true;
+            MethodSignature ms = (MethodSignature) joinPoint.getSignature();
+            //获得执行方法对象
+            Method method = ms.getMethod();
+            //获得执行方法对象上的@checkAuth，@Operation注解对象
+            checkAuth myAnnotation = method.getAnnotation(checkAuth.class);
+            Operation operAnnotation = method.getAnnotation(Operation.class);
+            //获得@checkAuth注解上FunId参数的值
+            String functionId = myAnnotation.FunId();
+            //获得执行方法的参数对象
+            Object[] args = joinPoint.getArgs();
+            //根据登录人的id以及功能id获得规则信息
+            //将登录人的id以及功能id放入requestBody中
+            RequestBody requestBody = new FormBody.Builder()
+                    .add("loginId", loginUtils.getId().toString())
+                    .add("functionId", functionId)
+                    .build();
+            //建立远程连接
+            OkHttpClient okHttpClient = new OkHttpClient();
+            //发送请求
+            Request request = new Request.Builder()
+                    .url(url + "/permission/api/data/queryDataRule")
+                    .addHeader("Cookie", LoginUtils.getToken())
+                    .post(requestBody)
+                    .build();
+            //获得请求结果
+            String resBody = Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+            JSONArray jsonArray = JSONArray.parseArray(resBody);
+            //如果获得规则的返回值为[-1]则代表登录人没有使用该功能的权限
+            if (jsonArray.get(0).toString().equals("-1")) {
+                return Response.noPermissions("没有" + operAnnotation.summary() + "的功能");
+            }
+            //如果获得规则的返回值为[0],则直接通过判断
+            else if (jsonArray.size() == 1 && jsonArray.get(0).equals("0")) {
+                return joinPoint.proceed();
+            }
+            // 如果查询结果的size大于0证明有限制逻辑
+            if (jsonArray.size() > 0) {
+                RequestBody reBodySource = new FormBody.Builder()
+                        .add("tableName", "local")
+                        .build();
+                //处理jsonObject,变为（x==y）&&（z==t）的形式 ,并用js引擎进行boolean判断
+                //建立连接去获得字典信息
+                OkHttpClient okHttpClientSou = new OkHttpClient();
+                //发送请求
+                Request requestSou = new Request.Builder()
+                        .url(url + "/permission/api/data/getDataSource")
+                        .post(reBodySource)
+                        .addHeader("Cookie", LoginUtils.getToken())
+                        .build();
+                //获得请求返回
+                String resSource = Objects.requireNonNull(okHttpClientSou.newCall(requestSou).execute().body()).string();
+
+                JSONArray jsonArray1 = JSON.parseArray(resSource);
+                // 获得字典
+                List<DataSource> dataSources = jsonArray1.toJavaList(DataSource.class);
+                //循环遍历将多个规则拼接起来
+                StringBuilder sqlStr = new StringBuilder();
+                for (int i = 0; i < jsonArray.size(); i++) {
+                    //将数据库里存的规则转换为可识别的判断逻辑
+                    String sql = TreeUtils.reCompute(JSONObject.parseObject(jsonArray.get(i).toString()), args, dataSources, personnelVO);
+                    sqlStr.append(jsonArray.size() != i + 1 ? sql + " || " : sql);
+                }
+                //js引擎进行判断
+                ScriptEngineManager manager = new ScriptEngineManager();
+                //根据名字获得引擎
+                ScriptEngine engine = manager.getEngineByName("javascript");
+                //进行判断,生成判断结果并将判断结果赋给isPass
+                Object result = engine.eval(sqlStr.toString());//进行判断
+                isPass = (Boolean) result;
+            }
+
+            //判断不通过
+            if (!isPass) {
+                return Response.noPermissions("没有权限进行" + operAnnotation.summary() + "的操作");
+            }
+            //判断通过
+            return joinPoint.proceed();
+        }
+        catch (Exception var10) {
+            log.error("operlog exception:{}", var10);
+            return joinPoint.proceed();
+        }
+
+    }
+
+
+    @Before(value = "annotationPointcut()")
+    public void doAfterReturning(JoinPoint joinPoint) {
+        this.handleAfterLog(joinPoint);
+
+    }
+
+    protected void handleAfterLog(JoinPoint joinPoint) {
+        try {
+            log.info("after ----> title:{}, desc:{}",1,2);
+            return;
+        } catch (Exception var10) {
+            log.error("operlog exception:{}", var10);
+            return;
+        }
+    }
+
+}
+

src/main/java/cn/cslg/pas/common/auth/TreeUtils.java

@@ -0,0 +1,362 @@
+package cn.cslg.pas.common.auth;
+
+
+import cn.cslg.pas.common.DataSource;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
+import com.alibaba.fastjson.JSONObject;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+@Component
+public class TreeUtils {
+    /**
+     * 将二叉树json对象转为sql where后的条件语句
+     * liRJ
+     *
+     * @param jsonObject  要处理的jsonObject对象
+     * @param dataSource  要使用的数据字典
+     * @param personnelVO 登录人的信息
+     * @return 拼接的sql
+     */
+    // 处理sql语句，返回拼接sql
+    public static String reSql(JSONObject jsonObject, List<DataSource> dataSource, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        String sql;
+        //判断是否为规则，是的话则返回为“”，不对其他sql条件产生影响
+        if (jsonObject.get("nodeType").equals("logic")) {
+            sql = "";
+        }
+        //符合二叉树形式
+        else if (jsonObject.containsKey("left") && jsonObject.containsKey("right")) {
+            //将二叉树转换为sql条件
+            sql = recursionTree(jsonObject, dataSource, personnelVO);
+        }
+        // 不符合二叉树形式（单条数据）
+        else {
+            //获得规则的field字段，作为sql条件的栏位
+            String field = jsonObject.get("field").toString();
+            //获得规则的栏位值，并且要对值进行识别操作
+            String value = distinguishFields(jsonObject.get("value").toString(), dataSource, personnelVO);
+            if (jsonObject.get("opr").toString().equals("FIND_IN_SET")) {
+                sql = "FIND_IN_SET(" + value + "," + field + ")";
+            } else {
+                sql = field + " " + jsonObject.get("opr").toString() + " " + value;
+            }
+        }
+
+        return sql;
+    }
+
+    /**
+     * 将二叉树json对象转为sql where后的条件语句
+     * liRJ
+     *
+     * @param jsonObject  要处理的jsonObject对象
+     * @param dataSource  要使用的数据字典
+     * @param personnelVO 登录人的信息
+     * @return 拼接的sql
+     */
+    // 处理规则
+    public static String reCompute(JSONObject jsonObject, Object[] object, List<DataSource> dataSource, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        String sql;
+        //判断是否为sql类型规则，是的话规则转换为1==1，不对其他规则产生影响
+        if (jsonObject.get("nodeType").equals("sql")) {
+            sql = "1==1";
+        }
+        //符合二叉树形式
+        else if (jsonObject.containsKey("left") && jsonObject.containsKey("right")) {
+            //将二叉树转换为规则判断
+            sql = cRecursionTree(jsonObject, object, dataSource, personnelVO);
+        }
+        // 不符合二叉树形式(单条数据)
+        else {
+            //获得规则的 field字段，并进行识别操作
+            String field = distinguishFields(jsonObject.get("field").toString(), object, dataSource, personnelVO);
+            //获得规则的 value字段，并进行识别操作
+            String value = distinguishValues(jsonObject.get("value").toString(), object);
+            //获得规则的 运算符字段，并进行识别操作
+            String opr = distinguishLogic(jsonObject.getString("nodeType"), jsonObject.getString("opr"));
+            //field 和value若为以,隔开的数组时，将被拆开，并合成为新的规则
+            sql = arrayEqlToString(field, value, opr);
+        }
+
+        return sql;
+    }
+
+    /**
+     * 递归将二叉树转换为字符串
+     * liRJ
+     *
+     * @param jsonObject jsonObject
+     */
+    //将二叉树转换为sql条件
+    public static String recursionTree(JSONObject jsonObject, List<DataSource> dataSource, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        String str1;
+        String str2;
+        // 获得规则左边
+        JSONObject jsonLeft = jsonObject.getJSONObject("left");
+        // 获得规则右边
+        JSONObject jsonRight = jsonObject.getJSONObject("right");
+        //判断是否含有left分支，有的话进行递归
+        if (jsonLeft.containsKey("left")) {
+            str1 = recursionTree(jsonLeft, dataSource, personnelVO);//递归
+        }
+        //没有的话解析字符串拼接成子sql
+        else {
+            String field = jsonLeft.get("field").toString();
+            //获得规则的 value字段，并进行识别操作
+            String value = distinguishFields(jsonLeft.get("value").toString(), dataSource, personnelVO); //没有的话解析字符串拼接成子sql
+            if (jsonLeft.get("opr").toString().equals("FIND_IN_SET")) {
+                str1 = "FIND_IN_SET(" + value + "," + field + ")";
+            } else {
+                str1 = field + " " + jsonLeft.get("opr").toString() + " " + value;
+            }
+        }
+        //同上部分处理left分支
+        if (jsonRight.containsKey("right")) {
+            str2 = recursionTree(jsonRight, dataSource, personnelVO);
+        } else {
+            String field = jsonRight.get("field").toString();
+            String value = distinguishFields(jsonRight.get("value").toString(), dataSource, personnelVO);
+            if (jsonRight.get("opr").toString().equals("FIND_IN_SET")) {
+                str2 = "FIND_IN_SET(" + value + "," + field + ")";
+            } else {
+                str2 = field + " " + jsonRight.get("opr").toString() + " " + value;
+            }
+        }
+        return "(" + str1 + ") " + jsonObject.get("logicOpr") + " (" + str2 + ")";
+    }
+
+    //将二叉树转换为规则判断
+    public static String cRecursionTree(JSONObject jsonObject, Object[] object, List<DataSource> dataSource, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        String str1;
+        String str2;
+        // 获得规则左边
+        JSONObject jsonLeft = jsonObject.getJSONObject("left");
+        // 获得规则右边
+        JSONObject jsonRight = jsonObject.getJSONObject("right");
+        //判断是否含有left分支，有的话进行递归
+        if (jsonLeft.containsKey("left")) {
+            str1 = cRecursionTree(jsonLeft, object, dataSource, personnelVO);
+        } else {
+            //获得规则的 field字段，并进行识别操作
+            String field = distinguishFields(jsonLeft.get("field").toString(), object, dataSource, personnelVO);
+            //获得规则的 value字段，并进行识别操作
+            String value = distinguishValues(jsonLeft.get("value").toString(), object);
+            //获得规则的 opr字段，并进行识别操作
+            String opr = distinguishLogic(jsonLeft.getString("nodeType"), jsonLeft.getString("opr"));
+            str1 = arrayEqlToString(field, value, opr);
+        }
+        //同上部分处理right分支
+        if (jsonRight.containsKey("right")) {
+            str2 = cRecursionTree(jsonRight, object, dataSource, personnelVO);
+        } else {
+            String field = distinguishFields(jsonRight.get("field").toString(), object, dataSource, personnelVO);
+            String value = distinguishValues(jsonRight.get("value").toString(), object);
+            String opr = distinguishLogic(jsonRight.getString("nodeType"), jsonRight.getString("opr"));
+            str2 = arrayEqlToString(field, value, opr);
+        }
+
+        return "(" + str1 + ") " + distinguishLogic(jsonObject.getString("nodeType"), jsonObject.getString("logicOpr")) + " (" + str2 + ")";
+    }
+
+    //对field和value部分进行计算 sql查询
+    public static String distinguishFields(String field, List<DataSource> dataSources, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        //获得登录用户部门列表信息
+        List<PersonnelVO.DP> dps = personnelVO.getDpList();
+        //获得登录用户角色列表信息
+        List<PersonnelVO.PerRole> perRoles = personnelVO.getRList();
+        String tem = "";
+        String reField = field;
+        //如果参数是sql语句
+        if (field.contains("select")) {
+            for (DataSource dataSource : dataSources) {
+                String sourceField = dataSource.getDataSourceField();
+                if (field.contains("local." + sourceField)) {
+                    // 判断是否是部门信息
+                    if (sourceField.contains("DP.")) {
+                        // 分割字符串获得部门字段
+                        String Fields = sourceField.split("\\.")[1];
+                        // 遍历部门信息，用反射将对应字段转换成（*,*,...)格式
+                        for (PersonnelVO.DP dp : dps) {
+                            Class<?> DPClass = dp.getClass();
+                            Field dataField = DPClass.getDeclaredField(Fields);
+                            dataField.setAccessible(true);
+                            tem = dataField.get(dp).toString() + ",";
+
+                        }
+                        reField = sourceField.replace("local." + sourceField, "(" + tem.substring(0, tem.length() - 1) + ")");
+                    }
+                    //判断是否是角色信息(处理过程同部门信息处理过程)
+                    else if (sourceField.contains("PerRole.")) {
+                        String Fields = sourceField.split("\\.")[1];
+                        for (PersonnelVO.PerRole perRole : perRoles) {
+                            Class<?> DPClass = perRole.getClass();
+                            Field dataField = DPClass.getDeclaredField(Fields);
+                            dataField.setAccessible(true);
+                            tem = dataField.get(perRole).toString() + ",";
+                        }
+                        reField = sourceField.replace("local." + sourceField, "(" + tem.substring(0, tem.length() - 1) + ")");
+                    } else {
+                        Class<?> personClass = personnelVO.getClass();
+                        Field dataField = personClass.getDeclaredField(sourceField);
+                        dataField.setAccessible(true);
+                        reField = reField.replace("local." + sourceField, dataField.get(personnelVO).toString());
+                    }
+                }
+            }
+        }
+        //遍历字典数据
+        else {
+            for (DataSource dataSource : dataSources) {
+                // 如果匹配上字典字段则进行处理
+                if (field.equals(dataSource.getDataSourceField())) {
+                    // 判断是否是部门信息
+                    if (field.contains("DP.")) {
+                        // 分割字符串获得部门字段
+                        String Fields = field.split("\\.")[1];
+                        // 遍历部门信息，用反射将对应字段转换成（*,*,...)格式
+                        for (PersonnelVO.DP dp : dps) {
+                            Class<?> DPClass = dp.getClass();
+                            Field dataField = DPClass.getDeclaredField(Fields);
+                            dataField.setAccessible(true);
+                            tem = dataField.get(dp).toString() + ",";
+
+                        }
+                        reField = "(" + tem.substring(0, tem.length() - 1) + ")";
+                    }
+                    //判断是否是角色信息(处理过程同部门信息处理过程)
+                    else if (field.contains("PerRole.")) {
+                        String Fields = field.split("\\.")[1];
+                        for (PersonnelVO.PerRole perRole : perRoles) {
+                            Class<?> DPClass = perRole.getClass();
+                            Field dataField = DPClass.getDeclaredField(Fields);
+                            dataField.setAccessible(true);
+                            tem = dataField.get(perRole).toString() + ",";
+                        }
+                        reField = "(" + tem.substring(0, tem.length() - 1) + ")";
+                    } else {
+                        Class<?> personClass = personnelVO.getClass();
+                        Field dataField = personClass.getDeclaredField(field);
+                        dataField.setAccessible(true);
+                        reField = dataField.get(personnelVO).toString();
+                        break;
+                    }
+                }
+            }
+        }
+        return reField;
+    }
+
+    //对field部分进行计算
+    public static String distinguishFields(String field, Object[] object, List<DataSource> dataSources, PersonnelVO personnelVO) throws NoSuchFieldException, IllegalAccessException {
+        String reField = "'" + field + "'";
+        //反射获方法的参数值
+        Class<?> jsonClass = object[0].getClass();
+        for (Field field1 : jsonClass.getDeclaredFields()) {
+            if (field1.getName().equals(field)) {     //判断field的值是否和参数名一样，一样的话变为参数值
+                Field dataField = jsonClass.getDeclaredField(field);
+                dataField.setAccessible(true);//设置data属性为可访问的
+                String fie = dataField.get(object[0]).toString();
+                reField = "'" + fie + "'";
+                break;
+            }
+        }
+        //获得登录用户部门列表信息
+        List<PersonnelVO.DP> dps = personnelVO.getDpList();
+        //获得登录用户角色列表信息
+        List<PersonnelVO.PerRole> perRoles = personnelVO.getRList();
+        String tem = "";
+        //遍历字典数据
+        for (DataSource dataSource : dataSources) {
+            // 如果匹配上字典字段则进行处理
+            if (field.equals(dataSource.getDataSourceField())) {
+                // 判断是否是部门信息
+                if (field.contains("DP.")) {
+                    // 分割字符串获得部门字段
+                    String Fields = field.split("\\.")[1];
+                    // 遍历部门信息，用反射将对应字段转换成（*,*,...)格式
+                    for (PersonnelVO.DP dp : dps) {
+                        Class<?> DPClass = dp.getClass();
+                        Field dataField = DPClass.getDeclaredField(Fields);
+                        dataField.setAccessible(true);
+                        tem = dataField.get(dp).toString() + ",";
+
+                    }
+                    reField = tem.substring(0, tem.length() - 1);
+                }
+                //判断是否是角色信息(处理过程同部门信息处理过程)
+                else if (field.contains("PerRole.")) {
+                    String Fields = field.split("\\.")[1];
+                    for (PersonnelVO.PerRole perRole : perRoles) {
+                        Class<?> DPClass = perRole.getClass();
+                        Field dataField = DPClass.getDeclaredField(Fields);
+                        dataField.setAccessible(true);
+                        tem = dataField.get(perRole).toString() + ",";
+                    }
+                    reField = tem.substring(0, tem.length() - 1);
+                } else {
+                    Class<?> personClass = personnelVO.getClass();
+                    Field dataField = personClass.getDeclaredField(field);
+                    dataField.setAccessible(true);
+                    reField = "'" + dataField.get(personnelVO).toString() + "'";
+                    break;
+                }
+            }
+        }
+
+        return reField;
+    }
+
+    //对value部分进行计算
+    public static String distinguishValues(String value, Object[] object) throws NoSuchFieldException, IllegalAccessException {
+        String reValue = "'" + value + "'";
+        //反射获得参数值
+        Class<?> jsonClass = object[0].getClass();
+        for (Field field1 : jsonClass.getDeclaredFields()) {
+            if (field1.getName().equals(value)) {     //判断value的值是否和参数名一样，一样的话变为参数值
+                Field dataField = jsonClass.getDeclaredField(value);
+                dataField.setAccessible(true);//设置data属性为可访问的
+                String fie = dataField.get(object[0]).toString();
+                reValue = "'" + fie + "'";
+                break;
+            }
+        }
+
+        return reValue;
+    }
+
+    //对应改变运算逻辑
+    public static String distinguishLogic(String nodeType, String opr) {
+        if (nodeType.equals("logic")) {
+            switch (opr) {
+                case "=":
+                    opr = "==";
+                    break;
+                case "and":
+                    opr = "&&";
+                    break;
+                case "or":
+                    opr = "||";
+                    break;
+            }
+        }
+
+        return opr;
+    }
+
+    // 将x,y=z,w 形式改为 x=z||x=w||y=z||y=w形式
+    public static String arrayEqlToString(String field, String value, String opr) {
+        StringBuilder reStr = new StringBuilder();
+        String[] fields = field.split(",");
+        String[] values = value.split(",");
+        for (int i = 0; i < fields.length; i++) {
+            for (int t = 0; t < values.length; t++) {
+                reStr.append(i == fields.length - 1 && t == values.length - 1 ? fields[i] + opr + values[t] : fields[i] + opr + values[t] + "||");
+            }
+        }
+
+        return reStr.toString();
+    }
+}

src/main/java/cn/cslg/pas/common/auth/checkAuth.java

@@ -0,0 +1,17 @@
+package cn.cslg.pas.common.auth;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * @author LRJ
+ * @date 2022-8-23
+ * @description 数据权限(增删改)条件判断注解
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface checkAuth {
+    String FunId() default "0";
+}
+

src/main/java/cn/cslg/pas/common/config/WebSocketConfig.java

@@ -6,8 +6,8 @@ import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
 @Configuration
 public class WebSocketConfig {
-    @Bean
-    public ServerEndpointExporter serverEndpointExporter() {
-        return new ServerEndpointExporter();
-    }
+//    @Bean
+//    public ServerEndpointExporter serverEndpointExporter() {
+//        return new ServerEndpointExporter();
+//    }
 }

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.common.dto;
+
+import cn.cslg.pas.common.vo.PersonSelfFieldVO;
+import lombok.Data;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * 实体类表以及栏位信息
+ */
+@Data
+public class QueryScratchWordsDTO {
+    private String createName;
+    private String patentNo;
+    private Date markTime;
+    private String markSelectText;
+
+}

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

@@ -0,0 +1,12 @@
+package cn.cslg.pas.common.dto;
+import lombok.Data;
+
+
+/**
+ * 划词检索dto类
+ */
+@Data
+public class SwQueryDTO {
+    private String patentNo;
+    private Integer projectId;
+}

src/main/java/cn/cslg/pas/common/dto/business/UpdateScratchWordsDTO.java

@@ -1,6 +1,8 @@
 package cn.cslg.pas.common.dto.business;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
+import org.joda.time.DateTime;
 
 /**
  * @Author xiexiang
@@ -8,69 +10,61 @@ import lombok.Data;
  */
 @Data
 public class UpdateScratchWordsDTO {
-    private Integer id;
+    private String id;
     /**
-     * 创建人
+     * 是否公开
      */
-    private String createId;
+    private   Boolean isPublic;
 
     /**
-     * 租户id
+     * 标注颜色
      */
-    private Integer tenantId;
+    private  String markColor;
 
     /**
-     * 专利号
+     * 标注备注
      */
-    private String patentNo;
+    private String markOteText;
 
     /**
-     * 位置
+     * 标注类型
      */
-    private Integer position;
+    private  Integer markType;
 
     /**
-     * 内容
+     * 标注栏位
      */
-    private String text;
+    private String markSelectField;
 
     /**
-     * 划词栏位
+     * 标注选择文本
      */
-    private String scratchField;
+    private  String markSelectText;
 
-    /**
-     * 划词类型（0下划线，1高亮,2波浪线）
-     */
-    private Integer scratchType;
+    private Integer markSite;
 
     /**
-     * 划词颜色
+     * 标注时间
      */
-    private String color;
+    private DateTime markTime;
 
     /**
-     * 标引备注
+     * 标注人
      */
-    private String remark;
+    private String markUserId;
 
     /**
-     * 创建来源
+     * 标注范围
      */
-    private Integer createFrom;
+    private Integer publicScope;
 
     /**
-     * 存放id（专题库id/报告id）
+     * 标注专利数据库id/报告id
      */
     private Integer projectId;
 
     /**
-     * 公开类型（0私有1公有）
-     */
-    private Integer permissionType;
-
-    /**
-     * 公开范围（true只在来源处可见/false所有地方可见）
+     * 标注租户id
      */
-    private String rangeType;
+    private Integer publicTenantId;
 }

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

@@ -24,10 +24,7 @@ public class ReportExportController {
     @Operation(summary = "导出报告")
     @PostMapping("/export")
     public Response queryPatentProject(@RequestBody StringRequest stringRequest) throws Exception {
-//        reportExportService.exportReport(1,1);
-      String a
-         =commonService.readJsonFile("event.json");
-      System.out.println(a);
+   reportExportService.exportReport(1,1);
         return Response.success("records");
     }
 

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

@@ -5,6 +5,7 @@ import cn.cslg.pas.common.dto.business.ScratchWordsDTO;
 import cn.cslg.pas.common.dto.business.UpdateScratchWordsDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.domain.business.ScratchWords;
 import cn.cslg.pas.service.business.ScratchWordsService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -29,9 +30,9 @@ public class ScratchWordsController {
 
     @Operation(summary = "新增划词高亮")
     @PostMapping("/add")
-    public Response add(@RequestBody ScratchWordsDTO scratchWordsDTO) {
-        if (scratchWordsDTO != null) {
-            Integer id = scratchWordsService.add(scratchWordsDTO);
+    public Response add(@RequestBody ScratchWords scratchWords) {
+        if (scratchWords != null) {
+            String id = scratchWordsService.add(scratchWords);
             Records records = new Records();
             records.setData(id);
             return Response.success(records);
@@ -40,35 +41,13 @@ public class ScratchWordsController {
         }
     }
 
-//    @Operation(summary = "查询划词高亮")
-//    @PostMapping("/query")
-//    public Response query(@RequestBody SWQueryDTO swQueryDTO) {
-//        if (swQueryDTO != null) {
-//            return Response.success(scratchWordsService.queryAll(swQueryDTO));
-//        } else {
-//            return Response.error("查询失败");
-//        }
-//    }
-
-//    @Operation(summary = "分页查询标注清单")
-//    @PostMapping("/queryScratchs")
-//    public String queryScratchs(@RequestBody QueryScratchsDTO queryScratchsDTO) throws IOException {
-//        return Response.success(scratchWordsService.queryScratchs(queryScratchsDTO));
-//    }
-//
-//    @Operation(summary = "分页分组查询标注清单")
-//    @PostMapping("/queryGroupScratchs")
-//    public String queryGroupScratchs(@RequestBody QueryGroupScratchsDTO queryGroupScratchsDTO) throws IOException {
-//        return Response.success(scratchWordsService.queryGroupScratchs(queryGroupScratchsDTO));
-//    }
-
     @Operation(summary = "更新划词高亮")
     @PostMapping("/update")
     public Response update(@RequestBody UpdateScratchWordsDTO updateScratchWordsDTO) {
         if (updateScratchWordsDTO != null) {
-            Integer id = scratchWordsService.update(updateScratchWordsDTO);
+            String id = scratchWordsService.update(updateScratchWordsDTO);
             Records records = new Records();
-            records.setData(records);
+            records.setData(id);
             return Response.success(records);
         } else {
             return Response.error("更新失败");
@@ -76,10 +55,10 @@ public class ScratchWordsController {
     }
 
     @Operation(summary = "删除标注")
-    @PostMapping("/delete")
-    public Response delete(@RequestBody List<Integer> ids) {
+    @PostMapping("/removeScratchWrods")
+    public Response removeScratchWrods(@RequestBody List<String> ids) {
         if (ids != null && !ids.isEmpty()) {
-            List<Integer> deleteIds = scratchWordsService.delete(ids);
+            List<String> deleteIds = scratchWordsService.removeById(ids);
             Records records = new Records();
             records.setData(deleteIds);
             return Response.success(records);

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

@@ -2,23 +2,16 @@ package cn.cslg.pas.controller;
 
 
 import cn.cslg.pas.common.core.base.Constants;
-import cn.cslg.pas.common.dto.business.EsCountDTO;
 import cn.cslg.pas.common.dto.business.ReportTempleDTO;
 import cn.cslg.pas.common.utils.Response;
-import cn.cslg.pas.common.vo.business.EsCountVO;
 import cn.cslg.pas.common.vo.business.TempleByReportTypeVO;
-import cn.cslg.pas.service.business.TempleService;
+import cn.cslg.pas.service.business.ReportTempleService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
 
-import java.io.IOException;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 
 @Tag(name = "报告模板")
 @RestController
@@ -26,7 +19,7 @@ import java.util.Map;
 public class TempleController {
 
     @Autowired
-    private TempleService templeService;
+    private ReportTempleService templeService;
 
     @Operation(summary = "根据报告类型查询报告模板表")
     @PostMapping("/queryTempleByType")

src/main/java/cn/cslg/pas/domain/business/ReportTemple.java

@@ -2,6 +2,7 @@ package cn.cslg.pas.domain.business;
 
 import cn.cslg.pas.domain.BaseEntity;
 import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import nonapi.io.github.classgraph.json.Id;
 
@@ -16,6 +17,7 @@ import java.util.Date;
  * @since 2023-12-09
  */
 @Data
+@TableName("report_temple")
 public class ReportTemple extends BaseEntity<ReportTemple> {
     /**
      * 模板名称

src/main/java/cn/cslg/pas/domain/business/ScratchWords.java

@@ -3,7 +3,9 @@ package cn.cslg.pas.domain.business;
 import cn.cslg.pas.domain.BaseEntity;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Data;
+import org.joda.time.DateTime;
 
 import java.util.Date;
 
@@ -13,99 +15,66 @@ import java.util.Date;
  * @Date 2024/1/10
  */
 @Data
-@TableName("scratch_words")
 /*数据库中的表对应的类
  */
-public class ScratchWords extends BaseEntity<ScratchWords> {
-
+public class ScratchWords {
+    private String patentNo;
     /**
-     * 创建人
+     * 是否公开
      */
-    @TableField("create_id")
-    private String createId;
+    private Boolean isPublic;
 
     /**
-     * 租户id
+     * 标注颜色
      */
-    @TableField("tenant_id")
-    private Integer tenantId;
+    private  String markColor;
 
     /**
-     * 专利号
+     * 标注备注
      */
-    @TableField("patent_no")
-    private String patentNo;
+    private String markOteText;
 
     /**
-     * 位置
+     * 标注类型
      */
-    @TableField("position")
-    private Integer position;
+    private Integer markType;
 
     /**
-     * 内容
+     * 标注栏位
      */
-    @TableField("text")
-    private String text;
+    private String markSelectField;
 
     /**
-     * 划词栏位
+     * 标注选择文本
      */
-    @TableField("scratch_field")
-    private String scratchField;
+    private String markSelectText;
 
-    /**
-     * 划词类型（0下划线，1高亮,2波浪线）
-     */
-    @TableField("scratch_type")
-    private Integer scratchType;
+    private Integer markSite;
 
     /**
-     * 划词颜色
+     * 标注时间
      */
-    @TableField("color")
-    private String color;
+    private Date markTime;
 
     /**
-     * 标引备注
+     * 标注人
      */
-    @TableField("remark")
-    private String remark;
+    private  String markUserId;
 
     /**
-     * 创建来源
+     * 标注范围 1仅在范围可见 0所有地方可见
      */
-    @TableField("create_from")
-    private Integer createFrom;
+    private Integer publicScope;
 
     /**
-     * 存放id（专题库id/报告id）
+     * 标注专利数据库id/报告id
      */
-    @TableField("project_id")
     private Integer projectId;
 
     /**
-     * 公开类型（0私有1公有）
+     * 标注租户id
      */
-    @TableField("permission_type")
-    private Integer permissionType;
+    private Integer publicTenantId;
 
-    /**
-     * 公开范围（true只在来源处可见/false所有地方可见）
-     */
-    @TableField("range_type")
-    private String rangeType;
-    /**
-     * 创建时间
-     */
-    @TableField("create_time")
-    private Date createTime;
-
-
-    /**
-     * 创建人名称
-     */
-    @TableField(exist = false)
-    private String createName;
 
 }

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

@@ -7,6 +7,8 @@ import lombok.NoArgsConstructor;
 import org.joda.time.DateTime;
 import org.springframework.stereotype.Component;
 
+import java.util.Date;
+
 /**
  * 标注
  */
@@ -19,69 +21,69 @@ public class Marking {
      * 是否公开
      */
     @JsonProperty("is_public")
-    String isPublic;
+  private   Boolean isPublic;
 
     /**
      * 标注颜色
      */
     @JsonProperty("mark_Color")
-    String markColor;
+    private  String markColor;
 
     /**
      * 标注备注
      */
     @JsonProperty("mark_noteText")
-    String mark_oteText;
+    private String markOteText;
 
     /**
      * 标注类型
      */
     @JsonProperty("mark_type")
-    Integer markType;
+    private  Integer markType;
 
     /**
      * 标注栏位
      */
     @JsonProperty("mark_selectField")
-    String mark_selectField;
+    private String markSelectField;
 
     /**
      * 标注选择文本
      */
     @JsonProperty("mark_selectText")
-    String markSelectText;
+    private  String markSelectText;
 
     @JsonProperty("mark_site")
-    String markSite;
+    private Integer markSite;
 
     /**
      * 标注时间
      */
     @JsonProperty("mark_time")
-    DateTime markTime;
+    private Date markTime;
 
     /**
      * 标注人
      */
     @JsonProperty("mark_user_id")
-    Integer markUserId;
+    private String markUserId;
 
     /**
      * 标注范围
      */
     @JsonProperty("public_scope")
-    Integer publicScope;
+    private Integer publicScope;
 
     /**
      * 标注专利数据库id/报告id
      */
     @JsonProperty("public_project_id")
-    Integer projectId;
+    private Integer projectId;
 
     /**
      * 标注租户id
      */
     @JsonProperty("public_tenant_id")
-    Integer publicTenantId;
+    private Integer publicTenantId;
 
 }

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

@@ -418,7 +418,7 @@ public class Patent {
      * 标注
      */
     @JsonProperty("markings")
-    List<Marking> markings;
+    Marking markings;
     @JsonProperty("patent_join")
     PatentJoin patentJoin;
 

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

@@ -2,16 +2,12 @@ package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.dto.PatentColumnDTO;
 import cn.cslg.pas.common.dto.PatentDTO;
-import cn.cslg.pas.common.dto.PatentDetailDTO;
-import cn.cslg.pas.common.dto.es.EsCustomFieldDTO;
 import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
 import cn.cslg.pas.common.model.SystemMO;
 import cn.cslg.pas.common.model.cronModel.PersonnelVO;
 import cn.cslg.pas.common.model.request.StringRequest;
 import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.common.vo.*;
-import cn.cslg.pas.common.vo.business.AllCustomFieldVO;
-import cn.cslg.pas.common.vo.business.PatentNoVO;
 import cn.cslg.pas.domain.ReportDocument;
 import cn.cslg.pas.domain.business.*;
 import cn.cslg.pas.domain.es.Text;
@@ -21,8 +17,6 @@ import cn.cslg.pas.service.business.*;
 import cn.cslg.pas.service.business.es.*;
 import cn.cslg.pas.service.common.FileManagerService;
 import cn.hutool.core.util.IdUtil;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.deepoove.poi.XWPFTemplate;
 import com.deepoove.poi.config.Configure;
@@ -32,9 +26,7 @@ import com.deepoove.poi.data.Pictures;
 import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.poi.ss.usermodel.PictureData;
 import org.ddr.poi.html.HtmlRenderPolicy;
-import org.joda.time.format.FormatUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -42,13 +34,12 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.*;
-import java.util.stream.Collectors;
 
 @Slf4j
 @Service
 public class ReportExportService {
     @Autowired
-    private TempleService templeService;
+    private ReportTempleService templeService;
     @Autowired
     private FileUtils fileUtils;
     @Autowired

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

@@ -16,7 +16,7 @@ import java.util.List;
 
 @Service
 @Slf4j
-public class TempleService extends ServiceImpl<ReportTempleMapper, ReportTemple> {
+public class ReportTempleService extends ServiceImpl<ReportTempleMapper, ReportTemple> {
 
     /**
      * 根据报告类型查询报告模板表

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

@@ -1,28 +1,23 @@
 package cn.cslg.pas.service.business;
 
-import cn.cslg.pas.common.dto.business.ScratchWordsDTO;
+import cn.cslg.pas.common.dto.SwQueryDTO;
 import cn.cslg.pas.common.dto.business.UpdateScratchWordsDTO;
 import cn.cslg.pas.common.model.cronModel.PersonnelVO;
 import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.LoginUtils;
 import cn.cslg.pas.domain.business.ScratchWords;
+import cn.cslg.pas.domain.es.Marking;
 import cn.cslg.pas.exception.XiaoShiException;
-import cn.cslg.pas.mapper.ProjectMapper;
 import cn.cslg.pas.mapper.ScratchWordsMapper;
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson2.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import cn.cslg.pas.service.business.es.EsScratchWordsService;
+import cn.cslg.pas.service.business.es.EsService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.github.pagehelper.PageHelper;
-import com.github.pagehelper.PageInfo;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 
-import java.io.IOException;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -34,37 +29,32 @@ import java.util.stream.Collectors;
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class ScratchWordsService extends ServiceImpl<ScratchWordsMapper, ScratchWords> {
-    private final ScratchWordsMapper scratchWordsMapper;
     private final CacheUtils cacheUtils;
     private final LoginUtils loginUtils;
-    private final ProjectService projectService;
-    private final ProjectMapper projectMapper;
-    private final PatentService patentService;
+    private final EsScratchWordsService esScratchWordsService;
+    private final EsService esService;
 
     /**
      * 新增划词高亮
      *
-     * @param scratchWordsDTO
+     * @param scratchWords
      */
-    public Integer add(ScratchWordsDTO scratchWordsDTO) {
-        if (scratchWordsDTO.getCreateFrom() == null) {
-            scratchWordsDTO.setCreateFrom(0);
-        }
-        ScratchWords scratchWords = new ScratchWords();
-        BeanUtils.copyProperties(scratchWordsDTO, scratchWords);
+    public String add(ScratchWords scratchWords) {
+
+        scratchWords = new ScratchWords();
         //获取当前登陆人信息
         PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
         if (personnelVO != null) {
             //设置创建人id
-            scratchWords.setCreateId(personnelVO.getId());
+            scratchWords.setMarkUserId(personnelVO.getId());
             //设置租户id
-            scratchWords.setTenantId(personnelVO.getTenantId());
+            scratchWords.setPublicTenantId(personnelVO.getTenantId());
         } else {
             throw new XiaoShiException("未查询到创建人信息");
         }
         //数据入表
-        scratchWords.insert();
-        return scratchWords.getId();
+        String id = esScratchWordsService.addScratchWords(scratchWords);
+        return id;
     }
 
     /**
@@ -72,238 +62,49 @@ public class ScratchWordsService extends ServiceImpl<ScratchWordsMapper, Scratch
      *
      * @param updateScratchWordsDTO
      */
-    public Integer update(UpdateScratchWordsDTO updateScratchWordsDTO) {
-        //判断传入列表不为空
-        if (updateScratchWordsDTO.getId() != null) {
-            ScratchWords scratchWords = this.getById(updateScratchWordsDTO.getId());
-            BeanUtils.copyProperties(updateScratchWordsDTO, scratchWords);
-            scratchWords.updateById();
-            return scratchWords.getId();
+    public String update(UpdateScratchWordsDTO updateScratchWordsDTO) {
+        String id = updateScratchWordsDTO.getId();
+        Marking marking = new Marking();
+        BeanUtils.copyProperties(updateScratchWordsDTO, marking);
+        id = esScratchWordsService.updateScratchWords(id, marking);
+        return id;
+
+    }
+
+    /**
+     * 查询划词高亮
+     *
+     * @param swQueryDTO
+     * @return
+     */
+    public List<String> queryAll(SwQueryDTO swQueryDTO) {
+        if (swQueryDTO.getPatentNo() != null) {
+            //获取当前登陆人信息
+            PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
+            Integer tenantId = personnelVO.getTenantId();
+            String createId = personnelVO.getId();
+
         } else {
-            throw new XiaoShiException("传入对象的id不能为空");
+            throw new XiaoShiException("传入参数不可为空");
         }
+        return null;
     }
 
-//    /**
-//     * 查询划词高亮
-//     *
-//     * @param swQueryDTO
-//     * @return
-//     */
-//    public List<ScratchWordsVO> queryAll(SWQueryDTO swQueryDTO) {
-//        if (swQueryDTO.getPatentNo() != null) {
-//            //获取当前登陆人信息
-//            PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
-//            Integer tenantId = personnelVO.getTenantId();
-//            Integer createId = personnelVO.getId();
-//            //创建来源（默认0/专题库1/报告2）
-//            if (swQueryDTO.getCreateFrom().equals(1)) {
-//                Integer projectId = swQueryDTO.getId();
-//                Integer reportId = -1;
-//                List<ScratchWordsVO> scratchWords = scratchWordsMapper.querySW(swQueryDTO.getPatentNo(), tenantId, createId, projectId, reportId);
-//                return scratchWords;
-//            }
-//            //创建来源（默认0/专题库1/报告2）
-//            else if (swQueryDTO.getCreateFrom().equals(2)) {
-//                Integer reportId = swQueryDTO.getId();
-//                Integer projectId = -1;
-//                List<ScratchWordsVO> scratchWords = scratchWordsMapper.querySW(swQueryDTO.getPatentNo(), tenantId, createId, projectId, reportId);
-//                return scratchWords;
-//            }
-//            //创建来源（默认0/专题库1/报告2）
-//            else if (swQueryDTO.getCreateFrom().equals(0)) {
-//                Integer reportId = -1;
-//                Integer projectId = -1;
-//                List<ScratchWordsVO> scratchWords = scratchWordsMapper.querySW(swQueryDTO.getPatentNo(), tenantId, createId, projectId, reportId);
-//                return scratchWords;
-//            } else {
-//                throw new XiaoShiException("暂无该情况");
-//            }
-//        } else {
-//            throw new XiaoShiException("传入参数不可为空");
-//        }
-//    }
-//
-//
-//    public PageVO queryScratchs(QueryScratchsDTO queryScratchsDTO) throws IOException {
-//        log.info("开始处理【查询标注清单】的业务，参数为：{}", queryScratchsDTO);
-//
-//        List<SearchItem> search = queryScratchsDTO.getSearch();
-//        List<String> names = search.stream().filter(searchItem -> searchItem.getValue().equals("name")).map(SearchItem::getContent).collect(Collectors.toList());
-//        List<Integer> personIds = new ArrayList<>();
-//        if (names.size() > 0) {
-//            //若根据创建人名称模糊查询，调用权限系统根据人员名称获得人员ids并装载到参数中
-//            String res = outInterfaceService.getPersonIdByNamesPCS(names);
-//            personIds = JSON.parseArray(res, Integer.class);
-//            if (personIds.size() == 0) {
-//                personIds.add(-1);
-//            }
-//        }
-//
-//        PageVO pageVO = new PageVO()
-//                .setCurrent(queryScratchsDTO.getCurrent())
-//                .setSize(queryScratchsDTO.getSize());
-//
-//        //获取登陆人id、所属租户id、token
-//        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
-//        Integer personId = personnelVO.getId();
-//        Integer tenantId = personnelVO.getTenantId();
-//        String token = "token=" + personnelVO.getToken();
-//
-//        //获取当前登陆人有权查看的专题库projectIds
-//        ProjectVO params = new ProjectVO();
-//        if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {  //代码控制不同类型的角色查询权限
-//            params.setPersonnelId(personId);
-//            if (personnelVO.getRoleType() != null && personnelVO.getRoleType() == 2) {
-//                params.setTenantId(personnelVO.getTenantId());
-//            }
-//        }
-//        List<Project> projects = projectMapper.getProjects(params);
-//        List<Integer> projectIds = new ArrayList<>();
-//        if (projects == null || projects.size() == 0) {
-//            projectIds.add(-1);
-//        } else {
-//            projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
-//        }
-//
-//        //获取当前登陆人有权查看的报告reportIds
-//        String res = outInterfaceService.getReportsFromRMS(token);
-//        JSONObject jsonObject = JSONObject.parseObject(res);
-//        List<Integer> reportIds = JSON.parseArray(jsonObject.get("data").toString(), Integer.class);
-//
-//
-//        //开始分页（分组）查询标注表标注清单
-//        if (queryScratchsDTO.getCurrent() != null && queryScratchsDTO.getSize() != null) {
-//            PageHelper.startPage(queryScratchsDTO.getCurrent(), queryScratchsDTO.getSize());
-//        }
-////        if (queryScratchsDTO.getGrouping() == null || queryScratchsDTO.getGrouping().equals("")) {  //不分组
-//        List<ScratchWordVO> scratchWords = scratchWordsMapper.queryScratchWords(personIds, search, tenantId, personId, projectIds, reportIds);
-//        PageInfo<ScratchWordVO> pageInfo = new PageInfo<>(scratchWords);
-//        if (scratchWords.size() > 0) {
-//            //装载创建人名称
-//            List<Integer> createPersonIds = scratchWords.stream().map(ScratchWordVO::getCreateId).collect(Collectors.toList());
-//            res = outInterfaceService.getPersonnelByIdsFromPCS(createPersonIds);
-//            jsonObject = JSONObject.parseObject(res);
-//            List<Personnel> personnels = JSON.parseArray(jsonObject.get("data").toString(), Personnel.class);
-//            scratchWords.forEach(scratchWord -> {
-//                personnels.forEach(personnel -> {
-//                    if (personnel.getId().equals(scratchWord.getCreateId())) {
-//                        scratchWord.setName(personnel.getPersonnelName());
-//                    }
-//                });
-//            });
-//            //装载专利id和专利标题
-//            List<String> patentNos = scratchWords.stream().map(ScratchWordVO::getPatentNo).collect(Collectors.toList());
-//            List<Patent> patents = patentService.list(new LambdaQueryWrapper<Patent>().in(Patent::getPatentNo, patentNos).or().in(Patent::getPublicNo, patentNos));
-//            scratchWords.forEach(scratchWord -> {
-//                patents.forEach(patent -> {
-//                    if (scratchWord.getPatentNo().equals(patent.getPatentNo()) || scratchWord.getPatentNo().equals(patent.getPublicNo())) {
-//                        scratchWord.setPatentId(patent.getId());
-//                        scratchWord.setPatentTitle(patent.getName());
-//                    }
-//                });
-//            });
-//        }
-//        pageVO.setRecords(scratchWords)
-//                .setTotal((int) pageInfo.getTotal());
-////        } else {  //分组
-////            List<GroupName> groupNames = scratchWordsMapper.queryGroupScratchs(queryScratchsDTO, tenantId, personId, projectIds, reportIds);
-////            PageInfo<GroupName> pageInfo = new PageInfo<>(groupNames);
-////            if (groupNames.size() > 0) {
-////                //装载创建人名称
-////                List<Integer> createPersonIds = groupNames.stream().map(GroupName::getCreateId).collect(Collectors.toList());
-////                res = outInterfaceService.getPersonnelByIdsFromPCS(createPersonIds);
-////                jsonObject = JSONObject.parseObject(res);
-////                List<Personnel> personnels = JSON.parseArray(jsonObject.get("data").toString(), Personnel.class);
-////                groupNames.forEach(groupName -> {
-////                    personnels.forEach(personnel -> {
-////                        if (personnel.getId().equals(groupName.getCreateId())) {
-////                            groupName.setName(personnel.getPersonnelName());
-////                        }
-////                    });
-////                });
-////            }
-////            pageVO.setRecords(groupNames)
-////                    .setTotal((int) pageInfo.getTotal());
-////        }
-//
-//        return pageVO;
-//    }
-//
-//    public PageVO queryGroupScratchs(QueryGroupScratchsDTO queryGroupScratchsDTO) throws IOException {
-//        log.info("开始处理【分页分组查询标注清单】的业务，参数为：{}", queryGroupScratchsDTO);
-//
-//        List<SearchItem> search = queryGroupScratchsDTO.getSearch();
-//        List<String> names = search.stream().filter(searchItem -> searchItem.getValue().equals("name")).map(SearchItem::getContent).collect(Collectors.toList());
-//        List<Integer> personIds = new ArrayList<>();
-//        if (names.size() > 0) {
-//            //若根据创建人名称模糊查询，调用权限系统根据人员名称获得人员ids并装载到参数中
-//            String res = outInterfaceService.getPersonIdByNamesPCS(names);
-//            personIds = JSON.parseArray(res, Integer.class);
-//            if (personIds.size() == 0) {
-//                personIds.add(-1);
-//            }
-//        }
-//
-//        //获取登陆人id和所属租户id
-//        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
-//        Integer personId = personnelVO.getId();
-//        Integer tenantId = personnelVO.getTenantId();
-//        String token = "token=" + personnelVO.getToken();
-//
-//        //查询本系统的专题库表"os_thematic"，获取当前登陆人有权查看的专题库projectIds
-//        ProjectVO params = new ProjectVO();
-//        //代码控制不同类型的角色查询权限
-//        if (personnelVO.getRoleType() == null || personnelVO.getRoleType() != 1) {
-//            params.setPersonnelId(personId);
-//            if (personnelVO.getRoleType() != null && personnelVO.getRoleType() == 2) {
-//                params.setTenantId(personnelVO.getTenantId());
-//            }
-//        }
-//        List<Project> projects = projectMapper.getProjects(params);
-//        List<Integer> projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
-//        //查询报告系统，获取当前登陆人有权查看的报告reportIds
-//        String res = outInterfaceService.getReportsFromRMS(token);
-//        JSONObject jsonObject = JSONObject.parseObject(res);
-//        List<Integer> reportIds = JSON.parseArray(jsonObject.get("data").toString(), Integer.class);
-//
-//        //开始查询标注表标注清单
-//        if (queryGroupScratchsDTO.getCurrent() != null && queryGroupScratchsDTO.getSize() != null) {
-//            PageHelper.startPage(queryGroupScratchsDTO.getCurrent(), queryGroupScratchsDTO.getSize());
-//        }
-//        List<GroupName> groupNames = scratchWordsMapper.queryGroupScratchs(personIds, search, queryGroupScratchsDTO.getGrouping(), tenantId, personId, projectIds, reportIds);
-//        PageInfo<GroupName> pageInfo = new PageInfo<>(groupNames);
-//
-//        //若本次请求是根据创建人分组查询，则装载创建人名称
-//        if (groupNames.size() > 0 && queryGroupScratchsDTO.getGrouping().equals("name")) {
-//            List<Integer> createPersonIds = groupNames.stream().map(GroupName::getCreateId).collect(Collectors.toList());
-//            res = outInterfaceService.getPersonnelByIdsFromPCS(createPersonIds);
-//            jsonObject = JSONObject.parseObject(res);
-//            List<Personnel> personnels = JSON.parseArray(jsonObject.get("data").toString(), Personnel.class);
-//            groupNames.forEach(groupName -> {
-//                personnels.forEach(personnel -> {
-//                    if (personnel.getId().equals(groupName.getCreateId())) {
-//                        groupName.setName(personnel.getPersonnelName());
-//                    }
-//                });
-//            });
-//        }
-//        PageVO pageVO = new PageVO()
-//                .setRecords(groupNames)
-//                .setCurrent(queryGroupScratchsDTO.getCurrent())
-//                .setSize(queryGroupScratchsDTO.getSize())
-//                .setTotal((int) pageInfo.getTotal());
-//        return pageVO;
-//
-//    }
 
     /**
      * 删除划词高亮
      *
      * @param ids
-     */
-    public List<Integer> delete(List<Integer> ids) {
-        this.removeBatchByIds(ids);
+     **/
+    public List<String> removeById(List<String> ids) {
+        ids.forEach(item -> {
+            try {
+                esScratchWordsService.removeById(item);
+            }catch (Exception e){
+                throw new XiaoShiException("删除错误");
+            }
+
+        });
         return ids;
     }
 }

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

@@ -616,7 +616,6 @@ public class EsCustomFieldService {
         long total = response.hits().total().value();
         if (total > 0) {
             esCustomFieldHistoryHit = response.hits().hits().get(0);
-
         }
         return esCustomFieldHistoryHit;
 

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

@@ -0,0 +1,239 @@
+package cn.cslg.pas.service.business.es;
+
+import cn.cslg.pas.common.dto.QueryScratchWordsDTO;
+import cn.cslg.pas.common.vo.PatentWithIdVO;
+import cn.cslg.pas.domain.business.ScratchWords;
+import cn.cslg.pas.domain.es.Marking;
+import cn.cslg.pas.domain.es.Patent;
+import cn.cslg.pas.domain.es.PatentJoin;
+import cn.cslg.pas.exception.XiaoShiException;
+import cn.cslg.pas.service.permissions.PermissionService;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch._types.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import co.elastic.clients.elasticsearch.core.DeleteResponse;
+import co.elastic.clients.elasticsearch.core.SearchRequest;
+import co.elastic.clients.elasticsearch.core.SearchResponse;
+import co.elastic.clients.elasticsearch.core.search.Hit;
+import co.elastic.clients.json.JsonData;
+import com.alibaba.fastjson.JSON;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+@Service
+public class EsScratchWordsService {
+    @Autowired
+    private EsService esService;
+    @Autowired
+    private ElasticsearchClient client;
+    @Autowired
+    private PermissionService permissionService;
+
+    //添加划词标注
+    public String addScratchWords(ScratchWords scratchWords) {
+        String patentNo = scratchWords.getPatentNo();
+        if (patentNo == null) {
+            throw new XiaoShiException("请输入专利号");
+        }
+        //根据专利号查询专利
+        String patentId = null;
+        try {
+            PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo(patentNo);
+            if (patentWithIdVO != null) {
+                patentId = patentWithIdVO.getId();
+            }
+        } catch (Exception e) {
+            throw new XiaoShiException("未获取到专利");
+        }
+        if (patentId == null) {
+            throw new XiaoShiException("未获取到专利");
+        }
+        Marking marking = new Marking();
+        BeanUtils.copyProperties(scratchWords, marking);
+        Patent patent = new Patent();
+        patent.setMarkings(marking);
+        PatentJoin patentJoin = new PatentJoin();
+        patentJoin.setParent(patentId);
+        patentJoin.setName("marking");
+        patent.setPatentJoin(patentJoin);
+        String id = null;
+        try {
+            id = esService.addChildPatent(patent, patentId);
+        } catch (Exception e) {
+            throw new XiaoShiException("保存失败");
+        }
+        return id;
+    }
+
+    public String updateScratchWords(String id, Marking marking) {
+        //根据id查询
+        Patent patent = null;
+        try {
+            patent = this.getById(id);
+        } catch (Exception e) {
+            throw new XiaoShiException("错误");
+        }
+        if (patent == null) {
+            throw new XiaoShiException("划词信息不存在");
+        }
+        Marking marking1 = patent.getMarkings();
+        BeanUtils.copyProperties(marking, marking1);
+        patent.setMarkings(marking1);
+        esService.updatePatent(patent, id);
+        return id;
+    }
+
+    public void queryScratchWord(QueryScratchWordsDTO queryScratchWordsDTO) {
+        String createId = "1";
+        Integer tenantId = 1;
+        String createName = queryScratchWordsDTO.getCreateName();
+        String patentNo = queryScratchWordsDTO.getPatentNo();
+        String content = queryScratchWordsDTO.getMarkSelectText();
+        Date marketTime = queryScratchWordsDTO.getMarkTime();
+        Integer projectId = 1;
+        //公开
+        Query q1 = QueryBuilders.term(t -> t.field("markings.is_public").value(true));
+        //不公开
+        Query q2 = QueryBuilders.term(t -> t.field("markings.is_public").value(false));
+        //创建人id
+        Query q3 = QueryBuilders.term(t -> t.field("markings.mark_user_id").value(createId));
+        //租户id
+        Query q4 = QueryBuilders.term(t -> t.field("markings.public_tenant_id").value(tenantId));
+        //公开范围为全部
+        Query q5 = QueryBuilders.term(t -> t.field("markings.public_scope").value(0));
+        //公开范围为所在地
+        Query q6 = QueryBuilders.term(t -> t.field("markings.public_scope").value(1));
+        //数据库id
+        Query q7 = QueryBuilders.term(t -> t.field("public_project_id").value(projectId));
+        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));
+
+        //公开号
+        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));
+
+        //授权号
+        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));
+        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));
+        Query qPatent = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));
+        //公开并且全部范围
+        Query bool1 = QueryBuilders.bool(i -> i.must(q1, q6, q4));
+        // 公开并且所在地
+        Query bool2 = QueryBuilders.bool(i -> i.must(q1, q6, q7));
+        //不公开
+        Query bool3 = QueryBuilders.bool(i -> i.must(q2, q3, q7));
+        List<Query> queries = new ArrayList<>();
+        queries.add(bool1);
+        queries.add(bool2);
+        queries.add(bool3);
+        if (patentNo != null) {
+            Query query = this.getPatentNoQuery(patentNo);
+            queries.add(query);
+        }
+        if (createName != null && createName.trim() != "") {
+            Query query = this.getCreateQuery(createName);
+            queries.add(query);
+        }
+        if (content != null && content.trim() != "") {
+            Query query = this.getContentQuery(content);
+            queries.add(query);
+        }
+        if(marketTime!=null){
+            Query query =this.getMarkTimeQuery(marketTime);
+            queries.add(query);
+        }
+        Query searchBool = QueryBuilders.bool(i -> i.must(queries));
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+
+        builder.index("patent");
+        builder.query(searchBool);
+        try {
+            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+            List<Hit<Patent>> hits = response.hits().hits();
+            List<Patent> patentList = new ArrayList<>();
+            for (Hit<Patent> hit : hits) {
+                Patent patent = hit.source();
+                patentList.add(patent);
+            }
+        } catch (Exception e) {
+            System.out.println("aa");
+        }
+
+    }
+
+
+    //查询栏位历史
+    public Patent getById(String wordsId) throws Exception {
+        Patent patent = null;
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        builder.index("patent");
+        Query q = QueryBuilders.ids(i -> i.values(Arrays.asList(wordsId)));
+        builder.query(q);
+        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+        long total = response.hits().total().value();
+        if (total > 0) {
+            patent = response.hits().hits().get(0).source();
+        }
+        return patent;
+    }
+
+
+    public void removeById(String id) throws IOException {
+        DeleteResponse deleteResponse = client.delete(deleteRequest ->
+                deleteRequest.index("patent").id(id)
+        );
+
+    }
+
+
+    //获得专利号检索式
+    public Query getPatentNoQuery(String patentNo) {
+        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));
+
+        //公开号
+        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));
+
+        //授权号
+        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));
+        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));
+        Query qPatent = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));
+        return qPatent;
+    }
+
+    //获得创建时间检索式
+    public Query getMarkTimeQuery(Date markTime) {
+        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
+        String time = format2.format(markTime);
+        Query query = QueryBuilders.term(t -> t.field("mark_time").value(time));
+        return query;
+    }
+
+    //获得创建人检索式
+    public Query getCreateQuery(String createName) {
+        List<String> ids = new ArrayList<>();
+        try {
+            String json = permissionService.getPersonIdByNamePCS(createName, false);
+            ids = JSON.parseArray(json, String.class);
+        } catch (Exception e) {
+        }
+        if (ids == null || ids.size() == 0) {
+            ids = new ArrayList<>();
+            ids.add("0");
+        }
+        String strs = JsonData.of(ids).toString();
+        Query query = QueryBuilders.term(t -> t.field("mark_time").value(strs));
+        return query;
+    }
+
+    //获得内容检索式
+    public Query getContentQuery(String content) {
+        Query query = QueryBuilders.match(t -> t.field("mark_selectText").query(content));
+        return query;
+    }
+}

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

@@ -89,9 +89,10 @@ public class EsService {
                 .document(patent)
         );
         return indexResponse.id();
-
     }
 
+
+
     /**
      * 根据专利号获取专利id
      *
@@ -125,6 +126,8 @@ public class EsService {
     }
 
 
+
+
     /**
      * Es检索
      *

src/main/java/cn/cslg/pas/service/business/invalidReport/EvidenceReasonService.java

@@ -266,6 +266,7 @@ public class EvidenceReasonService extends ServiceImpl<EvidenceReasonMapper, Evi
                         if (evidenceReason != null) {
                             queryEvidenceReasonVO.setEvidenceText(evidenceReason.getEvidenceText());
                             queryEvidenceReasonVO.setEvidenceDescription(evidenceReason.getDescription());
+                           queryEvidenceReasonVO.setErRbSummary(evidenceReason.getRbSummary());
                             queryEvidenceReasonVO.setErPresentOpinions1(evidenceReason.getPresentOpinions1());
                             queryEvidenceReasonVO.setErRbDecisionKey(evidenceReason.getRbDecisionKey());
                             queryEvidenceReasonVO.setErIfPresentOpinions1(evidenceReason.getIfPresentOpinions1());

src/main/resources/jsons/patent.json

@@ -1079,5 +1079,5 @@
     "ifGroup": "false",
     "ifShow": "false",
     "ifAsCondition": "true"
-  }
+  },
 ]

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

@@ -0,0 +1,69 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.dto.business.UpdateScratchWordsDTO;
+import cn.cslg.pas.domain.business.ScratchWords;
+import cn.cslg.pas.domain.es.Marking;
+import cn.cslg.pas.domain.es.Patent;
+import cn.cslg.pas.service.business.es.EsScratchWordsService;
+import cn.cslg.pas.service.business.es.EsService;
+import org.apache.ibatis.annotations.Update;
+import org.joda.time.DateTime;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Date;
+
+/**
+ * @author chenyu
+ * @date 2023/9/6
+ */
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class EsScratchWordsServiceTest {
+
+    @Autowired
+    private EsScratchWordsService esScratchWordsService;
+
+@Autowired
+private EsService esService;
+    @Test
+    public void addPatent() throws Exception {
+        ScratchWords scratchWords = new ScratchWords();
+        scratchWords.setPatentNo("CN201721042063.9");
+        scratchWords.setPublicTenantId(1);
+        scratchWords.setMarkUserId("1");
+        scratchWords.setIsPublic(true);
+        scratchWords.setMarkColor("#qeqrqr");
+        scratchWords.setMarkOteText("测试标引");
+        scratchWords.setMarkSite(10);
+        scratchWords.setMarkTime(new Date());
+        scratchWords.setPublicScope(1);
+        esScratchWordsService.addScratchWords(scratchWords);
+    }
+
+    @Test
+    public void getPatent() throws Exception {
+
+        esScratchWordsService.query11();
+
+    }
+
+    @Test
+    public void test() throws Exception {
+        UpdateScratchWordsDTO updateScratchWordsDTO =new UpdateScratchWordsDTO();
+        updateScratchWordsDTO.setIsPublic(true);
+        Marking marking =new Marking();
+        BeanUtils.copyProperties(updateScratchWordsDTO,marking);
+        System.out.println(marking);
+    }
+
+    @Test
+    public  void remove() throws  Exception{
+        esScratchWordsService.removeById("noU2_YwBmzIo81_4JOrU");
+
+    }
+}

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

@@ -12,6 +12,8 @@ import cn.cslg.pas.service.business.es.EsService;
 
 import cn.cslg.pas.service.importPatent.SchedulingTaskService;
 import cn.hutool.core.util.XmlUtil;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.BeanUtils;
@@ -59,7 +61,7 @@ public class EsServiceTests {
     }
 
     @Test
-  public  void search() throws Exception {
+    public void search() throws Exception {
         StringRequest stringRequest = new StringRequest();
         stringRequest.setSearchQuery("patentNo=CN201199922Y and (simpleFamilyNum>1 or simpleFamilyNum=0)");
         stringRequest.setCurrent(0L);
@@ -96,9 +98,10 @@ public class EsServiceTests {
         List<String> nos = new ArrayList<>();
         nos.add("CN201920033236.3");
         nos.add("CN202010306989.4");
-        esService.addEsPatentFamily( nos,"inpadoc");
+        esService.addEsPatentFamily(nos, "inpadoc");
         System.out.println("aa");
     }
+
     @Test
     public void addAffairPatent() throws Exception {
         String no = "CN202221363803.X";
@@ -109,4 +112,15 @@ public class EsServiceTests {
         System.out.println("aa");
     }
 
+    @Test
+    public void addNet() throws Exception {
+        List<String> patents = new ArrayList<>();
+        patents.add("aa");
+        patents.add("vbb");
+        String aa = JSONObject.toJSON(patents).toString();
+        List<String> abv =JSONArray.parseArray(aa);
+        System.out.println(abv);
+
+    }
+
 }

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

@@ -1,7 +1,6 @@
 package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.dto.*;
-import cn.cslg.pas.common.dto.business.EsCountDTO;
 import cn.cslg.pas.common.dto.business.EsPatentFamilyDTO;
 import cn.cslg.pas.common.dto.business.ReportTempleDTO;
 import cn.cslg.pas.common.dto.business.SelectClaimDTO;
@@ -10,8 +9,6 @@ import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
 import cn.cslg.pas.common.model.request.*;
 import cn.cslg.pas.common.utils.Response;
-import cn.cslg.pas.common.utils.parseQueryToTree.expressManager;
-import cn.cslg.pas.common.utils.parseQueryToTree.treeNode;
 import cn.cslg.pas.common.vo.business.EsCountVO;
 import cn.cslg.pas.common.vo.business.PatentKinVO;
 import cn.cslg.pas.common.vo.business.PatentNoVO;
@@ -22,7 +19,7 @@ import cn.cslg.pas.domain.es.FamilyPatent;
 import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.domain.es.PatentFamilyMessage;
 import cn.cslg.pas.service.business.ProductMarketDataService;
-import cn.cslg.pas.service.business.TempleService;
+import cn.cslg.pas.service.business.ReportTempleService;
 import cn.cslg.pas.service.business.es.EsCountService;
 import cn.cslg.pas.service.business.es.EsCustomFieldService;
 import cn.cslg.pas.service.business.es.EsService;
@@ -41,8 +38,6 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 
 
 /**
@@ -60,7 +55,7 @@ public class EventServiceTests {
     @Autowired
     private EsCountService esCountService;
     @Autowired
-    private TempleService templeService;
+    private ReportTempleService templeService;
     @Autowired
     private EsPatentService patentService;
     @Autowired