dongjunchuan/de
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(数据源): 数据集行权限

Browse Source
This commit is contained in:
taojinlong 2021-12-10 23:20:17 +08:00
parent 94cb9b45e6
commit 1e60188abd
19 changed files with 115 additions and 1627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
backend/pom.xml
View File

@ -207,7 +207,7 @@
<dependency>
<groupId>io.dataease</groupId>
<artifactId>dataease-plugin-interface</artifactId>
<version>1.5</version>
<version>1.6</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
@ -387,34 +387,34 @@
</dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<executions>
<execution>
<?m2e execute onConfiguration?>
<id>main-class-placement</id>
<phase>generate-resources</phase>
<configuration>
<target>
<move todir="src/main/resources/static">
<fileset dir="../frontend/dist">
<exclude name="*.html"/>
</fileset>
</move>
<move todir="src/main/resources/templates">
<fileset dir="../frontend/dist">
<include name="*.html"/>
</fileset>
</move>
</target>
</configuration>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
<!-- <plugin>-->
<!-- <groupId>org.apache.maven.plugins</groupId>-->
<!-- <artifactId>maven-antrun-plugin</artifactId>-->
<!-- <executions>-->
<!-- <execution>-->
<!-- <?m2e execute onConfiguration?>-->
<!-- <id>main-class-placement</id>-->
<!-- <phase>generate-resources</phase>-->
<!-- <configuration>-->
<!-- <target>-->
<!-- <move todir="src/main/resources/static">-->
<!-- <fileset dir="../frontend/dist">-->
<!-- <exclude name="*.html"/>-->
<!-- </fileset>-->
<!-- </move>-->
<!-- <move todir="src/main/resources/templates">-->
<!-- <fileset dir="../frontend/dist">-->
<!-- <include name="*.html"/>-->
<!-- </fileset>-->
<!-- </move>-->
<!-- </target>-->
<!-- </configuration>-->
<!-- <goals>-->
<!-- <goal>run</goal>-->
<!-- </goals>-->
<!-- </execution>-->
<!-- </executions>-->
<!-- </plugin>-->
</plugins>
</build>

23
backend/src/main/java/io/dataease/base/domain/DatasetRowPermissions.java
View File

@ -1,23 +0,0 @@
package io.dataease.base.domain;
import java.io.Serializable;
import lombok.Data;
@Data
public class DatasetRowPermissions implements Serializable {
private String id;
private String authTargetType;
private Long authTargetId;
private String datasetId;
private String datasetFieldId;
private String filter;
private Long updateTime;
private static final long serialVersionUID = 1L;
}

670
backend/src/main/java/io/dataease/base/domain/DatasetRowPermissionsExample.java
View File

