修改门户资源鉴权

base-manager/src/main/java/com/mortals/xhx/module/site/service/impl/SiteServiceImpl.java

@@ -5,6 +5,7 @@ import cn.hutool.core.util.URLUtil;
 import cn.hutool.core.util.ZipUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.serializer.SerializerFeature;
 import com.mortals.framework.ap.GlobalSysInfo;
 import com.mortals.framework.common.Rest;
 import com.mortals.framework.exception.AppException;
@@ -13,6 +14,7 @@ import com.mortals.framework.model.PageInfo;
 import com.mortals.framework.model.Result;
 import com.mortals.framework.service.impl.AbstractCRUDCacheServiceImpl;
 import com.mortals.framework.util.DataUtil;
+import com.mortals.framework.util.HttpUtil;
 import com.mortals.framework.util.StringUtils;
 import com.mortals.xhx.base.system.user.service.UserService;
 import com.mortals.xhx.common.code.AreaLevelDxTypeEnum;
@@ -60,6 +62,7 @@ import org.springframework.util.ObjectUtils;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static com.mortals.framework.util.HttpUtil.HEADER_CONTENT_TYPE;
 import static com.mortals.xhx.common.key.Constant.*;
 
 /**
@@ -189,7 +192,6 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
         //刷新站点树
         //ThreadPool.getInstance().execute(new SyncTreeSiteThread(this,context));
         Rest<String> rest = userFeign.synchSiteAuth();
-        log.info("站点更新2");
         if (rest.getCode().equals(YesNoEnum.YES.getValue())) {
             UserPdu userPdu = new UserPdu();
             userPdu.setPage(1);
@@ -197,10 +199,23 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
             Rest<RespData<List<UserPdu>>> list = userFeign.list(userPdu);
             userService.updateUserList(list.getData().getData());
         }
-        log.info("站点更新3");
         //更新同步部门相关
         deptService.syncDeptBySiteId(entity, context);
-        log.info("站点更新4");
+
+        //通知php系统更新
+        String phpUrl = GlobalSysInfo.getParamValue(PARAM_SERVER_PHP_HTTP_URL, "http://172.15.28.116:8090");
+        HashMap<String, String> paramsMap = new HashMap<>();
+        paramsMap.put("siteid", entity.getId().toString());
+
+        phpUrl += "/api/site/childSiteSet";
+        String resp = null;
+        try {
+            resp = HttpUtil.doGet(phpUrl, paramsMap);
+            log.info("thirdPartyUrl =>resp:{}", resp);
+        } catch (Exception e) {
+            log.error("异常:", e);
+        }
+
 
     }
 
@@ -327,17 +342,13 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
     protected void updateAfter(SiteEntity entity, Context context) throws AppException {
         super.updateAfter(entity,context);
         //刷新站点树
-        log.info("update1");
         Rest<String> rest = userFeign.synchSiteAuth();
         if (rest.getCode().equals(YesNoEnum.YES.getValue())) {
-            log.info("update2");
             UserPdu userPdu = new UserPdu();
             userPdu.setPage(1);
             userPdu.setSize(-1);
             Rest<RespData<List<UserPdu>>> list = userFeign.list(userPdu);
-            log.info("update21");
             userService.updateUserList(list.getData().getData());
-            log.info("update22");
         }
         if (refresh) {
             //通知设备更新站点信息

base-manager/src/main/java/com/mortals/xhx/module/skin/service/impl/SkinBaseServiceImpl.java

@@ -17,6 +17,8 @@ import com.mortals.xhx.common.code.FiletypeEnum;
 import com.mortals.xhx.common.key.Constant;
 import com.mortals.xhx.common.utils.BeanUtil;
 import com.mortals.xhx.common.utils.FreeMarkerUtils;
+import com.mortals.xhx.feign.skin.ISkinFillFeign;
+import com.mortals.xhx.feign.skin.ISkinSampleFeign;
 import com.mortals.xhx.module.product.model.ProductEntity;
 import com.mortals.xhx.module.product.service.ProductService;
 import com.mortals.xhx.module.skin.dao.SkinBaseDao;
@@ -64,6 +66,10 @@ public class SkinBaseServiceImpl extends AbstractCRUDServiceImpl<SkinBaseDao, Sk
     private ProductService productService;
     @Autowired
     private ParamService paramService;
+    @Autowired
+    private ISkinSampleFeign skinSampleFeign;
+    @Autowired
+    private ISkinFillFeign skinFillFeign;
 
     @Override
     protected void validData(SkinBaseEntity entity, Context context) throws AppException {
@@ -161,6 +167,9 @@ public class SkinBaseServiceImpl extends AbstractCRUDServiceImpl<SkinBaseDao, Sk
             });
             skinFieldService.save(entity.getSkinFieldList(), context);
         }
+        //通知子系统同步皮肤数据
+        skinSampleFeign.refreshSkin();
+        skinFillFeign.refreshSkin();
     }
 
     @Override

common-lib/src/main/java/com/mortals/xhx/feign/area/IApiAreaFeign.java

 package com.mortals.xhx.feign.area;
 
 import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
 import com.mortals.xhx.common.code.ApiRespCodeEnum;
 import com.mortals.xhx.common.pdu.SitePdu;
 import com.mortals.xhx.feign.IFeign;
@@ -70,6 +71,15 @@ public interface IApiAreaFeign extends IFeign {
     @PostMapping(value = "/site/getFlatSitesByAreaIds")
     String getFlatSitesByAreaIds(@RequestBody SitePdu query);
 
+    /**
+     * 用户刷新通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/usr/refreshUser")
+    Rest<Void> refreshUser();
+
 //    /**
 //     * 根据条件查询站点列表
 //     * @param query
@@ -134,6 +144,16 @@ class AreaFeignFallbackFactory implements FallbackFactory<IApiAreaFeign> {
                 return JSON.toJSONString(failResp);
             }
 
+
+
+            /**
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshUser() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
+
 //            @Override
 //            public String getSitesByQuery(SitePdu query) {
 //                ApiResp<String> failResp = new ApiResp<>();

common-lib/src/main/java/com/mortals/xhx/feign/device/IDeviceFeign.java

@@ -69,6 +69,16 @@ public interface IDeviceFeign extends IFeign {
     Rest<Void> refreshMessage(@RequestBody DevicePdu devicePdu);
 
 
+    /**
+     * 用户刷新通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/usr/refreshUser")
+    Rest<Void> refreshUser();
+
+
 }
 
 
@@ -106,6 +116,14 @@ class DeviceFeignFallbackFactory implements FallbackFactory<IDeviceFeign> {
             public Rest<Void> refreshMessage(DevicePdu devicePdu) {
                 return Rest.fail("暂时无法通知设备，请稍后再试!");
             }
+
+            /**
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshUser() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
         };
     }
 }

common-lib/src/main/java/com/mortals/xhx/feign/skin/ISkinFillFeign.java

+package com.mortals.xhx.feign.skin;
+
+import com.mortals.framework.common.Rest;
+import com.mortals.xhx.feign.IFeign;
+import feign.hystrix.FallbackFactory;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PostMapping;
+
+/**
+ * 填单皮肤 Feign接口
+ * @author zxfei
+ * @date 2022-10-26
+ */
+@FeignClient(name = "fill-manager", path = "/fm", fallbackFactory = SkinFillFeignFallbackFactory.class)
+public interface ISkinFillFeign extends IFeign {
+
+
+    /**
+     * 皮肤变更通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/skin/refreshSkin")
+    Rest<Void> refreshSkin();
+
+
+    /**
+     * 用户刷新通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/usr/refreshUser")
+    Rest<Void> refreshUser();
+
+
+}
+
+
+@Slf4j
+@Component
+class SkinFillFeignFallbackFactory implements FallbackFactory<ISkinFillFeign> {
+    @Override
+    public ISkinFillFeign create(Throwable t) {
+        return new ISkinFillFeign() {
+
+            /**
+             * @param
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshSkin() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
+
+            /**
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshUser() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
+        };
+    }
+}
+
+
+
+
+
+
+
+

common-lib/src/main/java/com/mortals/xhx/feign/skin/ISkinSampleFeign.java

+package com.mortals.xhx.feign.skin;
+
+import com.mortals.framework.common.Rest;
+import com.mortals.xhx.feign.IFeign;
+import feign.hystrix.FallbackFactory;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * 样表皮肤 Feign接口
+ * @author zxfei
+ * @date 2022-10-26
+ */
+@FeignClient(name = "sample-form-manager", path = "/sampleform", fallbackFactory = SkinFillFeignFallbackFactory.class)
+public interface ISkinSampleFeign extends IFeign {
+
+
+    /**
+     * 皮肤变更通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/skin/refreshSkin")
+    Rest<Void> refreshSkin();
+
+
+
+    /**
+     * 用户刷新通知
+     *
+     * @param
+     * @return
+     */
+    @PostMapping(value = "/usr/refreshUser")
+    Rest<Void> refreshUser();
+
+}
+
+
+@Slf4j
+@Component
+class SkinSampleFeignFallbackFactory implements FallbackFactory<ISkinFillFeign> {
+    @Override
+    public ISkinFillFeign create(Throwable t) {
+        return new ISkinFillFeign() {
+
+            /**
+             * @param
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshSkin() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
+
+            /**
+             * @return
+             */
+            @Override
+            public Rest<Void> refreshUser() {
+                return Rest.fail("暂时无法通知设备，请稍后再试!");
+            }
+        };
+    }
+}
+
+
+
+
+
+
+
+

portal-manager/db/add.sql

@@ -61,4 +61,12 @@ CREATE TABLE `mortals_xhx_user_model_collect` (
 ALTER TABLE `mortals_xhx_user_model_collect`
 ADD COLUMN `siteId` bigint(20) DEFAULT NULL COMMENT '站点ID';
 
-UPDATE mortals_xhx_user_model_collect SET siteId=1;
+UPDATE mortals_xhx_user_model_collect SET siteId=1;
\ No newline at end of file
+
+-- ----------------------------
+2023-11-13
+-- ----------------------------
+ALTER TABLE mortals_xhx_role_auth ADD COLUMN `resourceId` bigint(20)      COMMENT '资源ID';
+ALTER TABLE mortals_xhx_role_auth ADD COLUMN  `createTime` datetime      COMMENT '创建时间';
+ALTER TABLE mortals_xhx_role_auth ADD COLUMN  `createUserId` bigint(20)      COMMENT '创建用户';
+ALTER TABLE mortals_xhx_role_auth ADD COLUMN `createUserName` varchar(50)      COMMENT '创建用户名称';

portal-manager/src/main/java/com/mortals/xhx/base/framework/security/AuthTokenServiceImpl.java

@@ -8,6 +8,11 @@ import com.mortals.framework.service.ICacheService;
 import com.mortals.framework.service.IUser;
 import com.mortals.framework.util.DateUtils;
 import com.mortals.framework.util.StringUtils;
+import com.mortals.xhx.base.system.resource.service.ResourceService;
+import com.mortals.xhx.common.key.RedisKey;
+import com.mortals.xhx.common.utils.MenuEncodeUtil;
+import com.mortals.xhx.module.user.model.UserEntity;
+import com.mortals.xhx.module.user.service.UserService;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
@@ -50,6 +55,9 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
     @Value("${token.prefix:}")
     private String tokenPrefix;
 
+    @Autowired
+    private UserService userService;
+
     protected static final Long MILLIS_SECOND = 1l;
 
     protected static final Long MILLIS_MINUTE = 60 * MILLIS_SECOND;
@@ -65,6 +73,9 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
     @Autowired
     private ICacheService cacheService;
 
+    @Autowired
+    private ResourceService resourceService;
+
     /**
      * 获取信息
      *
@@ -85,7 +96,25 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
                 String uuid = (String) claims.get(SysConstains.LOGIN_USER_KEY);
                 String userKey = getTokenKey(uuid);
                 String userStr = cacheService.get(userKey);
-                if (StringUtils.isNotEmpty(userStr)) {
+
+                UserEntity userEntity = JSONObject.parseObject(userStr, UserEntity.class);
+                userEntity.setToken(token);
+                //更新portal 中的id 为 device中的id
+                //  UserEntity temp = userService.selectOne(new UserQuery().loginName(userEntity.getLoginName()));
+                UserEntity temp = userService.getExtCache(userEntity.getLoginName());
+                if (!ObjectUtils.isEmpty(temp)) {
+                    userEntity.setId(temp.getId());
+                }
+                //更新resource 路径
+                String menuUrlCode = cacheService.hget(RedisKey.KEY_USER_MENU_CACHE, userEntity.getId().toString(), String.class);
+                if (ObjectUtils.isEmpty(menuUrlCode)) {
+                    Set<String> urls = resourceService.findUrlSetByUserId(userEntity.getId());
+                    menuUrlCode = MenuEncodeUtil.generateMenuUrlCode(urls);
+                    cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userEntity.getId().toString(), menuUrlCode);
+                }
+                userEntity.setMenuUrl(menuUrlCode);
+                return userEntity;
+           /*     if (StringUtils.isNotEmpty(userStr)) {
                     JSONObject userObj = JSON.parseObject(userStr);
                     Long userId = userObj.getLongValue("id");
                     Integer userType = userObj.getIntValue("userType");
@@ -198,8 +227,6 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
                         public void setExpireTime(Long expireTime) {
 
                         }
-
-
                         @Override
                         public String getMenuUrl() {
                             return menuUrl;
@@ -207,7 +234,7 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
 
                     };
 
-                }
+                }*/
                 //  return cacheService.get(userKey, IUser.class);
             } catch (Exception e) {
                 log.error("解析jwt token异常！", e);

portal-manager/src/main/java/com/mortals/xhx/base/system/resource/service/impl/ResourceServiceImpl.java

 /**
-* 文件：ResourceServiceImpl.java
-* 版本：1.0.0
-* 日期：
-* Copyright ® 
-* All right reserved.
-*/
+ * 文件：ResourceServiceImpl.java
+ * 版本：1.0.0
+ * 日期：
+ * Copyright ®
+ * All right reserved.
+ */
 
 package com.mortals.xhx.base.system.resource.service.impl;
 
@@ -19,9 +19,14 @@ import com.mortals.xhx.base.system.resource.model.ResourceEntity;
 import com.mortals.xhx.base.system.resource.model.ResourceQuery;
 import com.mortals.xhx.base.system.resource.service.ResourceService;
 import com.mortals.xhx.common.key.RedisKey;
+import com.mortals.xhx.module.role.model.RoleAuthEntity;
+import com.mortals.xhx.module.role.model.RoleAuthQuery;
+import com.mortals.xhx.module.role.service.RoleAuthService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
 
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -33,15 +38,20 @@ import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode;
  * <p>Description: ResourceServiceImpl service接口 </p>
  * <p>Copyright: Copyright &reg;  </p>
  * <p>Company: </p>
- * @author 
+ *
+ * @author
  * @version 1.0.0
  */
 @Service("resourceService")
-public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao,ResourceEntity,Long> implements ResourceService {
+public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, ResourceEntity, Long> implements ResourceService {
 
     @Autowired
     private ICacheService cacheService;
 
+    @Autowired
+    private RoleAuthService roleAuthService;
+
+
     @Override
     public List<ResourceEntity> findAllEnable() throws AppException {
         ResourceQuery params = new ResourceQuery();
@@ -90,13 +100,27 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao,Res
         updateUserMenuUrlCache();
     }
 
+    @Override
+    protected void removeAfter(Long[] ids, Context context, int result) throws AppException {
+        //删除关联表中数据
+        if (!ObjectUtils.isEmpty(ids)) {
+            RoleAuthQuery query = new RoleAuthQuery();
+            query.setResourceIdList(Arrays.asList(ids));
+            List<RoleAuthEntity> roleAuthEntities = roleAuthService.find(query);
+            if (!ObjectUtils.isEmpty(roleAuthEntities)) {
+                roleAuthService.remove(roleAuthEntities.stream().map(m -> m.getId()).toArray(Long[]::new), context);
+                updateUserMenuUrlCache();
+            }
+        }
+    }
+
     private void updateUserMenuUrlCache() {
         //更新用户菜单
         Set<String> hkeys = cacheService.hkeys(RedisKey.KEY_USER_MENU_CACHE);
         for (String userId : hkeys) {
-            Set<String> urls = this.findUrlSetByUserId(DataUtil.converStr2Long(userId,0L));
+            Set<String> urls = this.findUrlSetByUserId(DataUtil.converStr2Long(userId, 0L));
             String menuUrlCode = generateMenuUrlCode(urls);
-            cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId,menuUrlCode);
+            cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId, menuUrlCode);
         }
     }
 }
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/role/model/RoleAuthEntity.java

 package com.mortals.xhx.module.role.model;
-
 import java.util.List;
 import java.util.ArrayList;
+import java.math.BigDecimal;
+import cn.hutool.core.date.DateUtil;
+import java.util.Date;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.role.model.vo.RoleAuthVo;
+import lombok.Data;
 /**
-* 角色菜单权限关联实体对象
-*
-* @author zxfei
-* @date 2022-06-02
-*/
-
+ * 角色菜单权限关联实体对象
+ *
+ * @author zxfei
+ * @date 2023-11-13
+ */
+@Data
 public class RoleAuthEntity extends RoleAuthVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 角色ID
-    */
+     * 角色ID
+     */
     private Long roleId;
     /**
-    * 菜单ID
-    */
+     * 菜单ID
+     */
     private Long menuId;
-
-
-
-    public RoleAuthEntity(){}
     /**
-    * 获取 角色ID
-    * @return Long
-    */
-    public Long getRoleId(){
-        return roleId;
-    }
-    /**
-    * 设置 角色ID
-    * @param roleId
-    */
-    public void setRoleId(Long roleId){
-        this.roleId = roleId;
-    }
-    /**
-    * 获取 菜单ID
-    * @return Long
-    */
-    public Long getMenuId(){
-        return menuId;
-    }
+     * 资源ID
+     */
+    private Long resourceId;
     /**
-    * 设置 菜单ID
-    * @param menuId
-    */
-    public void setMenuId(Long menuId){
-        this.menuId = menuId;
-    }
-
-
-
-
+     * 创建用户名称
+     */
+    private String createUserName;
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -70,23 +45,16 @@ public class RoleAuthEntity extends RoleAuthVo {
         if (obj instanceof RoleAuthEntity) {
             RoleAuthEntity tmp = (RoleAuthEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
     }
 
-    public String toString(){
-        StringBuilder sb = new StringBuilder("");
-        sb.append(",roleId:").append(getRoleId());
-        sb.append(",menuId:").append(getMenuId());
-        return sb.toString();
-    }
-
     public void initAttrValue(){
-
-            this.roleId = null;
-
-            this.menuId = null;
+        this.roleId = null;
+        this.menuId = null;
+        this.resourceId = null;
+        this.createUserName = "";
     }
 }
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/role/model/RoleAuthQuery.java

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.role.model;
 import java.util.List;
 import com.mortals.xhx.module.role.model.RoleAuthEntity;
 /**
-* 角色菜单权限关联查询对象
-*
-* @author zxfei
-* @date 2022-06-02
-*/
+ * 角色菜单权限关联查询对象
+ *
+ * @author zxfei
+ * @date 2023-11-13
+ */
 public class RoleAuthQuery extends RoleAuthEntity {
     /** 开始 序号，主键，自增长 */
     private Long idStart;
@@ -21,6 +21,9 @@ public class RoleAuthQuery extends RoleAuthEntity {
     /** 序号，主键，自增长列表 */
     private List <Long> idList;
 
+    /** 序号，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
     /** 开始 角色ID */
     private Long roleIdStart;
 
@@ -33,6 +36,9 @@ public class RoleAuthQuery extends RoleAuthEntity {
     /** 角色ID列表 */
     private List <Long> roleIdList;
 
+    /** 角色ID排除列表 */
+    private List <Long> roleIdNotList;
+
     /** 开始 菜单ID */
     private Long menuIdStart;
 
@@ -45,6 +51,50 @@ public class RoleAuthQuery extends RoleAuthEntity {
     /** 菜单ID列表 */
     private List <Long> menuIdList;
 
+    /** 菜单ID排除列表 */
+    private List <Long> menuIdNotList;
+
+    /** 开始 资源ID */
+    private Long resourceIdStart;
+
+    /** 结束 资源ID */
+    private Long resourceIdEnd;
+
+    /** 增加 资源ID */
+    private Long resourceIdIncrement;
+
+    /** 资源ID列表 */
+    private List <Long> resourceIdList;
+
+    /** 资源ID排除列表 */
+    private List <Long> resourceIdNotList;
+
+    /** 开始 创建时间 */
+    private String createTimeStart;
+
+    /** 结束 创建时间 */
+    private String createTimeEnd;
+
+    /** 开始 创建用户 */
+    private Long createUserIdStart;
+
+    /** 结束 创建用户 */
+    private Long createUserIdEnd;
+
+    /** 增加 创建用户 */
+    private Long createUserIdIncrement;
+
+    /** 创建用户列表 */
+    private List <Long> createUserIdList;
+
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
+    /** 创建用户名称 */
+    private List<String> createUserNameList;
+
+    /** 创建用户名称排除列表 */
+    private List <String> createUserNameNotList;
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<RoleAuthQuery> orConditionList;
 
@@ -54,360 +104,792 @@ public class RoleAuthQuery extends RoleAuthEntity {
     public RoleAuthQuery(){}
 
     /**
-    * 获取 开始 序号，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 序号，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 序号，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 序号，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 序号，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 序号，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 序号，主键，自增长
-    * @return idList
-    */
+     * 获取 序号，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 开始 角色ID
-    * @return roleIdStart
-    */
+     * 获取 序号，主键，自增长
+     * @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
-    */
+     * 设置 开始 角色ID
+     * @param roleIdStart
+     */
     public void setRoleIdStart(Long roleIdStart){
         this.roleIdStart = roleIdStart;
     }
 
     /**
-    * 获取 结束 角色ID
-    * @return $roleIdEnd
-    */
+     * 获取 结束 角色ID
+     * @return $roleIdEnd
+     */
     public Long getRoleIdEnd(){
         return this.roleIdEnd;
     }
 
     /**
-    * 设置 结束 角色ID
-    * @param roleIdEnd
-    */
+     * 设置 结束 角色ID
+     * @param roleIdEnd
+     */
     public void setRoleIdEnd(Long roleIdEnd){
         this.roleIdEnd = roleIdEnd;
     }
 
     /**
-    * 获取 增加 角色ID
-    * @return roleIdIncrement
-    */
+     * 获取 增加 角色ID
+     * @return roleIdIncrement
+     */
     public Long getRoleIdIncrement(){
         return this.roleIdIncrement;
     }
 
     /**
-    * 设置 增加 角色ID
-    * @param roleIdIncrement
-    */
+     * 设置 增加 角色ID
+     * @param roleIdIncrement
+     */
     public void setRoleIdIncrement(Long roleIdIncrement){
         this.roleIdIncrement = roleIdIncrement;
     }
 
     /**
-    * 获取 角色ID
-    * @return roleIdList
-    */
+     * 获取 角色ID
+     * @return roleIdList
+     */
     public List<Long> getRoleIdList(){
         return this.roleIdList;
     }
 
     /**
-    * 设置 角色ID
-    * @param roleIdList
-    */
+     * 设置 角色ID
+     * @param roleIdList
+     */
     public void setRoleIdList(List<Long> roleIdList){
         this.roleIdList = roleIdList;
     }
 
     /**
-    * 获取 开始 菜单ID
-    * @return menuIdStart
-    */
+     * 获取 角色ID
+     * @return roleIdNotList
+     */
+    public List<Long> getRoleIdNotList(){
+        return this.roleIdNotList;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdNotList
+     */
+    public void setRoleIdNotList(List<Long> roleIdNotList){
+        this.roleIdNotList = roleIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 菜单ID
+     * @return menuIdStart
+     */
     public Long getMenuIdStart(){
         return this.menuIdStart;
     }
 
     /**
-    * 设置 开始 菜单ID
-    * @param menuIdStart
-    */
+     * 设置 开始 菜单ID
+     * @param menuIdStart
+     */
     public void setMenuIdStart(Long menuIdStart){
         this.menuIdStart = menuIdStart;
     }
 
     /**
-    * 获取 结束 菜单ID
-    * @return $menuIdEnd
-    */
+     * 获取 结束 菜单ID
+     * @return $menuIdEnd
+     */
     public Long getMenuIdEnd(){
         return this.menuIdEnd;
     }
 
     /**
-    * 设置 结束 菜单ID
-    * @param menuIdEnd
-    */
+     * 设置 结束 菜单ID
+     * @param menuIdEnd
+     */
     public void setMenuIdEnd(Long menuIdEnd){
         this.menuIdEnd = menuIdEnd;
     }
 
     /**
-    * 获取 增加 菜单ID
-    * @return menuIdIncrement
-    */
+     * 获取 增加 菜单ID
+     * @return menuIdIncrement
+     */
     public Long getMenuIdIncrement(){
         return this.menuIdIncrement;
     }
 
     /**
-    * 设置 增加 菜单ID
-    * @param menuIdIncrement
-    */
+     * 设置 增加 菜单ID
+     * @param menuIdIncrement
+     */
     public void setMenuIdIncrement(Long menuIdIncrement){
         this.menuIdIncrement = menuIdIncrement;
     }
 
     /**
-    * 获取 菜单ID
-    * @return menuIdList
-    */
+     * 获取 菜单ID
+     * @return menuIdList
+     */
     public List<Long> getMenuIdList(){
         return this.menuIdList;
     }
 
     /**
-    * 设置 菜单ID
-    * @param menuIdList
-    */
+     * 设置 菜单ID
+     * @param menuIdList
+     */
     public void setMenuIdList(List<Long> menuIdList){
         this.menuIdList = menuIdList;
     }
 
     /**
-    * 设置  序号，主键，自增长
-    * @param id
-    */
+     * 获取 菜单ID
+     * @return menuIdNotList
+     */
+    public List<Long> getMenuIdNotList(){
+        return this.menuIdNotList;
+    }
+
+    /**
+     * 设置 菜单ID
+     * @param menuIdNotList
+     */
+    public void setMenuIdNotList(List<Long> menuIdNotList){
+        this.menuIdNotList = menuIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 资源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 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 createUserNameList
+     */
+    public List<String> getCreateUserNameList(){
+        return this.createUserNameList;
+    }
+
+    /**
+     * 设置 创建用户名称
+     * @param createUserNameList
+     */
+    public void setCreateUserNameList(List<String> createUserNameList){
+        this.createUserNameList = createUserNameList;
+    }
+
+    /**
+     * 获取 创建用户名称
+     * @return createUserNameNotList
+     */
+    public List<String> getCreateUserNameNotList(){
+        return this.createUserNameNotList;
+    }
+
+    /**
+     * 设置 创建用户名称
+     * @param createUserNameNotList
+     */
+    public void setCreateUserNameNotList(List<String> createUserNameNotList){
+        this.createUserNameNotList = createUserNameNotList;
+    }
+
+    /**
+     * 设置  序号，主键，自增长
+     * @param id
+     */
     public RoleAuthQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public RoleAuthQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public RoleAuthQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public RoleAuthQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public RoleAuthQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
+        return this;
+    }
 
     /**
-    * 设置  角色ID
-    * @param roleId
-    */
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public RoleAuthQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+    }
+
+    /**
+     * 设置  角色ID
+     * @param roleId
+     */
     public RoleAuthQuery roleId(Long roleId){
-	    setRoleId(roleId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 角色ID
-    * @param roleIdStart
-    */
+        setRoleId(roleId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 角色ID
+     * @param roleIdStart
+     */
     public RoleAuthQuery roleIdStart(Long roleIdStart){
-		this.roleIdStart = roleIdStart;
-		return this;
+        this.roleIdStart = roleIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 角色ID
-    * @param roleIdEnd
-    */
+     * 设置 结束 角色ID
+     * @param roleIdEnd
+     */
     public RoleAuthQuery roleIdEnd(Long roleIdEnd){
-		this.roleIdEnd = roleIdEnd;
-		return this;
+        this.roleIdEnd = roleIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 角色ID
-    * @param roleIdIncrement
-    */
+     * 设置 增加 角色ID
+     * @param roleIdIncrement
+     */
     public RoleAuthQuery roleIdIncrement(Long roleIdIncrement){
-		this.roleIdIncrement = roleIdIncrement;
-		return this;
+        this.roleIdIncrement = roleIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 角色ID
-    * @param roleIdList
-    */
+     * 设置 角色ID
+     * @param roleIdList
+     */
     public RoleAuthQuery roleIdList(List<Long> roleIdList){
         this.roleIdList = roleIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 角色ID
+     * @param roleIdNotList
+     */
+    public RoleAuthQuery roleIdNotList(List<Long> roleIdNotList){
+        this.roleIdNotList = roleIdNotList;
+        return this;
+    }
 
     /**
-    * 设置  菜单ID
-    * @param menuId
-    */
+     * 设置  菜单ID
+     * @param menuId
+     */
     public RoleAuthQuery menuId(Long menuId){
-	    setMenuId(menuId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 菜单ID
-    * @param menuIdStart
-    */
+        setMenuId(menuId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 菜单ID
+     * @param menuIdStart
+     */
     public RoleAuthQuery menuIdStart(Long menuIdStart){
-		this.menuIdStart = menuIdStart;
-		return this;
+        this.menuIdStart = menuIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 菜单ID
-    * @param menuIdEnd
-    */
+     * 设置 结束 菜单ID
+     * @param menuIdEnd
+     */
     public RoleAuthQuery menuIdEnd(Long menuIdEnd){
-		this.menuIdEnd = menuIdEnd;
-		return this;
+        this.menuIdEnd = menuIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 菜单ID
-    * @param menuIdIncrement
-    */
+     * 设置 增加 菜单ID
+     * @param menuIdIncrement
+     */
     public RoleAuthQuery menuIdIncrement(Long menuIdIncrement){
-		this.menuIdIncrement = menuIdIncrement;
-		return this;
+        this.menuIdIncrement = menuIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 菜单ID
-    * @param menuIdList
-    */
+     * 设置 菜单ID
+     * @param menuIdList
+     */
     public RoleAuthQuery menuIdList(List<Long> menuIdList){
         this.menuIdList = menuIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 菜单ID
+     * @param menuIdNotList
+     */
+    public RoleAuthQuery menuIdNotList(List<Long> menuIdNotList){
+        this.menuIdNotList = menuIdNotList;
+        return this;
+    }
+
+    /**
+     * 设置  资源ID
+     * @param resourceId
+     */
+    public RoleAuthQuery resourceId(Long resourceId){
+        setResourceId(resourceId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 资源ID
+     * @param resourceIdStart
+     */
+    public RoleAuthQuery resourceIdStart(Long resourceIdStart){
+        this.resourceIdStart = resourceIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 资源ID
+     * @param resourceIdEnd
+     */
+    public RoleAuthQuery resourceIdEnd(Long resourceIdEnd){
+        this.resourceIdEnd = resourceIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 资源ID
+     * @param resourceIdIncrement
+     */
+    public RoleAuthQuery resourceIdIncrement(Long resourceIdIncrement){
+        this.resourceIdIncrement = resourceIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdList
+     */
+    public RoleAuthQuery resourceIdList(List<Long> resourceIdList){
+        this.resourceIdList = resourceIdList;
+        return this;
+    }
+
+    /**
+     * 设置 资源ID
+     * @param resourceIdNotList
+     */
+    public RoleAuthQuery resourceIdNotList(List<Long> resourceIdNotList){
+        this.resourceIdNotList = resourceIdNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置  创建用户
+     * @param createUserId
+     */
+    public RoleAuthQuery createUserId(Long createUserId){
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
+    public RoleAuthQuery createUserIdStart(Long createUserIdStart){
+        this.createUserIdStart = createUserIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
+    public RoleAuthQuery createUserIdEnd(Long createUserIdEnd){
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
+    public RoleAuthQuery createUserIdIncrement(Long createUserIdIncrement){
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdList
+     */
+    public RoleAuthQuery createUserIdList(List<Long> createUserIdList){
+        this.createUserIdList = createUserIdList;
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public RoleAuthQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置 创建用户名称
+     * @param createUserName
+     */
+    public RoleAuthQuery createUserName(String createUserName){
+        setCreateUserName(createUserName);
+        return this;
+    }
+
+    /**
+     * 设置 创建用户名称
+     * @param createUserNameList
+     */
+    public RoleAuthQuery createUserNameList(List<String> createUserNameList){
+        this.createUserNameList = createUserNameList;
+        return this;
+    }
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<RoleAuthQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param 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<RoleAuthQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<RoleAuthQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param 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<RoleAuthQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

portal-manager/src/main/java/com/mortals/xhx/module/role/service/RoleAuthService.java

@@ -28,4 +28,8 @@ public interface RoleAuthService extends ICRUDService<RoleAuthEntity, Long> {
      * @return
      */
     Map<Long,List<Long>> getMenuIdByRole(Long userId);
+
+
+    /** 角色分配资源 */
+    void doDistributionSource(RoleAuthQuery query);
 }
\ No newline at end of file

portal-manager/src/main/java/com/mortals/xhx/module/role/service/impl/RoleAuthServiceImpl.java

@@ -29,6 +29,27 @@ public class RoleAuthServiceImpl extends AbstractCRUDServiceImpl<RoleAuthDao, Ro
     @Autowired
     private RoleUserService roleUserService;
 
+
+    @Override
+    public void doDistributionSource(RoleAuthQuery query) {
+        // 删除角色资源老数据
+        Long roleId = query.getRoleId();
+        Map<String, Object> condition = new HashMap<>();
+        condition.put("roleId", roleId);
+        condition.put("menuId", null);
+        this.dao.delete(condition);
+
+        List<RoleAuthEntity> list = new ArrayList<>();
+        for (Long sourceId : query.getResourceIdList()) {
+            RoleAuthEntity entity = new RoleAuthEntity();
+            entity.setRoleId(roleId);
+            entity.setResourceId(sourceId);
+            list.add(entity);
+        }
+        this.dao.insertBatch(list);
+    }
+
+
     @Override
     public void assignMenu(RoleAuthQuery query) {
         Map<Long, MenuEntity> menuEntityMap = menuService.find(new MenuQuery()).stream().collect(Collectors.toMap(x -> x.getId(), y -> y));
@@ -36,6 +57,7 @@ public class RoleAuthServiceImpl extends AbstractCRUDServiceImpl<RoleAuthDao, Ro
         Long roleId = query.getRoleId();
         Map<String, Object> condition = new HashMap<>();
         condition.put("roleId", roleId);
+        condition.put("resoruceId", null);
         this.dao.delete(condition);
 
         Set<Long> curSet = query.getMenuIdList().stream().collect(Collectors.toSet());
@@ -70,27 +92,27 @@ public class RoleAuthServiceImpl extends AbstractCRUDServiceImpl<RoleAuthDao, Ro
     }
 
     @Override
-    public Map<Long,List<Long>> getMenuIdByRole(Long roleId) {
+    public Map<Long, List<Long>> getMenuIdByRole(Long roleId) {
         RoleAuthQuery condition = new RoleAuthQuery();
         condition.setRoleId(roleId);
         List<RoleAuthEntity> roleModelEntities = this.find(condition);
-        if(CollectionUtils.isNotEmpty(roleModelEntities)) {
+        if (CollectionUtils.isNotEmpty(roleModelEntities)) {
             List<Long> menuIds = roleModelEntities.stream().map(RoleAuthEntity::getMenuId).collect(Collectors.toList());
             MenuQuery query1 = new MenuQuery();
             query1.setIdList(menuIds);
             List<MenuEntity> menuEntities = menuService.find(query1);
-            Map<Long,List<Long>> map = new HashMap<>();
-            menuEntities.forEach(m->{
-                if(map.containsKey(m.getParentId())){
+            Map<Long, List<Long>> map = new HashMap<>();
+            menuEntities.forEach(m -> {
+                if (map.containsKey(m.getParentId())) {
                     map.get(m.getParentId()).add(m.getId());
-                }else {
+                } else {
                     List<Long> menuIdList = new ArrayList<>();
                     menuIdList.add(m.getId());
-                    map.put(m.getParentId(),menuIdList);
+                    map.put(m.getParentId(), menuIdList);
                 }
             });
             return map;
-        }else {
+        } else {
             return Collections.emptyMap();
         }
     }

portal-manager/src/main/java/com/mortals/xhx/module/role/web/RoleAuthController.java

@@ -37,6 +37,27 @@ public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAu
         super.init(model, context);
     }
 
+
+
+    /**
+     * 分配资源
+     */
+    @PostMapping(value = "distributionSource")
+    public String distributionUser(@RequestBody RoleAuthQuery query) {
+        try {
+            service.doDistributionSource(query);
+            JSONObject ret = new JSONObject();
+            ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
+            return ret.toJSONString();
+        } catch (Exception e) {
+            log.error("分配角色资源错误", e);
+            JSONObject ret = new JSONObject();
+            ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
+            ret.put(KEY_RESULT_MSG, super.convertException(e));
+            return ret.toJSONString();
+        }
+    }
+
     /**
      * 分配菜单到角色
      */

portal-manager/src/main/java/com/mortals/xhx/module/user/model/vo/UserVo.java

@@ -57,6 +57,11 @@ public class UserVo extends BaseEntityLong  {
     private String oldPwd;
     private String newPwd;
 
+    /**
+     * 菜单栏
+     */
+    private String menuUrl;
+
 
     public static void main(String[] args) {
         UserQuery userEntity = new UserQuery();

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

@@ -4,6 +4,7 @@ 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.ICRUDCacheService;
 import com.mortals.framework.service.ICRUDService;
 import com.mortals.xhx.module.user.model.UserEntity;
 import com.mortals.xhx.module.user.model.UserEntityExt;
@@ -16,7 +17,7 @@ import com.mortals.xhx.module.user.model.UserEntityExt;
 * @author zxfei
 * @date 2022-05-25
 */
-public interface UserService extends ICRUDService<UserEntity,Long>{
+public interface UserService extends ICRUDCacheService<UserEntity,Long> {
     /**
      * 用户登录
      *

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

@@ -12,6 +12,7 @@ import com.mortals.framework.model.PageInfo;
 import com.mortals.framework.model.Result;
 import com.mortals.framework.service.IAuthTokenService;
 import com.mortals.framework.service.ICacheService;
+import com.mortals.framework.service.impl.AbstractCRUDCacheServiceImpl;
 import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
 import com.mortals.framework.util.*;
 import com.mortals.xhx.common.code.YesNoEnum;
@@ -44,7 +45,7 @@ import java.util.stream.Collectors;
  * @date 2022-05-25
  */
 @Service("userService")
-public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity, Long> implements UserService {
+public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserEntity, Long> implements UserService {
     @Autowired
     private MenuService menuService;
     @Autowired
@@ -60,8 +61,17 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
     @Autowired
     private UserPwdRecordDao userPwdRecordDao;
 
+    /**
+     * @param data
+     * @return
+     */
+    @Override
+    protected String getExtKey(UserEntity data) {
+        return data.getLoginName();
+    }
+
 
-/*    @Override
+    /*    @Override
     protected void findAfter(UserEntity entity, PageInfo pageInfo, Context context, List<UserEntity> list) throws AppException {
         Map<Long, String> roleMap = roleService.find(new RoleQuery()).stream().collect(Collectors.toMap(x -> x.getId(), y -> y.getName()));
         List<Long> userIdList = list.stream().map(item -> item.getId()).collect(Collectors.toList());
@@ -79,22 +89,22 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
 
     private void doHandlerUser(UserEntity entity) throws AppException {
         if (StringUtils.isNotEmpty(entity.getLoginPwd())) {
-            if(!Solution.strongPasswordCheckerII(entity.getLoginPwd())){
+            if (!Solution.strongPasswordCheckerII(entity.getLoginPwd())) {
                 throw new AppException("新密码至少八位以上，包含大小写加特殊字符加数字");
             }
             try {
-                if(StringUtils.isEmpty(entity.getSaltKey())){
-                    String saltKey = SecurityCode.getSecurityCode(6,SecurityCode.SecurityCodeLevel.Medium,false);
+                if (StringUtils.isEmpty(entity.getSaltKey())) {
+                    String saltKey = SecurityCode.getSecurityCode(6, SecurityCode.SecurityCodeLevel.Medium, false);
                     entity.setSaltKey(saltKey);
                 }
                 entity.setLoginPwd(SecurityUtil.md5DoubleEncoding(entity.getLoginPwd() + entity.getSaltKey()));
             } catch (Exception e) {
                 throw new AppException("密码转换异常");
             }
-            if(entity.getId()!=null) {
+            if (entity.getId() != null) {
                 UserEntity old = this.get(entity.getId());
-                if (old != null ) {
-                    if(!old.getLoginPwd().equals(entity.getLoginPwd())){
+                if (old != null) {
+                    if (!old.getLoginPwd().equals(entity.getLoginPwd())) {
                         //判断新密码与最近五次修改密码是否相同
                         UserPwdRecordQuery recordQuery = new UserPwdRecordQuery();
                         recordQuery.setUserId(entity.getId());
@@ -103,10 +113,10 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
                                 add(new OrderCol("a.createTime", "desc"));
                             }
                         });
-                        List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery,0,5);
-                        if(CollectionUtils.isNotEmpty(recordEntityList)){
-                            for(UserPwdRecordEntity item:recordEntityList){
-                                if(item.getLoginPwd().equals(entity.getLoginPwd())){
+                        List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery, 0, 5);
+                        if (CollectionUtils.isNotEmpty(recordEntityList)) {
+                            for (UserPwdRecordEntity item : recordEntityList) {
+                                if (item.getLoginPwd().equals(entity.getLoginPwd())) {
                                     throw new AppException("新密码不能与最近五次密码相同！");
                                 }
                             }
@@ -178,39 +188,39 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
         if (sysUser == null || !sysUser.getLoginName().equals(loginName)) {
             throw new AppException("用户名不存在！");
         }
-        if(sysUser.getErrorCount()==null){
+        if (sysUser.getErrorCount() == null) {
             sysUser.setErrorCount(0);
         }
-        if(sysUser.getLoginLock()==null){
+        if (sysUser.getLoginLock() == null) {
             sysUser.setLoginLock(0);
         }
-        if(sysUser.getLoginLock() == 1 && sysUser.getLockTime()!=null){
+        if (sysUser.getLoginLock() == 1 && sysUser.getLockTime() != null) {
             String nowStr = DateUtils.getCurrStrDate();
-            String loginDateStr = DateUtils.getDateTime(sysUser.getLockTime(),"yyyy-MM-dd");
-            if(nowStr.equals(loginDateStr)) {
+            String loginDateStr = DateUtils.getDateTime(sysUser.getLockTime(), "yyyy-MM-dd");
+            if (nowStr.equals(loginDateStr)) {
                 throw new AppException("此账号当天密码错误次数已达上限，已被锁定");
             }
         }
 
         try {
-            if(StringUtils.isNotEmpty(sysUser.getSaltKey())) {
+            if (StringUtils.isNotEmpty(sysUser.getSaltKey())) {
                 password += sysUser.getSaltKey();
             }
             if (!sysUser.getLoginPwd().equals(SecurityUtil.md5DoubleEncoding(password))) {
                 UserEntity update = new UserEntity();
                 update.setId(sysUser.getId());
-                update.setErrorCount(sysUser.getErrorCount()+1);
-                if(update.getErrorCount()==5){
+                update.setErrorCount(sysUser.getErrorCount() + 1);
+                if (update.getErrorCount() == 5) {
                     update.setLoginLock(1);
                     update.setLockTime(new Date());
                 }
                 this.dao.update(update);
                 throw new AppException("登录密码错误！");
-            }else {
-                if(sysUser.getLastUpdatePwdTime()!=null) {
+            } else {
+                if (sysUser.getLastUpdatePwdTime() != null) {
                     long day = DateUtils.getBetween(sysUser.getLastUpdatePwdTime(), new Date(), 2);
                     if (day >= 90) {
-                        throw new AppException(99998,"密码已超过三个月没有更改，请修改以后再登录");
+                        throw new AppException(99998, "密码已超过三个月没有更改，请修改以后再登录");
                     }
                 }
             }
@@ -261,13 +271,13 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
             throw new AppException("帐号错误！");
         }
         try {
-            if(StringUtils.isNotEmpty(sysUser.getSaltKey())) {
+            if (StringUtils.isNotEmpty(sysUser.getSaltKey())) {
                 oldPwd += sysUser.getSaltKey();
             }
             if (!sysUser.getLoginPwd().equals(SecurityUtil.md5DoubleEncoding(oldPwd))) {
                 throw new AppException("原始密码错误！");
             }
-            if(!Solution.strongPasswordCheckerII(newPwd)){
+            if (!Solution.strongPasswordCheckerII(newPwd)) {
                 throw new AppException("新密码至少八位以上，包含大小写加特殊字符加数字");
             }
         } catch (Exception e) {
@@ -275,8 +285,8 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
         }
 
         try {
-            if(StringUtils.isEmpty(sysUser.getSaltKey())) {
-                String saltKey = SecurityCode.getSecurityCode(6,SecurityCode.SecurityCodeLevel.Medium,false);
+            if (StringUtils.isEmpty(sysUser.getSaltKey())) {
+                String saltKey = SecurityCode.getSecurityCode(6, SecurityCode.SecurityCodeLevel.Medium, false);
                 sysUser.setSaltKey(saltKey);
             }
             newPwd += sysUser.getSaltKey();
@@ -289,10 +299,10 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
                     add(new OrderCol("a.createTime", "desc"));
                 }
             });
-            List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery,0,5);
-            if(CollectionUtils.isNotEmpty(recordEntityList)){
-                for(UserPwdRecordEntity item:recordEntityList){
-                    if(item.getLoginPwd().equals(sysUser.getLoginPwd())){
+            List<UserPwdRecordEntity> recordEntityList = userPwdRecordDao.getList(recordQuery, 0, 5);
+            if (CollectionUtils.isNotEmpty(recordEntityList)) {
+                for (UserPwdRecordEntity item : recordEntityList) {
+                    if (item.getLoginPwd().equals(sysUser.getLoginPwd())) {
                         throw new AppException("新密码不能与最近五次密码相同！");
                     }
                 }
@@ -445,8 +455,8 @@ public class UserServiceImpl extends AbstractCRUDServiceImpl<UserDao, UserEntity
             throw new AppException("帐号错误！");
         }
         try {
-            if(StringUtils.isEmpty(sysUser.getSaltKey())) {
-                String saltKey = SecurityCode.getSecurityCode(6,SecurityCode.SecurityCodeLevel.Medium,false);
+            if (StringUtils.isEmpty(sysUser.getSaltKey())) {
+                String saltKey = SecurityCode.getSecurityCode(6, SecurityCode.SecurityCodeLevel.Medium, false);
                 sysUser.setSaltKey(saltKey);
             }
             sysUser.setLoginPwd(SecurityUtil.md5DoubleEncoding(newPwd + sysUser.getSaltKey()));

portal-manager/src/main/resources/sqlmap/base/system/resource.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.base.system.resource.dao.ibatis.ResourceDaoImpl">
+    
+	<!-- 字段和属性映射 -->
+	<resultMap type="ResourceEntity" id="ResourceEntity-Map">
+		<result property="id" column="id" />
+		<result property="name" column="name" />
+		<result property="url" column="url" />
+		<result property="authType" column="authType" />
+		<result property="sourceType" column="sourceType" />
+		<result property="createTime" column="createTime" />
+		<result property="createUserId" column="createUserId" />
+		<result property="createUserName" column="createUserName" />
+		<result property="userType" column="userType" />
+	</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 as id,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
+				a.name as name,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('url') or colPickMode == 1 and data.containsKey('url')))">
+				a.url as url,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('authType') or colPickMode == 1 and data.containsKey('authType')))">
+				a.authType as authType,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sourceType') or colPickMode == 1 and data.containsKey('sourceType')))">
+				a.sourceType as sourceType,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+				a.createTime as 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 as createUserId,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
+				a.createUserName as createUserName,
+			</if>
+			<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userType') or colPickMode == 1 and data.containsKey('userType')))">
+				a.userType as userType,
+			</if>
+		</trim>
+	</sql>
+	<!-- 新增 -->
+	<insert id="insert" parameterType="ResourceEntity" useGeneratedKeys="true" keyProperty="id">
+		insert into mortals_xhx_resource 
+		(name,url,authType,sourceType,createTime,
+			createUserId,createUserName,userType
+		)VALUES(#{name},#{url},#{authType},#{sourceType},#{createTime},
+			#{createUserId},#{createUserName},#{userType})
+	</insert>
+	<!-- 批量新增 -->
+	<insert id="insertBatch" parameterType="paramDto">
+		insert into mortals_xhx_resource 
+		(name,url,authType,sourceType,createTime,
+			createUserId,createUserName,userType
+		)
+		VALUES
+		<foreach collection="data.dataList" item="item" index="index" separator="," >  
+		(#{item.name},#{item.url},#{item.authType},#{item.sourceType},#{item.createTime},
+			#{item.createUserId},#{item.createUserName},#{item.userType})
+		</foreach>
+	</insert>
+	<!-- 根据ParamDto更新 -->
+	<update id="update" parameterType="paramDto">
+		update mortals_xhx_resource as a
+		   set
+		   <trim suffixOverrides="," suffix="">
+				<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
+					a.name=#{data.name},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('url')) or (colPickMode==1 and !data.containsKey('url'))">
+					a.url=#{data.url},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('authType')) or (colPickMode==1 and !data.containsKey('authType'))">
+					a.authType=#{data.authType},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('authTypeIncrement')) or (colPickMode==1 and !data.containsKey('authTypeIncrement'))">
+					a.authType=ifnull(a.authType,0) + #{data.authTypeIncrement},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('sourceType')) or (colPickMode==1 and !data.containsKey('sourceType'))">
+					a.sourceType=#{data.sourceType},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('sourceTypeIncrement')) or (colPickMode==1 and !data.containsKey('sourceTypeIncrement'))">
+					a.sourceType=ifnull(a.sourceType,0) + #{data.sourceTypeIncrement},
+				</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('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
+					a.createUserName=#{data.createUserName},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('userType')) or (colPickMode==1 and !data.containsKey('userType'))">
+					a.userType=#{data.userType},
+				</if>
+				<if test="(colPickMode==0 and data.containsKey('userTypeIncrement')) or (colPickMode==1 and !data.containsKey('userTypeIncrement'))">
+					a.userType=ifnull(a.userType,0) + #{data.userTypeIncrement},
+				</if>
+		    </trim>
+		   <trim suffixOverrides="where" suffix="">
+			    where
+			    <trim prefixOverrides="and" prefix="">
+					<include refid="_condition_"/>
+			   	</trim>
+			</trim>
+	</update>
+
+	<!-- 根据主健查询 -->
+	<select id="getByKey" parameterType="paramDto" resultMap="ResourceEntity-Map">
+		select <include refid="_columns"/>
+		from mortals_xhx_resource as a
+	   where a.id=#{condition.id}
+	</select>
+	<!-- 根据主健删除 -->
+	<delete id="deleteByKey" parameterType="paramDto">
+		delete a.* from mortals_xhx_resource as a where a.id=#{condition.id}
+	</delete>
+	<!-- 根据主健删除一批，针对单一主健有效 -->
+	<delete id="deleteByKeys">
+		delete from mortals_xhx_resource where id in
+		<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
+			#{item}
+		</foreach>
+	</delete>
+	<!-- 根据paramDto删除一批 -->
+	<delete id="deleteByMap" parameterType="paramDto">
+		delete a.* from mortals_xhx_resource as a
+		<trim suffixOverrides="where" suffix="">
+			 where 
+			<trim prefixOverrides="and" prefix="">
+				<include refid="_condition_"/>
+			</trim>
+		</trim>
+	</delete>
+	<!-- 获取列表 -->
+	<select id="getList" parameterType="paramDto" resultMap="ResourceEntity-Map">
+		select <include refid="_columns"/>
+		  from mortals_xhx_resource 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_resource 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()">
+				<if test="condition.containsKey('id')">
+					<if test="condition.id != null">
+						and a.id=#{condition.id}
+					</if>
+				</if>
+				<if test="condition.containsKey('id')">
+					<if test="condition.id != null ">
+						and a.id = #{condition.id}
+					</if>
+					<if test="condition.id == null">
+						and a.id is null
+					</if>
+				</if>
+				<if test="condition.containsKey('idList')">
+					 and a.id in 
+					<foreach collection="condition.idList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('idStart') and condition.idStart != null">
+					<![CDATA[ and a.id >= #{condition.idStart} ]]>
+				</if>
+				<if test="condition.containsKey('idEnd') and condition.idEnd != null">
+					<![CDATA[ and a.id <= #{condition.idEnd} ]]>
+				</if>
+				<if test="condition.containsKey('name')">
+					<if test="condition.name != null and condition.name != ''">
+						and a.name like #{condition.name}
+					</if>
+					<if test="condition.name == null">
+						and a.name is null
+					</if>
+				</if>
+				<if test="condition.containsKey('nameList')">
+					 and a.name in 
+					<foreach collection="condition.nameList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('url')">
+					<if test="condition.url != null and condition.url != ''">
+						and a.url like #{condition.url}
+					</if>
+					<if test="condition.url == null">
+						and a.url is null
+					</if>
+				</if>
+				<if test="condition.containsKey('urlList')">
+					 and a.url in 
+					<foreach collection="condition.urlList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('authType')">
+					<if test="condition.authType != null ">
+						and a.authType = #{condition.authType}
+					</if>
+					<if test="condition.authType == null">
+						and a.authType is null
+					</if>
+				</if>
+				<if test="condition.containsKey('authTypeList')">
+					 and a.authType in 
+					<foreach collection="condition.authTypeList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('authTypeStart') and condition.authTypeStart != null">
+					<![CDATA[ and a.authType >= #{condition.authTypeStart} ]]>
+				</if>
+				<if test="condition.containsKey('authTypeEnd') and condition.authTypeEnd != null">
+					<![CDATA[ and a.authType <= #{condition.authTypeEnd} ]]>
+				</if>
+				<if test="condition.containsKey('sourceType')">
+					<if test="condition.sourceType != null ">
+						and a.sourceType = #{condition.sourceType}
+					</if>
+					<if test="condition.sourceType == null">
+						and a.sourceType is null
+					</if>
+				</if>
+				<if test="condition.containsKey('sourceTypeList')">
+					 and a.sourceType in 
+					<foreach collection="condition.sourceTypeList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('sourceTypeStart') and condition.sourceTypeStart != null">
+					<![CDATA[ and a.sourceType >= #{condition.sourceTypeStart} ]]>
+				</if>
+				<if test="condition.containsKey('sourceTypeEnd') and condition.sourceTypeEnd != null">
+					<![CDATA[ and a.sourceType <= #{condition.sourceTypeEnd} ]]>
+				</if>
+				<if test="condition.containsKey('createTime')">
+					<if test="condition.createTime != null ">
+						and a.createTime = #{condition.createTime}
+					</if>
+					<if test="condition.createTime == null">
+						and a.createTime is null
+					</if>
+				</if>
+				<if test="condition.containsKey('createTimeStart') and condition.createTimeStart != null and condition.createTimeStart!=''">
+					<![CDATA[ and a.createTime >= STR_TO_DATE(left(concat(#{condition.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ]]>
+				</if>
+				<if test="condition.containsKey('createTimeEnd') and condition.createTimeEnd != null and condition.createTimeEnd!=''">
+					<![CDATA[ and a.createTime <= STR_TO_DATE(left(concat(#{condition.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ]]>
+				</if>
+				<if test="condition.containsKey('createUserId')">
+					<if test="condition.createUserId != null ">
+						and a.createUserId = #{condition.createUserId}
+					</if>
+					<if test="condition.createUserId == null">
+						and a.createUserId is null
+					</if>
+				</if>
+				<if test="condition.containsKey('createUserIdList')">
+					 and a.createUserId in 
+					<foreach collection="condition.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('createUserIdStart') and condition.createUserIdStart != null">
+					<![CDATA[ and a.createUserId >= #{condition.createUserIdStart} ]]>
+				</if>
+				<if test="condition.containsKey('createUserIdEnd') and condition.createUserIdEnd != null">
+					<![CDATA[ and a.createUserId <= #{condition.createUserIdEnd} ]]>
+				</if>
+				<if test="condition.containsKey('createUserName')">
+					<if test="condition.createUserName != null and condition.createUserName != ''">
+						and a.createUserName like #{condition.createUserName}
+					</if>
+					<if test="condition.createUserName == null">
+						and a.createUserName is null
+					</if>
+				</if>
+				<if test="condition.containsKey('createUserNameList')">
+					 and a.createUserName in 
+					<foreach collection="condition.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('userType')">
+					<if test="condition.userType != null ">
+						and a.userType = #{condition.userType}
+					</if>
+					<if test="condition.userType == null">
+						and a.userType is null
+					</if>
+				</if>
+				<if test="condition.containsKey('userTypeList')">
+					 and a.userType in 
+					<foreach collection="condition.userTypeList" open="(" close=")" index="index" item="item" separator=",">
+						#{item}
+					</foreach>
+				</if>
+				<if test="condition.containsKey('userTypeStart') and condition.userTypeStart != null">
+					<![CDATA[ and a.userType >= #{condition.userTypeStart} ]]>
+				</if>
+				<if test="condition.containsKey('userTypeEnd') and condition.userTypeEnd != null">
+					<![CDATA[ and a.userType <= #{condition.userTypeEnd} ]]>
+				</if>
+		</if>
+	</sql>
+	<sql id="_orderCols_">
+		<if test="orderColList != null and !orderColList.isEmpty()">
+	        order by
+	        <trim suffixOverrides=","  suffix="">
+				<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+						${item.colName} ${item.sortKind}
+				</foreach>
+			</trim>
+		</if>
+		<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+			order by
+			<trim suffixOverrides=","  suffix="">
+				<if test="orderCol.containsKey('id')">
+					a.id
+					<if test="orderCol.id!= null">
+						${orderCol.id}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('name')">
+					a.name
+					<if test="orderCol.name!= null">
+						${orderCol.name}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('url')">
+					a.url
+					<if test="orderCol.url!= null">
+						${orderCol.url}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('authType')">
+					a.authType
+					<if test="orderCol.authType!= null">
+						${orderCol.authType}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('sourceType')">
+					a.sourceType
+					<if test="orderCol.sourceType!= null">
+						${orderCol.sourceType}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('createTime')">
+					a.createTime
+					<if test="orderCol.createTime!= null">
+						${orderCol.createTime}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('createUserId')">
+					a.createUserId
+					<if test="orderCol.createUserId!= null">
+						${orderCol.createUserId}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('createUserName')">
+					a.createUserName
+					<if test="orderCol.createUserName!= null">
+						${orderCol.createUserName}
+					</if>
+					,
+				</if>
+				<if test="orderCol.containsKey('userType')">
+					a.userType
+					<if test="orderCol.userType!= null">
+						${orderCol.userType}
+					</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

portal-manager/src/main/resources/sqlmap/base/system/resourceExt.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.base.system.resource.dao.ibatis.ResourceDaoImpl">
+    
+	<!-- 获取列表 -->
+	<select id="getListByUserId" parameterType="paramDto" resultMap="ResourceEntity-Map">
+		select <include refid="_columns"/>
+		from mortals_xhx_resource as a
+	   where a.authType in(0,1,2) or a.id IN
+	   (select resourceId
+		  from mortals_xhx_role_auth as b
+		  left join mortals_xhx_role_user as c
+		 on b.roleId=c.roleId
+		 where c.userId=#{condition.userId})
+	</select>
+
+    <select id="getAllByUserType" parameterType="java.util.HashMap" resultMap="ResourceEntity-Map">
+        select <include refid="_columns"/>
+        from mortals_xhx_resource as a
+        where a.userType=#{userType}
+
+    </select>
+</mapper>
\ No newline at end of file

portal-manager/src/main/resources/sqlmap/module/role/RoleAuthMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"mybatis-3-mapper.dtd">
+        "mybatis-3-mapper.dtd">
 <mapper namespace="com.mortals.xhx.module.role.dao.ibatis.RoleAuthDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="RoleAuthEntity" id="RoleAuthEntity-Map">
-            <id  property="id" column="id" />
-            <result property="roleId" column="roleId" />
-            <result property="menuId" column="menuId" />
-            
+        <id  property="id" column="id" />
+        <result property="roleId" column="roleId" />
+        <result property="menuId" column="menuId" />
+        <result property="resourceId" column="resourceId" />
+        <result property="createTime" column="createTime" />
+        <result property="createUserId" column="createUserId" />
+        <result property="createUserName" column="createUserName" />
+
     </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.roleId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuId') or colPickMode == 1 and data.containsKey('menuId')))">
-                    a.menuId,
-                </if>
+            <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.roleId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuId') or colPickMode == 1 and data.containsKey('menuId')))">
+                a.menuId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceId') or colPickMode == 1 and data.containsKey('resourceId')))">
+                a.resourceId,
+            </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('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
+                a.createUserName,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="RoleAuthEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_role_auth
-        (roleId,menuId)
+        (roleId,menuId,resourceId,createTime,createUserId,createUserName)
         VALUES
-        (#{roleId},#{menuId})
+        (#{roleId},#{menuId},#{resourceId},#{createTime},#{createUserId},#{createUserName})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_role_auth
-        (roleId,menuId)
+        (roleId,menuId,resourceId,createTime,createUserId,createUserName)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.roleId},#{item.menuId})
+            (#{item.roleId},#{item.menuId},#{item.resourceId},#{item.createTime},#{item.createUserId},#{item.createUserName})
         </foreach>
     </insert>
 
@@ -62,6 +78,24 @@
             <if test="(colPickMode==0 and data.containsKey('menuIdIncrement')) or (colPickMode==1 and !data.containsKey('menuIdIncrement'))">
                 a.menuId=ifnull(a.menuId,0) + #{data.menuIdIncrement},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('resourceId')) or (colPickMode==1 and !data.containsKey('resourceId'))">
+                a.resourceId=#{data.resourceId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('resourceIdIncrement')) or (colPickMode==1 and !data.containsKey('resourceIdIncrement'))">
+                a.resourceId=ifnull(a.resourceId,0) + #{data.resourceIdIncrement},
+            </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('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
+                a.createUserName=#{data.createUserName},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -74,30 +108,68 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_xhx_role_auth as a
         <trim prefix="set" suffixOverrides=",">
-                        <trim prefix="roleId=(case" suffix="ELSE roleId 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.roleId,0) + #{item.roleIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="menuId=(case" suffix="ELSE menuId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('menuId')) or (colPickMode==1 and !item.containsKey('menuId'))">
-                                        when a.id=#{item.id} then #{item.menuId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('menuIdIncrement')) or (colPickMode==1 and !item.containsKey('menuIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.menuId,0) + #{item.menuIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
+            <trim prefix="roleId=(case" suffix="ELSE roleId 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.roleId,0) + #{item.roleIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="menuId=(case" suffix="ELSE menuId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('menuId')) or (colPickMode==1 and !item.containsKey('menuId'))">
+                            when a.id=#{item.id} then #{item.menuId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('menuIdIncrement')) or (colPickMode==1 and !item.containsKey('menuIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.menuId,0) + #{item.menuIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="resourceId=(case" suffix="ELSE resourceId 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.resourceId,0) + #{item.resourceIdIncrement}
+                        </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="createUserName=(case" suffix="ELSE createUserName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
+                        when a.id=#{item.id} then #{item.createUserName}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -121,6 +193,21 @@
             #{item}
         </foreach>
     </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_xhx_role_auth where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_xhx_role_auth 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_role_auth as a
@@ -199,99 +286,299 @@
                 ${_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 test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </if>
-            <if test="conditionParamRef.containsKey('idList')">
-                ${_conditionType_} a.id in
-                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </if>
-            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
-                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </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.roleId = #{${_conditionParam_}.roleId}
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            <if test="conditionParamRef.roleId == null">
+                ${_conditionType_} a.roleId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
+            ${_conditionType_} a.roleId 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.roleId 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.roleId <![CDATA[ >= ]]> #{${_conditionParam_}.roleIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('roleIdEnd') and conditionParamRef.roleIdEnd != null">
+            ${_conditionType_} a.roleId <![CDATA[ <= ]]> #{${_conditionParam_}.roleIdEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('roleId')">
-                <if test="conditionParamRef.roleId != null ">
-                    ${_conditionType_} a.roleId = #{${_conditionParam_}.roleId}
-                </if>
-                <if test="conditionParamRef.roleId == null">
-                    ${_conditionType_} a.roleId is null
-                </if>
+        <if test="conditionParamRef.containsKey('menuId')">
+            <if test="conditionParamRef.menuId != null ">
+                ${_conditionType_} a.menuId = #{${_conditionParam_}.menuId}
             </if>
-            <if test="conditionParamRef.containsKey('roleIdList')">
-                ${_conditionType_} a.roleId in
-                <foreach collection="conditionParamRef.roleIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.menuId == null">
+                ${_conditionType_} a.menuId is null
             </if>
-            <if test="conditionParamRef.containsKey('roleIdStart') and conditionParamRef.roleIdStart != null">
-                ${_conditionType_} a.roleId <![CDATA[ >= ]]> #{${_conditionParam_}.roleIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('menuIdList') and conditionParamRef.menuIdList.size() > 0">
+            ${_conditionType_} a.menuId in
+            <foreach collection="conditionParamRef.menuIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('menuIdNotList') and conditionParamRef.menuIdNotList.size() > 0">
+            ${_conditionType_} a.menuId not in
+            <foreach collection="conditionParamRef.menuIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('menuIdStart') and conditionParamRef.menuIdStart != null">
+            ${_conditionType_} a.menuId <![CDATA[ >= ]]> #{${_conditionParam_}.menuIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('menuIdEnd') and conditionParamRef.menuIdEnd != null">
+            ${_conditionType_} a.menuId <![CDATA[ <= ]]> #{${_conditionParam_}.menuIdEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('resourceId')">
+            <if test="conditionParamRef.resourceId != null ">
+                ${_conditionType_} a.resourceId = #{${_conditionParam_}.resourceId}
             </if>
-            <if test="conditionParamRef.containsKey('roleIdEnd') and conditionParamRef.roleIdEnd != null">
-                ${_conditionType_} a.roleId <![CDATA[ <= ]]> #{${_conditionParam_}.roleIdEnd}
+            <if test="conditionParamRef.resourceId == null">
+                ${_conditionType_} a.resourceId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdList') and conditionParamRef.resourceIdList.size() > 0">
+            ${_conditionType_} a.resourceId 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.resourceId 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.resourceId <![CDATA[ >= ]]> #{${_conditionParam_}.resourceIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('resourceIdEnd') and conditionParamRef.resourceIdEnd != null">
+            ${_conditionType_} a.resourceId <![CDATA[ <= ]]> #{${_conditionParam_}.resourceIdEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('menuId')">
-                <if test="conditionParamRef.menuId != null ">
-                    ${_conditionType_} a.menuId = #{${_conditionParam_}.menuId}
-                </if>
-                <if test="conditionParamRef.menuId == null">
-                    ${_conditionType_} a.menuId is null
-                </if>
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('menuIdList')">
-                ${_conditionType_} a.menuId in
-                <foreach collection="conditionParamRef.menuIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('menuIdStart') and conditionParamRef.menuIdStart != null">
-                ${_conditionType_} a.menuId <![CDATA[ >= ]]> #{${_conditionParam_}.menuIdStart}
+        </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.containsKey('menuIdEnd') and conditionParamRef.menuIdEnd != null">
-                ${_conditionType_} a.menuId <![CDATA[ <= ]]> #{${_conditionParam_}.menuIdEnd}
+            <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('createUserName')">
+            <if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
+                ${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
+            </if>
+            <if test="conditionParamRef.createUserName == null">
+                ${_conditionType_} a.createUserName is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserNameList') and conditionParamRef.createUserNameList.size() > 0">
+            ${_conditionType_} a.createUserName in
+            <foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserNameNotList') and conditionParamRef.createUserNameNotList.size() > 0">
+            ${_conditionType_} a.createUserName not in
+            <foreach collection="conditionParamRef.createUserNameNotList" 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('menuIdList') and conditionParamRef.menuIdList.size() > 0">
+                field(a.menuId,
+                <foreach collection="conditionParamRef.menuIdList" 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('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
+            </if>
             <trim suffixOverrides=","  suffix="">
                 <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     ${item.colName} ${item.sortKind}
+                    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('menuIdList') and conditionParamRef.menuIdList.size() > 0">
+                field(a.menuId,
+                <foreach collection="conditionParamRef.menuIdList" 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('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" 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.roleId
-                        <if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('menuId')">
-                        a.menuId
-                        <if test='orderCol.menuId != null and "DESC".equalsIgnoreCase(orderCol.menuId)'>DESC</if>
-                        ,
-                    </if>
+                <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.roleId
+                    <if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('menuId')">
+                    a.menuId
+                    <if test='orderCol.menuId != null and "DESC".equalsIgnoreCase(orderCol.menuId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('resourceId')">
+                    a.resourceId
+                    <if test='orderCol.resourceId != null and "DESC".equalsIgnoreCase(orderCol.resourceId)'>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('createUserName')">
+                    a.createUserName
+                    <if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
+
+
     </sql>
     <sql id="_group_by_">
         <if test="groupList != null and !groupList.isEmpty()">