添加数据权限

one-certificate-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 "";
+}

one-certificate-manager/src/main/java/com/mortals/xhx/base/framework/aspect/DataPermissionAspect.java

+package com.mortals.xhx.base.framework.aspect;
+
+import com.mortals.framework.service.IAuthTokenService;
+import com.mortals.framework.service.IUser;
+import com.mortals.xhx.annotation.DataPermission;
+import com.mortals.xhx.common.utils.RuleQueryGenerator;
+import com.mortals.xhx.module.dimension.model.DimensionResourceRuleEntity;
+import com.mortals.xhx.module.dimension.service.DimensionResourceRuleService;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ObjectUtils;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.Method;
+import java.util.List;
+
+@Aspect
+@Slf4j
+@Component
+public class DataPermissionAspect {
+
+    @Autowired
+    private DimensionResourceRuleService dimensionResourceRuleService;
+    @Autowired
+    private IAuthTokenService authTokenService;
+
+    public static final String DATA_PERMISSION_SEARCH_SQL = "DATA_PERMISSION_SEARCH_SQL";
+
+    @Pointcut("@annotation(com.mortals.xhx.annotation.DataPermission)")
+    public void pointCut() {
+
+    }
+
+    @Around("pointCut()")
+    public Object around(ProceedingJoinPoint point) throws Throwable {
+        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        HttpServletRequest request = attributes.getRequest();
+        String componentRoute = request.getServletPath();
+        IUser loginUser = authTokenService.getLoginUser(request);
+        MethodSignature signature = (MethodSignature) point.getSignature();
+        Method method = signature.getMethod();
+        DataPermission permissionData = method.getAnnotation(DataPermission.class);
+
+        //获取授权方式
+        String permissionType = permissionData.permissionType();
+        //获取组件路由  通过controller 获取
+       // String componentRoute = permissionData.componentRoute();
+        if (!ObjectUtils.isEmpty(componentRoute)) {
+            // 查找当前用户此资源路径下的所有规则
+            List<DimensionResourceRuleEntity> componentRules = dimensionResourceRuleService.getRoleComponentRule(loginUser.getId(), componentRoute);
+            if (!ObjectUtils.isEmpty(componentRules)) {
+                //在request添加属性
+                // DataPermissionUtils.installDataSearchConditon(request, componentRules);
+                //DataPermissionUtils.installUserInfo(request, loginUser);
+                //todo 构建数据权限sql 并设置到request中。
+                String permissionSql = RuleQueryGenerator.getPermissionSql(componentRules,loginUser);
+                log.info("permissionSql:{}", permissionSql);
+
+                request.setAttribute(DATA_PERMISSION_SEARCH_SQL, permissionSql);
+                //  Map<Long, List<DimensionResourceRuleEntity>> ruleMap = RuleQueryGenerator.getRuleMapByRoleId(componentRules);
+            }
+            //  String permissionSql = RuleQueryGenerator.getPermissionSql(identityId);
+        }
+
+        return point.proceed();
+    }
+
+}

one-certificate-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);
+    }
+}

one-certificate-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();
+    }
+}

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/dao/ChildLicenseDatasetDao.java

 package com.mortals.xhx.module.child.dao;
 
 import com.mortals.framework.dao.ICRUDDao;
+import com.mortals.framework.model.PageInfo;
+import com.mortals.framework.model.Result;
 import com.mortals.xhx.module.child.model.ChildLicenseDatasetEntity;
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
+import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldEntity;
+
 import java.util.List;
+
 /**
-* 行业许可子证数据集Dao
-* 行业许可子证数据集 DAO接口
-*
-* @author zxfei
-* @date 2024-07-27
-*/
+ * 行业许可子证数据集Dao
+ * 行业许可子证数据集 DAO接口
+ *
+ * @author zxfei
+ * @date 2024-07-27
+ */
 
