添加 数据权限访问范围实现

base-manager/db/permission.sql

+
+-- ----------------------------
+-- 数据授权权限表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_dimension`;
+CREATE TABLE `mortals_xhx_dimension` (
+    `id` bigint(20)   AUTO_INCREMENT   COMMENT '序号，主键，自增长',
+    `dimension_code` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '维度编码',
+    `dimension_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '维度名称',
+    `dimension_value` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '维度值',
+    `dimension_type` tinyint(2)  DEFAULT '1' COMMENT '维度类型(1.固定值,2.系统上下问变量)',
+    `createTime` datetime      COMMENT '创建时间',
+    `createUserId` bigint(20)      COMMENT '创建用户',
+    `updateUserId` bigint(20)      COMMENT '更新用户',
+    `updateTime` datetime      COMMENT '更新时间',
+    PRIMARY KEY (`id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=DYNAMIC COMMENT='授权维度';
+
+-- ----------------------------
+-- 角色资源授权规则表
+-- ----------------------------
+DROP TABLE IF EXISTS `mortals_xhx_dimension_resource_rule`;
+CREATE TABLE `mortals_xhx_dimension_resource_rule` (
+    `id` bigint(20)   AUTO_INCREMENT   COMMENT '序号，主键，自增长',
+    `role_id` bigint(20)  DEFAULT NULL COMMENT '角色ID',
+    `role_name` varchar(64)  DEFAULT NULL COMMENT '角色名称',
+    `resource_id` bigint(20) DEFAULT NULL COMMENT '资源ID',
+    `resource_name` varchar(64)  DEFAULT NULL COMMENT '资源名称',
+    `rule_code` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '规则编码',
+    `rule_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '规则名称',
+    `rule_condition` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT 'IN' COMMENT '规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)',
+    `rule_value` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '规则值,固定值或者系统变量',
+    `rule_type` tinyint(2)  DEFAULT '1' COMMENT '规则值类型(1.固定值,2.系统上下问变量)',
+    `create_time` datetime      COMMENT '创建时间',
+    `create_user_id` bigint(20)      COMMENT '创建用户',
+    `update_user_id` bigint(20)      COMMENT '更新用户',
+    `update_time` datetime      COMMENT '更新时间',
+  PRIMARY KEY (`id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=DYNAMIC COMMENT='角色资源维度规则表';
+
+
+
+
+

base-manager/src/main/java/com/mortals/xhx/annotation/DataPermission.java

+package com.mortals.xhx.annotation;
+
+import java.lang.annotation.*;
+
+/**
+ *
+ * @author: zxfei
+ * @date: 2024/5/15 16:09
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Documented
+public @interface DataPermission {
+    /**
+     * 数据权限类型
+     * 1 上下级授权  2 数据范围授权
+     */
+    String permissionType() default "2";
+
+    /**
+     * 配置菜单的组件路径,用于数据权限
+     */
+    String componentRoute() default "";
+}

base-manager/src/main/java/com/mortals/xhx/common/code/DimensionTypeEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 维度类型(1.固定值,2.系统上下问变量)枚举类
+*
+* @author zxfei
+*/
+public enum DimensionTypeEnum {
+    固定值(1, "固定值"),
+    系统上下问变量(2, "系统上下问变量");
+    private Integer value;
+    private String desc;
+
+    DimensionTypeEnum(Integer value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public Integer getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static DimensionTypeEnum getByValue(Integer value) {
+        for (DimensionTypeEnum dimensionTypeEnum : DimensionTypeEnum.values()) {
+            if (dimensionTypeEnum.getValue() == value) {
+                return dimensionTypeEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(Integer... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (DimensionTypeEnum item : DimensionTypeEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (Integer e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/common/code/RuleConditionEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)枚举类
+*
+* @author zxfei
+*/
+public enum RuleConditionEnum {
+    属于("IN", "属于"),
+    小于("<", "小于"),
+    大于(">", "大于"),
+    等于("=", "等于"),
+    不等于("!=", "不等于"),
+    大于等于(">=", "大于等于"),
+    小于等于("<=", "小于等于"),
+    左模糊("like %", "左模糊"),
+    右模糊("like %", "右模糊");
+    private String value;
+    private String desc;
+
+    RuleConditionEnum(String value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static RuleConditionEnum getByValue(String value) {
+        for (RuleConditionEnum ruleConditionEnum : RuleConditionEnum.values()) {
+            if (ruleConditionEnum.getValue() == value) {
+                return ruleConditionEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(String... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (RuleConditionEnum item : RuleConditionEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (String e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/common/code/RuleTypeEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 规则值类型(1.固定值,2.系统上下问变量)枚举类
+*
+* @author zxfei
+*/
+public enum RuleTypeEnum {
+    固定值(1, "固定值"),
+    系统上下问变量(2, "系统上下问变量");
+    private Integer value;
+    private String desc;
+
+    RuleTypeEnum(Integer value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public Integer getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static RuleTypeEnum getByValue(Integer value) {
+        for (RuleTypeEnum ruleTypeEnum : RuleTypeEnum.values()) {
+            if (ruleTypeEnum.getValue() == value) {
+                return ruleTypeEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(Integer... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (RuleTypeEnum item : RuleTypeEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (Integer e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/common/utils/DataPermissionUtils.java

+package com.mortals.xhx.common.utils;
+
+import com.mortals.framework.service.IUser;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import org.apache.commons.compress.utils.Lists;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+
+public class DataPermissionUtils {
+
+    public static final String COMPONENT_DATA_RULES = "COMPONENT_DATA_RULES";
+
+    public static final String SYS_USER_INFO = "SYS_USER_INFO";
+
+
+
+    /**
+     * 往链接请求里面，传入数据查询条件
+     *
+     * @param request
+     * @param componentRules
+     */
+    public static void installDataSearchConditon(HttpServletRequest request, List<DimensionResourceRuleEntity> componentRules) {
+        // 1.先从request获取MENU_DATA_AUTHOR_RULES，如果存则获取到LIST
+        List<DimensionResourceRuleEntity> list = loadDataSearchCondition(request);
+        if (list == null) {
+            // 2.如果不存在，则new一个list
+            list = Lists.newArrayList();
+        }
+        list.addAll(componentRules);
+        // 3.往list里面增量存指
+        request.setAttribute(COMPONENT_DATA_RULES, list);
+    }
+
+
+    /**
+     * 往链接请求里面，传入数据查询条件
+     *
+     * @param request
+     * @param searchSql
+     */
+    public static void installSearchSql(HttpServletRequest request,String searchSql) {
+        // 1.先从request获取MENU_DATA_AUTHOR_RULES，如果存则获取到LIST
+
+        // 3.往list里面增量存指
+     //   request.setAttribute(DATA_PERMISSION_SEARCH_SQL, searchSql);
+    }
+
+
+    /**
+     * 获取请求对应的数据权限规则
+     */
+    @SuppressWarnings("unchecked")
+    public static synchronized List<DimensionResourceRuleEntity> loadDataSearchCondition(HttpServletRequest request) {
+        return (List<DimensionResourceRuleEntity>) request.getAttribute(COMPONENT_DATA_RULES);
+    }
+
+    public static synchronized void installUserInfo(HttpServletRequest request, IUser userinfo) {
+        request.setAttribute(SYS_USER_INFO, userinfo);
+    }
+}

base-manager/src/main/java/com/mortals/xhx/common/utils/RuleQueryGenerator.java

+package com.mortals.xhx.common.utils;
+
+import cn.hutool.core.util.ReflectUtil;
+import com.google.common.collect.Maps;
+import com.mortals.framework.service.IUser;
+import com.mortals.framework.util.StringUtils;
+import com.mortals.xhx.common.code.RuleConditionEnum;
+import com.mortals.xhx.common.code.RuleTypeEnum;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.springframework.util.ObjectUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 权限sql 查询语句实现
+ *
+ * @author: zxfei
+ * @date: 2024/5/15 10:44
+ */
+@Slf4j
+@UtilityClass
+public class RuleQueryGenerator {
+
+    private static final String SQL_AND = " and ";
+
+    private static final String SQL_OR = " or ";
+
+    private static final String SQL_JOINT = " (%s) ";
+
+
+    public static String getPermissionSql(List<DimensionResourceRuleEntity> conditionList, IUser loginUser) {
+        //存在权限
+        //对当前身份根据规则编码分组-去除不同角色中相同编码且规则值为ALL的规则 并根据角色id分组
+        Map<Long, List<DimensionResourceRuleEntity>> ruleMap = getRuleMapByRoleId(conditionList);
+
+        StringBuilder sb = new StringBuilder();
+        String roleSql;
+        if (MapUtils.isNotEmpty(ruleMap)) {
+            //按角色拼接SQL
+            for (Map.Entry<Long, List<DimensionResourceRuleEntity>> entry : ruleMap.entrySet()) {
+                List<DimensionResourceRuleEntity> lists = entry.getValue();
+                // 同角色之间使用 AND
+                roleSql = buildRoleSql(lists, loginUser);
+                //角色之间使用 OR
+                if (StringUtils.isNotEmpty(roleSql)) {
+                    jointSqlByRoles(sb, roleSql);
+                }
+            }
+
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * 获取带有数据权限的SQL
+     *
+     * @param identityId 身份ID
+     */
+    public String getPermissionSql(String identityId) {
+        //------------------------获取当前身份的数据规则------------------------------------
+        List<DimensionResourceRuleEntity> conditionList = getCurrentIdentyPermission(identityId);
+        if (ObjectUtils.isEmpty(conditionList)) {
+            //没有权限
+            return "1 = 0";
+        }
+        //存在权限
+        //对当前身份根据规则编码分组-去除不同角色中相同编码且规则值为ALL的规则 并根据角色id分组
+        Map<Long, List<DimensionResourceRuleEntity>> ruleMap = getRuleMapByRoleId(conditionList);
+
+        StringBuilder sb = new StringBuilder();
+        String roleSql;
+        if (MapUtils.isNotEmpty(ruleMap)) {
+            //按角色拼接SQL
+            for (Map.Entry<Long, List<DimensionResourceRuleEntity>> entry : ruleMap.entrySet()) {
+
+                List<DimensionResourceRuleEntity> lists = entry.getValue();
+
+                // 同角色之间使用 AND
+                roleSql = buildRoleSql(lists, null);
+
+                //角色之间使用 OR
+                if (StringUtils.isNotEmpty(roleSql)) {
+                    jointSqlByRoles(sb, roleSql);
+                }
+            }
+
+        }
+        return sb.toString();
+    }
+
+    private static List<DimensionResourceRuleEntity> getCurrentIdentyPermission(String identityId) {
+        return null;
+
+/*        //----------------------------获取所有数据规则-----------------------------
+        List<DimensionResourceRuleEntity> roleRuleList = DataPermissionUtils.loadDataSearchCondition();
+        if(ObjectUtils.isEmpty(roleRuleList)){
+            return null;
+        }
+        //-----------------------------过滤掉不属于当前身份的规则-----------------------------------
+        return roleRuleList.stream()
+               // .filter(item -> item.getIdentityId().equals(identityId))
+                .collect(Collectors.toList());*/
+    }
+
+    /**
+     * 构建单角色SQL
+     */
+    private static String buildRoleSql(List<DimensionResourceRuleEntity> lists, IUser loginUser) {
+        StringBuilder roleSql = new StringBuilder();
+        for (DimensionResourceRuleEntity item : lists) {
+            //如果出现全选 则 代表全部，不需要限定范围
+            if ("ALL".equals(item.getRuleValue())) {
+                continue;
+            }
+            //将规则转换成SQL
+            String filedSql = convertRuleToSql(item, loginUser);
+
+            if(!ObjectUtils.isEmpty(filedSql)){
+                roleSql.append(SQL_AND).append(filedSql);
+            }
+
+        }
+        return roleSql.toString();
+    }
+
+
+    /**
+     * 将单一规则转化成SQL，默认全部使用 In
+     * ruleCode : area_test
+     * ruleValue : 区域1，区域2，区域3
+     *
+     * @param rule 规则值
+     */
+    private static String convertRuleToSql(DimensionResourceRuleEntity rule, IUser loginUser) {
+
+        //判断规则类型
+        String ruleValueConvert = "";
+        if (RuleConditionEnum.属于.getValue().equalsIgnoreCase(rule.getRuleCondition())) {
+            String whereCondition = " in ";
+            if(RuleTypeEnum.系统上下问变量.getValue()==rule.getRuleType()){
+                ruleValueConvert = getInConditionValue(rule.getRuleValue(),loginUser);
+                if(ObjectUtils.isEmpty(ruleValueConvert)) return null;
+                return rule.getRuleCode() + whereCondition + ruleValueConvert;
+            }else{
+                ruleValueConvert = getInConditionValue(rule.getRuleValue());
+                if(ObjectUtils.isEmpty(ruleValueConvert)) return null;
+                return rule.getRuleCode() + whereCondition + ruleValueConvert;
+            }
+        } else if (RuleConditionEnum.大于.getValue().equalsIgnoreCase(rule.getRuleCondition())) {
+            String whereCondition = " > ";
+            ruleValueConvert = getGreaterConditionValue(rule.getRuleValue());
+            return rule.getRuleCode() + whereCondition + ruleValueConvert;
+        } else {
+            //todo
+            //不支持的类型
+        }
+        return null;
+
+    }
+
+
+    /**
+     * IN字符串转换
+     * 区域1, 区域2, 区域3  --> ("区域1","区域2","区域3")
+     * 江西大区  --> ("江西大区")
+     */
+    private static String getInConditionValue(String ruleValue) {
+        String[] temp = ruleValue.split(",");
+        StringBuilder res = new StringBuilder();
+        for (String string : temp) {
+            res.append(",'").append(string).append("'");
+        }
+        return "(" + res.substring(1) + ")";
+    }
+
+    /**
+     * IN字符串转换
+     * 区域1, 区域2, 区域3  --> ("区域1","区域2","区域3")
+     * 江西大区  --> ("江西大区")
+     */
+    private static String getInConditionValue(String ruleValue,IUser loginUser) {
+        //el表达式 提取变量  再通过反射获取值，最终设置值
+        Object fieldValue = ReflectUtil.getFieldValue(loginUser, ruleValue);
+        if(fieldValue!=null){
+            return "(" + fieldValue + ")";
+        }
+        return null;
+
+    }
+
+    /**
+     * > 字符串转换
+     * 区域1, 区域2, 区域3  --> ("区域1","区域2","区域3")
+     * 江西大区  --> ("江西大区")
+     */
+    private static String getGreaterConditionValue(String ruleValue) {
+        return ruleValue;
+    }
+
+    /**
+     * 拼接单角色的SQL
+     *
+     * @param sqlBuilder 总的SQL
+     * @param roleSql    单角色SQL
+     */
+    private static void jointSqlByRoles(StringBuilder sqlBuilder, String roleSql) {
+        roleSql = roleSql.replaceFirst(SQL_AND, "");
+        if (StringUtils.isEmpty(sqlBuilder.toString())) {
+            sqlBuilder.append(String.format(SQL_JOINT, roleSql));
+        } else {
+            sqlBuilder.append(SQL_OR).append(String.format(SQL_JOINT, roleSql));
+        }
+    }
+
+    /**
+     * 1. 对当前身份根据规则编码分组-去除不同角色中相同编码且规则值为ALL的规则
+     * 2. 对角色进行分组
+     *
+     * @param conditionList 数据规则
+     * @return 分组后的规则list
+     */
+    public static Map<Long, List<DimensionResourceRuleEntity>> getRuleMapByRoleId(List<DimensionResourceRuleEntity> conditionList) {
+        //--------过滤掉不属于当前身份的规则,并对条件编码进行分组-----------------------------------
+        Map<String, List<DimensionResourceRuleEntity>> conditionMap = conditionList.stream().collect(Collectors.groupingBy(DimensionResourceRuleEntity::getRuleCode));
+
+        //--------相同编码分组中存在ALL的排除掉-----------------------------------------------
+        List<DimensionResourceRuleEntity> newRoleRuleList = new ArrayList<>();
+        if (MapUtils.isNotEmpty(conditionMap)) {
+            for (Map.Entry<String, List<DimensionResourceRuleEntity>> entry : conditionMap.entrySet()) {
+                boolean flag = true;
+                List<DimensionResourceRuleEntity> lists = entry.getValue();
+                for (DimensionResourceRuleEntity item : lists) {
+                    if ("ALL".equals(item.getRuleValue())) {
+                        flag = false;
+                        break;
+                    }
+                }
+
+                if (flag) {
+                    newRoleRuleList.addAll(lists);
+                }
+            }
+        }
+        if (CollectionUtils.isNotEmpty(newRoleRuleList)) {
+            return newRoleRuleList.stream().collect(Collectors.groupingBy(DimensionResourceRuleEntity::getRoleId));
+        }
+        return Maps.newHashMap();
+    }
+}

base-manager/src/main/java/com/mortals/xhx/module/dimension/dao/DimensionDao.java

+package com.mortals.xhx.module.dimension.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.dimension.model.DimensionEntity;
+
+/**
+* 授权维度Dao
+* 授权维度 DAO接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+
+public interface  DimensionDao extends ICRUDDao<DimensionEntity,Long>{
+
+
+}

base-manager/src/main/java/com/mortals/xhx/module/dimension/dao/DimensionResourceRuleDao.java

+package com.mortals.xhx.module.dimension.dao;
+
+import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+
+import java.util.List;
+/**
+* 角色资源维度规则Dao
+* 角色资源维度规则 DAO接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+
+public interface  DimensionResourceRuleDao extends ICRUDDao<DimensionResourceRuleEntity,Long>{
+
+    List<DimensionResourceRuleEntity> getRoleComponentRule(Long userId,String route);
+}

base-manager/src/main/java/com/mortals/xhx/module/dimension/dao/ibatis/DimensionDaoImpl.java

+package com.mortals.xhx.module.dimension.dao.ibatis;
+
+
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import com.mortals.xhx.module.dimension.dao.DimensionDao;
+import com.mortals.xhx.module.dimension.model.DimensionEntity;
+import org.springframework.stereotype.Repository;
+
+/**
+* 授权维度DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Repository("dimensionDao")
+public class DimensionDaoImpl extends BaseCRUDDaoMybatis<DimensionEntity,Long> implements DimensionDao {
+
+
+
+}

base-manager/src/main/java/com/mortals/xhx/module/dimension/dao/ibatis/DimensionResourceRuleDaoImpl.java

+package com.mortals.xhx.module.dimension.dao.ibatis;
+
+
+import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+import com.mortals.xhx.module.dimension.dao.DimensionResourceRuleDao;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import org.springframework.stereotype.Repository;
+
+import java.util.HashMap;
+import java.util.List;
+/**
+* 角色资源维度规则DaoImpl DAO接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Repository("dimensionResourceRuleDao")
+public class DimensionResourceRuleDaoImpl extends BaseCRUDDaoMybatis<DimensionResourceRuleEntity,Long> implements DimensionResourceRuleDao {
+
+
+    /**
+     * @param userId
+     * @param route
+     * @return
+     */
+    @Override
+    public List<DimensionResourceRuleEntity> getRoleComponentRule(Long userId, String route) {
+
+        return getSqlSession().selectList(getSqlId("getRoleComponentRule"), new HashMap<String, Object>() {
+            {
+                put("userId", userId);
+                put("route", route);
+            }
+        });
+    }
+}

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/DimensionEntity.java

+package com.mortals.xhx.module.dimension.model;
+import com.mortals.xhx.module.dimension.model.vo.DimensionVo;
+import lombok.Data;
+/**
+* 授权维度实体对象
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Data
+public class DimensionEntity extends DimensionVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+    * 维度编码
+    */
+    private String dimensionCode;
+    /**
+    * 维度名称
+    */
+    private String dimensionName;
+    /**
+    * 维度值
+    */
+    private String dimensionValue;
+    /**
+    * 维度类型(1.固定值,2.系统上下问变量)
+    */
+    private Integer dimensionType;
+    @Override
+    public int hashCode() {
+         return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof DimensionEntity) {
+            DimensionEntity tmp = (DimensionEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                 return true;
+            }
+        }
+        return false;
+    }
+
+    public void initAttrValue(){
+            this.dimensionCode = "";
+            this.dimensionName = "";
+            this.dimensionValue = "";
+            this.dimensionType = 1;
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/DimensionQuery.java

+package com.mortals.xhx.module.dimension.model;
+
+import java.util.List;
+
+/**
+* 授权维度查询对象
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+public class DimensionQuery extends DimensionEntity {
+    /** 开始 序号，主键，自增长 */
+    private Long idStart;
+
+    /** 结束 序号，主键，自增长 */
+    private Long idEnd;
+
+    /** 增加 序号，主键，自增长 */
+    private Long idIncrement;
+
+    /** 序号，主键，自增长列表 */
+    private List <Long> idList;
+
+    /** 序号，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
+    /** 维度编码 */
+    private List<String> dimensionCodeList;
+
+    /** 维度编码排除列表 */
+    private List <String> dimensionCodeNotList;
+    /** 维度名称 */
+    private List<String> dimensionNameList;
+
+    /** 维度名称排除列表 */
+    private List <String> dimensionNameNotList;
+    /** 维度值 */
+    private List<String> dimensionValueList;
+
+    /** 维度值排除列表 */
+    private List <String> dimensionValueNotList;
+    /** 开始 维度类型(1.固定值,2.系统上下问变量) */
+    private Integer dimensionTypeStart;
+
+    /** 结束 维度类型(1.固定值,2.系统上下问变量) */
+    private Integer dimensionTypeEnd;
+
+    /** 增加 维度类型(1.固定值,2.系统上下问变量) */
+    private Integer dimensionTypeIncrement;
+
+    /** 维度类型(1.固定值,2.系统上下问变量)列表 */
+    private List <Integer> dimensionTypeList;
+
+    /** 维度类型(1.固定值,2.系统上下问变量)排除列表 */
+    private List <Integer> dimensionTypeNotList;
+
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建用户 */
+    private Long createUserIdStart;
+
+    /** 结束 创建用户 */
+    private Long createUserIdEnd;
+
+    /** 增加 创建用户 */
+    private Long createUserIdIncrement;
+
+    /** 创建用户列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 开始 更新用户 */
+    private Long updateUserIdStart;
+
+    /** 结束 更新用户 */
+    private Long updateUserIdEnd;
+
+    /** 增加 更新用户 */
+    private Long updateUserIdIncrement;
+
+    /** 更新用户列表 */
+    private List <Long> updateUserIdList;
+
+    /** 更新用户排除列表 */
+    private List <Long> updateUserIdNotList;
+
+    /** 开始 更新时间 */
+    private String updateTimeStart;
+
+    /** 结束 更新时间 */
+    private String updateTimeEnd;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<DimensionQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<DimensionQuery> andConditionList;
+
+    public DimensionQuery(){}
+
+    /**
+    * 获取 开始 序号，主键，自增长
+    * @return idStart
+    */
+    public Long getIdStart(){
+        return this.idStart;
+    }
+
+    /**
+    * 设置 开始 序号，主键，自增长
+    * @param idStart
+    */
+    public void setIdStart(Long idStart){
+        this.idStart = idStart;
+    }
+
+    /**
+    * 获取 结束 序号，主键，自增长
+    * @return $idEnd
+    */
+    public Long getIdEnd(){
+        return this.idEnd;
+    }
+
+    /**
+    * 设置 结束 序号，主键，自增长
+    * @param idEnd
+    */
+    public void setIdEnd(Long idEnd){
+        this.idEnd = idEnd;
+    }
+
+    /**
+    * 获取 增加 序号，主键，自增长
+    * @return idIncrement
+    */
+    public Long getIdIncrement(){
+        return this.idIncrement;
+    }
+
+    /**
+    * 设置 增加 序号，主键，自增长
+    * @param idIncrement
+    */
+    public void setIdIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+    }
+
+    /**
+    * 获取 序号，主键，自增长
+    * @return idList
+    */
+    public List<Long> getIdList(){
+        return this.idList;
+    }
+
+    /**
+    * 设置 序号，主键，自增长
+    * @param idList
+    */
+    public void setIdList(List<Long> idList){
+        this.idList = idList;
+    }
+
+    /**
+    * 获取 序号，主键，自增长
+    * @return idNotList
+    */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+    * 设置 序号，主键，自增长
+    * @param idNotList
+    */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+    * 获取 维度编码
+    * @return dimensionCodeList
+    */
+    public List<String> getDimensionCodeList(){
+        return this.dimensionCodeList;
+    }
+
+    /**
+    * 设置 维度编码
+    * @param dimensionCodeList
+    */
+    public void setDimensionCodeList(List<String> dimensionCodeList){
+        this.dimensionCodeList = dimensionCodeList;
+    }
+
+    /**
+    * 获取 维度编码
+    * @return dimensionCodeNotList
+    */
+    public List<String> getDimensionCodeNotList(){
+        return this.dimensionCodeNotList;
+    }
+
+    /**
+    * 设置 维度编码
+    * @param dimensionCodeNotList
+    */
+    public void setDimensionCodeNotList(List<String> dimensionCodeNotList){
+        this.dimensionCodeNotList = dimensionCodeNotList;
+    }
+
+    /**
+    * 获取 维度名称
+    * @return dimensionNameList
+    */
+    public List<String> getDimensionNameList(){
+        return this.dimensionNameList;
+    }
+
+    /**
+    * 设置 维度名称
+    * @param dimensionNameList
+    */
+    public void setDimensionNameList(List<String> dimensionNameList){
+        this.dimensionNameList = dimensionNameList;
+    }
+
+    /**
+    * 获取 维度名称
+    * @return dimensionNameNotList
+    */
+    public List<String> getDimensionNameNotList(){
+        return this.dimensionNameNotList;
+    }
+
+    /**
+    * 设置 维度名称
+    * @param dimensionNameNotList
+    */
+    public void setDimensionNameNotList(List<String> dimensionNameNotList){
+        this.dimensionNameNotList = dimensionNameNotList;
+    }
+
+    /**
+    * 获取 维度值
+    * @return dimensionValueList
+    */
+    public List<String> getDimensionValueList(){
+        return this.dimensionValueList;
+    }
+
+    /**
+    * 设置 维度值
+    * @param dimensionValueList
+    */
+    public void setDimensionValueList(List<String> dimensionValueList){
+        this.dimensionValueList = dimensionValueList;
+    }
+
+    /**
+    * 获取 维度值
+    * @return dimensionValueNotList
+    */
+    public List<String> getDimensionValueNotList(){
+        return this.dimensionValueNotList;
+    }
+
+    /**
+    * 设置 维度值
+    * @param dimensionValueNotList
+    */
+    public void setDimensionValueNotList(List<String> dimensionValueNotList){
+        this.dimensionValueNotList = dimensionValueNotList;
+    }
+
+    /**
+    * 获取 开始 维度类型(1.固定值,2.系统上下问变量)
+    * @return dimensionTypeStart
+    */
+    public Integer getDimensionTypeStart(){
+        return this.dimensionTypeStart;
+    }
+
+    /**
+    * 设置 开始 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeStart
+    */
+    public void setDimensionTypeStart(Integer dimensionTypeStart){
+        this.dimensionTypeStart = dimensionTypeStart;
+    }
+
+    /**
+    * 获取 结束 维度类型(1.固定值,2.系统上下问变量)
+    * @return $dimensionTypeEnd
+    */
+    public Integer getDimensionTypeEnd(){
+        return this.dimensionTypeEnd;
+    }
+
+    /**
+    * 设置 结束 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeEnd
+    */
+    public void setDimensionTypeEnd(Integer dimensionTypeEnd){
+        this.dimensionTypeEnd = dimensionTypeEnd;
+    }
+
+    /**
+    * 获取 增加 维度类型(1.固定值,2.系统上下问变量)
+    * @return dimensionTypeIncrement
+    */
+    public Integer getDimensionTypeIncrement(){
+        return this.dimensionTypeIncrement;
+    }
+
+    /**
+    * 设置 增加 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeIncrement
+    */
+    public void setDimensionTypeIncrement(Integer dimensionTypeIncrement){
+        this.dimensionTypeIncrement = dimensionTypeIncrement;
+    }
+
+    /**
+    * 获取 维度类型(1.固定值,2.系统上下问变量)
+    * @return dimensionTypeList
+    */
+    public List<Integer> getDimensionTypeList(){
+        return this.dimensionTypeList;
+    }
+
+    /**
+    * 设置 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeList
+    */
+    public void setDimensionTypeList(List<Integer> dimensionTypeList){
+        this.dimensionTypeList = dimensionTypeList;
+    }
+
+    /**
+    * 获取 维度类型(1.固定值,2.系统上下问变量)
+    * @return dimensionTypeNotList
+    */
+    public List<Integer> getDimensionTypeNotList(){
+        return this.dimensionTypeNotList;
+    }
+
+    /**
+    * 设置 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeNotList
+    */
+    public void setDimensionTypeNotList(List<Integer> dimensionTypeNotList){
+        this.dimensionTypeNotList = dimensionTypeNotList;
+    }
+
+
+    /**
+    * 获取 开始 创建时间
+    * @return createTimeStart
+    */
+    public String getCreateTimeStart(){
+        return this.createTimeStart;
+    }
+
+    /**
+    * 设置 开始 创建时间
+    * @param createTimeStart
+    */
+    public void setCreateTimeStart(String createTimeStart){
+        this.createTimeStart = createTimeStart;
+    }
+
+    /**
+    * 获取 结束 创建时间
+    * @return createTimeEnd
+    */
+    public String getCreateTimeEnd(){
+        return this.createTimeEnd;
+    }
+
+    /**
+    * 设置 结束 创建时间
+    * @param createTimeEnd
+    */
+    public void setCreateTimeEnd(String createTimeEnd){
+        this.createTimeEnd = createTimeEnd;
+    }
+
+    /**
+    * 获取 开始 创建用户
+    * @return createUserIdStart
+    */
+    public Long getCreateUserIdStart(){
+        return this.createUserIdStart;
+    }
+
+    /**
+    * 设置 开始 创建用户
+    * @param createUserIdStart
+    */
+    public void setCreateUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+    }
+
+    /**
+    * 获取 结束 创建用户
+    * @return $createUserIdEnd
+    */
+    public Long getCreateUserIdEnd(){
+        return this.createUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 创建用户
+    * @param createUserIdEnd
+    */
+    public void setCreateUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 创建用户
+    * @return createUserIdIncrement
+    */
+    public Long getCreateUserIdIncrement(){
+        return this.createUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 创建用户
+    * @param createUserIdIncrement
+    */
+    public void setCreateUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+    }
+
+    /**
+    * 获取 创建用户
+    * @return createUserIdList
+    */
+    public List<Long> getCreateUserIdList(){
+        return this.createUserIdList;
+    }
+
+    /**
+    * 设置 创建用户
+    * @param createUserIdList
+    */
+    public void setCreateUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+    }
+
+    /**
+    * 获取 创建用户
+    * @return createUserIdNotList
+    */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+    * 设置 创建用户
+    * @param createUserIdNotList
+    */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+    * 获取 开始 更新用户
+    * @return updateUserIdStart
+    */
+    public Long getUpdateUserIdStart(){
+        return this.updateUserIdStart;
+    }
+
+    /**
+    * 设置 开始 更新用户
+    * @param updateUserIdStart
+    */
+    public void setUpdateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+    }
+
+    /**
+    * 获取 结束 更新用户
+    * @return $updateUserIdEnd
+    */
+    public Long getUpdateUserIdEnd(){
+        return this.updateUserIdEnd;
+    }
+
+    /**
+    * 设置 结束 更新用户
+    * @param updateUserIdEnd
+    */
+    public void setUpdateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+    }
+
+    /**
+    * 获取 增加 更新用户
+    * @return updateUserIdIncrement
+    */
+    public Long getUpdateUserIdIncrement(){
+        return this.updateUserIdIncrement;
+    }
+
+    /**
+    * 设置 增加 更新用户
+    * @param updateUserIdIncrement
+    */
+    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+    }
+
+    /**
+    * 获取 更新用户
+    * @return updateUserIdList
+    */
+    public List<Long> getUpdateUserIdList(){
+        return this.updateUserIdList;
+    }
+
+    /**
+    * 设置 更新用户
+    * @param updateUserIdList
+    */
+    public void setUpdateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+    }
+
+    /**
+    * 获取 更新用户
+    * @return updateUserIdNotList
+    */
+    public List<Long> getUpdateUserIdNotList(){
+        return this.updateUserIdNotList;
+    }
+
+    /**
+    * 设置 更新用户
+    * @param updateUserIdNotList
+    */
+    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+    }
+
+
+    /**
+    * 获取 开始 更新时间
+    * @return updateTimeStart
+    */
+    public String getUpdateTimeStart(){
+        return this.updateTimeStart;
+    }
+
+    /**
+    * 设置 开始 更新时间
+    * @param updateTimeStart
+    */
+    public void setUpdateTimeStart(String updateTimeStart){
+        this.updateTimeStart = updateTimeStart;
+    }
+
+    /**
+    * 获取 结束 更新时间
+    * @return updateTimeEnd
+    */
+    public String getUpdateTimeEnd(){
+        return this.updateTimeEnd;
+    }
+
+    /**
+    * 设置 结束 更新时间
+    * @param updateTimeEnd
+    */
+    public void setUpdateTimeEnd(String updateTimeEnd){
+        this.updateTimeEnd = updateTimeEnd;
+    }
+
+    /**
+    * 设置  序号，主键，自增长
+    * @param id
+    */
+    public DimensionQuery id(Long id){
+	    setId(id);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 序号，主键，自增长
+    * @param idStart
+    */
+    public DimensionQuery idStart(Long idStart){
+		this.idStart = idStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 序号，主键，自增长
+    * @param idEnd
+    */
+    public DimensionQuery idEnd(Long idEnd){
+		this.idEnd = idEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 序号，主键，自增长
+    * @param idIncrement
+    */
+    public DimensionQuery idIncrement(Long idIncrement){
+		this.idIncrement = idIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 序号，主键，自增长
+    * @param idList
+    */
+    public DimensionQuery idList(List<Long> idList){
+        this.idList = idList;
+		return this;
+        }
+
+        /**
+        * 设置 序号，主键，自增长
+        * @param idNotList
+        */
+        public DimensionQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+        }
+
+
+	/**
+    * 设置 维度编码
+    * @param dimensionCode
+    */
+    public DimensionQuery dimensionCode(String dimensionCode){
+        setDimensionCode(dimensionCode);
+		return this;
+    }
+
+    /**
+    * 设置 维度编码
+    * @param dimensionCodeList
+    */
+    public DimensionQuery dimensionCodeList(List<String> dimensionCodeList){
+        this.dimensionCodeList = dimensionCodeList;
+		return this;
+    }
+
+
+	/**
+    * 设置 维度名称
+    * @param dimensionName
+    */
+    public DimensionQuery dimensionName(String dimensionName){
+        setDimensionName(dimensionName);
+		return this;
+    }
+
+    /**
+    * 设置 维度名称
+    * @param dimensionNameList
+    */
+    public DimensionQuery dimensionNameList(List<String> dimensionNameList){
+        this.dimensionNameList = dimensionNameList;
+		return this;
+    }
+
+
+	/**
+    * 设置 维度值
+    * @param dimensionValue
+    */
+    public DimensionQuery dimensionValue(String dimensionValue){
+        setDimensionValue(dimensionValue);
+		return this;
+    }
+
+    /**
+    * 设置 维度值
+    * @param dimensionValueList
+    */
+    public DimensionQuery dimensionValueList(List<String> dimensionValueList){
+        this.dimensionValueList = dimensionValueList;
+		return this;
+    }
+
+    /**
+    * 设置  维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionType
+    */
+    public DimensionQuery dimensionType(Integer dimensionType){
+	    setDimensionType(dimensionType);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeStart
+    */
+    public DimensionQuery dimensionTypeStart(Integer dimensionTypeStart){
+		this.dimensionTypeStart = dimensionTypeStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeEnd
+    */
+    public DimensionQuery dimensionTypeEnd(Integer dimensionTypeEnd){
+		this.dimensionTypeEnd = dimensionTypeEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeIncrement
+    */
+    public DimensionQuery dimensionTypeIncrement(Integer dimensionTypeIncrement){
+		this.dimensionTypeIncrement = dimensionTypeIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 维度类型(1.固定值,2.系统上下问变量)
+    * @param dimensionTypeList
+    */
+    public DimensionQuery dimensionTypeList(List<Integer> dimensionTypeList){
+        this.dimensionTypeList = dimensionTypeList;
+		return this;
+        }
+
+        /**
+        * 设置 维度类型(1.固定值,2.系统上下问变量)
+        * @param dimensionTypeNotList
+        */
+        public DimensionQuery dimensionTypeNotList(List<Integer> dimensionTypeNotList){
+        this.dimensionTypeNotList = dimensionTypeNotList;
+        return this;
+        }
+
+
+    /**
+    * 设置  创建用户
+    * @param createUserId
+    */
+    public DimensionQuery createUserId(Long createUserId){
+	    setCreateUserId(createUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 创建用户
+    * @param createUserIdStart
+    */
+    public DimensionQuery createUserIdStart(Long createUserIdStart){
+		this.createUserIdStart = createUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 创建用户
+    * @param createUserIdEnd
+    */
+    public DimensionQuery createUserIdEnd(Long createUserIdEnd){
+		this.createUserIdEnd = createUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 创建用户
+    * @param createUserIdIncrement
+    */
+    public DimensionQuery createUserIdIncrement(Long createUserIdIncrement){
+		this.createUserIdIncrement = createUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 创建用户
+    * @param createUserIdList
+    */
+    public DimensionQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 创建用户
+        * @param createUserIdNotList
+        */
+        public DimensionQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+        }
+
+    /**
+    * 设置  更新用户
+    * @param updateUserId
+    */
+    public DimensionQuery updateUserId(Long updateUserId){
+	    setUpdateUserId(updateUserId);
+		return this;
+    }
+	
+	 /**
+    * 设置 开始 更新用户
+    * @param updateUserIdStart
+    */
+    public DimensionQuery updateUserIdStart(Long updateUserIdStart){
+		this.updateUserIdStart = updateUserIdStart;
+		return this;
+    }
+
+    /**
+    * 设置 结束 更新用户
+    * @param updateUserIdEnd
+    */
+    public DimensionQuery updateUserIdEnd(Long updateUserIdEnd){
+		this.updateUserIdEnd = updateUserIdEnd;
+		return this;
+    }
+
+    /**
+    * 设置 增加 更新用户
+    * @param updateUserIdIncrement
+    */
+    public DimensionQuery updateUserIdIncrement(Long updateUserIdIncrement){
+		this.updateUserIdIncrement = updateUserIdIncrement;
+		return this;
+    }
+
+    /**
+    * 设置 更新用户
+    * @param updateUserIdList
+    */
+    public DimensionQuery updateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+		return this;
+        }
+
+        /**
+        * 设置 更新用户
+        * @param updateUserIdNotList
+        */
+        public DimensionQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+        return this;
+        }
+
+
+    /**
+    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @return orConditionList
+    */
+    public List<DimensionQuery> getOrConditionList(){
+    return this.orConditionList;
+    }
+
+    /**
+    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+    * @param orConditionList
+    */
+    public void setOrConditionList(List<DimensionQuery> orConditionList){
+        this.orConditionList = orConditionList;
+    }
+
+    /**
+    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+    * @return andConditionList
+    */
+    public List<DimensionQuery> getAndConditionList(){
+        return this.andConditionList;
+    }
+
+    /**
+    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+    * @param andConditionList
+    */
+    public void setAndConditionList(List<DimensionQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/DimensionResourceRuleEntity.java

+package com.mortals.xhx.module.dimension.model;
+
+import com.mortals.xhx.module.dimension.model.vo.DimensionResourceRuleVo;
+import lombok.Data;
+/**
+ * 角色资源维度规则实体对象
+ *
+ * @author zxfei
+ * @date 2024-05-22
+ */
+@Data
+public class DimensionResourceRuleEntity extends DimensionResourceRuleVo {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 角色ID
+     */
+    private Long roleId;
+    /**
+     * 资源ID
+     */
+    private Long resourceId;
+    /**
+     * 规则编码
+     */
+    private String ruleCode;
+    /**
+     * 规则名称
+     */
+    private String ruleName;
+    /**
+     * 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     */
+    private String ruleCondition;
+    /**
+     * 规则值,固定值或者系统变量
+     */
+    private String ruleValue;
+    /**
+     * 规则值类型(1.固定值,2.系统上下问变量)
+     */
+    private Integer ruleType;
+    /**
+     * 角色名称
+     */
+    private String roleName;
+    /**
+     * 资源名称
+     */
+    private String resourceName;
+    @Override
+    public int hashCode() {
+        return this.getId().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof DimensionResourceRuleEntity) {
+            DimensionResourceRuleEntity tmp = (DimensionResourceRuleEntity) obj;
+            if (this.getId() == tmp.getId()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void initAttrValue(){
+        this.roleId = null;
+        this.resourceId = null;
+        this.ruleCode = "";
+        this.ruleName = "";
+        this.ruleCondition = "IN";
+        this.ruleValue = "";
+        this.ruleType = 1;
+        this.roleName = "";
+        this.resourceName = "";
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/DimensionResourceRuleQuery.java

+package com.mortals.xhx.module.dimension.model;
+
+import java.util.List;
+/**
+ * 角色资源维度规则查询对象
+ *
+ * @author zxfei
+ * @date 2024-05-22
+ */
+public class DimensionResourceRuleQuery extends DimensionResourceRuleEntity {
+    /** 开始 序号，主键，自增长 */
+    private Long idStart;
+
+    /** 结束 序号，主键，自增长 */
+    private Long idEnd;
+
+    /** 增加 序号，主键，自增长 */
+    private Long idIncrement;
+
+    /** 序号，主键，自增长列表 */
+    private List <Long> idList;
+
+    /** 序号，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
+    /** 开始 角色ID */
+    private Long roleIdStart;
+
+    /** 结束 角色ID */
+    private Long roleIdEnd;
+
+    /** 增加 角色ID */
+    private Long roleIdIncrement;
+
+    /** 角色ID列表 */
+    private List <Long> roleIdList;
+
+    /** 角色ID排除列表 */
+    private List <Long> roleIdNotList;
+
+    /** 开始 资源ID */
+    private Long resourceIdStart;
+
+    /** 结束 资源ID */
+    private Long resourceIdEnd;
+
+    /** 增加 资源ID */
+    private Long resourceIdIncrement;
+
+    /** 资源ID列表 */
+    private List <Long> resourceIdList;
+
+    /** 资源ID排除列表 */
+    private List <Long> resourceIdNotList;
+
+    /** 规则编码 */
+    private List<String> ruleCodeList;
+
+    /** 规则编码排除列表 */
+    private List <String> ruleCodeNotList;
+    /** 规则名称 */
+    private List<String> ruleNameList;
+
+    /** 规则名称排除列表 */
+    private List <String> ruleNameNotList;
+    /** 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊) */
+    private List<String> ruleConditionList;
+
+    /** 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)排除列表 */
+    private List <String> ruleConditionNotList;
+    /** 规则值,固定值或者系统变量 */
+    private List<String> ruleValueList;
+
+    /** 规则值,固定值或者系统变量排除列表 */
+    private List <String> ruleValueNotList;
+    /** 开始 规则值类型(1.固定值,2.系统上下问变量) */
+    private Integer ruleTypeStart;
+
+    /** 结束 规则值类型(1.固定值,2.系统上下问变量) */
+    private Integer ruleTypeEnd;
+
+    /** 增加 规则值类型(1.固定值,2.系统上下问变量) */
+    private Integer ruleTypeIncrement;
+
+    /** 规则值类型(1.固定值,2.系统上下问变量)列表 */
+    private List <Integer> ruleTypeList;
+
+    /** 规则值类型(1.固定值,2.系统上下问变量)排除列表 */
+    private List <Integer> ruleTypeNotList;
+
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建用户 */
+    private Long createUserIdStart;
+
+    /** 结束 创建用户 */
+    private Long createUserIdEnd;
+
+    /** 增加 创建用户 */
+    private Long createUserIdIncrement;
+
+    /** 创建用户列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 开始 更新用户 */
+    private Long updateUserIdStart;
+
+    /** 结束 更新用户 */
+    private Long updateUserIdEnd;
+
+    /** 增加 更新用户 */
+    private Long updateUserIdIncrement;
+
+    /** 更新用户列表 */
+    private List <Long> updateUserIdList;
+
+    /** 更新用户排除列表 */
+    private List <Long> updateUserIdNotList;
+
+    /** 开始 更新时间 */
+    private String updateTimeStart;
+
+    /** 结束 更新时间 */
+    private String updateTimeEnd;
+
+    /** 角色名称 */
+    private List<String> roleNameList;
+
+    /** 角色名称排除列表 */
+    private List <String> roleNameNotList;
+    /** 资源名称 */
+    private List<String> resourceNameList;
+
+    /** 资源名称排除列表 */
+    private List <String> resourceNameNotList;
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<DimensionResourceRuleQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<DimensionResourceRuleQuery> andConditionList;
+
+    public DimensionResourceRuleQuery(){}
+
+    /**
+     * 获取 开始 序号，主键，自增长
+     * @return idStart
+     */
+    public Long getIdStart(){
+        return this.idStart;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
+    public void setIdStart(Long idStart){
+        this.idStart = idStart;
+    }
+
+    /**
+     * 获取 结束 序号，主键，自增长
+     * @return $idEnd
+     */
+    public Long getIdEnd(){
+        return this.idEnd;
+    }
+
+    /**
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
+    public void setIdEnd(Long idEnd){
+        this.idEnd = idEnd;
+    }
+
+    /**
+     * 获取 增加 序号，主键，自增长
+     * @return idIncrement
+     */
+    public Long getIdIncrement(){
+        return this.idIncrement;
+    }
+
+    /**
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
+    public void setIdIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+    }
+
+    /**
+     * 获取 序号，主键，自增长
+     * @return idList
+     */
+    public List<Long> getIdList(){
+        return this.idList;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
+    public void setIdList(List<Long> idList){
+        this.idList = idList;
+    }
+
+    /**
+     * 获取 序号，主键，自增长
+     * @return idNotList
+     */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+     * 获取 开始 角色ID
+     * @return roleIdStart
+     */
+    public Long getRoleIdStart(){
+        return this.roleIdStart;
+    }
+
+    /**
+     * 设置 开始 角色ID
+     * @param roleIdStart
+     */
+    public void setRoleIdStart(Long roleIdStart){
+        this.roleIdStart = roleIdStart;
+    }
+
+    /**
+     * 获取 结束 角色ID
+     * @return $roleIdEnd
+     */
+    public Long getRoleIdEnd(){
+        return this.roleIdEnd;
+    }
+
+    /**
+     * 设置 结束 角色ID
+     * @param roleIdEnd
+     */
+    public void setRoleIdEnd(Long roleIdEnd){
+        this.roleIdEnd = roleIdEnd;
+    }
+
+    /**
+     * 获取 增加 角色ID
+     * @return roleIdIncrement
+     */
+    public Long getRoleIdIncrement(){
+        return this.roleIdIncrement;
+    }
+
+    /**
+     * 设置 增加 角色ID
+     * @param roleIdIncrement
+     */
+    public void setRoleIdIncrement(Long roleIdIncrement){
+        this.roleIdIncrement = roleIdIncrement;
+    }
+
+    /**
+     * 获取 角色ID
+     * @return roleIdList
+     */
+    public List<Long> getRoleIdList(){
+        return this.roleIdList;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdList
+     */
+    public void setRoleIdList(List<Long> roleIdList){
+        this.roleIdList = roleIdList;
+    }
+
+    /**
+     * 获取 角色ID
+     * @return roleIdNotList
+     */
+    public List<Long> getRoleIdNotList(){
+        return this.roleIdNotList;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdNotList
+     */
+    public void setRoleIdNotList(List<Long> roleIdNotList){
+        this.roleIdNotList = roleIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 资源ID
+     * @return resourceIdStart
+     */
+    public Long getResourceIdStart(){
+        return this.resourceIdStart;
+    }
+
+    /**
+     * 设置 开始 资源ID
+     * @param resourceIdStart
+     */
+    public void setResourceIdStart(Long resourceIdStart){
+        this.resourceIdStart = resourceIdStart;
+    }
+
+    /**
+     * 获取 结束 资源ID
+     * @return $resourceIdEnd
+     */
+    public Long getResourceIdEnd(){
+        return this.resourceIdEnd;
+    }
+
+    /**
+     * 设置 结束 资源ID
+     * @param resourceIdEnd
+     */
+    public void setResourceIdEnd(Long resourceIdEnd){
+        this.resourceIdEnd = resourceIdEnd;
+    }
+
+    /**
+     * 获取 增加 资源ID
+     * @return resourceIdIncrement
+     */
+    public Long getResourceIdIncrement(){
+        return this.resourceIdIncrement;
+    }
+
+    /**
+     * 设置 增加 资源ID
+     * @param resourceIdIncrement
+     */
+    public void setResourceIdIncrement(Long resourceIdIncrement){
+        this.resourceIdIncrement = resourceIdIncrement;
+    }
+
+    /**
+     * 获取 资源ID
+     * @return resourceIdList
+     */
+    public List<Long> getResourceIdList(){
+        return this.resourceIdList;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdList
+     */
+    public void setResourceIdList(List<Long> resourceIdList){
+        this.resourceIdList = resourceIdList;
+    }
+
+    /**
+     * 获取 资源ID
+     * @return resourceIdNotList
+     */
+    public List<Long> getResourceIdNotList(){
+        return this.resourceIdNotList;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdNotList
+     */
+    public void setResourceIdNotList(List<Long> resourceIdNotList){
+        this.resourceIdNotList = resourceIdNotList;
+    }
+
+
+    /**
+     * 获取 规则编码
+     * @return ruleCodeList
+     */
+    public List<String> getRuleCodeList(){
+        return this.ruleCodeList;
+    }
+
+    /**
+     * 设置 规则编码
+     * @param ruleCodeList
+     */
+    public void setRuleCodeList(List<String> ruleCodeList){
+        this.ruleCodeList = ruleCodeList;
+    }
+
+    /**
+     * 获取 规则编码
+     * @return ruleCodeNotList
+     */
+    public List<String> getRuleCodeNotList(){
+        return this.ruleCodeNotList;
+    }
+
+    /**
+     * 设置 规则编码
+     * @param ruleCodeNotList
+     */
+    public void setRuleCodeNotList(List<String> ruleCodeNotList){
+        this.ruleCodeNotList = ruleCodeNotList;
+    }
+
+    /**
+     * 获取 规则名称
+     * @return ruleNameList
+     */
+    public List<String> getRuleNameList(){
+        return this.ruleNameList;
+    }
+
+    /**
+     * 设置 规则名称
+     * @param ruleNameList
+     */
+    public void setRuleNameList(List<String> ruleNameList){
+        this.ruleNameList = ruleNameList;
+    }
+
+    /**
+     * 获取 规则名称
+     * @return ruleNameNotList
+     */
+    public List<String> getRuleNameNotList(){
+        return this.ruleNameNotList;
+    }
+
+    /**
+     * 设置 规则名称
+     * @param ruleNameNotList
+     */
+    public void setRuleNameNotList(List<String> ruleNameNotList){
+        this.ruleNameNotList = ruleNameNotList;
+    }
+
+    /**
+     * 获取 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @return ruleConditionList
+     */
+    public List<String> getRuleConditionList(){
+        return this.ruleConditionList;
+    }
+
+    /**
+     * 设置 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @param ruleConditionList
+     */
+    public void setRuleConditionList(List<String> ruleConditionList){
+        this.ruleConditionList = ruleConditionList;
+    }
+
+    /**
+     * 获取 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @return ruleConditionNotList
+     */
+    public List<String> getRuleConditionNotList(){
+        return this.ruleConditionNotList;
+    }
+
+    /**
+     * 设置 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @param ruleConditionNotList
+     */
+    public void setRuleConditionNotList(List<String> ruleConditionNotList){
+        this.ruleConditionNotList = ruleConditionNotList;
+    }
+
+    /**
+     * 获取 规则值,固定值或者系统变量
+     * @return ruleValueList
+     */
+    public List<String> getRuleValueList(){
+        return this.ruleValueList;
+    }
+
+    /**
+     * 设置 规则值,固定值或者系统变量
+     * @param ruleValueList
+     */
+    public void setRuleValueList(List<String> ruleValueList){
+        this.ruleValueList = ruleValueList;
+    }
+
+    /**
+     * 获取 规则值,固定值或者系统变量
+     * @return ruleValueNotList
+     */
+    public List<String> getRuleValueNotList(){
+        return this.ruleValueNotList;
+    }
+
+    /**
+     * 设置 规则值,固定值或者系统变量
+     * @param ruleValueNotList
+     */
+    public void setRuleValueNotList(List<String> ruleValueNotList){
+        this.ruleValueNotList = ruleValueNotList;
+    }
+
+    /**
+     * 获取 开始 规则值类型(1.固定值,2.系统上下问变量)
+     * @return ruleTypeStart
+     */
+    public Integer getRuleTypeStart(){
+        return this.ruleTypeStart;
+    }
+
+    /**
+     * 设置 开始 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeStart
+     */
+    public void setRuleTypeStart(Integer ruleTypeStart){
+        this.ruleTypeStart = ruleTypeStart;
+    }
+
+    /**
+     * 获取 结束 规则值类型(1.固定值,2.系统上下问变量)
+     * @return $ruleTypeEnd
+     */
+    public Integer getRuleTypeEnd(){
+        return this.ruleTypeEnd;
+    }
+
+    /**
+     * 设置 结束 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeEnd
+     */
+    public void setRuleTypeEnd(Integer ruleTypeEnd){
+        this.ruleTypeEnd = ruleTypeEnd;
+    }
+
+    /**
+     * 获取 增加 规则值类型(1.固定值,2.系统上下问变量)
+     * @return ruleTypeIncrement
+     */
+    public Integer getRuleTypeIncrement(){
+        return this.ruleTypeIncrement;
+    }
+
+    /**
+     * 设置 增加 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeIncrement
+     */
+    public void setRuleTypeIncrement(Integer ruleTypeIncrement){
+        this.ruleTypeIncrement = ruleTypeIncrement;
+    }
+
+    /**
+     * 获取 规则值类型(1.固定值,2.系统上下问变量)
+     * @return ruleTypeList
+     */
+    public List<Integer> getRuleTypeList(){
+        return this.ruleTypeList;
+    }
+
+    /**
+     * 设置 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeList
+     */
+    public void setRuleTypeList(List<Integer> ruleTypeList){
+        this.ruleTypeList = ruleTypeList;
+    }
+
+    /**
+     * 获取 规则值类型(1.固定值,2.系统上下问变量)
+     * @return ruleTypeNotList
+     */
+    public List<Integer> getRuleTypeNotList(){
+        return this.ruleTypeNotList;
+    }
+
+    /**
+     * 设置 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeNotList
+     */
+    public void setRuleTypeNotList(List<Integer> ruleTypeNotList){
+        this.ruleTypeNotList = ruleTypeNotList;
+    }
+
+
+    /**
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
+    public String getCreateTimeStart(){
+        return this.createTimeStart;
+    }
+
+    /**
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
+    public void setCreateTimeStart(String createTimeStart){
+        this.createTimeStart = createTimeStart;
+    }
+
+    /**
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
+    public String getCreateTimeEnd(){
+        return this.createTimeEnd;
+    }
+
+    /**
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
+    public void setCreateTimeEnd(String createTimeEnd){
+        this.createTimeEnd = createTimeEnd;
+    }
+
+    /**
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
+    public Long getCreateUserIdStart(){
+        return this.createUserIdStart;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
+    public void setCreateUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+    }
+
+    /**
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
+    public Long getCreateUserIdEnd(){
+        return this.createUserIdEnd;
+    }
+
+    /**
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
+    public void setCreateUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+    }
+
+    /**
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
+    public Long getCreateUserIdIncrement(){
+        return this.createUserIdIncrement;
+    }
+
+    /**
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
+    public void setCreateUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+    }
+
+    /**
+     * 获取 创建用户
+     * @return createUserIdList
+     */
+    public List<Long> getCreateUserIdList(){
+        return this.createUserIdList;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdList
+     */
+    public void setCreateUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+    }
+
+    /**
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 更新用户
+     * @return updateUserIdStart
+     */
+    public Long getUpdateUserIdStart(){
+        return this.updateUserIdStart;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
+    public void setUpdateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+    }
+
+    /**
+     * 获取 结束 更新用户
+     * @return $updateUserIdEnd
+     */
+    public Long getUpdateUserIdEnd(){
+        return this.updateUserIdEnd;
+    }
+
+    /**
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
+    public void setUpdateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+    }
+
+    /**
+     * 获取 增加 更新用户
+     * @return updateUserIdIncrement
+     */
+    public Long getUpdateUserIdIncrement(){
+        return this.updateUserIdIncrement;
+    }
+
+    /**
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
+    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+    }
+
+    /**
+     * 获取 更新用户
+     * @return updateUserIdList
+     */
+    public List<Long> getUpdateUserIdList(){
+        return this.updateUserIdList;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
+    public void setUpdateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+    }
+
+    /**
+     * 获取 更新用户
+     * @return updateUserIdNotList
+     */
+    public List<Long> getUpdateUserIdNotList(){
+        return this.updateUserIdNotList;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 更新时间
+     * @return updateTimeStart
+     */
+    public String getUpdateTimeStart(){
+        return this.updateTimeStart;
+    }
+
+    /**
+     * 设置 开始 更新时间
+     * @param updateTimeStart
+     */
+    public void setUpdateTimeStart(String updateTimeStart){
+        this.updateTimeStart = updateTimeStart;
+    }
+
+    /**
+     * 获取 结束 更新时间
+     * @return updateTimeEnd
+     */
+    public String getUpdateTimeEnd(){
+        return this.updateTimeEnd;
+    }
+
+    /**
+     * 设置 结束 更新时间
+     * @param updateTimeEnd
+     */
+    public void setUpdateTimeEnd(String updateTimeEnd){
+        this.updateTimeEnd = updateTimeEnd;
+    }
+
+    /**
+     * 获取 角色名称
+     * @return roleNameList
+     */
+    public List<String> getRoleNameList(){
+        return this.roleNameList;
+    }
+
+    /**
+     * 设置 角色名称
+     * @param roleNameList
+     */
+    public void setRoleNameList(List<String> roleNameList){
+        this.roleNameList = roleNameList;
+    }
+
+    /**
+     * 获取 角色名称
+     * @return roleNameNotList
+     */
+    public List<String> getRoleNameNotList(){
+        return this.roleNameNotList;
+    }
+
+    /**
+     * 设置 角色名称
+     * @param roleNameNotList
+     */
+    public void setRoleNameNotList(List<String> roleNameNotList){
+        this.roleNameNotList = roleNameNotList;
+    }
+
+    /**
+     * 获取 资源名称
+     * @return resourceNameList
+     */
+    public List<String> getResourceNameList(){
+        return this.resourceNameList;
+    }
+
+    /**
+     * 设置 资源名称
+     * @param resourceNameList
+     */
+    public void setResourceNameList(List<String> resourceNameList){
+        this.resourceNameList = resourceNameList;
+    }
+
+    /**
+     * 获取 资源名称
+     * @return resourceNameNotList
+     */
+    public List<String> getResourceNameNotList(){
+        return this.resourceNameNotList;
+    }
+
+    /**
+     * 设置 资源名称
+     * @param resourceNameNotList
+     */
+    public void setResourceNameNotList(List<String> resourceNameNotList){
+        this.resourceNameNotList = resourceNameNotList;
+    }
+
+    /**
+     * 设置  序号，主键，自增长
+     * @param id
+     */
+    public DimensionResourceRuleQuery id(Long id){
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
+    public DimensionResourceRuleQuery idStart(Long idStart){
+        this.idStart = idStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
+    public DimensionResourceRuleQuery idEnd(Long idEnd){
+        this.idEnd = idEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
+    public DimensionResourceRuleQuery idIncrement(Long idIncrement){
+        this.idIncrement = idIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
+    public DimensionResourceRuleQuery idList(List<Long> idList){
+        this.idList = idList;
+        return this;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public DimensionResourceRuleQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+    }
+
+    /**
+     * 设置  角色ID
+     * @param roleId
+     */
+    public DimensionResourceRuleQuery roleId(Long roleId){
+        setRoleId(roleId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 角色ID
+     * @param roleIdStart
+     */
+    public DimensionResourceRuleQuery roleIdStart(Long roleIdStart){
+        this.roleIdStart = roleIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 角色ID
+     * @param roleIdEnd
+     */
+    public DimensionResourceRuleQuery roleIdEnd(Long roleIdEnd){
+        this.roleIdEnd = roleIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 角色ID
+     * @param roleIdIncrement
+     */
+    public DimensionResourceRuleQuery roleIdIncrement(Long roleIdIncrement){
+        this.roleIdIncrement = roleIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdList
+     */
+    public DimensionResourceRuleQuery roleIdList(List<Long> roleIdList){
+        this.roleIdList = roleIdList;
+        return this;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdNotList
+     */
+    public DimensionResourceRuleQuery roleIdNotList(List<Long> roleIdNotList){
+        this.roleIdNotList = roleIdNotList;
+        return this;
+    }
+
+    /**
+     * 设置  资源ID
+     * @param resourceId
+     */
+    public DimensionResourceRuleQuery resourceId(Long resourceId){
+        setResourceId(resourceId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 资源ID
+     * @param resourceIdStart
+     */
+    public DimensionResourceRuleQuery resourceIdStart(Long resourceIdStart){
+        this.resourceIdStart = resourceIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 资源ID
+     * @param resourceIdEnd
+     */
+    public DimensionResourceRuleQuery resourceIdEnd(Long resourceIdEnd){
+        this.resourceIdEnd = resourceIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 资源ID
+     * @param resourceIdIncrement
+     */
+    public DimensionResourceRuleQuery resourceIdIncrement(Long resourceIdIncrement){
+        this.resourceIdIncrement = resourceIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdList
+     */
+    public DimensionResourceRuleQuery resourceIdList(List<Long> resourceIdList){
+        this.resourceIdList = resourceIdList;
+        return this;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdNotList
+     */
+    public DimensionResourceRuleQuery resourceIdNotList(List<Long> resourceIdNotList){
+        this.resourceIdNotList = resourceIdNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置 规则编码
+     * @param ruleCode
+     */
+    public DimensionResourceRuleQuery ruleCode(String ruleCode){
+        setRuleCode(ruleCode);
+        return this;
+    }
+
+    /**
+     * 设置 规则编码
+     * @param ruleCodeList
+     */
+    public DimensionResourceRuleQuery ruleCodeList(List<String> ruleCodeList){
+        this.ruleCodeList = ruleCodeList;
+        return this;
+    }
+
+
+    /**
+     * 设置 规则名称
+     * @param ruleName
+     */
+    public DimensionResourceRuleQuery ruleName(String ruleName){
+        setRuleName(ruleName);
+        return this;
+    }
+
+    /**
+     * 设置 规则名称
+     * @param ruleNameList
+     */
+    public DimensionResourceRuleQuery ruleNameList(List<String> ruleNameList){
+        this.ruleNameList = ruleNameList;
+        return this;
+    }
+
+
+    /**
+     * 设置 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @param ruleCondition
+     */
+    public DimensionResourceRuleQuery ruleCondition(String ruleCondition){
+        setRuleCondition(ruleCondition);
+        return this;
+    }
+
+    /**
+     * 设置 规则条件(IN.属于,<.小于,>.大于,=.等于,!=.不等于,>=.大于等于,<=.小于等于,like %.左模糊,like %.右模糊)
+     * @param ruleConditionList
+     */
+    public DimensionResourceRuleQuery ruleConditionList(List<String> ruleConditionList){
+        this.ruleConditionList = ruleConditionList;
+        return this;
+    }
+
+
+    /**
+     * 设置 规则值,固定值或者系统变量
+     * @param ruleValue
+     */
+    public DimensionResourceRuleQuery ruleValue(String ruleValue){
+        setRuleValue(ruleValue);
+        return this;
+    }
+
+    /**
+     * 设置 规则值,固定值或者系统变量
+     * @param ruleValueList
+     */
+    public DimensionResourceRuleQuery ruleValueList(List<String> ruleValueList){
+        this.ruleValueList = ruleValueList;
+        return this;
+    }
+
+    /**
+     * 设置  规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleType
+     */
+    public DimensionResourceRuleQuery ruleType(Integer ruleType){
+        setRuleType(ruleType);
+        return this;
+    }
+
+    /**
+     * 设置 开始 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeStart
+     */
+    public DimensionResourceRuleQuery ruleTypeStart(Integer ruleTypeStart){
+        this.ruleTypeStart = ruleTypeStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeEnd
+     */
+    public DimensionResourceRuleQuery ruleTypeEnd(Integer ruleTypeEnd){
+        this.ruleTypeEnd = ruleTypeEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeIncrement
+     */
+    public DimensionResourceRuleQuery ruleTypeIncrement(Integer ruleTypeIncrement){
+        this.ruleTypeIncrement = ruleTypeIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeList
+     */
+    public DimensionResourceRuleQuery ruleTypeList(List<Integer> ruleTypeList){
+        this.ruleTypeList = ruleTypeList;
+        return this;
+    }
+
+    /**
+     * 设置 规则值类型(1.固定值,2.系统上下问变量)
+     * @param ruleTypeNotList
+     */
+    public DimensionResourceRuleQuery ruleTypeNotList(List<Integer> ruleTypeNotList){
+        this.ruleTypeNotList = ruleTypeNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置  创建用户
+     * @param createUserId
+     */
+    public DimensionResourceRuleQuery createUserId(Long createUserId){
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
+    public DimensionResourceRuleQuery createUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
+    public DimensionResourceRuleQuery createUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
+    public DimensionResourceRuleQuery createUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdList
+     */
+    public DimensionResourceRuleQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public DimensionResourceRuleQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+    }
+
+    /**
+     * 设置  更新用户
+     * @param updateUserId
+     */
+    public DimensionResourceRuleQuery updateUserId(Long updateUserId){
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
+    public DimensionResourceRuleQuery updateUserIdStart(Long updateUserIdStart){
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
+    public DimensionResourceRuleQuery updateUserIdEnd(Long updateUserIdEnd){
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
+    public DimensionResourceRuleQuery updateUserIdIncrement(Long updateUserIdIncrement){
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
+    public DimensionResourceRuleQuery updateUserIdList(List<Long> updateUserIdList){
+        this.updateUserIdList = updateUserIdList;
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public DimensionResourceRuleQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        this.updateUserIdNotList = updateUserIdNotList;
+        return this;
+    }
+
+
+
+    /**
+     * 设置 角色名称
+     * @param roleName
+     */
+    public DimensionResourceRuleQuery roleName(String roleName){
+        setRoleName(roleName);
+        return this;
+    }
+
+    /**
+     * 设置 角色名称
+     * @param roleNameList
+     */
+    public DimensionResourceRuleQuery roleNameList(List<String> roleNameList){
+        this.roleNameList = roleNameList;
+        return this;
+    }
+
+
+    /**
+     * 设置 资源名称
+     * @param resourceName
+     */
+    public DimensionResourceRuleQuery resourceName(String resourceName){
+        setResourceName(resourceName);
+        return this;
+    }
+
+    /**
+     * 设置 资源名称
+     * @param resourceNameList
+     */
+    public DimensionResourceRuleQuery resourceNameList(List<String> resourceNameList){
+        this.resourceNameList = resourceNameList;
+        return this;
+    }
+
+    /**
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
+    public List<DimensionResourceRuleQuery> getOrConditionList(){
+        return this.orConditionList;
+    }
+
+    /**
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
+    public void setOrConditionList(List<DimensionResourceRuleQuery> orConditionList){
+        this.orConditionList = orConditionList;
+    }
+
+    /**
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
+    public List<DimensionResourceRuleQuery> getAndConditionList(){
+        return this.andConditionList;
+    }
+
+    /**
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
+    public void setAndConditionList(List<DimensionResourceRuleQuery> andConditionList){
+        this.andConditionList = andConditionList;
+    }
+
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/vo/DimensionResourceRuleVo.java

+package com.mortals.xhx.module.dimension.model.vo;
+
+import com.mortals.framework.model.BaseEntityLong;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+* 角色资源维度规则视图对象
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Data
+public class DimensionResourceRuleVo extends BaseEntityLong {
+
+    /** 序号，主键，自增长列表 */
+    private List <Long> idList;
+
+
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/model/vo/DimensionVo.java

+package com.mortals.xhx.module.dimension.model.vo;
+
+import com.mortals.framework.model.BaseEntityLong;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+* 授权维度视图对象
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Data
+public class DimensionVo extends BaseEntityLong {
+
+    /** 序号，主键，自增长列表 */
+    private List <Long> idList;
+
+
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/service/DimensionResourceRuleService.java

+package com.mortals.xhx.module.dimension.service;
+
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.dimension.dao.DimensionResourceRuleDao;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+
+import java.util.List;
+
+/**
+* DimensionResourceRuleService
+*
+* 角色资源维度规则 service接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+public interface DimensionResourceRuleService extends ICRUDService<DimensionResourceRuleEntity,Long>{
+
+    DimensionResourceRuleDao getDao();
+
+    /**
+     * 根据当前controller路由获取用户角色资源维度规则
+     * @param userId
+     * @param route 当前controller路由
+     * @return
+     */
+    List<DimensionResourceRuleEntity> getRoleComponentRule(Long userId,String route);
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/service/DimensionService.java

+package com.mortals.xhx.module.dimension.service;
+
+import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.dimension.dao.DimensionDao;
+import com.mortals.xhx.module.dimension.model.DimensionEntity;
+/**
+* DimensionService
+*
+* 授权维度 service接口
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+public interface DimensionService extends ICRUDService<DimensionEntity,Long>{
+
+    DimensionDao getDao();
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/service/impl/DimensionResourceRuleServiceImpl.java

+package com.mortals.xhx.module.dimension.service.impl;
+
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.xhx.module.dimension.dao.DimensionResourceRuleDao;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import com.mortals.xhx.module.dimension.service.DimensionResourceRuleService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+* DimensionResourceRuleService
+* 角色资源维度规则 service实现
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Service("dimensionResourceRuleService")
+@Slf4j
+public class DimensionResourceRuleServiceImpl extends AbstractCRUDServiceImpl<DimensionResourceRuleDao, DimensionResourceRuleEntity, Long> implements DimensionResourceRuleService {
+
+    /**
+     * @param userId
+     * @param route  当前controller路由
+     * @return
+     */
+    @Override
+    public List<DimensionResourceRuleEntity> getRoleComponentRule(Long userId, String route) {
+         return this.getDao().getRoleComponentRule(userId, route);
+
+    }
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/service/impl/DimensionServiceImpl.java

+package com.mortals.xhx.module.dimension.service.impl;
+
+import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.xhx.module.dimension.dao.DimensionDao;
+import com.mortals.xhx.module.dimension.model.DimensionEntity;
+import com.mortals.xhx.module.dimension.service.DimensionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+/**
+* DimensionService
+* 授权维度 service实现
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@Service("dimensionService")
+@Slf4j
+public class DimensionServiceImpl extends AbstractCRUDServiceImpl<DimensionDao, DimensionEntity, Long> implements DimensionService {
+    
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/web/DimensionController.java

+package com.mortals.xhx.module.dimension.web;
+
+import com.mortals.framework.model.Context;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.param.service.ParamService;
+import com.mortals.xhx.common.code.DimensionTypeEnum;
+import com.mortals.xhx.module.dimension.model.DimensionEntity;
+import com.mortals.xhx.module.dimension.service.DimensionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+*
+* 授权维度
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@RestController
+@RequestMapping("dimension")
+public class DimensionController extends BaseCRUDJsonBodyMappingController<DimensionService,DimensionEntity,Long> {
+
+    @Autowired
+    private ParamService paramService;
+
+    public DimensionController(){
+        super.setModuleDesc( "授权维度");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+                this.addDict(model, "dimensionType", DimensionTypeEnum.getEnumMap());
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/module/dimension/web/DimensionResourceRuleController.java

+package com.mortals.xhx.module.dimension.web;
+
+import com.mortals.framework.model.Context;
+import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
+import com.mortals.xhx.base.system.param.service.ParamService;
+import com.mortals.xhx.common.code.RuleConditionEnum;
+import com.mortals.xhx.common.code.RuleTypeEnum;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import com.mortals.xhx.module.dimension.service.DimensionResourceRuleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+*
+* 角色资源维度规则
+*
+* @author zxfei
+* @date 2024-05-16
+*/
+@RestController
+@RequestMapping("dimension/resource/rule")
+public class DimensionResourceRuleController extends BaseCRUDJsonBodyMappingController<DimensionResourceRuleService,DimensionResourceRuleEntity,Long> {
+
+    @Autowired
+    private ParamService paramService;
+
+    public DimensionResourceRuleController(){
+        super.setModuleDesc( "角色资源维度规则");
+    }
+
+    @Override
+    protected void init(Map<String, Object> model, Context context) {
+                this.addDict(model, "ruleCondition", RuleConditionEnum.getEnumMap());
+                this.addDict(model, "ruleType", RuleTypeEnum.getEnumMap());
+        super.init(model, context);
+    }
+
+
+}
\ No newline at end of file

base-manager/src/main/resources/sqlmap/module/dimension/DimensionMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.dimension.dao.ibatis.DimensionDaoImpl">
+
+    <!-- 字段和属性映射 -->
+    <resultMap type="DimensionEntity" id="DimensionEntity-Map">
+            <id  property="id" column="id" />
+            <result property="dimensionCode" column="dimension_code" />
+            <result property="dimensionName" column="dimension_name" />
+            <result property="dimensionValue" column="dimension_value" />
+            <result property="dimensionType" column="dimension_type" />
+            <result property="createTime" column="createTime" />
+            <result property="createUserId" column="createUserId" />
+            <result property="updateUserId" column="updateUserId" />
+            <result property="updateTime" column="updateTime" />
+            
+    </resultMap>
+
+
+    <!-- 表所有列 -->
+    <sql id="_columns">
+        <trim suffixOverrides="," suffix="">
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                    a.id,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dimensionCode') or colPickMode == 1 and data.containsKey('dimensionCode')))">
+                    a.dimension_code,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dimensionName') or colPickMode == 1 and data.containsKey('dimensionName')))">
+                    a.dimension_name,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dimensionValue') or colPickMode == 1 and data.containsKey('dimensionValue')))">
+                    a.dimension_value,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dimensionType') or colPickMode == 1 and data.containsKey('dimensionType')))">
+                    a.dimension_type,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                    a.createTime,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                    a.createUserId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                    a.updateUserId,
+                </if>
+                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
+                    a.updateTime,
+                </if>
+        </trim>
+    </sql>
+    <!-- 新增 区分主键自增加还是业务插入 -->
+    <insert id="insert" parameterType="DimensionEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_dimension
+        (dimension_code,dimension_name,dimension_value,dimension_type,createTime,createUserId,updateUserId,updateTime)
+        VALUES
+        (#{dimensionCode},#{dimensionName},#{dimensionValue},#{dimensionType},#{createTime},#{createUserId},#{updateUserId},#{updateTime})
+    </insert>
+
+    <!-- 批量新增 -->
+    <insert id="insertBatch" parameterType="paramDto">
+        insert into mortals_xhx_dimension
+        (dimension_code,dimension_name,dimension_value,dimension_type,createTime,createUserId,updateUserId,updateTime)
+        VALUES
+        <foreach collection="data.dataList" item="item" index="index" separator="," >
+            (#{item.dimensionCode},#{item.dimensionName},#{item.dimensionValue},#{item.dimensionType},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime})
+        </foreach>
+    </insert>
+
+
+    <!-- 根据ParamDto更新 -->
+    <update id="update" parameterType="paramDto">
+        update mortals_xhx_dimension as a
+        set
+        <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('dimensionCode')) or (colPickMode==1 and !data.containsKey('dimensionCode'))">
+                a.dimension_code=#{data.dimensionCode},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dimensionName')) or (colPickMode==1 and !data.containsKey('dimensionName'))">
+                a.dimension_name=#{data.dimensionName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dimensionValue')) or (colPickMode==1 and !data.containsKey('dimensionValue'))">
+                a.dimension_value=#{data.dimensionValue},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dimensionType')) or (colPickMode==1 and !data.containsKey('dimensionType'))">
+                a.dimension_type=#{data.dimensionType},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dimensionTypeIncrement')) or (colPickMode==1 and !data.containsKey('dimensionTypeIncrement'))">
+                a.dimension_type=ifnull(a.dimension_type,0) + #{data.dimensionTypeIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.createTime=#{data.createTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
+                a.createUserId=#{data.createUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
+                a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
+                a.updateUserId=#{data.updateUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
+                a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
+                a.updateTime=#{data.updateTime},
+            </if>
+        </trim>
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </update>
+    <!-- 批量更新 -->
+    <update id="updateBatch" parameterType="paramDto">
+        update mortals_xhx_dimension as a
+        <trim prefix="set" suffixOverrides=",">
+                <trim prefix="dimension_code=(case" suffix="ELSE dimension_code end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('dimensionCode')) or (colPickMode==1 and !item.containsKey('dimensionCode'))">
+                            when a.id=#{item.id} then #{item.dimensionCode}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="dimension_name=(case" suffix="ELSE dimension_name end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('dimensionName')) or (colPickMode==1 and !item.containsKey('dimensionName'))">
+                            when a.id=#{item.id} then #{item.dimensionName}
+                        </if>
+                    </foreach>
+                </trim>
+                <trim prefix="dimension_value=(case" suffix="ELSE dimension_value end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('dimensionValue')) or (colPickMode==1 and !item.containsKey('dimensionValue'))">
+                            when a.id=#{item.id} then #{item.dimensionValue}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="dimension_type=(case" suffix="ELSE dimension_type end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('dimensionType')) or (colPickMode==1 and !item.containsKey('dimensionType'))">
+                                        when a.id=#{item.id} then #{item.dimensionType}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('dimensionTypeIncrement')) or (colPickMode==1 and !item.containsKey('dimensionTypeIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.dimension_type,0) + #{item.dimensionTypeIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                            when a.id=#{item.id} then #{item.createTime}
+                        </if>
+                    </foreach>
+                </trim>
+                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                                        when a.id=#{item.id} then #{item.createUserId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                        <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
+                            <foreach collection="data.dataList" item="item" index="index" separator="" >
+                                <choose>
+                                    <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
+                                        when a.id=#{item.id} then #{item.updateUserId}
+                                    </when>
+                                    <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
+                                        when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
+                                    </when>
+                                </choose>
+                            </foreach>
+                        </trim>
+                <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
+                    <foreach collection="data.dataList" item="item" index="index" separator="" >
+                        <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                            when a.id=#{item.id} then #{item.updateTime}
+                        </if>
+                    </foreach>
+                </trim>
+        </trim>
+        where id in
+        <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </update>
+    <!-- 根据主健查询 -->
+    <select id="getByKey" parameterType="paramDto" resultMap="DimensionEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_dimension as a
+        where a.id=#{condition.id}
+    </select>
+    <!-- 根据主健删除 -->
+    <delete id="deleteByKey" parameterType="paramDto">
+        delete a.* from mortals_xhx_dimension as a where a.id=#{condition.id}
+    </delete>
+    <!-- 根据主健删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeys">
+        delete from mortals_xhx_dimension where id in
+        <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_dimension where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_dimension where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
+    <!-- 根据paramDto删除一批 -->
+    <delete id="deleteByMap" parameterType="paramDto">
+        delete a.* from mortals_xhx_dimension as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </delete>
+    <!-- 获取列表 -->
+    <select id="getList" parameterType="paramDto" resultMap="DimensionEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_dimension as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+        <include refid="_orderCols_"/>
+    </select>
+
+
+
+    <!-- 获取 -->
+    <select id="getListCount" parameterType="paramDto" resultType="int">
+        select count(1)
+        from mortals_xhx_dimension as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </select>
+    <!-- 条件映射 -->
+    <sql id="_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_condition_param_">
+                <property name="_conditionParam_" value="condition"/>
+                <property name="_conditionType_" value="and"/>
+            </include>
+            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
+            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
+                and
+                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
+                    <trim prefixOverrides="or" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="andCondition"/>
+                            <property name="_conditionType_" value="or"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
+            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
+                and
+                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
+                    <trim prefixOverrides="and" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null">
+                ${_conditionType_} a.id=#{${_conditionParam_}.id}
+            </if>
+        </if>
+            <if test="conditionParamRef.containsKey('id')">
+                <if test="conditionParamRef.id != null ">
+                    ${_conditionType_} a.id = #{${_conditionParam_}.id}
+                </if>
+                <if test="conditionParamRef.id == null">
+                    ${_conditionType_} a.id is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                ${_conditionType_} a.id in
+                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+                ${_conditionType_} a.id not in
+                <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+            </if>
+            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('dimensionCode')">
+                <if test="conditionParamRef.dimensionCode != null and conditionParamRef.dimensionCode != ''">
+                    ${_conditionType_} a.dimension_code like #{${_conditionParam_}.dimensionCode}
+                </if>
+                <if test="conditionParamRef.dimensionCode == null">
+                    ${_conditionType_} a.dimension_code is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionCodeList') and conditionParamRef.dimensionCodeList.size() > 0">
+                ${_conditionType_} a.dimension_code in
+                <foreach collection="conditionParamRef.dimensionCodeList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionCodeNotList') and conditionParamRef.dimensionCodeNotList.size() > 0">
+                ${_conditionType_} a.dimension_code not in
+                <foreach collection="conditionParamRef.dimensionCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('dimensionName')">
+                <if test="conditionParamRef.dimensionName != null and conditionParamRef.dimensionName != ''">
+                    ${_conditionType_} a.dimension_name like #{${_conditionParam_}.dimensionName}
+                </if>
+                <if test="conditionParamRef.dimensionName == null">
+                    ${_conditionType_} a.dimension_name is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionNameList') and conditionParamRef.dimensionNameList.size() > 0">
+                ${_conditionType_} a.dimension_name in
+                <foreach collection="conditionParamRef.dimensionNameList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionNameNotList') and conditionParamRef.dimensionNameNotList.size() > 0">
+                ${_conditionType_} a.dimension_name not in
+                <foreach collection="conditionParamRef.dimensionNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+
+            <if test="conditionParamRef.containsKey('dimensionValue')">
+                <if test="conditionParamRef.dimensionValue != null and conditionParamRef.dimensionValue != ''">
+                    ${_conditionType_} a.dimension_value like #{${_conditionParam_}.dimensionValue}
+                </if>
+                <if test="conditionParamRef.dimensionValue == null">
+                    ${_conditionType_} a.dimension_value is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionValueList') and conditionParamRef.dimensionValueList.size() > 0">
+                ${_conditionType_} a.dimension_value in
+                <foreach collection="conditionParamRef.dimensionValueList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionValueNotList') and conditionParamRef.dimensionValueNotList.size() > 0">
+                ${_conditionType_} a.dimension_value not in
+                <foreach collection="conditionParamRef.dimensionValueNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionType')">
+                <if test="conditionParamRef.dimensionType != null ">
+                    ${_conditionType_} a.dimension_type = #{${_conditionParam_}.dimensionType}
+                </if>
+                <if test="conditionParamRef.dimensionType == null">
+                    ${_conditionType_} a.dimension_type is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionTypeList') and conditionParamRef.dimensionTypeList.size() > 0">
+                ${_conditionType_} a.dimension_type in
+                <foreach collection="conditionParamRef.dimensionTypeList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionTypeNotList') and conditionParamRef.dimensionTypeNotList.size() > 0">
+                ${_conditionType_} a.dimension_type not in
+                <foreach collection="conditionParamRef.dimensionTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionTypeStart') and conditionParamRef.dimensionTypeStart != null">
+                ${_conditionType_} a.dimension_type <![CDATA[ >= ]]> #{${_conditionParam_}.dimensionTypeStart}
+            </if>
+            <if test="conditionParamRef.containsKey('dimensionTypeEnd') and conditionParamRef.dimensionTypeEnd != null">
+                ${_conditionType_} a.dimension_type <![CDATA[ <= ]]> #{${_conditionParam_}.dimensionTypeEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('createTime')">
+                <if test="conditionParamRef.createTime != null ">
+                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
+                </if>
+                <if test="conditionParamRef.createTime == null">
+                    ${_conditionType_} a.createTime is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+                ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+                ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('createUserId')">
+                <if test="conditionParamRef.createUserId != null ">
+                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
+                </if>
+                <if test="conditionParamRef.createUserId == null">
+                    ${_conditionType_} a.createUserId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                ${_conditionType_} a.createUserId in
+                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+                ${_conditionType_} a.createUserId not in
+                <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+                ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            </if>
+
+            <if test="conditionParamRef.containsKey('updateUserId')">
+                <if test="conditionParamRef.updateUserId != null ">
+                    ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
+                </if>
+                <if test="conditionParamRef.updateUserId == null">
+                    ${_conditionType_} a.updateUserId is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                ${_conditionType_} a.updateUserId in
+                <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+                ${_conditionType_} a.updateUserId not in
+                <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
+                ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
+                ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+            </if>
+
+
+            <if test="conditionParamRef.containsKey('updateTime')">
+                <if test="conditionParamRef.updateTime != null ">
+                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+                </if>
+                <if test="conditionParamRef.updateTime == null">
+                    ${_conditionType_} a.updateTime is null
+                </if>
+            </if>
+            <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
+                ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+            <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
+                ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            </if>
+    </sql>
+    <sql id="_orderCols_">
+        <if test="orderColList != null and !orderColList.isEmpty()">
+            order by
+                    <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                        field(a.id,
+                        <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('dimensionTypeList') and conditionParamRef.dimensionTypeList.size() > 0">
+                        field(a.dimensionType,
+                        <foreach collection="conditionParamRef.dimensionTypeList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                        field(a.createUserId,
+                        <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                        field(a.updateUserId,
+                        <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                     a.${item.colName} ${item.sortKind}
+                </foreach>
+            </trim>
+        </if>
+        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+            order by
+                    <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                        field(a.id,
+                        <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('dimensionTypeList') and conditionParamRef.dimensionTypeList.size() > 0">
+                        field(a.dimensionType,
+                        <foreach collection="conditionParamRef.dimensionTypeList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                        field(a.createUserId,
+                        <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+                    <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                        field(a.updateUserId,
+                        <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
+                            #{item}
+                        </foreach>
+                        ,
+                    </if>
+            <trim suffixOverrides=","  suffix="">
+                    <if test="orderCol.containsKey('id')">
+                        a.id
+                        <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('dimensionCode')">
+                        a.dimension_code
+                        <if test='orderCol.dimensionCode != null and "DESC".equalsIgnoreCase(orderCol.dimensionCode)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('dimensionName')">
+                        a.dimension_name
+                        <if test='orderCol.dimensionName != null and "DESC".equalsIgnoreCase(orderCol.dimensionName)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('dimensionValue')">
+                        a.dimension_value
+                        <if test='orderCol.dimensionValue != null and "DESC".equalsIgnoreCase(orderCol.dimensionValue)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('dimensionType')">
+                        a.dimension_type
+                        <if test='orderCol.dimensionType != null and "DESC".equalsIgnoreCase(orderCol.dimensionType)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('createTime')">
+                        a.createTime
+                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('createUserId')">
+                        a.createUserId
+                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('updateUserId')">
+                        a.updateUserId
+                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                        ,
+                    </if>
+                    <if test="orderCol.containsKey('updateTime')">
+                        a.updateTime
+                        <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
+                        ,
+                    </if>
+            </trim>
+        </if>
+
+
+    </sql>
+    <sql id="_group_by_">
+        <if test="groupList != null and !groupList.isEmpty()">
+            GROUP BY
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
+                    ${item}
+                </foreach>
+            </trim>
+        </if>
+    </sql>
+</mapper>
\ No newline at end of file

base-manager/src/main/resources/sqlmap/module/dimension/DimensionResourceRuleMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.dimension.dao.ibatis.DimensionResourceRuleDaoImpl">
+
+    <!-- 字段和属性映射 -->
+    <resultMap type="DimensionResourceRuleEntity" id="DimensionResourceRuleEntity-Map">
+        <id  property="id" column="id" />
+        <result property="roleId" column="role_id" />
+        <result property="resourceId" column="resource_id" />
+        <result property="ruleCode" column="rule_code" />
+        <result property="ruleName" column="rule_name" />
+        <result property="ruleCondition" column="rule_condition" />
+        <result property="ruleValue" column="rule_value" />
+        <result property="ruleType" column="rule_type" />
+        <result property="createTime" column="create_time" />
+        <result property="createUserId" column="create_user_id" />
+        <result property="updateUserId" column="update_user_id" />
+        <result property="updateTime" column="update_time" />
+        <result property="roleName" column="role_name" />
+        <result property="resourceName" column="resource_name" />
+
+    </resultMap>
+
+
+    <!-- 表所有列 -->
+    <sql id="_columns">
+        <trim suffixOverrides="," suffix="">
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                a.id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
+                a.role_id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceId') or colPickMode == 1 and data.containsKey('resourceId')))">
+                a.resource_id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleCode') or colPickMode == 1 and data.containsKey('ruleCode')))">
+                a.rule_code,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleName') or colPickMode == 1 and data.containsKey('ruleName')))">
+                a.rule_name,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleCondition') or colPickMode == 1 and data.containsKey('ruleCondition')))">
+                a.rule_condition,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleValue') or colPickMode == 1 and data.containsKey('ruleValue')))">
+                a.rule_value,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ruleType') or colPickMode == 1 and data.containsKey('ruleType')))">
+                a.rule_type,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                a.create_time,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                a.create_user_id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                a.update_user_id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
+                a.update_time,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleName') or colPickMode == 1 and data.containsKey('roleName')))">
+                a.role_name,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceName') or colPickMode == 1 and data.containsKey('resourceName')))">
+                a.resource_name,
+            </if>
+        </trim>
+    </sql>
+    <!-- 新增 区分主键自增加还是业务插入 -->
+    <insert id="insert" parameterType="DimensionResourceRuleEntity"  useGeneratedKeys="true" keyProperty="id">
+        insert into mortals_xhx_dimension_resource_rule
+        (role_id,resource_id,rule_code,rule_name,rule_condition,rule_value,rule_type,create_time,create_user_id,update_user_id,update_time,role_name,resource_name)
+        VALUES
+        (#{roleId},#{resourceId},#{ruleCode},#{ruleName},#{ruleCondition},#{ruleValue},#{ruleType},#{createTime},#{createUserId},#{updateUserId},#{updateTime},#{roleName},#{resourceName})
+    </insert>
+
+    <!-- 批量新增 -->
+    <insert id="insertBatch" parameterType="paramDto">
+        insert into mortals_xhx_dimension_resource_rule
+        (role_id,resource_id,rule_code,rule_name,rule_condition,rule_value,rule_type,create_time,create_user_id,update_user_id,update_time,role_name,resource_name)
+        VALUES
+        <foreach collection="data.dataList" item="item" index="index" separator="," >
+            (#{item.roleId},#{item.resourceId},#{item.ruleCode},#{item.ruleName},#{item.ruleCondition},#{item.ruleValue},#{item.ruleType},#{item.createTime},#{item.createUserId},#{item.updateUserId},#{item.updateTime},#{item.roleName},#{item.resourceName})
+        </foreach>
+    </insert>
+
+
+    <!-- 根据ParamDto更新 -->
+    <update id="update" parameterType="paramDto">
+        update mortals_xhx_dimension_resource_rule as a
+        set
+        <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
+                a.role_id=#{data.roleId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
+                a.role_id=ifnull(a.role_id,0) + #{data.roleIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('resourceId')) or (colPickMode==1 and !data.containsKey('resourceId'))">
+                a.resource_id=#{data.resourceId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('resourceIdIncrement')) or (colPickMode==1 and !data.containsKey('resourceIdIncrement'))">
+                a.resource_id=ifnull(a.resource_id,0) + #{data.resourceIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleCode')) or (colPickMode==1 and !data.containsKey('ruleCode'))">
+                a.rule_code=#{data.ruleCode},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleName')) or (colPickMode==1 and !data.containsKey('ruleName'))">
+                a.rule_name=#{data.ruleName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleCondition')) or (colPickMode==1 and !data.containsKey('ruleCondition'))">
+                a.rule_condition=#{data.ruleCondition},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleValue')) or (colPickMode==1 and !data.containsKey('ruleValue'))">
+                a.rule_value=#{data.ruleValue},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleType')) or (colPickMode==1 and !data.containsKey('ruleType'))">
+                a.rule_type=#{data.ruleType},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('ruleTypeIncrement')) or (colPickMode==1 and !data.containsKey('ruleTypeIncrement'))">
+                a.rule_type=ifnull(a.rule_type,0) + #{data.ruleTypeIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
+                a.create_time=#{data.createTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
+                a.create_user_id=#{data.createUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
+                a.create_user_id=ifnull(a.create_user_id,0) + #{data.createUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
+                a.update_user_id=#{data.updateUserId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
+                a.update_user_id=ifnull(a.update_user_id,0) + #{data.updateUserIdIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
+                a.update_time=#{data.updateTime},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('roleName')) or (colPickMode==1 and !data.containsKey('roleName'))">
+                a.role_name=#{data.roleName},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('resourceName')) or (colPickMode==1 and !data.containsKey('resourceName'))">
+                a.resource_name=#{data.resourceName},
+            </if>
+        </trim>
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </update>
+    <!-- 批量更新 -->
+    <update id="updateBatch" parameterType="paramDto">
+        update mortals_xhx_dimension_resource_rule as a
+        <trim prefix="set" suffixOverrides=",">
+            <trim prefix="role_id=(case" suffix="ELSE role_id end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('roleId')) or (colPickMode==1 and !item.containsKey('roleId'))">
+                            when a.id=#{item.id} then #{item.roleId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('roleIdIncrement')) or (colPickMode==1 and !item.containsKey('roleIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.role_id,0) + #{item.roleIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="resource_id=(case" suffix="ELSE resource_id end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('resourceId')) or (colPickMode==1 and !item.containsKey('resourceId'))">
+                            when a.id=#{item.id} then #{item.resourceId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('resourceIdIncrement')) or (colPickMode==1 and !item.containsKey('resourceIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.resource_id,0) + #{item.resourceIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="rule_code=(case" suffix="ELSE rule_code end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ruleCode')) or (colPickMode==1 and !item.containsKey('ruleCode'))">
+                        when a.id=#{item.id} then #{item.ruleCode}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="rule_name=(case" suffix="ELSE rule_name end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ruleName')) or (colPickMode==1 and !item.containsKey('ruleName'))">
+                        when a.id=#{item.id} then #{item.ruleName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="rule_condition=(case" suffix="ELSE rule_condition end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ruleCondition')) or (colPickMode==1 and !item.containsKey('ruleCondition'))">
+                        when a.id=#{item.id} then #{item.ruleCondition}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="rule_value=(case" suffix="ELSE rule_value end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('ruleValue')) or (colPickMode==1 and !item.containsKey('ruleValue'))">
+                        when a.id=#{item.id} then #{item.ruleValue}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="rule_type=(case" suffix="ELSE rule_type end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('ruleType')) or (colPickMode==1 and !item.containsKey('ruleType'))">
+                            when a.id=#{item.id} then #{item.ruleType}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('ruleTypeIncrement')) or (colPickMode==1 and !item.containsKey('ruleTypeIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.rule_type,0) + #{item.ruleTypeIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="create_time=(case" suffix="ELSE create_time end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                        when a.id=#{item.id} then #{item.createTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="create_user_id=(case" suffix="ELSE create_user_id end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                            when a.id=#{item.id} then #{item.createUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.create_user_id,0) + #{item.createUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="update_user_id=(case" suffix="ELSE update_user_id end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
+                            when a.id=#{item.id} then #{item.updateUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.update_user_id,0) + #{item.updateUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="update_time=(case" suffix="ELSE update_time end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                        when a.id=#{item.id} then #{item.updateTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="role_name=(case" suffix="ELSE role_name end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('roleName')) or (colPickMode==1 and !item.containsKey('roleName'))">
+                        when a.id=#{item.id} then #{item.roleName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="resource_name=(case" suffix="ELSE resource_name end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('resourceName')) or (colPickMode==1 and !item.containsKey('resourceName'))">
+                        when a.id=#{item.id} then #{item.resourceName}
+                    </if>
+                </foreach>
+            </trim>
+        </trim>
+        where id in
+        <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </update>
+    <!-- 根据主健查询 -->
+    <select id="getByKey" parameterType="paramDto" resultMap="DimensionResourceRuleEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_dimension_resource_rule as a
+        where a.id=#{condition.id}
+    </select>
+    <!-- 根据主健删除 -->
+    <delete id="deleteByKey" parameterType="paramDto">
+        delete a.* from mortals_xhx_dimension_resource_rule as a where a.id=#{condition.id}
+    </delete>
+    <!-- 根据主健删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeys">
+        delete from mortals_xhx_dimension_resource_rule where id in
+        <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_dimension_resource_rule where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_dimension_resource_rule where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
+    <!-- 根据paramDto删除一批 -->
+    <delete id="deleteByMap" parameterType="paramDto">
+        delete a.* from mortals_xhx_dimension_resource_rule as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </delete>
+    <!-- 获取列表 -->
+    <select id="getList" parameterType="paramDto" resultMap="DimensionResourceRuleEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_dimension_resource_rule as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+        <include refid="_orderCols_"/>
+    </select>
+
+
+
+    <!-- 获取 -->
+    <select id="getListCount" parameterType="paramDto" resultType="int">
+        select count(1)
+        from mortals_xhx_dimension_resource_rule as a
+        <trim suffixOverrides="where" suffix="">
+            where
+            <trim prefixOverrides="and" prefix="">
+                <include refid="_condition_"/>
+            </trim>
+        </trim>
+    </select>
+    <!-- 条件映射 -->
+    <sql id="_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_condition_param_">
+                <property name="_conditionParam_" value="condition"/>
+                <property name="_conditionType_" value="and"/>
+            </include>
+            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
+            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
+                and
+                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
+                    <trim prefixOverrides="or" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="andCondition"/>
+                            <property name="_conditionType_" value="or"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
+            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
+                and
+                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
+                    <trim prefixOverrides="and" prefix="(" suffix=")">
+                        <include refid="_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="permissionSql != null and permissionSql != ''">
+            ${permissionSql}
+        </if>
+
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null">
+                ${_conditionType_} a.id=#{${_conditionParam_}.id}
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
+            </if>
+            <if test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+            ${_conditionType_} a.id in
+            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+            ${_conditionType_} a.id not in
+            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+            ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+            ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('roleId')">
+            <if test="conditionParamRef.roleId != null ">
+                ${_conditionType_} a.role_id = #{${_conditionParam_}.roleId}
+            </if>
+            <if test="conditionParamRef.roleId == null">
+                ${_conditionType_} a.role_id is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
+            ${_conditionType_} a.role_id in
+            <foreach collection="conditionParamRef.roleIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdNotList') and conditionParamRef.roleIdNotList.size() > 0">
+            ${_conditionType_} a.role_id not in
+            <foreach collection="conditionParamRef.roleIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdStart') and conditionParamRef.roleIdStart != null">
+            ${_conditionType_} a.role_id <![CDATA[ >= ]]> #{${_conditionParam_}.roleIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdEnd') and conditionParamRef.roleIdEnd != null">
+            ${_conditionType_} a.role_id <![CDATA[ <= ]]> #{${_conditionParam_}.roleIdEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('resourceId')">
+            <if test="conditionParamRef.resourceId != null ">
+                ${_conditionType_} a.resource_id = #{${_conditionParam_}.resourceId}
+            </if>
+            <if test="conditionParamRef.resourceId == null">
+                ${_conditionType_} a.resource_id is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdList') and conditionParamRef.resourceIdList.size() > 0">
+            ${_conditionType_} a.resource_id in
+            <foreach collection="conditionParamRef.resourceIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdNotList') and conditionParamRef.resourceIdNotList.size() > 0">
+            ${_conditionType_} a.resource_id not in
+            <foreach collection="conditionParamRef.resourceIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdStart') and conditionParamRef.resourceIdStart != null">
+            ${_conditionType_} a.resource_id <![CDATA[ >= ]]> #{${_conditionParam_}.resourceIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdEnd') and conditionParamRef.resourceIdEnd != null">
+            ${_conditionType_} a.resource_id <![CDATA[ <= ]]> #{${_conditionParam_}.resourceIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('ruleCode')">
+            <if test="conditionParamRef.ruleCode != null and conditionParamRef.ruleCode != ''">
+                ${_conditionType_} a.rule_code like #{${_conditionParam_}.ruleCode}
+            </if>
+            <if test="conditionParamRef.ruleCode == null">
+                ${_conditionType_} a.rule_code is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleCodeList') and conditionParamRef.ruleCodeList.size() > 0">
+            ${_conditionType_} a.rule_code in
+            <foreach collection="conditionParamRef.ruleCodeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleCodeNotList') and conditionParamRef.ruleCodeNotList.size() > 0">
+            ${_conditionType_} a.rule_code not in
+            <foreach collection="conditionParamRef.ruleCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ruleName')">
+            <if test="conditionParamRef.ruleName != null and conditionParamRef.ruleName != ''">
+                ${_conditionType_} a.rule_name like #{${_conditionParam_}.ruleName}
+            </if>
+            <if test="conditionParamRef.ruleName == null">
+                ${_conditionType_} a.rule_name is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleNameList') and conditionParamRef.ruleNameList.size() > 0">
+            ${_conditionType_} a.rule_name in
+            <foreach collection="conditionParamRef.ruleNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleNameNotList') and conditionParamRef.ruleNameNotList.size() > 0">
+            ${_conditionType_} a.rule_name not in
+            <foreach collection="conditionParamRef.ruleNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ruleCondition')">
+            <if test="conditionParamRef.ruleCondition != null and conditionParamRef.ruleCondition != ''">
+                ${_conditionType_} a.rule_condition like #{${_conditionParam_}.ruleCondition}
+            </if>
+            <if test="conditionParamRef.ruleCondition == null">
+                ${_conditionType_} a.rule_condition is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleConditionList') and conditionParamRef.ruleConditionList.size() > 0">
+            ${_conditionType_} a.rule_condition in
+            <foreach collection="conditionParamRef.ruleConditionList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleConditionNotList') and conditionParamRef.ruleConditionNotList.size() > 0">
+            ${_conditionType_} a.rule_condition not in
+            <foreach collection="conditionParamRef.ruleConditionNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('ruleValue')">
+            <if test="conditionParamRef.ruleValue != null and conditionParamRef.ruleValue != ''">
+                ${_conditionType_} a.rule_value like #{${_conditionParam_}.ruleValue}
+            </if>
+            <if test="conditionParamRef.ruleValue == null">
+                ${_conditionType_} a.rule_value is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleValueList') and conditionParamRef.ruleValueList.size() > 0">
+            ${_conditionType_} a.rule_value in
+            <foreach collection="conditionParamRef.ruleValueList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleValueNotList') and conditionParamRef.ruleValueNotList.size() > 0">
+            ${_conditionType_} a.rule_value not in
+            <foreach collection="conditionParamRef.ruleValueNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleType')">
+            <if test="conditionParamRef.ruleType != null ">
+                ${_conditionType_} a.rule_type = #{${_conditionParam_}.ruleType}
+            </if>
+            <if test="conditionParamRef.ruleType == null">
+                ${_conditionType_} a.rule_type is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleTypeList') and conditionParamRef.ruleTypeList.size() > 0">
+            ${_conditionType_} a.rule_type in
+            <foreach collection="conditionParamRef.ruleTypeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleTypeNotList') and conditionParamRef.ruleTypeNotList.size() > 0">
+            ${_conditionType_} a.rule_type not in
+            <foreach collection="conditionParamRef.ruleTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('ruleTypeStart') and conditionParamRef.ruleTypeStart != null">
+            ${_conditionType_} a.rule_type <![CDATA[ >= ]]> #{${_conditionParam_}.ruleTypeStart}
+        </if>
+        <if test="conditionParamRef.containsKey('ruleTypeEnd') and conditionParamRef.ruleTypeEnd != null">
+            ${_conditionType_} a.rule_type <![CDATA[ <= ]]> #{${_conditionParam_}.ruleTypeEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.create_time = #{${_conditionParam_}.createTime}
+            </if>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.create_time is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+            ${_conditionType_} a.create_time <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+            ${_conditionType_} a.create_time <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createUserId')">
+            <if test="conditionParamRef.createUserId != null ">
+                ${_conditionType_} a.create_user_id = #{${_conditionParam_}.createUserId}
+            </if>
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} a.create_user_id is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+            ${_conditionType_} a.create_user_id in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+            ${_conditionType_} a.create_user_id not in
+            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+            ${_conditionType_} a.create_user_id <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+            ${_conditionType_} a.create_user_id <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} a.update_user_id = #{${_conditionParam_}.updateUserId}
+            </if>
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} a.update_user_id is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+            ${_conditionType_} a.update_user_id in
+            <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+            ${_conditionType_} a.update_user_id not in
+            <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
+            ${_conditionType_} a.update_user_id <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
+            ${_conditionType_} a.update_user_id <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.update_time = #{${_conditionParam_}.updateTime}
+            </if>
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.update_time is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
+            ${_conditionType_} a.update_time <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
+            ${_conditionType_} a.update_time <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+
+        <if test="conditionParamRef.containsKey('roleName')">
+            <if test="conditionParamRef.roleName != null and conditionParamRef.roleName != ''">
+                ${_conditionType_} a.role_name like #{${_conditionParam_}.roleName}
+            </if>
+            <if test="conditionParamRef.roleName == null">
+                ${_conditionType_} a.role_name is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('roleNameList') and conditionParamRef.roleNameList.size() > 0">
+            ${_conditionType_} a.role_name in
+            <foreach collection="conditionParamRef.roleNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('roleNameNotList') and conditionParamRef.roleNameNotList.size() > 0">
+            ${_conditionType_} a.role_name not in
+            <foreach collection="conditionParamRef.roleNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('resourceName')">
+            <if test="conditionParamRef.resourceName != null and conditionParamRef.resourceName != ''">
+                ${_conditionType_} a.resource_name like #{${_conditionParam_}.resourceName}
+            </if>
+            <if test="conditionParamRef.resourceName == null">
+                ${_conditionType_} a.resource_name is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceNameList') and conditionParamRef.resourceNameList.size() > 0">
+            ${_conditionType_} a.resource_name in
+            <foreach collection="conditionParamRef.resourceNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceNameNotList') and conditionParamRef.resourceNameNotList.size() > 0">
+            ${_conditionType_} a.resource_name not in
+            <foreach collection="conditionParamRef.resourceNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+    </sql>
+    <sql id="_orderCols_">
+        <if test="orderColList != null and !orderColList.isEmpty()">
+            order by
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
+                field(a.roleId,
+                <foreach collection="conditionParamRef.roleIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('resourceIdList') and conditionParamRef.resourceIdList.size() > 0">
+                field(a.resourceId,
+                <foreach collection="conditionParamRef.resourceIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('ruleTypeList') and conditionParamRef.ruleTypeList.size() > 0">
+                field(a.ruleType,
+                <foreach collection="conditionParamRef.ruleTypeList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                field(a.updateUserId,
+                <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                    a.${item.colName} ${item.sortKind}
+                </foreach>
+            </trim>
+        </if>
+        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+            order by
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
+                field(a.roleId,
+                <foreach collection="conditionParamRef.roleIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('resourceIdList') and conditionParamRef.resourceIdList.size() > 0">
+                field(a.resourceId,
+                <foreach collection="conditionParamRef.resourceIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('ruleTypeList') and conditionParamRef.ruleTypeList.size() > 0">
+                field(a.ruleType,
+                <foreach collection="conditionParamRef.ruleTypeList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+                field(a.updateUserId,
+                <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
+            <trim suffixOverrides=","  suffix="">
+                <if test="orderCol.containsKey('id')">
+                    a.id
+                    <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('roleId')">
+                    a.role_id
+                    <if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('resourceId')">
+                    a.resource_id
+                    <if test='orderCol.resourceId != null and "DESC".equalsIgnoreCase(orderCol.resourceId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ruleCode')">
+                    a.rule_code
+                    <if test='orderCol.ruleCode != null and "DESC".equalsIgnoreCase(orderCol.ruleCode)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ruleName')">
+                    a.rule_name
+                    <if test='orderCol.ruleName != null and "DESC".equalsIgnoreCase(orderCol.ruleName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ruleCondition')">
+                    a.rule_condition
+                    <if test='orderCol.ruleCondition != null and "DESC".equalsIgnoreCase(orderCol.ruleCondition)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ruleValue')">
+                    a.rule_value
+                    <if test='orderCol.ruleValue != null and "DESC".equalsIgnoreCase(orderCol.ruleValue)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('ruleType')">
+                    a.rule_type
+                    <if test='orderCol.ruleType != null and "DESC".equalsIgnoreCase(orderCol.ruleType)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createTime')">
+                    a.create_time
+                    <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createUserId')">
+                    a.create_user_id
+                    <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateUserId')">
+                    a.update_user_id
+                    <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateTime')">
+                    a.update_time
+                    <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('roleName')">
+                    a.role_name
+                    <if test='orderCol.roleName != null and "DESC".equalsIgnoreCase(orderCol.roleName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('resourceName')">
+                    a.resource_name
+                    <if test='orderCol.resourceName != null and "DESC".equalsIgnoreCase(orderCol.resourceName)'>DESC</if>
+                    ,
+                </if>
+            </trim>
+        </if>
+
+
+    </sql>
+    <sql id="_group_by_">
+        <if test="groupList != null and !groupList.isEmpty()">
+            GROUP BY
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
+                    ${item}
+                </foreach>
+            </trim>
+        </if>
+    </sql>
+</mapper>
\ No newline at end of file

base-manager/src/main/resources/sqlmap/module/dimension/DimensionResourceRuleMapperExt.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+"mybatis-3-mapper.dtd">
+<mapper namespace="com.mortals.xhx.module.dimension.dao.ibatis.DimensionResourceRuleDaoImpl">
+
+
+    <!-- 获取列表 -->
+    <select id="getRoleComponentRule" parameterType="java.util.HashMap" resultMap="DimensionResourceRuleEntity-Map">
+        SELECT DISTINCT
+        t1.role_id,
+        t1.resource_id,
+        t1.rule_code,
+        t1.rule_name,
+        t1.rule_condition,
+        t1.rule_value,
+        t1.rule_type,
+        t2.userId
+        FROM
+        mortals_xhx_dimension_resource_rule t1
+        LEFT JOIN mortals_xhx_role_user t2 ON t1.role_id = t2.roleId
+        LEFT JOIN mortals_xhx_role_auth t3 ON t1.role_id = t3.roleId
+        LEFT JOIN mortals_xhx_resource t4 ON t4.id = t3.resourceId
+        WHERE
+        FIND_IN_SET( #{route}, t4.url )
+        AND t2.userId = #{userId}
+    </select>
+
+</mapper>
\ No newline at end of file

base-manager/src/test/java/TestParsePost.java

+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
+import com.mortals.xhx.common.code.YesNoEnum;
+import com.mortals.xhx.common.utils.MatterHtmlParseUtil;
+import com.mortals.xhx.module.matter.model.MatterEntity;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+public class TestParsePost {
+
+    @Test
+    public void testUrl() {
+
+        String url = "http://www.sczwfw.gov.cn/jiq/interface/item/tags";
+        HashMap<String, String> params = new HashMap<>();
+        params.put("areaCode", "511500000000");
+        params.put("dxType", "6");
+        params.put("deptCode", "11511200MB1147469G");
+        params.put("searchtext", "");
+       // params.put("type", "2");//类型 2.部门  1.主题  3.热度
+        params.put("taskType", "");
+        // params.put("pageno", "1");
+        Rest<Map<String, Integer>> rest = MatterHtmlParseUtil.statSiteMatterCount(params, url);
+        System.out.println(JSON.toJSONString(rest));
+
+        List<MatterEntity> allList = new ArrayList<>();
+        String url1 = "http://www.sczwfw.gov.cn/jiq/interface/item/tags";
+        HashMap<String, String> params1 = new HashMap<>();
+        params1.put("areaCode", "511500000000");
+        params1.put("dxType", "6");
+        params1.put("deptCode", "11511200MB1147469G");
+        params1.put("searchtext", "");
+     //   params1.put("type", "2");
+        params1.put("taskType", "");
+        for (int i = 1; i <= rest.getData().get("pageNum"); i++) {
+            params1.put("pageno", String.valueOf(i));
+            Rest<List<MatterEntity>> restList = MatterHtmlParseUtil.getMatterList(params1, url1);
+            if (restList.getCode() == YesNoEnum.YES.getValue() && !ObjectUtils.isEmpty(restList.getData())) {
+                allList.addAll(restList.getData());
+            }
+        }
+
+        for (int i = 0; i < allList.size(); i++) {
+            System.out.println(i + "  " + allList.get(i).getMatterName()+"  "+ allList.get(i).getUrl()) ;
+        }
+
+    }
+
+
+}

base-manager/src/test/java/TestPost.java

+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Test;
+
+import java.util.HashMap;
+
+@Slf4j
+public class TestPost {
+
+    @Test
+    public void testUrl() {
+
+        HashMap<String, String> headers = new HashMap<>();
+        headers.put("satoken","d186dc7a-8f07-4936-9f36-94aeb7b246bb");
+        HttpRequest httpRequest = HttpUtil.createGet("http://59.225.206.13:8331/oauth-pro/admin-pro/oauth2/isLogin").headerMap(headers, true);
+
+        String resp = httpRequest.execute().body();
+        //String resp = httpRequest.getUrl();
+
+      //  String resp = HttpUtil.get("http://59.225.206.13:8331/oauth-pro/admin-pro/oauth2/isLogin");
+
+        log.info("resp:{}",resp);
+
+    }
+
+
+}

base-manager/src/test/java/com/mortals/httpclient/dimension/DimensionController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###授权维度列表
+POST {{baseUrl}}/dimension/list
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###授权维度更新与保存
+POST {{baseUrl}}/dimension/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "dimensionCode":"SdgQHJ",
+        "dimensionName":"0SiGlt",
+        "dimensionValue":"yVbV78",
+        "dimensionType":1,
+}
+
+> {%
+client.global.set("Dimension_id", JSON.parse(response.body).data.id);
+%}
+
+###授权维度查看
+GET {{baseUrl}}/dimension/info?id={{Dimension_id}}
+Accept: application/json
+
+###授权维度编辑
+GET {{baseUrl}}/dimension/edit?id={{Dimension_id}}
+Accept: application/json
+
+
+###授权维度删除
+GET {{baseUrl}}/dimension/delete?id={{Dimension_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

base-manager/src/test/java/com/mortals/httpclient/dimension/DimensionResourceRuleController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###角色资源维度规则列表
+POST {{baseUrl}}/dimension/resource/rule/list
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###角色资源维度规则更新与保存
+POST {{baseUrl}}/dimension/resource/rule/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "roleId":506,
+        "resourceId":118,
+        "ruleCode":"XhCY8s",
+        "ruleName":"1XHmAY",
+        "ruleCondition":"IN",
+        "ruleValue":"HiaFt9",
+        "ruleType":1,
+}
+
+> {%
+client.global.set("DimensionResourceRule_id", JSON.parse(response.body).data.id);
+%}
+
+###角色资源维度规则查看
+GET {{baseUrl}}/dimension/resource/rule/info?id={{DimensionResourceRule_id}}
+Accept: application/json
+
+###角色资源维度规则编辑
+GET {{baseUrl}}/dimension/resource/rule/edit?id={{DimensionResourceRule_id}}
+Accept: application/json
+
+
+###角色资源维度规则删除
+GET {{baseUrl}}/dimension/resource/rule/delete?id={{DimensionResourceRule_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

base-manager/src/test/java/com/mortals/httpclient/ph/PhQueueController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###排号汇总列表
+POST {{baseUrl}}/ph/queue/list
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###排号汇总更新与保存
+POST {{baseUrl}}/ph/queue/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "ordernumber":"addtBJ",
+        "style":"未叫号",
+        "business":"qdKnAF",
+        "windowName":"fFkdlu",
+        "windowFromnum":"dMLXLG",
+        "flownum":"Um9INN",
+        "formernum":"Sx3gb6",
+        "peopleIdcard":"VfS6Xk",
+        "peopleName":"BZAYKD",
+        "peopleSex":"a1LaM3",
+        "peoplePhone":"nH10yu",
+        "workmanName":"l0DDCz",
+        "workmanNumber":"U0l5x4",
+        "taketime":"1712592000000",
+        "calltime":"1712592000000",
+        "endtime":"1712592000000",
+        "waitTime":0,
+        "handleTime":0,
+        "deviceName":"oVFvi7",
+        "callName":"zQ04Ri",
+        "matterName":"UBwXu5",
+        "queueid":"42lyL3",
+        "wySignin":"现场取号",
+        "sectionName":"0CEkDm",
+        "hallName":"ASmxoc",
+        "deviceType":"排号机",
+        "siteId":0,
+        "siteCode":"ffN09b",
+        "siteName":"fIoxJO",
+        "extNum":"mJdlw4",
+}
+
+> {%
+client.global.set("PhQueue_id", JSON.parse(response.body).data.id);
+%}
+
+###排号汇总查看
+GET {{baseUrl}}/ph/queue/info?id={{PhQueue_id}}
+Accept: application/json
+
+###排号汇总编辑
+GET {{baseUrl}}/ph/queue/edit?id={{PhQueue_id}}
+Accept: application/json
+
+
+###排号汇总删除
+GET {{baseUrl}}/ph/queue/delete?id={{PhQueue_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

base-manager/src/test/java/com/mortals/httpclient/pj/PjEvaluateController.http

+###登录
+POST {{baseUrl}}/login/login
+Content-Type: application/json
+
+{
+"loginName":"admin",
+"password":"admin",
+"securityCode":"8888"
+}
+
+> {%
+client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
+client.global.set("authToken", JSON.parse(response.body).data.token);
+%}
+
+###评价汇总列表
+POST {{baseUrl}}/pj/evaluate/list
+Content-Type: application/json
+
+{
+    "page":1,
+    "size":10
+}
+
+
+###评价汇总更新与保存
+POST {{baseUrl}}/pj/evaluate/save
+Authorization: {{authToken}}
+Content-Type: application/json
+
+{
+        "peopleIdcard":"snZS5A",
+        "peopleName":"AmUiOm",
+        "peopleSex":"mkvrTF",
+        "peoplePhone":"37a4T3",
+        "pjOption":"mdVOnL",
+        "contentTag":"jl8xv2",
+        "picUrl":"BGNr0D",
+        "sectionName":"yVM2SE",
+        "hallName":"vTcXaf",
+        "pjSource":"jdkCLi",
+        "opinion":"Ah3ETA",
+        "windowName":"5oK21X",
+        "windowFromnum":"pzl4kw",
+        "flounum":"FIsY0p",
+        "pjxt":"窗口评价",
+        "workmanName":"u3u775",
+        "workmanNumber":"dCOirx",
+        "devicenum":"AsK2ye",
+        "evaluatestatus":"等待评价",
+        "evaluatetype":"截图",
+        "photobefor":"DQJe0a",
+        "photoautograph":"k06ZIZ",
+        "picture":"LLHjrm",
+        "process":"i95lNE",
+        "eyevaluate":"未标记",
+        "pjType":"窗口评价",
+        "pjTime":"1712592000000",
+        "siteId":0,
+        "siteCode":"PO98kN",
+        "siteName":"CZ26Cv",
+        "extNum":"x0Zcd3",
+}
+
+> {%
+client.global.set("PjEvaluate_id", JSON.parse(response.body).data.id);
+%}
+
+###评价汇总查看
+GET {{baseUrl}}/pj/evaluate/info?id={{PjEvaluate_id}}
+Accept: application/json
+
+###评价汇总编辑
+GET {{baseUrl}}/pj/evaluate/edit?id={{PjEvaluate_id}}
+Accept: application/json
+
+
+###评价汇总删除
+GET {{baseUrl}}/pj/evaluate/delete?id={{PjEvaluate_id}}
+Authorization: {{authToken}}
+Accept: application/json
+
+
+
+

portal-manager/src/main/java/com/mortals/xhx/module/user/service/impl/UserServiceImpl.java

@@ -208,13 +208,14 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
         if (sysUser.getLoginLock() == null) {
             sysUser.setLoginLock(0);
         }
-        if (sysUser.getLoginLock() == 1 && sysUser.getLockTime() != null) {
+        //取消账户锁定功能
+/*        if (sysUser.getLoginLock() == 1 && sysUser.getLockTime() != null) {
             String nowStr = DateUtils.getCurrStrDate();
             String loginDateStr = DateUtils.getDateTime(sysUser.getLockTime(), "yyyy-MM-dd");
             if (nowStr.equals(loginDateStr)) {
                 throw new AppException("此账号当天密码错误次数已达上限，已被锁定");
             }
-        }
+        }*/
 
         try {
             if (StringUtils.isNotEmpty(sysUser.getSaltKey())) {

portal-manager/src/test/java/com/mortals/httpclient/system.http

@@ -16,7 +16,7 @@ Content-Type: application/json
 {
   "loginName":"admin",
   "password":"admin",
-  "securityCode":"8888"
+  "securityCode":"admin"
 }
 
 > {%

smart-gateway/src/main/java/com/mortals/xhx/base/framework/filter/AuthFilter.java

-package com.mortals.xhx.base.framework.filter;
-
-import cn.dev33.satoken.reactor.filter.SaReactorFilter;
-import cn.dev33.satoken.router.SaRouter;
-import cn.dev33.satoken.stp.StpUtil;
-import cn.dev33.satoken.util.SaResult;
-import com.mortals.framework.common.HttpStatus;
-import com.mortals.xhx.base.framework.config.IgnoreWhiteProperties;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * Sa-Token 权限认证拦截器
- *
- * @author: zxfei
- * @date: 2022/6/17 15:18
- */
-//@Configuration
-public class AuthFilter {
-
-    /**
-     * 注册 Sa-Token 全局过滤器
-     */
-    @Bean
-    public SaReactorFilter getSaReactorFilter(IgnoreWhiteProperties ignoreWhite) {
-        return new SaReactorFilter()
-                // 拦截地址
-                .addInclude("/**")
-                //排除地址
-                .addExclude("/favicon.ico", "/actuator/**")
-                // 鉴权方法：每次访问进入
-                .setAuth(obj -> {
-                    // 登录校验 -- 拦截所有路由
-                    SaRouter.match("/**")
-                            .notMatch(ignoreWhite.getWhites())
-                            .check(r -> {
-                                // 检查是否登录 是否有token
-                                // StpUtil.checkLogin();
-                                // 有效率影响 用于临时测试
-                                // if (log.isDebugEnabled()) {
-                                //     log.debug("剩余有效时间: {}", StpUtil.getTokenTimeout());
-                                //     log.debug("临时有效时间: {}", StpUtil.getTokenActivityTimeout());
-                                // }
-                            });
-                }).setError(e -> SaResult.error("认证失败，无法访问系统资源").setCode(HttpStatus.UNAUTHORIZED));
-    }
-}