项目初始化

datax-common/datax-common-core/src/main/java/cn/datax/common/core/RedisConstant.java

@@ -16,9 +16,11 @@ public interface RedisConstant {
 
     String METADATA_COLUMN_KEY = "data:metadata:columns";
 
-    String VISUAL_SET_KEY = "data:visual:sets";
+    String METADATA_AUTHORIZE_KEY = "data:metadata:authorizes";
 
     String STANDARD_DICT_KEY = "data:standard:dicts";
 
     String WORKFLOW_BUSINESS_KEY = "data:workflow:business";
+
+    String VISUAL_SET_KEY = "data:visual:sets";
 }

datax-modules/data-metadata-service-parent/data-metadata-service-api/src/main/java/cn/datax/service/data/metadata/api/dto/AuthorizeData.java

@@ -20,6 +20,6 @@ public class AuthorizeData implements Serializable {
     @ApiModelProperty(value = "角色ID")
     private String roleId;
     @NotBlank(message = "目标表类型不能为空")
-    @ApiModelProperty(value = "目标表类型(1数据源2表3字段)")
+    @ApiModelProperty(value = "目标表类型")
     private String objectType;
 }

datax-modules/data-metadata-service-parent/data-metadata-service-api/src/main/java/cn/datax/service/data/metadata/api/entity/MetadataAuthorizeEntity.java

@@ -42,7 +42,7 @@ public class MetadataAuthorizeEntity implements Serializable {
     private String roleId;
 
     /**
-     * 目标表类型(1数据源2表3字段)
+     * 目标表类型
      */
     private String objectType;
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/config/StartedUpRunner.java

@@ -2,9 +2,11 @@ package cn.datax.service.data.metadata.config;
 
 import cn.datax.common.core.RedisConstant;
 import cn.datax.common.redis.service.RedisService;
+import cn.datax.service.data.metadata.api.entity.MetadataAuthorizeEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataColumnEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataSourceEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataTableEntity;
+import cn.datax.service.data.metadata.dao.MetadataAuthorizeDao;
 import cn.datax.service.data.metadata.dao.MetadataColumnDao;
 import cn.datax.service.data.metadata.dao.MetadataSourceDao;
 import cn.datax.service.data.metadata.dao.MetadataTableDao;
@@ -41,6 +43,9 @@ public class StartedUpRunner implements ApplicationRunner {
     private MetadataColumnDao metadataColumnDao;
 
     @Autowired
+    private MetadataAuthorizeDao metadataAuthorizeDao;
+
+    @Autowired
     private RedisService redisService;
 
     @Autowired
@@ -79,6 +84,14 @@ public class StartedUpRunner implements ApplicationRunner {
                 Map<String, List<MetadataColumnEntity>> columnListMap = columnEntityList.stream().collect(Collectors.groupingBy(MetadataColumnEntity::getTableId));
                 redisTemplate.opsForHash().putAll(columnKey, columnListMap);
             }
+
+            String authorizeKey = RedisConstant.METADATA_AUTHORIZE_KEY;
+            Boolean hasAuthorizeKey = redisService.hasKey(authorizeKey);
+            if (!hasAuthorizeKey) {
+                List<MetadataAuthorizeEntity> metadataAuthorizeList = metadataAuthorizeDao.selectList(Wrappers.emptyWrapper());
+                Map<String, List<MetadataAuthorizeEntity>> authorizeListMap = metadataAuthorizeList.stream().collect(Collectors.groupingBy(MetadataAuthorizeEntity::getRoleId));
+                redisTemplate.opsForHash().putAll(authorizeKey, authorizeListMap);
+            }
         }
     }
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/controller/MetadataAuthorizeController.java

@@ -43,4 +43,15 @@ public class MetadataAuthorizeController extends BaseController {
         metadataAuthorizeService.metadataAuthorize(metadataAuthorizeDto);
         return R.ok();
     }
+
+    /**
+     * 刷新缓存
+     *
+     * @return
+     */
+    @GetMapping("/refresh")
+    public R refreshCache() {
+        metadataAuthorizeService.refreshCache();
+        return R.ok();
+    }
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/controller/MetadataColumnController.java

