(improvement)(Headless) Add terms management to help the model learn private domain knowledge (#979)

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/Term.java

@@ -0,0 +1,15 @@
+package com.tencent.supersonic.headless.api.pojo;
+
+import lombok.Data;
+import java.util.List;
+
+@Data
+public class Term {
+
+    private String name;
+
+    private String description;
+
+    private List<String> similarTerms;
+
+}

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/request/TermSetReq.java

@@ -0,0 +1,19 @@
+package com.tencent.supersonic.headless.api.pojo.request;
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.common.pojo.RecordInfo;
+import com.tencent.supersonic.headless.api.pojo.Term;
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@Data
+public class TermSetReq extends RecordInfo {
+
+    @NotNull(message = "主题域ID不可为空")
+    private Long domainId;
+
+    private List<Term> terms = Lists.newArrayList();
+
+}

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/response/MapInfoResp.java

@@ -1,6 +1,7 @@
 package com.tencent.supersonic.headless.api.pojo.response;
 
 import com.tencent.supersonic.headless.api.pojo.SchemaElementMatch;
+import com.tencent.supersonic.headless.api.pojo.Term;
 import lombok.Data;
 
 import java.util.List;
@@ -15,4 +16,6 @@ public class MapInfoResp {
 
     private Map<String, List<SchemaElementMatch>> topFields;
 
+    private Map<String, List<Term>> terms;
+
 }

headless/api/src/main/java/com/tencent/supersonic/headless/api/pojo/response/TermSetResp.java

@@ -0,0 +1,24 @@
+package com.tencent.supersonic.headless.api.pojo.response;
+
+import com.google.common.collect.Lists;
+import com.tencent.supersonic.common.pojo.RecordInfo;
+import com.tencent.supersonic.headless.api.pojo.Term;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class TermSetResp extends RecordInfo {
+
+    private Long domainId;
+
+    private List<Term> terms = Lists.newArrayList();
+
+    public TermSetResp(Long domainId) {
+        this.domainId = domainId;
+    }
+}

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/dataobject/TermSetDO.java

@@ -0,0 +1,28 @@
+package com.tencent.supersonic.headless.server.persistence.dataobject;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import java.util.Date;
+
+@Data
+@TableName("s2_term_set")
+public class TermSetDO {
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    private Long domainId;
+
+    private String terms;
+
+    private Date createdAt;
+
+    private String createdBy;
+
+    private Date updatedAt;
+
+    private String updatedBy;
+
+}

headless/server/src/main/java/com/tencent/supersonic/headless/server/persistence/mapper/TermSetMapper.java

@@ -0,0 +1,11 @@
+package com.tencent.supersonic.headless.server.persistence.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.tencent.supersonic.headless.server.persistence.dataobject.TermSetDO;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface TermSetMapper extends BaseMapper<TermSetDO> {
+
+
+}

headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/DataSetController.java

@@ -47,12 +47,10 @@ public class DataSetController {
     }
 
     @GetMapping("/getDataSetList")
-    public List<DataSetResp> getDataSetList(@RequestParam("domainId") Long domainId,
+    public List<DataSetResp> getDataSetList(@RequestParam("domainId") Long domainId) {
-            HttpServletRequest request, HttpServletResponse response) {
         MetaFilter metaFilter = new MetaFilter();
         metaFilter.setDomainId(domainId);
-        User user = UserHolder.findUser(request, response);
+        return dataSetService.getDataSetList(metaFilter);
-        return dataSetService.getDataSetList(metaFilter, user);
     }
 
     @DeleteMapping("/{id}")

headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/TagController.java

@@ -12,11 +12,6 @@ import com.tencent.supersonic.headless.api.pojo.response.TagResp;
 import com.tencent.supersonic.headless.server.persistence.dataobject.TagDO;
 import com.tencent.supersonic.headless.server.pojo.TagFilter;
 import com.tencent.supersonic.headless.server.service.TagMetaService;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.validation.Valid;
-
 import com.tencent.supersonic.headless.server.service.TagQueryService;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -26,6 +21,9 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.Valid;
 import java.util.List;
 
 @RestController
@@ -130,17 +128,11 @@ public class TagController {
      * 标签查询
      *
      * @param tagFilter
-     * @param request
-     * @param response
      * @return
-     * @throws Exception
      */
     @PostMapping("/queryTag")
-    public List<TagDO> queryPage(@RequestBody TagFilter tagFilter,
+    public List<TagDO> queryPage(@RequestBody TagFilter tagFilter) {
-                                     HttpServletRequest request,
+        return tagMetaService.getTagDOList(tagFilter);
-                                     HttpServletResponse response) throws Exception {
-        User user = UserHolder.findUser(request, response);
-        return tagMetaService.getTagDOList(tagFilter, user);
     }
 
 

headless/server/src/main/java/com/tencent/supersonic/headless/server/rest/TermController.java

@@ -0,0 +1,40 @@
+package com.tencent.supersonic.headless.server.rest;
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.auth.api.authentication.utils.UserHolder;
+import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
+import com.tencent.supersonic.headless.server.service.TermService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@RestController
+@RequestMapping("/api/semantic/term")
+public class TermController {
+
+    @Autowired
+    private TermService termService;
+
+    @PostMapping("/saveOrUpdate")
+    public boolean saveOrUpdate(@RequestBody TermSetReq termSetReq,
+                             HttpServletRequest request,
+                             HttpServletResponse response) {
+        User user = UserHolder.findUser(request, response);
+        termService.saveOrUpdate(termSetReq, user);
+        return true;
+    }
+
+    @GetMapping
+    public TermSetResp getTermSet(@RequestParam("domainId") Long domainId) {
+        return termService.getTermSet(domainId);
+    }
+
+}

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/DataSetService.java

@@ -18,7 +18,7 @@ public interface DataSetService {
 
     DataSetResp getDataSet(Long id);
 
-    List<DataSetResp> getDataSetList(MetaFilter metaFilter, User user);
+    List<DataSetResp> getDataSetList(MetaFilter metaFilter);
 
     void delete(Long id, User user);
 
@@ -32,8 +32,6 @@ public interface DataSetService {
 
     List<DataSetResp> getDataSets(List<String> dataSetNames, User user);
 
-    Map<Long, String> getDataSetIdToNameMap(List<Long> dataSetIds);
-
     List<DataSetResp> getDataSetsInheritAuth(User user, Long domainId);
 
     SemanticQueryReq convert(QueryDataSetReq queryDataSetReq);

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/TagMetaService.java

@@ -27,9 +27,9 @@ public interface TagMetaService {
 
     List<TagResp> getTags(TagFilter tagFilter);
 
-    List<TagDO> getTagDOList(TagFilter tagFilter, User user);
+    List<TagDO> getTagDOList(TagFilter tagFilter);
 
     PageInfo<TagResp> queryTagMarketPage(TagFilterPageReq tagMarketPageReq, User user);
 
-    List<TagItem> getTagItems(User user, List<Long> itemIds, TagDefineType tagDefineType);
+    List<TagItem> getTagItems(List<Long> itemIds, TagDefineType tagDefineType);
 }

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/TermService.java

@@ -0,0 +1,21 @@
+package com.tencent.supersonic.headless.server.service;
+
+
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.headless.api.pojo.Term;
+import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface TermService {
+
+    void saveOrUpdate(TermSetReq termSetReq, User user);
+
+    TermSetResp getTermSet(Long domainId);
+
+    Map<Long, List<Term>> getTermSets(Set<Long> domainIds);
+
+}

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/DataSetServiceImpl.java

@@ -84,7 +84,7 @@ public class DataSetServiceImpl
         dataSetReq.createdBy(user.getName());
         DataSetDO dataSetDO = convert(dataSetReq);
         dataSetDO.setStatus(StatusEnum.ONLINE.getCode());
-        DataSetResp dataSetResp = convert(dataSetDO, user);
+        DataSetResp dataSetResp = convert(dataSetDO);
         conflictCheck(dataSetResp);
         save(dataSetDO);
         return dataSetResp;
@@ -94,7 +94,7 @@ public class DataSetServiceImpl
     public DataSetResp update(DataSetReq dataSetReq, User user) {
         dataSetReq.updatedBy(user.getName());
         DataSetDO dataSetDO = convert(dataSetReq);
-        DataSetResp dataSetResp = convert(dataSetDO, user);
+        DataSetResp dataSetResp = convert(dataSetDO);
         conflictCheck(dataSetResp);
         updateById(dataSetDO);
         return dataSetResp;
@@ -103,11 +103,11 @@ public class DataSetServiceImpl
     @Override
     public DataSetResp getDataSet(Long id) {
         DataSetDO dataSetDO = getById(id);
-        return convert(dataSetDO, User.getFakeUser());
+        return convert(dataSetDO);
     }
 
     @Override
-    public List<DataSetResp> getDataSetList(MetaFilter metaFilter, User user) {
+    public List<DataSetResp> getDataSetList(MetaFilter metaFilter) {
         QueryWrapper<DataSetDO> wrapper = new QueryWrapper<>();
         if (metaFilter.getDomainId() != null) {
             wrapper.lambda().eq(DataSetDO::getDomainId, metaFilter.getDomainId());
@@ -125,7 +125,7 @@ public class DataSetServiceImpl
             wrapper.lambda().in(DataSetDO::getName, metaFilter.getNames());
         }
         wrapper.lambda().ne(DataSetDO::getStatus, StatusEnum.DELETED.getCode());
-        return list(wrapper).stream().map(entry -> convert(entry, user)).collect(Collectors.toList());
+        return list(wrapper).stream().map(this::convert).collect(Collectors.toList());
     }
 
     @Override
@@ -158,22 +158,13 @@ public class DataSetServiceImpl
     }
 
     private List<DataSetResp> getDataSetsByAuth(User user, MetaFilter metaFilter) {
-        List<DataSetResp> dataSetResps = getDataSetList(metaFilter, user);
+        List<DataSetResp> dataSetResps = getDataSetList(metaFilter);
         return getDataSetFilterByAuth(dataSetResps, user);
     }
 
-    @Override
-    public Map<Long, String> getDataSetIdToNameMap(List<Long> dataSetIds) {
-        MetaFilter metaFilter = new MetaFilter();
-        metaFilter.setIds(dataSetIds);
-        List<DataSetResp> dataSetResps = getDataSetList(metaFilter, User.getFakeUser());
-        return dataSetResps.stream().collect(
-                Collectors.toMap(DataSetResp::getId, DataSetResp::getName, (k1, k2) -> k1));
-    }
-
     @Override
     public List<DataSetResp> getDataSetsInheritAuth(User user, Long domainId) {
-        List<DataSetResp> dataSetResps = getDataSetList(new MetaFilter(), user);
+        List<DataSetResp> dataSetResps = getDataSetList(new MetaFilter());
         List<DataSetResp> inheritAuthFormDomain = getDataSetFilterByDomainAuth(dataSetResps, user);
         Set<DataSetResp> dataSetRespSet = new HashSet<>(inheritAuthFormDomain);
         List<DataSetResp> dataSetFilterByAuth = getDataSetFilterByAuth(dataSetResps, user);
@@ -202,7 +193,7 @@ public class DataSetServiceImpl
                 domainIds.contains(dataSetResp.getDomainId())).collect(Collectors.toList());
     }
 
-    private DataSetResp convert(DataSetDO dataSetDO, User user) {
+    private DataSetResp convert(DataSetDO dataSetDO) {
         DataSetResp dataSetResp = new DataSetResp();
         BeanMapper.mapper(dataSetDO, dataSetResp);
         dataSetResp.setDataSetDetail(JSONObject.parseObject(dataSetDO.getDataSetDetail(), DataSetDetail.class));
@@ -214,11 +205,11 @@ public class DataSetServiceImpl
         dataSetResp.setAdminOrgs(StringUtils.isBlank(dataSetDO.getAdminOrg())
                 ? Lists.newArrayList() : Arrays.asList(dataSetDO.getAdminOrg().split(",")));
         dataSetResp.setTypeEnum(TypeEnums.DATASET);
-        List<TagItem> dimensionItems = tagMetaService.getTagItems(user, dataSetResp.dimensionIds(),
+        List<TagItem> dimensionItems = tagMetaService.getTagItems(dataSetResp.dimensionIds(),
                 TagDefineType.DIMENSION);
         dataSetResp.setAllDimensions(dimensionItems);
 
-        List<TagItem> metricItems = tagMetaService.getTagItems(user, dataSetResp.metricIds(), TagDefineType.METRIC);
+        List<TagItem> metricItems = tagMetaService.getTagItems(dataSetResp.metricIds(), TagDefineType.METRIC);
         dataSetResp.setAllMetrics(metricItems);
         return dataSetResp;
     }
@@ -259,7 +250,7 @@ public class DataSetServiceImpl
         metaFilter.setIds(dataSetIds);
         List<DataSetResp> dataSetList = dataSetSchemaCache.getIfPresent(metaFilter);
         if (CollectionUtils.isEmpty(dataSetList)) {
-            dataSetList = getDataSetList(metaFilter, user);
+            dataSetList = getDataSetList(metaFilter);
             dataSetSchemaCache.put(metaFilter, dataSetList);
         }
         return dataSetList.stream()

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/DimensionServiceImpl.java

@@ -246,7 +246,7 @@ public class DimensionServiceImpl implements DimensionService {
 
         List<Long> dimensionIds = dimensionResps.stream().map(dimensionResp -> dimensionResp.getId())
                 .collect(Collectors.toList());
-        List<TagItem> tagItems = tagMetaService.getTagItems(User.getFakeUser(), dimensionIds, TagDefineType.DIMENSION);
+        List<TagItem> tagItems = tagMetaService.getTagItems(dimensionIds, TagDefineType.DIMENSION);
         Map<Long, TagItem> itemIdToTagItem = tagItems.stream()
                 .collect(Collectors.toMap(tag -> tag.getItemId(), tag -> tag, (newTag, oldTag) -> newTag));
 
@@ -325,7 +325,7 @@ public class DimensionServiceImpl implements DimensionService {
         List<Long> dimensionIds = dimensionResps.stream().map(dimension -> dimension.getId())
                 .collect(Collectors.toList());
         tagFilter.setItemIds(dimensionIds);
-        Map<Long, TagDO> keyAndTagMap = tagMetaService.getTagDOList(tagFilter, User.getFakeUser()).stream()
+        Map<Long, TagDO> keyAndTagMap = tagMetaService.getTagDOList(tagFilter).stream()
                 .collect(Collectors.toMap(tag -> tag.getItemId(), tag -> tag,
                         (newTag, oldTag) -> newTag));
         if (Objects.nonNull(keyAndTagMap)) {

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/MetaDiscoveryServiceImpl.java

@@ -4,17 +4,21 @@ import com.tencent.supersonic.common.pojo.enums.TimeDimensionEnum;
 import com.tencent.supersonic.headless.api.pojo.SchemaElement;
 import com.tencent.supersonic.headless.api.pojo.SchemaElementMatch;
 import com.tencent.supersonic.headless.api.pojo.SchemaElementType;
+import com.tencent.supersonic.headless.api.pojo.SchemaItem;
 import com.tencent.supersonic.headless.api.pojo.SchemaMapInfo;
 import com.tencent.supersonic.headless.api.pojo.SemanticSchema;
+import com.tencent.supersonic.headless.api.pojo.Term;
 import com.tencent.supersonic.headless.api.pojo.request.QueryMapReq;
 import com.tencent.supersonic.headless.api.pojo.request.QueryReq;
 import com.tencent.supersonic.headless.api.pojo.response.DataSetResp;
 import com.tencent.supersonic.headless.api.pojo.response.MapInfoResp;
 import com.tencent.supersonic.headless.api.pojo.response.MapResp;
 import com.tencent.supersonic.headless.core.chat.knowledge.builder.BaseWordBuilder;
+import com.tencent.supersonic.headless.server.pojo.MetaFilter;
 import com.tencent.supersonic.headless.server.service.ChatQueryService;
 import com.tencent.supersonic.headless.server.service.DataSetService;
 import com.tencent.supersonic.headless.server.service.MetaDiscoveryService;
+import com.tencent.supersonic.headless.server.service.TermService;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
@@ -43,30 +47,37 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
     @Autowired
     private SemanticService semanticService;
 
+    @Autowired
+    private TermService termService;
+
     @Override
     public MapInfoResp getMapMeta(QueryMapReq queryMapReq) {
 
         QueryReq queryReq = new QueryReq();
         BeanUtils.copyProperties(queryMapReq, queryReq);
         List<DataSetResp> dataSets = dataSetService.getDataSets(queryMapReq.getDataSetNames(), queryMapReq.getUser());
-        Set<Long> dataSetIds = dataSets.stream().map(dataSetResp -> dataSetResp.getId()).collect(Collectors.toSet());
-        queryReq.setDataSetIds(dataSetIds);
 
+        Set<Long> dataSetIds = dataSets.stream().map(SchemaItem::getId).collect(Collectors.toSet());
+        queryReq.setDataSetIds(dataSetIds);
         MapResp mapResp = chatQueryService.performMapping(queryReq);
         return convert(mapResp, queryMapReq.getTopN());
     }
 
-    public MapInfoResp convert(MapResp mapResp, Integer topN) {
+    private MapInfoResp convert(MapResp mapResp, Integer topN) {
         MapInfoResp mapInfoResp = new MapInfoResp();
         if (Objects.isNull(mapResp)) {
             return mapInfoResp;
         }
         BeanUtils.copyProperties(mapResp, mapInfoResp);
         Set<Long> dataSetIds = mapResp.getMapInfo().getDataSetElementMatches().keySet();
-        Map<Long, String> dataSetMap = dataSetService.getDataSetIdToNameMap(new ArrayList<>(dataSetIds));
+        MetaFilter metaFilter = new MetaFilter();
-
+        metaFilter.setIds(new ArrayList<>(dataSetIds));
+        List<DataSetResp> dataSetList = dataSetService.getDataSetList(metaFilter);
+        Map<Long, String> dataSetMap = dataSetList.stream()
+                .collect(Collectors.toMap(DataSetResp::getId, DataSetResp::getName));
         mapInfoResp.setMapFields(getMapFields(mapResp.getMapInfo(), dataSetMap));
         mapInfoResp.setTopFields(getTopFields(topN, mapResp.getMapInfo(), dataSetMap));
+        mapInfoResp.setTerms(getTerms(dataSetList, dataSetMap));
         return mapInfoResp;
     }
 
@@ -114,6 +125,19 @@ public class MetaDiscoveryServiceImpl implements MetaDiscoveryService {
         return result;
     }
 
+    private Map<String, List<Term>> getTerms(List<DataSetResp> dataSets, Map<Long, String> dataSetNameMap) {
+        Set<Long> domainIds = dataSets.stream().map(DataSetResp::getDomainId).collect(Collectors.toSet());
+        Map<Long, Long> dataSetDomainIdMap = dataSets.stream()
+                .collect(Collectors.toMap(DataSetResp::getId, DataSetResp::getDomainId));
+        Map<Long, List<Term>> domainTermSetMap = termService.getTermSets(domainIds);
+        Map<String, List<Term>> dataSetTermSetMap = new HashMap<>();
+        for (DataSetResp dataSet : dataSets) {
+            dataSetTermSetMap.put(dataSetNameMap.get(dataSet.getId()),
+                    domainTermSetMap.get(dataSetDomainIdMap.get(dataSet.getId())));
+        }
+        return dataSetTermSetMap;
+    }
+
     /***
      * get time dimension SchemaElementMatch
      * @param dataSetId

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/MetricServiceImpl.java

@@ -316,7 +316,7 @@ public class MetricServiceImpl implements MetricService {
         List<MetricResp> metricResps = convertList(queryMetric(metricFilter));
         List<Long> metricIds = metricResps.stream().map(metricResp -> metricResp.getId()).collect(Collectors.toList());
 
-        List<TagItem> tagItems = tagMetaService.getTagItems(User.getFakeUser(), metricIds, TagDefineType.METRIC);
+        List<TagItem> tagItems = tagMetaService.getTagItems(metricIds, TagDefineType.METRIC);
         Map<Long, TagItem> itemIdToTagItem = tagItems.stream()
                 .collect(Collectors.toMap(tag -> tag.getItemId(), tag -> tag, (newTag, oldTag) -> newTag));
 
@@ -374,7 +374,7 @@ public class MetricServiceImpl implements MetricService {
         List<Long> metricIds = metricRespList.stream().map(metric -> metric.getId())
                 .collect(Collectors.toList());
         tagFilter.setItemIds(metricIds);
-        Map<Long, TagDO> keyAndTagMap = tagMetaService.getTagDOList(tagFilter, User.getFakeUser()).stream()
+        Map<Long, TagDO> keyAndTagMap = tagMetaService.getTagDOList(tagFilter).stream()
                 .collect(Collectors.toMap(tag -> tag.getItemId(), tag -> tag,
                         (newTag, oldTag) -> newTag));
         if (Objects.nonNull(keyAndTagMap)) {

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/SchemaServiceImpl.java

@@ -163,7 +163,7 @@ public class SchemaServiceImpl implements SchemaService {
         MetaFilter metaFilter = new MetaFilter();
         metaFilter.setStatus(StatusEnum.ONLINE.getCode());
         metaFilter.setIds(filter.getDataSetIds());
-        List<DataSetResp> dataSetResps = dataSetService.getDataSetList(metaFilter, User.getFakeUser());
+        List<DataSetResp> dataSetResps = dataSetService.getDataSetList(metaFilter);
         Map<Long, DataSetResp> dataSetRespMap = getDataSetMap(dataSetResps);
 
         List<Long> modelIds = dataSetRespMap.values().stream().map(DataSetResp::getAllModels)
@@ -404,7 +404,7 @@ public class SchemaServiceImpl implements SchemaService {
             }
             parentItem.getChildren().add(itemResp);
         }
-        List<DataSetResp> dataSetResps = dataSetService.getDataSetList(new MetaFilter(), User.getFakeUser());
+        List<DataSetResp> dataSetResps = dataSetService.getDataSetList(new MetaFilter());
         for (DataSetResp dataSetResp : dataSetResps) {
             ItemResp itemResp = itemRespMap.get(dataSetResp.getDomainId());
             if (itemResp != null) {

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/TagMetaServiceImpl.java

@@ -138,7 +138,7 @@ public class TagMetaServiceImpl implements TagMetaService {
     }
 
     @Override
-    public List<TagDO> getTagDOList(TagFilter tagFilter, User user) {
+    public List<TagDO> getTagDOList(TagFilter tagFilter) {
         return tagRepository.getTagDOList(tagFilter);
     }
 
@@ -388,11 +388,11 @@ public class TagMetaServiceImpl implements TagMetaService {
     }
 
     @Override
-    public List<TagItem> getTagItems(User user, List<Long> itemIds, TagDefineType tagDefineType) {
+    public List<TagItem> getTagItems(List<Long> itemIds, TagDefineType tagDefineType) {
         TagFilter tagFilter = new TagFilter();
         tagFilter.setTagDefineType(tagDefineType);
         tagFilter.setItemIds(itemIds);
-        Set<Long> dimensionItemSet = getTagDOList(tagFilter, user).stream().map(TagDO::getItemId)
+        Set<Long> dimensionItemSet = getTagDOList(tagFilter).stream().map(TagDO::getItemId)
                 .collect(Collectors.toSet());
         return itemIds.stream().map(entry -> {
                     TagItem tagItem = new TagItem();

headless/server/src/main/java/com/tencent/supersonic/headless/server/service/impl/TermServiceImpl.java

@@ -0,0 +1,67 @@
+package com.tencent.supersonic.headless.server.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tencent.supersonic.auth.api.authentication.pojo.User;
+import com.tencent.supersonic.common.util.BeanMapper;
+import com.tencent.supersonic.common.util.JsonUtil;
+import com.tencent.supersonic.headless.api.pojo.Term;
+import com.tencent.supersonic.headless.api.pojo.request.TermSetReq;
+import com.tencent.supersonic.headless.api.pojo.response.TermSetResp;
+import com.tencent.supersonic.headless.server.persistence.dataobject.TermSetDO;
+import com.tencent.supersonic.headless.server.persistence.mapper.TermSetMapper;
+import com.tencent.supersonic.headless.server.service.TermService;
+import org.springframework.stereotype.Service;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+
+@Service
+public class TermServiceImpl extends ServiceImpl<TermSetMapper, TermSetDO> implements TermService {
+
+    @Override
+    public void saveOrUpdate(TermSetReq termSetReq, User user) {
+        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().eq(TermSetDO::getDomainId, termSetReq.getDomainId());
+        TermSetDO termSetDO = getOne(queryWrapper);
+        if (termSetDO == null) {
+            termSetReq.createdBy(user.getName());
+            termSetDO = new TermSetDO();
+        }
+        termSetReq.updatedBy(user.getName());
+        BeanMapper.mapper(termSetReq, termSetDO);
+        termSetDO.setTerms(JsonUtil.toString(termSetReq.getTerms()));
+        saveOrUpdate(termSetDO);
+    }
+
+    @Override
+    public TermSetResp getTermSet(Long domainId) {
+        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().eq(TermSetDO::getDomainId, domainId);
+        TermSetDO termSetDO = getOne(queryWrapper);
+        TermSetResp termSetResp = new TermSetResp(domainId);
+        if (termSetDO == null) {
+            return termSetResp;
+        }
+        return convert(termSetDO);
+    }
+
+    @Override
+    public Map<Long, List<Term>> getTermSets(Set<Long> domainIds) {
+        QueryWrapper<TermSetDO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().in(TermSetDO::getDomainId, domainIds);
+        List<TermSetDO> list = list(queryWrapper);
+        return list.stream().map(this::convert).collect(
+                Collectors.toMap(TermSetResp::getDomainId, TermSetResp::getTerms, (k1, k2) -> k1));
+    }
+
+    private TermSetResp convert(TermSetDO termSetDO) {
+        TermSetResp termSetResp = new TermSetResp();
+        BeanMapper.mapper(termSetDO, termSetResp);
+        termSetResp.setTerms(JsonUtil.toList(termSetDO.getTerms(), Term.class));
+        return termSetResp;
+    }
+
+}

launchers/standalone/src/main/resources/config.update/sql-update.sql

@@ -294,3 +294,15 @@ update s2_metric set is_publish = 1;
 
 --20240402
 alter table s2_dimension add column `ext` varchar(1000) DEFAULT NULL;
+
+--20240510
+CREATE TABLE IF NOT EXISTS `s2_term_set` (
+    `id` bigint(20) NOT NULL  AUTO_INCREMENT,
+    `domain_id` bigint(20),
+    `terms` varchar(1000),
+    `created_at` datetime NOT NULL ,
+    `created_by` varchar(100) NOT NULL ,
+    `updated_at` datetime DEFAULT NULL ,
+    `updated_by` varchar(100) DEFAULT NULL ,
+    PRIMARY KEY (`id`)
+);

launchers/standalone/src/main/resources/db/schema-h2.sql

@@ -626,3 +626,15 @@ CREATE TABLE IF NOT EXISTS `s2_query_rule` (
     PRIMARY KEY (`id`)
     );
 COMMENT ON TABLE s2_query_rule IS 'tag query rule table';
+
+CREATE TABLE IF NOT EXISTS `s2_term_set` (
+    `id` INT NOT NULL  AUTO_INCREMENT,
+    `domain_id` INT ,
+    `terms` varchar(1000),
+    `created_at` TIMESTAMP NOT NULL ,
+    `created_by` varchar(100) NOT NULL ,
+    `updated_at` TIMESTAMP DEFAULT NULL ,
+    `updated_by` varchar(100) DEFAULT NULL ,
+    PRIMARY KEY (`id`)
+    );
+COMMENT ON TABLE s2_term_set IS 'term info';

launchers/standalone/src/main/resources/db/schema-mysql.sql

@@ -549,3 +549,14 @@ CREATE TABLE IF NOT EXISTS `s2_query_rule` (
     `ext` text DEFAULT NULL  ,
     PRIMARY KEY (`id`)
     ) ENGINE = InnoDB DEFAULT CHARSET = utf8 COMMENT ='查询规则表';
+
+CREATE TABLE IF NOT EXISTS `s2_term_set` (
+    `id` bigint(20) NOT NULL  AUTO_INCREMENT,
+    `domain_id` bigint(20),
+    `terms` varchar(1000),
+    `created_at` datetime NOT NULL ,
+    `created_by` varchar(100) NOT NULL ,
+    `updated_at` datetime DEFAULT NULL ,
+    `updated_by` varchar(100) DEFAULT NULL ,
+    PRIMARY KEY (`id`)
+);

launchers/standalone/src/test/resources/db/schema-h2.sql

@@ -626,3 +626,15 @@ CREATE TABLE IF NOT EXISTS `s2_query_rule` (
     PRIMARY KEY (`id`)
     );
 COMMENT ON TABLE s2_query_rule IS 'tag query rule table';
+
+CREATE TABLE IF NOT EXISTS `s2_term_set` (
+                                             `id` INT NOT NULL  AUTO_INCREMENT,
+                                             `domain_id` INT ,
+                                             `terms` varchar(1000),
+    `created_at` TIMESTAMP NOT NULL ,
+    `created_by` varchar(100) NOT NULL ,
+    `updated_at` TIMESTAMP DEFAULT NULL ,
+    `updated_by` varchar(100) DEFAULT NULL ,
+    PRIMARY KEY (`id`)
+    );
+COMMENT ON TABLE s2_term_set IS 'term info';