@ -1,670 +0,0 @@
package io.dataease.base.domain;
import java.util.ArrayList;
import java.util.List;
public class DatasetRowPermissionsExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public DatasetRowPermissionsExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(String value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(String value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(String value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(String value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(String value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(String value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdLike(String value) {
addCriterion("id like", value, "id");
return (Criteria) this;
}
public Criteria andIdNotLike(String value) {
addCriterion("id not like", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<String> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<String> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(String value1, String value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(String value1, String value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andAuthTargetTypeIsNull() {
addCriterion("auth_target_type is null");
return (Criteria) this;
}
public Criteria andAuthTargetTypeIsNotNull() {
addCriterion("auth_target_type is not null");
return (Criteria) this;
}
public Criteria andAuthTargetTypeEqualTo(String value) {
addCriterion("auth_target_type =", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeNotEqualTo(String value) {
addCriterion("auth_target_type <>", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeGreaterThan(String value) {
addCriterion("auth_target_type >", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeGreaterThanOrEqualTo(String value) {
addCriterion("auth_target_type >=", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeLessThan(String value) {
addCriterion("auth_target_type <", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeLessThanOrEqualTo(String value) {
addCriterion("auth_target_type <=", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeLike(String value) {
addCriterion("auth_target_type like", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeNotLike(String value) {
addCriterion("auth_target_type not like", value, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeIn(List<String> values) {
addCriterion("auth_target_type in", values, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeNotIn(List<String> values) {
addCriterion("auth_target_type not in", values, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeBetween(String value1, String value2) {
addCriterion("auth_target_type between", value1, value2, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetTypeNotBetween(String value1, String value2) {
addCriterion("auth_target_type not between", value1, value2, "authTargetType");
return (Criteria) this;
}
public Criteria andAuthTargetIdIsNull() {
addCriterion("auth_target_id is null");
return (Criteria) this;
}
public Criteria andAuthTargetIdIsNotNull() {
addCriterion("auth_target_id is not null");
return (Criteria) this;
}
public Criteria andAuthTargetIdEqualTo(Long value) {
addCriterion("auth_target_id =", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdNotEqualTo(Long value) {
addCriterion("auth_target_id <>", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdGreaterThan(Long value) {
addCriterion("auth_target_id >", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdGreaterThanOrEqualTo(Long value) {
addCriterion("auth_target_id >=", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdLessThan(Long value) {
addCriterion("auth_target_id <", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdLessThanOrEqualTo(Long value) {
addCriterion("auth_target_id <=", value, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdIn(List<Long> values) {
addCriterion("auth_target_id in", values, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdNotIn(List<Long> values) {
addCriterion("auth_target_id not in", values, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdBetween(Long value1, Long value2) {
addCriterion("auth_target_id between", value1, value2, "authTargetId");
return (Criteria) this;
}
public Criteria andAuthTargetIdNotBetween(Long value1, Long value2) {
addCriterion("auth_target_id not between", value1, value2, "authTargetId");
return (Criteria) this;
}
public Criteria andDatasetIdIsNull() {
addCriterion("dataset_id is null");
return (Criteria) this;
}
public Criteria andDatasetIdIsNotNull() {
addCriterion("dataset_id is not null");
return (Criteria) this;
}
public Criteria andDatasetIdEqualTo(String value) {
addCriterion("dataset_id =", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdNotEqualTo(String value) {
addCriterion("dataset_id <>", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdGreaterThan(String value) {
addCriterion("dataset_id >", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdGreaterThanOrEqualTo(String value) {
addCriterion("dataset_id >=", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdLessThan(String value) {
addCriterion("dataset_id <", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdLessThanOrEqualTo(String value) {
addCriterion("dataset_id <=", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdLike(String value) {
addCriterion("dataset_id like", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdNotLike(String value) {
addCriterion("dataset_id not like", value, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdIn(List<String> values) {
addCriterion("dataset_id in", values, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdNotIn(List<String> values) {
addCriterion("dataset_id not in", values, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdBetween(String value1, String value2) {
addCriterion("dataset_id between", value1, value2, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetIdNotBetween(String value1, String value2) {
addCriterion("dataset_id not between", value1, value2, "datasetId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdIsNull() {
addCriterion("dataset_field_id is null");
return (Criteria) this;
}
public Criteria andDatasetFieldIdIsNotNull() {
addCriterion("dataset_field_id is not null");
return (Criteria) this;
}
public Criteria andDatasetFieldIdEqualTo(String value) {
addCriterion("dataset_field_id =", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdNotEqualTo(String value) {
addCriterion("dataset_field_id <>", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdGreaterThan(String value) {
addCriterion("dataset_field_id >", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdGreaterThanOrEqualTo(String value) {
addCriterion("dataset_field_id >=", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdLessThan(String value) {
addCriterion("dataset_field_id <", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdLessThanOrEqualTo(String value) {
addCriterion("dataset_field_id <=", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdLike(String value) {
addCriterion("dataset_field_id like", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdNotLike(String value) {
addCriterion("dataset_field_id not like", value, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdIn(List<String> values) {
addCriterion("dataset_field_id in", values, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdNotIn(List<String> values) {
addCriterion("dataset_field_id not in", values, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdBetween(String value1, String value2) {
addCriterion("dataset_field_id between", value1, value2, "datasetFieldId");
return (Criteria) this;
}
public Criteria andDatasetFieldIdNotBetween(String value1, String value2) {
addCriterion("dataset_field_id not between", value1, value2, "datasetFieldId");
return (Criteria) this;
}
public Criteria andFilterIsNull() {
addCriterion("`filter` is null");
return (Criteria) this;
}
public Criteria andFilterIsNotNull() {
addCriterion("`filter` is not null");
return (Criteria) this;
}
public Criteria andFilterEqualTo(String value) {
addCriterion("`filter` =", value, "filter");
return (Criteria) this;
}
public Criteria andFilterNotEqualTo(String value) {
addCriterion("`filter` <>", value, "filter");
return (Criteria) this;
}
public Criteria andFilterGreaterThan(String value) {
addCriterion("`filter` >", value, "filter");
return (Criteria) this;
}
public Criteria andFilterGreaterThanOrEqualTo(String value) {
addCriterion("`filter` >=", value, "filter");
return (Criteria) this;
}
public Criteria andFilterLessThan(String value) {
addCriterion("`filter` <", value, "filter");
return (Criteria) this;
}
public Criteria andFilterLessThanOrEqualTo(String value) {
addCriterion("`filter` <=", value, "filter");
return (Criteria) this;
}
public Criteria andFilterLike(String value) {
addCriterion("`filter` like", value, "filter");
return (Criteria) this;
}
public Criteria andFilterNotLike(String value) {
addCriterion("`filter` not like", value, "filter");
return (Criteria) this;
}
public Criteria andFilterIn(List<String> values) {
addCriterion("`filter` in", values, "filter");
return (Criteria) this;
}
public Criteria andFilterNotIn(List<String> values) {
addCriterion("`filter` not in", values, "filter");
return (Criteria) this;
}
public Criteria andFilterBetween(String value1, String value2) {
addCriterion("`filter` between", value1, value2, "filter");
return (Criteria) this;
}
public Criteria andFilterNotBetween(String value1, String value2) {
addCriterion("`filter` not between", value1, value2, "filter");
return (Criteria) this;
}
public Criteria andUpdateTimeIsNull() {
addCriterion("update_time is null");
return (Criteria) this;
}
public Criteria andUpdateTimeIsNotNull() {
addCriterion("update_time is not null");
return (Criteria) this;
}
public Criteria andUpdateTimeEqualTo(Long value) {
addCriterion("update_time =", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeNotEqualTo(Long value) {
addCriterion("update_time <>", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeGreaterThan(Long value) {
addCriterion("update_time >", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeGreaterThanOrEqualTo(Long value) {
addCriterion("update_time >=", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeLessThan(Long value) {
addCriterion("update_time <", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeLessThanOrEqualTo(Long value) {
addCriterion("update_time <=", value, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeIn(List<Long> values) {
addCriterion("update_time in", values, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeNotIn(List<Long> values) {
addCriterion("update_time not in", values, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeBetween(Long value1, Long value2) {
addCriterion("update_time between", value1, value2, "updateTime");
return (Criteria) this;
}
public Criteria andUpdateTimeNotBetween(Long value1, Long value2) {
addCriterion("update_time not between", value1, value2, "updateTime");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

30
backend/src/main/java/io/dataease/base/mapper/DatasetRowPermissionsMapper.java
View File

@ -1,30 +0,0 @@
package io.dataease.base.mapper;
import io.dataease.base.domain.DatasetRowPermissions;
import io.dataease.base.domain.DatasetRowPermissionsExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface DatasetRowPermissionsMapper {
long countByExample(DatasetRowPermissionsExample example);
int deleteByExample(DatasetRowPermissionsExample example);
int deleteByPrimaryKey(String id);
int insert(DatasetRowPermissions record);
int insertSelective(DatasetRowPermissions record);
List<DatasetRowPermissions> selectByExample(DatasetRowPermissionsExample example);
DatasetRowPermissions selectByPrimaryKey(String id);
int updateByExampleSelective(@Param("record") DatasetRowPermissions record, @Param("example") DatasetRowPermissionsExample example);
int updateByExample(@Param("record") DatasetRowPermissions record, @Param("example") DatasetRowPermissionsExample example);
int updateByPrimaryKeySelective(DatasetRowPermissions record);
int updateByPrimaryKey(DatasetRowPermissions record);
}

243
backend/src/main/java/io/dataease/base/mapper/DatasetRowPermissionsMapper.xml
View File

@ -1,243 +0,0 @@
<?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="io.dataease.base.mapper.DatasetRowPermissionsMapper">
<resultMap id="BaseResultMap" type="io.dataease.base.domain.DatasetRowPermissions">
<id column="id" jdbcType="VARCHAR" property="id" />
<result column="auth_target_type" jdbcType="VARCHAR" property="authTargetType" />
<result column="auth_target_id" jdbcType="BIGINT" property="authTargetId" />
<result column="dataset_id" jdbcType="VARCHAR" property="datasetId" />
<result column="dataset_field_id" jdbcType="VARCHAR" property="datasetFieldId" />
<result column="filter" jdbcType="VARCHAR" property="filter" />
<result column="update_time" jdbcType="BIGINT" property="updateTime" />
</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>
</where>
</sql>
<sql id="Update_By_Example_Where_Clause">
<where>
<foreach collection="example.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>
</where>
</sql>
<sql id="Base_Column_List">
id, auth_target_type, auth_target_id, dataset_id, dataset_field_id, `filter`, update_time
</sql>
<select id="selectByExample" parameterType="io.dataease.base.domain.DatasetRowPermissionsExample" resultMap="BaseResultMap">
select
<if test="distinct">
distinct
</if>
<include refid="Base_Column_List" />
from dataset_row_permissions
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
<if test="orderByClause != null">
order by ${orderByClause}
</if>
</select>
<select id="selectByPrimaryKey" parameterType="java.lang.String" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from dataset_row_permissions
where id = #{id,jdbcType=VARCHAR}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.String">
delete from dataset_row_permissions
where id = #{id,jdbcType=VARCHAR}
</delete>
<delete id="deleteByExample" parameterType="io.dataease.base.domain.DatasetRowPermissionsExample">
delete from dataset_row_permissions
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</delete>
<insert id="insert" parameterType="io.dataease.base.domain.DatasetRowPermissions">
insert into dataset_row_permissions (id, auth_target_type, auth_target_id,
dataset_id, dataset_field_id, `filter`,
update_time)
values (#{id,jdbcType=VARCHAR}, #{authTargetType,jdbcType=VARCHAR}, #{authTargetId,jdbcType=BIGINT},
#{datasetId,jdbcType=VARCHAR}, #{datasetFieldId,jdbcType=VARCHAR}, #{filter,jdbcType=VARCHAR},
#{updateTime,jdbcType=BIGINT})
</insert>
<insert id="insertSelective" parameterType="io.dataease.base.domain.DatasetRowPermissions">
insert into dataset_row_permissions
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="authTargetType != null">
auth_target_type,
</if>
<if test="authTargetId != null">
auth_target_id,
</if>
<if test="datasetId != null">
dataset_id,
</if>
<if test="datasetFieldId != null">
dataset_field_id,
</if>
<if test="filter != null">
`filter`,
</if>
<if test="updateTime != null">
update_time,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=VARCHAR},
</if>
<if test="authTargetType != null">
#{authTargetType,jdbcType=VARCHAR},
</if>
<if test="authTargetId != null">
#{authTargetId,jdbcType=BIGINT},
</if>
<if test="datasetId != null">
#{datasetId,jdbcType=VARCHAR},
</if>
<if test="datasetFieldId != null">
#{datasetFieldId,jdbcType=VARCHAR},
</if>
<if test="filter != null">
#{filter,jdbcType=VARCHAR},
</if>
<if test="updateTime != null">
#{updateTime,jdbcType=BIGINT},
</if>
</trim>
</insert>
<select id="countByExample" parameterType="io.dataease.base.domain.DatasetRowPermissionsExample" resultType="java.lang.Long">
select count(*) from dataset_row_permissions
<if test="_parameter != null">
<include refid="Example_Where_Clause" />
</if>
</select>
<update id="updateByExampleSelective" parameterType="map">
update dataset_row_permissions
<set>
<if test="record.id != null">
id = #{record.id,jdbcType=VARCHAR},
</if>
<if test="record.authTargetType != null">
auth_target_type = #{record.authTargetType,jdbcType=VARCHAR},
</if>
<if test="record.authTargetId != null">
auth_target_id = #{record.authTargetId,jdbcType=BIGINT},
</if>
<if test="record.datasetId != null">
dataset_id = #{record.datasetId,jdbcType=VARCHAR},
</if>
<if test="record.datasetFieldId != null">
dataset_field_id = #{record.datasetFieldId,jdbcType=VARCHAR},
</if>
<if test="record.filter != null">
`filter` = #{record.filter,jdbcType=VARCHAR},
</if>
<if test="record.updateTime != null">
update_time = #{record.updateTime,jdbcType=BIGINT},
</if>
</set>
<if test="_parameter != null">
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByExample" parameterType="map">
update dataset_row_permissions
set id = #{record.id,jdbcType=VARCHAR},
auth_target_type = #{record.authTargetType,jdbcType=VARCHAR},
auth_target_id = #{record.authTargetId,jdbcType=BIGINT},
dataset_id = #{record.datasetId,jdbcType=VARCHAR},
dataset_field_id = #{record.datasetFieldId,jdbcType=VARCHAR},
`filter` = #{record.filter,jdbcType=VARCHAR},
update_time = #{record.updateTime,jdbcType=BIGINT}
<if test="_parameter != null">
<include refid="Update_By_Example_Where_Clause" />
</if>
</update>
<update id="updateByPrimaryKeySelective" parameterType="io.dataease.base.domain.DatasetRowPermissions">
update dataset_row_permissions
<set>
<if test="authTargetType != null">
auth_target_type = #{authTargetType,jdbcType=VARCHAR},
</if>
<if test="authTargetId != null">
auth_target_id = #{authTargetId,jdbcType=BIGINT},
</if>
<if test="datasetId != null">
dataset_id = #{datasetId,jdbcType=VARCHAR},
</if>
<if test="datasetFieldId != null">
dataset_field_id = #{datasetFieldId,jdbcType=VARCHAR},
</if>
<if test="filter != null">
`filter` = #{filter,jdbcType=VARCHAR},
</if>
<if test="updateTime != null">
update_time = #{updateTime,jdbcType=BIGINT},
</if>
</set>
where id = #{id,jdbcType=VARCHAR}
</update>
<update id="updateByPrimaryKey" parameterType="io.dataease.base.domain.DatasetRowPermissions">
update dataset_row_permissions
set auth_target_type = #{authTargetType,jdbcType=VARCHAR},
auth_target_id = #{authTargetId,jdbcType=BIGINT},
dataset_id = #{datasetId,jdbcType=VARCHAR},
dataset_field_id = #{datasetFieldId,jdbcType=VARCHAR},
`filter` = #{filter,jdbcType=VARCHAR},
update_time = #{updateTime,jdbcType=BIGINT}
where id = #{id,jdbcType=VARCHAR}
</update>
</mapper>

11
backend/src/main/java/io/dataease/base/mapper/ext/ExtDataSetTableMapper.java
View File

@ -1,10 +1,6 @@
package io.dataease.base.mapper.ext;
import io.dataease.base.domain.DatasetRowPermissions;
import io.dataease.base.mapper.ext.query.GridExample;
import io.dataease.controller.request.dataset.DataSetTableRequest;
import io.dataease.controller.sys.response.RoleUserItem;
import io.dataease.dto.dataset.DataSetRowPermissionsDTO;
import io.dataease.dto.dataset.DataSetTableDTO;
import java.util.List;
@ -14,11 +10,4 @@ public interface ExtDataSetTableMapper {
DataSetTableDTO searchOne(DataSetTableRequest request);
List<DataSetRowPermissionsDTO> searchRowPermissons(GridExample example);
List<RoleUserItem> searchAuthUsers(DatasetRowPermissions example);
List<RoleUserItem> searchAuthRoles(DatasetRowPermissions example);
List<RoleUserItem> searchAuthDepts(DatasetRowPermissions example);
}

57
backend/src/main/java/io/dataease/base/mapper/ext/ExtDataSetTableMapper.xml
View File

@ -7,9 +7,6 @@
<result column="privileges" property="privileges"/>
</resultMap>
<resultMap id="RowPermissonsDTO" type="io.dataease.dto.dataset.DataSetRowPermissionsDTO"
extends="io.dataease.base.mapper.DatasetRowPermissionsMapper.BaseResultMap">
</resultMap>
<resultMap id="roleItemMap" type="io.dataease.controller.sys.response.RoleUserItem">
<id property="id" column="id"/>
@ -103,58 +100,4 @@
ORDER BY CONVERT(`name` using gbk)
</select>
<select id="searchRowPermissons" resultMap="RowPermissonsDTO" parameterType="io.dataease.base.mapper.ext.query.GridExample">
SELECT dataset_table.name as datasetName, dataset_table_field.name as fieldName, dataset_row_permissions.*
FROM dataset_row_permissions
left join dataset_table on dataset_table.id=dataset_row_permissions.dataset_id
left join dataset_table_field on dataset_table_field.id=dataset_row_permissions.dataset_field_id
<if test="_parameter != null">
<include refid="io.dataease.base.mapper.ext.query.GridSql.gridCondition" />
</if>
<if test="orderByClause != null">
order by ${orderByClause}
</if>
<if test="orderByClause == null">
order by dataset_row_permissions.update_time desc
</if>
</select>
<select id="searchAuthUsers" resultMap="roleItemMap">
SELECT sys_user.user_id as id, sys_user.username as name
FROM sys_auth
left join sys_auth_detail on sys_auth.id=sys_auth_detail.auth_id
left join sys_user on sys_user.user_id=sys_auth.auth_target
where sys_auth.auth_target_type='user'
and sys_auth.auth_source_type='dataset'
and sys_auth.auth_source=#{datasetId,jdbcType=VARCHAR}
and sys_auth_detail.privilege_type=1
and sys_auth_detail.privilege_value=1;
</select>
<select id="searchAuthRoles" resultMap="roleItemMap">
SELECT sys_role.role_id as id, sys_role.name as name
FROM sys_auth
left join sys_auth_detail on sys_auth.id=sys_auth_detail.auth_id
left join sys_role on sys_role.role_id=sys_auth.auth_target
where sys_auth.auth_target_type='role'
and sys_auth.auth_source_type='dataset'
and sys_auth.auth_source=#{datasetId,jdbcType=VARCHAR}
and sys_auth_detail.privilege_type=1
and sys_auth_detail.privilege_value=1;
</select>
<select id="searchAuthDepts" resultMap="roleItemMap">
SELECT sys_dept.dept_id as id, sys_dept.name as name
FROM sys_auth
left join sys_auth_detail on sys_auth.id=sys_auth_detail.auth_id
left join sys_dept on sys_dept.dept_id=sys_auth.auth_target
where sys_auth.auth_target_type='dept'
and sys_auth.auth_source_type='dataset'
and sys_auth.auth_source=#{datasetId,jdbcType=VARCHAR}
and sys_auth_detail.privilege_type=1
and sys_auth_detail.privilege_value=1;
</select>
</mapper>

2
backend/src/main/java/io/dataease/commons/license/DefaultLicenseService.java
View File

@ -19,7 +19,7 @@ public class DefaultLicenseService {
private InnerLicenseService innerLicenseService;
private static final String LICENSE_ID = "fit2cloud_license";
private static final String validatorUtil = "/usr/bin/validator";
private static final String validatorUtil = "/usr/local/bin/validator";
private static final String product = "DataEase";
public F2CLicenseResponse validateLicense(String product, String licenseKey) {

60
backend/src/main/java/io/dataease/controller/dataset/DataSetTableRowPermissionsController.java
View File

@ -1,60 +0,0 @@
package io.dataease.controller.dataset;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.xiaoymin.knife4j.annotations.ApiSupport;
import io.dataease.base.domain.DatasetRowPermissions;
import io.dataease.commons.utils.PageUtils;
import io.dataease.commons.utils.Pager;
import io.dataease.controller.sys.base.BaseGridRequest;
import io.dataease.dto.dataset.DataSetRowPermissionsDTO;
import io.dataease.service.dataset.DataSetTableRowPermissionsService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
@Api(tags = "数据集：数据集行权限")
@ApiSupport(order = 90)
@RestController
@RequestMapping("dataset/rowPermissions")
public class DataSetTableRowPermissionsController {
@Resource
private DataSetTableRowPermissionsService dataSetTableRowPermissionsService;
@ApiOperation("保存")
@PostMapping("save")
public void save(@RequestBody DatasetRowPermissions datasetRowPermissions) throws Exception {
dataSetTableRowPermissionsService.save(datasetRowPermissions);
}
@ApiOperation("分页查询")
@PostMapping("/pageList/{datasetId}/{goPage}/{pageSize}")
public Pager<List<DataSetRowPermissionsDTO>> rowPermissions(@PathVariable String datasetId, @PathVariable int goPage, @PathVariable int pageSize, @RequestBody BaseGridRequest request) {
Page<Object> page = PageHelper.startPage(goPage, pageSize, true);
return PageUtils.setPageInfo(page, dataSetTableRowPermissionsService.searchRowPermissions(request, datasetId));
}
@ApiOperation("有权限的对象")
@PostMapping("/authObjs")
public List<Object> authObjs(@RequestBody DataSetRowPermissionsDTO request) {
return (List<Object>) dataSetTableRowPermissionsService.authObjs(request);
}
@ApiOperation("详情")
@PostMapping("/dataSetRowPermissionInfo")
public DataSetRowPermissionsDTO dataSetRowPermissionInfo(@RequestBody DataSetRowPermissionsDTO request) {
return dataSetTableRowPermissionsService.dataSetRowPermissionInfo(request);
}
@ApiOperation("删除")
@PostMapping("/delete/{id}")
public void dataSetRowPermissionInfo(@PathVariable String id) {
dataSetTableRowPermissionsService.delete(id);
}
}

21
backend/src/main/java/io/dataease/dto/dataset/DataSetRowPermissionsDTO.java
View File

@ -1,21 +0,0 @@
package io.dataease.dto.dataset;
import io.dataease.base.domain.DatasetRowPermissions;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
/**
* @Author gin
* @Date 2021/3/9 3:19 下午
*/
@Getter
@Setter
public class DataSetRowPermissionsDTO extends DatasetRowPermissions {
@ApiModelProperty("数据集名称")
private String datasetName;
@ApiModelProperty("字段名称")
private String fieldName;
@ApiModelProperty("授权对象名称")
private String authTargetName;
}

39
backend/src/main/java/io/dataease/plugins/server/RowPermissionsController.java Normal file
View File

@ -0,0 +1,39 @@
package io.dataease.plugins.server;
import io.dataease.plugins.config.SpringContextUtil;
import io.dataease.plugins.xpack.auth.dto.request.DataSetRowPermissionsDTO;
import io.dataease.plugins.xpack.auth.dto.request.DatasetRowPermissions;
import io.dataease.plugins.xpack.auth.dto.response.XpackSysAuthDetailDTO;
import io.dataease.plugins.xpack.auth.service.RowPermissionService;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("plugin/dataset/rowPermissions")
public class RowPermissionsController {
@ApiOperation("保存")
@PostMapping("save")
public void save(@RequestBody DatasetRowPermissions datasetRowPermissions) throws Exception {
RowPermissionService rowPermissionService = SpringContextUtil.getBean(RowPermissionService.class);
rowPermissionService.save(datasetRowPermissions);
}
@ApiOperation("分页查询")
@PostMapping("/list")
public List<DataSetRowPermissionsDTO> rowPermissions(@RequestBody XpackSysAuthDetailDTO request) {
RowPermissionService rowPermissionService = SpringContextUtil.getBean(RowPermissionService.class);
return rowPermissionService.searchRowPermissions(request);
}
@ApiOperation("删除")
@GetMapping("/delete/{id}")
public void dataSetRowPermissionInfo(@PathVariable String id) {
RowPermissionService rowPermissionService = SpringContextUtil.getBean(RowPermissionService.class);
rowPermissionService.delete(id);
}
}

13
backend/src/main/java/io/dataease/plugins/server/XAuthServer.java
View File

@ -42,12 +42,13 @@ public class XAuthServer {
public List<XpackSysAuthDetail>authDetailsModel(@PathVariable String authType){
AuthXpackService sysAuthService = SpringContextUtil.getBean(AuthXpackService.class);
List<XpackSysAuthDetail> authDetails = sysAuthService.searchAuthDetailsModel(authType);
// if(authType.equalsIgnoreCase("dataset")){
// XpackSysAuthDetail xpackSysAuthDetail = new XpackSysAuthDetail();
// xpackSysAuthDetail.setPrivilegeName("i18n_auth_row_permission");
// xpackSysAuthDetail.setPrivilegeType(20);
// authDetails.add(3,xpackSysAuthDetail);
// }
if(authType.equalsIgnoreCase("dataset")){
XpackSysAuthDetail xpackSysAuthDetail = new XpackSysAuthDetail();
xpackSysAuthDetail.setPrivilegeName("i18n_auth_row_permission");
xpackSysAuthDetail.setPrivilegeType(20);
xpackSysAuthDetail.setPrivilegeValue(1);
authDetails.add(0,xpackSysAuthDetail);
}
return authDetails;
}

110
backend/src/main/java/io/dataease/service/dataset/DataSetTableRowPermissionsService.java
View File

@ -1,110 +0,0 @@
package io.dataease.service.dataset;
import io.dataease.base.domain.DatasetRowPermissions;
import io.dataease.base.domain.DatasetRowPermissionsExample;
import io.dataease.base.mapper.DatasetRowPermissionsMapper;
import io.dataease.base.mapper.SysDeptMapper;
import io.dataease.base.mapper.SysRoleMapper;
import io.dataease.base.mapper.SysUserMapper;
import io.dataease.base.mapper.ext.ExtDataSetTableMapper;
import io.dataease.base.mapper.ext.query.GridExample;
import io.dataease.commons.utils.AuthUtils;
import io.dataease.controller.sys.base.BaseGridRequest;
import io.dataease.controller.sys.base.ConditionEntity;
import io.dataease.dto.dataset.DataSetRowPermissionsDTO;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
@Service
@Transactional(rollbackFor = Exception.class)
public class DataSetTableRowPermissionsService {
@Resource
private ExtDataSetTableMapper extDataSetTableMapper;
@Resource
private DatasetRowPermissionsMapper datasetRowPermissionsMapper;
@Resource
private SysUserMapper sysUserMapper;
@Resource
private SysRoleMapper sysRoleMapper;
@Resource
private SysDeptMapper sysDeptMapper;
public List<DataSetRowPermissionsDTO> searchRowPermissions(BaseGridRequest request, String datasetId){
List<ConditionEntity> conditionEntities = request.getConditions() == null ? new ArrayList<>() : request.getConditions();
ConditionEntity entity = new ConditionEntity();
entity.setField("dataset_row_permissions.dataset_id");
entity.setOperator("eq");
entity.setValue(datasetId);
conditionEntities.add(entity);
request.setConditions(conditionEntities);
GridExample gridExample = request.convertExample();
gridExample.setExtendCondition(AuthUtils.getUser().getUserId().toString());
return extDataSetTableMapper.searchRowPermissons(gridExample);
}
public List<? extends Object> authObjs(DataSetRowPermissionsDTO request){
switch (request.getAuthTargetType()) {
case "user":
return extDataSetTableMapper.searchAuthUsers(request);
case "role":
return extDataSetTableMapper.searchAuthRoles(request);
case "dept":
return extDataSetTableMapper.searchAuthDepts(request);
default:
return new ArrayList<>();
}
}
public void save(DatasetRowPermissions datasetRowPermissions){
if(StringUtils.isEmpty(datasetRowPermissions.getId())){
datasetRowPermissions.setId(UUID.randomUUID().toString());
datasetRowPermissions.setUpdateTime(System.currentTimeMillis());
datasetRowPermissionsMapper.insert(datasetRowPermissions);
}else {
datasetRowPermissions.setUpdateTime(System.currentTimeMillis());
datasetRowPermissionsMapper.updateByPrimaryKey(datasetRowPermissions);
}
}
public DataSetRowPermissionsDTO dataSetRowPermissionInfo(DataSetRowPermissionsDTO datasetRowPermissions){
switch (datasetRowPermissions.getAuthTargetType()) {
case "user":
datasetRowPermissions.setAuthTargetName(Optional.ofNullable(sysUserMapper.selectByPrimaryKey(datasetRowPermissions.getAuthTargetId())).get().getUsername());
break;
case "role":
datasetRowPermissions.setAuthTargetName(Optional.ofNullable(sysRoleMapper.selectByPrimaryKey(datasetRowPermissions.getAuthTargetId())).get().getName());
break;
case "dept":
datasetRowPermissions.setAuthTargetName(Optional.ofNullable(sysDeptMapper.selectByPrimaryKey(datasetRowPermissions.getAuthTargetId())).get().getName());
break;
default:
break;
}
return datasetRowPermissions;
}
public void delete(String id){
datasetRowPermissionsMapper.deleteByPrimaryKey(id);
}
public List<DatasetRowPermissions> listDatasetRowPermissions(String datasetId, List<Long>authTargetIds, String authTargetType){
if(CollectionUtils.isEmpty(authTargetIds)){
return new ArrayList<>();
}
DatasetRowPermissionsExample example = new DatasetRowPermissionsExample();
example.createCriteria().andDatasetIdEqualTo(datasetId).andAuthTargetTypeEqualTo(authTargetType).andAuthTargetIdIn(authTargetIds);
return datasetRowPermissionsMapper.selectByExample(example);
}
}

29
backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java
View File

@ -19,25 +19,23 @@ import io.dataease.controller.request.dataset.DataSetGroupRequest;
import io.dataease.controller.request.dataset.DataSetTableRequest;
import io.dataease.controller.request.dataset.DataSetTaskRequest;
import io.dataease.controller.response.DataSetDetail;
import io.dataease.commons.constants.DatasourceTypes;
import io.dataease.dto.chart.ChartCustomFilterDTO;
import io.dataease.dto.datasource.TableFiled;
import io.dataease.plugins.config.SpringContextUtil;
import io.dataease.plugins.xpack.auth.dto.request.DatasetRowPermissions;
import io.dataease.plugins.xpack.auth.service.RowPermissionService;
import io.dataease.plugins.xpack.oidc.service.OidcXpackService;
import io.dataease.provider.datasource.DatasourceProvider;
import io.dataease.provider.datasource.JdbcProvider;
import io.dataease.provider.ProviderFactory;
import io.dataease.controller.request.datasource.DatasourceRequest;
import io.dataease.controller.response.DataSetDetail;
import io.dataease.dto.dataset.*;
import io.dataease.dto.dataset.union.UnionDTO;
import io.dataease.dto.dataset.union.UnionItemDTO;
import io.dataease.dto.dataset.union.UnionParamDTO;
import io.dataease.dto.datasource.TableFiled;
import io.dataease.dto.dataset.union.UnionParamDTO;;
import io.dataease.exception.DataEaseException;
import io.dataease.i18n.Translator;
import io.dataease.plugins.loader.ClassloaderResponsity;
import io.dataease.provider.ProviderFactory;
import io.dataease.provider.datasource.DatasourceProvider;
import io.dataease.provider.datasource.JdbcProvider;
import io.dataease.provider.query.DDLProvider;
import io.dataease.provider.query.QueryProvider;
import org.apache.commons.collections4.CollectionUtils;
@ -102,8 +100,6 @@ public class DataSetTableService {
private ExtDataSetGroupMapper extDataSetGroupMapper;
@Resource
private DatasetTableFieldMapper datasetTableFieldMapper;
@Resource
private DataSetTableRowPermissionsService dataSetTableRowPermissionsService;
private static final String lastUpdateTime = "${__last_update_time__}";
private static final String currentUpdateTime = "${__current_update_time__}";
@ -445,9 +441,14 @@ public class DataSetTableService {
private List<DatasetRowPermissions> rowPermissions(String datasetId){
List<DatasetRowPermissions> datasetRowPermissions = new ArrayList<>();
datasetRowPermissions.addAll(dataSetTableRowPermissionsService.listDatasetRowPermissions(datasetId, Collections.singletonList(AuthUtils.getUser().getUserId()), "user"));
datasetRowPermissions.addAll(dataSetTableRowPermissionsService.listDatasetRowPermissions(datasetId, AuthUtils.getUser().getRoles().stream().map(CurrentRoleDto::getId).collect(Collectors.toList()) , "role"));
datasetRowPermissions.addAll(dataSetTableRowPermissionsService.listDatasetRowPermissions(datasetId, Collections.singletonList(AuthUtils.getUser().getDeptId()), "dept"));
Map<String, RowPermissionService> beansOfType = SpringContextUtil.getApplicationContext().getBeansOfType((RowPermissionService.class));
if(beansOfType.keySet().size() == 0) {
return new ArrayList<>();
}
RowPermissionService rowPermissionService = SpringContextUtil.getBean(RowPermissionService.class);
datasetRowPermissions.addAll(rowPermissionService.listDatasetRowPermissions(datasetId, Collections.singletonList(AuthUtils.getUser().getUserId()), "user"));
datasetRowPermissions.addAll(rowPermissionService.listDatasetRowPermissions(datasetId, AuthUtils.getUser().getRoles().stream().map(CurrentRoleDto::getId).collect(Collectors.toList()) , "role"));
datasetRowPermissions.addAll(rowPermissionService.listDatasetRowPermissions(datasetId, Collections.singletonList(AuthUtils.getUser().getDeptId()), "dept"));
return datasetRowPermissions;
}
@ -467,7 +468,7 @@ public class DataSetTableService {
rowPermissions(datasetTable.getId()).forEach(datasetRowPermissions -> {
List<ChartCustomFilterDTO> lists = JSONObject.parseArray(datasetRowPermissions.getFilter(), ChartCustomFilterDTO.class);
lists.forEach(chartCustomFilterDTO -> {
DatasetTableField field = getFieldById(fields, chartCustomFilterDTO.getFieldId());
DatasetTableField field = getFieldById(fields, datasetRowPermissions.getDatasetFieldId());
if(field != null){
chartCustomFilterDTO.setFieldId(datasetRowPermissions.getDatasetFieldId());
chartCustomFilterDTO.setField(field);
@ -1686,7 +1687,7 @@ public class DataSetTableService {
dataSetDetail.setTable(table);
if (ObjectUtils.isNotEmpty(table)) {
Datasource datasource = datasourceMapper.selectByPrimaryKey(table.getDataSourceId());
datasource.setConfiguration(null);
Optional.ofNullable(datasource).orElse(new Datasource()).setConfiguration(null);
dataSetDetail.setDatasource(datasource);
}
return dataSetDetail;

10
frontend/src/lang/en.js
View File

@ -1154,6 +1154,16 @@ export default {
confirm_sync_field_tips: 'Sync field maybe change edit field，please confirm',
sync_success: 'Success',
sync_success_1: 'Success，please sync data again',
row_permission: {
type: 'Type',
name: 'Name',
condition: 'Conditions',
value: 'Value',
add: 'Add row permissions',
edit: 'Edit row permissions',
please_select_field: 'Please select a field'
},
row_permissions: 'Row Permissions',
union_data: 'Union Dataset',
add_union_table: 'Add Union Dataset',
edit_union: 'Edit Union Dataset',

10
frontend/src/lang/tw.js
View File

@ -1155,6 +1155,16 @@ export default {
confirm_sync_field_tips: '同步字段可能會導致已編輯字段發生變更，請確認',
sync_success: '同步成功',
sync_success_1: '同步成功，請對當前數據集重新執行數據同步操作',
row_permission: {
type: '類型',
name: '名稱',
condition: '條件',
value: '值',
add: '添加行權限',
edit: '編輯行權限',
please_select_field: '請選擇字段'
},
row_permissions: '行權限',
union_data: '關聯數據集',
add_union_table: '添加關聯數據集',
edit_union: '編輯關聯數據集',

5
frontend/src/lang/zh.js
View File

@ -1016,7 +1016,6 @@ export default {
field_check: '选中',
update_info: '更新信息',
join_view: '数据关联',
row_permissions: '行权限',
text: '文本',
time: '时间',
value: '数值',
@ -1164,8 +1163,10 @@ export default {
condition: '条件',
value: '值',
add: '添加行权限',
edit: '编辑行权限'
edit: '编辑行权限',
please_select_field: '请选择字段'
},
row_permissions: '行权限',
union_data: '关联数据集',
add_union_table: '添加关联数据集',
edit_union: '编辑关联数据集',

345
frontend/src/views/dataset/data/RowPermissions.vue
View File

@ -1,345 +0,0 @@
<template>
<el-col>
<el-row v-loading="$store.getters.loadingMap[$store.getters.currentPath]" style="margin-top: 10px;">
<complex-table :data="data" :columns="columns" local-key="rowPermission" :search-config="searchConfig" :pagination-config="paginationConfig" @select="select" @search="search">
<template #toolbar>
<el-button icon="el-icon-circle-plus-outline" @click="create(undefined)">{{ $t('commons.add') }}</el-button>
</template>
<el-table-column prop="authTargetType" :label="$t('dataset.row_permission.type')">
<template slot-scope="scope">
<span v-if="scope.row.authTargetType === 'dept'">{{ $t('auth.dept') }}</span>
<span v-if="scope.row.authTargetType === 'role'">{{ $t('auth.role') }}</span>
<span v-if="scope.row.authTargetType === 'user'">{{ $t('auth.user') }}</span>
</template>
</el-table-column>
<el-table-column prop="authTargetName" :label="$t('dataset.row_permission.name')" />
<el-table-column prop="fieldName" :label="$t('dataset.field_name')" />
<el-table-column prop="filter" :label="$t('dataset.row_permission.value')">
<template slot-scope="scope">
<el-table :data="scope.row.filter" :show-header='false' style="width: 100%">
<el-table-column prop="term" width="180">
<template slot-scope="scope">
<span v-if="scope.row.term === 'eq'">{{ $t('chart.filter_eq') }}</span>
<span v-if="scope.row.term === 'not_eq'">{{ $t('chart.filter_not_eq') }}</span>
<span v-if="scope.row.term === 'lt'">{{ $t('chart.filter_lt') }}</span>
<span v-if="scope.row.term === 'gt'">{{ $t('chart.filter_gt') }}</span>
<span v-if="scope.row.term === 'le'">{{ $t('chart.filter_le') }}</span>
<span v-if="scope.row.term === 'ge'">{{ $t('chart.filter_le') }}</span>
</template>
</el-table-column>
<el-table-column prop="value" width="180"></el-table-column>
</el-table>
</template>
</el-table-column>
<fu-table-operations :buttons="buttons" :label="$t('commons.operating')" fix />
</complex-table>
</el-row>
<el-dialog v-dialogDrag :title="update_row_permission_dialog_title" :visible="update_row_permission" :show-close="false" width="50%" class="dialog-css" append-to-body>
<el-col>
<el-form ref="rowPermissionForm" :form="rowPermissionForm" :model="rowPermissionForm" label-width="100px" >
<el-form-item :label="$t('dataset.row_permission.type')" prop="type">
<el-select v-model="rowPermissionForm.authTargetType" @change="onTypeChange">
<el-option :label="$t('auth.dept')" value="dept" />
<el-option :label="$t('auth.role')" value="role" />
<el-option :label="$t('auth.user')" value="user" />
</el-select>
</el-form-item>
<el-form-item :label="$t('commons.name')" prop="authTargetId">
<el-select v-model="rowPermissionForm.authTargetId">
<el-option
v-for="item in targetObjs"
:key="item.id"
:label="item.name"
:value="item.id"
/>
</el-select>
</el-form-item>
<el-form-item :label="$t('dataset.field_name')" prop="authTargetId">
<el-select v-model="rowPermissionForm.datasetFieldId">
<el-option
v-for="item in filedList"
:key="item.id"
:label="item.name"
:value="item.id"
/>
</el-select>
</el-form-item>
<el-form-item>
<el-col>
<el-button icon="el-icon-plus" circle size="mini" style="margin-bottom: 10px;" @click="addFilter" />
<div style="max-height: 50vh;overflow-y: auto;">
<el-row v-for="(f,index) in rowPermissionForm.filter" :key="index" class="filter-item">
<el-col :span="4">
<el-select v-model="f.term" size="mini">
<el-option-group
v-for="(group,idx) in options"
:key="idx"
:label="group.label"
>
<el-option
v-for="opt in group.options"
:key="opt.value"
:label="opt.label"
:value="opt.value"
/>
</el-option-group>
</el-select>
</el-col>
<el-col :span="6">
<el-input v-show="!f.term.includes('null')" v-model="f.value" class="value-item" :placeholder="$t('chart.condition')" size="mini" clearable />
</el-col>
<el-col :span="2">
<el-button type="text" icon="el-icon-delete" circle style="float: right" @click="removeFilter(index)" />
</el-col>
</el-row>
</div>
</el-col>
</el-form-item>
</el-form>
</el-col>
<div slot="footer" class="dialog-footer">
<el-button size="mini" @click="closeDialog">{{ $t('dataset.cancel') }}</el-button>
<el-button type="primary" size="mini" @click="save()">{{ $t('dataset.confirm') }}</el-button>
</div>
</el-dialog>
</el-col>
</template>
<script>
import ComplexTable from '@/components/business/complex-table'
import { formatCondition, formatQuickCondition, formatOrders } from '@/utils/index'
import '@riophae/vue-treeselect/dist/vue-treeselect.css'
import { datasetRowPermissionsList, post, fieldList} from '@/api/dataset/dataset'
import TableSelector from '@/views/chart/view/TableSelector'
export default {
name: 'RowPermissions',
components: { ComplexTable, TableSelector },
props: {
param: {
type: Object,
default: null
},
table: {
type: Object,
default: null
}
},
data() {
return {
columns: [],
buttons: [
{
label: this.$t('commons.edit'), icon: 'el-icon-edit', type: 'primary', click: this.create, disabled: this.disableEdit
},
{
label: this.$t('commons.delete'), icon: 'el-icon-delete', type: 'danger', click: this.deleteRowPermission, disabled: this.disableDelete
}
],
searchConfig: {
useQuickSearch: true,
useComplexSearch: true,
quickPlaceholder: this.$t('dataset.task.search_by_name'),
components: [
{ field: 'dataset_table_task.name', label: this.$t('dataset.task_name'), component: 'DeComplexInput' },
{ field: 'dataset_table_task.id', label: this.$t('dataset.task_id'), component: 'FuComplexInput' },
{ field: 'dataset_table.name', label: this.$t('dataset.name'), component: 'DeComplexInput' },
{ field: 'dataset_table_task.status', label: this.$t('dataset.task.task_status'), component: 'FuComplexSelect',
options: [{ label: this.$t('dataset.task.stopped'), value: 'Stopped' }, { label: this.$t('dataset.task.underway'), value: 'Underway' }, { label: this.$t('dataset.task.pending'), value: 'Pending' }, { label: this.$t('dataset.underway'), value: 'Exec' }], multiple: false },
{ field: 'dataset_table_task.last_exec_status', label: this.$t('dataset.task.last_exec_status'), component: 'FuComplexSelect', options: [{ label: this.$t('dataset.completed'), value: 'Completed' }, { label: this.$t('dataset.underway'), value: 'Underway' }, { label: this.$t('dataset.error'), value: 'Error' }], multiple: false }
]
},
last_condition: null,
orderConditions: [],
paginationConfig: {
currentPage: 1,
pageSize: 10,
total: 0
},
data: [],
update_row_permission: false,
update_row_permission_dialog_title: '',
defaultForm: {
authTargetId: null,
authTargetType: null,
datasetFieldId: null,
datasetId: '',
filter: [{term: 'eq', value: ''}]
},
rowPermissionForm: {},
targetObjs: [],
filedList: [],
depts: null,
options: [
{
label: '',
options: [{
value: 'eq',
label: this.$t('chart.filter_eq')
}, {
value: 'not_eq',
label: this.$t('chart.filter_not_eq')
}]
},
{
label: '',
options: [{
value: 'lt',
label: this.$t('chart.filter_lt')
}, {
value: 'gt',
label: this.$t('chart.filter_gt')
}]
},
{
label: '',
options: [{
value: 'le',
label: this.$t('chart.filter_le')
}, {
value: 'ge',
label: this.$t('chart.filter_ge')
}]
}]
}
},
computed: {
},
created() {
this.rowPermissionForm.datasetId = this.table.id
this.initFieldLists()
this.search(this.last_condition)
},
beforeDestroy() {
},
methods: {
initFieldLists(){
fieldList(this.table.id).then(response => {
this.filedList = response.data
})
},
select(selection) {
},
search(condition, showLoading = true) {
this.last_condition = condition
condition = formatQuickCondition(condition, 'dataset_table_field.name')
const temp = formatCondition(condition)
const param = temp || {}
param['orders'] = formatOrders(this.orderConditions)
const { currentPage, pageSize } = this.paginationConfig
datasetRowPermissionsList(this.table.id, currentPage, pageSize, param, showLoading).then(response => {
this.data = response.data.listObject
this.data.forEach(item => {
item.filter = JSON.parse(item.filter)
this.dataSetRowPermissionInfo(item)
})
this.paginationConfig.total = response.data.itemCount
})
},
dataSetRowPermissionInfo(item) {
let params = JSON.parse(JSON.stringify(item));
params.filter = JSON.stringify(params.filter)
post('/dataset/rowPermissions/dataSetRowPermissionInfo', params, false).then(response => {
item.authTargetName = response.data.authTargetName
})
},
create(rowPermissionObj) {
if (!rowPermissionObj) { // add
this.rowPermissionForm = Object.assign({}, this.defaultForm)
this.update_row_permission_dialog_title = this.$t('dataset.row_permission.add')
} else { // update
this.rowPermissionForm = Object.assign({}, rowPermissionObj)
this.update_row_permission_dialog_title = this.$t('dataset.row_permission.edit')
this.fetchTypeList()
}
this.update_row_permission = true
},
onTypeChange(){
this.rowPermissionForm.authTargetId = ''
this.fetchTypeList()
},
fetchTypeList(){
let params = JSON.parse(JSON.stringify(this.rowPermissionForm));
params.filter = JSON.stringify(params.filter)
post('/dataset/rowPermissions/authObjs', params).then(response => {
this.targetObjs = response.data
}).catch(() => {
this.targetObjs = []
})
},
addFilter() {
this.rowPermissionForm.filter.push({
term: 'eq',
value: ''
})
},
removeFilter(index) {
this.rowPermissionForm.filter.splice(index, 1)
},
closeDialog() {
this.update_row_permission = false
this.resetTaskForm()
},
resetTaskForm(){
this.rowPermissionForm={
datasetId: this.rowPermissionForm.datasetId,
authTargetId: null,
filter: [{term: 'eq', value: ''}]
}
},
deleteRowPermission(item) {
this.$confirm(this.$t('dataset.confirm_delete'), this.$t('dataset.tips'), {
confirmButtonText: this.$t('dataset.confirm'),
cancelButtonText: this.$t('dataset.cancel'),
type: 'warning'
}).then(() => {
post('/dataset/rowPermissions/delete/' + item.id, null).then(() => {
this.$message({
message: this.$t('dataset.delete_success'),
type: 'success',
showClose: true
})
this.search(this.last_condition, true)
})
}).catch(() => {
})
},
save() {
this.$refs.rowPermissionForm.validate(valid => {
if (valid) {
let params = JSON.parse(JSON.stringify(this.rowPermissionForm));
params.filter = JSON.stringify(params.filter)
post('/dataset/rowPermissions/save', params).then(() => {
this.$message({
message: this.$t('dataset.save_success'),
type: 'success',
showClose: true
})
this.update_row_permission = false
this.resetTaskForm()
this.search(this.last_condition, true)
})
} else {
return false
}
})
}
}
}
</script>
<style scoped>
span{
font-size: 12px;
}
</style>

6
frontend/src/views/dataset/data/ViewTable.vue
View File

@ -59,9 +59,6 @@
<el-tab-pane v-if="table.type !== 'custom' && !(table.type === 'sql' && table.mode === 0)" :label="$t('dataset.join_view')" name="joinView">
<union-view :param="param" :table="table" />
</el-tab-pane>
<el-tab-pane :label="$t('dataset.row_permissions')" name="rowPermissions">
<row-permissions v-if="tabActive=='rowPermissions'" :param="param" :table="table" />
</el-tab-pane>
<el-tab-pane v-if="table.mode === 1 && (table.type === 'excel' || table.type === 'db' || table.type === 'sql')" :label="$t('dataset.update_info')" name="updateInfo">
<update-info v-if="tabActive=='updateInfo'" :param="param" :table="table" />
</el-tab-pane>
@ -75,12 +72,11 @@ import TabDataPreview from './TabDataPreview'
import UpdateInfo from './UpdateInfo'
import DatasetChartDetail from '../common/DatasetChartDetail'
import UnionView from './UnionView'
import RowPermissions from './RowPermissions'
import FieldEdit from './FieldEdit'
export default {
name: 'ViewTable',
components: {RowPermissions, FieldEdit, UnionView, DatasetChartDetail, UpdateInfo, TabDataPreview },
components: {FieldEdit, UnionView, DatasetChartDetail, UpdateInfo, TabDataPreview },
props: {
param: {
type: Object,