@@ -63,11 +63,12 @@ public class MetadataColumnController extends BaseController {
     @ApiOperation(value = "获取列表", notes = "")
     @GetMapping("/list")
     public R getDataMetadataColumnList(MetadataColumnQuery metadataColumnQuery) {
-        QueryWrapper<MetadataColumnEntity> queryWrapper = new QueryWrapper<>();
-        queryWrapper.like(StrUtil.isNotBlank(metadataColumnQuery.getColumnName()), "column_name", metadataColumnQuery.getColumnName());
-        queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getSourceId()), "source_id", metadataColumnQuery.getSourceId());
-        queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getTableId()), "table_id", metadataColumnQuery.getTableId());
-        List<MetadataColumnEntity> list = metadataColumnService.list(queryWrapper);
+//        QueryWrapper<MetadataColumnEntity> queryWrapper = new QueryWrapper<>();
+//        queryWrapper.like(StrUtil.isNotBlank(metadataColumnQuery.getColumnName()), "column_name", metadataColumnQuery.getColumnName());
+//        queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getSourceId()), "source_id", metadataColumnQuery.getSourceId());
+//        queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getTableId()), "table_id", metadataColumnQuery.getTableId());
+//        List<MetadataColumnEntity> list = metadataColumnService.list(queryWrapper);
+        List<MetadataColumnEntity> list = metadataColumnService.getDataMetadataColumnList(metadataColumnQuery);
         List<MetadataColumnVo> collect = list.stream().map(metadataColumnMapper::toVO).collect(Collectors.toList());
         return R.ok().setData(collect);
     }
@@ -88,7 +89,7 @@ public class MetadataColumnController extends BaseController {
         queryWrapper.like(StrUtil.isNotBlank(metadataColumnQuery.getColumnName()), "c.column_name", metadataColumnQuery.getColumnName());
         queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getSourceId()), "c.source_id", metadataColumnQuery.getSourceId());
         queryWrapper.eq(StrUtil.isNotBlank(metadataColumnQuery.getTableId()), "c.table_id", metadataColumnQuery.getTableId());
-        IPage<MetadataColumnEntity> page = metadataColumnService.page(new Page<>(metadataColumnQuery.getPageNum(), metadataColumnQuery.getPageSize()), queryWrapper);
+        IPage<MetadataColumnEntity> page = metadataColumnService.pageWithAuth(new Page<>(metadataColumnQuery.getPageNum(), metadataColumnQuery.getPageSize()), queryWrapper);
         List<MetadataColumnVo> collect = page.getRecords().stream().map(metadataColumnMapper::toVO).collect(Collectors.toList());
         JsonPage<MetadataColumnVo> jsonPage = new JsonPage<>(page.getCurrent(), page.getSize(), page.getTotal(), collect);
         return R.ok().setData(jsonPage);

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/controller/MetadataSourceController.java