-public interface  ChildLicenseDatasetDao extends ICRUDDao<ChildLicenseDatasetEntity,Long>{
+public interface ChildLicenseDatasetDao extends ICRUDDao<ChildLicenseDatasetEntity, Long> {
 
+    String SQLID_CUSTOM_LIST = "getCustomList";
+    String SQLID_CUSTOM_COUNT = "getCustomListCount";
 
+    Result<ChildLicenseInfoFieldEntity> getCustomList(ChildLicenseDatasetQuery appDatasetQuery, PageInfo pageInfo);
 }

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/dao/ibatis/ChildLicenseDatasetDaoImpl.java

 package com.mortals.xhx.module.child.dao.ibatis;
 
 
+import com.mortals.framework.model.PageInfo;
+import com.mortals.framework.model.ParamDto;
+import com.mortals.framework.model.Result;
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
+import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldEntity;
 import org.springframework.stereotype.Repository;
 import com.mortals.xhx.module.child.dao.ChildLicenseDatasetDao;
 import com.mortals.xhx.module.child.model.ChildLicenseDatasetEntity;
+
+import java.util.ArrayList;
 import java.util.Date;
+
 import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
+
 import java.util.List;
+
 /**
-* 行业许可子证数据集DaoImpl DAO接口
-*
-* @author zxfei
-* @date 2024-07-27
-*/
+ * 行业许可子证数据集DaoImpl DAO接口
+ *
+ * @author zxfei
+ * @date 2024-07-27
+ */
 @Repository("childLicenseDatasetDao")
-public class ChildLicenseDatasetDaoImpl extends BaseCRUDDaoMybatis<ChildLicenseDatasetEntity,Long> implements ChildLicenseDatasetDao {
-
+public class ChildLicenseDatasetDaoImpl extends BaseCRUDDaoMybatis<ChildLicenseDatasetEntity, Long> implements ChildLicenseDatasetDao {
 
+    @Override
+    public Result<ChildLicenseInfoFieldEntity> getCustomList(ChildLicenseDatasetQuery appDatasetQuery, PageInfo pageInfo) {
+        Result<ChildLicenseInfoFieldEntity> result = new Result();
+        ParamDto paramDto = this.getQueryParam(appDatasetQuery);
+        int count = this.getCustomCount(paramDto);
+        List list = null;
+        if (count == 0) {
+            list = new ArrayList();
+        } else if (pageInfo.getPrePageResult() == -1) {
+            list = this.getSqlSession().selectList(this.getSqlId(SQLID_CUSTOM_LIST), paramDto);
+        } else {
+            list = this.getSqlSession().selectList(this.getSqlId(SQLID_CUSTOM_LIST), paramDto);
+        }
+        pageInfo.setTotalResult(count);
+        result.setPageInfo(pageInfo);
+        result.setList(list);
+        return result;
+    }
 
+    public int getCustomCount(ParamDto paramDto) {
+        return this.getSqlSession().selectOne(this.getSqlId(SQLID_CUSTOM_COUNT), this.cpyQueryParamDto(paramDto));
+    }
 }

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/model/vo/ChildLicenseDatasetVo.java

@@ -3,6 +3,8 @@ import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.child.model.ChildLicenseDatasetEntity;
 import java.util.ArrayList;
 import java.util.List;
+
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
 import lombok.Data;
 import com.mortals.framework.annotation.Excel;
 import java.math.BigDecimal;
@@ -16,8 +18,31 @@ import java.util.Date;
 @Data
 public class ChildLicenseDatasetVo extends BaseEntityLong {
 
-    /** 主键ID，主键，自增长列表 */
-    private List <Long> idList;
+    /**
+     * 字段编码
+     */
+    private String fieldCode;
+    /**
+     * 字段名称
+     */
+    private String fieldName;
+    /**
+     * 字段值
+     */
+    private String fieldValue;
+
+    private Long appId;
+
+    private List<Long> idList;
+
+    private List<String> fieldNameList;
+
+    private List<String> fieldValueList;
+
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<ChildLicenseDatasetQuery> orConditionList;
 
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<ChildLicenseDatasetQuery> andConditionList;
 
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/model/vo/ChildLicenseInfoFieldVo.java

@@ -3,6 +3,8 @@ import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldEntity;
 import java.util.ArrayList;
 import java.util.List;
+
+import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldQuery;
 import lombok.Data;
 import com.mortals.framework.annotation.Excel;
 import java.math.BigDecimal;
@@ -19,5 +21,11 @@ public class ChildLicenseInfoFieldVo extends BaseEntityLong {
     /** 序号，主键，自增长列表 */
     private List <Long> idList;
 
+    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
+    private List<ChildLicenseInfoFieldQuery> orConditionList;
+
+    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
+    private List<ChildLicenseInfoFieldQuery> andConditionList;
+
 
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/model/vo/ChildLicenseVo.java

@@ -19,5 +19,8 @@ public class ChildLicenseVo extends BaseEntityLong {
     /** 主键ID，主键，自增长列表 */
     private List <Long> idList;
 
-
+    /**
+     * 站点列表
+     */
+    private List<Long> siteIdList;
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/service/ChildLicenseDatasetService.java

 package com.mortals.xhx.module.child.service;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
+import com.mortals.framework.model.PageInfo;
+import com.mortals.framework.model.Result;
 import com.mortals.framework.service.ICRUDService;
 import com.mortals.xhx.module.child.model.ChildLicenseDatasetEntity;
 import com.mortals.xhx.module.child.dao.ChildLicenseDatasetDao;
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
+import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldEntity;
+
 /**
 * ChildLicenseDatasetService
 *
@@ -13,4 +20,8 @@ import com.mortals.xhx.module.child.dao.ChildLicenseDatasetDao;
 public interface ChildLicenseDatasetService extends ICRUDService<ChildLicenseDatasetEntity,Long>{
 
     ChildLicenseDatasetDao getDao();
+
+
+    Result<ChildLicenseInfoFieldEntity> findCustomList(ChildLicenseDatasetQuery appDatasetQuery, PageInfo pageInfo, Context context) throws AppException;
+
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/service/impl/ChildLicenseDatasetServiceImpl.java

 package com.mortals.xhx.module.child.service.impl;
+import com.mortals.framework.model.PageInfo;
+import com.mortals.framework.model.Result;
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
 import org.springframework.beans.BeanUtils;
+
+import java.util.Map;
 import java.util.function.Function;
 import org.springframework.stereotype.Service;
 import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
@@ -16,6 +21,8 @@ import org.springframework.util.ObjectUtils;
 import java.util.Date;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
+
 import lombok.extern.slf4j.Slf4j;
 /**
 * ChildLicenseDatasetService
@@ -86,4 +93,9 @@ public class ChildLicenseDatasetServiceImpl extends AbstractCRUDServiceImpl<Chil
         childLicenseInfoFieldService.removeList(childLicenseInfoFieldlist,context);
         super.removeAfter(ids, context, result);
     }
+
+    @Override
+    public Result<ChildLicenseInfoFieldEntity> findCustomList(ChildLicenseDatasetQuery appDatasetQuery, PageInfo pageInfo, Context context) throws AppException {
+        return this.dao.getCustomList(appDatasetQuery, pageInfo);
+    }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/service/impl/ChildLicenseTempleteFieldServiceImpl.java

 package com.mortals.xhx.module.child.service.impl;
+
+import com.mortals.xhx.common.utils.BeanUtil;
+import com.mortals.xhx.module.child.model.*;
+import com.mortals.xhx.module.child.service.ChildLicenseDatasetService;
+import com.mortals.xhx.module.child.service.ChildLicenseInfoFieldService;
 import org.springframework.beans.BeanUtils;
+
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Function;
+
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
 import com.mortals.framework.exception.AppException;
 import com.mortals.framework.model.Context;
 import com.mortals.xhx.module.child.dao.ChildLicenseTempleteFieldDao;
-import com.mortals.xhx.module.child.model.ChildLicenseTempleteFieldEntity;
 import com.mortals.xhx.module.child.service.ChildLicenseTempleteFieldService;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.util.ObjectUtils;
+
 /**
-* ChildLicenseTempleteFieldService
-* 行业许可子证模板信息字段 service实现
-*
-* @author zxfei
-* @date 2024-07-27
-*/
+ * ChildLicenseTempleteFieldService
+ * 行业许可子证模板信息字段 service实现
+ *
+ * @author zxfei
+ * @date 2024-07-27
+ */
 @Service("childLicenseTempleteFieldService")
 @Slf4j
 public class ChildLicenseTempleteFieldServiceImpl extends AbstractCRUDServiceImpl<ChildLicenseTempleteFieldDao, ChildLicenseTempleteFieldEntity, Long> implements ChildLicenseTempleteFieldService {
-    
+
+
+    @Autowired
+    private ChildLicenseDatasetService childLicenseDatasetService;
+    @Autowired
+    private ChildLicenseInfoFieldService childLicenseInfoFieldService;
+
+    /**
+     * @param entity
+     * @param context
+     * @throws AppException
+     */
+    @Override
+    protected void saveAfter(ChildLicenseTempleteFieldEntity entity, Context context) throws AppException {
+        //同步添加已有模板数据
+        ChildLicenseDatasetQuery appDatasetQuery = new ChildLicenseDatasetQuery();
+        appDatasetQuery.setAppId(entity.getSubLicenseId());
+        List<ChildLicenseDatasetEntity> childLicenseDatasetEntities = childLicenseDatasetService.find(appDatasetQuery, context);
+// 判断该数据集 是否已经存在 没存在 再添加
+        ArrayList<ChildLicenseInfoFieldEntity> fieldSaveList = new ArrayList<>();
+
+        for (ChildLicenseDatasetEntity childLicenseDatasetEntity : childLicenseDatasetEntities) {
+            ChildLicenseInfoFieldQuery appInfoFieldQuery = new ChildLicenseInfoFieldQuery();
+            appInfoFieldQuery.setDatasetId(childLicenseDatasetEntity.getId());
+            appInfoFieldQuery.setFieldCode(entity.getFieldCode());
+            appInfoFieldQuery.setFieldType(entity.getFieldType());
+            ChildLicenseInfoFieldEntity childLicenseInfoFieldEntity = childLicenseInfoFieldService.selectOne(appInfoFieldQuery, context);
+
+            if (ObjectUtils.isEmpty(childLicenseInfoFieldEntity)) {
+                ChildLicenseInfoFieldEntity fieldEntity = new ChildLicenseInfoFieldEntity();
+                fieldEntity.initAttrValue();
+                BeanUtils.copyProperties(entity, fieldEntity, BeanUtil.getNullPropertyNames(entity));
+                fieldEntity.setDatasetId(childLicenseDatasetEntity.getId());
+                fieldEntity.setId(null);
+                fieldSaveList.add(fieldEntity);
+            }
+        }
+
+        if (!ObjectUtils.isEmpty(fieldSaveList)) {
+            childLicenseInfoFieldService.save(fieldSaveList, context);
+        }
+        super.saveAfter(entity, context);
+    }
 }
\ No newline at end of file

one-certificate-manager/src/main/java/com/mortals/xhx/module/child/web/ChildLicenseDatasetController.java

 package com.mortals.xhx.module.child.web;
+import cn.hutool.core.collection.ListUtil;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.PageInfo;
+import com.mortals.framework.model.Result;
 import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
 import com.mortals.xhx.base.system.param.service.ParamService;
+import com.mortals.xhx.module.child.model.ChildLicenseDatasetQuery;
+import com.mortals.xhx.module.child.model.ChildLicenseInfoFieldEntity;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.ObjectUtils;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.*;
@@ -13,12 +20,10 @@ import com.mortals.xhx.module.child.model.ChildLicenseDatasetEntity;
 import com.mortals.xhx.module.child.service.ChildLicenseDatasetService;
 import org.apache.commons.lang3.ArrayUtils;
 import com.mortals.framework.util.StringUtils;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+
+import java.util.*;
 import java.util.stream.Collectors;
 import com.alibaba.fastjson.JSONObject;
-import java.util.Arrays;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 import static com.mortals.framework.ap.SysConstains.*;
@@ -46,5 +51,69 @@ public class ChildLicenseDatasetController extends BaseCRUDJsonBodyMappingContro
         super.init(model, context);
     }
 
+    @Override
+    protected void doListBefore(ChildLicenseDatasetEntity query, Map<String, Object> model, Context context) throws AppException {
+        if (!ObjectUtils.isEmpty(query.getOrConditionList()) || !ObjectUtils.isEmpty(query.getAndConditionList())) {
+            ChildLicenseDatasetQuery appDatasetQuery = new ChildLicenseDatasetQuery();
+
+            if (!ObjectUtils.isEmpty(query.getAndConditionList())) {
+                appDatasetQuery.setOrConditionList(query.getAndConditionList());
+            }
+
+            if (!ObjectUtils.isEmpty(query.getOrConditionList())) {
+                appDatasetQuery.setOrConditionList(query.getOrConditionList());
+                appDatasetQuery.setAppId(query.getAppId());
+                appDatasetQuery.setOrderCols(query.getOrderCols());
+                PageInfo pageInfo = this.buildPageInfo(query);
+                Result<ChildLicenseInfoFieldEntity> customResult = this.service.findCustomList(appDatasetQuery, pageInfo, context);
+                //根据查询条件的数量去除数量不足的结果
+                int count = query.getOrConditionList().size();
+                List<Long> datasetIdList = customResult.getList().stream().map(item -> item.getDatasetId()).collect(Collectors.toList());
+                Map<Long, Long> collect = datasetIdList.stream().collect(Collectors.groupingBy(x -> x, Collectors.counting()));
+                List<Long> dataSets = collect.entrySet().stream().map(entrySet -> {
+                    if (entrySet.getValue() == count) {
+                        return entrySet.getKey();
+                    } else {
+                        return null;
+                    }
+                }).filter(f -> f != null).collect(Collectors.toList());
+
+
+                if (!ObjectUtils.isEmpty(dataSets)) {
+                    //排序-
+                    List<Long> orderList = new ArrayList<>();
+                    for (Long dataId : datasetIdList) {
+                        if(dataSets.contains(dataId)){
+                            orderList.add(dataId);
+                        }
+                    }
+                    query.setIdList(orderList);
+                } else {
+                    query.setIdList(ListUtil.toList(0L));
+                }
+                query.setOrConditionList(null);
+            }
+        }
+
+        if (!ObjectUtils.isEmpty(query.getFieldCode()) || !ObjectUtils.isEmpty(query.getFieldName())) {
+            ChildLicenseDatasetQuery appDatasetQuery = new ChildLicenseDatasetQuery();
+            appDatasetQuery.setFieldCode(query.getFieldCode());
+            appDatasetQuery.setFieldName(query.getFieldName());
+            appDatasetQuery.setAppId(query.getAppId());
+//            String fieldValue = StrUtil.addPrefixIfNot(query.getFieldValue(), "%");
+//            fieldValue = StrUtil.addSuffixIfNot(fieldValue, "%");
+            appDatasetQuery.setFieldValue(query.getFieldValue());
+            PageInfo pageInfo = this.buildPageInfo(query);
+            Result<ChildLicenseInfoFieldEntity> customResult = this.service.findCustomList(appDatasetQuery, pageInfo, context);
+            List<Long> datasetIdList = customResult.getList().stream().map(item -> item.getDatasetId()).collect(Collectors.toList());
+            if (!ObjectUtils.isEmpty(datasetIdList)) {
+                query.setIdList(datasetIdList);
+                //query.setOrderColList();
+            } else {
+                query.setIdList(ListUtil.toList(0L));
+            }
+        }
+        super.doListBefore(query, model, context);
+    }
 
 }
\ No newline at end of file

one-certificate-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>{
+
+
+}

one-certificate-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);
+}

one-certificate-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 {
+
+
+
+}

one-certificate-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);
+            }
+        });
+    }
+}

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-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

