[improvement][project] update version to 0.7.2 (#32)

Co-authored-by: lexluo <lexluo@tencent.com>

CHANGELOG

@@ -1,21 +0,0 @@
-davinci 0.3.0 change log
-1) add data portal
-2) add metric trend chart
-3) add feedback component
-4) add tab component
-5) add page setting
-6) modify permission process
-7) optimize css style
-8) optimize filter
-9) delete view module
-
-
-supersonic 0.6.0 change log
-1) add llm parser and llm api server
-2) support fuzzy mapping
-3) support query filter and domain filter in query and search
-4) support standalone mode
-5) add dsl query in semantic
-6) code architecture adjustment in semantic and chat
-7) add unit testing and integration testing
-8) support dimension and metric alias

CHANGELOG.md

@@ -0,0 +1,116 @@
+# SuperSonic Changelog
+
+- All notable changes to this project will be documented in this file.
+- "Breaking Changes" describes any changes that may break existing functionality or cause
+  compatibility issues with previous versions.
+
+
+
+## SuperSonic [0.7.2] - 2023-08-12
+
+### Added
+- Support asynchronous query - return parse information to user before executing result
+- Add Model as the basic data structure of the semantic definitions - this will repalce the old conception of subdomain
+
+### Updated
+- improve knowledge word similarity algorithm
+- improve embedding plugin chooser
+- improve DSLQuery field correction and parser
+
+
+### Fixed
+-  Fix mapper error that detectWord text is shorter than word
+-  Fix MetricDomainQuery inherit context
+  
+## SuperSonic [0.7.0] - 2023-07-30
+
+### Added
+
+- Add function call parser and embedding recall parser
+- Add plugin management
+- Add web page query and web service query
+- Metric filter query support querying metrics and comparing them in different dimensions
+- Support dimension value mapping
+- Support dimension/metric invisible, chat filter related data
+- Add user guide docs
+
+
+### Fixed
+
+- Fix the data problem of getDomainList interface in standalone mode
+
+## SuperSonic [0.6.0] - 2023-07-16
+
+### Added
+
+- Support llm parser and llm api server - users can query data through complex natural language.
+- Support fuzzy query dimension and metric name - users can set the 'metric.dimension.threshold'
+  parameter to control the fuzzy threshold.
+- Support query filter and domain filter in query and search - users can specify domainId and query
+  filter to filter the results in search and query.
+- Support standalone mode - users can integrate semantic and chat services in one process for easy
+  management and debugging.
+- Support dsl query in semantic - users can specify DSL language to query data in Semantic. In the
+  past, data querying was limited to struct language.
+- Add unit and integration testing - add integration tests for single-turn and multi-turn
+  conversations, to efficiently validate the code.
+- Support dimension and metric alias - users can specify one or multiple aliases to expand search
+  and query.
+- Add scheduled semantic metadata update functionality in chat.
+- Support create datasource by table name in the web page.
+- Add the ability to set permissions for domain.
+- Add a local/Remote implementation to the SemanticLayer interface.
+
+### Updated
+
+- Code architecture adjustment in chat.
+
+1) Abstracting into three modules, namely api, core, and knowledge. Providing four core interfaces:
+   SchemaMapper, SemanticLayer, SemanticParser, and SemanticQuery.
+2) Add RuleSemanticQuery and LLMSemanticQuery implement to SemanticQuery.
+3) Add all possible queries to the candidate queries, and then select the most suitable query from
+   the candidate queries.
+
+- Code architecture adjustment in semantic.
+
+1) Refactor semantic layer SQL parsing code through Calcite.
+2) Add QueryOptimizer interface.
+
+- Chat config subdivided into detailed and metric scenarios - users can set different parameters in these two scenarios.
+
+### Fixed
+
+- Resolved last word not be recognized in SchemaMapper.
+- Fix context inheritance problem.
+- Fix the error of querying H2 database by month unit.
+- Set faker user to context when authentication disable.
+
+## SuperSonic [0.5.0] - 2023-06-15
+
+### Added
+- Add the search and query feature in chat according to rules in an extensible way.
+- Add semantic/chat independent service for users.
+- Add Modeling Interface - users can visually define and maintain semantic models in the web page.
+- Add a unified semantic parsing layer - user can query data by struct language.
+
+# Davinci Changelog
+
+## Davinci [0.3.0] - 2023-06-15
+
+### Added
+
+- add data portal
+- add metric trend chart
+- add feedback component
+- add tab component
+- add page setting
+
+### Updated
+
+- modify permission process
+- optimize css style
+- optimize filter
+
+### Removed
+
+- delete view module

README.md

@@ -2,20 +2,19 @@ English | [中文](README_CN.md)
 
 # SuperSonic (超音数)
 
-**SuperSonic is an out-of-the-box yet highly extensible framework for building a data chatbot**. SuperSonic provides a chat interface that empowers users to query data using natural language and visualize the results with suitable charts. To enable such experience, the only thing necessary is to define logical semantic models (metrics, dimensions, relationships, etc) on top of physical data models, and no data modification or copying is required. Meanwhile SuperSonic is designed to be plugable, allowing new functionalities to be added through plugins and core components to be integrated into other systems.
+**SuperSonic is an out-of-the-box yet highly extensible framework for building a data chatbot**. SuperSonic provides a chat interface that empowers users to query data using natural language and visualize the results with suitable charts. To enable such experience, the only thing necessary is to build logical semantic models (definition of metrics/dimensions/entities, along with their meaning, context and relationships) on top of physical data models, and no data modification or copying is required. Meanwhile, SuperSonic is designed to be pluggable, allowing new functionalities to be added through plugins and core components to be integrated with other systems.
 
-
-<img src="./docs/images/supersonic_demo.gif" align="center"/>
+<img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
 
 ## Motivation
 
-The emergence of Large Language Models (LLMs) like ChatGPT is reshaping the way information is retrieved. In the field of data analytics, both academia and industry are primarily focused on leveraging deep learning models to convert natural language queries into SQL queries. While some works show promising results, they are not applicable to real-world scenarios. 
+The emergence of Large Language Model (LLM) like ChatGPT is reshaping the way information is retrieved. In the field of data analytics, both academia and industry are primarily focused on leveraging LLM to convert natural language queries into SQL queries. While some works show promising results, they are still not applicable to real-world scenarios.
 
 From our perspective, the key to filling the real-world gap lies in two aspects: 
-1. Utilize a combination of rule-based and model-based semantic parsers to deal with different scenarios
-2. Introduce a semantic model layer to encapsulate underlying complexity thus simplify the semantic parsers
+1. Utilize a combination of rule-based and model-based semantic parsers to deal with different scenarios.
+2. Introduce a semantic model layer encapsulating the underlying data complexity(joins, formulas, etc) to simplify semantic parsing.
 
-With these ideas in mind, we developed SuperSonic as a reference implementation and used it to power our real-world products. Additionally, to encourage further development of data chatbots, we decided to open source SuperSonic as an extensible framework.
+With these ideas in mind, we develop SuperSonic as a practical reference implementation and use it to power our real-world products. Additionally, to facilitate further development of data chatbot, we decide to open source SuperSonic as an extensible framework.
 
 ## Out-of-the-box Features
 
@@ -27,35 +26,19 @@ With these ideas in mind, we developed SuperSonic as a reference implementation
 
 ## Extensible Components
 
-SuperSonic is composed of two layers: supersonic-chat and supersonic-semantic. The chat layer is responsible for converting **natural language query** into semantic query (also known as DSL query), whereas the semantic layer is responsible for converting DSL query into **SQL query**. The high-level architecture and main process flow is shown in below diagram:
-
+The high-level architecture and main process flow is shown in below diagram:
 
 <img src="./docs/images/supersonic_components.png" height="80%" width="80%" align="center"/> 
 
-
-### Chat Layer
-
-The chat layer contains four core components:
-
-- **Chat Interface:** accepts user queries and answer results with appropriate visualization charts. It supports input auto-completion as well as multi-turn conversation.
-
-- **Schema Mapper Chain:** identifies references to semantic schema elements in user queries. It matches queries against the knowledage base which is constructed using the schema of semantic models.
-
-- **Semantic Parser Chain:** resolves query mode based on mapped semantic models. It is composed of a group of rule-based and model-based parsers, each of which deals with specific scenarios.
-
-- **Semantic Query:** performs execution according to the results of semantic parsing. The default semantic query would submit DSL to the semantic component, but new types of semantic query can be extended.
-
-### Semantic Layer
-
-The semantic layer contains four core components:
+- **Chat Interface:** accepts natural language queries and answer results with appropriate visualization charts. It supports input auto-completion as well as multi-turn conversation.
 
 - **Modeling Interface:** empowers analytics engineers to visually define and maintain semantic models. The configurations related to access permission and chat conversation can also be set on the UI.
 
-- **DSL Parser:** converts DSL expression to intermediate structures. To make it easily integratable with analytics applications, SQL (without joins and calculation formulas) is used as the DSL.
+- **Schema Mapper Chain:** identifies references to schema elements(metrics/dimensions/entities/values) in user queries. It matches the query text against a knowledge base constructed from the semantic models.
 
-- **Query Planner:** builds and optimizes query plans according to various rules. 
+- **Semantic Parser Chain:** understands user queries and extract semantic information. It consists of a combination of rule-based and model-based parsers, each of which deals with specific scenarios.
 
-- **SQL Generator:** generates final SQL expression (with joins and calculation formulas) based on the query plan.
+- **Semantic Query:** performs execution according to extracted semantic information. It generates SQL queries and executes them against physical data models.
 
 ## Quick Demo
 
@@ -67,4 +50,12 @@ SuperSonic comes with sample semantic models as well as chat conversations that
 
 ## How to Build
 
-Pull the source code and run script "assembly/bin/build-standalone.sh" to build packages in the standalone mode.
+SuperSonic can be deployed in two modes: standalone (intended for quick demo) and distributed (intended for production). 
+
+### Build for Standalone Mode 
+ 
+Pull the source code and run script "assembly/bin/build-standalone.sh" to build a single packages.
+
+### Build for Distributed Mode 
+
+Pull the source code and run scripts "assembly/bin/build-chat.sh" and "assembly/bin/build-semantic.sh" separately to build packages.

README_CN.md

@@ -1,56 +1,42 @@
 # 超音数（SuperSonic）
 
-**超音数是一个开箱即用且易于扩展的数据问答对话框架**。通过超音数的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。超音数不需要修改或复制数据，只需要在物理数据库之上构建逻辑语义模型（定义指标、维度、相互间关系等），即可开启数据问答体验。与此同时，超音数被设计为可插拔式框架，允许以插件形式来扩展新功能，或者将核心组件与其他系统集成。
+**超音数是一个开箱即用且易于扩展的数据问答对话框架**。通过超音数的问答对话界面，用户能够使用自然语言查询数据，系统会选择合适的可视化图表呈现结果。超音数不需要修改或复制数据，只需要在物理数据模型之上构建逻辑语义模型（指标/维度/实体的定义，以及他们的业务含义、相互间关系等），即可开启数据问答体验。与此同时，超音数被设计为可插拔式的框架，允许以插件形式来扩展新功能，或者将核心组件与其他系统集成。
 
-<img src="./docs/images/supersonic_demo.gif" align="center"/>
+<img src="./docs/images/supersonic_demo.gif" height="100%" width="100%" align="center"/>
 
 ## 项目动机
 
 大型语言模型（LLMs）如ChatGPT的出现正在重塑信息检索的方式。在数据分析领域，学术界和工业界主要关注利用深度学习模型将自然语言查询转换为SQL查询。虽然一些工作显示出有前景的结果，但它们还并不适用于实际场景。
 
 在我们看来，为了在实际场景发挥价值，有两个关键点：
-1. 将基于规则和基于模型的语义解析器相结合，发挥各自优势，以便处理不同的场景
-2. 引入语义模型层来封装数据底层的复杂性，从而简化语义解析器的问题求解空间
+1. 将基于规则和基于模型的语义解析器相结合，发挥各自优势，以便处理不同的场景。
+2. 引入语义模型层来封装数据底层的复杂性（关联、公式等），从而简化语义解析的求解空间。
 
-为了验证上述想法，我们开发了超音数项目，并将其应用在实际的内部产品中。与此同时，我们决定将超音数作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
+为了验证上述想法，我们开发了超音数项目，并将其应用在实际的内部产品中。与此同时，我们将超音数作为一个可扩展的框架开源，希望能够促进数据问答对话领域的进一步发展。
 
 ## 开箱即用的特性
 
-- 内置图形界面以便业务用户输入数据查询
-- 内置图形界面以便分析工程师管理语义模型
-- 支持文本输入的联想和查询问题的推荐
-- 支持多轮对话，根据语境自动切换上下文
-- 支持三级权限控制：主题域级、列级、行级
+- 内置图形界面以便业务用户输入数据查询。
+- 内置图形界面以便分析工程师管理语义模型。
+- 支持文本输入的联想和查询问题的推荐。
+- 支持多轮对话，根据语境自动切换上下文。
+- 支持三级权限控制：主题域级、列级、行级。
 
 ## 易于扩展的组件
 
-超音数主要分为两层：supersonic-chat and supersonic-semantic。问答层负责将自然语言查询转换为语义查询（也称为DSL查询），而语义层负责将DSL查询转换为SQL查询。超音数的整体架构和主流程如下图所示：
+超音数的整体架构和主流程如下图所示：
 
 <img src="./docs/images/supersonic_components.png" height="80%" width="80%" align="center"/> 
 
-### 问答层
-
-问答层包含以下4个核心组件：
-
 - **问答对话界面(chat interface)**：接受用户查询并选择合适的可视化图表呈现结果，支持输入联想和多轮对话。
 
-- **模式映射器(schema mapper)**：基于语义模型的schema构建知识库，然后将自然语言查询在知识库中进行匹配，为后续的语义解析提供相关信息。
-
-- **语义解析器链(semantic parser chain)**：识别查询模式并选择最匹配的语义模型，其由一组基于规则或模型的解析器组成，每个解析器可用于应对不同的特定场景。
-
-- **语义查询(semantic query)**: 根据语义解析的结果执行查询，默认的语义查询会将DSL提交给语义组件，但可以扩展新类型的查询。 
-
-### 语义层
-
-语义层包含以下4个核心组件：
-
 - **语义建模界面(modeling interface)**：使分析工程师能够通过可视化方式定义和维护语义模型，与访问权限和聊天对话相关的配置也可以在用户界面上设置。
 
-- **DSL解析器(DSL parser)**：将DSL表达式转换为中间结构。为了使其易于与分析应用程序集成，使用SQL（不含join和计算公式）来作为DSL。
+- **模式映射器(schema mapper chain)**：基于语义模型构建知识库，然后将自然语言文本在知识库中进行匹配，为后续的语义解析提供相关信息。
 
-- **查询计划器(query planner)**：根据各种规则来构建和优化查询计划。
+- **语义解析器(semantic parser chain)**：理解用户查询并抽取语义信息，其由一组基于规则和基于模型的解析器组成，每个解析器可应对不同的特定场景。
 
-- **SQL生成器(SQL genenrator)**：基于查询计划来生成最终的SQL语句（（含join和计算公式））。
+- **语义查询(semantic query)**: 根据语义信息生成物理SQL执行查询。
 
 ## 快速体验
 
@@ -62,4 +48,12 @@
 
 ## 如何构建
 
+超音数可以运行在两个模式：standalone（一般用于快速演示）和distributed（一般用于生产环境）。
+
+### Standalone模式构建
+
 下载源码包，运行脚本"assembly/bin/build-standalone.sh"，将所有服务一起编译打包
+
+### Distributed模式构建
+
+下载源码包，分别运行脚本"assembly/bin/build-chat.sh"、"assembly/bin/build-semantic.sh"，为问答层服务和语义层服务编译打包

assembly/bin/build-ide.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+sbinDir=$(cd "$(dirname "$0")"; pwd)
+baseDir=$(readlink -f $sbinDir/../)
+buildDir=$baseDir/build
+
+cd $baseDir/bin
+sh build-standalone.sh
+
+cd $buildDir
+tar xvf supersonic-webapp.tar.gz
+mv supersonic-webapp webapp
+mv webapp ../../launchers/standalone/target/classes

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/adaptor/UserAdaptor.java

@@ -0,0 +1,24 @@
+package com.tencent.supersonic.auth.api.authentication.adaptor;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.auth.api.authentication.request.UserReq;
+import java.util.List;
+import java.util.Set;
+
+public interface UserAdaptor {
+
+    List<String> getUserNames();
+
+    List<User> getUserList();
+
+    List<Organization> getOrganizationTree();
+
+    void register(UserReq userReq);
+
+    String login(UserReq userReq);
+
+    List<User> getUserByOrg(String key);
+
+    Set<String> getUserAllOrgId(String userName);
+}

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/pojo/Organization.java

@@ -0,0 +1,22 @@
+package com.tencent.supersonic.auth.api.authentication.pojo;
+
+import com.google.common.collect.Lists;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class Organization {
+
+    private String id;
+
+    private String parentId;
+
+    private String name;
+
+    private String fullName;
+
+    private List<Organization> subOrganizations = Lists.newArrayList();
+
+    private boolean isRoot;
+
+}

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/service/UserService.java

@@ -1,9 +1,10 @@
 package com.tencent.supersonic.auth.api.authentication.service;
 
+import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
-
 import java.util.List;