@@ -73,9 +73,10 @@ public class MetadataSourceController extends BaseController {
     @ApiOperation(value = "获取列表", notes = "")
     @GetMapping("/list")
     public R getMetadataSourceList() {
-        QueryWrapper<MetadataSourceEntity> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("status", DataConstant.EnableState.ENABLE.getKey());
-        List<MetadataSourceEntity> list = metadataSourceService.list(queryWrapper);
+//        QueryWrapper<MetadataSourceEntity> queryWrapper = new QueryWrapper<>();
+//        queryWrapper.eq("status", DataConstant.EnableState.ENABLE.getKey());
+//        List<MetadataSourceEntity> list = metadataSourceService.list(queryWrapper);
+        List<MetadataSourceEntity> list = metadataSourceService.getMetadataSourceList();
         List<MetadataSourceVo> collect = list.stream().map(metadataSourceMapper::toVO).collect(Collectors.toList());
         return R.ok().setData(collect);
     }
@@ -93,8 +94,8 @@ public class MetadataSourceController extends BaseController {
     @GetMapping("/page")
     public R getMetadataSourcePage(MetadataSourceQuery metadataSourceQuery) {
         QueryWrapper<MetadataSourceEntity> queryWrapper = new QueryWrapper<>();
-        queryWrapper.like(StrUtil.isNotBlank(metadataSourceQuery.getSourceName()), "source_name", metadataSourceQuery.getSourceName());
-        IPage<MetadataSourceEntity> page = metadataSourceService.page(new Page<>(metadataSourceQuery.getPageNum(), metadataSourceQuery.getPageSize()), queryWrapper);
+        queryWrapper.like(StrUtil.isNotBlank(metadataSourceQuery.getSourceName()), "s.source_name", metadataSourceQuery.getSourceName());
+        IPage<MetadataSourceEntity> page = metadataSourceService.pageWithAuth(new Page<>(metadataSourceQuery.getPageNum(), metadataSourceQuery.getPageSize()), queryWrapper);
         List<MetadataSourceVo> collect = page.getRecords().stream().map(metadataSourceMapper::toVO).collect(Collectors.toList());
         JsonPage<MetadataSourceVo> jsonPage = new JsonPage<>(page.getCurrent(), page.getSize(), page.getTotal(), collect);
         return R.ok().setData(jsonPage);

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/controller/MetadataTableController.java

@@ -62,10 +62,11 @@ public class MetadataTableController extends BaseController {
     @ApiOperation(value = "获取列表", notes = "")
     @GetMapping("/list")
     public R getDataMetadataTableList(MetadataTableQuery metadataTableQuery) {
-        QueryWrapper<MetadataTableEntity> queryWrapper = new QueryWrapper<>();
-        queryWrapper.like(StrUtil.isNotBlank(metadataTableQuery.getTableName()), "table_name", metadataTableQuery.getTableName());
-        queryWrapper.eq(StrUtil.isNotBlank(metadataTableQuery.getSourceId()), "source_id", metadataTableQuery.getSourceId());
-        List<MetadataTableEntity> list = metadataTableService.list(queryWrapper);
+//        QueryWrapper<MetadataTableEntity> queryWrapper = new QueryWrapper<>();
+//        queryWrapper.like(StrUtil.isNotBlank(metadataTableQuery.getTableName()), "table_name", metadataTableQuery.getTableName());
+//        queryWrapper.eq(StrUtil.isNotBlank(metadataTableQuery.getSourceId()), "source_id", metadataTableQuery.getSourceId());
+//        List<MetadataTableEntity> list = metadataTableService.list(queryWrapper);
+        List<MetadataTableEntity> list = metadataTableService.getDataMetadataTableList(metadataTableQuery);
         List<MetadataTableVo> collect = list.stream().map(metadataTableMapper::toVO).collect(Collectors.toList());
         return R.ok().setData(collect);
     }
@@ -85,7 +86,7 @@ public class MetadataTableController extends BaseController {
         QueryWrapper<MetadataTableEntity> queryWrapper = new QueryWrapper<>();
         queryWrapper.like(StrUtil.isNotBlank(metadataTableQuery.getTableName()), "t.table_name", metadataTableQuery.getTableName());
         queryWrapper.eq(StrUtil.isNotBlank(metadataTableQuery.getSourceId()), "t.source_id", metadataTableQuery.getSourceId());
-        IPage<MetadataTableEntity> page = metadataTableService.page(new Page<>(metadataTableQuery.getPageNum(), metadataTableQuery.getPageSize()), queryWrapper);
+        IPage<MetadataTableEntity> page = metadataTableService.pageWithAuth(new Page<>(metadataTableQuery.getPageNum(), metadataTableQuery.getPageSize()), queryWrapper);
         List<MetadataTableVo> collect = page.getRecords().stream().map(metadataTableMapper::toVO).collect(Collectors.toList());
         JsonPage<MetadataTableVo> jsonPage = new JsonPage<>(page.getCurrent(), page.getSize(), page.getTotal(), collect);
         return R.ok().setData(jsonPage);

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/dao/MetadataColumnDao.java

@@ -8,6 +8,8 @@ import com.baomidou.mybatisplus.core.toolkit.Constants;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
+
 /**
  * <p>
  * 元数据信息表 Mapper 接口
@@ -19,6 +21,5 @@ import org.apache.ibatis.annotations.Param;
 @Mapper
 public interface MetadataColumnDao extends BaseDao<MetadataColumnEntity> {
 
-    @Override
-    <E extends IPage<MetadataColumnEntity>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<MetadataColumnEntity> queryWrapper);
+    <E extends IPage<MetadataColumnEntity>> E selectPageWithAuth(E page, @Param(Constants.WRAPPER) Wrapper<MetadataColumnEntity> queryWrapper, @Param("roles") List<String> roles);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/dao/MetadataSourceDao.java

@@ -28,6 +28,5 @@ public interface MetadataSourceDao extends BaseDao<MetadataSourceEntity> {
     @Override
     List<MetadataSourceEntity> selectList(@Param(Constants.WRAPPER) Wrapper<MetadataSourceEntity> queryWrapper);
 
-    @Override
-    <E extends IPage<MetadataSourceEntity>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<MetadataSourceEntity> queryWrapper);
+    <E extends IPage<MetadataSourceEntity>> E selectPageWithAuth(E page, @Param(Constants.WRAPPER) Wrapper<MetadataSourceEntity> queryWrapper, @Param("roles") List<String> roles);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/dao/MetadataTableDao.java

@@ -8,6 +8,8 @@ import com.baomidou.mybatisplus.core.toolkit.Constants;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
+
 /**
  * <p>
  * 数据库表信息表 Mapper 接口
@@ -19,6 +21,5 @@ import org.apache.ibatis.annotations.Param;
 @Mapper
 public interface MetadataTableDao extends BaseDao<MetadataTableEntity> {
 
-    @Override
-    <E extends IPage<MetadataTableEntity>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<MetadataTableEntity> queryWrapper);
+    <E extends IPage<MetadataTableEntity>> E selectPageWithAuth(E page, @Param(Constants.WRAPPER) Wrapper<MetadataTableEntity> queryWrapper, @Param("roles") List<String> roles);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/MetadataAuthorizeService.java

@@ -19,4 +19,6 @@ public interface MetadataAuthorizeService extends BaseService<MetadataAuthorizeE
     List<String> getAuthorizedMetadata(String id);
 
     void metadataAuthorize(MetadataAuthorizeDto metadataAuthorizeDto);
+
+    void refreshCache();
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/MetadataColumnService.java

@@ -5,6 +5,8 @@ import cn.datax.common.base.BaseService;
 import cn.datax.service.data.metadata.api.entity.MetadataColumnEntity;
 import cn.datax.service.data.metadata.api.query.MetadataColumnQuery;
 import cn.datax.service.data.metadata.api.vo.MetadataTreeVo;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 
 import java.util.List;
 
@@ -29,4 +31,8 @@ public interface MetadataColumnService extends BaseService<MetadataColumnEntity>
     void deleteMetadataColumnBatch(List<String> ids);
 
     List<MetadataTreeVo> getDataMetadataTree(String level, MetadataColumnQuery metadataColumnQuery);
+
+    List<MetadataColumnEntity> getDataMetadataColumnList(MetadataColumnQuery metadataColumnQuery);
+
+    <E extends IPage<MetadataColumnEntity>> E pageWithAuth(E page, Wrapper<MetadataColumnEntity> queryWrapper);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/MetadataSourceService.java

@@ -7,6 +7,8 @@ import cn.datax.common.database.core.DbTable;
 import cn.datax.service.data.metadata.api.dto.MetadataSourceDto;
 import cn.datax.service.data.metadata.api.entity.MetadataSourceEntity;
 import com.aspose.words.Document;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 
 import java.util.List;
 
@@ -43,4 +45,8 @@ public interface MetadataSourceService extends BaseService<MetadataSourceEntity>
     Document wordMetadata(String id) throws Exception;
 
     void refreshMetadata();
+
+    List<MetadataSourceEntity> getMetadataSourceList();
+
+    <E extends IPage<MetadataSourceEntity>> E pageWithAuth(E page, Wrapper<MetadataSourceEntity> queryWrapper);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/MetadataTableService.java

@@ -3,6 +3,9 @@ package cn.datax.service.data.metadata.service;
 import cn.datax.service.data.metadata.api.entity.MetadataTableEntity;
 import cn.datax.service.data.metadata.api.dto.MetadataTableDto;
 import cn.datax.common.base.BaseService;
+import cn.datax.service.data.metadata.api.query.MetadataTableQuery;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 
 import java.util.List;
 
@@ -25,4 +28,8 @@ public interface MetadataTableService extends BaseService<MetadataTableEntity> {
     void deleteMetadataTableById(String id);
 
     void deleteMetadataTableBatch(List<String> ids);
+
+    List<MetadataTableEntity> getDataMetadataTableList(MetadataTableQuery metadataTableQuery);
+
+    <E extends IPage<MetadataTableEntity>> E pageWithAuth(E page, Wrapper<MetadataTableEntity> queryWrapper);
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/impl/MetadataAuthorizeServiceImpl.java

 package cn.datax.service.data.metadata.service.impl;
 
+import cn.datax.common.core.RedisConstant;
+import cn.datax.common.redis.service.RedisService;
 import cn.datax.service.data.metadata.api.dto.MetadataAuthorizeDto;
 import cn.datax.service.data.metadata.api.entity.MetadataAuthorizeEntity;
-import cn.datax.service.data.metadata.api.enums.DataLevel;
 import cn.datax.service.data.metadata.service.MetadataAuthorizeService;
 import cn.datax.service.data.metadata.mapstruct.MetadataAuthorizeMapper;
 import cn.datax.service.data.metadata.dao.MetadataAuthorizeDao;
 import cn.datax.common.base.BaseServiceImpl;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -34,6 +37,12 @@ public class MetadataAuthorizeServiceImpl extends BaseServiceImpl<MetadataAuthor
     @Autowired
     private MetadataAuthorizeMapper metadataAuthorizeMapper;
 
+    @Autowired
+    private RedisService redisService;
+
+    @Autowired
+    private RedisTemplate<String, Object> redisTemplate;
+
     @Override
     public List<String> getAuthorizedMetadata(String id) {
         List<MetadataAuthorizeEntity> metadataAuthorizeList = metadataAuthorizeDao.selectList(Wrappers.<MetadataAuthorizeEntity>lambdaQuery().eq(MetadataAuthorizeEntity::getRoleId, id));
@@ -49,9 +58,20 @@ public class MetadataAuthorizeServiceImpl extends BaseServiceImpl<MetadataAuthor
             MetadataAuthorizeEntity metadataAuthorizeEntity = new MetadataAuthorizeEntity();
             metadataAuthorizeEntity.setRoleId(s.getRoleId());
             metadataAuthorizeEntity.setObjectId(s.getObjectId());
-            Integer level = DataLevel.getLevel(s.getObjectType()).getLevel();
-            metadataAuthorizeEntity.setObjectType(String.valueOf(level));
+            metadataAuthorizeEntity.setObjectType(s.getObjectType());
             metadataAuthorizeDao.insert(metadataAuthorizeEntity);
         });
     }
+
+    @Override
+    public void refreshCache() {
+        String authorizeKey = RedisConstant.METADATA_AUTHORIZE_KEY;
+        Boolean hasAuthorizeKey = redisService.hasKey(authorizeKey);
+        if (hasAuthorizeKey) {
+            redisService.del(authorizeKey);
+        }
+        List<MetadataAuthorizeEntity> metadataAuthorizeList = metadataAuthorizeDao.selectList(Wrappers.emptyWrapper());
+        Map<String, List<MetadataAuthorizeEntity>> authorizeListMap = metadataAuthorizeList.stream().collect(Collectors.groupingBy(MetadataAuthorizeEntity::getRoleId));
+        redisTemplate.opsForHash().putAll(authorizeKey, authorizeListMap);
+    }
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/impl/MetadataColumnServiceImpl.java

@@ -2,8 +2,11 @@ package cn.datax.service.data.metadata.service.impl;
 
 import cn.datax.common.core.DataConstant;
 import cn.datax.common.core.RedisConstant;
+import cn.datax.common.exception.DataException;
 import cn.datax.common.redis.service.RedisService;
+import cn.datax.common.utils.SecurityUtil;
 import cn.datax.service.data.metadata.api.dto.MetadataColumnDto;
+import cn.datax.service.data.metadata.api.entity.MetadataAuthorizeEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataColumnEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataSourceEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataTableEntity;
@@ -15,14 +18,14 @@ import cn.datax.service.data.metadata.mapstruct.MetadataColumnMapper;
 import cn.datax.service.data.metadata.dao.MetadataColumnDao;
 import cn.datax.common.base.BaseServiceImpl;
 import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -83,11 +86,23 @@ public class MetadataColumnServiceImpl extends BaseServiceImpl<MetadataColumnDao
 
     @Override
     public List<MetadataTreeVo> getDataMetadataTree(String level, MetadataColumnQuery metadataColumnQuery) {
+        boolean admin = SecurityUtil.isAdmin();
         List<MetadataSourceEntity> sourceList = (List<MetadataSourceEntity>) redisService.get(RedisConstant.METADATA_SOURCE_KEY);
         Stream<MetadataSourceEntity> stream = Optional.ofNullable(sourceList).orElseGet(ArrayList::new).stream().filter(s -> DataConstant.EnableState.ENABLE.getKey().equals(s.getStatus()));
         if (StrUtil.isNotBlank(metadataColumnQuery.getSourceId())) {
             stream = stream.filter(s -> metadataColumnQuery.getSourceId().equals(s.getId()));
         }
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.DATABASE.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
         List<MetadataTreeVo> list = stream.map(m -> {
             MetadataTreeVo tree = new MetadataTreeVo();
             tree.setId(m.getId());
@@ -103,11 +118,23 @@ public class MetadataColumnServiceImpl extends BaseServiceImpl<MetadataColumnDao
     }
 
     private List<MetadataTreeVo> getTableChildrens(String id, String level, String tableId) {
+        boolean admin = SecurityUtil.isAdmin();
         List<MetadataTableEntity> tableList = (List<MetadataTableEntity>) redisService.hget(RedisConstant.METADATA_TABLE_KEY, id);
         Stream<MetadataTableEntity> stream = Optional.ofNullable(tableList).orElseGet(ArrayList::new).stream();
         if (StrUtil.isNotBlank(tableId)) {
             stream = stream.filter(s -> tableId.equals(s.getId()));
         }
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.TABLE.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
         List<MetadataTreeVo> children = stream.map(m -> {
             MetadataTreeVo tree = new MetadataTreeVo();
             tree.setId(m.getId());
@@ -124,9 +151,21 @@ public class MetadataColumnServiceImpl extends BaseServiceImpl<MetadataColumnDao
     }
 
     private List<MetadataTreeVo> getColumnChildrens(String id) {
+        boolean admin = SecurityUtil.isAdmin();
         List<MetadataColumnEntity> columnList = (List<MetadataColumnEntity>) redisService.hget(RedisConstant.METADATA_COLUMN_KEY, id);
-        List<MetadataTreeVo> children = Optional.ofNullable(columnList).orElseGet(ArrayList::new).stream()
-                .map(m -> {
+        Stream<MetadataColumnEntity> stream = Optional.ofNullable(columnList).orElseGet(ArrayList::new).stream();
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.COLUMN.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
+        List<MetadataTreeVo> children = stream.map(m -> {
             MetadataTreeVo tree = new MetadataTreeVo();
             tree.setId(m.getId());
             tree.setType(DataLevel.COLUMN.getKey());
@@ -137,4 +176,36 @@ public class MetadataColumnServiceImpl extends BaseServiceImpl<MetadataColumnDao
         }).collect(Collectors.toList());
         return children;
     }
+
+    @Override
+    public List<MetadataColumnEntity> getDataMetadataColumnList(MetadataColumnQuery metadataColumnQuery) {
+        boolean admin = SecurityUtil.isAdmin();
+        if (StrUtil.isBlank(metadataColumnQuery.getTableId())) {
+            throw new DataException("数据表不能为空");
+        }
+        List<MetadataColumnEntity> columnList = (List<MetadataColumnEntity>) redisService.hget(RedisConstant.METADATA_COLUMN_KEY, metadataColumnQuery.getTableId());
+        Stream<MetadataColumnEntity> stream = Optional.ofNullable(columnList).orElseGet(ArrayList::new).stream();
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.COLUMN.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
+        return stream.collect(Collectors.toList());
+    }
+
+    @Override
+    public <E extends IPage<MetadataColumnEntity>> E pageWithAuth(E page, Wrapper<MetadataColumnEntity> queryWrapper) {
+        boolean admin = SecurityUtil.isAdmin();
+        List<String> roles = new ArrayList<>();
+        if (!admin) {
+            roles = SecurityUtil.getUserRoleIds();
+        }
+        return metadataColumnDao.selectPageWithAuth(page, queryWrapper, roles);
+    }
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/impl/MetadataSourceServiceImpl.java

@@ -14,9 +14,11 @@ import cn.datax.common.redis.service.RedisService;
 import cn.datax.common.utils.SecurityUtil;
 import cn.datax.service.data.metadata.api.dto.DbSchema;
 import cn.datax.service.data.metadata.api.dto.MetadataSourceDto;
+import cn.datax.service.data.metadata.api.entity.MetadataAuthorizeEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataColumnEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataSourceEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataTableEntity;
+import cn.datax.service.data.metadata.api.enums.DataLevel;
 import cn.datax.service.data.metadata.async.AsyncTask;
 import cn.datax.service.data.metadata.dao.MetadataColumnDao;
 import cn.datax.service.data.metadata.dao.MetadataSourceDao;
@@ -30,7 +32,9 @@ import com.aspose.words.net.System.Data.DataRelation;
 import com.aspose.words.net.System.Data.DataRow;
 import com.aspose.words.net.System.Data.DataSet;
 import com.aspose.words.net.System.Data.DataTable;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.io.ClassPathResource;
@@ -40,9 +44,9 @@ import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.io.InputStream;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * <p>
@@ -102,6 +106,36 @@ public class MetadataSourceServiceImpl extends BaseServiceImpl<MetadataSourceDao
     }
 
     @Override
+    public List<MetadataSourceEntity> getMetadataSourceList() {
+        boolean admin = SecurityUtil.isAdmin();
+        List<MetadataSourceEntity> sourceList = (List<MetadataSourceEntity>) redisService.get(RedisConstant.METADATA_SOURCE_KEY);
+        Stream<MetadataSourceEntity> stream = Optional.ofNullable(sourceList).orElseGet(ArrayList::new).stream()
+                .filter(s -> DataConstant.EnableState.ENABLE.getKey().equals(s.getStatus()));
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.DATABASE.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
+        return stream.collect(Collectors.toList());
+    }
+
+    @Override
+    public <E extends IPage<MetadataSourceEntity>> E pageWithAuth(E page, Wrapper<MetadataSourceEntity> queryWrapper) {
+        boolean admin = SecurityUtil.isAdmin();
+        List<String> roles = new ArrayList<>();
+        if (!admin) {
+            roles = SecurityUtil.getUserRoleIds();
+        }
+        return metadataSourceDao.selectPageWithAuth(page, queryWrapper, roles);
+    }
+
+    @Override
     @Transactional(rollbackFor = Exception.class)
     public void deleteMetadataSourceById(String id) {
         metadataSourceDao.deleteById(id);

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/java/cn/datax/service/data/metadata/service/impl/MetadataTableServiceImpl.java

 package cn.datax.service.data.metadata.service.impl;
 
+import cn.datax.common.core.RedisConstant;
+import cn.datax.common.exception.DataException;
+import cn.datax.common.redis.service.RedisService;
+import cn.datax.common.utils.SecurityUtil;
+import cn.datax.service.data.metadata.api.entity.MetadataAuthorizeEntity;
 import cn.datax.service.data.metadata.api.entity.MetadataTableEntity;
 import cn.datax.service.data.metadata.api.dto.MetadataTableDto;
+import cn.datax.service.data.metadata.api.enums.DataLevel;
+import cn.datax.service.data.metadata.api.query.MetadataTableQuery;
 import cn.datax.service.data.metadata.service.MetadataTableService;
 import cn.datax.service.data.metadata.mapstruct.MetadataTableMapper;
 import cn.datax.service.data.metadata.dao.MetadataTableDao;
 import cn.datax.common.base.BaseServiceImpl;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * <p>
@@ -31,6 +43,9 @@ public class MetadataTableServiceImpl extends BaseServiceImpl<MetadataTableDao,
     @Autowired
     private MetadataTableMapper metadataTableMapper;
 
+    @Autowired
+    private RedisService redisService;
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public MetadataTableEntity saveMetadataTable(MetadataTableDto metadataTableDto) {
@@ -64,4 +79,36 @@ public class MetadataTableServiceImpl extends BaseServiceImpl<MetadataTableDao,
     public void deleteMetadataTableBatch(List<String> ids) {
         metadataTableDao.deleteBatchIds(ids);
     }
+
+    @Override
+    public List<MetadataTableEntity> getDataMetadataTableList(MetadataTableQuery metadataTableQuery) {
+        boolean admin = SecurityUtil.isAdmin();
+        if (StrUtil.isBlank(metadataTableQuery.getSourceId())) {
+            throw new DataException("数据源不能为空");
+        }
+        List<MetadataTableEntity> tableList = (List<MetadataTableEntity>) redisService.hget(RedisConstant.METADATA_TABLE_KEY, metadataTableQuery.getSourceId());
+        Stream<MetadataTableEntity> stream = Optional.ofNullable(tableList).orElseGet(ArrayList::new).stream();
+        if (!admin) {
+            Set<String> set = new HashSet<>();
+            List<String> roleIds = SecurityUtil.getUserRoleIds();
+            roleIds.stream().forEach(role -> {
+                List<MetadataAuthorizeEntity> list = (List<MetadataAuthorizeEntity>) redisService.hget(RedisConstant.METADATA_AUTHORIZE_KEY, role);
+                set.addAll(Optional.ofNullable(list).orElseGet(ArrayList::new).stream()
+                        .filter(s -> Objects.equals(DataLevel.TABLE.getKey(), s.getObjectType()))
+                        .map(s -> s.getObjectId()).collect(Collectors.toSet()));
+            });
+            stream = stream.filter(s -> set.contains(s.getId()));
+        }
+        return stream.collect(Collectors.toList());
+    }
+
+    @Override
+    public <E extends IPage<MetadataTableEntity>> E pageWithAuth(E page, Wrapper<MetadataTableEntity> queryWrapper) {
+        boolean admin = SecurityUtil.isAdmin();
+        List<String> roles = new ArrayList<>();
+        if (!admin) {
+            roles = SecurityUtil.getUserRoleIds();
+        }
+        return metadataTableDao.selectPageWithAuth(page, queryWrapper, roles);
+    }
 }

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/resources/mapper/MetadataColumnMapper.xml

@@ -36,13 +36,24 @@
         ${alias}.source_id, ${alias}.table_id, ${alias}.column_name, ${alias}.column_comment, ${alias}.column_key, ${alias}.column_nullable, ${alias}.column_position, ${alias}.data_type, ${alias}.data_length, ${alias}.data_precision, ${alias}.data_scale, ${alias}.data_default
     </sql>
 
-    <select id="selectPage" resultMap="ExtendResultMap">
+    <select id="selectPageWithAuth" resultMap="ExtendResultMap">
         SELECT s.source_name, t.table_name, t.table_comment,
         <include refid="Column_Column_List"><property name="alias" value="c"/></include>
         FROM metadata_column c
         LEFT JOIN metadata_source s ON s.id = c.source_id
         LEFT JOIN metadata_table t ON t.id = c.table_id
+        <trim prefix="WHERE" prefixOverrides="WHERE |AND |OR ">
             ${ew.customSqlSegment}
+            <if test="roles != null and roles.size > 0">
+                AND EXISTS (
+                SELECT 1 FROM metadata_authorize auth WHERE auth.object_id = c.id AND auth.object_type = 'column'
+                AND auth.role_id IN
+                <foreach collection="roles" index="index" item="item" open="(" separator="," close=")">
+                    #{item}
+                </foreach>
+                )
+            </if>
+        </trim>
     </select>
 
 </mapper>

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/resources/mapper/MetadataSourceMapper.xml

@@ -60,11 +60,22 @@
         ${ew.customSqlSegment}
     </select>
 
-    <select id="selectPage" resultMap="BaseResultMap">
+    <select id="selectPageWithAuth" resultMap="BaseResultMap">
         SELECT
-        <include refid="Base_Column_List"></include>
-        FROM metadata_source
+        <include refid="Source_Column_List"><property name="alias" value="s"/></include>
+        FROM metadata_source s
+        <trim prefix="WHERE" prefixOverrides="WHERE |AND |OR ">
             ${ew.customSqlSegment}
+            <if test="roles != null and roles.size > 0">
+                AND EXISTS (
+                    SELECT 1 FROM metadata_authorize auth WHERE auth.object_id = s.id AND auth.object_type = 'database'
+                    AND auth.role_id IN
+                    <foreach collection="roles" index="index" item="item" open="(" separator="," close=")">
+                        #{item}
+                    </foreach>
+                )
+            </if>
+        </trim>
     </select>
 
 </mapper>

datax-modules/data-metadata-service-parent/data-metadata-service/src/main/resources/mapper/MetadataTableMapper.xml

@@ -25,12 +25,23 @@
         ${alias}.source_id, ${alias}.table_name, ${alias}.table_comment
     </sql>
 
-    <select id="selectPage" resultMap="ExtendResultMap">
+    <select id="selectPageWithAuth" resultMap="ExtendResultMap">
         SELECT s.source_name,
         <include refid="Table_Column_List"><property name="alias" value="t"/></include>
         FROM metadata_table t
         LEFT JOIN metadata_source s ON s.id = t.source_id
+        <trim prefix="WHERE" prefixOverrides="WHERE |AND |OR ">
             ${ew.customSqlSegment}
+            <if test="roles != null and roles.size > 0">
+                AND EXISTS (
+                SELECT 1 FROM metadata_authorize auth WHERE auth.object_id = t.id AND auth.object_type = 'table'
+                AND auth.role_id IN
+                <foreach collection="roles" index="index" item="item" open="(" separator="," close=")">
+                    #{item}
+                </foreach>
+                )
+            </if>
+        </trim>
     </select>
 
 </mapper>

datax-ui/src/api/metadata/dataauthorize.js

 import request from '@/utils/request'
 
+// 刷新参数缓存
+export function refreshAuthorize() {
+  return request({
+    url: '/data/metadata/authorizes/refresh',
+    method: 'get'
+  })
+}
+
 export function getAuthorizedMetadata(id) {
   return request({
     url: '/data/metadata/authorizes/getAuthorizedMetadata/' + id,

datax-ui/src/views/metadata/dataauthorize/index.vue

@@ -75,7 +75,7 @@
 <script>
 import { listRole } from '@/api/system/role'
 import { getDataMetadataTree } from '@/api/metadata/datacolumn'
-import { getAuthorizedMetadata, metadataAuthorize } from '@/api/metadata/dataauthorize'
+import { getAuthorizedMetadata, metadataAuthorize, refreshAuthorize } from '@/api/metadata/dataauthorize'
 
 export default {
   name: 'DataAuthorize',
@@ -162,7 +162,15 @@ export default {
         }
       })
     },
-    handleCacheRefresh() {}
+    handleCacheRefresh() {
+      refreshAuthorize().then(response => {
+        if (response.success) {
+          this.$message.success('刷新缓存成功')
+        } else {
+          this.$message.error('刷新缓存失败')
+        }
+      })
+    }
   }
 }
 </script>

datax-ui/src/views/metadata/datasearch/SourcePane.vue

 <template>
   <ul class="list-group">
     <li v-for="(item, index) in data" :key="index" class="list-group-item">
-      <span class="list-group-item-heading">{{item.sourceName}}
-        <el-badge v-if="item.isSync === '0'" value="未同步" type="danger"/>
-        <el-badge v-if="item.isSync === '1'" value="已同步" type="success"/>
-      </span>
-      <p class="list-group-item-text">数据源类型: {{item.dbTypeName}}</p>
+      <span class="list-group-item-heading">{{ item.sourceName }}</span>
     </li>
   </ul>
 </template>
@@ -20,25 +16,6 @@ export default {
         return []
       }
     }
-  },
-  data() {
-    return {
-      // 数据源类型数据字典
-      dbTypeOptions: []
-    }
-  },
-  created() {
-    this.getDicts('data_db_type').then(response => {
-      if (response.success) {
-        this.dbTypeOptions = response.data
-        this.data.map(d => {
-          const item = this.dbTypeOptions.find((item, index, arr) => {
-            return item.itemText === d.dbType
-          })
-          d.dbTypeName = item ? item.itemValue : ''
-        })
-      }
-    })
   }
 }
 </script>