one-certificate-manager/src/main/resources/sqlmap/module/child/ChildLicenseDatasetMapperExt.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.child.dao.ibatis.ChildLicenseDatasetDaoImpl">
+    <select id="getCustomListCount" parameterType="paramDto" resultType="int">
+        SELECT
+        count( 1 )
+        FROM
+        mortals_xhx_child_license_dataset a
+        LEFT JOIN mortals_sys_child_license_info_field b ON a.id = b.datasetId
+        <trim suffixOverrides="where" suffix="">
+            where 1=1 and
+            <trim prefixOverrides="and" prefix="">
+                <if test="condition.subLicenseId!=null and condition.subLicenseId!=''">
+                    and a.subLicenseId = #{condition.appId,jdbcType=VARCHAR}
+                </if>
+                <include refid="_second_condition_"/>
+            </trim>
+        </trim>
+    </select>
+
+    <!-- 获取事项差集列表列表 -->
+    <select id="getCustomList" parameterType="paramDto" resultMap="AppInfoFieldEntity-Map">
+        SELECT
+        <include refid="_columns_sub"/>
+        FROM
+        mortals_xhx_child_license_dataset a
+        LEFT JOIN mortals_sys_child_license_info_field b ON a.id = b.datasetId
+        <trim suffixOverrides="where" suffix="">
+            where 1=1 and
+            <trim prefixOverrides="and" prefix="">
+                <if test="condition.subLicenseId!=null and condition.subLicenseId!=''">
+                    and a.subLicenseId = #{condition.appId,jdbcType=VARCHAR}
+                </if>
+                <include refid="_second_condition_"/>
+            </trim>
+        </trim>
+
+        order by
+        IF
+        ( `fieldCode` = 'top', '0', '1' ),
+        `fieldValue` DESC,
+
+        IF
+        ( `fieldType` = 'date', '0', '1' ),
+        `fieldValue` DESC;
+
+
+    </select>
+
+    <!-- 条件映射 -->
+    <sql id="_second_condition_">
+        <if test="condition != null and !condition.isEmpty()">
+            <!-- 条件映射-普通条件 -->
+            <include refid="_second_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="_second_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="_second_condition_param_">
+                            <property name="_conditionParam_" value="orCondition"/>
+                            <property name="_conditionType_" value="and"/>
+                        </include>
+                    </trim>
+                </foreach>
+            </if>
+        </if>
+    </sql>
+    <!-- 条件映射-代参数 -->
+    <sql id="_second_condition_param_">
+        <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="conditionParamRef.containsKey('datasetId')">
+            <if test="conditionParamRef.datasetId != null ">
+                ${_conditionType_} b.datasetId = #{${_conditionParam_}.datasetId}
+            </if>
+            <if test="conditionParamRef.datasetId == null">
+                ${_conditionType_} b.datasetId is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('datasetIdList')">
+            ${_conditionType_} b.datasetId in
+            <foreach collection="conditionParamRef.datasetIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('datasetIdStart') and conditionParamRef.datasetIdStart != null">
+            ${_conditionType_} b.datasetId <![CDATA[ >= ]]> #{${_conditionParam_}.datasetIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('datasetIdEnd') and conditionParamRef.datasetIdEnd != null">
+            ${_conditionType_} b.datasetId <![CDATA[ <= ]]> #{${_conditionParam_}.datasetIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('fieldCode')">
+            <if test="conditionParamRef.fieldCode != null and conditionParamRef.fieldCode != ''">
+                ${_conditionType_} b.fieldCode like #{${_conditionParam_}.fieldCode}
+            </if>
+            <if test="conditionParamRef.fieldCode == null">
+                ${_conditionType_} b.fieldCode is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldCodeList')">
+            ${_conditionType_} b.fieldCode in
+            <foreach collection="conditionParamRef.fieldCodeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('fieldName')">
+            <if test="conditionParamRef.fieldName != null and conditionParamRef.fieldName != ''">
+                ${_conditionType_} b.fieldName like #{${_conditionParam_}.fieldName}
+            </if>
+            <if test="conditionParamRef.fieldName == null">
+                ${_conditionType_} b.fieldName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldNameList')">
+            ${_conditionType_} b.fieldName in
+            <foreach collection="conditionParamRef.fieldNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('fieldType')">
+            <if test="conditionParamRef.fieldType != null and conditionParamRef.fieldType != ''">
+                ${_conditionType_} b.fieldType like #{${_conditionParam_}.fieldType}
+            </if>
+            <if test="conditionParamRef.fieldType == null">
+                ${_conditionType_} b.fieldType is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldTypeList')">
+            ${_conditionType_} b.fieldType in
+            <foreach collection="conditionParamRef.fieldTypeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('dataType')">
+            <if test="conditionParamRef.dataType != null and conditionParamRef.dataType != ''">
+                ${_conditionType_} b.dataType like #{${_conditionParam_}.dataType}
+            </if>
+            <if test="conditionParamRef.dataType == null">
+                ${_conditionType_} b.dataType is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('dataTypeList')">
+            ${_conditionType_} b.dataType in
+            <foreach collection="conditionParamRef.dataTypeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('fieldValue')">
+            <if test="conditionParamRef.fieldValue != null and conditionParamRef.fieldValue != ''">
+                ${_conditionType_} b.fieldValue like #{${_conditionParam_}.fieldValue}
+            </if>
+            <if test="conditionParamRef.fieldValue == null">
+                ${_conditionType_} b.fieldValue is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldValueList')">
+            ${_conditionType_} b.fieldValue in
+            <foreach collection="conditionParamRef.fieldValueList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldLen')">
+            <if test="conditionParamRef.fieldLen != null ">
+                ${_conditionType_} b.fieldLen = #{${_conditionParam_}.fieldLen}
+            </if>
+            <if test="conditionParamRef.fieldLen == null">
+                ${_conditionType_} b.fieldLen is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldLenList')">
+            ${_conditionType_} b.fieldLen in
+            <foreach collection="conditionParamRef.fieldLenList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldLenStart') and conditionParamRef.fieldLenStart != null">
+            ${_conditionType_} b.fieldLen <![CDATA[ >= ]]> #{${_conditionParam_}.fieldLenStart}
+        </if>
+        <if test="conditionParamRef.containsKey('fieldLenEnd') and conditionParamRef.fieldLenEnd != null">
+            ${_conditionType_} b.fieldLen <![CDATA[ <= ]]> #{${_conditionParam_}.fieldLenEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('fieldNull')">
+            <if test="conditionParamRef.fieldNull != null ">
+                ${_conditionType_} b.fieldNull = #{${_conditionParam_}.fieldNull}
+            </if>
+            <if test="conditionParamRef.fieldNull == null">
+                ${_conditionType_} b.fieldNull is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldNullList')">
+            ${_conditionType_} b.fieldNull in
+            <foreach collection="conditionParamRef.fieldNullList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldNullStart') and conditionParamRef.fieldNullStart != null">
+            ${_conditionType_} b.fieldNull <![CDATA[ >= ]]> #{${_conditionParam_}.fieldNullStart}
+        </if>
+        <if test="conditionParamRef.containsKey('fieldNullEnd') and conditionParamRef.fieldNullEnd != null">
+            ${_conditionType_} b.fieldNull <![CDATA[ <= ]]> #{${_conditionParam_}.fieldNullEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('isList')">
+            <if test="conditionParamRef.isList != null ">
+                ${_conditionType_} b.isList = #{${_conditionParam_}.isList}
+            </if>
+            <if test="conditionParamRef.isList == null">
+                ${_conditionType_} b.isList is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('isListList')">
+            ${_conditionType_} b.isList in
+            <foreach collection="conditionParamRef.isListList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('isListStart') and conditionParamRef.isListStart != null">
+            ${_conditionType_} b.isList <![CDATA[ >= ]]> #{${_conditionParam_}.isListStart}
+        </if>
+        <if test="conditionParamRef.containsKey('isListEnd') and conditionParamRef.isListEnd != null">
+            ${_conditionType_} b.isList <![CDATA[ <= ]]> #{${_conditionParam_}.isListEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('fieldOrderNo')">
+            <if test="conditionParamRef.fieldOrderNo != null ">
+                ${_conditionType_} b.fieldOrderNo = #{${_conditionParam_}.fieldOrderNo}
+            </if>
+            <if test="conditionParamRef.fieldOrderNo == null">
+                ${_conditionType_} b.fieldOrderNo is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldOrderNoList')">
+            ${_conditionType_} b.fieldOrderNo in
+            <foreach collection="conditionParamRef.fieldOrderNoList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('fieldOrderNoStart') and conditionParamRef.fieldOrderNoStart != null">
+            ${_conditionType_} b.fieldOrderNo <![CDATA[ >= ]]> #{${_conditionParam_}.fieldOrderNoStart}
+        </if>
+        <if test="conditionParamRef.containsKey('fieldOrderNoEnd') and conditionParamRef.fieldOrderNoEnd != null">
+            ${_conditionType_} b.fieldOrderNo <![CDATA[ <= ]]> #{${_conditionParam_}.fieldOrderNoEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('remark')">
+            <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
+                ${_conditionType_} b.remark like #{${_conditionParam_}.remark}
+            </if>
+            <if test="conditionParamRef.remark == null">
+                ${_conditionType_} b.remark is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('remarkList')">
+            ${_conditionType_} b.remark in
+            <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} b.createTime = #{${_conditionParam_}.createTime}
+            </if>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} b.createTime is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+            ${_conditionType_} b.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_} b.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_} b.createUserId = #{${_conditionParam_}.createUserId}
+            </if>
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} b.createUserId is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList')">
+            ${_conditionType_} b.createUserId in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+            ${_conditionType_} b.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+            ${_conditionType_} b.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} b.updateTime = #{${_conditionParam_}.updateTime}
+            </if>
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} b.updateTime is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
+            ${_conditionType_} b.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_} b.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} b.updateUserId = #{${_conditionParam_}.updateUserId}
+            </if>
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} b.updateUserId is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdList')">
+            ${_conditionType_} b.updateUserId in
+            <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
+            ${_conditionType_} b.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
+            ${_conditionType_} b.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+        </if>
+
+    </sql>
+</mapper>
\ No newline at end of file

one-certificate-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

one-certificate-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

one-certificate-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