+import java.util.Set;
 
 public interface UserService {
 
@@ -14,4 +15,10 @@ public interface UserService {
     void register(UserReq userCmd);
 
     String login(UserReq userCmd);
+
+    Set<String> getUserAllOrgId(String userName);
+
+    List<User> getUserByOrg(String key);
+
+    List<Organization> getOrganizationTree();
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authentication/service/UserStrategy.java

@@ -1,7 +1,6 @@
 package com.tencent.supersonic.auth.api.authentication.service;
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
-
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthGroup.java

@@ -6,7 +6,7 @@ import lombok.Data;
 @Data
 public class AuthGroup {
 
-    private String domainId;
+    private String modelId;
     private String name;
     private Integer groupId;
     private List<AuthRule> authRules;

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/pojo/AuthRes.java

@@ -7,14 +7,14 @@ import lombok.ToString;
 @ToString
 public class AuthRes {
 
-    private String domainId;
+    private String modelId;
     private String name;
 
     public AuthRes() {
     }
 
-    public AuthRes(String domainId, String name) {
-        this.domainId = domainId;
+    public AuthRes(String modelId, String name) {
+        this.modelId = modelId;
         this.name = name;
     }
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/request/QueryAuthResReq.java

@@ -3,7 +3,6 @@ package com.tencent.supersonic.auth.api.authorization.request;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
 import java.util.ArrayList;
 import java.util.List;
-
 import lombok.Data;
 import lombok.ToString;
 
@@ -17,5 +16,5 @@ public class QueryAuthResReq {
 
     private List<AuthRes> resources;
 
-    private String domainId;
+    private String modelId;
 }

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/request/QueryGroupReq.java

@@ -1,7 +1,7 @@
 package com.tencent.supersonic.auth.api.authorization.request;
 
 
-import com.tencent.supersonic.common.request.PageBaseReq;
+import com.tencent.supersonic.common.pojo.PageBaseReq;
 import java.util.List;
 import lombok.Data;
 

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/response/AuthorizedResourceResp.java

@@ -4,7 +4,6 @@ import com.tencent.supersonic.auth.api.authorization.pojo.AuthResGrp;
 import com.tencent.supersonic.auth.api.authorization.pojo.DimensionFilter;
 import java.util.ArrayList;
 import java.util.List;
-
 import lombok.Data;
 
 @Data

auth/api/src/main/java/com/tencent/supersonic/auth/api/authorization/service/AuthService.java

@@ -3,8 +3,8 @@ package com.tencent.supersonic.auth.api.authorization.service;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
 import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
-import javax.servlet.http.HttpServletRequest;
 import java.util.List;
+import javax.servlet.http.HttpServletRequest;
 
 public interface AuthService {
 

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/adaptor/DefaultUserAdaptor.java

@@ -1,67 +1,58 @@
-package com.tencent.supersonic.auth.authentication.application;
+package com.tencent.supersonic.auth.authentication.adaptor;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.tencent.supersonic.auth.api.authentication.adaptor.UserAdaptor;
+import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
-import com.tencent.supersonic.auth.api.authentication.service.UserService;
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO;
-import com.tencent.supersonic.auth.authentication.domain.repository.UserRepository;
-import com.tencent.supersonic.auth.authentication.domain.utils.UserTokenUtils;
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO;
+import com.tencent.supersonic.auth.authentication.persistence.repository.UserRepository;
+import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
+import com.tencent.supersonic.common.util.ContextUtils;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.springframework.beans.BeanUtils;
-import org.springframework.stereotype.Service;
-
-@Service
-public class UserServiceImpl implements UserService {
-
-    private UserRepository userRepository;
-
-    private UserTokenUtils userTokenUtils;
-
-    public UserServiceImpl(UserRepository userRepository, UserTokenUtils userTokenUtils) {
-        this.userRepository = userRepository;
-        this.userTokenUtils = userTokenUtils;
-    }
 
+public class DefaultUserAdaptor implements UserAdaptor {
 
     private List<UserDO> getUserDOList() {
+        UserRepository userRepository = ContextUtils.getBean(UserRepository.class);
         return userRepository.getUserList();
     }
 
     private UserDO getUser(String name) {
+        UserRepository userRepository = ContextUtils.getBean(UserRepository.class);
         return userRepository.getUser(name);
     }
 
-    public boolean checkExist(UserWithPassword user) {
-        UserDO userDO = getUser(user.getName());
-        if (userDO == null) {
-            return false;
-        }
-        return userDO.getPassword().equals(user.getPassword());
-    }
-
     @Override
     public List<String> getUserNames() {
         return getUserDOList().stream().map(UserDO::getName).collect(Collectors.toList());
     }
 
-
     @Override
     public List<User> getUserList() {
         List<UserDO> userDOS = getUserDOList();
         return userDOS.stream().map(this::convert).collect(Collectors.toList());
     }
 
+    @Override
+    public List<Organization> getOrganizationTree() {
+        return Lists.newArrayList();
+    }
+
     private User convert(UserDO userDO) {
         User user = new User();
         BeanUtils.copyProperties(userDO, user);
         return user;
     }
 
-
     @Override
     public void register(UserReq userReq) {
+        UserRepository userRepository = ContextUtils.getBean(UserRepository.class);
         List<String> userDOS = getUserNames();
         if (userDOS.contains(userReq.getName())) {
             throw new RuntimeException(String.format("user %s exist", userReq.getName()));
@@ -73,6 +64,7 @@ public class UserServiceImpl implements UserService {
 
     @Override
     public String login(UserReq userReq) {
+        UserTokenUtils userTokenUtils = ContextUtils.getBean(UserTokenUtils.class);
         UserDO userDO = getUser(userReq.getName());
         if (userDO == null) {
             throw new RuntimeException("user not exist,please register");
@@ -85,5 +77,14 @@ public class UserServiceImpl implements UserService {
         throw new RuntimeException("password not correct, please try again");
     }
 
+    @Override
+    public List<User> getUserByOrg(String key) {
+        return Lists.newArrayList();
+    }
+
+    @Override
+    public Set<String> getUserAllOrgId(String userName) {
+        return Sets.newHashSet();
+    }
 
 }

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/config/TppConfig.java

@@ -0,0 +1,21 @@
+package com.tencent.supersonic.auth.authentication.config;
+
+
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+@Data
+@Configuration
+public class TppConfig {
+
+    @Value(value = "${auth.app.secret:}")
+    private String appSecret;
+
+    @Value(value = "${auth.app.key:}")
+    private String appKey;
+
+    @Value(value = "${auth.oa.url:}")
+    private String tppOaUrl;
+
+}

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/infrastructure/mapper/UserDOMapper.java

@@ -1,51 +0,0 @@
-package com.tencent.supersonic.auth.authentication.infrastructure.mapper;
-
-
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO;
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDOExample;
-import java.util.List;
-import org.apache.ibatis.annotations.Mapper;
-
-@Mapper
-public interface UserDOMapper {
-
-    /**
-     * @mbg.generated
-     */
-    long countByExample(UserDOExample example);
-
-    /**
-     * @mbg.generated
-     */
-    int deleteByPrimaryKey(Long id);
-
-    /**
-     * @mbg.generated
-     */
-    int insert(UserDO record);
-
-    /**
-     * @mbg.generated
-     */
-    int insertSelective(UserDO record);
-
-    /**
-     * @mbg.generated
-     */
-    List<UserDO> selectByExample(UserDOExample example);
-
-    /**
-     * @mbg.generated
-     */
-    UserDO selectByPrimaryKey(Long id);
-
-    /**
-     * @mbg.generated
-     */
-    int updateByPrimaryKeySelective(UserDO record);
-
-    /**
-     * @mbg.generated
-     */
-    int updateByPrimaryKey(UserDO record);
-}

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/AuthenticationIgnore.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.interceptor;
+package com.tencent.supersonic.auth.authentication.interceptor;
 
 
 import java.lang.annotation.ElementType;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/AuthenticationInterceptor.java

@@ -1,10 +1,10 @@
-package com.tencent.supersonic.auth.authentication.domain.interceptor;
+package com.tencent.supersonic.auth.authentication.interceptor;
 
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
 import com.tencent.supersonic.auth.api.authentication.constant.UserConstants;
-import com.tencent.supersonic.auth.authentication.application.UserServiceImpl;
-import com.tencent.supersonic.auth.authentication.domain.utils.UserTokenUtils;
-import com.tencent.supersonic.common.util.context.S2ThreadContext;
+import com.tencent.supersonic.auth.authentication.service.UserServiceImpl;
+import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
+import com.tencent.supersonic.common.util.S2ThreadContext;
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.List;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/DefaultAuthenticationInterceptor.java

@@ -1,15 +1,15 @@
-package com.tencent.supersonic.auth.authentication.domain.interceptor;
+package com.tencent.supersonic.auth.authentication.interceptor;
 
 
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
-import com.tencent.supersonic.auth.authentication.application.UserServiceImpl;
-import com.tencent.supersonic.auth.authentication.domain.utils.UserTokenUtils;
-import com.tencent.supersonic.common.exception.AccessException;
-import com.tencent.supersonic.common.util.context.ContextUtils;
-import com.tencent.supersonic.common.util.context.S2ThreadContext;
-import com.tencent.supersonic.common.util.context.ThreadContext;
+import com.tencent.supersonic.auth.authentication.service.UserServiceImpl;
+import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
+import com.tencent.supersonic.common.pojo.exception.AccessException;
+import com.tencent.supersonic.common.util.ContextUtils;
+import com.tencent.supersonic.common.util.S2ThreadContext;
+import com.tencent.supersonic.common.util.ThreadContext;
 import java.lang.reflect.Method;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -35,11 +35,14 @@ public class DefaultAuthenticationInterceptor extends AuthenticationInterceptor
             setFakerUser(request);
             return true;
         }
-        HandlerMethod handlerMethod = (HandlerMethod) handler;
-        Method method = handlerMethod.getMethod();
-        AuthenticationIgnore ignore = method.getAnnotation(AuthenticationIgnore.class);
-        if (ignore != null) {
-            return true;
+
+        if (handler instanceof HandlerMethod) {
+            HandlerMethod handlerMethod = (HandlerMethod) handler;
+            Method method = handlerMethod.getMethod();
+            AuthenticationIgnore ignore = method.getAnnotation(AuthenticationIgnore.class);
+            if (ignore != null) {
+                return true;
+            }
         }
 
         String uri = request.getServletPath();

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/interceptor/InterceptorFactory.java

@@ -1,12 +1,11 @@
-package com.tencent.supersonic.auth.authentication.domain.interceptor;
+package com.tencent.supersonic.auth.authentication.interceptor;
 
+import java.util.List;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.support.SpringFactoriesLoader;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import java.util.List;
-
 @Configuration
 public class InterceptorFactory implements WebMvcConfigurer {
 

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/dataobject/UserDO.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.dataobject;
+package com.tencent.supersonic.auth.authentication.persistence.dataobject;
 
 public class UserDO {
 

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/dataobject/UserDOExample.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.dataobject;
+package com.tencent.supersonic.auth.authentication.persistence.dataobject;
 
 import java.util.ArrayList;
 import java.util.List;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/mapper/UserDOMapper.java

@@ -0,0 +1,22 @@
+package com.tencent.supersonic.auth.authentication.persistence.mapper;
+
+
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO;
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample;
+import java.util.List;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface UserDOMapper {
+
+    /**
+     * @mbg.generated
+     */
+    int insert(UserDO record);
+
+    /**
+     * @mbg.generated
+     */
+    List<UserDO> selectByExample(UserDOExample example);
+
+}

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/repository/Impl/UserRepositoryImpl.java

@@ -1,10 +1,10 @@
-package com.tencent.supersonic.auth.authentication.infrastructure.repository;
+package com.tencent.supersonic.auth.authentication.persistence.repository.Impl;
 
 
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO;
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDOExample;
-import com.tencent.supersonic.auth.authentication.domain.repository.UserRepository;
-import com.tencent.supersonic.auth.authentication.infrastructure.mapper.UserDOMapper;
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO;
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample;
+import com.tencent.supersonic.auth.authentication.persistence.mapper.UserDOMapper;
+import com.tencent.supersonic.auth.authentication.persistence.repository.UserRepository;
 import java.util.List;
 import java.util.Optional;
 import org.springframework.stereotype.Component;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/persistence/repository/UserRepository.java

@@ -1,6 +1,6 @@
-package com.tencent.supersonic.auth.authentication.domain.repository;
+package com.tencent.supersonic.auth.authentication.persistence.repository;
 
-import com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO;
+import com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO;
 import java.util.List;
 
 public interface UserRepository {

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/rest/UserController.java

@@ -1,15 +1,18 @@
 package com.tencent.supersonic.auth.authentication.rest;
 
 
+import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.request.UserReq;
 import com.tencent.supersonic.auth.api.authentication.service.UserService;
 import com.tencent.supersonic.auth.api.authentication.utils.UserHolder;
 import java.util.List;
+import java.util.Set;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -32,7 +35,6 @@ public class UserController {
         return UserHolder.findUser(httpServletRequest, httpServletResponse);
     }
 
-
     @GetMapping("/getUserNames")
     public List<String> getUserNames() {
         return userService.getUserNames();
@@ -43,6 +45,21 @@ public class UserController {
         return userService.getUserList();
     }
 
+    @GetMapping("/getOrganizationTree")
+    public List<Organization> getOrganizationTree() {
+        return userService.getOrganizationTree();
+    }
+
+    @GetMapping("/getUserAllOrgId/{userName}")
+    public Set<String> getUserAllOrgId(@PathVariable("userName") String userName) {
+        return userService.getUserAllOrgId(userName);
+    }
+
+    @GetMapping("/getUserByOrg/{org}")
+    public List<User> getUserByOrg(@PathVariable("org") String org) {
+        return userService.getUserByOrg(org);
+    }
+
     @PostMapping("/register")
     public void register(@RequestBody UserReq userCmd) {
         userService.register(userCmd);

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/service/UserServiceImpl.java

@@ -0,0 +1,51 @@
+package com.tencent.supersonic.auth.authentication.service;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.Organization;
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.auth.api.authentication.request.UserReq;
+import com.tencent.supersonic.auth.api.authentication.service.UserService;
+import com.tencent.supersonic.auth.authentication.utils.ComponentFactory;
+import java.util.List;
+import java.util.Set;
+import org.springframework.stereotype.Service;
+
+@Service
+public class UserServiceImpl implements UserService {
+
+
+    @Override
+    public List<String> getUserNames() {
+        return ComponentFactory.getUserAdaptor().getUserNames();
+    }
+
+    @Override
+    public List<User> getUserList() {
+        return ComponentFactory.getUserAdaptor().getUserList();
+    }
+
+    @Override
+    public Set<String> getUserAllOrgId(String userName) {
+        return ComponentFactory.getUserAdaptor().getUserAllOrgId(userName);
+    }
+
+    @Override
+    public List<User> getUserByOrg(String key) {
+        return ComponentFactory.getUserAdaptor().getUserByOrg(key);
+    }
+
+    @Override
+    public List<Organization> getOrganizationTree() {
+        return ComponentFactory.getUserAdaptor().getOrganizationTree();
+    }
+
+    @Override
+    public void register(UserReq userReq) {
+        ComponentFactory.getUserAdaptor().register(userReq);
+    }
+
+    @Override
+    public String login(UserReq userReq) {
+        return ComponentFactory.getUserAdaptor().login(userReq);
+    }
+
+}

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/strategy/FakeUserStrategy.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.strategy;
+package com.tencent.supersonic.auth.authentication.strategy;
 
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/strategy/HttpHeaderUserStrategy.java

@@ -1,8 +1,8 @@
-package com.tencent.supersonic.auth.authentication.domain.strategy;
+package com.tencent.supersonic.auth.authentication.strategy;
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.service.UserStrategy;
-import com.tencent.supersonic.auth.authentication.domain.utils.UserTokenUtils;
+import com.tencent.supersonic.auth.authentication.utils.UserTokenUtils;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import org.springframework.stereotype.Service;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/strategy/UserStrategyFactory.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.strategy;
+package com.tencent.supersonic.auth.authentication.strategy;
 
 
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/utils/ComponentFactory.java

@@ -0,0 +1,23 @@
+package com.tencent.supersonic.auth.authentication.utils;
+
+import com.tencent.supersonic.auth.api.authentication.adaptor.UserAdaptor;
+import java.util.Objects;
+import org.springframework.core.io.support.SpringFactoriesLoader;
+
+public class ComponentFactory {
+
+    private static UserAdaptor userAdaptor;
+
+    public static UserAdaptor getUserAdaptor() {
+        if (Objects.isNull(userAdaptor)) {
+            userAdaptor = init(UserAdaptor.class);
+        }
+        return userAdaptor;
+    }
+
+    private static <T> T init(Class<T> factoryType) {
+        return SpringFactoriesLoader.loadFactories(factoryType,
+                Thread.currentThread().getContextClassLoader()).get(0);
+    }
+
+}

auth/authentication/src/main/java/com/tencent/supersonic/auth/authentication/utils/UserTokenUtils.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.auth.authentication.domain.utils;
+package com.tencent.supersonic.auth.authentication.utils;
 
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_ALGORITHM;
 import static com.tencent.supersonic.auth.api.authentication.constant.UserConstants.TOKEN_CREATE_TIME;
@@ -13,7 +13,7 @@ import static com.tencent.supersonic.auth.api.authentication.constant.UserConsta
 import com.tencent.supersonic.auth.api.authentication.config.AuthenticationConfig;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.auth.api.authentication.pojo.UserWithPassword;
-import com.tencent.supersonic.common.exception.AccessException;
+import com.tencent.supersonic.common.pojo.exception.AccessException;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;

auth/authentication/src/main/resources/mapper/UserDOMapper.xml

@@ -1,145 +1,159 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.tencent.supersonic.auth.authentication.infrastructure.mapper.UserDOMapper">
-  <resultMap id="BaseResultMap" type="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO">
-    <id column="id" jdbcType="BIGINT" property="id" />
-    <result column="name" jdbcType="VARCHAR" property="name" />
-    <result column="password" jdbcType="VARCHAR" property="password" />
-    <result column="display_name" jdbcType="VARCHAR" property="displayName" />
-    <result column="email" jdbcType="VARCHAR" property="email" />
-  </resultMap>
-  <sql id="Example_Where_Clause">
-    <where>
-      <foreach collection="oredCriteria" item="criteria" separator="or">
-        <if test="criteria.valid">
-          <trim prefix="(" prefixOverrides="and" suffix=")">
-            <foreach collection="criteria.criteria" item="criterion">
-              <choose>
-                <when test="criterion.noValue">
-                  and ${criterion.condition}
-                </when>
-                <when test="criterion.singleValue">
-                  and ${criterion.condition} #{criterion.value}
-                </when>
-                <when test="criterion.betweenValue">
-                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
-                </when>
-                <when test="criterion.listValue">
-                  and ${criterion.condition}
-                  <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
-                    #{listItem}
-                  </foreach>
-                </when>
-              </choose>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tencent.supersonic.auth.authentication.persistence.mapper.UserDOMapper">
+    <resultMap id="BaseResultMap"
+            type="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
+        <id column="id" jdbcType="BIGINT" property="id"/>
+        <result column="name" jdbcType="VARCHAR" property="name"/>
+        <result column="password" jdbcType="VARCHAR" property="password"/>
+        <result column="display_name" jdbcType="VARCHAR" property="displayName"/>
+        <result column="email" jdbcType="VARCHAR" property="email"/>
+    </resultMap>
+    <sql id="Example_Where_Clause">
+        <where>
+            <foreach collection="oredCriteria" item="criteria" separator="or">
+                <if test="criteria.valid">
+                    <trim prefix="(" prefixOverrides="and" suffix=")">
+                        <foreach collection="criteria.criteria" item="criterion">
+                            <choose>
+                                <when test="criterion.noValue">
+                                    and ${criterion.condition}
+                                </when>
+                                <when test="criterion.singleValue">
+                                    and ${criterion.condition} #{criterion.value}
+                                </when>
+                                <when test="criterion.betweenValue">
+                                    and ${criterion.condition} #{criterion.value} and
+                                    #{criterion.secondValue}
+                                </when>
+                                <when test="criterion.listValue">
+                                    and ${criterion.condition}
+                                    <foreach close=")" collection="criterion.value" item="listItem"
+                                            open="(" separator=",">
+                                        #{listItem}
+                                    </foreach>
+                                </when>
+                            </choose>
+                        </foreach>
+                    </trim>
+                </if>
             </foreach>
-          </trim>
+        </where>
+    </sql>
+    <sql id="Base_Column_List">
+        id
+        , name, password, display_name, email
+    </sql>
+    <select id="selectByExample"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample"
+            resultMap="BaseResultMap">
+        select
+        <if test="distinct">
+            distinct
         </if>
-      </foreach>
-    </where>
-  </sql>
-  <sql id="Base_Column_List">
-    id, name, password, display_name, email
-  </sql>
-  <select id="selectByExample" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDOExample" resultMap="BaseResultMap">
-    select
-    <if test="distinct">
-      distinct
-    </if>
-    <include refid="Base_Column_List" />
-    from s2_user
-    <if test="_parameter != null">
-      <include refid="Example_Where_Clause" />
-    </if>
-    <if test="orderByClause != null">
-      order by ${orderByClause}
-    </if>
-    <if test="limitStart != null and limitStart>=0">
-      limit #{limitStart} , #{limitEnd}
-    </if>
-  </select>
-  <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
-    select 
-    <include refid="Base_Column_List" />
-    from s2_user
-    where id = #{id,jdbcType=BIGINT}
-  </select>
-  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
-    delete from s2_user
-    where id = #{id,jdbcType=BIGINT}
-  </delete>
-  <insert id="insert" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO">
-    insert into s2_user (id, name, password, 
-      display_name, email)
-    values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
-      #{displayName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR})
-  </insert>
-  <insert id="insertSelective" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO">
-    insert into s2_user
-    <trim prefix="(" suffix=")" suffixOverrides=",">
-      <if test="id != null">
-        id,
-      </if>
-      <if test="name != null">
-        name,
-      </if>
-      <if test="password != null">
-        password,
-      </if>
-      <if test="displayName != null">
-        display_name,
-      </if>
-      <if test="email != null">
-        email,
-      </if>
-    </trim>
-    <trim prefix="values (" suffix=")" suffixOverrides=",">
-      <if test="id != null">
-        #{id,jdbcType=BIGINT},
-      </if>
-      <if test="name != null">
-        #{name,jdbcType=VARCHAR},
-      </if>
-      <if test="password != null">
-        #{password,jdbcType=VARCHAR},
-      </if>
-      <if test="displayName != null">
-        #{displayName,jdbcType=VARCHAR},
-      </if>
-      <if test="email != null">
-        #{email,jdbcType=VARCHAR},
-      </if>
-    </trim>
-  </insert>
-  <select id="countByExample" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDOExample" resultType="java.lang.Long">
-    select count(*) from s2_user
-    <if test="_parameter != null">
-      <include refid="Example_Where_Clause" />
-    </if>
-  </select>
-  <update id="updateByPrimaryKeySelective" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO">
-    update s2_user
-    <set>
-      <if test="name != null">
-        name = #{name,jdbcType=VARCHAR},
-      </if>
-      <if test="password != null">
-        password = #{password,jdbcType=VARCHAR},
-      </if>
-      <if test="displayName != null">
-        display_name = #{displayName,jdbcType=VARCHAR},
-      </if>
-      <if test="email != null">
-        email = #{email,jdbcType=VARCHAR},
-      </if>
-    </set>
-    where id = #{id,jdbcType=BIGINT}
-  </update>
-  <update id="updateByPrimaryKey" parameterType="com.tencent.supersonic.auth.authentication.domain.dataobject.UserDO">
-    update s2_user
-    set name = #{name,jdbcType=VARCHAR},
-      password = #{password,jdbcType=VARCHAR},
-      display_name = #{displayName,jdbcType=VARCHAR},
-      email = #{email,jdbcType=VARCHAR}
-    where id = #{id,jdbcType=BIGINT}
-  </update>
+        <include refid="Base_Column_List"/>
+        from s2_user
+        <if test="_parameter != null">
+            <include refid="Example_Where_Clause"/>
+        </if>
+        <if test="orderByClause != null">
+            order by ${orderByClause}
+        </if>
+        <if test="limitStart != null and limitStart>=0">
+            limit #{limitStart} , #{limitEnd}
+        </if>
+    </select>
+    <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from s2_user
+        where id = #{id,jdbcType=BIGINT}
+    </select>
+    <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
+        delete
+        from s2_user
+        where id = #{id,jdbcType=BIGINT}
+    </delete>
+    <insert id="insert"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
+        insert into s2_user (id, name, password,
+                             display_name, email)
+        values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR},
+                #{displayName,jdbcType=VARCHAR}, #{email,jdbcType=VARCHAR})
+    </insert>
+    <insert id="insertSelective"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
+        insert into s2_user
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="id != null">
+                id,
+            </if>
+            <if test="name != null">
+                name,
+            </if>
+            <if test="password != null">
+                password,
+            </if>
+            <if test="displayName != null">
+                display_name,
+            </if>
+            <if test="email != null">
+                email,
+            </if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="id != null">
+                #{id,jdbcType=BIGINT},
+            </if>
+            <if test="name != null">
+                #{name,jdbcType=VARCHAR},
+            </if>
+            <if test="password != null">
+                #{password,jdbcType=VARCHAR},
+            </if>
+            <if test="displayName != null">
+                #{displayName,jdbcType=VARCHAR},
+            </if>
+            <if test="email != null">
+                #{email,jdbcType=VARCHAR},
+            </if>
+        </trim>
+    </insert>
+    <select id="countByExample"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDOExample"
+            resultType="java.lang.Long">
+        select count(*) from s2_user
+        <if test="_parameter != null">
+            <include refid="Example_Where_Clause"/>
+        </if>
+    </select>
+    <update id="updateByPrimaryKeySelective"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
+        update s2_user
+        <set>
+            <if test="name != null">
+                name = #{name,jdbcType=VARCHAR},
+            </if>
+            <if test="password != null">
+                password = #{password,jdbcType=VARCHAR},
+            </if>
+            <if test="displayName != null">
+                display_name = #{displayName,jdbcType=VARCHAR},
+            </if>
+            <if test="email != null">
+                email = #{email,jdbcType=VARCHAR},
+            </if>
+        </set>
+        where id = #{id,jdbcType=BIGINT}
+    </update>
+    <update id="updateByPrimaryKey"
+            parameterType="com.tencent.supersonic.auth.authentication.persistence.dataobject.UserDO">
+        update s2_user
+        set name         = #{name,jdbcType=VARCHAR},
+            password     = #{password,jdbcType=VARCHAR},
+            display_name = #{displayName,jdbcType=VARCHAR},
+            email        = #{email,jdbcType=VARCHAR}
+        where id = #{id,jdbcType=BIGINT}
+    </update>
 </mapper>

auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/application/AuthServiceImpl.java

@@ -2,36 +2,40 @@ package com.tencent.supersonic.auth.authorization.application;
 
 import com.google.common.base.Strings;
 import com.google.gson.Gson;
+import com.tencent.supersonic.auth.api.authentication.service.UserService;
+import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthRes;
 import com.tencent.supersonic.auth.api.authorization.pojo.AuthResGrp;
+import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
 import com.tencent.supersonic.auth.api.authorization.pojo.DimensionFilter;
 import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
 import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
 import com.tencent.supersonic.auth.api.authorization.service.AuthService;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
 import javax.servlet.http.HttpServletRequest;
-
-import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
-import com.tencent.supersonic.auth.api.authorization.pojo.AuthRule;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
 @Service
 @Slf4j
 public class AuthServiceImpl implements AuthService {
 
     private JdbcTemplate jdbcTemplate;
 
-    public AuthServiceImpl(JdbcTemplate jdbcTemplate) {
+    private UserService userService;
+
+    public AuthServiceImpl(JdbcTemplate jdbcTemplate,
+            UserService userService) {
         this.jdbcTemplate = jdbcTemplate;
+        this.userService = userService;
     }
 
     private List<AuthGroup> load() {
@@ -41,10 +45,10 @@ public class AuthServiceImpl implements AuthService {
     }
 
     @Override
-    public List<AuthGroup> queryAuthGroups(String domainId, Integer groupId) {
+    public List<AuthGroup> queryAuthGroups(String modelId, Integer groupId) {
         return load().stream()
                 .filter(group -> (Objects.isNull(groupId) || groupId.equals(group.getGroupId()))
-                        && domainId.equals(group.getDomainId()))
+                        && modelId.equals(group.getModelId()))
                 .collect(Collectors.toList());
     }
 
@@ -75,18 +79,22 @@ public class AuthServiceImpl implements AuthService {
 
     @Override
     public AuthorizedResourceResp queryAuthorizedResources(QueryAuthResReq req, HttpServletRequest request) {
+        Set<String> userOrgIds = userService.getUserAllOrgId(req.getUser());
+        if (!CollectionUtils.isEmpty(userOrgIds)) {
+            req.setDepartmentIds(new ArrayList<>(userOrgIds));
+        }
         List<AuthGroup> groups = getAuthGroups(req);
         AuthorizedResourceResp resource = new AuthorizedResourceResp();
-        Map<String, List<AuthGroup>> authGroupsByDomainId = groups.stream()
-                .collect(Collectors.groupingBy(AuthGroup::getDomainId));
+        Map<String, List<AuthGroup>> authGroupsByModelId = groups.stream()
+                .collect(Collectors.groupingBy(AuthGroup::getModelId));
         Map<String, List<AuthRes>> reqAuthRes = req.getResources().stream()
-                .collect(Collectors.groupingBy(AuthRes::getDomainId));
+                .collect(Collectors.groupingBy(AuthRes::getModelId));
 
-        for (String domainId : reqAuthRes.keySet()) {
-            List<AuthRes> reqResourcesList = reqAuthRes.get(domainId);
+        for (String modelId : reqAuthRes.keySet()) {
+            List<AuthRes> reqResourcesList = reqAuthRes.get(modelId);
             AuthResGrp rg = new AuthResGrp();
-            if (authGroupsByDomainId.containsKey(domainId)) {
-                List<AuthGroup> authGroups = authGroupsByDomainId.get(domainId);
+            if (authGroupsByModelId.containsKey(modelId)) {
+                List<AuthGroup> authGroups = authGroupsByModelId.get(modelId);
                 for (AuthRes reqRes : reqResourcesList) {
                     for (AuthGroup authRuleGroup : authGroups) {
                         List<AuthRule> authRules = authRuleGroup.getAuthRules();
@@ -105,8 +113,8 @@ public class AuthServiceImpl implements AuthService {
             }
         }
 
-        if (StringUtils.isNotEmpty(req.getDomainId())) {
-            List<AuthGroup> authGroups = authGroupsByDomainId.get(req.getDomainId());
+        if (StringUtils.isNotEmpty(req.getModelId())) {
+            List<AuthGroup> authGroups = authGroupsByModelId.get(req.getModelId());
             if (!CollectionUtils.isEmpty(authGroups)) {
                 for (AuthGroup group : authGroups) {
                     if (group.getDimensionFilters() != null
@@ -119,23 +127,22 @@ public class AuthServiceImpl implements AuthService {
                 }
             }
         }
-
         return resource;
     }
 
     private List<AuthGroup> getAuthGroups(QueryAuthResReq req) {
-        List<AuthGroup> groups = load().stream().
-                filter(group -> {
-                    if (!Objects.equals(group.getDomainId(), req.getDomainId())) {
+        List<AuthGroup> groups = load().stream()
+                .filter(group -> {
+                    if (!Objects.equals(group.getModelId(), req.getModelId())) {
                         return false;
                     }
                     if (!CollectionUtils.isEmpty(group.getAuthorizedUsers()) && group.getAuthorizedUsers()
                             .contains(req.getUser())) {
                         return true;
                     }
-                    for (String deparmentId : req.getDepartmentIds()) {
+                    for (String departmentId : req.getDepartmentIds()) {
                         if (!CollectionUtils.isEmpty(group.getAuthorizedDepartmentIds())
-                                && group.getAuthorizedDepartmentIds().contains(deparmentId)) {
+                                && group.getAuthorizedDepartmentIds().contains(departmentId)) {
                             return true;
                         }
                     }

auth/authorization/src/main/java/com/tencent/supersonic/auth/authorization/rest/AuthController.java

@@ -1,9 +1,9 @@
 package com.tencent.supersonic.auth.authorization.rest;
 
+import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import com.tencent.supersonic.auth.api.authorization.request.QueryAuthResReq;
 import com.tencent.supersonic.auth.api.authorization.response.AuthorizedResourceResp;
 import com.tencent.supersonic.auth.api.authorization.service.AuthService;
-import com.tencent.supersonic.auth.api.authorization.pojo.AuthGroup;
 import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;
@@ -26,9 +26,9 @@ public class AuthController {
     }
 
     @GetMapping("/queryGroup")
-    public List<AuthGroup> queryAuthGroup(@RequestParam("domainId") String domainId,
+    public List<AuthGroup> queryAuthGroup(@RequestParam("modelId") String modelId,
             @RequestParam(value = "groupId", required = false) Integer groupId) {
-        return authService.queryAuthGroups(domainId, groupId);
+        return authService.queryAuthGroups(modelId, groupId);
     }
 
     /**

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SchemaMapper.java

@@ -1,6 +1,6 @@
 package com.tencent.supersonic.chat.api.component;
 
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
+import com.tencent.supersonic.chat.api.pojo.QueryContext;
 
 /**
  * This interface defines the contract for a schema mapper that identifies references to schema
@@ -11,5 +11,5 @@ import com.tencent.supersonic.chat.api.request.QueryContextReq;
  */
 public interface SchemaMapper {
 
-    void map(QueryContextReq queryContext);
+    void map(QueryContext queryContext);
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticLayer.java

@@ -2,12 +2,18 @@ package com.tencent.supersonic.chat.api.component;
 
 import com.github.pagehelper.PageInfo;
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.semantic.api.core.request.PageDimensionReq;
-import com.tencent.supersonic.semantic.api.core.request.PageMetricReq;
-import com.tencent.supersonic.semantic.api.core.response.*;
-import com.tencent.supersonic.semantic.api.query.request.QuerySqlReq;
+import com.tencent.supersonic.chat.api.pojo.ModelSchema;
+import com.tencent.supersonic.common.pojo.enums.AuthType;
+import com.tencent.supersonic.semantic.api.model.request.PageDimensionReq;
+import com.tencent.supersonic.semantic.api.model.request.PageMetricReq;
+import com.tencent.supersonic.semantic.api.model.response.DimensionResp;
+import com.tencent.supersonic.semantic.api.model.response.DomainResp;
+import com.tencent.supersonic.semantic.api.model.response.MetricResp;
+import com.tencent.supersonic.semantic.api.model.response.ModelResp;
+import com.tencent.supersonic.semantic.api.model.response.QueryResultWithSchemaResp;
+import com.tencent.supersonic.semantic.api.query.request.QueryDslReq;
+import com.tencent.supersonic.semantic.api.query.request.QueryMultiStructReq;
 import com.tencent.supersonic.semantic.api.query.request.QueryStructReq;
-
 import java.util.List;
 
 /**
@@ -26,26 +32,21 @@ public interface SemanticLayer {
 
     QueryResultWithSchemaResp queryByStruct(QueryStructReq queryStructReq, User user);
 
-    QueryResultWithSchemaResp queryBySql(QuerySqlReq querySqlReq, User user);
+    QueryResultWithSchemaResp queryByMultiStruct(QueryMultiStructReq queryMultiStructReq, User user);
 
-    DomainSchemaResp getDomainSchemaInfo(Long domain, Boolean cacheEnable);
+    QueryResultWithSchemaResp queryByDsl(QueryDslReq queryDslReq, User user);
 
-    List<DomainSchemaResp> getDomainSchemaInfo(List<Long> ids);
+    List<ModelSchema> getModelSchema();
 
-    List<DomainResp> getDomainListForViewer();
+    List<ModelSchema> getModelSchema(List<Long> ids);
 
-    List<DomainResp> getDomainListForAdmin();
+    ModelSchema getModelSchema(Long model, Boolean cacheEnable);
 
-    PageInfo<DimensionResp> queryDimensionPage(PageDimensionReq pageDimensionCmd);
+    PageInfo<DimensionResp> getDimensionPage(PageDimensionReq pageDimensionCmd);
 
-    PageInfo<MetricResp> queryMetricPage(PageMetricReq pageMetricCmd);
+    PageInfo<MetricResp> getMetricPage(PageMetricReq pageMetricCmd);
 
-//    PageInfo<MetricResp> queryMetricPage(PageMetricReq pageMetricCmd);
-//
-//    PageInfo<DimensionResp> queryDimensionPage(PageDimensionReq pageDimensionCmd);
-//
-//    List<DomainResp> getDomainListForAdmin();
-//
-//    List<DomainResp> getDomainListForViewer();
+    List<DomainResp> getDomainList(User user);
 
+    List<ModelResp> getModelList(AuthType authType, Long domainId, User user);
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticParser.java

@@ -2,7 +2,7 @@ package com.tencent.supersonic.chat.api.component;
 
 
 import com.tencent.supersonic.chat.api.pojo.ChatContext;
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
+import com.tencent.supersonic.chat.api.pojo.QueryContext;
 
 /**
  * This interface defines the contract for a semantic parser that can analyze natural language query
@@ -13,5 +13,5 @@ import com.tencent.supersonic.chat.api.request.QueryContextReq;
  */
 public interface SemanticParser {
 
-    void parse(QueryContextReq queryContext, ChatContext chatContext);
+    void parse(QueryContext queryContext, ChatContext chatContext);
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/component/SemanticQuery.java

@@ -2,7 +2,8 @@ package com.tencent.supersonic.chat.api.component;
 
 import com.tencent.supersonic.auth.api.authentication.pojo.User;
 import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.response.QueryResultResp;
+import com.tencent.supersonic.chat.api.pojo.response.QueryResult;
+import org.apache.calcite.sql.parser.SqlParseException;
 
 /**
  * This class defines the contract for a semantic query that executes specific type of
@@ -12,7 +13,9 @@ public interface SemanticQuery {
 
     String getQueryMode();
 
-    QueryResultResp execute(User user);
+    QueryResult execute(User user) throws SqlParseException;
 
     SemanticParseInfo getParseInfo();
+
+    void setParseInfo(SemanticParseInfo parseInfo);
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/ModelSchema.java

@@ -0,0 +1,45 @@
+package com.tencent.supersonic.chat.api.pojo;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import lombok.Data;
+
+@Data
+public class ModelSchema {
+
+    private SchemaElement model;
+    private Set<SchemaElement> metrics = new HashSet<>();
+    private Set<SchemaElement> dimensions = new HashSet<>();
+    private Set<SchemaElement> dimensionValues = new HashSet<>();
+    private SchemaElement entity = new SchemaElement();
+
+    public SchemaElement getElement(SchemaElementType elementType, long elementID) {
+        Optional<SchemaElement> element = Optional.empty();
+
+        switch (elementType) {
+            case ENTITY:
+                element = Optional.ofNullable(entity);
+                break;
+            case MODEL:
+                element = Optional.of(model);
+                break;
+            case METRIC:
+                element = metrics.stream().filter(e -> e.getId() == elementID).findFirst();
+                break;
+            case DIMENSION:
+                element = dimensions.stream().filter(e -> e.getId() == elementID).findFirst();
+                break;
+            case VALUE:
+                element = dimensionValues.stream().filter(e -> e.getId() == elementID).findFirst();
+            default:
+        }
+
+        if (element.isPresent()) {
+            return element.get();
+        } else {
+            return null;
+        }
+    }
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/QueryContext.java

@@ -0,0 +1,21 @@
+package com.tencent.supersonic.chat.api.pojo;
+
+import com.tencent.supersonic.chat.api.component.SemanticQuery;
+import com.tencent.supersonic.chat.api.pojo.request.QueryReq;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class QueryContext {
+
+    private QueryReq request;
+    private List<SemanticQuery> candidateQueries = new ArrayList<>();
+    private SchemaMapInfo mapInfo = new SchemaMapInfo();
+
+    public QueryContext(QueryReq request) {
+        this.request = request;
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/QueryMatchInfo.java

@@ -1,12 +0,0 @@
-package com.tencent.supersonic.chat.api.pojo;
-
-import lombok.Data;
-
-@Data
-public class QueryMatchInfo {
-
-    SchemaElementType elementType;
-    String detectWord;
-    private Integer count = 0;
-    private double maxSimilarity;
-}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaElement.java

@@ -0,0 +1,59 @@
+package com.tencent.supersonic.chat.api.pojo;
+
+import com.google.common.base.Objects;
+import java.io.Serializable;
+import java.util.List;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Data
+@Getter
+@Builder
+@NoArgsConstructor
+//@AllArgsConstructor
+public class SchemaElement implements Serializable {
+
+    private Long model;
+    private Long id;
+    private String name;
+    private String bizName;
+    private Long useCnt;
+    private SchemaElementType type;
+    private List<String> alias;
+
+//    public SchemaElement() {
+//    }
+
+    public SchemaElement(Long model, Long id, String name, String bizName,
+            Long useCnt, SchemaElementType type, List<String> alias) {
+        this.model = model;
+        this.id = id;
+        this.name = name;
+        this.bizName = bizName;
+        this.useCnt = useCnt;
+        this.type = type;
+        this.alias = alias;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        SchemaElement schemaElement = (SchemaElement) o;
+        return Objects.equal(model, schemaElement.model) && Objects.equal(id,
+                schemaElement.id) && Objects.equal(name, schemaElement.name)
+                && Objects.equal(bizName, schemaElement.bizName) && Objects.equal(
+                useCnt, schemaElement.useCnt) && Objects.equal(type, schemaElement.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(model, id, name, bizName, useCnt, type);
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaElementMatch.java

@@ -13,15 +13,11 @@ import lombok.ToString;
 @NoArgsConstructor
 public class SchemaElementMatch {
 
-    SchemaElementType elementType;
-
-    int elementID;
-
+    SchemaElement element;
     double similarity;
-
     String detectWord;
-
     String word;
-
     Long frequency;
+    boolean isInherited;
+
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaElementType.java

@@ -1,7 +1,7 @@
 package com.tencent.supersonic.chat.api.pojo;
 
 public enum SchemaElementType {
-    DOMAIN,
+    MODEL,
     METRIC,
     DIMENSION,
     VALUE,

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SchemaMapInfo.java

@@ -7,26 +7,21 @@ import java.util.Set;
 
 public class SchemaMapInfo {
 
-    private Map<Integer, List<SchemaElementMatch>> domainElementMatches = new HashMap<>();
+    private Map<Long, List<SchemaElementMatch>> modelElementMatches = new HashMap<>();
 
-    public Set<Integer> getMatchedDomains() {
-        return domainElementMatches.keySet();
+    public Set<Long> getMatchedModels() {
+        return modelElementMatches.keySet();
     }
 
-    public List<SchemaElementMatch> getMatchedElements(Integer domain) {
-        return domainElementMatches.get(domain);
+    public List<SchemaElementMatch> getMatchedElements(Long model) {
+        return modelElementMatches.get(model);
     }
 
-    public Map<Integer, List<SchemaElementMatch>> getDomainElementMatches() {
-        return domainElementMatches;
+    public Map<Long, List<SchemaElementMatch>> getModelElementMatches() {
+        return modelElementMatches;
     }
 
-    public void setDomainElementMatches(
-            Map<Integer, List<SchemaElementMatch>> domainElementMatches) {
-        this.domainElementMatches = domainElementMatches;
-    }
-
-    public void setMatchedElements(Integer domain, List<SchemaElementMatch> elementMatches) {
-        domainElementMatches.put(domain, elementMatches);
+    public void setMatchedElements(Long model, List<SchemaElementMatch> elementMatches) {
+        modelElementMatches.put(model, elementMatches);
     }
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SemanticParseInfo.java

@@ -1,34 +1,66 @@
 package com.tencent.supersonic.chat.api.pojo;
 
 
-import com.tencent.supersonic.common.enums.AggregateTypeEnum;
+import com.tencent.supersonic.chat.api.pojo.request.QueryFilter;
 import com.tencent.supersonic.common.pojo.DateConf;
 import com.tencent.supersonic.common.pojo.Order;
-import com.tencent.supersonic.common.pojo.SchemaItem;
-
+import com.tencent.supersonic.common.pojo.enums.AggregateTypeEnum;
 import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.TreeSet;
 import lombok.Data;
 
 @Data
 public class SemanticParseInfo {
 
-    String queryMode;
-    AggregateTypeEnum aggType = AggregateTypeEnum.NONE;
-    Long domainId = 0L;
-    String domainName;
-    Long entity = 0L;
-    Set<SchemaItem> metrics = new LinkedHashSet();
-    Set<SchemaItem> dimensions = new LinkedHashSet();
-    Set<Filter> dimensionFilters = new LinkedHashSet();
-    Set<Filter> metricFilters = new LinkedHashSet();
+    private String queryMode;
+    private SchemaElement model;
+    private Set<SchemaElement> metrics = new TreeSet<>(new SchemaNameLengthComparator());
+    private Set<SchemaElement> dimensions = new LinkedHashSet();
+    private SchemaElement entity;
+    private AggregateTypeEnum aggType = AggregateTypeEnum.NONE;
+    private Set<QueryFilter> dimensionFilters = new LinkedHashSet();
+    private Set<QueryFilter> metricFilters = new LinkedHashSet();
     private Set<Order> orders = new LinkedHashSet();
     private DateConf dateInfo;
     private Long limit;
     private Boolean nativeQuery = false;
-    private Double bonus = 0d;
+    private double score;
     private List<SchemaElementMatch> elementMatches = new ArrayList<>();
-    private Object info;
+    private Map<String, Object> properties = new HashMap<>();
+
+    public Long getModelId() {
+        return model != null ? model.getId() : 0L;
+    }
+
+    public String getModelName() {
+        return model != null ? model.getName() : "null";
+    }
+
+    private static class SchemaNameLengthComparator implements Comparator<SchemaElement> {
+
+        @Override
+        public int compare(SchemaElement o1, SchemaElement o2) {
+            int len1 = o1.getName().length();
+            int len2 = o2.getName().length();
+            if (len1 != len2) {
+                return len1 - len2;
+            } else {
+                return o1.getName().compareTo(o2.getName());
+            }
+        }
+    }
+
+    public Set<SchemaElement> getMetrics() {
+        Set<SchemaElement> metricSet = new TreeSet<>(new SchemaNameLengthComparator());
+        metricSet.addAll(metrics);
+        metrics = metricSet;
+        return metrics;
+    }
+
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/SemanticSchema.java

@@ -0,0 +1,55 @@
+package com.tencent.supersonic.chat.api.pojo;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class SemanticSchema implements Serializable {
+
+    private List<ModelSchema> modelSchemaList;
+
+    public SemanticSchema(List<ModelSchema> modelSchemaList) {
+        this.modelSchemaList = modelSchemaList;
+    }
+
+    public void add(ModelSchema schema) {
+        modelSchemaList.add(schema);
+    }
+
+    public Map<Long, String> getModelIdToName() {
+        return modelSchemaList.stream()
+                .collect(Collectors.toMap(a -> a.getModel().getId(), a -> a.getModel().getName(), (k1, k2) -> k1));
+    }
+
+    public List<SchemaElement> getDimensionValues() {
+        List<SchemaElement> dimensionValues = new ArrayList<>();
+        modelSchemaList.stream().forEach(d -> dimensionValues.addAll(d.getDimensionValues()));
+        return dimensionValues;
+    }
+
+    public List<SchemaElement> getDimensions() {
+        List<SchemaElement> dimensions = new ArrayList<>();
+        modelSchemaList.stream().forEach(d -> dimensions.addAll(d.getDimensions()));
+        return dimensions;
+    }
+
+    public List<SchemaElement> getMetrics() {
+        List<SchemaElement> metrics = new ArrayList<>();
+        modelSchemaList.stream().forEach(d -> metrics.addAll(d.getMetrics()));
+        return metrics;
+    }
+
+    public List<SchemaElement> getModels() {
+        List<SchemaElement> models = new ArrayList<>();
+        modelSchemaList.stream().forEach(d -> models.add(d.getModel()));
+        return models;
+    }
+
+    public List<SchemaElement> getEntities() {
+        List<SchemaElement> entities = new ArrayList<>();
+        modelSchemaList.stream().forEach(d -> entities.add(d.getEntity()));
+        return entities;
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatAggConfigReq.java

@@ -0,0 +1,23 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatAggConfigReq {
+
+    /**
+     * invisible dimensions/metrics
+     */
+    private ItemVisibility visibility;
+
+    /**
+     * information about dictionary about the model
+     */
+    private List<KnowledgeInfoReq> knowledgeInfos;
+
+    private KnowledgeAdvancedConfig globalKnowledgeConfig;
+
+    private ChatDefaultConfigReq chatDefaultConfig;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatConfigBaseReq.java

@@ -0,0 +1,38 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.common.pojo.enums.StatusEnum;
+import java.util.List;
+import lombok.Data;
+import lombok.ToString;
+
+/**
+ * extended information command about model
+ */
+@Data
+@ToString
+public class ChatConfigBaseReq {
+
+    private Long modelId;
+
+    /**
+     * the chatDetailConfig about the model
+     */
+    private ChatDetailConfigReq chatDetailConfig;
+
+    /**
+     * the chatAggConfig about the model
+     */
+    private ChatAggConfigReq chatAggConfig;
+
+
+    /**
+     * the recommended questions about the model
+     */
+    private List<RecommendedQuestionReq> recommendedQuestions;
+
+    /**
+     * available status
+     */
+    private StatusEnum status;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatConfigEditReqReq.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import lombok.Data;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatConfigFilter.java

@@ -1,6 +1,6 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
-import com.tencent.supersonic.common.enums.StatusEnum;
+import com.tencent.supersonic.common.pojo.enums.StatusEnum;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
@@ -10,6 +10,6 @@ import lombok.NoArgsConstructor;
 public class ChatConfigFilter {
 
     private Long id;
-    private Long domainId;
+    private Long modelId;
     private StatusEnum status = StatusEnum.ONLINE;
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatDefaultConfigReq.java

@@ -1,14 +1,13 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 
-import com.tencent.supersonic.common.constant.Constants;
-import lombok.Data;
-
+import com.tencent.supersonic.common.pojo.Constants;
 import java.util.ArrayList;
 import java.util.List;
+import lombok.Data;
 
 @Data
-public class ChatDefaultConfig {
+public class ChatDefaultConfigReq {
 
     private List<Long> dimensionIds = new ArrayList<>();
     private List<Long> metricIds = new ArrayList<>();
@@ -24,4 +23,15 @@ public class ChatDefaultConfig {
      */
     private String period = Constants.DAY;
 
+    private TimeMode timeMode = TimeMode.LAST;
+
+    public enum TimeMode {
+        /**
+         * date mode
+         * LAST   - a certain time
+         * RECENT - a period time
+         */
+        LAST, RECENT
+    }
+
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ChatDetailConfigReq.java

@@ -0,0 +1,23 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatDetailConfigReq {
+
+    /**
+     * invisible dimensions/metrics
+     */
+    private ItemVisibility visibility;
+
+    /**
+     * information about dictionary about the model
+     */
+    private List<KnowledgeInfoReq> knowledgeInfos;
+
+    private KnowledgeAdvancedConfig globalKnowledgeConfig;
+
+    private ChatDefaultConfigReq chatDefaultConfig;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/Entity.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import java.util.List;
 import lombok.AllArgsConstructor;
@@ -7,7 +7,7 @@ import lombok.NoArgsConstructor;
 import lombok.ToString;
 
 /**
- * the entity info about the domain
+ * the entity info about the model
  */
 @Data
 @AllArgsConstructor

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ExecuteQueryReq.java

@@ -0,0 +1,16 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
+import lombok.Data;
+
+@Data
+public class ExecuteQueryReq {
+
+    private User user;
+    private Integer chatId;
+    private String queryText;
+    private SemanticParseInfo parseInfo;
+    private boolean saveAnswer = true;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/ItemVisibility.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import java.util.ArrayList;
 import java.util.List;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/KnowledgeAdvancedConfig.java

@@ -1,9 +1,8 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
-
-import lombok.Data;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import java.util.ArrayList;
 import java.util.List;
+import lombok.Data;
 
 /**
  * advanced knowledge config

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/KnowledgeInfoReq.java

@@ -1,21 +1,18 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.request;
 
-import com.tencent.supersonic.common.enums.TypeEnums;
-
-import java.util.List;
+import com.tencent.supersonic.common.pojo.enums.TypeEnums;
 import javax.validation.constraints.NotNull;
-
 import lombok.Data;
 
 /**
- * information about dictionary about the domain
+ * information about dictionary about the model
  */
 
 @Data
-public class KnowledgeInfo {
+public class KnowledgeInfoReq {
 
     /**
-     * metricId、DimensionId、domainId
+     * metricId、DimensionId、modelId
      */
     private Long itemId;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/PageQueryInfoReq.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.domain.pojo.chat;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import lombok.Data;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/PluginQueryReq.java

@@ -0,0 +1,21 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+
+import lombok.Data;
+
+@Data
+public class PluginQueryReq {
+
+
+    private String name;
+
+    private String parseMode;
+
+    private String type;
+
+    private String model;
+
+    private String pattern;
+
+    private String createdBy;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryDataReq.java

@@ -0,0 +1,24 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+
+import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import com.tencent.supersonic.common.pojo.DateConf;
+import com.tencent.supersonic.common.pojo.Order;
+import java.util.HashSet;
+import java.util.Set;
+import lombok.Data;
+
+@Data
+public class QueryDataReq {
+
+    String queryMode;
+    SchemaElement model;
+    Set<SchemaElement> metrics = new HashSet<>();
+    Set<SchemaElement> dimensions = new HashSet<>();
+    Set<QueryFilter> dimensionFilters = new HashSet<>();
+    Set<QueryFilter> metricFilters = new HashSet<>();
+    private Set<Order> orders = new HashSet<>();
+    private DateConf dateInfo;
+    private Long limit;
+    private Boolean nativeQuery = false;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryFilter.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.api.pojo;
+package com.tencent.supersonic.chat.api.pojo.request;
 
 import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
 import java.util.Objects;
@@ -7,7 +7,7 @@ import lombok.ToString;
 
 @Data
 @ToString(callSuper = true)
-public class Filter {
+public class QueryFilter {
 
     private String bizName;
 
@@ -27,7 +27,7 @@ public class Filter {
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
-        Filter filter = (Filter) o;
+        QueryFilter filter = (QueryFilter) o;
         return Objects.equals(bizName, filter.bizName) && Objects.equals(name, filter.name)
                 && operator == filter.operator && Objects.equals(value, filter.value) && Objects.equals(
                 elementID, filter.elementID);

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryFilters.java

@@ -1,16 +1,14 @@
-package com.tencent.supersonic.chat.api.pojo;
+package com.tencent.supersonic.chat.api.pojo.request;
 
-import lombok.Data;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import lombok.Data;
 
 @Data
-public class QueryFilter {
-
-    private List<Filter> filters = new ArrayList<>();
+public class QueryFilters {
 
+    private List<QueryFilter> filters = new ArrayList<>();
     private Map<String, Object> params = new HashMap<>();
-
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/QueryReq.java

@@ -0,0 +1,15 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import lombok.Data;
+
+@Data
+public class QueryReq {
+
+    private String queryText;
+    private Integer chatId;
+    private Long modelId = 0L;
+    private User user;
+    private QueryFilters queryFilters;
+    private boolean saveAnswer = true;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/request/RecommendedQuestionReq.java

@@ -0,0 +1,16 @@
+package com.tencent.supersonic.chat.api.pojo.request;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@Data
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+public class RecommendedQuestionReq {
+
+    private String question;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/AggregateInfo.java

@@ -0,0 +1,11 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class AggregateInfo {
+
+    private List<MetricInfo> metricInfos = new ArrayList<>();
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatAggRichConfigResp.java

@@ -0,0 +1,25 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.request.KnowledgeAdvancedConfig;
+import com.tencent.supersonic.chat.api.pojo.request.KnowledgeInfoReq;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatAggRichConfigResp {
+
+    /**
+     * invisible dimensions/metrics
+     */
+    private ItemVisibilityInfo visibility;
+
+    /**
+     * information about dictionary about the model
+     */
+    private List<KnowledgeInfoReq> knowledgeInfos;
+
+    private KnowledgeAdvancedConfig globalKnowledgeConfig;
+
+    private ChatDefaultRichConfigResp chatDefaultConfig;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatConfigResp.java

@@ -0,0 +1,33 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.request.ChatAggConfigReq;
+import com.tencent.supersonic.chat.api.pojo.request.ChatDetailConfigReq;
+import com.tencent.supersonic.chat.api.pojo.request.RecommendedQuestionReq;
+import com.tencent.supersonic.common.pojo.enums.StatusEnum;
+import java.util.Date;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatConfigResp {
+
+    private Long id;
+
+    private Long modelId;
+
+    private ChatDetailConfigReq chatDetailConfig;
+
+    private ChatAggConfigReq chatAggConfig;
+
+    private List<RecommendedQuestionReq> recommendedQuestions;
+
+    /**
+     * available status
+     */
+    private StatusEnum statusEnum;
+
+    private String createdBy;
+    private String updatedBy;
+    private Date createdAt;
+    private Date updatedAt;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatConfigRichResp.java

@@ -0,0 +1,34 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.request.RecommendedQuestionReq;
+import com.tencent.supersonic.common.pojo.enums.StatusEnum;
+import java.util.Date;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatConfigRichResp {
+
+    private Long id;
+
+    private Long modelId;
+
+    private String modelName;
+    private String bizName;
+
+    private ChatAggRichConfigResp chatAggRichConfig;
+
+    private ChatDetailRichConfigResp chatDetailRichConfig;
+
+    private List<RecommendedQuestionReq> recommendedQuestions;
+
+    /**
+     * available status
+     */
+    private StatusEnum statusEnum;
+
+    private String createdBy;
+    private String updatedBy;
+    private Date createdAt;
+    private Date updatedAt;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatDefaultRichConfigResp.java

@@ -0,0 +1,30 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+
+import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import com.tencent.supersonic.chat.api.pojo.request.ChatDefaultConfigReq;
+import com.tencent.supersonic.common.pojo.Constants;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatDefaultRichConfigResp {
+
+    private List<SchemaElement> dimensions;
+    private List<SchemaElement> metrics;
+
+
+    /**
+     * default time span unit
+     */
+    private Integer unit = 1;
+
+    /**
+     * default time type: day
+     * DAY, WEEK, MONTH, YEAR
+     */
+    private String period = Constants.DAY;
+
+    private ChatDefaultConfigReq.TimeMode timeMode;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ChatDetailRichConfigResp.java

@@ -0,0 +1,26 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.request.KnowledgeAdvancedConfig;
+import com.tencent.supersonic.chat.api.pojo.request.KnowledgeInfoReq;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class ChatDetailRichConfigResp {
+
+    /**
+     * invisible dimensions/metrics
+     */
+    private ItemVisibilityInfo visibility;
+
+    /**
+     * information about dictionary about the model
+     */
+    private List<KnowledgeInfoReq> knowledgeInfos;
+
+    private KnowledgeAdvancedConfig globalKnowledgeConfig;
+
+    private ChatDefaultRichConfigResp chatDefaultConfig;
+
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/DataInfo.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.api.pojo;
+package com.tencent.supersonic.chat.api.pojo.response;
 
 import lombok.Data;
 

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/EntityInfo.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.api.pojo;
+package com.tencent.supersonic.chat.api.pojo.response;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -7,7 +7,7 @@ import lombok.Data;
 @Data
 public class EntityInfo {
 
-    private DomainInfo domainInfo = new DomainInfo();
+    private ModelInfo modelInfo = new ModelInfo();
     private List<DataInfo> dimensions = new ArrayList<>();
     private List<DataInfo> metrics = new ArrayList<>();
     private String entityId;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/EntityRichInfoResp.java

@@ -0,0 +1,16 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class EntityRichInfoResp {
+
+    /**
+     * entity alias
+     */
+    private List<String> names;
+
+    private SchemaElement dimItem;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ItemVisibilityInfo.java

@@ -1,4 +1,4 @@
-package com.tencent.supersonic.chat.domain.pojo.config;
+package com.tencent.supersonic.chat.api.pojo.response;
 
 import java.util.List;
 import lombok.Data;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/MetricInfo.java

@@ -0,0 +1,15 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import java.util.Map;
+import lombok.Data;
+
+@Data
+public class MetricInfo {
+
+    private String name;
+    private String dimension;
+    private String value;
+    private String date;
+    private Map<String, String> statistics;
+
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ModelInfo.java

@@ -1,11 +1,11 @@
-package com.tencent.supersonic.chat.api.pojo;
+package com.tencent.supersonic.chat.api.pojo.response;
 
 import java.io.Serializable;
 import java.util.List;
 import lombok.Data;
 
 @Data
-public class DomainInfo extends DataInfo implements Serializable {
+public class ModelInfo extends DataInfo implements Serializable {
 
     private List<String> words;
     private String primaryEntityBizName;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/ParseResp.java

@@ -0,0 +1,29 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Data
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ParseResp {
+
+    private Integer chatId;
+    private String queryText;
+    private ParseState state;
+    private List<SemanticParseInfo> selectedParses;
+    private List<SemanticParseInfo> candidateParses;
+
+    public enum ParseState {
+        COMPLETED,
+        PENDING,
+        FAILED
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/QueryResp.java

@@ -1,11 +1,10 @@
-package com.tencent.supersonic.chat.domain.pojo.chat;
+package com.tencent.supersonic.chat.api.pojo.response;
 
-import com.tencent.supersonic.chat.api.response.QueryResultResp;
 import java.util.Date;
 import lombok.Data;
 
 @Data
-public class ChatQueryVO {
+public class QueryResp {
 
     private Long questionId;
     private Date createTime;
@@ -13,5 +12,5 @@ public class ChatQueryVO {
     private Integer score;
     private String feedback;
     private String queryText;
-    private QueryResultResp queryResponse;
+    private QueryResult queryResult;
 }

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/QueryResult.java

@@ -1,21 +1,21 @@
-package com.tencent.supersonic.chat.api.response;
+package com.tencent.supersonic.chat.api.pojo.response;
 
-import com.tencent.supersonic.chat.api.pojo.EntityInfo;
 import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.semantic.api.core.pojo.QueryAuthorization;
-import com.tencent.supersonic.semantic.api.core.pojo.QueryColumn;
+import com.tencent.supersonic.common.pojo.QueryAuthorization;
+import com.tencent.supersonic.common.pojo.QueryColumn;
 import java.util.List;
 import java.util.Map;
 import lombok.Data;
 
 @Data
-public class QueryResultResp {
+public class QueryResult {
 
     public EntityInfo entityInfo;
+    public AggregateInfo aggregateInfo;
     private Long queryId;
     private String queryMode;
     private String querySql;
-    private int queryState;
+    private QueryState queryState = QueryState.EMPTY;
     private List<QueryColumn> queryColumns;
     private QueryAuthorization queryAuthorization;
     private SemanticParseInfo chatContext;

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/QueryState.java

@@ -0,0 +1,8 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+public enum QueryState {
+    SUCCESS,
+    SEARCH_EXCEPTION,
+    EMPTY,
+    INVALID;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/RecommendQuestionResp.java

@@ -0,0 +1,14 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.request.RecommendedQuestionReq;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class RecommendQuestionResp {
+
+    private Long modelId;
+    private List<RecommendedQuestionReq> recommendedQuestions;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/RecommendResp.java

@@ -0,0 +1,12 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.SchemaElement;
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class RecommendResp {
+
+    private List<SchemaElement> dimensions;
+    private List<SchemaElement> metrics;
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/SearchResp.java

@@ -0,0 +1,14 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import java.util.List;
+import lombok.Data;
+
+@Data
+public class SearchResp {
+
+    private List<SearchResult> searchResults;
+
+    public SearchResp(List<SearchResult> searchResults) {
+        this.searchResults = searchResults;
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/pojo/response/SearchResult.java

@@ -0,0 +1,45 @@
+package com.tencent.supersonic.chat.api.pojo.response;
+
+import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
+import java.util.Objects;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+@Data
+@Setter
+@Getter
+@Builder
+public class SearchResult {
+
+    private String recommend;
+
+    private String subRecommend;
+
+    private String modelName;
+
+    private Long modelId;
+
+    private SchemaElementType schemaElementType;
+
+    private boolean isComplete = true;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        SearchResult searchResult1 = (SearchResult) o;
+        return Objects.equals(recommend, searchResult1.recommend) && Objects.equals(modelName,
+                searchResult1.modelName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(recommend, modelName);
+    }
+}

chat/api/src/main/java/com/tencent/supersonic/chat/api/request/QueryContextReq.java

@@ -1,23 +0,0 @@
-package com.tencent.supersonic.chat.api.request;
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.component.SemanticQuery;
-import com.tencent.supersonic.chat.api.pojo.QueryFilter;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import lombok.Data;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Data
-public class QueryContextReq {
-
-    private String queryText;
-    private Integer chatId;
-    private Integer domainId = 0;
-    private User user;
-    private QueryFilter queryFilter;
-    private List<SemanticQuery> candidateQueries = new ArrayList<>();
-    private SchemaMapInfo mapInfo = new SchemaMapInfo();
-    private boolean saveAnswer = true;
-}

chat/core/pom.xml

@@ -40,6 +40,11 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>com.github.plexpt</groupId>
+            <artifactId>chatgpt</artifactId>
+            <version>4.1.2</version>
+        </dependency>
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -113,12 +118,6 @@
             <artifactId>semantic-api</artifactId>
             <version>${project.version}</version>
         </dependency>
-<!--        <dependency>-->
-<!--            <groupId>com.tencent.supersonic</groupId>-->
-<!--            <artifactId>semantic-query</artifactId>-->
-<!--            <version>${project.version}</version>-->
-<!--            <scope>compile</scope>-->
-<!--        </dependency>-->
         <dependency>
             <groupId>com.tencent.supersonic</groupId>
             <artifactId>semantic-query</artifactId>
@@ -137,6 +136,12 @@
             <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
+
+        <dependency>
+            <groupId>com.github.xkzhangsan</groupId>
+            <artifactId>xk-time</artifactId>
+            <version>${xk.time.version}</version>
+        </dependency>
     </dependencies>
 
 </project>

chat/core/src/main/java/com/tencent/supersonic/chat/application/ConfigServiceImpl.java

@@ -1,266 +0,0 @@
-package com.tencent.supersonic.chat.application;
-
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.component.SemanticLayer;
-import com.tencent.supersonic.chat.domain.pojo.config.*;
-import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
-import com.tencent.supersonic.common.pojo.SchemaItem;
-import com.tencent.supersonic.semantic.api.core.response.DimSchemaResp;
-import com.tencent.supersonic.semantic.api.core.response.DomainResp;
-import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
-import com.tencent.supersonic.semantic.api.core.response.MetricSchemaResp;
-import com.tencent.supersonic.chat.domain.repository.ChatConfigRepository;
-import com.tencent.supersonic.chat.domain.service.ConfigService;
-import com.tencent.supersonic.chat.domain.utils.ChatConfigUtils;
-import com.tencent.supersonic.common.util.json.JsonUtil;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-
-@Slf4j
-@Service
-public class ConfigServiceImpl implements ConfigService {
-
-    private final ChatConfigRepository chatConfigRepository;
-    private final ChatConfigUtils chatConfigUtils;
-    private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-
-
-    public ConfigServiceImpl(ChatConfigRepository chatConfigRepository,
-                             ChatConfigUtils chatConfigUtils) {
-        this.chatConfigRepository = chatConfigRepository;
-        this.chatConfigUtils = chatConfigUtils;
-    }
-
-    @Override
-    public Long addConfig(ChatConfigBaseReq configBaseCmd, User user) {
-        log.info("[create domain extend] object:{}", JsonUtil.toString(configBaseCmd, true));
-        duplicateCheck(configBaseCmd.getDomainId());
-        permissionCheckLogic(configBaseCmd.getDomainId(), user.getName());
-        ChatConfig chaConfig = chatConfigUtils.newChatConfig(configBaseCmd, user);
-        Long id = chatConfigRepository.createConfig(chaConfig);
-        return id;
-    }
-
-    private void duplicateCheck(Long domainId) {
-        ChatConfigFilter filter = new ChatConfigFilter();
-        filter.setDomainId(domainId);
-        List<ChatConfigResp> chaConfigDescList = chatConfigRepository.getChatConfig(filter);
-        if (!CollectionUtils.isEmpty(chaConfigDescList)) {
-            throw new RuntimeException("chat config existed, no need to add repeatedly");
-        }
-    }
-
-
-    @Override
-    public Long editConfig(ChatConfigEditReqReq configEditCmd, User user) {
-        log.info("[edit domain extend] object:{}", JsonUtil.toString(configEditCmd, true));
-        if (Objects.isNull(configEditCmd) || Objects.isNull(configEditCmd.getId()) && Objects.isNull(
-                configEditCmd.getDomainId())) {
-            throw new RuntimeException("editConfig, id and domainId are not allowed to be empty at the same time");
-        }
-        permissionCheckLogic(configEditCmd.getDomainId(), user.getName());
-        ChatConfig chaConfig = chatConfigUtils.editChatConfig(configEditCmd, user);
-        chatConfigRepository.updateConfig(chaConfig);
-        return configEditCmd.getId();
-    }
-
-
-    /**
-     * domain administrators have the right to modify related configuration information.
-     */
-    private Boolean permissionCheckLogic(Long domainId, String staffName) {
-        // todo
-        return true;
-    }
-
-    @Override
-    public List<ChatConfigResp> search(ChatConfigFilter filter, User user) {
-        log.info("[search domain extend] object:{}", JsonUtil.toString(filter, true));
-        List<ChatConfigResp> chaConfigDescList = chatConfigRepository.getChatConfig(filter);
-        return chaConfigDescList;
-    }
-
-
-    @Override
-    public ChatConfigResp fetchConfigByDomainId(Long domainId) {
-        return chatConfigRepository.getConfigByDomainId(domainId);
-    }
-
-
-    private ItemVisibilityInfo fetchVisibilityDescByConfig(ItemVisibility visibility,
-                                                           DomainSchemaResp domainSchemaDesc) {
-        ItemVisibilityInfo itemVisibilityDesc = new ItemVisibilityInfo();
-
-        List<Long> dimIdAllList = chatConfigUtils.generateAllDimIdList(domainSchemaDesc);
-        List<Long> metricIdAllList = chatConfigUtils.generateAllMetricIdList(domainSchemaDesc);
-
-        List<Long> blackDimIdList = new ArrayList<>();
-        List<Long> blackMetricIdList = new ArrayList<>();
-        if (Objects.nonNull(visibility)) {
-            if (!CollectionUtils.isEmpty(visibility.getBlackDimIdList())) {
-                blackDimIdList.addAll(visibility.getBlackDimIdList());
-            }
-            if (!CollectionUtils.isEmpty(visibility.getBlackMetricIdList())) {
-                blackMetricIdList.addAll(visibility.getBlackMetricIdList());
-            }
-        }
-        List<Long> whiteMetricIdList = metricIdAllList.stream().filter(id -> !blackMetricIdList.contains(id))
-                .collect(Collectors.toList());
-        List<Long> whiteDimIdList = dimIdAllList.stream().filter(id -> !blackDimIdList.contains(id))
-                .collect(Collectors.toList());
-
-        itemVisibilityDesc.setBlackDimIdList(blackDimIdList);
-        itemVisibilityDesc.setBlackMetricIdList(blackMetricIdList);
-        itemVisibilityDesc.setWhiteDimIdList(whiteDimIdList);
-        itemVisibilityDesc.setWhiteMetricIdList(whiteMetricIdList);
-
-        return itemVisibilityDesc;
-    }
-
-    @Override
-    public ChatConfigRichResp getConfigRichInfo(Long domainId) {
-        ChatConfigRichResp chatConfigRichResp = new ChatConfigRichResp();
-        ChatConfigResp chatConfigResp = chatConfigRepository.getConfigByDomainId(domainId);
-        if (Objects.isNull(chatConfigResp)) {
-            log.info("there is no chatConfigDesc for domainId:{}", domainId);
-            return chatConfigRichResp;
-        }
-        BeanUtils.copyProperties(chatConfigResp, chatConfigRichResp);
-
-        SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-        DomainSchemaResp domainSchemaInfo = semanticLayer.getDomainSchemaInfo(domainId, false);
-        chatConfigRichResp.setBizName(domainSchemaInfo.getBizName());
-        chatConfigRichResp.setDomainName(domainSchemaInfo.getName());
-
-        chatConfigRichResp.setChatAggRichConfig(fillChatAggRichConfig(domainSchemaInfo, chatConfigResp));
-        chatConfigRichResp.setChatDetailRichConfig(fillChatDetailRichConfig(domainSchemaInfo, chatConfigRichResp, chatConfigResp));
-
-        return chatConfigRichResp;
-    }
-
-    private ChatDetailRichConfig fillChatDetailRichConfig(DomainSchemaResp domainSchemaInfo, ChatConfigRichResp chatConfigRichResp, ChatConfigResp chatConfigResp) {
-        if (Objects.isNull(chatConfigResp) || Objects.isNull(chatConfigResp.getChatDetailConfig())) {
-            return null;
-        }
-        ChatDetailRichConfig detailRichConfig = new ChatDetailRichConfig();
-        ChatDetailConfig chatDetailConfig = chatConfigResp.getChatDetailConfig();
-
-        detailRichConfig.setVisibility(fetchVisibilityDescByConfig(chatDetailConfig.getVisibility(), domainSchemaInfo));
-        detailRichConfig.setKnowledgeInfos(fillKnowledgeBizName(chatDetailConfig.getKnowledgeInfos(), domainSchemaInfo));
-        detailRichConfig.setGlobalKnowledgeConfig(chatDetailConfig.getGlobalKnowledgeConfig());
-        detailRichConfig.setChatDefaultConfig(fetchDefaultConfig(chatDetailConfig.getChatDefaultConfig(), domainSchemaInfo));
-
-        detailRichConfig.setEntity(generateRichEntity(chatDetailConfig.getEntity(), domainSchemaInfo));
-        return detailRichConfig;
-    }
-
-    private EntityRichInfo generateRichEntity(Entity entity, DomainSchemaResp domainSchemaInfo) {
-        EntityRichInfo entityRichInfo = new EntityRichInfo();
-        if (Objects.isNull(entity) || Objects.isNull(entity.getEntityId())) {
-            return entityRichInfo;
-        }
-        BeanUtils.copyProperties(entity, entityRichInfo);
-        Map<Long, DimSchemaResp> dimIdAndRespPair = domainSchemaInfo.getDimensions().stream()
-                .collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
-
-        entityRichInfo.setDimItem(dimIdAndRespPair.get(entity.getEntityId()));
-        return entityRichInfo;
-    }
-
-    private ChatAggRichConfig fillChatAggRichConfig(DomainSchemaResp domainSchemaInfo, ChatConfigResp chatConfigResp) {
-        if (Objects.isNull(chatConfigResp) || Objects.isNull(chatConfigResp.getChatAggConfig())) {
-            return null;
-        }
-        ChatAggConfig chatAggConfig = chatConfigResp.getChatAggConfig();
-        ChatAggRichConfig chatAggRichConfig = new ChatAggRichConfig();
-
-        chatAggRichConfig.setVisibility(fetchVisibilityDescByConfig(chatAggConfig.getVisibility(), domainSchemaInfo));
-        chatAggRichConfig.setKnowledgeInfos(fillKnowledgeBizName(chatAggConfig.getKnowledgeInfos(), domainSchemaInfo));
-        chatAggRichConfig.setGlobalKnowledgeConfig(chatAggConfig.getGlobalKnowledgeConfig());
-        chatAggRichConfig.setChatDefaultConfig(fetchDefaultConfig(chatAggConfig.getChatDefaultConfig(), domainSchemaInfo));
-
-        return chatAggRichConfig;
-    }
-
-    private ChatDefaultRichConfig fetchDefaultConfig(ChatDefaultConfig chatDefaultConfig, DomainSchemaResp domainSchemaInfo) {
-        ChatDefaultRichConfig defaultRichConfig = new ChatDefaultRichConfig();
-        if (Objects.isNull(chatDefaultConfig)) {
-            return defaultRichConfig;
-        }
-        BeanUtils.copyProperties(chatDefaultConfig, defaultRichConfig);
-        Map<Long, DimSchemaResp> dimIdAndRespPair = domainSchemaInfo.getDimensions().stream()
-                .collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
-
-        Map<Long, MetricSchemaResp> metricIdAndRespPair = domainSchemaInfo.getMetrics().stream()
-                .collect(Collectors.toMap(MetricSchemaResp::getId, Function.identity()));
-
-        List<SchemaItem> dimensions = new ArrayList<>();
-        List<SchemaItem> metrics = new ArrayList<>();
-        if (!CollectionUtils.isEmpty(chatDefaultConfig.getDimensionIds())) {
-            chatDefaultConfig.getDimensionIds().stream().forEach(dimId -> {
-                DimSchemaResp dimSchemaResp = dimIdAndRespPair.get(dimId);
-                SchemaItem dimSchema = new SchemaItem();
-                BeanUtils.copyProperties(dimSchemaResp, dimSchema);
-                dimensions.add(dimSchema);
-            });
-        }
-
-        if (!CollectionUtils.isEmpty(chatDefaultConfig.getMetricIds())) {
-            chatDefaultConfig.getMetricIds().stream().forEach(metricId -> {
-                MetricSchemaResp metricSchemaResp = metricIdAndRespPair.get(metricId);
-                SchemaItem metricSchema = new SchemaItem();
-                BeanUtils.copyProperties(metricSchemaResp, metricSchema);
-                metrics.add(metricSchema);
-            });
-        }
-
-        defaultRichConfig.setDimensions(dimensions);
-        defaultRichConfig.setMetrics(metrics);
-        return defaultRichConfig;
-    }
-
-
-    private List<KnowledgeInfo> fillKnowledgeBizName(List<KnowledgeInfo> knowledgeInfos,
-                                                     DomainSchemaResp domainSchemaInfo) {
-        if (CollectionUtils.isEmpty(knowledgeInfos)) {
-            return new ArrayList<>();
-        }
-        Map<Long, DimSchemaResp> dimIdAndRespPair = domainSchemaInfo.getDimensions().stream()
-                .collect(Collectors.toMap(DimSchemaResp::getId, Function.identity()));
-        knowledgeInfos.stream().forEach(knowledgeInfo -> {
-            if (Objects.nonNull(knowledgeInfo)) {
-                DimSchemaResp dimSchemaResp = dimIdAndRespPair.get(knowledgeInfo.getItemId());
-                if (Objects.nonNull(dimSchemaResp)) {
-                    knowledgeInfo.setBizName(dimSchemaResp.getBizName());
-                }
-            }
-        });
-        return knowledgeInfos;
-    }
-
-    @Override
-    public List<ChatConfigRichResp> getAllChatRichConfig() {
-        List<ChatConfigRichResp> chatConfigRichInfoList = new ArrayList<>();
-        List<DomainResp> domainRespList = semanticLayer.getDomainListForAdmin();
-        domainRespList.stream().forEach(domainResp -> {
-            ChatConfigRichResp chatConfigRichInfo = getConfigRichInfo(domainResp.getId());
-            if (Objects.nonNull(chatConfigRichInfo)) {
-                chatConfigRichInfoList.add(chatConfigRichInfo);
-            }
-        });
-        return chatConfigRichInfoList;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/DomainEntityService.java

@@ -1,213 +0,0 @@
-package com.tencent.supersonic.chat.application;
-
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.component.SemanticLayer;
-import com.tencent.supersonic.chat.api.pojo.DataInfo;
-import com.tencent.supersonic.chat.api.pojo.DomainInfo;
-import com.tencent.supersonic.chat.api.pojo.EntityInfo;
-import com.tencent.supersonic.chat.api.pojo.Filter;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.component.SemanticLayer;
-import com.tencent.supersonic.chat.domain.pojo.config.ChatConfigRichResp;
-import com.tencent.supersonic.chat.domain.pojo.config.ChatDefaultRichConfig;
-import com.tencent.supersonic.chat.domain.pojo.config.EntityRichInfo;
-import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
-import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
-import com.tencent.supersonic.common.pojo.DateConf;
-import com.tencent.supersonic.common.pojo.SchemaItem;
-import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
-import com.tencent.supersonic.semantic.api.query.enums.FilterOperatorEnum;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-
-@Service
-@Slf4j
-public class DomainEntityService {
-
-    private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-
-    @Autowired
-    private ConfigServiceImpl configService;
-
-    public EntityInfo getEntityInfo(SemanticParseInfo parseInfo, User user) {
-        if (parseInfo != null && parseInfo.getDomainId() > 0) {
-            EntityInfo entityInfo = getEntityInfo(parseInfo.getDomainId());
-            if (parseInfo.getDimensionFilters().size() <= 0) {
-                entityInfo.setMetrics(null);
-                entityInfo.setDimensions(null);
-                return entityInfo;
-            }
-            if (entityInfo.getDomainInfo() != null && entityInfo.getDomainInfo().getPrimaryEntityBizName() != null) {
-                String domainInfoPrimaryName = entityInfo.getDomainInfo().getPrimaryEntityBizName();
-                String domainInfoId = "";
-                for (Filter chatFilter : parseInfo.getDimensionFilters()) {
-                    if (chatFilter != null && chatFilter.getBizName() != null && chatFilter.getBizName()
-                            .equals(domainInfoPrimaryName)) {
-                        if (chatFilter.getOperator().equals(FilterOperatorEnum.EQUALS)) {
-                            domainInfoId = chatFilter.getValue().toString();
-                        }
-                        if (chatFilter.getOperator().equals(FilterOperatorEnum.IN)) {
-                            domainInfoId = ((List<String>) chatFilter.getValue()).get(0);
-                        }
-                    }
-                }
-                if (!"".equals(domainInfoId)) {
-                    try {
-                        setMainDomain(entityInfo, parseInfo.getDomainId(),
-                                domainInfoId, user);
-
-                        return entityInfo;
-                    } catch (Exception e) {
-                        log.error("setMaintDomain error {}", e);
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    public EntityInfo getEntityInfo(Long domain) {
-        ChatConfigRichResp chaConfigRichDesc = configService.getConfigRichInfo(domain);
-        if (Objects.isNull(chaConfigRichDesc) || Objects.isNull(chaConfigRichDesc.getChatDetailRichConfig())) {
-            return new EntityInfo();
-        }
-        return getEntityInfo(chaConfigRichDesc);
-    }
-
-    private EntityInfo getEntityInfo(ChatConfigRichResp chaConfigRichDesc) {
-
-        EntityInfo entityInfo = new EntityInfo();
-        EntityRichInfo entityDesc = chaConfigRichDesc.getChatDetailRichConfig().getEntity();
-        if (entityDesc != null && Objects.nonNull(chaConfigRichDesc.getDomainId())) {
-            DomainInfo domainInfo = new DomainInfo();
-            domainInfo.setItemId(Integer.valueOf(chaConfigRichDesc.getDomainId().intValue()));
-            domainInfo.setName(chaConfigRichDesc.getDomainName());
-            domainInfo.setWords(entityDesc.getNames());
-            domainInfo.setBizName(chaConfigRichDesc.getBizName());
-            if (Objects.nonNull(entityDesc.getDimItem())) {
-                domainInfo.setPrimaryEntityBizName(entityDesc.getDimItem().getBizName());
-            }
-
-            entityInfo.setDomainInfo(domainInfo);
-            List<DataInfo> dimensions = new ArrayList<>();
-            List<DataInfo> metrics = new ArrayList<>();
-
-            if (Objects.nonNull(chaConfigRichDesc) && Objects.nonNull(chaConfigRichDesc.getChatDetailRichConfig())
-                    && Objects.nonNull(chaConfigRichDesc.getChatDetailRichConfig().getChatDefaultConfig())) {
-                ChatDefaultRichConfig chatDefaultConfig = chaConfigRichDesc.getChatDetailRichConfig().getChatDefaultConfig();
-                if(!CollectionUtils.isEmpty(chatDefaultConfig.getDimensions())){
-                    for (SchemaItem dimensionDesc : chatDefaultConfig.getDimensions()) {
-                        DataInfo mainEntityDimension = new DataInfo();
-                        mainEntityDimension.setItemId(dimensionDesc.getId().intValue());
-                        mainEntityDimension.setName(dimensionDesc.getName());
-                        mainEntityDimension.setBizName(dimensionDesc.getBizName());
-                        dimensions.add(mainEntityDimension);
-                    }
-                    entityInfo.setDimensions(dimensions);
-                }
-
-                if(!CollectionUtils.isEmpty(chatDefaultConfig.getMetrics())){
-                    for (SchemaItem metricDesc : chatDefaultConfig.getMetrics()) {
-                        DataInfo dataInfo = new DataInfo();
-                        dataInfo.setName(metricDesc.getName());
-                        dataInfo.setBizName(metricDesc.getBizName());
-                        dataInfo.setItemId(metricDesc.getId().intValue());
-                        metrics.add(dataInfo);
-                    }
-                    entityInfo.setMetrics(metrics);
-                }
-            }
-        }
-        return entityInfo;
-    }
-
-    public void setMainDomain(EntityInfo domainInfo, Long domain, String entity, User user) {
-        domainInfo.setEntityId(entity);
-        SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
-        semanticParseInfo.setDomainId(Long.valueOf(domain));
-        semanticParseInfo.setNativeQuery(true);
-        semanticParseInfo.setMetrics(getMetrics(domainInfo));
-        semanticParseInfo.setDimensions(getDimensions(domainInfo));
-        DateConf dateInfo = new DateConf();
-        dateInfo.setUnit(1);
-        dateInfo.setDateMode(DateConf.DateMode.RECENT_UNITS);
-        semanticParseInfo.setDateInfo(dateInfo);
-
-        // add filter
-        Filter chatFilter = new Filter();
-        chatFilter.setValue(String.valueOf(entity));
-        chatFilter.setOperator(FilterOperatorEnum.EQUALS);
-        chatFilter.setBizName(getEntityPrimaryName(domainInfo));
-        Set<Filter> chatFilters = new LinkedHashSet();
-        chatFilters.add(chatFilter);
-        semanticParseInfo.setDimensionFilters(chatFilters);
-
-        QueryResultWithSchemaResp queryResultWithColumns = null;
-        try {
-            queryResultWithColumns = semanticLayer.queryByStruct(SchemaInfoConverter.convertTo(semanticParseInfo),
-                    user);
-        } catch (Exception e) {
-            log.warn("setMainDomain queryByStruct error, e:", e);
-        }
-
-        if (queryResultWithColumns != null) {
-            if (!CollectionUtils.isEmpty(queryResultWithColumns.getResultList())
-                    && queryResultWithColumns.getResultList().size() > 0) {
-                Map<String, Object> result = queryResultWithColumns.getResultList().get(0);
-                for (Map.Entry<String, Object> entry : result.entrySet()) {
-                    String entryKey = getEntryKey(entry);
-                    if (entry.getValue() == null || entryKey == null) {
-                        continue;
-                    }
-                    domainInfo.getDimensions().stream().filter(i -> entryKey.equals(i.getBizName()))
-                            .forEach(i -> i.setValue(entry.getValue().toString()));
-                    domainInfo.getMetrics().stream().filter(i -> entryKey.equals(i.getBizName()))
-                            .forEach(i -> i.setValue(entry.getValue().toString()));
-                }
-            }
-        }
-    }
-
-    private Set<SchemaItem> getDimensions(EntityInfo domainInfo) {
-        Set<SchemaItem> dimensions = new LinkedHashSet();
-        for (DataInfo mainEntityDimension : domainInfo.getDimensions()) {
-            SchemaItem dimension = new SchemaItem();
-            dimension.setBizName(mainEntityDimension.getBizName());
-            dimensions.add(dimension);
-        }
-        return dimensions;
-    }
-
-    private String getEntryKey(Map.Entry<String, Object> entry) {
-        // metric parser special handle, TODO delete
-        String entryKey = entry.getKey();
-        if (entryKey.contains("__")) {
-            entryKey = entryKey.split("__")[1];
-        }
-        return entryKey;
-    }
-
-    private Set<SchemaItem> getMetrics(EntityInfo domainInfo) {
-        Set<SchemaItem> metrics = new LinkedHashSet();
-        for (DataInfo metricValue : domainInfo.getMetrics()) {
-            SchemaItem metric = new SchemaItem();
-            metric.setBizName(metricValue.getBizName());
-            metrics.add(metric);
-        }
-        return metrics;
-    }
-
-    private String getEntityPrimaryName(EntityInfo domainInfo) {
-        return domainInfo.getDomainInfo().getPrimaryEntityBizName();
-    }
-
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/QueryServiceImpl.java

@@ -1,93 +0,0 @@
-package com.tencent.supersonic.chat.application;
-
-
-import com.tencent.supersonic.auth.api.authentication.pojo.User;
-import com.tencent.supersonic.chat.api.component.*;
-import com.tencent.supersonic.chat.api.pojo.ChatContext;
-import com.tencent.supersonic.chat.api.pojo.SemanticParseInfo;
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
-import com.tencent.supersonic.chat.api.response.QueryResultResp;
-import com.tencent.supersonic.chat.application.query.QuerySelector;
-import com.tencent.supersonic.chat.domain.pojo.chat.QueryData;
-import com.tencent.supersonic.chat.domain.pojo.search.QueryState;
-import com.tencent.supersonic.chat.domain.service.QueryService;
-import com.tencent.supersonic.chat.domain.service.ChatService;
-import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
-import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
-import com.tencent.supersonic.common.util.json.JsonUtil;
-import com.tencent.supersonic.semantic.api.core.response.QueryResultWithSchemaResp;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Primary;
-import org.springframework.stereotype.Component;
-import org.springframework.stereotype.Service;
-
-@Service
-@Component("chatQueryService")
-@Primary
-@Slf4j
-public class QueryServiceImpl implements QueryService {
-
-    @Autowired
-    private ChatService chatService;
-
-    private List<SchemaMapper> schemaMappers = ComponentFactory.getSchemaMappers();
-    private List<SemanticParser> semanticParsers = ComponentFactory.getSemanticParsers();
-    private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-    private QuerySelector querySelector = ComponentFactory.getQuerySelector();
-
-    @Override
-    public QueryResultResp executeQuery(QueryContextReq queryCtx) throws Exception {
-        schemaMappers.stream().forEach(s -> s.map(queryCtx));
-
-        // in order to support multi-turn conversation, we need to consider chat context
-        ChatContext chatCtx = chatService.getOrCreateContext(queryCtx.getChatId());
-
-        for (SemanticParser semanticParser : semanticParsers) {
-            log.info("semanticParser processing:[{}]", semanticParser.getClass().getName());
-            semanticParser.parse(queryCtx, chatCtx);
-        }
-        if (queryCtx.getCandidateQueries().size() > 0) {
-            log.info("pick before [{}]", queryCtx.getCandidateQueries().stream().collect(
-                    Collectors.toList()));
-            SemanticQuery semanticQuery = querySelector.select(queryCtx.getCandidateQueries());
-            log.info("pick after [{}]", semanticQuery);
-
-            QueryResultResp queryResponse = semanticQuery.execute(queryCtx.getUser());
-            if (queryResponse != null) {
-                // update chat context after a successful semantic query
-                if (queryCtx.isSaveAnswer() && queryResponse.getQueryState() == QueryState.NORMAL.getState()) {
-                    chatService.updateContext(chatCtx, queryCtx, semanticQuery.getParseInfo());
-                }
-                queryResponse.setChatContext(chatCtx.getParseInfo());
-                chatService.addQuery(queryResponse, queryCtx, chatCtx);
-                return queryResponse;
-            }
-        }
-
-        return null;
-    }
-
-    @Override
-    public SemanticParseInfo queryContext(QueryContextReq queryCtx) {
-        ChatContext context = chatService.getOrCreateContext(queryCtx.getChatId());
-        return context.getParseInfo();
-    }
-
-    @Override
-    public QueryResultResp executeDirectQuery(QueryData queryData, User user) throws Exception {
-        SemanticParseInfo semanticParseInfo = new SemanticParseInfo();
-        QueryResultResp queryResponse = new QueryResultResp();
-        BeanUtils.copyProperties(queryData, semanticParseInfo);
-        QueryResultWithSchemaResp resultWithColumns = semanticLayer.queryByStruct(
-                SchemaInfoConverter.convertTo(semanticParseInfo), user);
-        queryResponse.setQueryColumns(resultWithColumns.getColumns());
-        queryResponse.setQueryResults(resultWithColumns.getResultList());
-        return queryResponse;
-    }
-}
-

chat/core/src/main/java/com/tencent/supersonic/chat/application/RecommendServiceImpl.java

@@ -1,55 +0,0 @@
-package com.tencent.supersonic.chat.application;
-
-
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
-import com.tencent.supersonic.chat.api.component.SemanticLayer;
-import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
-import com.tencent.supersonic.semantic.api.core.response.DomainSchemaResp;
-import com.tencent.supersonic.chat.domain.pojo.chat.RecommendResponse;
-import com.tencent.supersonic.chat.domain.service.RecommendService;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
-import org.springframework.stereotype.Service;
-
-/***
- * Recommend Service impl
- */
-@Service
-public class RecommendServiceImpl implements RecommendService {
-
-    private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-
-    @Override
-    public RecommendResponse recommend(QueryContextReq queryCtx) {
-        Integer domainId = queryCtx.getDomainId();
-        if (Objects.isNull(domainId)) {
-            return new RecommendResponse();
-        }
-
-        DomainSchemaResp domainSchemaDesc = semanticLayer.getDomainSchemaInfo(
-                Long.valueOf(domainId), true);
-
-        List<RecommendResponse.Item> dimensions = domainSchemaDesc.getDimensions().stream().map(dimSchemaDesc -> {
-            RecommendResponse.Item item = new RecommendResponse.Item();
-            item.setDomain(domainId);
-            item.setName(dimSchemaDesc.getName());
-            item.setBizName(dimSchemaDesc.getBizName());
-            return item;
-        }).collect(Collectors.toList());
-
-        List<RecommendResponse.Item> metrics = domainSchemaDesc.getMetrics().stream().map(metricSchemaDesc -> {
-            RecommendResponse.Item item = new RecommendResponse.Item();
-            item.setDomain(domainId);
-            item.setName(metricSchemaDesc.getName());
-            item.setBizName(metricSchemaDesc.getBizName());
-            return item;
-        }).collect(Collectors.toList());
-
-        RecommendResponse response = new RecommendResponse();
-        response.setDimensions(dimensions);
-        response.setMetrics(metrics);
-        return response;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/SearchServiceImpl.java

@@ -1,285 +0,0 @@
-package com.tencent.supersonic.chat.application;
-
-import com.google.common.collect.Lists;
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.pojo.Filter;
-import com.tencent.supersonic.chat.api.pojo.QueryFilter;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
-import com.tencent.supersonic.chat.application.knowledge.NatureHelper;
-import com.tencent.supersonic.chat.application.knowledge.WordNatureService;
-import com.tencent.supersonic.chat.application.mapper.SearchMatchStrategy;
-import com.tencent.supersonic.chat.domain.pojo.search.DomainInfoStat;
-import com.tencent.supersonic.chat.domain.pojo.search.DomainWithSemanticType;
-import com.tencent.supersonic.chat.domain.pojo.search.MatchText;
-import com.tencent.supersonic.chat.domain.pojo.search.SearchResult;
-import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
-import com.tencent.supersonic.chat.domain.service.ChatService;
-import com.tencent.supersonic.chat.domain.service.SearchService;
-import com.tencent.supersonic.chat.domain.utils.NatureConverter;
-import com.tencent.supersonic.common.nlp.ItemDO;
-import com.tencent.supersonic.common.nlp.MapResult;
-import com.tencent.supersonic.common.nlp.NatureType;
-import com.tencent.supersonic.common.nlp.WordNature;
-import com.tencent.supersonic.knowledge.infrastructure.nlp.HanlpHelper;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-
-/**
- * search service impl
- */
-@Service
-@Slf4j
-public class SearchServiceImpl implements SearchService {
-
-    private static final int RESULT_SIZE = 10;
-
-    @Autowired
-    private WordNatureService wordNatureService;
-    @Autowired
-    private ChatService chatService;
-    @Autowired
-    private SearchMatchStrategy searchMatchStrategy;
-
-    @Override
-    public List<SearchResult> search(QueryContextReq queryCtx) {
-        String queryText = queryCtx.getQueryText();
-        // 1.get meta info
-        DomainInfos domainInfosDb = wordNatureService.getCache().getUnchecked("");
-
-        List<ItemDO> metricsDb = domainInfosDb.getMetrics();
-        final Map<Integer, String> domainToName = domainInfosDb.getDomainToName();
-        // 2.detect by segment
-        List<Term> originals = HanlpHelper.getTerms(queryText);
-        Map<MatchText, List<MapResult>> regTextMap = searchMatchStrategy.match(queryText, originals,
-                queryCtx.getDomainId());
-        regTextMap.entrySet().stream().forEach(m -> HanlpHelper.transLetterOriginal(m.getValue()));
-        // 3.get the most matching data
-        Optional<Entry<MatchText, List<MapResult>>> mostSimilarSearchResult = regTextMap.entrySet()
-                .stream()
-                .filter(entry -> CollectionUtils.isNotEmpty(entry.getValue()))
-                .reduce((entry1, entry2) ->
-                        entry1.getKey().getDetectSegment().length() >= entry2.getKey().getDetectSegment().length()
-                                ? entry1 : entry2);
-        log.debug("mostSimilarSearchResult:{}", mostSimilarSearchResult);
-        // 4.optimize the results after the query
-        if (!mostSimilarSearchResult.isPresent()) {
-            log.info("unable to find any information through search , queryCtx:{}", queryCtx);
-            return Lists.newArrayList();
-        }
-        Map.Entry<MatchText, List<MapResult>> searchTextEntry = mostSimilarSearchResult.get();
-        log.info("searchTextEntry:{},queryCtx:{}", searchTextEntry, queryCtx);
-
-        Set<SearchResult> searchResults = new LinkedHashSet();
-        DomainInfoStat domainStat = NatureHelper.getDomainStat(originals);
-
-        List<Integer> possibleDomains = getPossibleDomains(queryCtx, originals, domainStat, queryCtx.getDomainId());
-
-        // 4.1 priority dimension metric
-        boolean existMetricAndDimension = searchMetricAndDimension(new HashSet<>(possibleDomains), domainToName,
-                searchTextEntry, searchResults);
-
-        // 4.2 process based on dimension values
-        MatchText matchText = searchTextEntry.getKey();
-        Map<String, String> natureToNameMap = getNatureToNameMap(searchTextEntry, new HashSet<>(possibleDomains));
-        log.debug("possibleDomains:{},natureToNameMap:{}", possibleDomains, natureToNameMap);
-
-        for (Map.Entry<String, String> natureToNameEntry : natureToNameMap.entrySet()) {
-            searchDimensionValue(metricsDb, domainToName, domainStat.getMetricDomainCount(), searchResults,
-                    existMetricAndDimension, matchText, natureToNameMap, natureToNameEntry, queryCtx.getQueryFilter());
-        }
-        return searchResults.stream().limit(RESULT_SIZE).collect(Collectors.toList());
-    }
-
-    private List<Integer> getPossibleDomains(QueryContextReq queryCtx, List<Term> originals,
-            DomainInfoStat domainStat, Integer webDomainId) {
-
-        if (Objects.nonNull(webDomainId) && webDomainId > 0) {
-            List<Integer> result = new ArrayList<>();
-            result.add(webDomainId);
-            return result;
-        }
-
-        List<Integer> possibleDomains = NatureHelper.selectPossibleDomains(originals);
-
-        Long contextDomain = chatService.getContextDomain(queryCtx.getChatId());
-
-        log.debug("possibleDomains:{},domainStat:{},contextDomain:{}", possibleDomains, domainStat, contextDomain);
-
-        // If nothing is recognized or only metric are present, then add the contextDomain.
-        if (nothingOrOnlyMetric(domainStat) && effectiveDomain(contextDomain)) {
-            List<Integer> result = new ArrayList<>();
-            result.add(Math.toIntExact(contextDomain));
-            return result;
-        }
-        return possibleDomains;
-    }
-
-    private boolean nothingOrOnlyMetric(DomainInfoStat domainStat) {
-        return domainStat.getMetricDomainCount() >= 0 && domainStat.getDimensionDomainCount() <= 0
-                && domainStat.getDimensionValueDomainCount() <= 0 && domainStat.getDomainCount() <= 0;
-    }
-
-    private boolean effectiveDomain(Long contextDomain) {
-        return Objects.nonNull(contextDomain) && contextDomain > 0;
-    }
-
-    private void searchDimensionValue(List<ItemDO> metricsDb,
-                                      Map<Integer, String> domainToName,
-                                      long metricDomainCount,
-                                      Set<SearchResult> searchResults,
-                                      boolean existMetricAndDimension,
-                                      MatchText matchText,
-                                      Map<String, String> natureToNameMap,
-                                      Map.Entry<String, String> natureToNameEntry,
-                                      QueryFilter queryFilter) {
-        String nature = natureToNameEntry.getKey();
-        String wordName = natureToNameEntry.getValue();
-
-        Integer domain = NatureHelper.getDomain(nature);
-        SchemaElementType schemaElementType = NatureConverter.convertTo(nature);
-
-        if (SchemaElementType.ENTITY.equals(schemaElementType)) {
-            return;
-        }
-        // If there are no metric/dimension, complete the  metric information
-        if (metricDomainCount <= 0 && !existMetricAndDimension) {
-            if (filterByQueryFilter(matchText.getRegText(), queryFilter)) {
-                return;
-            }
-            searchResults.add(
-                    new SearchResult(matchText.getRegText() + wordName, wordName, domainToName.get(domain), domain,
-                            schemaElementType));
-            int metricSize = RESULT_SIZE / (natureToNameMap.entrySet().size());
-            if (metricSize <= 1) {
-                metricSize = 1;
-            }
-            List<String> metrics = filerMetricsByDomain(metricsDb, domain).stream().limit(metricSize).collect(
-                    Collectors.toList());
-            for (String metric : metrics) {
-                String subRecommend = matchText.getRegText() + wordName + NatureType.SPACE + metric;
-                searchResults.add(
-                        new SearchResult(subRecommend, wordName + NatureType.SPACE + metric, domainToName.get(domain),
-                                domain, false));
-            }
-        } else {
-            searchResults.add(
-                    new SearchResult(matchText.getRegText() + wordName, wordName, domainToName.get(domain), domain,
-                            schemaElementType));
-        }
-    }
-
-    private boolean filterByQueryFilter(String regText, QueryFilter queryFilter) {
-        if (queryFilter == null || CollectionUtils.isEmpty(queryFilter.getFilters())) {
-            return false;
-        }
-        List<Filter> filters = queryFilter.getFilters();
-        for (Filter filter : filters) {
-            if (regText.equalsIgnoreCase(String.valueOf(filter.getValue()))) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    protected List<String> filerMetricsByDomain(List<ItemDO> metricsDb, Integer domain) {
-        if (CollectionUtils.isEmpty(metricsDb)) {
-            return Lists.newArrayList();
-        }
-        return metricsDb.stream()
-                .filter(mapDO -> Objects.nonNull(mapDO) && domain.equals(mapDO.getDomain()))
-                .sorted(Comparator.comparing(ItemDO::getUseCnt).reversed())
-                .flatMap(entry -> {
-                    List<String> result = new ArrayList<>();
-                    result.add(entry.getName());
-                    return result.stream();
-                })
-                .collect(Collectors.toList());
-    }
-
-    /***
-     * convert nature to name
-     * @param recommendTextListEntry
-     * @return
-     */
-    private Map<String, String> getNatureToNameMap(Map.Entry<MatchText, List<MapResult>> recommendTextListEntry,
-            Set<Integer> possibleDomains) {
-        List<MapResult> recommendValues = recommendTextListEntry.getValue();
-        return recommendValues.stream()
-                .flatMap(entry -> entry.getNatures().stream()
-                        .filter(nature -> {
-                            if (CollectionUtils.isEmpty(possibleDomains)) {
-                                return true;
-                            }
-                            Integer domain = NatureHelper.getDomain(nature);
-                            return possibleDomains.contains(domain);
-                        })
-                        .map(nature -> {
-                                    WordNature posDO = new WordNature();
-                                    posDO.setWord(entry.getName());
-                                    posDO.setNature(nature);
-                                    return posDO;
-                                }
-                        )).sorted(Comparator.comparingInt(a -> a.getWord().length()))
-                .collect(Collectors.toMap(WordNature::getNature, WordNature::getWord, (value1, value2) -> value1,
-                        LinkedHashMap::new));
-    }
-
-    private boolean searchMetricAndDimension(Set<Integer> possibleDomains, Map<Integer, String> domainToName,
-            Map.Entry<MatchText, List<MapResult>> searchTextEntry, Set<SearchResult> searchResults) {
-        boolean existMetric = false;
-
-        MatchText matchText = searchTextEntry.getKey();
-        List<MapResult> mapResults = searchTextEntry.getValue();
-
-        for (MapResult mapResult : mapResults) {
-
-            List<DomainWithSemanticType> dimensionMetricClassIds = mapResult.getNatures().stream()
-                    .map(nature -> new DomainWithSemanticType(NatureHelper.getDomain(nature),
-                            NatureConverter.convertTo(nature)))
-                    .filter(entry -> matchCondition(entry, possibleDomains)).collect(Collectors.toList());
-
-            if (CollectionUtils.isNotEmpty(dimensionMetricClassIds)) {
-                for (DomainWithSemanticType domainWithSemanticType : dimensionMetricClassIds) {
-                    existMetric = true;
-                    Integer domain = domainWithSemanticType.getDomain();
-                    SchemaElementType semanticType = domainWithSemanticType.getSemanticType();
-                    searchResults.add(
-                            new SearchResult(matchText.getRegText() + mapResult.getName(), mapResult.getName(),
-                                    domainToName.get(domain), domain, semanticType));
-                }
-            }
-            log.info("parseResult:{},dimensionMetricClassIds:{},possibleDomains:{}", mapResult,
-                    dimensionMetricClassIds, possibleDomains);
-        }
-        return existMetric;
-    }
-
-    private boolean matchCondition(DomainWithSemanticType entry, Set<Integer> possibleDomains) {
-        if (!(SchemaElementType.METRIC.equals(entry.getSemanticType()) || SchemaElementType.DIMENSION.equals(
-                entry.getSemanticType()))) {
-            return false;
-        }
-
-        if (CollectionUtils.isEmpty(possibleDomains)) {
-            return true;
-        }
-        return possibleDomains.contains(entry.getDomain());
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/ApplicationStartedInit.java

@@ -1,69 +0,0 @@
-package com.tencent.supersonic.chat.application.knowledge;
-
-import com.tencent.supersonic.common.nlp.WordNature;
-import com.tencent.supersonic.knowledge.domain.service.OnlineKnowledgeService;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.context.event.ApplicationStartedEvent;
-import org.springframework.context.ApplicationListener;
-import org.springframework.scheduling.annotation.Scheduled;
-import org.springframework.stereotype.Component;
-
-import java.util.List;
-
-@Slf4j
-@Component
-public class ApplicationStartedInit implements ApplicationListener<ApplicationStartedEvent> {
-
-    @Autowired
-    private OnlineKnowledgeService onlineKnowledgeService;
-
-    @Autowired
-    private WordNatureService wordNatureService;
-
-
-    @Override
-    public void onApplicationEvent(ApplicationStartedEvent event) {
-        try {
-            log.info("ApplicationStartedInit start");
-
-            List<WordNature> wordNatures = wordNatureService.getAllWordNature();
-
-            wordNatureService.setPreWordNatures(wordNatures);
-
-            onlineKnowledgeService.reloadAllData(wordNatures);
-
-            log.info("ApplicationStartedInit end");
-        } catch (Exception e) {
-            log.error("ApplicationStartedInit error", e);
-        }
-    }
-
-    /***
-     * reload knowledge task
-     */
-    @Scheduled(cron = "${reload.knowledge.corn:0 0/1 * * * ?}")
-    public void reloadKnowledge() {
-        log.info("reloadKnowledge start");
-
-        try {
-            List<WordNature> wordNatures = wordNatureService.getAllWordNature();
-            List<WordNature> preWordNatures = wordNatureService.getPreWordNatures();
-
-            if (CollectionUtils.isEqualCollection(wordNatures, preWordNatures)) {
-                log.debug("wordNatures is not change, reloadKnowledge end");
-                return;
-            }
-            log.info("wordNatures is change");
-            wordNatureService.setPreWordNatures(wordNatures);
-            onlineKnowledgeService.updateOnlineKnowledge(wordNatureService.getAllWordNature());
-            wordNatureService.getCache().refresh("");
-
-        } catch (Exception e) {
-            log.error("reloadKnowledge error", e);
-        }
-
-        log.info("reloadKnowledge end");
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/NatureHelper.java

@@ -1,144 +0,0 @@
-package com.tencent.supersonic.chat.application.knowledge;
-
-import com.hankcs.hanlp.corpus.tag.Nature;
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.application.mapper.HanlpSchemaMapper;
-import com.tencent.supersonic.chat.domain.pojo.search.DomainInfoStat;
-import com.tencent.supersonic.common.nlp.NatureType;
-import com.tencent.supersonic.knowledge.application.online.BaseWordNature;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * nature parse helper
- */
-@Slf4j
-public class NatureHelper {
-
-    private static boolean isDomainOrEntity(Term term, Integer domain) {
-        return (NatureType.NATURE_SPILT + domain).equals(term.nature.toString()) || term.nature.toString()
-                .endsWith(NatureType.ENTITY.getType());
-    }
-
-    public static Integer getDomainByNature(Nature nature) {
-        if (nature.startsWith(NatureType.NATURE_SPILT)) {
-            String[] dimensionValues = nature.toString().split(NatureType.NATURE_SPILT);
-            if (StringUtils.isNumeric(dimensionValues[1])) {
-                return Integer.valueOf(dimensionValues[1]);
-            }
-        }
-        return 0;
-    }
-
-    public static Integer getDomain(String nature) {
-        try {
-            String[] split = nature.split(NatureType.NATURE_SPILT);
-            if (split.length <= 1) {
-                return null;
-            }
-            return Integer.valueOf(split[1]);
-        } catch (NumberFormatException e) {
-            log.error("", e);
-        }
-        return null;
-    }
-
-    public static boolean isDimensionValueClassId(String nature) {
-        if (StringUtils.isEmpty(nature)) {
-            return false;
-        }
-        if (!nature.startsWith(NatureType.NATURE_SPILT)) {
-            return false;
-        }
-        String[] split = nature.split(NatureType.NATURE_SPILT);
-        if (split.length <= 1) {
-            return false;
-        }
-        return !nature.endsWith(NatureType.METRIC.getType()) && !nature.endsWith(NatureType.DIMENSION.getType())
-                && StringUtils.isNumeric(split[1]);
-    }
-
-    public static DomainInfoStat getDomainStat(List<Term> terms) {
-        DomainInfoStat stat = new DomainInfoStat();
-        stat.setDimensionDomainCount(getDimensionCount(terms));
-        stat.setMetricDomainCount(getMetricCount(terms));
-        stat.setDomainCount(getDomainCount(terms));
-        stat.setDimensionValueDomainCount(getDimensionValueCount(terms));
-        return stat;
-    }
-
-
-    private static long getDomainCount(List<Term> terms) {
-        return terms.stream().filter(term -> isDomainOrEntity(term, getDomainByNature(term.nature))).count();
-    }
-
-    private static long getDimensionValueCount(List<Term> terms) {
-        return terms.stream().filter(term -> isDimensionValueClassId(term.nature.toString())).count();
-    }
-
-    private static long getDimensionCount(List<Term> terms) {
-        return terms.stream().filter(term -> term.nature.startsWith(NatureType.NATURE_SPILT) && term.nature.toString()
-                .endsWith(NatureType.DIMENSION.getType())).count();
-    }
-
-    private static long getMetricCount(List<Term> terms) {
-        return terms.stream().filter(term -> term.nature.startsWith(NatureType.NATURE_SPILT) && term.nature.toString()
-                .endsWith(NatureType.METRIC.getType())).count();
-    }
-
-    /**
-     * Get the number of types of class parts of speech
-     * domainId -> (nature , natureCount)
-     *
-     * @param terms
-     * @return
-     */
-    public static Map<Integer, Map<NatureType, Integer>> getDomainToNatureStat(List<Term> terms) {
-        Map<Integer, Map<NatureType, Integer>> domainToNature = new HashMap<>();
-        terms.stream().filter(
-                term -> term.nature.startsWith(NatureType.NATURE_SPILT)
-        ).forEach(term -> {
-            NatureType natureType = NatureType.getNatureType(String.valueOf(term.nature));
-            Integer domain = getDomain(String.valueOf(term.nature));
-
-            Map<NatureType, Integer> natureTypeMap = new HashMap<>();
-            natureTypeMap.put(natureType, 1);
-
-            Map<NatureType, Integer> original = domainToNature.get(domain);
-            if (Objects.isNull(original)) {
-                domainToNature.put(domain, natureTypeMap);
-            } else {
-                Integer count = original.get(natureType);
-                if (Objects.isNull(count)) {
-                    count = 1;
-                } else {
-                    count = count + 1;
-                }
-                original.put(natureType, count);
-            }
-        });
-        return domainToNature;
-    }
-
-    public static List<Integer> selectPossibleDomains(List<Term> terms) {
-        Map<Integer, Map<NatureType, Integer>> domainToNatureStat = getDomainToNatureStat(terms);
-        Integer maxDomainTypeSize = domainToNatureStat.entrySet().stream()
-                .max(Comparator.comparingInt(o -> o.getValue().size())).map(entry -> entry.getValue().size())
-                .orElse(null);
-        if (Objects.isNull(maxDomainTypeSize) || maxDomainTypeSize == 0) {
-            return new ArrayList<>();
-        }
-        return domainToNatureStat.entrySet().stream().filter(entry -> entry.getValue().size() == maxDomainTypeSize)
-                .map(entry -> entry.getKey()).collect(Collectors.toList());
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/knowledge/WordNatureService.java

@@ -1,81 +0,0 @@
-package com.tencent.supersonic.chat.application.knowledge;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.tencent.supersonic.chat.api.component.SemanticLayer;
-import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
-import com.tencent.supersonic.chat.domain.utils.ComponentFactory;
-import com.tencent.supersonic.chat.domain.utils.SchemaInfoConverter;
-import com.tencent.supersonic.common.nlp.ItemDO;
-import com.tencent.supersonic.common.nlp.NatureType;
-import com.tencent.supersonic.common.nlp.WordNature;
-import com.tencent.supersonic.knowledge.application.online.WordNatureStrategyFactory;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import lombok.extern.slf4j.Slf4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Service;
-
-
-/**
- * word nature service
- **/
-@Service
-@Slf4j
-public class WordNatureService {
-
-    private static final Integer META_CACHE_TIME = 5;
-    private SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-    private List<WordNature> preWordNatures = new ArrayList<>();
-
-    private LoadingCache<String, DomainInfos> cache = CacheBuilder.newBuilder()
-            .expireAfterWrite(META_CACHE_TIME, TimeUnit.MINUTES)
-            .build(
-                    new CacheLoader<String, DomainInfos>() {
-                        @Override
-                        public DomainInfos load(String key) {
-                            log.info("load getDomainSchemaInfo cache [{}]", key);
-                            return SchemaInfoConverter.convert(semanticLayer.getDomainSchemaInfo(new ArrayList<>()));
-                        }
-                    }
-            );
-
-    public List<WordNature> getAllWordNature() {
-        SemanticLayer semanticLayer = ComponentFactory.getSemanticLayer();
-        DomainInfos domainInfos = SchemaInfoConverter.convert(semanticLayer.getDomainSchemaInfo(new ArrayList<>()));
-
-        List<WordNature> natures = new ArrayList<>();
-
-        addNatureToResult(NatureType.DIMENSION, domainInfos.getDimensions(), natures);
-
-        addNatureToResult(NatureType.METRIC, domainInfos.getMetrics(), natures);
-
-        addNatureToResult(NatureType.DOMAIN, domainInfos.getDomains(), natures);
-
-        addNatureToResult(NatureType.ENTITY, domainInfos.getEntities(), natures);
-
-        return natures;
-    }
-
-    private void addNatureToResult(NatureType value, List<ItemDO> metas, List<WordNature> natures) {
-        List<WordNature> natureList = WordNatureStrategyFactory.get(value).getWordNatureList(metas);
-        log.debug("nature type:{} , nature size:{}", value.name(), natureList.size());
-        natures.addAll(natureList);
-    }
-
-    public List<WordNature> getPreWordNatures() {
-        return preWordNatures;
-    }
-
-    public void setPreWordNatures(List<WordNature> preWordNatures) {
-        this.preWordNatures = preWordNatures;
-    }
-
-    public LoadingCache<String, DomainInfos> getCache() {
-        return cache;
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/DatabaseSchemaMapper.java

@@ -1,143 +0,0 @@
-package com.tencent.supersonic.chat.application.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.component.SchemaMapper;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
-import com.tencent.supersonic.chat.application.knowledge.WordNatureService;
-import com.tencent.supersonic.chat.domain.pojo.chat.DomainInfos;
-import com.tencent.supersonic.common.nlp.ItemDO;
-import com.tencent.supersonic.common.util.context.ContextUtils;
-import com.tencent.supersonic.knowledge.infrastructure.nlp.HanlpHelper;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.util.CollectionUtils;
-
-@Slf4j
-public class DatabaseSchemaMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContextReq queryContext) {
-
-        log.debug("before db mapper,mapInfo:{}", queryContext.getMapInfo());
-
-        List<Term> terms = HanlpHelper.getTerms(queryContext.getQueryText());
-
-        WordNatureService wordNatureService = ContextUtils.getBean(WordNatureService.class);
-
-        DomainInfos domainInfos = wordNatureService.getCache().getUnchecked("");
-
-        detectAndAddToSchema(queryContext, terms, domainInfos.getDimensions(),
-                SchemaElementType.DIMENSION);
-        detectAndAddToSchema(queryContext, terms, domainInfos.getMetrics(), SchemaElementType.METRIC);
-
-        log.debug("after db mapper,mapInfo:{}", queryContext.getMapInfo());
-    }
-
-    private void detectAndAddToSchema(QueryContextReq queryContext, List<Term> terms, List<ItemDO> domains,
-            SchemaElementType schemaElementType) {
-        try {
-            String queryText = queryContext.getQueryText();
-
-            Map<String, Set<ItemDO>> domainResultSet = getResultSet(queryText, terms, domains);
-
-            addToSchemaMapInfo(domainResultSet, queryContext.getMapInfo(), schemaElementType);
-
-        } catch (Exception e) {
-            log.error("detectAndAddToSchema error", e);
-        }
-    }
-
-    private Map<String, Set<ItemDO>> getResultSet(String queryText, List<Term> terms, List<ItemDO> domains) {
-
-        MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
-
-        Map<String, Set<ItemDO>> nameToItems = getNameToItems(domains);
-
-        Map<Integer, Integer> regOffsetToLength = terms.stream().sorted(Comparator.comparing(Term::length))
-                .collect(Collectors.toMap(Term::getOffset, term -> term.word.length(), (value1, value2) -> value2));
-
-        Map<String, Set<ItemDO>> domainResultSet = new HashMap<>();
-        for (Integer index = 0; index <= queryText.length() - 1; ) {
-            for (Integer i = index; i <= queryText.length(); ) {
-                i = mapperHelper.getStepIndex(regOffsetToLength, i);
-                if (i <= queryText.length()) {
-                    String detectSegment = queryText.substring(index, i);
-                    nameToItems.forEach(
-                            (name, newItemDOs) -> {
-                                if (name.contains(detectSegment)
-                                        && mapperHelper.getSimilarity(detectSegment, name)
-                                        >= mapperHelper.getMetricDimensionThresholdConfig()) {
-                                    Set<ItemDO> preItemDOS = domainResultSet.putIfAbsent(detectSegment, newItemDOs);
-                                    if (Objects.nonNull(preItemDOS)) {
-                                        preItemDOS.addAll(newItemDOs);
-                                    }
-                                }
-                            }
-                    );
-                }
-            }
-            index = mapperHelper.getStepIndex(regOffsetToLength, index);
-        }
-        return domainResultSet;
-    }
-
-    private Map<String, Set<ItemDO>> getNameToItems(List<ItemDO> domains) {
-        return domains.stream()
-                .collect(Collectors.toMap(ItemDO::getName, a -> {
-                    Set<ItemDO> result = new HashSet<>();
-                    result.add(a);
-                    return result;
-                }, (k1, k2) -> {
-                    k1.addAll(k2);
-                    return k1;
-                }));
-    }
-
-    private void addToSchemaMapInfo(Map<String, Set<ItemDO>> mapResultRowSet, SchemaMapInfo schemaMap,
-            SchemaElementType schemaElementType) {
-        if (Objects.isNull(mapResultRowSet) || mapResultRowSet.size() <= 0) {
-            return;
-        }
-        MapperHelper mapperHelper = ContextUtils.getBean(MapperHelper.class);
-
-        for (Map.Entry<String, Set<ItemDO>> entry : mapResultRowSet.entrySet()) {
-            String detectWord = entry.getKey();
-            Set<ItemDO> itemDOS = entry.getValue();
-            for (ItemDO itemDO : itemDOS) {
-
-                List<SchemaElementMatch> elements = schemaMap.getMatchedElements(itemDO.getDomain());
-                if (CollectionUtils.isEmpty(elements)) {
-                    elements = new ArrayList<>();
-                    schemaMap.setMatchedElements(itemDO.getDomain(), elements);
-                }
-                Set<Integer> regElementSet = elements.stream()
-                        .filter(elementMatch -> schemaElementType.equals(elementMatch.getElementType()))
-                        .map(elementMatch -> elementMatch.getElementID())
-                        .collect(Collectors.toSet());
-
-                if (regElementSet.contains(itemDO.getItemId())) {
-                    continue;
-                }
-                SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
-                        .elementID(itemDO.getItemId()).word(itemDO.getName()).frequency(10000L)
-                        .elementType(schemaElementType).detectWord(detectWord)
-                        .similarity(mapperHelper.getSimilarity(detectWord, itemDO.getName()))
-                        .build();
-                log.info("schemaElementType:{},add to schema, elementMatch {}", schemaElementType, schemaElementMatch);
-                elements.add(schemaElementMatch);
-            }
-        }
-
-    }
-}

chat/core/src/main/java/com/tencent/supersonic/chat/application/mapper/HanlpSchemaMapper.java

@@ -1,103 +0,0 @@
-package com.tencent.supersonic.chat.application.mapper;
-
-import com.hankcs.hanlp.seg.common.Term;
-import com.tencent.supersonic.chat.api.component.SchemaMapper;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementMatch;
-import com.tencent.supersonic.chat.api.pojo.SchemaElementType;
-import com.tencent.supersonic.chat.api.pojo.SchemaMapInfo;
-import com.tencent.supersonic.chat.api.request.QueryContextReq;
-import com.tencent.supersonic.chat.application.knowledge.NatureHelper;
-import com.tencent.supersonic.chat.domain.pojo.search.MatchText;
-import com.tencent.supersonic.chat.domain.utils.NatureConverter;
-import com.tencent.supersonic.common.nlp.MapResult;
-import com.tencent.supersonic.common.nlp.NatureType;
-import com.tencent.supersonic.common.util.context.ContextUtils;
-import com.tencent.supersonic.knowledge.application.online.BaseWordNature;
-import com.tencent.supersonic.knowledge.application.online.WordNatureStrategyFactory;
-import com.tencent.supersonic.knowledge.infrastructure.nlp.HanlpHelper;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections.CollectionUtils;
-
-@Slf4j
-public class HanlpSchemaMapper implements SchemaMapper {
-
-    @Override
-    public void map(QueryContextReq queryContext) {
-
-        List<Term> terms = HanlpHelper.getTerms(queryContext.getQueryText());
-
-        terms.forEach(
-                item -> log.info("word:{},nature:{},frequency:{}", item.word, item.nature.toString(),
-                        item.getFrequency())
-        );
-        QueryMatchStrategy matchStrategy = ContextUtils.getBean(QueryMatchStrategy.class);
-
-        Map<MatchText, List<MapResult>> matchResult = matchStrategy.match(queryContext.getQueryText(), terms,
-                queryContext.getDomainId());
-        List<MapResult> matches = new ArrayList<>();
-        if (Objects.nonNull(matchResult)) {
-            Optional<List<MapResult>> first = matchResult.entrySet().stream()
-                    .filter(entry -> CollectionUtils.isNotEmpty(entry.getValue()))
-                    .map(entry -> entry.getValue()).findFirst();
-            if (first.isPresent()) {
-                matches = first.get();
-            }
-        }
-        HanlpHelper.transLetterOriginal(matches);
-        log.info("queryContext:{},matches:{}", queryContext, matches);
-
-        convertTermsToSchemaMapInfo(matches, queryContext.getMapInfo(), terms);
-    }
-
-
-
-    private void convertTermsToSchemaMapInfo(List<MapResult> mapResults, SchemaMapInfo schemaMap, List<Term> terms) {
-        if (CollectionUtils.isEmpty(mapResults)) {
-            return;
-        }
-
-        Map<String, Long> wordNatureToFrequency = terms.stream().collect(
-                Collectors.toMap(entry -> entry.getWord() + entry.getNature(),
-                        term -> Long.valueOf(term.getFrequency()), (value1, value2) -> value2));
-
-        for (MapResult mapResult : mapResults) {
-            for (String nature : mapResult.getNatures()) {
-                Integer domain = NatureHelper.getDomain(nature);
-                if (Objects.isNull(domain)) {
-                    continue;
-                }
-                SchemaElementType elementType = NatureConverter.convertTo(nature);
-                if (Objects.isNull(elementType)) {
-                    continue;
-                }
-
-                BaseWordNature baseWordNature = WordNatureStrategyFactory.get(NatureType.getNatureType(nature));
-                Integer elementID = baseWordNature.getElementID(nature);
-                Long frequency = wordNatureToFrequency.get(mapResult.getName() + nature);
-                SchemaElementMatch schemaElementMatch = SchemaElementMatch.builder()
-                        .elementType(elementType)
-                        .elementID(elementID)
-                        .frequency(frequency)
-                        .word(mapResult.getName())
-                        .similarity(mapResult.getSimilarity())
-                        .detectWord(mapResult.getDetectWord())
-                        .build();
-
-                Map<Integer, List<SchemaElementMatch>> domainElementMatches = schemaMap.getDomainElementMatches();
-                List<SchemaElementMatch> schemaElementMatches = domainElementMatches.putIfAbsent(domain,
-                        new ArrayList<>());
-                if (schemaElementMatches == null) {
-                    schemaElementMatches = domainElementMatches.get(domain);
-                }
-                schemaElementMatches.add(schemaElementMatch);
-            }
-        }
-    }
-
-}