Commit 2de852e5 authored by 赵啸非's avatar 赵啸非

修改菜单权限模块

parent c7b41b86
...@@ -381,3 +381,138 @@ INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32' ...@@ -381,3 +381,138 @@ INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32'
INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32', '福善镇', 'abe17ba11bbf48568547c21b174c8a32', 'gde17ba11bbf48568547c21b174c8a32', 'True', 'True', 'false', 'false', '511715282000', 4, '福善镇', 'dzsgxjscyy.sczwfw.gov.cn', 1, '2025-03-20 10:20:10', NULL, '2025-03-20 10:20:10'); INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32', '福善镇', 'abe17ba11bbf48568547c21b174c8a32', 'gde17ba11bbf48568547c21b174c8a32', 'True', 'True', 'false', 'false', '511715282000', 4, '福善镇', 'dzsgxjscyy.sczwfw.gov.cn', 1, '2025-03-20 10:20:10', NULL, '2025-03-20 10:20:10');
INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32', '安仁乡', 'abf17ba11bbf48568547c21b174c8a32', 'gde17ba11bbf48568547c21b174c8a32', 'True', 'True', 'false', 'false', '511715414000', 4, '安仁乡', 'dzsgxjscyy.sczwfw.gov.cn', 1, '2025-03-20 10:20:10', NULL, '2025-03-20 10:20:10'); INSERT INTO `mortals_sys_area` VALUES (null, ',gde17ba11bbf48568547c21b174c8a32', '安仁乡', 'abf17ba11bbf48568547c21b174c8a32', 'gde17ba11bbf48568547c21b174c8a32', 'True', 'True', 'false', 'false', '511715414000', 4, '安仁乡', 'dzsgxjscyy.sczwfw.gov.cn', 1, '2025-03-20 10:20:10', NULL, '2025-03-20 10:20:10');
-- ----------------------------
-- 角色权限改造 2025-04-23
-- ----------------------------
-- ----------------------------
-- 资源信息业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_resource`;
CREATE TABLE mortals_xhx_resource(
`id` bigint(20) AUTO_INCREMENT COMMENT '菜单ID,主键,自增长',
`name` varchar(50) COMMENT '名称',
`groupName` varchar(255) COMMENT '分组名称',
`url` varchar(2000) COMMENT '连接地址,多个地址以逗号分隔',
`authType` tinyint(2) DEFAULT '3' COMMENT '权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)',
`sourceType` tinyint(2) DEFAULT '0' COMMENT '资源类型,(0.系统资源,1.开放资源)',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`),
INDEX `idx_name`(`name`) USING BTREE,
INDEX `idx_groupName`(`groupName`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='资源信息业务';
-- ----------------------------
-- 角色信息业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_role`;
CREATE TABLE mortals_xhx_role(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号,主键,自增长',
`name` varchar(50) COMMENT '角色名称',
`remark` varchar(200) COMMENT '备注',
`roleType` tinyint(2) DEFAULT '2' COMMENT '角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)',
`customerId` bigint(20) COMMENT '归属客户ID',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`),
INDEX `idx_name`(`name`) USING BTREE,
INDEX `idx_roleType`(`roleType`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色信息业务';
-- ----------------------------
-- 角色资源权限业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_role_auth`;
CREATE TABLE mortals_xhx_role_auth(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号,主键,自增长',
`roleId` bigint(20) COMMENT '角色ID',
`menuId` bigint(20) COMMENT '菜单ID',
`resourceId` bigint(20) COMMENT '资源ID',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`),
INDEX `idx_roleId`(`roleId`) USING BTREE,
INDEX `idx_menuId`(`menuId`) USING BTREE,
INDEX `resourceId` (`resourceId`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色资源权限业务';
-- ----------------------------
-- 角色用户业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_role_user`;
CREATE TABLE mortals_xhx_role_user(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号,主键,自增长',
`roleId` bigint(20) COMMENT '角色ID',
`userId` bigint(20) COMMENT '用户ID',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`),
INDEX `idx_roleId`(`roleId`) USING BTREE,
INDEX `idx_userId`(`userId`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色用户业务';
DROP TABLE IF EXISTS `mortals_xhx_menu`;
CREATE TABLE mortals_xhx_menu(
`id` bigint(20) AUTO_INCREMENT COMMENT '菜单ID,主键,自增长',
`name` varchar(50) COMMENT '菜单名称',
`url` varchar(256) COMMENT '路由地址',
`ancestors` varchar(255) COMMENT '当前节点父id路径,“,”分割',
`parentId` bigint(20) COMMENT '父菜单ID,一级菜单的该字段值为-1',
`linkType` tinyint(2) DEFAULT '0' COMMENT '链接方式 (0.普通,1.弹出,2.脚本)',
`imgPath` varchar(128) COMMENT '主菜单图标,主菜单图标的css样式名',
`buttonImgPath` varchar(128) COMMENT '按钮图标,按钮图标的css样式名',
`imgCommPath` varchar(128) COMMENT '常用菜单图标,常用菜单图标的css样式名',
`commMenu` tinyint(2) DEFAULT '1' COMMENT '是否常用菜单 (0.非常用,1.常用)',
`component` varchar(128) COMMENT 'vue组件路径',
`menuType` tinyint(2) DEFAULT '0' COMMENT '菜单类型 (0.目录,1.菜单,2.按钮)',
`authType` tinyint(2) DEFAULT '3' COMMENT '权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)',
`visible` tinyint(2) DEFAULT '0' COMMENT '菜单显示状态 (0.显示,1.隐藏)',
`perms` varchar(128) COMMENT '权限标识,多个逗号分割',
`orderId` int(4) COMMENT '排序编号',
`status` tinyint(2) DEFAULT '1' COMMENT '菜单状态 (0.停用,1.启用)',
`cache` tinyint(2) DEFAULT '0' COMMENT '是否启用缓存 (0.否,1.是)',
`activeDir` varchar(128) COMMENT '激活目录',
`resourceUrl` varchar(512) COMMENT '资源访问路径,多个逗号分割',
`hideChildrenInMenu` tinyint(2) DEFAULT '0' COMMENT '是否隐藏(0.否,1.是)',
`remark` varchar(512) COMMENT '备注信息',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`),
INDEX `idx_name`(`name`) USING BTREE,
INDEX `idx_url`(`url`) USING BTREE,
INDEX `idx_parentId`(`parentId`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='菜单信息业务';
ALTER TABLE mortals_xhx_param ADD COLUMN `updateUserId` bigint(20) COMMENT '更新用户';
ALTER TABLE mortals_xhx_param ADD COLUMN `updateUserName` varchar(50) COMMENT '创建用户名称';
ALTER TABLE mortals_xhx_param ADD COLUMN `updateTime` datetime COMMENT '更新时间';
\ No newline at end of file
...@@ -246,6 +246,10 @@ ...@@ -246,6 +246,10 @@
<groupId>org.springframework</groupId> <groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId> <artifactId>spring-context</artifactId>
</dependency> </dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<!-- Spring Boot Data Elasticsearch依赖 --> <!-- Spring Boot Data Elasticsearch依赖 -->
......
...@@ -3,7 +3,6 @@ package com.mortals.xhx.base.system.idgenerator.dao.ibatis; ...@@ -3,7 +3,6 @@ package com.mortals.xhx.base.system.idgenerator.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.idgenerator.dao.IdgeneratorDao; import com.mortals.xhx.base.system.idgenerator.dao.IdgeneratorDao;
import com.mortals.xhx.base.system.idgenerator.model.IdgeneratorEntity; import com.mortals.xhx.base.system.idgenerator.model.IdgeneratorEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
package com.mortals.xhx.base.system.idgenerator.service; package com.mortals.xhx.base.system.idgenerator.service;
import java.util.List;
import com.mortals.xhx.base.system.idgenerator.service.impl.IdgeneratorServiceImpl.IdGeneratorKey; import com.mortals.xhx.base.system.idgenerator.service.impl.IdgeneratorServiceImpl.IdGeneratorKey;
import java.util.List;
/** /**
* <p>Title: id生成器</p> * <p>Title: id生成器</p>
* <p>Description: IdgeneratorService service接口 </p> * <p>Description: IdgeneratorService service接口 </p>
......
package com.mortals.xhx.base.system.idgenerator.service.impl; package com.mortals.xhx.base.system.idgenerator.service.impl;
import cn.hutool.Hutool;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.mortals.xhx.base.system.idgenerator.dao.IdgeneratorDao; import com.mortals.xhx.base.system.idgenerator.dao.IdgeneratorDao;
import com.mortals.xhx.base.system.idgenerator.model.IdgeneratorEntity; import com.mortals.xhx.base.system.idgenerator.model.IdgeneratorEntity;
import com.mortals.xhx.base.system.idgenerator.service.IdgeneratorService; import com.mortals.xhx.base.system.idgenerator.service.IdgeneratorService;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
...@@ -69,8 +67,6 @@ public class IdgeneratorServiceImpl implements IdgeneratorService { ...@@ -69,8 +67,6 @@ public class IdgeneratorServiceImpl implements IdgeneratorService {
private final Class[] factorsClazz; private final Class[] factorsClazz;
private IdGeneratorKey(Long step, String methodName, Class[] factorsClazz) { private IdGeneratorKey(Long step, String methodName, Class[] factorsClazz) {
this.step = step; this.step = step;
this.methodName = methodName; this.methodName = methodName;
this.factorsClazz = factorsClazz; this.factorsClazz = factorsClazz;
......
...@@ -12,6 +12,8 @@ package com.mortals.xhx.base.system.menu.dao; ...@@ -12,6 +12,8 @@ package com.mortals.xhx.base.system.menu.dao;
import com.mortals.framework.dao.ICRUDDao; import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import java.util.List;
/** /**
* <p>Title: 菜单信息</p> * <p>Title: 菜单信息</p>
* <p>Description: MenuDao DAO接口 </p> * <p>Description: MenuDao DAO接口 </p>
...@@ -22,5 +24,14 @@ import com.mortals.xhx.base.system.menu.model.MenuEntity; ...@@ -22,5 +24,14 @@ import com.mortals.xhx.base.system.menu.model.MenuEntity;
*/ */
public interface MenuDao extends ICRUDDao<MenuEntity,Long> { public interface MenuDao extends ICRUDDao<MenuEntity,Long> {
List<MenuEntity> getListByUserId(Long userId);
/**
* 查询子节点
*
* @param
* @return
*/
List<MenuEntity> selectChildrenMenuById(String menuId);
} }
\ No newline at end of file
...@@ -9,11 +9,13 @@ ...@@ -9,11 +9,13 @@
package com.mortals.xhx.base.system.menu.dao.ibatis; package com.mortals.xhx.base.system.menu.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.framework.model.ParamDto;
import com.mortals.xhx.base.system.menu.dao.MenuDao; import com.mortals.xhx.base.system.menu.dao.MenuDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
import java.util.List;
/** /**
* <p>Title: 菜单信息</p> * <p>Title: 菜单信息</p>
* <p>Description: MenuDaoImpl DAO接口 </p> * <p>Description: MenuDaoImpl DAO接口 </p>
...@@ -25,4 +27,16 @@ import org.springframework.stereotype.Repository; ...@@ -25,4 +27,16 @@ import org.springframework.stereotype.Repository;
@Repository("menuDao") @Repository("menuDao")
public class MenuDaoImpl extends BaseCRUDDaoMybatis<MenuEntity,Long> implements MenuDao { public class MenuDaoImpl extends BaseCRUDDaoMybatis<MenuEntity,Long> implements MenuDao {
@Override
public List<MenuEntity> selectChildrenMenuById(String menuId) {
return getSqlSession().selectList(getSqlId("selectChildrenMenuById"), menuId);
}
@Override
public List<MenuEntity> getListByUserId(Long userId) {
ParamDto param = new ParamDto();
param.getCondition().put("userId", userId);
return getSqlSession().selectList(getSqlId("getListByUserId"), param);
}
} }
\ No newline at end of file
/**
* 文件:MenuEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model; package com.mortals.xhx.base.system.menu.model;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
import java.util.ArrayList; import lombok.Data;
import java.util.Date;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
/** /**
* <p>Title: 菜单信息</p> * 菜单信息业务实体对象
* <p>Description: MenuEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-12-06
* @author
* @version 1.0.0
*/ */
public class MenuEntity extends BaseEntityLong{ @Data
private static final long serialVersionUID = 1547777703328L; public class MenuEntity extends MenuVo {
private static final long serialVersionUID = 1L;
/** 菜单名称 */
private String name; /**
* 菜单名称
/** 连接地址 */ */
private String url; private String name;
/**
/** 父菜单ID,一级菜单的该字段值为-1 */ * 路由地址
private Long parentId; */
private String url;
/** 排序编号 */ /**
private Integer orderId; * 当前节点父id路径,“,”分割
*/
/** 菜单状态,0:禁用,1:启用,默认1 */ private String ancestors;
private Integer status; /**
* 父菜单ID,一级菜单的该字段值为-1
/** 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0 */ */
private Integer linkType; private Long parentId;
/**
/** 分组编号,使用菜单分隔符按该值分隔,默认1 */ * 链接方式 (0.普通,1.弹出,2.脚本)
private Integer groupId; */
private Integer linkType;
/** 分组名称 */ /**
private Integer groupName; * 主菜单图标,主菜单图标的css样式名
*/
/** 主菜单图标,主菜单图标的css样式名 */ private String imgPath;
private String imgPath; /**
* 按钮图标,按钮图标的css样式名
/** 按钮图标,按钮图标的css样式名 */ */
private String buttonImgPath; private String buttonImgPath;
/**
/** 常用菜单图标,常用菜单图标的css样式名 */ * 常用菜单图标,常用菜单图标的css样式名
private String imgCommPath; */
private String imgCommPath;
/** 是否常用菜单,0:非常用,1:常用,默认0 */ /**
private Integer commMenu; * 是否常用菜单 (0.非常用,1.常用)
*/
/** 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0 */ private Integer commMenu;
private Integer menuType; /**
* vue组件路径
/** 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ */
private Integer authType; private String component;
/**
/** 创建时间 */ * 菜单类型 (0.目录,1.菜单,2.按钮)
private Date createTime; */
private Integer menuType;
/** 创建用户 */ /**
private String createUser; * 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
*/
/** 创建用户名称 */ private Integer authType;
private String createUserName; /**
* 菜单显示状态 (0.显示,1.隐藏)
private List<MenuEntity> childList = new ArrayList<MenuEntity>(); */
private Integer visible;
/**
public MenuEntity() { * 权限标识,多个逗号分割
*/
} private String perms;
/**
/** * 备注信息
* 获取 菜单名称 */
* @return name private String remark;
*/ /**
public String getName() { * 排序编号
return this.name; */
} private Integer orderId;
/**
/** * 菜单状态 (0.停用,1.启用)
* 设置 菜单名称 */
* @param name private Integer status;
*/ /**
public void setName(String name) { * 创建用户名称
this.name = name; */
} private String createUserName;
/**
/** * 创建用户名称
* 获取 连接地址 */
* @return url private String updateUserName;
*/ /**
public String getUrl() { * 是否启用缓存 (0.否,1.是)
return this.url; */
} private Integer cache;
/**
/** * 激活目录
* 设置 连接地址 */
* @param url private String activeDir;
*/ /**
public void setUrl(String url) { * 是否隐藏(0.否,1.是)
this.url = url; */
} private Integer hideChildrenInMenu;
/**
/** * 资源访问路径,多个逗号分割
* 获取 父菜单ID,一级菜单的该字段值为-1 */
* @return parentId private String resourceUrl;
*/ @Override
public Long getParentId() { public int hashCode() {
return this.parentId; return this.getId().hashCode();
} }
@Override
/** public boolean equals(Object obj) {
* 设置 父菜单ID,一级菜单的该字段值为-1 if (obj == null) return false;
* @param parentId if (obj instanceof MenuEntity) {
*/ MenuEntity tmp = (MenuEntity) obj;
public void setParentId(Long parentId) { if (this.getId() == tmp.getId()) {
this.parentId = parentId; return true;
} }
}
/** return false;
* 获取 排序编号 }
* @return orderId
*/ public void initAttrValue(){
public Integer getOrderId() { this.name = "";
return this.orderId; this.url = "";
} this.ancestors = "";
this.parentId = null;
/** this.linkType = 0;
* 设置 排序编号 this.imgPath = "";
* @param orderId this.buttonImgPath = "";
*/ this.imgCommPath = "";
public void setOrderId(Integer orderId) { this.commMenu = 1;
this.orderId = orderId; this.component = "";
} this.menuType = 0;
this.authType = 3;
/** this.visible = 0;
* 获取 菜单状态,0:禁用,1:启用,默认1 this.perms = "";
* @return status this.remark = "";
*/ this.orderId = 0;
public Integer getStatus() { this.status = 1;
return this.status; this.createUserName = "";
} this.updateUserName = "";
this.cache = 0;
/** this.activeDir = "";
* 设置 菜单状态,0:禁用,1:启用,默认1 this.hideChildrenInMenu = 0;
* @param status this.resourceUrl = "";
*/ }
public void setStatus(Integer status) {
this.status = status;
}
/**
* 获取 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @return linkType
*/
public Integer getLinkType() {
return this.linkType;
}
/**
* 设置 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @param linkType
*/
public void setLinkType(Integer linkType) {
this.linkType = linkType;
}
/**
* 获取 分组编号,使用菜单分隔符按该值分隔,默认1
* @return groupId
*/
public Integer getGroupId() {
return this.groupId;
}
/**
* 设置 分组编号,使用菜单分隔符按该值分隔,默认1
* @param groupId
*/
public void setGroupId(Integer groupId) {
this.groupId = groupId;
}
public Integer getGroupName() {
return groupName;
}
public void setGroupName(Integer groupName) {
this.groupName = groupName;
}
/**
* 获取 主菜单图标,主菜单图标的css样式名
* @return imgPath
*/
public String getImgPath() {
return this.imgPath;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPath
*/
public void setImgPath(String imgPath) {
this.imgPath = imgPath;
}
/**
* 获取 按钮图标,按钮图标的css样式名
* @return buttonImgPath
*/
public String getButtonImgPath() {
return this.buttonImgPath;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPath
*/
public void setButtonImgPath(String buttonImgPath) {
this.buttonImgPath = buttonImgPath;
}
/**
* 获取 常用菜单图标,常用菜单图标的css样式名
* @return imgCommPath
*/
public String getImgCommPath() {
return this.imgCommPath;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPath
*/
public void setImgCommPath(String imgCommPath) {
this.imgCommPath = imgCommPath;
}
/**
* 获取 是否常用菜单,0:非常用,1:常用,默认0
* @return commMenu
*/
public Integer getCommMenu() {
return this.commMenu;
}
/**
* 设置 是否常用菜单,0:非常用,1:常用,默认0
* @param commMenu
*/
public void setCommMenu(Integer commMenu) {
this.commMenu = commMenu;
}
/**
* 获取 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @return menuType
*/
public Integer getMenuType() {
return this.menuType;
}
/**
* 设置 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @param menuType
*/
public void setMenuType(Integer menuType) {
this.menuType = menuType;
}
/**
* 获取 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authType
*/
public Integer getAuthType() {
return this.authType;
}
/**
* 设置 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authType
*/
public void setAuthType(Integer authType) {
this.authType = authType;
}
/**
* 获取 创建时间
* @return createTime
*/
@Override
public Date getCreateTime() {
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
@Override
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 获取 创建用户
* @return createUser
*/
@Override
public String getCreateUser() {
return this.createUser;
}
/**
* 设置 创建用户
* @param createUser
*/
@Override
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
@Override
public String getCreateUserName() {
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
@Override
public void setCreateUserName(String createUserName) {
this.createUserName = createUserName;
}
public List<MenuEntity> getChildList() {
return childList;
}
public void setChildList(List<MenuEntity> childList) {
this.childList = childList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",url:").append(getUrl())
.append(",parentId:").append(getParentId())
.append(",orderId:").append(getOrderId())
.append(",status:").append(getStatus())
.append(",linkType:").append(getLinkType())
.append(",groupId:").append(getGroupId())
.append(",groupName:").append(getGroupName())
.append(",imgPath:").append(getImgPath())
.append(",buttonImgPath:").append(getButtonImgPath())
.append(",imgCommPath:").append(getImgCommPath())
.append(",commMenu:").append(getCommMenu())
.append(",menuType:").append(getMenuType())
.append(",authType:").append(getAuthType())
.append(",createTime:").append(getCreateTime())
.append(",createUser:").append(getCreateUser())
.append(",createUserName:").append(getCreateUserName());
return sb.toString();
}
@Override
public void initAttrValue() {
this.name = null;
this.url = null;
this.parentId = null;
this.orderId = null;
this.status = 1;
this.linkType = 0;
this.groupId = 1;
this.imgPath = null;
this.buttonImgPath = null;
this.imgCommPath = null;
this.commMenu = 0;
this.menuType = 0;
this.authType = 3;
this.createTime = null;
this.createUser = null;
this.createUserName = null;
}
} }
\ No newline at end of file
/**
* 文件:MenuQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model; package com.mortals.xhx.base.system.menu.model;
import java.util.List; import java.util.List;
/** /**
* <p>Title: 菜单信息</p> * 菜单信息业务查询对象
* <p>Description: MenuQuery </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-12-06
* @author
* @version 1.0.0
*/ */
public class MenuQuery extends MenuEntity{ public class MenuQuery extends MenuEntity {
private static final long serialVersionUID = 1547777703329L; /** 开始 菜单ID,主键,自增长 */
/** 开始 菜单ID,主键,自增长 */ private Long idStart;
private Long idStart;
/** 结束 菜单ID,主键,自增长 */
private Long idEnd;
/** 增加 菜单ID,主键,自增长 */
private Long idIncrement;
/** 菜单ID,主键,自增长列表 */
private List <Long> idList;
/** 菜单ID,主键,自增长排除列表 */
private List <Long> idNotList;
/** 菜单名称 */
private List<String> nameList;
/** 菜单名称排除列表 */
private List <String> nameNotList;
/** 路由地址 */
private List<String> urlList;
/** 路由地址排除列表 */
private List <String> urlNotList;
/** 当前节点父id路径,“,”分割 */
private List<String> ancestorsList;
/** 当前节点父id路径,“,”分割排除列表 */
private List <String> ancestorsNotList;
/** 开始 父菜单ID,一级菜单的该字段值为-1 */
private Long parentIdStart;
/** 结束 父菜单ID,一级菜单的该字段值为-1 */
private Long parentIdEnd;
/** 增加 父菜单ID,一级菜单的该字段值为-1 */
private Long parentIdIncrement;
/** 父菜单ID,一级菜单的该字段值为-1列表 */
private List <Long> parentIdList;
/** 父菜单ID,一级菜单的该字段值为-1排除列表 */
private List <Long> parentIdNotList;
/** 开始 链接方式 (0.普通,1.弹出,2.脚本) */
private Integer linkTypeStart;
/** 结束 链接方式 (0.普通,1.弹出,2.脚本) */
private Integer linkTypeEnd;
/** 增加 链接方式 (0.普通,1.弹出,2.脚本) */
private Integer linkTypeIncrement;
/** 链接方式 (0.普通,1.弹出,2.脚本)列表 */
private List <Integer> linkTypeList;
/** 链接方式 (0.普通,1.弹出,2.脚本)排除列表 */
private List <Integer> linkTypeNotList;
/** 主菜单图标,主菜单图标的css样式名 */
private List<String> imgPathList;
/** 主菜单图标,主菜单图标的css样式名排除列表 */
private List <String> imgPathNotList;
/** 按钮图标,按钮图标的css样式名 */
private List<String> buttonImgPathList;
/** 按钮图标,按钮图标的css样式名排除列表 */
private List <String> buttonImgPathNotList;
/** 常用菜单图标,常用菜单图标的css样式名 */
private List<String> imgCommPathList;
/** 常用菜单图标,常用菜单图标的css样式名排除列表 */
private List <String> imgCommPathNotList;
/** 开始 是否常用菜单 (0.非常用,1.常用) */
private Integer commMenuStart;
/** 结束 是否常用菜单 (0.非常用,1.常用) */
private Integer commMenuEnd;
/** 增加 是否常用菜单 (0.非常用,1.常用) */
private Integer commMenuIncrement;
/** 是否常用菜单 (0.非常用,1.常用)列表 */
private List <Integer> commMenuList;
/** 是否常用菜单 (0.非常用,1.常用)排除列表 */
private List <Integer> commMenuNotList;
/** vue组件路径 */
private List<String> componentList;
/** vue组件路径排除列表 */
private List <String> componentNotList;
/** 开始 菜单类型 (0.目录,1.菜单,2.按钮) */
private Integer menuTypeStart;
/** 结束 菜单类型 (0.目录,1.菜单,2.按钮) */
private Integer menuTypeEnd;
/** 增加 菜单类型 (0.目录,1.菜单,2.按钮) */
private Integer menuTypeIncrement;
/** 菜单类型 (0.目录,1.菜单,2.按钮)列表 */
private List <Integer> menuTypeList;
/** 结束 菜单ID,主键,自增长 */ /** 菜单类型 (0.目录,1.菜单,2.按钮)排除列表 */
private Long idEnd; private List <Integer> menuTypeNotList;
/** 增加 菜单ID,主键,自增长 */ /** 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private Long idIncrement; private Integer authTypeStart;
/** 菜单ID,主键,自增长 */ /** 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private List<Long> idList; private Integer authTypeEnd;
/** 菜单名称 */ /** 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private List<String> nameList; private Integer authTypeIncrement;
/** 连接地址 */ /** 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)列表 */
private List<String> urlList; private List <Integer> authTypeList;
/** 开始 父菜单ID,一级菜单的该字段值为-1 */ /** 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)排除列表 */
private Long parentIdStart; private List <Integer> authTypeNotList;
/** 结束 父菜单ID,一级菜单的该字段值为-1 */ /** 开始 菜单显示状态 (0.显示,1.隐藏) */
private Long parentIdEnd; private Integer visibleStart;
/** 增加 父菜单ID,一级菜单的该字段值为-1 */ /** 结束 菜单显示状态 (0.显示,1.隐藏) */
private Long parentIdIncrement; private Integer visibleEnd;
/** 父菜单ID,一级菜单的该字段值为-1 */ /** 增加 菜单显示状态 (0.显示,1.隐藏) */
private List<Long> parentIdList; private Integer visibleIncrement;
/** 开始 排序编号 */ /** 菜单显示状态 (0.显示,1.隐藏)列表 */
private Integer orderIdStart; private List <Integer> visibleList;
/** 结束 排序编号 */ /** 菜单显示状态 (0.显示,1.隐藏)排除列表 */
private Integer orderIdEnd; private List <Integer> visibleNotList;
/** 增加 排序编号 */ /** 权限标识,多个逗号分割 */
private Integer orderIdIncrement; private List<String> permsList;
/** 排序编号 */ /** 权限标识,多个逗号分割排除列表 */
private List<Integer> orderIdList; private List <String> permsNotList;
/** 备注信息 */
private List<String> remarkList;
/** 开始 菜单状态,0:禁用,1:启用,默认1 */ /** 备注信息排除列表 */
private Integer statusStart; private List <String> remarkNotList;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 结束 菜单状态,0:禁用,1:启用,默认1 */ /** 结束 排序编号 */
private Integer statusEnd; private Integer orderIdEnd;
/** 增加 菜单状态,0:禁用,1:启用,默认1 */ /** 增加 排序编号 */
private Integer statusIncrement; private Integer orderIdIncrement;
/** 菜单状态,0:禁用,1:启用,默认1 */ /** 排序编号列表 */
private List<Integer> statusList; private List <Integer> orderIdList;
/** 开始 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0 */ /** 排序编号排除列表 */
private Integer linkTypeStart; private List <Integer> orderIdNotList;
/** 结束 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0 */ /** 开始 菜单状态 (0.停用,1.启用) */
private Integer linkTypeEnd; private Integer statusStart;
/** 增加 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0 */ /** 结束 菜单状态 (0.停用,1.启用) */
private Integer linkTypeIncrement; private Integer statusEnd;
/** 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0 */ /** 增加 菜单状态 (0.停用,1.启用) */
private List<Integer> linkTypeList; private Integer statusIncrement;
/** 开始 分组编号,使用菜单分隔符按该值分隔,默认1 */ /** 菜单状态 (0.停用,1.启用)列表 */
private Integer groupIdStart; private List <Integer> statusList;
/** 结束 分组编号,使用菜单分隔符按该值分隔,默认1 */ /** 菜单状态 (0.停用,1.启用)排除列表 */
private Integer groupIdEnd; private List <Integer> statusNotList;
/** 增加 分组编号,使用菜单分隔符按该值分隔,默认1 */ /** 开始 创建时间 */
private Integer groupIdIncrement; private String createTimeStart;
/** 分组编号,使用菜单分隔符按该值分隔,默认1 */ /** 结束 创建时间 */
private List<Integer> groupIdList; private String createTimeEnd;
/** 分组名称 */ /** 开始 创建用户 */
private List<String> groupNameList; private Long createUserIdStart;
/** 主菜单图标,主菜单图标的css样式名 */ /** 结束 创建用户 */
private List<String> imgPathList; private Long createUserIdEnd;
/** 按钮图标,按钮图标的css样式名 */ /** 增加 创建用户 */
private List<String> buttonImgPathList; private Long createUserIdIncrement;
/** 常用菜单图标,常用菜单图标的css样式名 */ /** 创建用户列表 */
private List<String> imgCommPathList; private List <Long> createUserIdList;
/** 开始 是否常用菜单,0:非常用,1:常用,默认0 */ /** 创建用户排除列表 */
private Integer commMenuStart; private List <Long> createUserIdNotList;
/** 结束 是否常用菜单,0:非常用,1:常用,默认0 */ /** 创建用户名称 */
private Integer commMenuEnd; private List<String> createUserNameList;
/** 增加 是否常用菜单,0:非常用,1:常用,默认0 */ /** 创建用户名称排除列表 */
private Integer commMenuIncrement; private List <String> createUserNameNotList;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 是否常用菜单,0:非常用,1:常用,默认0 */ /** 结束 更新用户 */
private List<Integer> commMenuList; private Long updateUserIdEnd;
/** 开始 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0 */ /** 增加 更新用户 */
private Integer menuTypeStart; private Long updateUserIdIncrement;
/** 结束 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0 */ /** 更新用户列表 */
private Integer menuTypeEnd; private List <Long> updateUserIdList;
/** 增加 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0 */ /** 更新用户排除列表 */
private Integer menuTypeIncrement; private List <Long> updateUserIdNotList;
/** 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0 */ /** 创建用户名称 */
private List<Integer> menuTypeList; private List<String> updateUserNameList;
/** 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 创建用户名称排除列表 */
private Integer authTypeStart; private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 结束 更新时间 */
private Integer authTypeEnd; private String updateTimeEnd;
/** 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 开始 是否启用缓存 (0.否,1.是) */
private Integer authTypeIncrement; private Integer cacheStart;
/** 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 结束 是否启用缓存 (0.否,1.是) */
private List<Integer> authTypeList; private Integer cacheEnd;
/** 开始 创建时间 */ /** 增加 是否启用缓存 (0.否,1.是) */
private String createTimeStart; private Integer cacheIncrement;
/** 结束 创建时间 */ /** 是否启用缓存 (0.否,1.是)列表 */
private String createTimeEnd; private List <Integer> cacheList;
/** 开始 创建用户 */ /** 是否启用缓存 (0.否,1.是)排除列表 */
private Long createUserIdStart; private List <Integer> cacheNotList;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户 */
private List<Long> createUserIdList;
/** 创建用户名称 */
private List<String> createUserNameList;
public MenuQuery(){
}
/**
* 获取 开始 菜单ID,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 菜单ID,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 菜单ID,主键,自增长
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 菜单ID,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 菜单ID,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 菜单ID,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 菜单ID,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 菜单ID,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 菜单名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 菜单名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 连接地址
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 连接地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 开始 父菜单ID,一级菜单的该字段值为-1
* @return parentIdStart
*/
public Long getParentIdStart(){
return this.parentIdStart;
}
/**
* 设置 开始 父菜单ID,一级菜单的该字段值为-1
* @param parentIdStart
*/
public void setParentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
}
/**
* 获取 结束 父菜单ID,一级菜单的该字段值为-1
* @return parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
}
/**
* 设置 结束 父菜单ID,一级菜单的该字段值为-1
* @param parentIdEnd
*/
public void setParentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
}
/**
* 获取 增加 父菜单ID,一级菜单的该字段值为-1
* @return parentIdIncrement
*/
public Long getParentIdIncrement(){
return this.parentIdIncrement;
}
/**
* 设置 增加 父菜单ID,一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public void setParentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
}
/**
* 获取 父菜单ID,一级菜单的该字段值为-1
* @return parentIdList
*/
public List<Long> getParentIdList(){
return this.parentIdList;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentIdList
*/
public void setParentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 开始 菜单状态,0:禁用,1:启用,默认1
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态,0:禁用,1:启用,默认1
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态,0:禁用,1:启用,默认1
* @return statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态,0:禁用,1:启用,默认1
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态,0:禁用,1:启用,默认1
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态,0:禁用,1:启用,默认1
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态,0:禁用,1:启用,默认1
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态,0:禁用,1:启用,默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 开始 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
return this.linkTypeStart;
}
/**
* 设置 开始 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
}
/**
* 获取 结束 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @return linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
}
/**
* 获取 增加 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
return this.linkTypeIncrement;
}
/**
* 设置 增加 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
}
/**
* 获取 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
return this.linkTypeList;
}
/**
* 设置 链接方式,0:普通,1:弹出,2:脚本(JavaScript),默认0
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
}
/**
* 获取 开始 分组编号,使用菜单分隔符按该值分隔,默认1
* @return groupIdStart
*/
public Integer getGroupIdStart(){
return this.groupIdStart;
}
/**
* 设置 开始 分组编号,使用菜单分隔符按该值分隔,默认1
* @param groupIdStart
*/
public void setGroupIdStart(Integer groupIdStart){
this.groupIdStart = groupIdStart;
}
/**
* 获取 结束 分组编号,使用菜单分隔符按该值分隔,默认1
* @return groupIdEnd
*/
public Integer getGroupIdEnd(){
return this.groupIdEnd;
}
/**
* 设置 结束 分组编号,使用菜单分隔符按该值分隔,默认1
* @param groupIdEnd
*/
public void setGroupIdEnd(Integer groupIdEnd){
this.groupIdEnd = groupIdEnd;
}
/**
* 获取 增加 分组编号,使用菜单分隔符按该值分隔,默认1
* @return groupIdIncrement
*/
public Integer getGroupIdIncrement(){
return this.groupIdIncrement;
}
/**
* 设置 增加 分组编号,使用菜单分隔符按该值分隔,默认1
* @param groupIdIncrement
*/
public void setGroupIdIncrement(Integer groupIdIncrement){
this.groupIdIncrement = groupIdIncrement;
}
/**
* 获取 分组编号,使用菜单分隔符按该值分隔,默认1
* @return groupIdList
*/
public List<Integer> getGroupIdList(){
return this.groupIdList;
}
/**
* 设置 分组编号,使用菜单分隔符按该值分隔,默认1
* @param groupIdList
*/
public void setGroupIdList(List<Integer> groupIdList){
this.groupIdList = groupIdList;
}
/**
* 获取 分组名称
* @return groupNameList
*/
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取 主菜单图标,主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 按钮图标,按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 常用菜单图标,常用菜单图标的css样式名
* @return imgCommPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 开始 是否常用菜单,0:非常用,1:常用,默认0
* @return commMenuStart
*/
public Integer getCommMenuStart(){
return this.commMenuStart;
}
/**
* 设置 开始 是否常用菜单,0:非常用,1:常用,默认0
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
}
/**
* 获取 结束 是否常用菜单,0:非常用,1:常用,默认0
* @return commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单,0:非常用,1:常用,默认0
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
}
/**
* 获取 增加 是否常用菜单,0:非常用,1:常用,默认0
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
return this.commMenuIncrement;
}
/**
* 设置 增加 是否常用菜单,0:非常用,1:常用,默认0
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
}
/**
* 获取 是否常用菜单,0:非常用,1:常用,默认0
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
return this.commMenuList;
}
/**
* 设置 是否常用菜单,0:非常用,1:常用,默认0
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
}
/**
* 获取 开始 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
return this.menuTypeStart;
}
/**
* 设置 开始 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
}
/**
* 获取 结束 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @return menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
}
/**
* 获取 增加 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
return this.menuTypeIncrement;
}
/**
* 设置 增加 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
}
/**
* 获取 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
return this.menuTypeList;
}
/**
* 设置 菜单类型,0:主菜单,1:非主菜单(功能操作组),默认0
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
}
/**
* 获取 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 开始 创建时间
* @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 createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/** 激活目录 */
private List<String> activeDirList;
/** 激活目录排除列表 */
private List <String> activeDirNotList;
/** 开始 是否隐藏(0.否,1.是) */
private Integer hideChildrenInMenuStart;
/** 结束 是否隐藏(0.否,1.是) */
private Integer hideChildrenInMenuEnd;
/** 增加 是否隐藏(0.否,1.是) */
private Integer hideChildrenInMenuIncrement;
/** 是否隐藏(0.否,1.是)列表 */
private List <Integer> hideChildrenInMenuList;
/** 是否隐藏(0.否,1.是)排除列表 */
private List <Integer> hideChildrenInMenuNotList;
/** 资源访问路径,多个逗号分割 */
private List<String> resourceUrlList;
/** 资源访问路径,多个逗号分割排除列表 */
private List <String> resourceUrlNotList;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MenuQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MenuQuery> andConditionList;
public MenuQuery(){}
/**
* 获取 开始 菜单ID,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 菜单ID,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 菜单ID,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 菜单ID,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 菜单ID,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 菜单ID,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 菜单ID,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 菜单ID,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 菜单ID,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 菜单ID,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 菜单名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 菜单名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 菜单名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 菜单名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 路由地址
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 路由地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 路由地址
* @return urlNotList
*/
public List<String> getUrlNotList(){
return this.urlNotList;
}
/**
* 设置 路由地址
* @param urlNotList
*/
public void setUrlNotList(List<String> urlNotList){
this.urlNotList = urlNotList;
}
/**
* 获取 当前节点父id路径,“,”分割
* @return ancestorsList
*/
public List<String> getAncestorsList(){
return this.ancestorsList;
}
/**
* 设置 当前节点父id路径,“,”分割
* @param ancestorsList
*/
public void setAncestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
}
/**
* 获取 当前节点父id路径,“,”分割
* @return ancestorsNotList
*/
public List<String> getAncestorsNotList(){
return this.ancestorsNotList;
}
/**
* 设置 当前节点父id路径,“,”分割
* @param ancestorsNotList
*/
public void setAncestorsNotList(List<String> ancestorsNotList){
this.ancestorsNotList = ancestorsNotList;
}
/**
* 获取 开始 父菜单ID,一级菜单的该字段值为-1
* @return parentIdStart
*/
public Long getParentIdStart(){
return this.parentIdStart;
}
/**
* 设置 开始 父菜单ID,一级菜单的该字段值为-1
* @param parentIdStart
*/
public void setParentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
}
/**
* 获取 结束 父菜单ID,一级菜单的该字段值为-1
* @return $parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
}
/**
* 设置 结束 父菜单ID,一级菜单的该字段值为-1
* @param parentIdEnd
*/
public void setParentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
}
/**
* 获取 增加 父菜单ID,一级菜单的该字段值为-1
* @return parentIdIncrement
*/
public Long getParentIdIncrement(){
return this.parentIdIncrement;
}
/**
* 设置 增加 父菜单ID,一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public void setParentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
}
/**
* 获取 父菜单ID,一级菜单的该字段值为-1
* @return parentIdList
*/
public List<Long> getParentIdList(){
return this.parentIdList;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentIdList
*/
public void setParentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
}
/**
* 获取 父菜单ID,一级菜单的该字段值为-1
* @return parentIdNotList
*/
public List<Long> getParentIdNotList(){
return this.parentIdNotList;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentIdNotList
*/
public void setParentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
}
/**
* 获取 开始 链接方式 (0.普通,1.弹出,2.脚本)
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
return this.linkTypeStart;
}
/**
* 设置 开始 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
}
/**
* 获取 结束 链接方式 (0.普通,1.弹出,2.脚本)
* @return $linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
}
/**
* 获取 增加 链接方式 (0.普通,1.弹出,2.脚本)
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
return this.linkTypeIncrement;
}
/**
* 设置 增加 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
}
/**
* 获取 链接方式 (0.普通,1.弹出,2.脚本)
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
return this.linkTypeList;
}
/**
* 设置 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
}
/**
* 获取 链接方式 (0.普通,1.弹出,2.脚本)
* @return linkTypeNotList
*/
public List<Integer> getLinkTypeNotList(){
return this.linkTypeNotList;
}
/**
* 设置 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeNotList
*/
public void setLinkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
}
/**
* 获取 主菜单图标,主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 主菜单图标,主菜单图标的css样式名
* @return imgPathNotList
*/
public List<String> getImgPathNotList(){
return this.imgPathNotList;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPathNotList
*/
public void setImgPathNotList(List<String> imgPathNotList){
this.imgPathNotList = imgPathNotList;
}
/**
* 获取 按钮图标,按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 按钮图标,按钮图标的css样式名
* @return buttonImgPathNotList
*/
public List<String> getButtonImgPathNotList(){
return this.buttonImgPathNotList;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPathNotList
*/
public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.buttonImgPathNotList = buttonImgPathNotList;
}
/**
* 获取 常用菜单图标,常用菜单图标的css样式名
* @return imgCommPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 常用菜单图标,常用菜单图标的css样式名
* @return imgCommPathNotList
*/
public List<String> getImgCommPathNotList(){
return this.imgCommPathNotList;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPathNotList
*/
public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathNotList = imgCommPathNotList;
}
/**
* 获取 开始 是否常用菜单 (0.非常用,1.常用)
* @return commMenuStart
*/
public Integer getCommMenuStart(){
return this.commMenuStart;
}
/**
* 设置 开始 是否常用菜单 (0.非常用,1.常用)
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
}
/**
* 获取 结束 是否常用菜单 (0.非常用,1.常用)
* @return $commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单 (0.非常用,1.常用)
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
}
/**
* 获取 增加 是否常用菜单 (0.非常用,1.常用)
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
return this.commMenuIncrement;
}
/**
* 设置 增加 是否常用菜单 (0.非常用,1.常用)
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
}
/**
* 获取 是否常用菜单 (0.非常用,1.常用)
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
return this.commMenuList;
}
/**
* 设置 是否常用菜单 (0.非常用,1.常用)
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
}
/**
* 获取 是否常用菜单 (0.非常用,1.常用)
* @return commMenuNotList
*/
public List<Integer> getCommMenuNotList(){
return this.commMenuNotList;
}
/**
* 设置 是否常用菜单 (0.非常用,1.常用)
* @param commMenuNotList
*/
public void setCommMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
}
/**
* 获取 vue组件路径
* @return componentList
*/
public List<String> getComponentList(){
return this.componentList;
}
/**
* 设置 vue组件路径
* @param componentList
*/
public void setComponentList(List<String> componentList){
this.componentList = componentList;
}
/**
* 获取 vue组件路径
* @return componentNotList
*/
public List<String> getComponentNotList(){
return this.componentNotList;
}
/**
* 设置 vue组件路径
* @param componentNotList
*/
public void setComponentNotList(List<String> componentNotList){
this.componentNotList = componentNotList;
}
/**
* 获取 开始 菜单类型 (0.目录,1.菜单,2.按钮)
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
return this.menuTypeStart;
}
/**
* 设置 开始 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
}
/**
* 获取 结束 菜单类型 (0.目录,1.菜单,2.按钮)
* @return $menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
}
/**
* 获取 增加 菜单类型 (0.目录,1.菜单,2.按钮)
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
return this.menuTypeIncrement;
}
/**
* 设置 增加 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
}
/**
* 获取 菜单类型 (0.目录,1.菜单,2.按钮)
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
return this.menuTypeList;
}
/**
* 设置 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
}
/**
* 获取 菜单类型 (0.目录,1.菜单,2.按钮)
* @return menuTypeNotList
*/
public List<Integer> getMenuTypeNotList(){
return this.menuTypeNotList;
}
/**
* 设置 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeNotList
*/
public void setMenuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
}
/**
* 获取 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return $authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeNotList
*/
public List<Integer> getAuthTypeNotList(){
return this.authTypeNotList;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeNotList
*/
public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
}
/**
* 获取 开始 菜单显示状态 (0.显示,1.隐藏)
* @return visibleStart
*/
public Integer getVisibleStart(){
return this.visibleStart;
}
/**
* 设置 开始 菜单显示状态 (0.显示,1.隐藏)
* @param visibleStart
*/
public void setVisibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
}
/**
* 获取 结束 菜单显示状态 (0.显示,1.隐藏)
* @return $visibleEnd
*/
public Integer getVisibleEnd(){
return this.visibleEnd;
}
/**
* 设置 结束 菜单显示状态 (0.显示,1.隐藏)
* @param visibleEnd
*/
public void setVisibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
}
/**
* 获取 增加 菜单显示状态 (0.显示,1.隐藏)
* @return visibleIncrement
*/
public Integer getVisibleIncrement(){
return this.visibleIncrement;
}
/**
* 设置 增加 菜单显示状态 (0.显示,1.隐藏)
* @param visibleIncrement
*/
public void setVisibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
}
/**
* 获取 菜单显示状态 (0.显示,1.隐藏)
* @return visibleList
*/
public List<Integer> getVisibleList(){
return this.visibleList;
}
/**
* 设置 菜单显示状态 (0.显示,1.隐藏)
* @param visibleList
*/
public void setVisibleList(List<Integer> visibleList){
this.visibleList = visibleList;
}
/**
* 获取 菜单显示状态 (0.显示,1.隐藏)
* @return visibleNotList
*/
public List<Integer> getVisibleNotList(){
return this.visibleNotList;
}
/**
* 设置 菜单显示状态 (0.显示,1.隐藏)
* @param visibleNotList
*/
public void setVisibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
}
/**
* 获取 权限标识,多个逗号分割
* @return permsList
*/
public List<String> getPermsList(){
return this.permsList;
}
/**
* 设置 权限标识,多个逗号分割
* @param permsList
*/
public void setPermsList(List<String> permsList){
this.permsList = permsList;
}
/**
* 获取 权限标识,多个逗号分割
* @return permsNotList
*/
public List<String> getPermsNotList(){
return this.permsNotList;
}
/**
* 设置 权限标识,多个逗号分割
* @param permsNotList
*/
public void setPermsNotList(List<String> permsNotList){
this.permsNotList = permsNotList;
}
/**
* 获取 备注信息
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注信息
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注信息
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注信息
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return $orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 排序编号
* @return orderIdNotList
*/
public List<Integer> getOrderIdNotList(){
return this.orderIdNotList;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public void setOrderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
}
/**
* 获取 开始 菜单状态 (0.停用,1.启用)
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态 (0.停用,1.启用)
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态 (0.停用,1.启用)
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态 (0.停用,1.启用)
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态 (0.停用,1.启用)
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态 (0.停用,1.启用)
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态 (0.停用,1.启用)
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态 (0.停用,1.启用)
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 菜单状态 (0.停用,1.启用)
* @return statusNotList
*/
public List<Integer> getStatusNotList(){
return this.statusNotList;
}
/**
* 设置 菜单状态 (0.停用,1.启用)
* @param statusNotList
*/
public void setStatusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
}
/**
* 获取 开始 创建时间
* @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;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 开始 是否启用缓存 (0.否,1.是)
* @return cacheStart
*/
public Integer getCacheStart(){
return this.cacheStart;
}
/**
* 设置 开始 是否启用缓存 (0.否,1.是)
* @param cacheStart
*/
public void setCacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
}
/**
* 获取 结束 是否启用缓存 (0.否,1.是)
* @return $cacheEnd
*/
public Integer getCacheEnd(){
return this.cacheEnd;
}
/**
* 设置 结束 是否启用缓存 (0.否,1.是)
* @param cacheEnd
*/
public void setCacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
}
/**
* 获取 增加 是否启用缓存 (0.否,1.是)
* @return cacheIncrement
*/
public Integer getCacheIncrement(){
return this.cacheIncrement;
}
/**
* 设置 增加 是否启用缓存 (0.否,1.是)
* @param cacheIncrement
*/
public void setCacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
}
/**
* 获取 是否启用缓存 (0.否,1.是)
* @return cacheList
*/
public List<Integer> getCacheList(){
return this.cacheList;
}
/**
* 设置 是否启用缓存 (0.否,1.是)
* @param cacheList
*/
public void setCacheList(List<Integer> cacheList){
this.cacheList = cacheList;
}
/**
* 获取 是否启用缓存 (0.否,1.是)
* @return cacheNotList
*/
public List<Integer> getCacheNotList(){
return this.cacheNotList;
}
/**
* 设置 是否启用缓存 (0.否,1.是)
* @param cacheNotList
*/
public void setCacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
}
/**
* 获取 激活目录
* @return activeDirList
*/
public List<String> getActiveDirList(){
return this.activeDirList;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public void setActiveDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
}
/**
* 获取 激活目录
* @return activeDirNotList
*/
public List<String> getActiveDirNotList(){
return this.activeDirNotList;
}
/**
* 设置 激活目录
* @param activeDirNotList
*/
public void setActiveDirNotList(List<String> activeDirNotList){
this.activeDirNotList = activeDirNotList;
}
/**
* 获取 开始 是否隐藏(0.否,1.是)
* @return hideChildrenInMenuStart
*/
public Integer getHideChildrenInMenuStart(){
return this.hideChildrenInMenuStart;
}
/**
* 设置 开始 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuStart
*/
public void setHideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
}
/**
* 获取 结束 是否隐藏(0.否,1.是)
* @return $hideChildrenInMenuEnd
*/
public Integer getHideChildrenInMenuEnd(){
return this.hideChildrenInMenuEnd;
}
/**
* 设置 结束 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuEnd
*/
public void setHideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
}
/**
* 获取 增加 是否隐藏(0.否,1.是)
* @return hideChildrenInMenuIncrement
*/
public Integer getHideChildrenInMenuIncrement(){
return this.hideChildrenInMenuIncrement;
}
/**
* 设置 增加 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuIncrement
*/
public void setHideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
}
/**
* 获取 是否隐藏(0.否,1.是)
* @return hideChildrenInMenuList
*/
public List<Integer> getHideChildrenInMenuList(){
return this.hideChildrenInMenuList;
}
/**
* 设置 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuList
*/
public void setHideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
}
/**
* 获取 是否隐藏(0.否,1.是)
* @return hideChildrenInMenuNotList
*/
public List<Integer> getHideChildrenInMenuNotList(){
return this.hideChildrenInMenuNotList;
}
/**
* 设置 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuNotList
*/
public void setHideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
}
/**
* 获取 资源访问路径,多个逗号分割
* @return resourceUrlList
*/
public List<String> getResourceUrlList(){
return this.resourceUrlList;
}
/**
* 设置 资源访问路径,多个逗号分割
* @param resourceUrlList
*/
public void setResourceUrlList(List<String> resourceUrlList){
this.resourceUrlList = resourceUrlList;
}
/**
* 获取 资源访问路径,多个逗号分割
* @return resourceUrlNotList
*/
public List<String> getResourceUrlNotList(){
return this.resourceUrlNotList;
}
/**
* 设置 资源访问路径,多个逗号分割
* @param resourceUrlNotList
*/
public void setResourceUrlNotList(List<String> resourceUrlNotList){
this.resourceUrlNotList = resourceUrlNotList;
}
/**
* 设置 菜单ID,主键,自增长
* @param id
*/
public MenuQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 菜单ID,主键,自增长
* @param idStart
*/
public MenuQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 菜单ID,主键,自增长
* @param idEnd
*/
public MenuQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 菜单ID,主键,自增长
* @param idIncrement
*/
public MenuQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 菜单ID,主键,自增长
* @param idList
*/
public MenuQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 菜单ID,主键,自增长
* @param idNotList
*/
public MenuQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 菜单名称
* @param name
*/
public MenuQuery name(String name){
setName(name);
return this;
}
/**
* 设置 菜单名称
* @param nameList
*/
public MenuQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 路由地址
* @param url
*/
public MenuQuery url(String url){
setUrl(url);
return this;
}
/**
* 设置 路由地址
* @param urlList
*/
public MenuQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
}
/**
* 设置 当前节点父id路径,“,”分割
* @param ancestors
*/
public MenuQuery ancestors(String ancestors){
setAncestors(ancestors);
return this;
}
/**
* 设置 当前节点父id路径,“,”分割
* @param ancestorsList
*/
public MenuQuery ancestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
return this;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentId
*/
public MenuQuery parentId(Long parentId){
setParentId(parentId);
return this;
}
/**
* 设置 开始 父菜单ID,一级菜单的该字段值为-1
* @param parentIdStart
*/
public MenuQuery parentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
return this;
}
/**
* 设置 结束 父菜单ID,一级菜单的该字段值为-1
* @param parentIdEnd
*/
public MenuQuery parentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
return this;
}
/**
* 设置 增加 父菜单ID,一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public MenuQuery parentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
return this;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentIdList
*/
public MenuQuery parentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
return this;
}
/**
* 设置 父菜单ID,一级菜单的该字段值为-1
* @param parentIdNotList
*/
public MenuQuery parentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
return this;
}
/**
* 设置 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkType
*/
public MenuQuery linkType(Integer linkType){
setLinkType(linkType);
return this;
}
/**
* 设置 开始 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeStart
*/
public MenuQuery linkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
return this;
}
/**
* 设置 结束 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeEnd
*/
public MenuQuery linkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
return this;
}
/**
* 设置 增加 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeIncrement
*/
public MenuQuery linkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
return this;
}
/**
* 设置 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeList
*/
public MenuQuery linkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
return this;
}
/**
* 设置 链接方式 (0.普通,1.弹出,2.脚本)
* @param linkTypeNotList
*/
public MenuQuery linkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
return this;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPath
*/
public MenuQuery imgPath(String imgPath){
setImgPath(imgPath);
return this;
}
/**
* 设置 主菜单图标,主菜单图标的css样式名
* @param imgPathList
*/
public MenuQuery imgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
return this;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPath
*/
public MenuQuery buttonImgPath(String buttonImgPath){
setButtonImgPath(buttonImgPath);
return this;
}
/**
* 设置 按钮图标,按钮图标的css样式名
* @param buttonImgPathList
*/
public MenuQuery buttonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
return this;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPath
*/
public MenuQuery imgCommPath(String imgCommPath){
setImgCommPath(imgCommPath);
return this;
}
/**
* 设置 常用菜单图标,常用菜单图标的css样式名
* @param imgCommPathList
*/
public MenuQuery imgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用,1.常用)
* @param commMenu
*/
public MenuQuery commMenu(Integer commMenu){
setCommMenu(commMenu);
return this;
}
/**
* 设置 开始 是否常用菜单 (0.非常用,1.常用)
* @param commMenuStart
*/
public MenuQuery commMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
return this;
}
/**
* 设置 结束 是否常用菜单 (0.非常用,1.常用)
* @param commMenuEnd
*/
public MenuQuery commMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
return this;
}
/**
* 设置 增加 是否常用菜单 (0.非常用,1.常用)
* @param commMenuIncrement
*/
public MenuQuery commMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用,1.常用)
* @param commMenuList
*/
public MenuQuery commMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用,1.常用)
* @param commMenuNotList
*/
public MenuQuery commMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
return this;
}
/**
* 设置 vue组件路径
* @param component
*/
public MenuQuery component(String component){
setComponent(component);
return this;
}
/**
* 设置 vue组件路径
* @param componentList
*/
public MenuQuery componentList(List<String> componentList){
this.componentList = componentList;
return this;
}
/**
* 设置 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuType
*/
public MenuQuery menuType(Integer menuType){
setMenuType(menuType);
return this;
}
/**
* 设置 开始 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeStart
*/
public MenuQuery menuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
return this;
}
/**
* 设置 结束 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeEnd
*/
public MenuQuery menuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
return this;
}
/**
* 设置 增加 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeIncrement
*/
public MenuQuery menuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
return this;
}
/**
* 设置 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeList
*/
public MenuQuery menuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
return this;
}
/**
* 设置 菜单类型 (0.目录,1.菜单,2.按钮)
* @param menuTypeNotList
*/
public MenuQuery menuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
return this;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authType
*/
public MenuQuery authType(Integer authType){
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeStart
*/
public MenuQuery authTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
return this;
}
/**
* 设置 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeEnd
*/
public MenuQuery authTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
return this;
}
/**
* 设置 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeIncrement
*/
public MenuQuery authTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
return this;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeList
*/
public MenuQuery authTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
return this;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeNotList
*/
public MenuQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
return this;
}
/**
* 设置 菜单显示状态 (0.显示,1.隐藏)
* @param visible
*/
public MenuQuery visible(Integer visible){
setVisible(visible);
return this;
}
/**
* 设置 开始 菜单显示状态 (0.显示,1.隐藏)
* @param visibleStart
*/
public MenuQuery visibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
return this;
}
/**
* 设置 结束 菜单显示状态 (0.显示,1.隐藏)
* @param visibleEnd
*/
public MenuQuery visibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
return this;
}
/**
* 设置 增加 菜单显示状态 (0.显示,1.隐藏)
* @param visibleIncrement
*/
public MenuQuery visibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
return this;
}
/**
* 设置 菜单显示状态 (0.显示,1.隐藏)
* @param visibleList
*/
public MenuQuery visibleList(List<Integer> visibleList){
this.visibleList = visibleList;
return this;
}
/**
* 设置 菜单显示状态 (0.显示,1.隐藏)
* @param visibleNotList
*/
public MenuQuery visibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
return this;
}
/**
* 设置 权限标识,多个逗号分割
* @param perms
*/
public MenuQuery perms(String perms){
setPerms(perms);
return this;
}
/**
* 设置 权限标识,多个逗号分割
* @param permsList
*/
public MenuQuery permsList(List<String> permsList){
this.permsList = permsList;
return this;
}
/**
* 设置 备注信息
* @param remark
*/
public MenuQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注信息
* @param remarkList
*/
public MenuQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 排序编号
* @param orderId
*/
public MenuQuery orderId(Integer orderId){
setOrderId(orderId);
return this;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public MenuQuery orderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
return this;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public MenuQuery orderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
return this;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public MenuQuery orderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
return this;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public MenuQuery orderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
return this;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
return this;
}
/**
* 设置 菜单状态 (0.停用,1.启用)
* @param status
*/
public MenuQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 菜单状态 (0.停用,1.启用)
* @param statusStart
*/
public MenuQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 菜单状态 (0.停用,1.启用)
* @param statusEnd
*/
public MenuQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 菜单状态 (0.停用,1.启用)
* @param statusIncrement
*/
public MenuQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 菜单状态 (0.停用,1.启用)
* @param statusList
*/
public MenuQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
/**
* 设置 菜单状态 (0.停用,1.启用)
* @param statusNotList
*/
public MenuQuery statusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MenuQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MenuQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MenuQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MenuQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MenuQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public MenuQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public MenuQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public MenuQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public MenuQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public MenuQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public MenuQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public MenuQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MenuQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 设置 创建用户名称
* @param updateUserName
*/
public MenuQuery updateUserName(String updateUserName){
setUpdateUserName(updateUserName);
return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public MenuQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 设置 是否启用缓存 (0.否,1.是)
* @param cache
*/
public MenuQuery cache(Integer cache){
setCache(cache);
return this;
}
/**
* 设置 开始 是否启用缓存 (0.否,1.是)
* @param cacheStart
*/
public MenuQuery cacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
return this;
}
/**
* 设置 结束 是否启用缓存 (0.否,1.是)
* @param cacheEnd
*/
public MenuQuery cacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
return this;
}
/**
* 设置 增加 是否启用缓存 (0.否,1.是)
* @param cacheIncrement
*/
public MenuQuery cacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
return this;
}
/**
* 设置 是否启用缓存 (0.否,1.是)
* @param cacheList
*/
public MenuQuery cacheList(List<Integer> cacheList){
this.cacheList = cacheList;
return this;
}
/**
* 设置 是否启用缓存 (0.否,1.是)
* @param cacheNotList
*/
public MenuQuery cacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
return this;
}
/**
* 设置 激活目录
* @param activeDir
*/
public MenuQuery activeDir(String activeDir){
setActiveDir(activeDir);
return this;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public MenuQuery activeDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
return this;
}
/**
* 设置 是否隐藏(0.否,1.是)
* @param hideChildrenInMenu
*/
public MenuQuery hideChildrenInMenu(Integer hideChildrenInMenu){
setHideChildrenInMenu(hideChildrenInMenu);
return this;
}
/**
* 设置 开始 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuStart
*/
public MenuQuery hideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
return this;
}
/**
* 设置 结束 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuEnd
*/
public MenuQuery hideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
return this;
}
/**
* 设置 增加 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuIncrement
*/
public MenuQuery hideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
return this;
}
/**
* 设置 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuList
*/
public MenuQuery hideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
return this;
}
/**
* 设置 是否隐藏(0.否,1.是)
* @param hideChildrenInMenuNotList
*/
public MenuQuery hideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
return this;
}
/**
* 设置 资源访问路径,多个逗号分割
* @param resourceUrl
*/
public MenuQuery resourceUrl(String resourceUrl){
setResourceUrl(resourceUrl);
return this;
}
/**
* 设置 资源访问路径,多个逗号分割
* @param resourceUrlList
*/
public MenuQuery resourceUrlList(List<String> resourceUrlList){
this.resourceUrlList = resourceUrlList;
return this;
}
/**
* 获取 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MenuQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<MenuQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<MenuQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<MenuQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.menu.model;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.JSONToken;
import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import org.springframework.util.ObjectUtils;
import java.io.Serializable;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* 菜单信息业务前端映射树结构实体类
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class MenuTreeSelect implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 节点ID
*/
private Long id;
/**
* 父节点ID
*/
private Long parentId;
/**
* 节点名称
*/
private String label;
/**
* 菜单类型 (0.目录,1.菜单,2.按钮)
*/
private Integer menuType;
/**
* 菜单显示状态 (0.显示,1.隐藏)
*/
private Integer visible;
/**
* 权限标识,多个逗号分割
*/
private String perms;
/**
* 权限标识,多个逗号分割
*/
private String resourceUrl;
/**
* 是否隐藏(0.否,1.是)
*/
private Integer hideChildrenInMenu;
/**
* 是否选中,0为未选中,1选中。默认0
*/
private Integer checked;
/**
* 子节点
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private List<MenuTreeSelect> children;
public MenuTreeSelect() {};
public MenuTreeSelect(MenuEntity entity) {
this.id = entity.getId();
this.parentId = entity.getParentId();
this.label = entity.getName();
this.menuType = entity.getMenuType();
this.visible = entity.getVisible();
this.perms = entity.getPerms();
this.resourceUrl=entity.getResourceUrl();
this.checked=entity.getChecked();
this.hideChildrenInMenu = entity.getHideChildrenInMenu();
if(!ObjectUtils.isEmpty(entity.getChildren())){
this.children = entity.getChildren().stream().map(MenuTreeSelect::new).collect(Collectors.toList());
}
}
// 反序列化器
public class Deserializer implements ObjectDeserializer {
@Override
public MenuTreeSelect deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
MenuTreeSelect node = new MenuTreeSelect();
JSONObject jsonObject = parser.parseObject();
node.setId(jsonObject.getLong("id"));
node.setLabel(jsonObject.getString("label"));
node.setMenuType(jsonObject.getInteger("menuType"));
node.setVisible(jsonObject.getInteger("visible"));
node.setPerms(jsonObject.getString("perms"));
node.setResourceUrl(jsonObject.getString("resourceUrl"));
node.setChecked(jsonObject.getInteger("checked"));
node.setHideChildrenInMenu(jsonObject.getInteger("hideChildrenInMenu"));
JSONArray jsonArray = jsonObject.getJSONArray("children");
List<MenuTreeSelect> children = new ArrayList<>();
if(!ObjectUtils.isEmpty(jsonArray)){
for (int i = 0; i < jsonArray.size(); i++) {
MenuTreeSelect child = JSON.parseObject(jsonArray.getJSONObject(i).toJSONString(), MenuTreeSelect.class);
children.add(child);
}
}
node.setChildren(children);
return node;
}
@Override
public int getFastMatchToken() {
return JSONToken.LBRACE;
}
}
}
\ No newline at end of file
package com.mortals.xhx.base.system.menu.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 菜单信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class MenuVo extends BaseEntityLong {
/** 菜单ID,主键,自增长列表 */
private List <Long> idList;
/** 子菜单信息业务 */
private List<MenuEntity> children = new ArrayList<>();
private List<MenuEntity> childList = new ArrayList<>();
private Integer type;
/**
* 是否选中,0为未选中,1选中。默认0
*/
private Integer checked;
}
\ No newline at end of file
...@@ -10,22 +10,20 @@ package com.mortals.xhx.base.system.menu.service; ...@@ -10,22 +10,20 @@ package com.mortals.xhx.base.system.menu.service;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService; import com.mortals.framework.service.ICRUDService;
import com.mortals.framework.service.IUser; import com.mortals.framework.service.IUser;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
/** /**
* <p>Title: 菜单信息</p> * 菜单资源类
* <p>Description: MenuService service接口 </p> * @author: zxfei
* <p>Copyright: Copyright &reg; </p> * @date: 2024/9/6 16:28
* <p>Company: </p>
* @author
* @version 1.0.0
*/ */
public interface MenuService extends ICRUDService<MenuEntity,Long> { public interface MenuService extends ICRUDService<MenuEntity,Long> {
/** /**
* 获取所有可用菜单 * 获取所有可用菜单
...@@ -33,31 +31,67 @@ public interface MenuService extends ICRUDService<MenuEntity,Long> { ...@@ -33,31 +31,67 @@ public interface MenuService extends ICRUDService<MenuEntity,Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
public List<MenuEntity> findAllEnable() throws AppException; List<MenuEntity> findAllEnable() throws AppException;
/** /**
* 查询有权限的菜单 * 查询有权限的菜单
* *
* @param user 当前用户 * @param user 当前用户
* @param urls 有权限的访问地址集合
* @return * @return
* @throws AppException * @throws AppException
*/ */
public List<MenuEntity> findTreeMenu(IUser user, Set<String> urls) throws AppException; List<MenuEntity> findTreeMenu(IUser user) throws AppException;
/**
* 更新排列顺序
* @param id
* @param type
*/
void upOrDown(Long id, Integer type);
/** /**
* 查看所有菜单 * 是否存在菜单信息业务节点
* *
* @param menuId 菜单信息业务ID
* @return 结果
*/
boolean hasChildByMenuId(Long menuId);
/**
* 构建树
* @param menuList
* @return * @return
* @throws AppException
*/ */
public List<MenuEntity> findTreeMenu() throws AppException; List<MenuEntity> buildMenuTree(List<MenuEntity> menuList);
/** /**
* 更新排列顺序 * 构建前端所需要下拉树结构
* @param id *
* @param type * @param menuList 菜单信息业务列表
* @return 下拉树结构列表
*/ */
void upOrDown(Long id, Integer type); List<MenuTreeSelect> buildMenuTreeSelect(List<MenuEntity> menuList);
/**
* 构建树,包含是否选中
* @param allMenuList
* @param menuIdsChecked
* @return
*/
List<MenuTreeSelect> buildMenuTreeChecked(List<MenuEntity> allMenuList, Set<Long> menuIdsChecked);
/**
* 根据父id查询子节点
* @param parentId
* @param context
* @return
*/
List<MenuTreeSelect> getListByParentId(Long parentId, Context context);
} }
\ No newline at end of file
...@@ -14,14 +14,14 @@ import com.mortals.framework.model.Context; ...@@ -14,14 +14,14 @@ import com.mortals.framework.model.Context;
import com.mortals.framework.model.OrderCol; import com.mortals.framework.model.OrderCol;
import com.mortals.framework.service.IUser; import com.mortals.framework.service.IUser;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl; import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.util.StringUtils;
import com.mortals.xhx.base.system.menu.dao.MenuDao; import com.mortals.xhx.base.system.menu.dao.MenuDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuQuery; import com.mortals.xhx.base.system.menu.model.MenuQuery;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.menu.service.MenuService; import com.mortals.xhx.base.system.menu.service.MenuService;
import com.mortals.xhx.common.code.YesNoEnum; import com.mortals.xhx.common.code.YesNoEnum;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import java.util.*; import java.util.*;
import java.util.stream.Collectors; import java.util.stream.Collectors;
...@@ -51,80 +51,31 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity ...@@ -51,80 +51,31 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
} }
@Override @Override
public List<MenuEntity> findTreeMenu(IUser user, Set<String> urls) throws AppException { public List<MenuEntity> findTreeMenu(IUser user) throws AppException {
Set<Long> authIds = new HashSet<Long>(); //todo 重新写 菜单树 通过角色获取菜单
Map<Long, MenuEntity> menuMap = new HashMap<Long, MenuEntity>(); if (user.isAdmin()) {
List<MenuEntity> userModuleList = this.findAllEnable(); //全菜单列表获取
for (MenuEntity sysModule : userModuleList) { MenuQuery menuQuery = new MenuQuery();
if (sysModule == null) { List<OrderCol> orderColList = new ArrayList<>();
continue; orderColList.add(new OrderCol("parentId"));
} orderColList.add(new OrderCol("orderId"));
menuMap.put(sysModule.getId(), sysModule); menuQuery.setOrderColList(orderColList);
if (!user.isAdmin() && urls.contains(StringUtils.trim(sysModule.getUrl()))) { List<MenuEntity> list = this.find(menuQuery);
authIds.add(sysModule.getId()); List<MenuEntity> returnTreeList = this.buildMenuTree(list);
} return returnTreeList;
}
if (!user.isAdmin()) {
Long[] ids = authIds.toArray(new Long[authIds.size()]);
for (Long id : ids) {
MenuEntity menu = menuMap.get(id);
while (menu != null) {
authIds.add(menu.getId());
menu = menuMap.get(menu.getParentId());
}
}
} }
List<MenuEntity> outlookBar = new ArrayList<MenuEntity>(); List<MenuEntity> menuEntities = this.getDao().getListByUserId(user.getId()).stream().distinct().collect(Collectors.toList());
List<MenuEntity> norightList = new ArrayList<MenuEntity>(); List<MenuEntity> returnTreeList = this.buildMenuTree(menuEntities);
for (MenuEntity sysModule : userModuleList) { return returnTreeList;
if (!user.isAdmin() && !authIds.contains(sysModule.getId())) {
norightList.add(sysModule);
continue;
}
if (sysModule.getParentId() == null || sysModule.getParentId().longValue() == 0) {
outlookBar.add(sysModule);
continue;
}
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) {
sysModuleParent.getChildList().add(sysModule);
}
}
return outlookBar;
}
public List<MenuEntity> findTreeMenu() throws AppException {
Map<Long, MenuEntity> menuMap = new HashMap<Long, MenuEntity>();
List<MenuEntity> userModuleList = this.findAllEnable();
for (MenuEntity sysModule : userModuleList) {
if (sysModule == null) {
continue;
}
menuMap.put(sysModule.getId(), sysModule);
}
List<MenuEntity> outlookBar = new ArrayList<MenuEntity>();
for (MenuEntity sysModule : userModuleList) {
if (sysModule.getParentId() == null || sysModule.getParentId().longValue() == 0) {
outlookBar.add(sysModule);
continue;
}
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) {
sysModuleParent.getChildList().add(sysModule);
}
}
return outlookBar;
} }
@Override @Override
public void upOrDown(Long id, Integer type) { public void upOrDown(Long id, Integer type) {
MenuQuery query = new MenuQuery(); MenuQuery query = new MenuQuery();
query.setOrderColList(Arrays.asList(new OrderCol("orderId"))); query.setOrderColList(Arrays.asList(new OrderCol("orderId")));
query.setOrderKind(OrderCol.ASCENDING); query.setOrderKind(OrderCol.ASCENDING);
//判断移动的是一级菜单还是二级菜单 //判断移动的是一级菜单还是二级菜单
MenuEntity menuEntity = this.get(id); MenuEntity menuEntity = this.get(id);
if (menuEntity.getParentId() == 0) { if (menuEntity.getParentId() == 0) {
...@@ -173,14 +124,177 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity ...@@ -173,14 +124,177 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
@Override @Override
protected void saveBefore(MenuEntity entity, Context context) throws AppException { protected void saveBefore(MenuEntity entity, Context context) throws AppException {
MenuEntity parentMenuEntity = this.get(entity.getParentId());
if (!ObjectUtils.isEmpty(parentMenuEntity)) {
entity.setAncestors(parentMenuEntity.getAncestors() + "," + entity.getParentId());
}
MenuQuery query = new MenuQuery(); MenuQuery query = new MenuQuery();
query.setParentId(entity.getParentId()); query.setParentId(entity.getParentId());
Comparator<Integer> comparator = Comparator.comparing(Integer::intValue); Comparator<Integer> comparator = Comparator.comparing(Integer::intValue);
Optional<Integer> maxOptional = this.find(query).stream().map(MenuEntity::getOrderId).filter(f->f!=9999).max(comparator); Optional<Integer> maxOptional = this.find(query).stream().map(MenuEntity::getOrderId).filter(f -> f != 9999).max(comparator);
maxOptional.ifPresent(e -> { maxOptional.ifPresent(e -> {
e=e+1; e = e + 1;
entity.setOrderId(e); entity.setOrderId(e);
}); });
super.saveBefore(entity, context); super.saveBefore(entity, context);
} }
@Override
protected void updateBefore(MenuEntity entity, Context context) throws AppException {
MenuEntity newParentEntity = this.get(entity.getParentId());
MenuEntity oldEntity = this.get(entity.getId());
if (!ObjectUtils.isEmpty(newParentEntity) && !ObjectUtils.isEmpty(oldEntity)) {
String newAncestors = newParentEntity.getAncestors() + "," + newParentEntity.getId();
String oldAncestors = oldEntity.getAncestors();
entity.setAncestors(newAncestors);
updateMenuChildren(entity.getId(), newAncestors, oldAncestors, context);
}
super.updateBefore(entity, context);
}
/**
* 修改子元素关系
*
* @param menuId 被修改的菜单信息业务ID
* @param newAncestors 新的父ID集合
* @param oldAncestors 旧的父ID集合
*/
public void updateMenuChildren(Long menuId, String newAncestors, String oldAncestors, Context context) {
List<MenuEntity> children = getDao().selectChildrenMenuById(menuId.toString());
for (MenuEntity child : children) {
child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
}
if (children.size() > 0) {
this.updateAfter(children, context);
}
}
@Override
public boolean hasChildByMenuId(Long menuId) {
List<MenuEntity> list = this.find(new MenuQuery().parentId(menuId));
return list.size() > 0 ? true : false;
}
@Override
public List<MenuEntity> buildMenuTree(List<MenuEntity> list) {
List<MenuEntity> returnList = new ArrayList<>();
List<Long> tempList = list.stream().map(MenuEntity::getId).collect(Collectors.toList());
for (Iterator<MenuEntity> iterator = list.iterator(); iterator.hasNext(); ) {
MenuEntity menuEntity = iterator.next();
if (!tempList.contains(menuEntity.getParentId())) {
recursionFn(list, menuEntity, new HashSet<>());
returnList.add(menuEntity);
}
}
if (returnList.isEmpty()) {
returnList = list;
}
return returnList;
}
@Override
public List<MenuTreeSelect> buildMenuTreeSelect(List<MenuEntity> list) {
List<MenuEntity> returnList = new ArrayList<>();
List<Long> tempList = list.stream().map(MenuEntity::getId).collect(Collectors.toList());
for (Iterator<MenuEntity> iterator = list.iterator(); iterator.hasNext(); ) {
MenuEntity menuEntity = iterator.next();
if (!tempList.contains(menuEntity.getParentId())) {
recursionFn(list, menuEntity, new HashSet<>());
returnList.add(menuEntity);
}
}
if (returnList.isEmpty()) {
returnList = list;
}
return returnList.stream().map(MenuTreeSelect::new).collect(Collectors.toList());
}
@Override
public List<MenuTreeSelect> buildMenuTreeChecked(List<MenuEntity> allMenuList, Set<Long> menuIdsChecked) {
List<MenuEntity> returnList = new ArrayList<>();
List<Long> tempList = allMenuList.stream().map(MenuEntity::getId).collect(Collectors.toList());
for (Iterator<MenuEntity> iterator = allMenuList.iterator(); iterator.hasNext(); ) {
MenuEntity menuEntity = iterator.next();
if (!tempList.contains(menuEntity.getParentId())) {
recursionFn(allMenuList, menuEntity, menuIdsChecked);
returnList.add(menuEntity);
}
}
if (returnList.isEmpty()) {
returnList = allMenuList;
}
return returnList.stream().map(MenuTreeSelect::new).collect(Collectors.toList());
}
/**
* 递归列表
*/
private void recursionFn(List<MenuEntity> list, MenuEntity t, Set<Long> menuIdsChecked) {
// 得到子节点列表
updateChecked(menuIdsChecked, t);
List<MenuEntity> childList = getChildList(list, t);
t.setChildren(childList);
for (MenuEntity tChild : childList) {
updateChecked(menuIdsChecked, tChild);
if (hasChild(list, tChild)) {
recursionFn(list, tChild, menuIdsChecked);
}
}
}
private void updateChecked(Set<Long> menuIdsChecked, MenuEntity menu) {
if (menuIdsChecked.contains(menu.getId())) {
menu.setChecked(YesNoEnum.YES.getValue());
} else {
menu.setChecked(YesNoEnum.NO.getValue());
}
}
@Override
protected void removeBefore(Long[] ids, Context context) throws AppException {
//有子节点 禁止删除
if (hasChildByMenuId(ids[0])) {
throw new AppException("存在下级菜单信息业务,不允许删除");
}
super.removeBefore(ids, context);
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<MenuEntity> list, MenuEntity t) {
return getChildList(list, t).size() > 0 ? true : false;
}
/**
* 得到子节点列表
*/
private List<MenuEntity> getChildList(List<MenuEntity> list, MenuEntity t) {
return list.stream().map(item -> {
if (!ObjectUtils.isEmpty(item.getParentId()) && item.getParentId() == t.getId()) {
return item;
}
return null;
}).filter(f -> f != null).collect(Collectors.toList());
}
@Override
public List<MenuTreeSelect> getListByParentId(Long parentId, Context context) {
if (ObjectUtils.isEmpty(parentId)) {
parentId = 0L;
}
//只做一层
List<MenuTreeSelect> collect = this.find(new MenuQuery().parentId(parentId), context).stream().map(item -> new MenuTreeSelect(item)
).collect(Collectors.toList());
return collect;
}
} }
\ No newline at end of file
...@@ -5,113 +5,150 @@ import com.alibaba.fastjson.JSONObject; ...@@ -5,113 +5,150 @@ import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.model.OrderCol; import com.mortals.framework.model.OrderCol;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuQuery;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.menu.service.MenuService; import com.mortals.xhx.base.system.menu.service.MenuService;
import com.mortals.xhx.common.code.DataSatus; import com.mortals.xhx.common.code.*;
import com.mortals.xhx.common.code.MenuAuthType; import io.swagger.annotations.ApiOperation;
import com.mortals.xhx.common.code.MenuComm; import org.springframework.web.bind.annotation.*;
import com.mortals.xhx.common.code.MenuLinkType;
import com.mortals.xhx.common.code.MenuType;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
* 菜单信息 * 菜单信息
* *
* @author: zxfei * @author: zxfei
* @date: 2021/11/30 10:02 * @date: 2024/9/6 16:23
*/ */
@RestController @RestController
@RequestMapping("menu") @RequestMapping("menu")
public class MenuController extends BaseCRUDJsonMappingController<MenuService, MenuForm,MenuEntity,Long> { public class MenuController extends BaseCRUDJsonBodyMappingController<MenuService, MenuEntity, Long> {
public MenuController() {
super.setModuleDesc("菜单信息");
}
@Override
protected void doListBefore(MenuEntity query, Map<String, Object> model, Context context) throws AppException {
List<OrderCol> orderColList = new ArrayList<>();
orderColList.add(new OrderCol("orderId"));
query.setOrderColList(orderColList);
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "linkType", LinkTypeEnum.getEnumMap());
this.addDict(model, "commMenu", CommMenuEnum.getEnumMap());
this.addDict(model, "menuType", MenuTypeEnum.getEnumMap());
this.addDict(model, "authType", AuthTypeEnum.getEnumMap());
this.addDict(model, "visible", VisibleEnum.getEnumMap());
this.addDict(model, "status", StatusEnum.getEnumMap());
}
public MenuController(){ /**
super.setFormClass(MenuForm.class); * 改变状态
super.setModuleDesc("菜单信息"); */
} @ApiOperation(value = "改变状态", notes = "改变状态")
@RequestMapping(value = "change/status")
public String changeStatus(@RequestBody MenuEntity query) {
JSONObject ret = new JSONObject();
Context context = getContext();
try {
MenuEntity entity = this.service.get(query.getId(), context);//.doSubmitAudit(form.getEntity(), context);
if (null == entity) {
throw new AppException("菜单不存在!");
}
if (null == entity.getStatus()) {
throw new AppException("菜单状态不能为空!");
}
if (entity.getStatus() != DataSatus.ENABLE.getValue() && entity.getStatus() != DataSatus.DISENABLE.getValue()) {
throw new AppException("非法菜单状态!");
}
String busiDesc = DataSatus.getByValue(entity.getStatus()).getDesc();
entity.setStatus(entity.getStatus());
this.service.update(entity, context);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_MSG, busiDesc + "成功");
recordSysLog(request, busiDesc + " 【成功】 [id:" + entity.getId() + "]");
} catch (Exception e) {
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
}
return ret.toJSONString();
}
@Override
protected void doListBefore(HttpServletRequest request, HttpServletResponse response, MenuForm form, Map<String, Object> model, Context context) throws AppException {
List<OrderCol> orderColList = new ArrayList<OrderCol>();
orderColList.add(new OrderCol("parentId"));
orderColList.add(new OrderCol("orderId"));
form.getQuery().setOrderColList(orderColList);
}
@Override /**
protected void init(HttpServletRequest request, HttpServletResponse response, MenuForm form, Map<String, Object> model, * 更换排序
Context context) { */
Map<String, Object> status = new HashMap<String, Object>(); @ApiOperation(value = "更换排序")
status.put("status", DataSatus.getEnumMap(DataSatus.CLOSE.getValue(), DataSatus.DELETE.getValue(), DataSatus.OVERDUE.getValue(), DataSatus.USEOUT.getValue())); @PostMapping(value = "upOrDown")
status.put("linkType", MenuLinkType.getEnumMap()); public String upOrDownTopicList(@RequestBody MenuEntity query) {
status.put("commMenu", MenuComm.getEnumMap()); JSONObject ret = new JSONObject();
status.put("menuType", MenuType.getEnumMap()); ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
status.put("authType", MenuAuthType.getEnumMap()); try {
model.put(KEY_RESULT_DICT, status); this.service.upOrDown(query.getId(), query.getType());
super.init(request, response, form, model, context); } catch (Exception e) {
} log.error("更新错误", e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, e.getMessage());
}
return ret.toJSONString();
}
/**
* 改变状态
*/
@RequestMapping(value = "change/status")
public String changeStatus(HttpServletRequest request, HttpServletResponse response, MenuForm form) {
JSONObject ret = new JSONObject();
Context context = getContext();
try {
MenuEntity entity = this.service.get(form.getEntity().getId(), context);//.doSubmitAudit(form.getEntity(), context);
if (null == entity) {
throw new AppException("菜单不存在!");
}
if (null == form.getEntity().getStatus()) {
throw new AppException("菜单状态不能为空!");
}
if (form.getEntity().getStatus() != DataSatus.ENABLE.getValue() && form.getEntity().getStatus() != DataSatus.DISENABLE.getValue()) {
throw new AppException("非法菜单状态!");
}
String busiDesc = DataSatus.getByValue(form.getEntity().getStatus()).getDesc();
entity.setStatus(form.getEntity().getStatus());
this.service.update(entity, context);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_MSG, busiDesc + "成功");
recordSysLog(request, busiDesc + " 【成功】 [id:" + entity.getId() + "]");
} catch (Exception e) { /**
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE); * 获取站点下拉树列表
ret.put(KEY_RESULT_MSG, super.convertException(e)); */
} @ApiOperation(value = "菜单树列表")
return ret.toJSONString(); @PostMapping("treeselect")
} public String treeselect() {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询" + this.getModuleDesc();
int code = VALUE_RESULT_SUCCESS;
try {
List<MenuEntity> list = this.service.find(new MenuQuery());
List<MenuTreeSelect> treeSelects = this.service.buildMenuTreeSelect(list);
model.put("result", treeSelects);
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_DATA, model);
ret.put(KEY_RESULT_CODE, code);
return ret.toJSONString();
}
/** /**
* 更换排序 * 根据parentId查询子信息
*/ */
@PostMapping(value = "upOrDown") @ApiOperation(value = "根据parentId查询子信息")
public String upOrDownTopicList(@RequestParam(value = "id") Long id, @RequestParam(value = "type") Integer type) { @GetMapping(value = "getListByParentId")
JSONObject ret = new JSONObject(); public String getListByParentId(Long parentId) {
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS); JSONObject ret = new JSONObject();
try { Map<String, Object> model = new HashMap<>();
this.service.upOrDown(id,type); String busiDesc = "查询" + this.getModuleDesc() + "子节点";
} catch (Exception e) { try {
log.error("更新错误", e); List<MenuTreeSelect> treeList = this.service.getListByParentId(parentId, getContext());
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE); model.put(KEY_RESULT_DATA, treeList);
ret.put(KEY_RESULT_MSG, e.getMessage()); ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
} ret.put(KEY_RESULT_DATA, model);
return ret.toJSONString(); recordSysLog(request, busiDesc + "【成功】");
} } catch (Exception e) {
log.error("根据parentId查询子信息错误", e);
this.doException(request, busiDesc, model, e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, e.getMessage());
}
return ret.toJSONString();
}
} }
\ No newline at end of file
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.oper.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.oper.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.oper.dao.OperLogDao; import com.mortals.xhx.base.system.oper.dao.OperLogDao;
import com.mortals.xhx.base.system.oper.model.OperLogEntity; import com.mortals.xhx.base.system.oper.model.OperLogEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
...@@ -8,10 +8,10 @@ ...@@ -8,10 +8,10 @@
package com.mortals.xhx.base.system.oper.model; package com.mortals.xhx.base.system.oper.model;
import java.util.Date;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import java.util.Date;
/** /**
* <p>Title: 操作日志</p> * <p>Title: 操作日志</p>
* <p>Description: OperLogEntity </p> * <p>Description: OperLogEntity </p>
......
...@@ -76,6 +76,5 @@ public interface OperLogService extends ICRUDService<OperLogEntity,Long> { ...@@ -76,6 +76,5 @@ public interface OperLogService extends ICRUDService<OperLogEntity,Long> {
void insertOperLog(HttpServletRequest request, IUser user, BaseEntity oldEntity, BaseEntity newEntity, OperTypeEnum operType, String content, String id); void insertOperLog(HttpServletRequest request, IUser user, BaseEntity oldEntity, BaseEntity newEntity, OperTypeEnum operType, String content, String id);
void insertOperLog(String ip, String requestUrl, Long userId, String userName, String loginName, String content); void insertOperLog(String ip, String requestUrl, Long userId, String userName, String loginName, String content);
} }
\ No newline at end of file
...@@ -21,7 +21,6 @@ import com.mortals.xhx.base.system.oper.dao.OperLogDao; ...@@ -21,7 +21,6 @@ import com.mortals.xhx.base.system.oper.dao.OperLogDao;
import com.mortals.xhx.base.system.oper.model.OperLogEntity; import com.mortals.xhx.base.system.oper.model.OperLogEntity;
import com.mortals.xhx.base.system.oper.service.OperLogService; import com.mortals.xhx.base.system.oper.service.OperLogService;
import com.mortals.xhx.common.code.OperTypeEnum; import com.mortals.xhx.common.code.OperTypeEnum;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
...@@ -104,19 +103,13 @@ public class OperLogServiceImpl extends AbstractCRUDServiceImpl<OperLogDao,OperL ...@@ -104,19 +103,13 @@ public class OperLogServiceImpl extends AbstractCRUDServiceImpl<OperLogDao,OperL
OperLogEntity operLogEntity = new OperLogEntity(); OperLogEntity operLogEntity = new OperLogEntity();
operLogEntity.setIp(ip); operLogEntity.setIp(ip);
operLogEntity.setLogDate(new Date()); operLogEntity.setLogDate(new Date());
operLogEntity.setPlatformMark(GlobalSysInfo.getPropertyValue(SysConstains.PROP_PLATFORM_MARK)==null?"unknow":GlobalSysInfo.getPropertyValue(SysConstains.PROP_PLATFORM_MARK));
operLogEntity.setPlatformMark(GlobalSysInfo.getPropertyValue(SysConstains.PROP_PLATFORM_MARK));
//operLogEntity.setOperType(operType.getValue());
operLogEntity.setRequestUrl(requestUrl); operLogEntity.setRequestUrl(requestUrl);
operLogEntity.setLoginName(loginName); operLogEntity.setLoginName(loginName);
operLogEntity.setUserId(userId); operLogEntity.setUserId(userId);
operLogEntity.setUserName(userName); operLogEntity.setUserName(userName);
operLogEntity.setContent(content); operLogEntity.setContent(content);
save(operLogEntity, null); save(operLogEntity, null);
} }
private void formatterLogContent(OperLogEntity operLogEntity, String content, String id, OperTypeEnum operType) { private void formatterLogContent(OperLogEntity operLogEntity, String content, String id, OperTypeEnum operType) {
if (operType == OperTypeEnum.SAVE) { if (operType == OperTypeEnum.SAVE) {
......
/**
* 文件:OperLogController.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.oper.web; package com.mortals.xhx.base.system.oper.web;
...@@ -20,47 +27,35 @@ import java.util.Map; ...@@ -20,47 +27,35 @@ import java.util.Map;
* <p>Description: OperLogController </p> * <p>Description: OperLogController </p>
* <p>Copyright: Copyright &reg; </p> * <p>Copyright: Copyright &reg; </p>
* <p>Company: </p> * <p>Company: </p>
* @author *
* @author
* @version 1.0.0 * @version 1.0.0
*/ */
@RestController @RestController
@RequestMapping("oper/log") @RequestMapping("oper/log")
public class OperLogController extends BaseCRUDJsonBodyMappingController<OperLogService,OperLogEntity,Long> { public class OperLogController extends BaseCRUDJsonBodyMappingController<OperLogService, OperLogEntity, Long> {
public OperLogController(){ public OperLogController() {
super.setFormClass(OperLogForm.class); super.setModuleDesc("操作日志");
super.setModuleDesc("操作日志"); }
}
/** @Override
* @param model protected void init(Map<String, Object> model, Context context) {
* @param context Map<String, Object> status = new HashMap<String, Object>(1);
*/ // 返回日志类型
@Override status.put("operType", OperTypeEnum.getEnumMap());
protected void init(Map<String, Object> model, Context context) {
Map<String, Object> status = new HashMap<String, Object>(1); model.put(KEY_RESULT_DICT, status);
// 返回日志类型 }
status.put("operType", OperTypeEnum.getEnumMap());
@Override
model.put(KEY_RESULT_DICT, status); protected void doListBefore(OperLogEntity query, Map<String, Object> model, Context context) throws AppException {
super.init(model, context); query.setOrderColList(new ArrayList<OrderCol>() {
} {
add(new OrderCol("a.logDate", "desc"));
/** }
* @param query });
* @param model }
* @param context
* @throws AppException
*/
@Override
protected void doListBefore(OperLogEntity query, Map<String, Object> model, Context context) throws AppException {
super.doListBefore(query, model, context);
query.setOrderColList(new ArrayList<OrderCol>() {
{
add(new OrderCol("a.logDate", "desc"));
}
});
}
} }
\ No newline at end of file
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.param.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.param.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.param.dao.ParamDao; import com.mortals.xhx.base.system.param.dao.ParamDao;
import com.mortals.xhx.base.system.param.model.ParamEntity; import com.mortals.xhx.base.system.param.model.ParamEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
/**
* 文件:ParamEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.param.model; package com.mortals.xhx.base.system.param.model;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.framework.service.IParam; import com.mortals.framework.service.IParam;
import com.mortals.xhx.base.system.param.model.vo.ParamVo;
import java.util.Date; import lombok.Data;
/** /**
* <p>Title: 参数信息</p> * 参数信息业务实体对象
* <p>Description: ParamEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class ParamEntity extends ParamVo implements IParam {
public class ParamEntity extends BaseEntityLong implements IParam { private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1536307966363L;
/**
/** 参数名称 */ * 参数名称
private String name; */
private String name;
/** 一级组织,如:平台配置 */ /**
private String firstOrganize; * 一级组织,如:平台配置
*/
/** 二级组织,如:基础配置 */ private String firstOrganize;
private String secondOrganize; /**
* 二级组织,如:基础配置
/** 参数键,全局唯一 */ */
private String paramKey; private String secondOrganize;
/**
/** 参数值 */ * 参数键,全局唯一
private String paramValue; */
private String paramKey;
/** 参数有效状态,0:禁用,1:启用,默认1 */ /**
private Integer validStatus; * 参数值
*/
/** 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 */ private String paramValue;
private Integer modStatus; /**
* 参数有效状态(0.禁用,1.启用)
/** 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 */ */
private Integer displayType; private Integer validStatus;
/**
/** 备注 */ * 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
private String remark; */
private Integer modStatus;
/** 创建时间 */ /**
private Date createTime; * 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
*/
/** 创建用户ID */ private Integer displayType;
private Long createUserId; /**
* 备注
/** 创建用户名称 */ */
private String createUserName; private String remark;
/**
* 创建用户名称
public ParamEntity(){ */
private String createUserName;
} /**
/** * 创建用户名称
* 获取 参数名称 */
* @return name private String updateUserName;
*/ @Override
public String getName(){ public int hashCode() {
return this.name; return this.getId().hashCode();
} }
@Override
/** public boolean equals(Object obj) {
* 设置 参数名称 if (obj == null) return false;
* @param name if (obj instanceof ParamEntity) {
*/ ParamEntity tmp = (ParamEntity) obj;
public void setName(String name){ if (this.getId() == tmp.getId()) {
this.name = name; return true;
} }
}
/** return false;
* 获取 一级组织,如:平台配置 }
* @return firstOrganize
*/ public void initAttrValue(){
public String getFirstOrganize(){ this.name = "";
return this.firstOrganize; this.firstOrganize = "";
} this.secondOrganize = "";
this.paramKey = "";
/** this.paramValue = "";
* 设置 一级组织,如:平台配置 this.validStatus = 1;
* @param firstOrganize this.modStatus = 4;
*/ this.displayType = 0;
public void setFirstOrganize(String firstOrganize){ this.remark = "";
this.firstOrganize = firstOrganize; this.createUserName = "";
} this.updateUserName = "";
}
/**
* 获取 二级组织,如:基础配置
* @return secondOrganize
*/
public String getSecondOrganize(){
return this.secondOrganize;
}
/**
* 设置 二级组织,如:基础配置
* @param secondOrganize
*/
public void setSecondOrganize(String secondOrganize){
this.secondOrganize = secondOrganize;
}
/**
* 获取 参数键,全局唯一
* @return paramKey
*/
public String getParamKey(){
return this.paramKey;
}
/**
* 设置 参数键,全局唯一
* @param paramKey
*/
public void setParamKey(String paramKey){
this.paramKey = paramKey;
}
/**
* 获取 参数值
* @return paramValue
*/
public String getParamValue(){
return this.paramValue;
}
/**
* 设置 参数值
* @param paramValue
*/
public void setParamValue(String paramValue){
this.paramValue = paramValue;
}
/**
* 获取 参数有效状态,0:禁用,1:启用,默认1
* @return validStatus
*/
public Integer getValidStatus(){
return this.validStatus;
}
/**
* 设置 参数有效状态,0:禁用,1:启用,默认1
* @param validStatus
*/
public void setValidStatus(Integer validStatus){
this.validStatus = validStatus;
}
/**
* 获取 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4
* @return modStatus
*/
public Integer getModStatus(){
return this.modStatus;
}
/**
* 设置 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4
* @param modStatus
*/
public void setModStatus(Integer modStatus){
this.modStatus = modStatus;
}
/**
* 获取 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0
* @return displayType
*/
public Integer getDisplayType(){
return this.displayType;
}
/**
* 设置 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0
* @param displayType
*/
public void setDisplayType(Integer displayType){
this.displayType = displayType;
}
/**
* 获取 备注
* @return remark
*/
public String getRemark(){
return this.remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 创建时间
* @return createTime
*/
public Date getCreateTime(){
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
public void setCreateTime(Date createTime){
this.createTime = createTime;
}
/**
* 获取 创建用户ID
* @return createUserId
*/
public Long getCreateUserId(){
return this.createUserId;
}
/**
* 设置 创建用户ID
* @param createUserId
*/
public void setCreateUserId(Long createUserId){
this.createUserId = createUserId;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
public String getCreateUserName(){
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public void setCreateUserName(String createUserName){
this.createUserName = createUserName;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof ParamEntity) {
ParamEntity tmp = (ParamEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",firstOrganize:").append(getFirstOrganize())
.append(",secondOrganize:").append(getSecondOrganize())
.append(",paramKey:").append(getParamKey())
.append(",paramValue:").append(getParamValue())
.append(",validStatus:").append(getValidStatus())
.append(",modStatus:").append(getModStatus())
.append(",displayType:").append(getDisplayType())
.append(",remark:").append(getRemark())
.append(",createTime:").append(getCreateTime())
.append(",createUserId:").append(getCreateUserId())
.append(",createUserName:").append(getCreateUserName());
return sb.toString();
}
public void initAttrValue(){
this.name = null;
this.firstOrganize = null;
this.secondOrganize = null;
this.paramKey = null;
this.paramValue = null;
this.validStatus = 1;
this.modStatus = 4;
this.displayType = 0;
this.remark = null;
this.createTime = null;
this.createUserId = null;
this.createUserName = null;
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.param.model;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
@Data
public class ParamEntityExt extends BaseEntityLong {
/** 素材分组名称 */
private String pictureGroupName;
}
/**
* 文件:ParamQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.param.model; package com.mortals.xhx.base.system.param.model;
import java.util.List; import java.util.List;
/** /**
* <p>Title: 参数信息</p> * 参数信息业务查询对象
* <p>Description: ParamQuery </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 public class ParamQuery extends ParamEntity {
*/ /** 开始 序号,主键,自增长 */
public class ParamQuery extends ParamEntity{ private Long idStart;
private static final long serialVersionUID = 1536307966364L;
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 结束 序号,主键,自增长 */ /** 结束 序号,主键,自增长 */
private Long idEnd; private Long idEnd;
/** 增加 序号,主键,自增长 */ /** 增加 序号,主键,自增长 */
private Long idIncrement; private Long idIncrement;
/** 序号,主键,自增长 */ /** 序号,主键,自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 参数名称 */ /** 序号,主键,自增长排除列表 */
private List<String> nameList; private List <Long> idNotList;
/** 一级组织,如:平台配置 */ /** 参数名称 */
private List<String> firstOrganizeList; private List<String> nameList;
/** 二级组织,如:基础配置 */ /** 参数名称排除列表 */
private List<String> secondOrganizeList; private List <String> nameNotList;
/** 一级组织,如:平台配置 */
private List<String> firstOrganizeList;
/** 参数键,全局唯一 */ /** 一级组织,如:平台配置排除列表 */
private List<String> paramKeyList; private List <String> firstOrganizeNotList;
/** 二级组织,如:基础配置 */
private List<String> secondOrganizeList;
/** 参数值 */ /** 二级组织,如:基础配置排除列表 */
private List<String> paramValueList; private List <String> secondOrganizeNotList;
/** 参数键,全局唯一 */
private List<String> paramKeyList;
/** 开始 参数有效状态,0:禁用,1:启用,默认1 */ /** 参数键,全局唯一排除列表 */
private Integer validStatusStart; private List <String> paramKeyNotList;
/** 参数值 */
private List<String> paramValueList;
/** 结束 参数有效状态,0:禁用,1:启用,默认1 */ /** 参数值排除列表 */
private Integer validStatusEnd; private List <String> paramValueNotList;
/** 开始 参数有效状态(0.禁用,1.启用) */
private Integer validStatusStart;
/** 增加 参数有效状态,0:禁用,1:启用,默认1 */ /** 结束 参数有效状态(0.禁用,1.启用) */
private Integer validStatusIncrement; private Integer validStatusEnd;
/** 参数有效状态,0:禁用,1:启用,默认1 */ /** 增加 参数有效状态(0.禁用,1.启用) */
private List<Integer> validStatusList; private Integer validStatusIncrement;
/** 开始 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 */ /** 参数有效状态(0.禁用,1.启用)列表 */
private Integer modStatusStart; private List <Integer> validStatusList;
/** 结束 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 */ /** 参数有效状态(0.禁用,1.启用)排除列表 */
private Integer modStatusEnd; private List <Integer> validStatusNotList;
/** 增加 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 */ /** 开始 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除) */
private Integer modStatusIncrement; private Integer modStatusStart;
/** 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 */ /** 结束 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除) */
private List<Integer> modStatusList; private Integer modStatusEnd;
/** 开始 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 */ /** 增加 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除) */
private Integer displayTypeStart; private Integer modStatusIncrement;
/** 结束 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 */ /** 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)列表 */
private Integer displayTypeEnd; private List <Integer> modStatusList;
/** 增加 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 */ /** 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)排除列表 */
private Integer displayTypeIncrement; private List <Integer> modStatusNotList;
/** 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 */ /** 开始 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框) */
private List<Integer> displayTypeList; private Integer displayTypeStart;
/** 备注 */ /** 结束 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框) */
private List<String> remarkList; private Integer displayTypeEnd;
/** 开始 创建时间 */ /** 增加 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框) */
private String createTimeStart; private Integer displayTypeIncrement;
/** 结束 创建时间 */ /** 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)列表 */
private String createTimeEnd; private List <Integer> displayTypeList;
/** 开始 创建用户ID */ /** 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)排除列表 */
private Long createUserIdStart; private List <Integer> displayTypeNotList;
/** 结束 创建用户ID */ /** 备注 */
private Long createUserIdEnd; private List<String> remarkList;
/** 增加 创建用户ID */ /** 备注排除列表 */
private Long createUserIdIncrement; private List <String> remarkNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 创建用户ID */ /** 结束 创建用户 */
private List<Long> createUserIdList; private Long createUserIdEnd;
/** 创建用户名称 */ /** 增加 创建用户 */
private List<String> createUserNameList; private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
public ParamQuery(){ /** 创建用户排除列表 */
} private List <Long> createUserIdNotList;
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/** /** 创建用户名称 */
* 设置 开始 序号,主键,自增长 private List<String> createUserNameList;
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号,主键,自增长
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/** /** 创建用户名称排除列表 */
* 设置 结束 序号,主键,自增长 private List <String> createUserNameNotList;
* @param idEnd /** 开始 创建时间 */
*/ private String createTimeStart;
public void setIdEnd(Long idEnd){
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */
private List<String> updateUserNameList;
/** 创建用户名称排除列表 */
private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<ParamQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<ParamQuery> andConditionList;
public ParamQuery(){}
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 参数名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 参数名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 参数名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 参数名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 一级组织,如:平台配置
* @return firstOrganizeList
*/
public List<String> getFirstOrganizeList(){
return this.firstOrganizeList;
}
/**
* 设置 一级组织,如:平台配置
* @param firstOrganizeList
*/
public void setFirstOrganizeList(List<String> firstOrganizeList){
this.firstOrganizeList = firstOrganizeList;
}
/**
* 获取 一级组织,如:平台配置
* @return firstOrganizeNotList
*/
public List<String> getFirstOrganizeNotList(){
return this.firstOrganizeNotList;
}
/**
* 设置 一级组织,如:平台配置
* @param firstOrganizeNotList
*/
public void setFirstOrganizeNotList(List<String> firstOrganizeNotList){
this.firstOrganizeNotList = firstOrganizeNotList;
}
/**
* 获取 二级组织,如:基础配置
* @return secondOrganizeList
*/
public List<String> getSecondOrganizeList(){
return this.secondOrganizeList;
}
/**
* 设置 二级组织,如:基础配置
* @param secondOrganizeList
*/
public void setSecondOrganizeList(List<String> secondOrganizeList){
this.secondOrganizeList = secondOrganizeList;
}
/**
* 获取 二级组织,如:基础配置
* @return secondOrganizeNotList
*/
public List<String> getSecondOrganizeNotList(){
return this.secondOrganizeNotList;
}
/**
* 设置 二级组织,如:基础配置
* @param secondOrganizeNotList
*/
public void setSecondOrganizeNotList(List<String> secondOrganizeNotList){
this.secondOrganizeNotList = secondOrganizeNotList;
}
/**
* 获取 参数键,全局唯一
* @return paramKeyList
*/
public List<String> getParamKeyList(){
return this.paramKeyList;
}
/**
* 设置 参数键,全局唯一
* @param paramKeyList
*/
public void setParamKeyList(List<String> paramKeyList){
this.paramKeyList = paramKeyList;
}
/**
* 获取 参数键,全局唯一
* @return paramKeyNotList
*/
public List<String> getParamKeyNotList(){
return this.paramKeyNotList;
}
/**
* 设置 参数键,全局唯一
* @param paramKeyNotList
*/
public void setParamKeyNotList(List<String> paramKeyNotList){
this.paramKeyNotList = paramKeyNotList;
}
/**
* 获取 参数值
* @return paramValueList
*/
public List<String> getParamValueList(){
return this.paramValueList;
}
/**
* 设置 参数值
* @param paramValueList
*/
public void setParamValueList(List<String> paramValueList){
this.paramValueList = paramValueList;
}
/**
* 获取 参数值
* @return paramValueNotList
*/
public List<String> getParamValueNotList(){
return this.paramValueNotList;
}
/**
* 设置 参数值
* @param paramValueNotList
*/
public void setParamValueNotList(List<String> paramValueNotList){
this.paramValueNotList = paramValueNotList;
}
/**
* 获取 开始 参数有效状态(0.禁用,1.启用)
* @return validStatusStart
*/
public Integer getValidStatusStart(){
return this.validStatusStart;
}
/**
* 设置 开始 参数有效状态(0.禁用,1.启用)
* @param validStatusStart
*/
public void setValidStatusStart(Integer validStatusStart){
this.validStatusStart = validStatusStart;
}
/**
* 获取 结束 参数有效状态(0.禁用,1.启用)
* @return $validStatusEnd
*/
public Integer getValidStatusEnd(){
return this.validStatusEnd;
}
/**
* 设置 结束 参数有效状态(0.禁用,1.启用)
* @param validStatusEnd
*/
public void setValidStatusEnd(Integer validStatusEnd){
this.validStatusEnd = validStatusEnd;
}
/**
* 获取 增加 参数有效状态(0.禁用,1.启用)
* @return validStatusIncrement
*/
public Integer getValidStatusIncrement(){
return this.validStatusIncrement;
}
/**
* 设置 增加 参数有效状态(0.禁用,1.启用)
* @param validStatusIncrement
*/
public void setValidStatusIncrement(Integer validStatusIncrement){
this.validStatusIncrement = validStatusIncrement;
}
/**
* 获取 参数有效状态(0.禁用,1.启用)
* @return validStatusList
*/
public List<Integer> getValidStatusList(){
return this.validStatusList;
}
/**
* 设置 参数有效状态(0.禁用,1.启用)
* @param validStatusList
*/
public void setValidStatusList(List<Integer> validStatusList){
this.validStatusList = validStatusList;
}
/**
* 获取 参数有效状态(0.禁用,1.启用)
* @return validStatusNotList
*/
public List<Integer> getValidStatusNotList(){
return this.validStatusNotList;
}
/**
* 设置 参数有效状态(0.禁用,1.启用)
* @param validStatusNotList
*/
public void setValidStatusNotList(List<Integer> validStatusNotList){
this.validStatusNotList = validStatusNotList;
}
/**
* 获取 开始 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @return modStatusStart
*/
public Integer getModStatusStart(){
return this.modStatusStart;
}
/**
* 设置 开始 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusStart
*/
public void setModStatusStart(Integer modStatusStart){
this.modStatusStart = modStatusStart;
}
/**
* 获取 结束 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @return $modStatusEnd
*/
public Integer getModStatusEnd(){
return this.modStatusEnd;
}
/**
* 设置 结束 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusEnd
*/
public void setModStatusEnd(Integer modStatusEnd){
this.modStatusEnd = modStatusEnd;
}
/**
* 获取 增加 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @return modStatusIncrement
*/
public Integer getModStatusIncrement(){
return this.modStatusIncrement;
}
/**
* 设置 增加 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusIncrement
*/
public void setModStatusIncrement(Integer modStatusIncrement){
this.modStatusIncrement = modStatusIncrement;
}
/**
* 获取 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @return modStatusList
*/
public List<Integer> getModStatusList(){
return this.modStatusList;
}
/**
* 设置 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusList
*/
public void setModStatusList(List<Integer> modStatusList){
this.modStatusList = modStatusList;
}
/**
* 获取 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @return modStatusNotList
*/
public List<Integer> getModStatusNotList(){
return this.modStatusNotList;
}
/**
* 设置 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusNotList
*/
public void setModStatusNotList(List<Integer> modStatusNotList){
this.modStatusNotList = modStatusNotList;
}
/**
* 获取 开始 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @return displayTypeStart
*/
public Integer getDisplayTypeStart(){
return this.displayTypeStart;
}
/**
* 设置 开始 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeStart
*/
public void setDisplayTypeStart(Integer displayTypeStart){
this.displayTypeStart = displayTypeStart;
}
/**
* 获取 结束 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @return $displayTypeEnd
*/
public Integer getDisplayTypeEnd(){
return this.displayTypeEnd;
}
/**
* 设置 结束 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeEnd
*/
public void setDisplayTypeEnd(Integer displayTypeEnd){
this.displayTypeEnd = displayTypeEnd;
}
/**
* 获取 增加 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @return displayTypeIncrement
*/
public Integer getDisplayTypeIncrement(){
return this.displayTypeIncrement;
}
/**
* 设置 增加 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeIncrement
*/
public void setDisplayTypeIncrement(Integer displayTypeIncrement){
this.displayTypeIncrement = displayTypeIncrement;
}
/**
* 获取 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @return displayTypeList
*/
public List<Integer> getDisplayTypeList(){
return this.displayTypeList;
}
/**
* 设置 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeList
*/
public void setDisplayTypeList(List<Integer> displayTypeList){
this.displayTypeList = displayTypeList;
}
/**
* 获取 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @return displayTypeNotList
*/
public List<Integer> getDisplayTypeNotList(){
return this.displayTypeNotList;
}
/**
* 设置 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeNotList
*/
public void setDisplayTypeNotList(List<Integer> displayTypeNotList){
this.displayTypeNotList = displayTypeNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 获取 开始 创建时间
* @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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号,主键,自增长
* @param id
*/
public ParamQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public ParamQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public ParamQuery idEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} return this;
}
/**
* 获取 增加 序号,主键,自增长 /**
* @return idIncrement * 设置 增加 序号,主键,自增长
*/ * @param idIncrement
public Long getIdIncrement(){ */
return this.idIncrement; public ParamQuery idIncrement(Long idIncrement){
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} return this;
}
/**
* 获取 序号,主键,自增长 /**
* @return idList * 设置 序号,主键,自增长
*/ * @param idList
public List<Long> getIdList(){ */
return this.idList; public ParamQuery idList(List<Long> idList){
} this.idList = idList;
return this;
/** }
* 设置 序号,主键,自增长
* @param idList /**
*/ * 设置 序号,主键,自增长
public void setIdList(List<Long> idList){ * @param idNotList
this.idList = idList; */
} public ParamQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 获取 参数名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/** /**
* 设置 参数名称 * 设置 参数名称
* @param nameList * @param name
*/ */
public void setNameList(List<String> nameList){ public ParamQuery name(String name){
this.nameList = nameList; setName(name);
} return this;
}
/**
* 设置 参数名称
* @param nameList
*/
public ParamQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 获取 一级组织,如:平台配置
* @return firstOrganizeList
*/
public List<String> getFirstOrganizeList(){
return this.firstOrganizeList;
}
/** /**
* 设置 一级组织,如:平台配置 * 设置 一级组织,如:平台配置
* @param firstOrganizeList * @param firstOrganize
*/ */
public void setFirstOrganizeList(List<String> firstOrganizeList){ public ParamQuery firstOrganize(String firstOrganize){
this.firstOrganizeList = firstOrganizeList; setFirstOrganize(firstOrganize);
} return this;
}
/**
* 设置 一级组织,如:平台配置
* @param firstOrganizeList
*/
public ParamQuery firstOrganizeList(List<String> firstOrganizeList){
this.firstOrganizeList = firstOrganizeList;
return this;
}
/**
* 获取 二级组织,如:基础配置
* @return secondOrganizeList
*/
public List<String> getSecondOrganizeList(){
return this.secondOrganizeList;
}
/** /**
* 设置 二级组织,如:基础配置 * 设置 二级组织,如:基础配置
* @param secondOrganizeList * @param secondOrganize
*/ */
public void setSecondOrganizeList(List<String> secondOrganizeList){ public ParamQuery secondOrganize(String secondOrganize){
this.secondOrganizeList = secondOrganizeList; setSecondOrganize(secondOrganize);
} return this;
}
/**
* 设置 二级组织,如:基础配置
* @param secondOrganizeList
*/
public ParamQuery secondOrganizeList(List<String> secondOrganizeList){
this.secondOrganizeList = secondOrganizeList;
return this;
}
/**
* 获取 参数键,全局唯一
* @return paramKeyList
*/
public List<String> getParamKeyList(){
return this.paramKeyList;
}
/** /**
* 设置 参数键,全局唯一 * 设置 参数键,全局唯一
* @param paramKeyList * @param paramKey
*/ */
public void setParamKeyList(List<String> paramKeyList){ public ParamQuery paramKey(String paramKey){
this.paramKeyList = paramKeyList; setParamKey(paramKey);
} return this;
}
/**
* 设置 参数键,全局唯一
* @param paramKeyList
*/
public ParamQuery paramKeyList(List<String> paramKeyList){
this.paramKeyList = paramKeyList;
return this;
}
/**
* 获取 参数值
* @return paramValueList
*/
public List<String> getParamValueList(){
return this.paramValueList;
}
/** /**
* 设置 参数值 * 设置 参数值
* @param paramValueList * @param paramValue
*/ */
public void setParamValueList(List<String> paramValueList){ public ParamQuery paramValue(String paramValue){
this.paramValueList = paramValueList; setParamValue(paramValue);
} return this;
}
/**
* 获取 开始 参数有效状态,0:禁用,1:启用,默认1 /**
* @return validStatusStart * 设置 参数值
*/ * @param paramValueList
public Integer getValidStatusStart(){ */
return this.validStatusStart; public ParamQuery paramValueList(List<String> paramValueList){
} this.paramValueList = paramValueList;
return this;
/** }
* 设置 开始 参数有效状态,0:禁用,1:启用,默认1
* @param validStatusStart /**
*/ * 设置 参数有效状态(0.禁用,1.启用)
public void setValidStatusStart(Integer validStatusStart){ * @param validStatus
*/
public ParamQuery validStatus(Integer validStatus){
setValidStatus(validStatus);
return this;
}
/**
* 设置 开始 参数有效状态(0.禁用,1.启用)
* @param validStatusStart
*/
public ParamQuery validStatusStart(Integer validStatusStart){
this.validStatusStart = validStatusStart; this.validStatusStart = validStatusStart;
} return this;
}
/**
* 获取 结束 参数有效状态,0:禁用,1:启用,默认1 /**
* @return validStatusEnd * 设置 结束 参数有效状态(0.禁用,1.启用)
*/ * @param validStatusEnd
public Integer getValidStatusEnd(){ */
return this.validStatusEnd; public ParamQuery validStatusEnd(Integer validStatusEnd){
}
/**
* 设置 结束 参数有效状态,0:禁用,1:启用,默认1
* @param validStatusEnd
*/
public void setValidStatusEnd(Integer validStatusEnd){
this.validStatusEnd = validStatusEnd; this.validStatusEnd = validStatusEnd;
} return this;
}
/**
* 获取 增加 参数有效状态,0:禁用,1:启用,默认1 /**
* @return validStatusIncrement * 设置 增加 参数有效状态(0.禁用,1.启用)
*/ * @param validStatusIncrement
public Integer getValidStatusIncrement(){ */
return this.validStatusIncrement; public ParamQuery validStatusIncrement(Integer validStatusIncrement){
}
/**
* 设置 增加 参数有效状态,0:禁用,1:启用,默认1
* @param validStatusIncrement
*/
public void setValidStatusIncrement(Integer validStatusIncrement){
this.validStatusIncrement = validStatusIncrement; this.validStatusIncrement = validStatusIncrement;
} return this;
}
/**
* 获取 参数有效状态,0:禁用,1:启用,默认1 /**
* @return validStatusList * 设置 参数有效状态(0.禁用,1.启用)
*/ * @param validStatusList
public List<Integer> getValidStatusList(){ */
return this.validStatusList; public ParamQuery validStatusList(List<Integer> validStatusList){
} this.validStatusList = validStatusList;
return this;
/** }
* 设置 参数有效状态,0:禁用,1:启用,默认1
* @param validStatusList /**
*/ * 设置 参数有效状态(0.禁用,1.启用)
public void setValidStatusList(List<Integer> validStatusList){ * @param validStatusNotList
this.validStatusList = validStatusList; */
} public ParamQuery validStatusNotList(List<Integer> validStatusNotList){
this.validStatusNotList = validStatusNotList;
/** return this;
* 获取 开始 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 }
* @return modStatusStart
*/ /**
public Integer getModStatusStart(){ * 设置 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
return this.modStatusStart; * @param modStatus
} */
public ParamQuery modStatus(Integer modStatus){
/** setModStatus(modStatus);
* 设置 开始 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 return this;
* @param modStatusStart }
*/
public void setModStatusStart(Integer modStatusStart){ /**
* 设置 开始 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
* @param modStatusStart
*/
public ParamQuery modStatusStart(Integer modStatusStart){
this.modStatusStart = modStatusStart; this.modStatusStart = modStatusStart;
} return this;
}
/**
* 获取 结束 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 /**
* @return modStatusEnd * 设置 结束 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
*/ * @param modStatusEnd
public Integer getModStatusEnd(){ */
return this.modStatusEnd; public ParamQuery modStatusEnd(Integer modStatusEnd){
}
/**
* 设置 结束 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4
* @param modStatusEnd
*/
public void setModStatusEnd(Integer modStatusEnd){
this.modStatusEnd = modStatusEnd; this.modStatusEnd = modStatusEnd;
} return this;
}
/**
* 获取 增加 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 /**
* @return modStatusIncrement * 设置 增加 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
*/ * @param modStatusIncrement
public Integer getModStatusIncrement(){ */
return this.modStatusIncrement; public ParamQuery modStatusIncrement(Integer modStatusIncrement){
}
/**
* 设置 增加 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4
* @param modStatusIncrement
*/
public void setModStatusIncrement(Integer modStatusIncrement){
this.modStatusIncrement = modStatusIncrement; this.modStatusIncrement = modStatusIncrement;
} return this;
}
/**
* 获取 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4 /**
* @return modStatusList * 设置 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
*/ * @param modStatusList
public List<Integer> getModStatusList(){ */
return this.modStatusList; public ParamQuery modStatusList(List<Integer> modStatusList){
} this.modStatusList = modStatusList;
return this;
/** }
* 设置 参数修改状态,0:隐藏,1:页面仅查看,2:页面可修改,3:页面可删除,4:页面可修改删除,默认4
* @param modStatusList /**
*/ * 设置 参数修改状态,(0.隐藏,1.页面仅查看,2.页面可修改,3.页面可删除,4.页面可修改删除)
public void setModStatusList(List<Integer> modStatusList){ * @param modStatusNotList
this.modStatusList = modStatusList; */
} public ParamQuery modStatusNotList(List<Integer> modStatusNotList){
this.modStatusNotList = modStatusNotList;
/** return this;
* 获取 开始 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 }
* @return displayTypeStart
*/ /**
public Integer getDisplayTypeStart(){ * 设置 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
return this.displayTypeStart; * @param displayType
} */
public ParamQuery displayType(Integer displayType){
/** setDisplayType(displayType);
* 设置 开始 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 return this;
* @param displayTypeStart }
*/
public void setDisplayTypeStart(Integer displayTypeStart){ /**
* 设置 开始 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
* @param displayTypeStart
*/
public ParamQuery displayTypeStart(Integer displayTypeStart){
this.displayTypeStart = displayTypeStart; this.displayTypeStart = displayTypeStart;
} return this;
}
/**
* 获取 结束 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 /**
* @return displayTypeEnd * 设置 结束 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
*/ * @param displayTypeEnd
public Integer getDisplayTypeEnd(){ */
return this.displayTypeEnd; public ParamQuery displayTypeEnd(Integer displayTypeEnd){
}
/**
* 设置 结束 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0
* @param displayTypeEnd
*/
public void setDisplayTypeEnd(Integer displayTypeEnd){
this.displayTypeEnd = displayTypeEnd; this.displayTypeEnd = displayTypeEnd;
} return this;
}
/**
* 获取 增加 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 /**
* @return displayTypeIncrement * 设置 增加 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
*/ * @param displayTypeIncrement
public Integer getDisplayTypeIncrement(){ */
return this.displayTypeIncrement; public ParamQuery displayTypeIncrement(Integer displayTypeIncrement){
}
/**
* 设置 增加 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0
* @param displayTypeIncrement
*/
public void setDisplayTypeIncrement(Integer displayTypeIncrement){
this.displayTypeIncrement = displayTypeIncrement; this.displayTypeIncrement = displayTypeIncrement;
} return this;
}
/**
* 获取 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0 /**
* @return displayTypeList * 设置 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
*/ * @param displayTypeList
public List<Integer> getDisplayTypeList(){ */
return this.displayTypeList; public ParamQuery displayTypeList(List<Integer> displayTypeList){
} this.displayTypeList = displayTypeList;
return this;
/** }
* 设置 展现类型,0:普通文本框,1:多行文本框,2:开关,3:块输入框,4:密码输入框,默认:0
* @param displayTypeList /**
*/ * 设置 展现类型 (0.普通文本框,1.多行文本框,2.开关,3.块输入框)
public void setDisplayTypeList(List<Integer> displayTypeList){ * @param displayTypeNotList
this.displayTypeList = displayTypeList; */
} public ParamQuery displayTypeNotList(List<Integer> displayTypeNotList){
this.displayTypeNotList = displayTypeNotList;
return this;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 开始 创建时间
* @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;
}
/**
* 获取 开始 创建用户ID
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/** /**
* 设置 开始 创建用户ID * 设置 备注
* @param createUserIdStart * @param remark
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public ParamQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public ParamQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public ParamQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public ParamQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart; this.createUserIdStart = createUserIdStart;
} return this;
}
/**
* 获取 结束 创建用户ID /**
* @return createUserIdEnd * 设置 结束 创建用户
*/ * @param createUserIdEnd
public Long getCreateUserIdEnd(){ */
return this.createUserIdEnd; public ParamQuery createUserIdEnd(Long createUserIdEnd){
}
/**
* 设置 结束 创建用户ID
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} return this;
}
/**
* 获取 增加 创建用户ID /**
* @return createUserIdIncrement * 设置 增加 创建用户
*/ * @param createUserIdIncrement
public Long getCreateUserIdIncrement(){ */
return this.createUserIdIncrement; public ParamQuery createUserIdIncrement(Long createUserIdIncrement){
}
/**
* 设置 增加 创建用户ID
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public ParamQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public ParamQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 获取 创建用户ID
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/** /**
* 设置 创建用户ID * 设置 创建用户名称
* @param createUserIdList * @param createUserName
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public ParamQuery createUserName(String createUserName){
this.createUserIdList = createUserIdList; setCreateUserName(createUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public ParamQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public ParamQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public ParamQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public ParamQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public ParamQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public ParamQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public ParamQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/** /**
* 设置 创建用户名称 * 设置 创建用户名称
* @param createUserNameList * @param updateUserName
*/ */
public void setCreateUserNameList(List<String> createUserNameList){ public ParamQuery updateUserName(String updateUserName){
this.createUserNameList = createUserNameList; setUpdateUserName(updateUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public ParamQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 获取 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<ParamQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<ParamQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<ParamQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<ParamQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.param.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
import java.util.List;
/**
* 参数信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class ParamVo extends BaseEntityLong {
/** 序号,主键,自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
...@@ -43,6 +43,12 @@ public interface ParamService extends ICRUDCacheService<ParamEntity, Long>, IPar ...@@ -43,6 +43,12 @@ public interface ParamService extends ICRUDCacheService<ParamEntity, Long>, IPar
* @return * @return
*/ */
Map<String, String> getParamBySecondOrganize(String firstOrganize,String secondOrganize, String... excludeParamKeys); Map<String, String> getParamBySecondOrganize(String firstOrganize,String secondOrganize, String... excludeParamKeys);
Map<String, String> getParamBySecondOrganizeOrder(String firstOrganize,String secondOrganize, String... excludeParamKeys);
/**
* 通过Key设置参数值 value
* @param key
* @param value
* @return
*/
void setValueByKey(String key,String value);
} }
\ No newline at end of file
...@@ -12,7 +12,10 @@ import com.mortals.xhx.base.system.param.model.ParamEntity; ...@@ -12,7 +12,10 @@ import com.mortals.xhx.base.system.param.model.ParamEntity;
import com.mortals.xhx.base.system.param.service.ParamService; import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.*; import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors; import java.util.stream.Collectors;
/** /**
...@@ -32,12 +35,6 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par ...@@ -32,12 +35,6 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par
return "ParamEntity.paramKey"; return "ParamEntity.paramKey";
} }
/**
* @param entity
* @param context
* @throws AppException
*/
@Override @Override
protected void saveBefore(ParamEntity entity, Context context) throws AppException { protected void saveBefore(ParamEntity entity, Context context) throws AppException {
//过滤换行符 //过滤换行符
...@@ -46,6 +43,8 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par ...@@ -46,6 +43,8 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par
super.saveBefore(entity, context); super.saveBefore(entity, context);
} }
@Override @Override
public String getValueByKey(String key) { public String getValueByKey(String key) {
List<ParamEntity> list = this.getCacheList(); List<ParamEntity> list = this.getCacheList();
...@@ -74,18 +73,6 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par ...@@ -74,18 +73,6 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par
} }
public Map<String, String> getParamBySecondOrganizeOrder(String firstOrganize, String secondOrganize, String... excludeParamKeys) {
List<ParamEntity> list = this.getCacheList();
return list.stream()
.filter(f -> firstOrganize.equals(f.getFirstOrganize()))
.filter(f -> secondOrganize.equals(f.getSecondOrganize()))
.filter(s ->
!Arrays.asList(excludeParamKeys).contains(s.getParamKey())
).sorted(Comparator.comparing(ParamEntity::getDisplayType)).collect(Collectors.toMap(x -> x.getParamKey(), y -> y.getParamValue(), (o, n) -> n, LinkedHashMap::new));
}
@Override @Override
public boolean needRefresh() { public boolean needRefresh() {
if (super.cacheService.isShareCache()) { if (super.cacheService.isShareCache()) {
...@@ -204,4 +191,29 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par ...@@ -204,4 +191,29 @@ public class ParamServiceImpl extends AbstractCRUDCacheServiceImpl<ParamDao, Par
} }
} }
@Override
public void setValueByKey(String key, String value) {
List<ParamEntity> list = this.getCacheList();
ParamEntity entity = null;
for(ParamEntity paramEntity:list){
if(key.equals(paramEntity.getParamKey())){
entity = paramEntity;
break;
}
}
if(entity!=null){
entity.setParamValue(String.valueOf(value));
this.update(entity);
}else {
entity = new ParamEntity();
entity.setParamValue(String.valueOf(value));
entity.setParamKey(key);
entity.setName("key");
entity.setCreateTime(new Date());
entity.setCreateUserId(1l);
entity.setCreateUserName("系统管理员");
this.save(entity);
}
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.param.web; package com.mortals.xhx.base.system.param.web;
import cn.hutool.core.net.Ipv4Util;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.IpUtils;
import com.mortals.framework.annotation.RepeatSubmit;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.code.PageDisplayType; import com.mortals.framework.common.code.PageDisplayType;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.util.FileUtil;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.model.ParamQuery;
import com.mortals.xhx.module.site.model.SiteQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.param.model.ParamEntity; import com.mortals.xhx.base.system.param.model.ParamEntity;
import com.mortals.xhx.base.system.param.service.ParamService; import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.common.code.DataSatusEnum; import com.mortals.xhx.common.code.DataSatusEnum;
import com.mortals.xhx.common.code.ModStatusEnum; import com.mortals.xhx.common.code.ModStatusEnum;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap; import java.util.HashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors;
import static com.mortals.xhx.common.key.Constant.PARAM_SERVER_HTTP_URL;
/** /**
* 参数信息 * 参数信息
...@@ -57,94 +38,6 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ ...@@ -57,94 +38,6 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ
model.put(KEY_RESULT_DICT, status); model.put(KEY_RESULT_DICT, status);
} }
/**
* @param query
* @param list
* @param context
* @throws AppException
*/
@Override
protected void doListAfter(ParamEntity query, List<ParamEntity> list, Context context) throws AppException {
super.doListAfter(query, list, context);
}
@RequestMapping(method = {RequestMethod.GET, RequestMethod.POST}, value = "key")
@UnAuth
public String getValueByKey(@RequestParam(name = "key") String key) {
JSONObject jsonObject = new JSONObject();
String busiDesc = "通过key查询参数值" + this.getModuleDesc();
try {
String value = this.service.getValueByKey(key);
jsonObject.put(KEY_RESULT_DATA, value);
recordSysLog(request, busiDesc + " 【成功】");
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
jsonObject.put(KEY_RESULT_MSG, busiDesc + "成功!");
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
@RequestMapping(method = {RequestMethod.GET, RequestMethod.POST}, value = "dict")
@UnAuth
public String getDict(@RequestParam(name = "first") String first, @RequestParam(name = "second") String second) {
JSONObject jsonObject = new JSONObject();
String busiDesc = "通过key查询字典参数值" + this.getModuleDesc();
try {
Map<String, String> dict = this.service.getParamBySecondOrganize(first, second);
// String value = this.service.getValueByKey(key);
jsonObject.put(KEY_RESULT_DATA, dict);
recordSysLog(request, busiDesc + " 【成功】");
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
jsonObject.put(KEY_RESULT_MSG, busiDesc + "成功!");
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
/**
* 更新终端访问服务器应用ip地址
*/
@GetMapping(value = "updateServerIp")
@UnAuth
public String updateServerip(String serverIp) {
JSONObject jsonObject = new JSONObject();
try {
//校验ip地址
boolean ipv4 = IpUtils.isIpv4(serverIp);
if (!ipv4) {
throw new AppException("请输入正确的ip地址");
}
ParamQuery paramQuery = new ParamQuery();
paramQuery.setParamKey(PARAM_SERVER_HTTP_URL);
ParamEntity paramEntity = this.service.selectOne(paramQuery);
if (!ObjectUtils.isEmpty(paramEntity)) {
//paramEntity.setParamValue(serverIp);
String value = "http://" + serverIp + ":11078";
paramEntity.setParamValue(value);
this.service.update(paramEntity);
}
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
jsonObject.put(KEY_RESULT_MSG, "更新终端访问服务端ip成功!");
} catch (Exception e) {
log.error("获取异常", e);
jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
}
return jsonObject.toJSONString();
}
private Map<String, Object> getPageDisplayType() { private Map<String, Object> getPageDisplayType() {
PageDisplayType[] pageDisplayTypes = PageDisplayType.values(); PageDisplayType[] pageDisplayTypes = PageDisplayType.values();
...@@ -155,11 +48,4 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ ...@@ -155,11 +48,4 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ
return result; return result;
} }
public static void main(String[] args) {
//FileUtil.delete("E:\\pic\\1.png");
System.out.println(IpUtils.isIpv4("10.102.252.13"));
}
} }
\ No newline at end of file
/**
* 文件:ParamForm.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.param.web;
import com.alibaba.fastjson.JSON;
import com.mortals.framework.web.BaseCRUDFormLong;
import com.mortals.xhx.base.system.param.model.ParamEntity;
import com.mortals.xhx.base.system.param.model.ParamQuery;
/**
* <p>Title: 参数信息</p>
* <p>Description: ParamForm </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
public class ParamForm extends BaseCRUDFormLong<ParamEntity> {
private ParamEntity entity = new ParamEntity();
private ParamQuery query = new ParamQuery();
public ParamForm(){
}
@Override
public ParamEntity getEntity() {
return entity;
}
public void setEntity(ParamEntity entity) {
this.entity = entity;
}
@Override
public ParamQuery getQuery() {
return query;
}
public void setQuery(ParamQuery query) {
this.query = query;
}
public static void main(String[] args) {
ParamForm form = new ParamForm();
String entityName =form.getEntity().getClass().getSimpleName();
System.out.println(entityName);
if ((entityName = entityName.substring(0, 1).toLowerCase() + entityName.substring(1, entityName.length())).endsWith("Entity")) {
entityName = entityName.substring(0, entityName.length() - "Entity".length());
}
System.out.println(entityName);
System.out.println(JSON.toJSONString(form));
}
}
\ No newline at end of file
/** /**
* 文件:ResourceDao.java * 文件:ResourceDao.java
* 版本:1.0.0 * 版本:1.0.0
* 日期: * 日期:
* Copyright &reg; * Copyright &reg;
* All right reserved. * All right reserved.
*/ */
package com.mortals.xhx.base.system.resource.dao; package com.mortals.xhx.base.system.resource.dao;
import com.mortals.framework.dao.ICRUDDao; import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.base.system.resource.model.ResourceEntity; import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import com.mortals.xhx.module.matter.model.MatterEntity;
import java.util.List; import java.util.List;
...@@ -20,13 +19,11 @@ import java.util.List; ...@@ -20,13 +19,11 @@ import java.util.List;
* <p>Description: ResourceDao DAO接口 </p> * <p>Description: ResourceDao DAO接口 </p>
* <p>Copyright: Copyright &reg; </p> * <p>Copyright: Copyright &reg; </p>
* <p>Company: </p> * <p>Company: </p>
* @author * @author
* @version 1.0.0 * @version 1.0.0
*/ */
public interface ResourceDao extends ICRUDDao<ResourceEntity, Long> { public interface ResourceDao extends ICRUDDao<ResourceEntity,Long> {
List<ResourceEntity> getListByUserId(Long userId); List<ResourceEntity> getListByUserId(Long userId);
List<ResourceEntity> getAll(int userType);
} }
\ No newline at end of file
...@@ -8,10 +8,8 @@ import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; ...@@ -8,10 +8,8 @@ import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.framework.model.ParamDto; import com.mortals.framework.model.ParamDto;
import com.mortals.xhx.base.system.resource.dao.ResourceDao; import com.mortals.xhx.base.system.resource.dao.ResourceDao;
import com.mortals.xhx.base.system.resource.model.ResourceEntity; import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
import java.util.HashMap;
import java.util.List; import java.util.List;
/** /**
...@@ -40,14 +38,5 @@ public class ResourceDaoImpl extends BaseCRUDDaoMybatis<ResourceEntity, Long> im ...@@ -40,14 +38,5 @@ public class ResourceDaoImpl extends BaseCRUDDaoMybatis<ResourceEntity, Long> im
return getSqlSession().selectList(getSqlId("getListByUserId"), param); return getSqlSession().selectList(getSqlId("getListByUserId"), param);
} }
@Override
public List<ResourceEntity> getAll(final int userType) {
return getSqlSession().selectList(getSqlId("getAllByUserType"), new HashMap<String, Object>() {
{
put("userType", userType);
}
});
}
} }
\ No newline at end of file
/**
* 文件:ResourceEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.resource.model; package com.mortals.xhx.base.system.resource.model;
import com.mortals.xhx.base.system.resource.model.vo.ResourceVo;
import java.util.Date; import lombok.Data;
import com.mortals.framework.model.BaseEntityLong;
/** /**
* <p>Title: 资源信息</p> * 资源信息业务实体对象
* <p>Description: ResourceEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class ResourceEntity extends ResourceVo {
public class ResourceEntity extends BaseEntityLong{ private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1547777703340L;
/**
/** 名称 */ * 名称
private String name; */
private String name;
/** 连接地址,多个地址以逗号分隔 */ /**
private String url; * 分组名称
*/
/** 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ private String groupName;
private Integer authType; /**
* 连接地址,多个地址以逗号分隔
/** 资源类型,0:系统资源,1:开放资源,默认0 */ */
private Integer sourceType; private String url;
/**
/** 创建时间 */ * 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
private Date createTime; */
private Integer authType;
/** 创建用户 */ /**
private Long createUserId; * 资源类型,(0.系统资源,1.开放资源)
*/
/** 创建用户名称 */ private Integer sourceType;
private String createUserName; /**
* 创建用户名称
/** 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ */
private Integer userType; private String createUserName;
/**
* 创建用户名称
public ResourceEntity(){ */
private String updateUserName;
} @Override
/** public int hashCode() {
* 获取 名称 return this.getId().hashCode();
* @return name }
*/ @Override
public String getName(){ public boolean equals(Object obj) {
return this.name; if (obj == null) return false;
} if (obj instanceof ResourceEntity) {
ResourceEntity tmp = (ResourceEntity) obj;
/** if (this.getId() == tmp.getId()) {
* 设置 名称 return true;
* @param name }
*/ }
public void setName(String name){ return false;
this.name = name; }
}
public void initAttrValue(){
/** this.name = "";
* 获取 连接地址,多个地址以逗号分隔 this.groupName = "";
* @return url this.url = "";
*/ this.authType = 3;
public String getUrl(){ this.sourceType = 0;
return this.url; this.createUserName = "";
} this.updateUserName = "";
}
/**
* 设置 连接地址,多个地址以逗号分隔
* @param url
*/
public void setUrl(String url){
this.url = url;
}
/**
* 获取 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @return authType
*/
public Integer getAuthType(){
return this.authType;
}
/**
* 设置 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authType
*/
public void setAuthType(Integer authType){
this.authType = authType;
}
/**
* 获取 资源类型,0:系统资源,1:开放资源,默认0
* @return sourceType
*/
public Integer getSourceType(){
return this.sourceType;
}
/**
* 设置 资源类型,0:系统资源,1:开放资源,默认0
* @param sourceType
*/
public void setSourceType(Integer sourceType){
this.sourceType = sourceType;
}
/**
* 获取 创建时间
* @return createTime
*/
public Date getCreateTime(){
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
public void setCreateTime(Date createTime){
this.createTime = createTime;
}
/**
* 获取 创建用户
* @return createUserId
*/
public Long getCreateUserId(){
return this.createUserId;
}
/**
* 设置 创建用户
* @param createUserId
*/
public void setCreateUserId(Long createUserId){
this.createUserId = createUserId;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
public String getCreateUserName(){
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public void setCreateUserName(String createUserName){
this.createUserName = createUserName;
}
/**
* 获取 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userType
*/
public Integer getUserType(){
return this.userType;
}
/**
* 设置 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @param userType
*/
public void setUserType(Integer userType){
this.userType = userType;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof ResourceEntity) {
ResourceEntity tmp = (ResourceEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",url:").append(getUrl())
.append(",authType:").append(getAuthType())
.append(",sourceType:").append(getSourceType())
.append(",createTime:").append(getCreateTime())
.append(",createUserId:").append(getCreateUserId())
.append(",createUserName:").append(getCreateUserName())
.append(",userType:").append(getUserType());
return sb.toString();
}
public void initAttrValue(){
this.name = null;
this.url = null;
this.authType = 3;
this.sourceType = 0;
this.createTime = null;
this.createUserId = null;
this.createUserName = null;
this.userType = null;
}
} }
\ No newline at end of file
/**
* 文件:ResourceQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.resource.model; package com.mortals.xhx.base.system.resource.model;
import java.util.List; import java.util.List;
/** /**
* <p>Title: 资源信息</p> * 资源信息业务查询对象
* <p>Description: ResourceQuery </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0
*/
public class ResourceQuery extends ResourceEntity { public class ResourceQuery extends ResourceEntity {
private static final long serialVersionUID = 1547777703341L; /** 开始 菜单ID,主键,自增长 */
/** 开始 菜单ID,主键,自增长 */ private Long idStart;
private Long idStart;
/** 结束 菜单ID,主键,自增长 */ /** 结束 菜单ID,主键,自增长 */
private Long idEnd; private Long idEnd;
/** 增加 菜单ID,主键,自增长 */ /** 增加 菜单ID,主键,自增长 */
private Long idIncrement; private Long idIncrement;
/** 菜单ID,主键,自增长 */ /** 菜单ID,主键,自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 名称 */ /** 菜单ID,主键,自增长排除列表 */
private List<String> nameList; private List <Long> idNotList;
/** 连接地址,多个地址以逗号分隔 */ /** 名称 */
private List<String> urlList; private List<String> nameList;
/** 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 名称排除列表 */
private Integer authTypeStart; private List <String> nameNotList;
/** 分组名称 */
private List<String> groupNameList;
/** 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 分组名称排除列表 */
private Integer authTypeEnd; private List <String> groupNameNotList;
/** 连接地址,多个地址以逗号分隔 */
private List<String> urlList;
/** 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 连接地址,多个地址以逗号分隔排除列表 */
private Integer authTypeIncrement; private List <String> urlNotList;
/** 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private Integer authTypeStart;
/** 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 */ /** 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private List<Integer> authTypeList; private Integer authTypeEnd;
/** 开始 资源类型,0:系统资源,1:开放资源,默认0 */ /** 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看) */
private Integer sourceTypeStart; private Integer authTypeIncrement;
/** 结束 资源类型,0:系统资源,1:开放资源,默认0 */ /** 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)列表 */
private Integer sourceTypeEnd; private List <Integer> authTypeList;
/** 增加 资源类型,0:系统资源,1:开放资源,默认0 */ /** 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)排除列表 */
private Integer sourceTypeIncrement; private List <Integer> authTypeNotList;
/** 资源类型,0:系统资源,1:开放资源,默认0 */ /** 开始 资源类型,(0.系统资源,1.开放资源) */
private List<Integer> sourceTypeList; private Integer sourceTypeStart;
/** 开始 创建时间 */ /** 结束 资源类型,(0.系统资源,1.开放资源) */
private String createTimeStart; private Integer sourceTypeEnd;
/** 结束 创建时间 */ /** 增加 资源类型,(0.系统资源,1.开放资源) */
private String createTimeEnd; private Integer sourceTypeIncrement;
/** 开始 创建用户 */ /** 资源类型,(0.系统资源,1.开放资源)列表 */
private Long createUserIdStart; private List <Integer> sourceTypeList;
/** 结束 创建用户 */ /** 资源类型,(0.系统资源,1.开放资源)排除列表 */
private Long createUserIdEnd; private List <Integer> sourceTypeNotList;
/** 增加 创建用户 */ /** 开始 创建用户 */
private Long createUserIdIncrement; private Long createUserIdStart;
/** 创建用户 */ /** 结束 创建用户 */
private List<Long> createUserIdList; private Long createUserIdEnd;
/** 创建用户名称 */ /** 增加 创建用户 */
private List<String> createUserNameList; private Long createUserIdIncrement;
/** 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户列表 */
private Integer userTypeStart; private List <Long> createUserIdList;
/** 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户排除列表 */
private Integer userTypeEnd; private List <Long> createUserIdNotList;
/** 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户名称 */
private Integer userTypeIncrement; private List<String> createUserNameList;
/** 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户名称排除列表 */
private List<Integer> userTypeList; private List <String> createUserNameNotList;
/** 开始 创建时间 */
private String createTimeStart;
public ResourceQuery(){
} /** 结束 创建时间 */
/** private String createTimeEnd;
* 获取 开始 菜单ID,主键,自增长
* @return idStart /** 开始 更新用户 */
*/ private Long updateUserIdStart;
public Long getIdStart(){
return this.idStart; /** 结束 更新用户 */
} private Long updateUserIdEnd;
/** /** 增加 更新用户 */
* 设置 开始 菜单ID,主键,自增长 private Long updateUserIdIncrement;
* @param idStart
*/ /** 更新用户列表 */
public void setIdStart(Long idStart){ private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */
private List<String> updateUserNameList;
/** 创建用户名称排除列表 */
private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<ResourceQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<ResourceQuery> andConditionList;
public ResourceQuery(){}
/**
* 获取 开始 菜单ID,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 菜单ID,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 菜单ID,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 菜单ID,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 菜单ID,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 菜单ID,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 菜单ID,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 菜单ID,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 菜单ID,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 菜单ID,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 分组名称
* @return groupNameList
*/
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取 分组名称
* @return groupNameNotList
*/
public List<String> getGroupNameNotList(){
return this.groupNameNotList;
}
/**
* 设置 分组名称
* @param groupNameNotList
*/
public void setGroupNameNotList(List<String> groupNameNotList){
this.groupNameNotList = groupNameNotList;
}
/**
* 获取 连接地址,多个地址以逗号分隔
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 连接地址,多个地址以逗号分隔
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 连接地址,多个地址以逗号分隔
* @return urlNotList
*/
public List<String> getUrlNotList(){
return this.urlNotList;
}
/**
* 设置 连接地址,多个地址以逗号分隔
* @param urlNotList
*/
public void setUrlNotList(List<String> urlNotList){
this.urlNotList = urlNotList;
}
/**
* 获取 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return $authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @return authTypeNotList
*/
public List<Integer> getAuthTypeNotList(){
return this.authTypeNotList;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeNotList
*/
public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
}
/**
* 获取 开始 资源类型,(0.系统资源,1.开放资源)
* @return sourceTypeStart
*/
public Integer getSourceTypeStart(){
return this.sourceTypeStart;
}
/**
* 设置 开始 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeStart
*/
public void setSourceTypeStart(Integer sourceTypeStart){
this.sourceTypeStart = sourceTypeStart;
}
/**
* 获取 结束 资源类型,(0.系统资源,1.开放资源)
* @return $sourceTypeEnd
*/
public Integer getSourceTypeEnd(){
return this.sourceTypeEnd;
}
/**
* 设置 结束 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeEnd
*/
public void setSourceTypeEnd(Integer sourceTypeEnd){
this.sourceTypeEnd = sourceTypeEnd;
}
/**
* 获取 增加 资源类型,(0.系统资源,1.开放资源)
* @return sourceTypeIncrement
*/
public Integer getSourceTypeIncrement(){
return this.sourceTypeIncrement;
}
/**
* 设置 增加 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeIncrement
*/
public void setSourceTypeIncrement(Integer sourceTypeIncrement){
this.sourceTypeIncrement = sourceTypeIncrement;
}
/**
* 获取 资源类型,(0.系统资源,1.开放资源)
* @return sourceTypeList
*/
public List<Integer> getSourceTypeList(){
return this.sourceTypeList;
}
/**
* 设置 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeList
*/
public void setSourceTypeList(List<Integer> sourceTypeList){
this.sourceTypeList = sourceTypeList;
}
/**
* 获取 资源类型,(0.系统资源,1.开放资源)
* @return sourceTypeNotList
*/
public List<Integer> getSourceTypeNotList(){
return this.sourceTypeNotList;
}
/**
* 设置 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeNotList
*/
public void setSourceTypeNotList(List<Integer> sourceTypeNotList){
this.sourceTypeNotList = sourceTypeNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 获取 开始 创建时间
* @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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 菜单ID,主键,自增长
* @param id
*/
public ResourceQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 菜单ID,主键,自增长
* @param idStart
*/
public ResourceQuery idStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
} return this;
}
/**
* 获取 结束 菜单ID,主键,自增长 /**
* @return idEnd * 设置 结束 菜单ID,主键,自增长
*/ * @param idEnd
public Long getIdEnd(){ */
return this.idEnd; public ResourceQuery idEnd(Long idEnd){
}
/**
* 设置 结束 菜单ID,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} return this;
}
/**
* 获取 增加 菜单ID,主键,自增长 /**
* @return idIncrement * 设置 增加 菜单ID,主键,自增长
*/ * @param idIncrement
public Long getIdIncrement(){ */
return this.idIncrement; public ResourceQuery idIncrement(Long idIncrement){
}
/**
* 设置 增加 菜单ID,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} return this;
}
/**
* 获取 菜单ID,主键,自增长 /**
* @return idList * 设置 菜单ID,主键,自增长
*/ * @param idList
public List<Long> getIdList(){ */
return this.idList; public ResourceQuery idList(List<Long> idList){
} this.idList = idList;
return this;
}
/**
* 设置 菜单ID,主键,自增长
* @param idNotList
*/
public ResourceQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 菜单ID,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/** /**
* 获取 名称 * 设置 名称
* @return nameList * @param name
*/ */
public List<String> getNameList(){ public ResourceQuery name(String name){
return this.nameList; setName(name);
} return this;
}
/**
* 设置 名称
* @param nameList
*/
public ResourceQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/** /**
* 获取 连接地址,多个地址以逗号分隔 * 设置 分组名称
* @return urlList * @param groupName
*/ */
public List<String> getUrlList(){ public ResourceQuery groupName(String groupName){
return this.urlList; setGroupName(groupName);
} return this;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public ResourceQuery groupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
return this;
}
/**
* 设置 连接地址,多个地址以逗号分隔
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/** /**
* 获取 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 * 设置 连接地址,多个地址以逗号分隔
* @return authTypeStart * @param url
*/ */
public Integer getAuthTypeStart(){ public ResourceQuery url(String url){
return this.authTypeStart; setUrl(url);
} return this;
}
/**
* 设置 开始 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 /**
* @param authTypeStart * 设置 连接地址,多个地址以逗号分隔
*/ * @param urlList
public void setAuthTypeStart(Integer authTypeStart){ */
public ResourceQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
}
/**
* 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authType
*/
public ResourceQuery authType(Integer authType){
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
* @param authTypeStart
*/
public ResourceQuery authTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart; this.authTypeStart = authTypeStart;
} return this;
}
/**
* 获取 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 /**
* @return authTypeEnd * 设置 结束 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
*/ * @param authTypeEnd
public Integer getAuthTypeEnd(){ */
return this.authTypeEnd; public ResourceQuery authTypeEnd(Integer authTypeEnd){
}
/**
* 设置 结束 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd; this.authTypeEnd = authTypeEnd;
} return this;
}
/**
* 获取 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 /**
* @return authTypeIncrement * 设置 增加 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
*/ * @param authTypeIncrement
public Integer getAuthTypeIncrement(){ */
return this.authTypeIncrement; public ResourceQuery authTypeIncrement(Integer authTypeIncrement){
}
/**
* 设置 增加 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement; this.authTypeIncrement = authTypeIncrement;
} return this;
}
/**
* 获取 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3 /**
* @return authTypeList * 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
*/ * @param authTypeList
public List<Integer> getAuthTypeList(){ */
return this.authTypeList; public ResourceQuery authTypeList(List<Integer> authTypeList){
} this.authTypeList = authTypeList;
return this;
/** }
* 设置 权限类型,0:无限制,1:无需登录查看,2:需要登录查看,3:需要角色权限查看,默认3
* @param authTypeList /**
*/ * 设置 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)
public void setAuthTypeList(List<Integer> authTypeList){ * @param authTypeNotList
this.authTypeList = authTypeList; */
} public ResourceQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
/** return this;
* 获取 开始 资源类型,0:系统资源,1:开放资源,默认0 }
* @return sourceTypeStart
*/ /**
public Integer getSourceTypeStart(){ * 设置 资源类型,(0.系统资源,1.开放资源)
return this.sourceTypeStart; * @param sourceType
} */
public ResourceQuery sourceType(Integer sourceType){
/** setSourceType(sourceType);
* 设置 开始 资源类型,0:系统资源,1:开放资源,默认0 return this;
* @param sourceTypeStart }
*/
public void setSourceTypeStart(Integer sourceTypeStart){ /**
* 设置 开始 资源类型,(0.系统资源,1.开放资源)
* @param sourceTypeStart
*/
public ResourceQuery sourceTypeStart(Integer sourceTypeStart){
this.sourceTypeStart = sourceTypeStart; this.sourceTypeStart = sourceTypeStart;
} return this;
}
/**
* 获取 结束 资源类型,0:系统资源,1:开放资源,默认0 /**
* @return sourceTypeEnd * 设置 结束 资源类型,(0.系统资源,1.开放资源)
*/ * @param sourceTypeEnd
public Integer getSourceTypeEnd(){ */
return this.sourceTypeEnd; public ResourceQuery sourceTypeEnd(Integer sourceTypeEnd){
}
/**
* 设置 结束 资源类型,0:系统资源,1:开放资源,默认0
* @param sourceTypeEnd
*/
public void setSourceTypeEnd(Integer sourceTypeEnd){
this.sourceTypeEnd = sourceTypeEnd; this.sourceTypeEnd = sourceTypeEnd;
} return this;
}
/**
* 获取 增加 资源类型,0:系统资源,1:开放资源,默认0 /**
* @return sourceTypeIncrement * 设置 增加 资源类型,(0.系统资源,1.开放资源)
*/ * @param sourceTypeIncrement
public Integer getSourceTypeIncrement(){ */
return this.sourceTypeIncrement; public ResourceQuery sourceTypeIncrement(Integer sourceTypeIncrement){
}
/**
* 设置 增加 资源类型,0:系统资源,1:开放资源,默认0
* @param sourceTypeIncrement
*/
public void setSourceTypeIncrement(Integer sourceTypeIncrement){
this.sourceTypeIncrement = sourceTypeIncrement; this.sourceTypeIncrement = sourceTypeIncrement;
} return this;
}
/**
* 获取 资源类型,0:系统资源,1:开放资源,默认0 /**
* @return sourceTypeList * 设置 资源类型,(0.系统资源,1.开放资源)
*/ * @param sourceTypeList
public List<Integer> getSourceTypeList(){ */
return this.sourceTypeList; public ResourceQuery sourceTypeList(List<Integer> sourceTypeList){
} this.sourceTypeList = sourceTypeList;
return this;
/** }
* 设置 资源类型,0:系统资源,1:开放资源,默认0
* @param sourceTypeList /**
*/ * 设置 资源类型,(0.系统资源,1.开放资源)
public void setSourceTypeList(List<Integer> sourceTypeList){ * @param sourceTypeNotList
this.sourceTypeList = sourceTypeList; */
} public ResourceQuery sourceTypeNotList(List<Integer> sourceTypeNotList){
this.sourceTypeNotList = sourceTypeNotList;
/** return this;
* 获取 开始 创建时间 }
* @return createTimeStart
*/ /**
public String getCreateTimeStart(){ * 设置 创建用户
return this.createTimeStart; * @param createUserId
} */
public ResourceQuery createUserId(Long createUserId){
/** setCreateUserId(createUserId);
* 设置 开始 创建时间 return this;
* @param createTimeStart }
*/
public void setCreateTimeStart(String createTimeStart){ /**
this.createTimeStart = createTimeStart; * 设置 开始 创建用户
} * @param createUserIdStart
*/
/** public ResourceQuery createUserIdStart(Long createUserIdStart){
* 获取 结束 创建时间
* @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; this.createUserIdStart = createUserIdStart;
} return this;
}
/**
* 获取 结束 创建用户 /**
* @return createUserIdEnd * 设置 结束 创建用户
*/ * @param createUserIdEnd
public Long getCreateUserIdEnd(){ */
return this.createUserIdEnd; public ResourceQuery createUserIdEnd(Long createUserIdEnd){
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} return this;
}
/**
* 获取 增加 创建用户 /**
* @return createUserIdIncrement * 设置 增加 创建用户
*/ * @param createUserIdIncrement
public Long getCreateUserIdIncrement(){ */
return this.createUserIdIncrement; public ResourceQuery createUserIdIncrement(Long createUserIdIncrement){
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} return this;
}
/**
* 获取 创建用户 /**
* @return createUserIdList * 设置 创建用户
*/ * @param createUserIdList
public List<Long> getCreateUserIdList(){ */
return this.createUserIdList; public ResourceQuery createUserIdList(List<Long> createUserIdList){
} this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public ResourceQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/** /**
* 设置 创建用户名称 * 设置 创建用户名称
* @param createUserNameList * @param createUserName
*/ */
public void setCreateUserNameList(List<String> createUserNameList){ public ResourceQuery createUserName(String createUserName){
this.createUserNameList = createUserNameList; setCreateUserName(createUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public ResourceQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public ResourceQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public ResourceQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public ResourceQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public ResourceQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public ResourceQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public ResourceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeStart
*/
public Integer getUserTypeStart(){
return this.userTypeStart;
}
/**
* 设置 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @param userTypeStart
*/
public void setUserTypeStart(Integer userTypeStart){
this.userTypeStart = userTypeStart;
}
/** /**
* 获取 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 * 设置 创建用户名称
* @return userTypeEnd * @param updateUserName
*/ */
public Integer getUserTypeEnd(){ public ResourceQuery updateUserName(String updateUserName){
return this.userTypeEnd; setUpdateUserName(updateUserName);
} return this;
}
/**
* 设置 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 /**
* @param userTypeEnd * 设置 创建用户名称
*/ * @param updateUserNameList
public void setUserTypeEnd(Integer userTypeEnd){ */
this.userTypeEnd = userTypeEnd; public ResourceQuery updateUserNameList(List<String> updateUserNameList){
} this.updateUserNameList = updateUserNameList;
return this;
/** }
* 获取 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeIncrement
*/ /**
public Integer getUserTypeIncrement(){ * 获取 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
return this.userTypeIncrement; * @return orConditionList
} */
public List<ResourceQuery> getOrConditionList(){
/** return this.orConditionList;
* 设置 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 }
* @param userTypeIncrement
*/ /**
public void setUserTypeIncrement(Integer userTypeIncrement){ * 设置 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
this.userTypeIncrement = userTypeIncrement; * @param orConditionList
} */
public void setOrConditionList(List<ResourceQuery> orConditionList){
/** this.orConditionList = orConditionList;
* 获取 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 }
* @return userTypeList
*/ /**
public List<Integer> getUserTypeList(){ * 获取 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
return this.userTypeList; * @return andConditionList
} */
public List<ResourceQuery> getAndConditionList(){
/** return this.andConditionList;
* 设置 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 }
* @param userTypeList
*/ /**
public void setUserTypeList(List<Integer> userTypeList){ * 设置 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
this.userTypeList = userTypeList; * @param andConditionList
} */
public void setAndConditionList(List<ResourceQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.resource.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
import java.util.List;
/**
* 资源信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class ResourceVo extends BaseEntityLong {
/** 菜单ID,主键,自增长列表 */
private List <Long> idList;
private Integer checked=0;
private Long roleId;
}
\ No newline at end of file
...@@ -16,6 +16,7 @@ import com.mortals.framework.service.ICRUDService; ...@@ -16,6 +16,7 @@ import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.base.system.resource.model.ResourceEntity; import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Set; import java.util.Set;
/** /**
...@@ -28,12 +29,6 @@ import java.util.Set; ...@@ -28,12 +29,6 @@ import java.util.Set;
*/ */
public interface ResourceService extends ICRUDService<ResourceEntity,Long> { public interface ResourceService extends ICRUDService<ResourceEntity,Long> {
/**
* 查询所有可用资源
* @return
* @throws AppException
*/
List<ResourceEntity> findAllEnable() throws AppException;
/** /**
* 根据用户查询可用资源 * 根据用户查询可用资源
...@@ -43,13 +38,6 @@ public interface ResourceService extends ICRUDService<ResourceEntity,Long> { ...@@ -43,13 +38,6 @@ public interface ResourceService extends ICRUDService<ResourceEntity,Long> {
*/ */
List<ResourceEntity> findListByUserId(Long userId) throws AppException; List<ResourceEntity> findListByUserId(Long userId) throws AppException;
/**
* 查询用户可用资源
* @param userId
* @return 字符串,多个以逗号分隔
* @throws AppException
*/
String findUrlByUserId(Long userId) throws AppException;
/** /**
* 查询用户用资源集合 * 查询用户用资源集合
...@@ -59,14 +47,11 @@ public interface ResourceService extends ICRUDService<ResourceEntity,Long> { ...@@ -59,14 +47,11 @@ public interface ResourceService extends ICRUDService<ResourceEntity,Long> {
*/ */
Set<String> findUrlSetByUserId(Long userId) throws AppException; Set<String> findUrlSetByUserId(Long userId) throws AppException;
/**
* 获取所有资源,不分页
* @return
* @param userType
*/
List<ResourceEntity> findAll(int userType);
Rest<String> refreshResourceUrl(String packageName, Context context); Rest<String> refreshResourceUrl(String packageName, Context context);
Map<String, List<ResourceEntity>> group(Long roleId, Context context);
} }
\ No newline at end of file
...@@ -22,6 +22,7 @@ import com.mortals.xhx.base.system.resource.service.ResourceService; ...@@ -22,6 +22,7 @@ import com.mortals.xhx.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity; import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import com.mortals.xhx.base.system.role.model.RoleAuthQuery; import com.mortals.xhx.base.system.role.model.RoleAuthQuery;
import com.mortals.xhx.base.system.role.service.RoleAuthService; import com.mortals.xhx.base.system.role.service.RoleAuthService;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.key.RedisKey; import com.mortals.xhx.common.key.RedisKey;
import com.mortals.xhx.common.utils.ControllerScanUtil; import com.mortals.xhx.common.utils.ControllerScanUtil;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
...@@ -35,13 +36,10 @@ import java.util.stream.Collectors; ...@@ -35,13 +36,10 @@ import java.util.stream.Collectors;
import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode; import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode;
/** /**
* <p>Title: 资源信息</p> * 资源信息
* <p>Description: ResourceServiceImpl service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* *
* @author * @author: zxfei
* @version 1.0.0 * @date: 2024/9/6 16:08
*/ */
@Service("resourceService") @Service("resourceService")
public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, ResourceEntity, Long> implements ResourceService { public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, ResourceEntity, Long> implements ResourceService {
...@@ -53,22 +51,12 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re ...@@ -53,22 +51,12 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re
@Lazy @Lazy
private RoleAuthService roleAuthService; private RoleAuthService roleAuthService;
@Override
public List<ResourceEntity> findAllEnable() throws AppException {
ResourceQuery params = new ResourceQuery();
return dao.getList(params);
}
@Override @Override
public List<ResourceEntity> findListByUserId(Long userId) throws AppException { public List<ResourceEntity> findListByUserId(Long userId) throws AppException {
return dao.getListByUserId(userId); return dao.getListByUserId(userId);
} }
@Override
public String findUrlByUserId(Long userId) throws AppException {
Set<String> urls = this.findUrlSetByUserId(userId);
return StringUtils.converArray2Str(urls.toArray(new String[urls.size()]));
}
@Override @Override
public Set<String> findUrlSetByUserId(Long userId) throws AppException { public Set<String> findUrlSetByUserId(Long userId) throws AppException {
...@@ -79,85 +67,11 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re ...@@ -79,85 +67,11 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re
if (StringUtils.isEmpty(url)) { if (StringUtils.isEmpty(url)) {
continue; continue;
} }
url = url.replaceAll(",", ","); urls.add(url);
urls.addAll(StringUtils.converStr2Set(url));
} }
return urls; return urls;
} }
@Override
public List<ResourceEntity> findAll(int userType) {
return dao.getAll(userType);
}
@Override
public Rest<String> refreshResourceUrl(String packageName, Context context) {
List<Class<?>> classList = ControllerScanUtil.getAllClassByPackageName(packageName);
//System.out.println(classList); //获取到了所有的类
List<ResourceEntity> newResourcelist = ControllerScanUtil.getAnnotationInfo(classList).stream().filter(f->!ObjectUtils.isEmpty(f.getUrl())).collect(Collectors.toList());
Map<String, List<ResourceEntity>> localResourceMap = this.find(new ResourceQuery()).stream().collect(Collectors.groupingBy(x -> x.getName()));
Map<String, List<ResourceEntity>> newResourceMap = newResourcelist.stream().collect(Collectors.groupingBy(x -> x.getName()));
//更新 与新增 新加的;
newResourceMap.entrySet().forEach(item -> {
List<ResourceEntity> resourceEntities = item.getValue();
if (ObjectUtils.isEmpty(resourceEntities)) return;
if (resourceEntities.size() == 1) {
ResourceEntity resourceEntity = resourceEntities.get(0);
saveUpdateResourceEntity(context, localResourceMap, resourceEntity);
} else if (resourceEntities.size() > 1) {
//原始扫描 有多个资源列表针对一个名称的
for (ResourceEntity resourceEntity : resourceEntities) {
saveUpdateResourceEntity(context, localResourceMap, resourceEntity);
}
}
});
return Rest.ok();
}
private void saveUpdateResourceEntity(Context context, Map<String, List<ResourceEntity>> localResourceMap, ResourceEntity resourceEntity) {
//查找 本地是否已经存在了
List<ResourceEntity> tempResourceList = localResourceMap.getOrDefault(resourceEntity.getName(), new ArrayList<>());
if (tempResourceList.size() == 0) {
//新增 resource;
resourceEntity.setCreateUserId(this.getContextUserId(context));
resourceEntity.setCreateTime(new Date());
this.save(resourceEntity, context);
} else if (tempResourceList.size() == 1) {
//更新
ResourceEntity tempResource = tempResourceList.get(0);
Set<String> setUrl = Arrays.stream(resourceEntity.getUrl().split(",")).collect(Collectors.toSet());
Arrays.stream(tempResource.getUrl().split(",")).forEach(i -> {
setUrl.add(i);
});
tempResource.setUrl(setUrl.stream().collect(Collectors.joining(",")));
this.update(tempResource, context);
} else if (tempResourceList.size() > 1) {
//找到多个同名的 资源配置
for (ResourceEntity tempResource : tempResourceList) {
//模糊匹配到路径有一个存在的
Set<String> setUrl = Arrays.stream(resourceEntity.getUrl().split(",")).collect(Collectors.toSet());
String[] splitUrl = tempResource.getUrl().split(",");
Boolean bool = false;
for (int i = 0; i < splitUrl.length; i++) {
if (setUrl.contains(splitUrl[i])) {
bool = true;
break;
}
}
if (bool) {
//匹配到了,更新当前这个资源
Arrays.stream(tempResource.getUrl().split(",")).forEach(i -> {
setUrl.add(i);
});
tempResource.setUrl(setUrl.stream().collect(Collectors.joining(",")));
this.update(tempResource, context);
}
}
}
}
@Override @Override
protected void updateAfter(ResourceEntity entity, Context context) throws AppException { protected void updateAfter(ResourceEntity entity, Context context) throws AppException {
...@@ -192,4 +106,66 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re ...@@ -192,4 +106,66 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re
cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId, menuUrlCode); cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId, menuUrlCode);
} }
} }
@Override
public Rest<String> refreshResourceUrl(String packageName, Context context) {
List<Class<?>> classList = ControllerScanUtil.getAllClassByPackageName(packageName);
//System.out.println(classList); //获取到了所有的类
List<ResourceEntity> newResourcelist = ControllerScanUtil.getAnnotationInfo(classList).stream().filter(f -> !ObjectUtils.isEmpty(f.getUrl())).collect(Collectors.toList());
//资源路径进行判断更新
Map<String, List<ResourceEntity>> localResourceMap = this.find(new ResourceQuery()).stream().collect(Collectors.groupingBy(x -> x.getUrl()));
Map<String, List<ResourceEntity>> newResourceMap = newResourcelist.stream().collect(Collectors.groupingBy(x -> x.getUrl()));
//更新 与新增 新加的;
newResourceMap.entrySet().forEach(item -> {
List<ResourceEntity> resourceEntities = item.getValue();
if (ObjectUtils.isEmpty(resourceEntities)) return;
ResourceEntity resourceEntity = resourceEntities.get(0);
saveUpdateResourceEntity(context, localResourceMap, resourceEntity);
});
return Rest.ok();
}
@Override
public Map<String, List<ResourceEntity>> group(Long roleId, Context context) {
if (!ObjectUtils.isEmpty(roleId)) {
List<RoleAuthEntity> roleAuthEntities = roleAuthService.find(new RoleAuthQuery().roleId(roleId));
Set<Long> collect = roleAuthEntities.stream()
.filter(f -> f.getMenuId() == null)
.map(m -> m.getResourceId())
.collect(Collectors.toSet());
Map<String, List<ResourceEntity>> group = this.find(new ResourceQuery(), context).stream()
.map(m -> {
if (collect.contains(m.getId())) {
m.setChecked(YesNoEnum.YES.getValue());
}
return m;
})
.collect(Collectors.groupingBy(x -> x.getGroupName()));
return group;
}
Map<String, List<ResourceEntity>> group = this.find(new ResourceQuery(), context).stream()
.collect(Collectors.groupingBy(x -> x.getGroupName()));
return group;
}
private void saveUpdateResourceEntity(Context context, Map<String, List<ResourceEntity>> localResourceMap, ResourceEntity resourceEntity) {
//查找 本地是否已经存在了
List<ResourceEntity> tempResourceList = localResourceMap.getOrDefault(resourceEntity.getUrl(), new ArrayList<>());
if (tempResourceList.size() == 0) {
//新增 resource;
resourceEntity.setCreateUserId(this.getContextUserId(context));
resourceEntity.setCreateTime(new Date());
this.save(resourceEntity, context);
} else {
//更新
ResourceEntity tempResourceEntity = tempResourceList.get(0);
resourceEntity.setId(tempResourceEntity.getId());
resourceEntity.setUpdateUserId(this.getContextUserId(context));
resourceEntity.setUpdateTime(new Date());
this.update(resourceEntity, context);
}
}
} }
\ No newline at end of file
...@@ -8,18 +8,22 @@ import com.mortals.framework.common.Rest; ...@@ -8,18 +8,22 @@ import com.mortals.framework.common.Rest;
import com.mortals.framework.common.code.UserType; import com.mortals.framework.common.code.UserType;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.model.OrderCol;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.resource.model.ResourceEntity; 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.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.role.service.RoleAuthService;
import com.mortals.xhx.common.code.AuthType; import com.mortals.xhx.common.code.AuthType;
import com.mortals.xhx.common.code.SourceType; import com.mortals.xhx.common.code.SourceType;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
...@@ -33,6 +37,9 @@ import java.util.Map; ...@@ -33,6 +37,9 @@ import java.util.Map;
@RequestMapping("resource") @RequestMapping("resource")
public class ResourceController extends BaseCRUDJsonBodyMappingController<ResourceService, ResourceEntity, Long> { public class ResourceController extends BaseCRUDJsonBodyMappingController<ResourceService, ResourceEntity, Long> {
@Autowired
private RoleAuthService roleAuthService;
public ResourceController() { public ResourceController() {
super.setModuleDesc("资源信息"); super.setModuleDesc("资源信息");
} }
...@@ -50,24 +57,10 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour ...@@ -50,24 +57,10 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour
model.put(KEY_RESULT_DICT, statsus); model.put(KEY_RESULT_DICT, statsus);
} }
/**
* 获取所有资源
*
* @return
*/
@PostMapping("allResources")
public String allResources(int userType) {
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_MSG, "所有的customer以及user");
ret.put(KEY_RESULT_DATA, service.findAll(userType));
return ret.toJSONString();
}
@Override @Override
protected void doListBefore(ResourceEntity query, Map<String, Object> model, Context context) throws AppException { protected void doListBefore(ResourceEntity query, Map<String, Object> model, Context context) throws AppException {
query.setOrderColList(Arrays.asList(new OrderCol("sourceType")));
super.doListBefore(query, model, context); super.doListBefore(query, model, context);
} }
...@@ -90,4 +83,30 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour ...@@ -90,4 +83,30 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour
return rest; return rest;
} }
/**
* 分组显示
*/
@ApiOperation(value = "分组列表")
@PostMapping(value = "group")
@UnAuth
public String group(@RequestBody ResourceQuery query) {
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap<>();
String busiDesc = "查询" + this.getModuleDesc() + "子节点";
try {
Map<String, List<ResourceEntity>> group = this.service.group(query.getRoleId(), getContext());
model.put(KEY_RESULT_DATA, group);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_DATA, model);
recordSysLog(request, busiDesc + "【成功】");
} catch (Exception e) {
log.error("分组列表错误", e);
this.doException(request, busiDesc, model, e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, e.getMessage());
}
return ret.toJSONString();
}
} }
\ No newline at end of file
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.role.dao.RoleAuthDao; import com.mortals.xhx.base.system.role.dao.RoleAuthDao;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity; import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.role.dao.RoleDao; import com.mortals.xhx.base.system.role.dao.RoleDao;
import com.mortals.xhx.base.system.role.model.RoleEntity; import com.mortals.xhx.base.system.role.model.RoleEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.role.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.role.dao.RoleUserDao; import com.mortals.xhx.base.system.role.dao.RoleUserDao;
import com.mortals.xhx.base.system.role.model.RoleUserEntity; import com.mortals.xhx.base.system.role.model.RoleUserEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
/**
* 文件:RoleAuthEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import com.mortals.xhx.base.system.role.model.vo.RoleAuthVo;
import lombok.Data;
import com.mortals.framework.model.BaseEntityLong;
/** /**
* <p>Title: 角色资源权限</p> * 角色资源权限业务实体对象
* <p>Description: RoleAuthEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class RoleAuthEntity extends RoleAuthVo {
public class RoleAuthEntity extends BaseEntityLong{ private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1547777703348L;
/**
/** 角色ID */ * 角色ID
private Long roleId; */
private Long roleId;
/** 资源ID */ /**
private Long resourceId; * 菜单ID
*/
private Long menuId;
public RoleAuthEntity(){ /**
* 资源ID
} */
/** private Long resourceId;
* 获取 角色ID /**
* @return roleId * 创建用户名称
*/ */
public Long getRoleId(){ private String createUserName;
return this.roleId; /**
} * 创建用户名称
*/
/** private String updateUserName;
* 设置 角色ID @Override
* @param roleId public int hashCode() {
*/ return this.getId().hashCode();
public void setRoleId(Long roleId){ }
this.roleId = roleId; @Override
} public boolean equals(Object obj) {
if (obj == null) return false;
/** if (obj instanceof RoleAuthEntity) {
* 获取 资源ID RoleAuthEntity tmp = (RoleAuthEntity) obj;
* @return resourceId if (this.getId() == tmp.getId()) {
*/ return true;
public Long getResourceId(){ }
return this.resourceId; }
} return false;
}
/**
* 设置 资源ID public void initAttrValue(){
* @param resourceId this.roleId = null;
*/ this.menuId = null;
public void setResourceId(Long resourceId){ this.resourceId = null;
this.resourceId = resourceId; this.createUserName = "";
} this.updateUserName = "";
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof RoleAuthEntity) {
RoleAuthEntity tmp = (RoleAuthEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",roleId:").append(getRoleId())
.append(",resourceId:").append(getResourceId());
return sb.toString();
}
public void initAttrValue(){
this.roleId = null;
this.resourceId = null;
}
} }
\ No newline at end of file
/**
* 文件:RoleAuthQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import java.util.List; import java.util.List;
/** /**
* <p>Title: 角色资源权限</p> * 角色资源权限业务查询对象
* <p>Description: RoleAuthQuery </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 public class RoleAuthQuery extends RoleAuthEntity {
*/ /** 开始 序号,主键,自增长 */
public class RoleAuthQuery extends RoleAuthEntity{ private Long idStart;
private static final long serialVersionUID = 1547777703349L;
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 结束 序号,主键,自增长 */ /** 结束 序号,主键,自增长 */
private Long idEnd; private Long idEnd;
/** 增加 序号,主键,自增长 */ /** 增加 序号,主键,自增长 */
private Long idIncrement; private Long idIncrement;
/** 序号,主键,自增长 */ /** 序号,主键,自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 开始 角色ID */ /** 序号,主键,自增长排除列表 */
private Long roleIdStart; private List <Long> idNotList;
/** 结束 角色ID */ /** 开始 角色ID */
private Long roleIdEnd; private Long roleIdStart;
/** 增加 角色ID */ /** 结束 角色ID */
private Long roleIdIncrement; private Long roleIdEnd;
/** 角色ID */ /** 增加 角色ID */
private List<Long> roleIdList; private Long roleIdIncrement;
/** 开始 资源ID */ /** 角色ID列表 */
private Long resourceIdStart; private List <Long> roleIdList;
/** 结束 资源ID */ /** 角色ID排除列表 */
private Long resourceIdEnd; private List <Long> roleIdNotList;
/** 增加 资源ID */ /** 开始 菜单ID */
private Long resourceIdIncrement; private Long menuIdStart;
/** 资源ID */ /** 结束 菜单ID */
private List<Long> resourceIdList; private Long menuIdEnd;
/** 增加 菜单ID */
private Long menuIdIncrement;
public RoleAuthQuery(){ /** 菜单ID列表 */
} private List <Long> menuIdList;
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/** /** 菜单ID排除列表 */
* 设置 开始 序号,主键,自增长 private List <Long> menuIdNotList;
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/** /** 开始 资源ID */
* 获取 结束 序号,主键,自增长 private Long resourceIdStart;
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/** /** 结束 资源ID */
* 设置 结束 序号,主键,自增长 private Long resourceIdEnd;
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/** /** 增加 资源ID */
* 获取 增加 序号,主键,自增长 private Long resourceIdIncrement;
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/** /** 资源ID列表 */
* 设置 增加 序号,主键,自增长 private List <Long> resourceIdList;
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/** /** 资源ID排除列表 */
* 获取 序号,主键,自增长 private List <Long> resourceIdNotList;
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/** /** 开始 创建用户 */
* 设置 序号,主键,自增长 private Long createUserIdStart;
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/** /** 结束 创建用户 */
* 获取 开始 角色ID private Long createUserIdEnd;
* @return roleIdStart
*/
public Long getRoleIdStart(){
return this.roleIdStart;
}
/** /** 增加 创建用户 */
* 设置 开始 角色ID private Long createUserIdIncrement;
* @param roleIdStart
*/
public void setRoleIdStart(Long roleIdStart){
this.roleIdStart = roleIdStart;
}
/** /** 创建用户列表 */
* 获取 结束 角色ID private List <Long> createUserIdList;
* @return roleIdEnd
*/
public Long getRoleIdEnd(){
return this.roleIdEnd;
}
/** /** 创建用户排除列表 */
* 设置 结束 角色ID private List <Long> createUserIdNotList;
* @param roleIdEnd
*/
public void setRoleIdEnd(Long roleIdEnd){
this.roleIdEnd = roleIdEnd;
}
/** /** 创建用户名称 */
* 获取 增加 角色ID private List<String> createUserNameList;
* @return roleIdIncrement
*/
public Long getRoleIdIncrement(){
return this.roleIdIncrement;
}
/** /** 创建用户名称排除列表 */
* 设置 增加 角色ID private List <String> createUserNameNotList;
* @param roleIdIncrement /** 开始 创建时间 */
*/ private String createTimeStart;
public void setRoleIdIncrement(Long roleIdIncrement){
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */
private List<String> updateUserNameList;
/** 创建用户名称排除列表 */
private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<RoleAuthQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<RoleAuthQuery> andConditionList;
public RoleAuthQuery(){}
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 角色ID
* @return roleIdStart
*/
public Long getRoleIdStart(){
return this.roleIdStart;
}
/**
* 设置 开始 角色ID
* @param roleIdStart
*/
public void setRoleIdStart(Long roleIdStart){
this.roleIdStart = roleIdStart;
}
/**
* 获取 结束 角色ID
* @return $roleIdEnd
*/
public Long getRoleIdEnd(){
return this.roleIdEnd;
}
/**
* 设置 结束 角色ID
* @param roleIdEnd
*/
public void setRoleIdEnd(Long roleIdEnd){
this.roleIdEnd = roleIdEnd;
}
/**
* 获取 增加 角色ID
* @return roleIdIncrement
*/
public Long getRoleIdIncrement(){
return this.roleIdIncrement;
}
/**
* 设置 增加 角色ID
* @param roleIdIncrement
*/
public void setRoleIdIncrement(Long roleIdIncrement){
this.roleIdIncrement = roleIdIncrement;
}
/**
* 获取 角色ID
* @return roleIdList
*/
public List<Long> getRoleIdList(){
return this.roleIdList;
}
/**
* 设置 角色ID
* @param roleIdList
*/
public void setRoleIdList(List<Long> roleIdList){
this.roleIdList = roleIdList;
}
/**
* 获取 角色ID
* @return roleIdNotList
*/
public List<Long> getRoleIdNotList(){
return this.roleIdNotList;
}
/**
* 设置 角色ID
* @param roleIdNotList
*/
public void setRoleIdNotList(List<Long> roleIdNotList){
this.roleIdNotList = roleIdNotList;
}
/**
* 获取 开始 菜单ID
* @return menuIdStart
*/
public Long getMenuIdStart(){
return this.menuIdStart;
}
/**
* 设置 开始 菜单ID
* @param menuIdStart
*/
public void setMenuIdStart(Long menuIdStart){
this.menuIdStart = menuIdStart;
}
/**
* 获取 结束 菜单ID
* @return $menuIdEnd
*/
public Long getMenuIdEnd(){
return this.menuIdEnd;
}
/**
* 设置 结束 菜单ID
* @param menuIdEnd
*/
public void setMenuIdEnd(Long menuIdEnd){
this.menuIdEnd = menuIdEnd;
}
/**
* 获取 增加 菜单ID
* @return menuIdIncrement
*/
public Long getMenuIdIncrement(){
return this.menuIdIncrement;
}
/**
* 设置 增加 菜单ID
* @param menuIdIncrement
*/
public void setMenuIdIncrement(Long menuIdIncrement){
this.menuIdIncrement = menuIdIncrement;
}
/**
* 获取 菜单ID
* @return menuIdList
*/
public List<Long> getMenuIdList(){
return this.menuIdList;
}
/**
* 设置 菜单ID
* @param menuIdList
*/
public void setMenuIdList(List<Long> menuIdList){
this.menuIdList = menuIdList;
}
/**
* 获取 菜单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 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;
}
/**
* 获取 开始 创建时间
* @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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号,主键,自增长
* @param id
*/
public RoleAuthQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public RoleAuthQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public RoleAuthQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public RoleAuthQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public RoleAuthQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号,主键,自增长
* @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
*/
public RoleAuthQuery roleIdStart(Long roleIdStart){
this.roleIdStart = roleIdStart;
return this;
}
/**
* 设置 结束 角色ID
* @param roleIdEnd
*/
public RoleAuthQuery roleIdEnd(Long roleIdEnd){
this.roleIdEnd = roleIdEnd;
return this;
}
/**
* 设置 增加 角色ID
* @param roleIdIncrement
*/
public RoleAuthQuery roleIdIncrement(Long roleIdIncrement){
this.roleIdIncrement = roleIdIncrement; this.roleIdIncrement = roleIdIncrement;
} return this;
}
/** /**
* 获取 角色ID * 设置 角色ID
* @return roleIdList * @param roleIdList
*/ */
public List<Long> getRoleIdList(){ public RoleAuthQuery roleIdList(List<Long> roleIdList){
return this.roleIdList; this.roleIdList = roleIdList;
} return this;
}
/** /**
* 设置 角色ID * 设置 角色ID
* @param roleIdList * @param roleIdNotList
*/ */
public void setRoleIdList(List<Long> roleIdList){ public RoleAuthQuery roleIdNotList(List<Long> roleIdNotList){
this.roleIdList = roleIdList; this.roleIdNotList = roleIdNotList;
} return this;
}
/** /**
* 获取 开始 资源ID * 设置 菜单ID
* @return resourceIdStart * @param menuId
*/ */
public Long getResourceIdStart(){ public RoleAuthQuery menuId(Long menuId){
return this.resourceIdStart; setMenuId(menuId);
} return this;
}
/**
* 设置 开始 菜单ID
* @param menuIdStart
*/
public RoleAuthQuery menuIdStart(Long menuIdStart){
this.menuIdStart = menuIdStart;
return this;
}
/** /**
* 设置 开始 资源ID * 设置 结束 菜单ID
* @param resourceIdStart * @param menuIdEnd
*/ */
public void setResourceIdStart(Long resourceIdStart){ public RoleAuthQuery menuIdEnd(Long menuIdEnd){
this.resourceIdStart = resourceIdStart; this.menuIdEnd = menuIdEnd;
} return this;
}
/** /**
* 获取 结束 资源ID * 设置 增加 菜单ID
* @return resourceIdEnd * @param menuIdIncrement
*/ */
public Long getResourceIdEnd(){ public RoleAuthQuery menuIdIncrement(Long menuIdIncrement){
return this.resourceIdEnd; this.menuIdIncrement = menuIdIncrement;
} return this;
}
/** /**
* 设置 结束 资源ID * 设置 菜单ID
* @param resourceIdEnd * @param menuIdList
*/ */
public void setResourceIdEnd(Long resourceIdEnd){ public RoleAuthQuery menuIdList(List<Long> menuIdList){
this.resourceIdEnd = resourceIdEnd; this.menuIdList = menuIdList;
} return this;
}
/** /**
* 获取 增加 资源ID * 设置 菜单ID
* @return resourceIdIncrement * @param menuIdNotList
*/ */
public Long getResourceIdIncrement(){ public RoleAuthQuery menuIdNotList(List<Long> menuIdNotList){
return this.resourceIdIncrement; this.menuIdNotList = menuIdNotList;
} return this;
}
/** /**
* 设置 增加 资源ID * 设置 资源ID
* @param resourceIdIncrement * @param resourceId
*/ */
public void setResourceIdIncrement(Long resourceIdIncrement){ 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; 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;
}
/** /**
* 获取 资源ID * 设置 创建用户名称
* @return resourceIdList * @param createUserName
*/ */
public List<Long> getResourceIdList(){ public RoleAuthQuery createUserName(String createUserName){
return this.resourceIdList; setCreateUserName(createUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public RoleAuthQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public RoleAuthQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public RoleAuthQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public RoleAuthQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public RoleAuthQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public RoleAuthQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public RoleAuthQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/** /**
* 设置 资源ID * 设置 创建用户名称
* @param resourceIdList * @param updateUserName
*/ */
public void setResourceIdList(List<Long> resourceIdList){ public RoleAuthQuery updateUserName(String updateUserName){
this.resourceIdList = resourceIdList; setUpdateUserName(updateUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public RoleAuthQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 获取 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;
}
/**
* 设置 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
*/
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
*/
public void setAndConditionList(List<RoleAuthQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
/**
* 文件:RoleEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import com.mortals.xhx.base.system.role.model.vo.RoleVo;
import java.util.Date; import lombok.Data;
import com.mortals.framework.model.BaseEntityLong;
/** /**
* <p>Title: 角色信息</p> * 角色信息业务实体对象
* <p>Description: RoleEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class RoleEntity extends RoleVo {
public class RoleEntity extends BaseEntityLong{ private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1547777703344L;
/**
* 角色名称
/** 用户ID */ */
private Long userId; private String name;
/**
/** 角色名称 */ * 备注
private String name; */
private String remark;
/** 备注 */ /**
private String remark; * 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
*/
/** 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 */ private Integer roleType;
private Integer roleType; /**
* 归属客户ID
/** 归属客户ID */ */
private Long customerId; private Long customerId;
/**
/** 创建时间 */ * 创建用户名称
private Date createTime; */
private String createUserName;
/** 创建用户 */ /**
private Long createUserId; * 创建用户名称
*/
/** 创建用户名称 */ private String updateUserName;
private String createUserName; @Override
public int hashCode() {
/** 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ return this.getId().hashCode();
private Integer userType; }
@Override
public boolean equals(Object obj) {
public RoleEntity(){ if (obj == null) return false;
if (obj instanceof RoleEntity) {
} RoleEntity tmp = (RoleEntity) obj;
/** if (this.getId() == tmp.getId()) {
* 获取 角色名称 return true;
* @return name }
*/ }
public String getName(){ return false;
return this.name; }
}
public void initAttrValue(){
/** this.name = "";
* 设置 角色名称 this.remark = "";
* @param name this.roleType = 2;
*/ this.customerId = null;
public void setName(String name){ this.createUserName = "";
this.name = name; this.updateUserName = "";
} }
/**
* 获取 备注
* @return remark
*/
public String getRemark(){
return this.remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
this.remark = remark;
}
/**
* 获取 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @return roleType
*/
public Integer getRoleType(){
return this.roleType;
}
/**
* 设置 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @param roleType
*/
public void setRoleType(Integer roleType){
this.roleType = roleType;
}
/**
* 获取 归属客户ID
* @return customerId
*/
public Long getCustomerId(){
return this.customerId;
}
/**
* 设置 归属客户ID
* @param customerId
*/
public void setCustomerId(Long customerId){
this.customerId = customerId;
}
/**
* 获取 创建时间
* @return createTime
*/
public Date getCreateTime(){
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
public void setCreateTime(Date createTime){
this.createTime = createTime;
}
/**
* 获取 创建用户
* @return createUserId
*/
public Long getCreateUserId(){
return this.createUserId;
}
/**
* 设置 创建用户
* @param createUserId
*/
public void setCreateUserId(Long createUserId){
this.createUserId = createUserId;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
public String getCreateUserName(){
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public void setCreateUserName(String createUserName){
this.createUserName = createUserName;
}
/**
* 获取 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userType
*/
public Integer getUserType(){
return this.userType;
}
/**
* 设置 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @param userType
*/
public void setUserType(Integer userType){
this.userType = userType;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof RoleEntity) {
RoleEntity tmp = (RoleEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",remark:").append(getRemark())
.append(",roleType:").append(getRoleType())
.append(",customerId:").append(getCustomerId())
.append(",createTime:").append(getCreateTime())
.append(",createUserId:").append(getCreateUserId())
.append(",createUserName:").append(getCreateUserName())
.append(",userType:").append(getUserType());
return sb.toString();
}
public void initAttrValue(){
this.name = null;
this.remark = null;
this.roleType = 2;
this.customerId = null;
this.createTime = null;
this.createUserId = null;
this.createUserName = null;
this.userType = null;
}
} }
\ No newline at end of file
/**
* 文件:RoleQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import java.util.List;
/**
* <p>Title: 角色信息</p>
* <p>Description: RoleQuery </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
public class RoleQuery extends RoleEntity{
private static final long serialVersionUID = 1547777703345L;
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 结束 序号,主键,自增长 */
private Long idEnd;
/** 增加 序号,主键,自增长 */
private Long idIncrement;
/** 序号,主键,自增长 */ import java.util.List;
private List<Long> idList;
/** 角色名称 */ /**
private List<String> nameList; * 角色信息业务查询对象
*
* @author zxfei
* @date 2024-09-06
*/
public class RoleQuery extends RoleEntity {
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 备注 */ /** 结束 序号,主键,自增长 */
private List<String> remarkList; private Long idEnd;
/** 开始 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 */ /** 增加 序号,主键,自增长 */
private Integer roleTypeStart; private Long idIncrement;
/** 结束 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 */ /** 序号,主键,自增长列表 */
private Integer roleTypeEnd; private List <Long> idList;
/** 增加 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 */ /** 序号,主键,自增长排除列表 */
private Integer roleTypeIncrement; private List <Long> idNotList;
/** 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 */ /** 角色名称 */
private List<Integer> roleTypeList; private List<String> nameList;
/** 开始 归属客户ID */ /** 角色名称排除列表 */
private Long customerIdStart; private List <String> nameNotList;
/** 备注 */
private List<String> remarkList;
/** 结束 归属客户ID */ /** 备注排除列表 */
private Long customerIdEnd; private List <String> remarkNotList;
/** 开始 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色) */
private Integer roleTypeStart;
/** 增加 归属客户ID */ /** 结束 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色) */
private Long customerIdIncrement; private Integer roleTypeEnd;
/** 归属客户ID */ /** 增加 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色) */
private List<Long> customerIdList; private Integer roleTypeIncrement;
/** 开始 创建时间 */ /** 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)列表 */
private String createTimeStart; private List <Integer> roleTypeList;
/** 结束 创建时间 */ /** 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)排除列表 */
private String createTimeEnd; private List <Integer> roleTypeNotList;
/** 开始 创建用户 */ /** 开始 归属客户ID */
private Long createUserIdStart; private Long customerIdStart;
/** 结束 创建用户 */ /** 结束 归属客户ID */
private Long createUserIdEnd; private Long customerIdEnd;
/** 增加 创建用户 */ /** 增加 归属客户ID */
private Long createUserIdIncrement; private Long customerIdIncrement;
/** 创建用户 */ /** 归属客户ID列表 */
private List<Long> createUserIdList; private List <Long> customerIdList;
/** 创建用户名称 */ /** 归属客户ID排除列表 */
private List<String> createUserNameList; private List <Long> customerIdNotList;
/** 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 开始 创建用户 */
private Integer userTypeStart; private Long createUserIdStart;
/** 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 结束 创建用户 */
private Integer userTypeEnd; private Long createUserIdEnd;
/** 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 增加 创建用户 */
private Integer userTypeIncrement; private Long createUserIdIncrement;
/** 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户列表 */
private List<Integer> userTypeList; private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
public RoleQuery(){ /** 创建用户名称 */
} private List<String> createUserNameList;
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/** /** 创建用户名称排除列表 */
* 设置 开始 序号,主键,自增长 private List <String> createUserNameNotList;
* @param idStart /** 开始 创建时间 */
*/ private String createTimeStart;
public void setIdStart(Long idStart){
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */
private List<String> updateUserNameList;
/** 创建用户名称排除列表 */
private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<RoleQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<RoleQuery> andConditionList;
public RoleQuery(){}
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 角色名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 角色名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 角色名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 角色名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @return roleTypeStart
*/
public Integer getRoleTypeStart(){
return this.roleTypeStart;
}
/**
* 设置 开始 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeStart
*/
public void setRoleTypeStart(Integer roleTypeStart){
this.roleTypeStart = roleTypeStart;
}
/**
* 获取 结束 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @return $roleTypeEnd
*/
public Integer getRoleTypeEnd(){
return this.roleTypeEnd;
}
/**
* 设置 结束 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeEnd
*/
public void setRoleTypeEnd(Integer roleTypeEnd){
this.roleTypeEnd = roleTypeEnd;
}
/**
* 获取 增加 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @return roleTypeIncrement
*/
public Integer getRoleTypeIncrement(){
return this.roleTypeIncrement;
}
/**
* 设置 增加 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeIncrement
*/
public void setRoleTypeIncrement(Integer roleTypeIncrement){
this.roleTypeIncrement = roleTypeIncrement;
}
/**
* 获取 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @return roleTypeList
*/
public List<Integer> getRoleTypeList(){
return this.roleTypeList;
}
/**
* 设置 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeList
*/
public void setRoleTypeList(List<Integer> roleTypeList){
this.roleTypeList = roleTypeList;
}
/**
* 获取 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @return roleTypeNotList
*/
public List<Integer> getRoleTypeNotList(){
return this.roleTypeNotList;
}
/**
* 设置 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeNotList
*/
public void setRoleTypeNotList(List<Integer> roleTypeNotList){
this.roleTypeNotList = roleTypeNotList;
}
/**
* 获取 开始 归属客户ID
* @return customerIdStart
*/
public Long getCustomerIdStart(){
return this.customerIdStart;
}
/**
* 设置 开始 归属客户ID
* @param customerIdStart
*/
public void setCustomerIdStart(Long customerIdStart){
this.customerIdStart = customerIdStart;
}
/**
* 获取 结束 归属客户ID
* @return $customerIdEnd
*/
public Long getCustomerIdEnd(){
return this.customerIdEnd;
}
/**
* 设置 结束 归属客户ID
* @param customerIdEnd
*/
public void setCustomerIdEnd(Long customerIdEnd){
this.customerIdEnd = customerIdEnd;
}
/**
* 获取 增加 归属客户ID
* @return customerIdIncrement
*/
public Long getCustomerIdIncrement(){
return this.customerIdIncrement;
}
/**
* 设置 增加 归属客户ID
* @param customerIdIncrement
*/
public void setCustomerIdIncrement(Long customerIdIncrement){
this.customerIdIncrement = customerIdIncrement;
}
/**
* 获取 归属客户ID
* @return customerIdList
*/
public List<Long> getCustomerIdList(){
return this.customerIdList;
}
/**
* 设置 归属客户ID
* @param customerIdList
*/
public void setCustomerIdList(List<Long> customerIdList){
this.customerIdList = customerIdList;
}
/**
* 获取 归属客户ID
* @return customerIdNotList
*/
public List<Long> getCustomerIdNotList(){
return this.customerIdNotList;
}
/**
* 设置 归属客户ID
* @param customerIdNotList
*/
public void setCustomerIdNotList(List<Long> customerIdNotList){
this.customerIdNotList = customerIdNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 获取 开始 创建时间
* @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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号,主键,自增长
* @param id
*/
public RoleQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public RoleQuery idStart(Long idStart){
this.idStart = idStart; this.idStart = idStart;
} return this;
}
/**
* 获取 结束 序号,主键,自增长 /**
* @return idEnd * 设置 结束 序号,主键,自增长
*/ * @param idEnd
public Long getIdEnd(){ */
return this.idEnd; public RoleQuery idEnd(Long idEnd){
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd; this.idEnd = idEnd;
} return this;
}
/**
* 获取 增加 序号,主键,自增长 /**
* @return idIncrement * 设置 增加 序号,主键,自增长
*/ * @param idIncrement
public Long getIdIncrement(){ */
return this.idIncrement; public RoleQuery idIncrement(Long idIncrement){
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement; this.idIncrement = idIncrement;
} return this;
}
/**
* 获取 序号,主键,自增长 /**
* @return idList * 设置 序号,主键,自增长
*/ * @param idList
public List<Long> getIdList(){ */
return this.idList; public RoleQuery idList(List<Long> idList){
} this.idList = idList;
return this;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public RoleQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/** /**
* 获取 角色名称 * 设置 角色名称
* @return nameList * @param name
*/ */
public List<String> getNameList(){ public RoleQuery name(String name){
return this.nameList; setName(name);
} return this;
}
/**
* 设置 角色名称
* @param nameList
*/
public RoleQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 角色名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/** /**
* 获取 备注 * 设置 备注
* @return remarkList * @param remark
*/ */
public List<String> getRemarkList(){ public RoleQuery remark(String remark){
return this.remarkList; setRemark(remark);
} return this;
}
/**
* 设置 备注 /**
* @param remarkList * 设置 备注
*/ * @param remarkList
public void setRemarkList(List<String> remarkList){ */
this.remarkList = remarkList; public RoleQuery remarkList(List<String> remarkList){
} this.remarkList = remarkList;
return this;
/** }
* 获取 开始 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @return roleTypeStart /**
*/ * 设置 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
public Integer getRoleTypeStart(){ * @param roleType
return this.roleTypeStart; */
} public RoleQuery roleType(Integer roleType){
setRoleType(roleType);
/** return this;
* 设置 开始 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 }
* @param roleTypeStart
*/ /**
public void setRoleTypeStart(Integer roleTypeStart){ * 设置 开始 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
* @param roleTypeStart
*/
public RoleQuery roleTypeStart(Integer roleTypeStart){
this.roleTypeStart = roleTypeStart; this.roleTypeStart = roleTypeStart;
} return this;
}
/**
* 获取 结束 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 /**
* @return roleTypeEnd * 设置 结束 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
*/ * @param roleTypeEnd
public Integer getRoleTypeEnd(){ */
return this.roleTypeEnd; public RoleQuery roleTypeEnd(Integer roleTypeEnd){
}
/**
* 设置 结束 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @param roleTypeEnd
*/
public void setRoleTypeEnd(Integer roleTypeEnd){
this.roleTypeEnd = roleTypeEnd; this.roleTypeEnd = roleTypeEnd;
} return this;
}
/**
* 获取 增加 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 /**
* @return roleTypeIncrement * 设置 增加 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
*/ * @param roleTypeIncrement
public Integer getRoleTypeIncrement(){ */
return this.roleTypeIncrement; public RoleQuery roleTypeIncrement(Integer roleTypeIncrement){
}
/**
* 设置 增加 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @param roleTypeIncrement
*/
public void setRoleTypeIncrement(Integer roleTypeIncrement){
this.roleTypeIncrement = roleTypeIncrement; this.roleTypeIncrement = roleTypeIncrement;
} return this;
}
/**
* 获取 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2 /**
* @return roleTypeList * 设置 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
*/ * @param roleTypeList
public List<Integer> getRoleTypeList(){ */
return this.roleTypeList; public RoleQuery roleTypeList(List<Integer> roleTypeList){
} this.roleTypeList = roleTypeList;
return this;
/** }
* 设置 角色类型,0:系统内置角色(不可删除),1:默认系统角色,2:普通角色,默认2
* @param roleTypeList /**
*/ * 设置 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)
public void setRoleTypeList(List<Integer> roleTypeList){ * @param roleTypeNotList
this.roleTypeList = roleTypeList; */
} public RoleQuery roleTypeNotList(List<Integer> roleTypeNotList){
this.roleTypeNotList = roleTypeNotList;
/** return this;
* 获取 开始 归属客户ID }
* @return customerIdStart
*/ /**
public Long getCustomerIdStart(){ * 设置 归属客户ID
return this.customerIdStart; * @param customerId
} */
public RoleQuery customerId(Long customerId){
/** setCustomerId(customerId);
* 设置 开始 归属客户ID return this;
* @param customerIdStart }
*/
public void setCustomerIdStart(Long customerIdStart){ /**
* 设置 开始 归属客户ID
* @param customerIdStart
*/
public RoleQuery customerIdStart(Long customerIdStart){
this.customerIdStart = customerIdStart; this.customerIdStart = customerIdStart;
} return this;
}
/**
* 获取 结束 归属客户ID /**
* @return customerIdEnd * 设置 结束 归属客户ID
*/ * @param customerIdEnd
public Long getCustomerIdEnd(){ */
return this.customerIdEnd; public RoleQuery customerIdEnd(Long customerIdEnd){
}
/**
* 设置 结束 归属客户ID
* @param customerIdEnd
*/
public void setCustomerIdEnd(Long customerIdEnd){
this.customerIdEnd = customerIdEnd; this.customerIdEnd = customerIdEnd;
} return this;
}
/**
* 获取 增加 归属客户ID /**
* @return customerIdIncrement * 设置 增加 归属客户ID
*/ * @param customerIdIncrement
public Long getCustomerIdIncrement(){ */
return this.customerIdIncrement; public RoleQuery customerIdIncrement(Long customerIdIncrement){
}
/**
* 设置 增加 归属客户ID
* @param customerIdIncrement
*/
public void setCustomerIdIncrement(Long customerIdIncrement){
this.customerIdIncrement = customerIdIncrement; this.customerIdIncrement = customerIdIncrement;
} return this;
}
/**
* 获取 归属客户ID /**
* @return customerIdList * 设置 归属客户ID
*/ * @param customerIdList
public List<Long> getCustomerIdList(){ */
return this.customerIdList; public RoleQuery customerIdList(List<Long> customerIdList){
} this.customerIdList = customerIdList;
return this;
/** }
* 设置 归属客户ID
* @param customerIdList /**
*/ * 设置 归属客户ID
public void setCustomerIdList(List<Long> customerIdList){ * @param customerIdNotList
this.customerIdList = customerIdList; */
} public RoleQuery customerIdNotList(List<Long> customerIdNotList){
this.customerIdNotList = customerIdNotList;
/** return this;
* 获取 开始 创建时间 }
* @return createTimeStart
*/ /**
public String getCreateTimeStart(){ * 设置 创建用户
return this.createTimeStart; * @param createUserId
} */
public RoleQuery createUserId(Long createUserId){
/** setCreateUserId(createUserId);
* 设置 开始 创建时间 return this;
* @param createTimeStart }
*/
public void setCreateTimeStart(String createTimeStart){ /**
this.createTimeStart = createTimeStart; * 设置 开始 创建用户
} * @param createUserIdStart
*/
/** public RoleQuery createUserIdStart(Long createUserIdStart){
* 获取 结束 创建时间
* @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; this.createUserIdStart = createUserIdStart;
} return this;
}
/**
* 获取 结束 创建用户 /**
* @return createUserIdEnd * 设置 结束 创建用户
*/ * @param createUserIdEnd
public Long getCreateUserIdEnd(){ */
return this.createUserIdEnd; public RoleQuery createUserIdEnd(Long createUserIdEnd){
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd; this.createUserIdEnd = createUserIdEnd;
} return this;
}
/**
* 获取 增加 创建用户 /**
* @return createUserIdIncrement * 设置 增加 创建用户
*/ * @param createUserIdIncrement
public Long getCreateUserIdIncrement(){ */
return this.createUserIdIncrement; public RoleQuery createUserIdIncrement(Long createUserIdIncrement){
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement; this.createUserIdIncrement = createUserIdIncrement;
} return this;
}
/**
* 获取 创建用户 /**
* @return createUserIdList * 设置 创建用户
*/ * @param createUserIdList
public List<Long> getCreateUserIdList(){ */
return this.createUserIdList; public RoleQuery createUserIdList(List<Long> createUserIdList){
} this.createUserIdList = createUserIdList;
return this;
/** }
* 设置 创建用户
* @param createUserIdList /**
*/ * 设置 创建用户
public void setCreateUserIdList(List<Long> createUserIdList){ * @param createUserIdNotList
this.createUserIdList = createUserIdList; */
} public RoleQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
/** return this;
* 获取 创建用户名称 }
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeStart
*/
public Integer getUserTypeStart(){
return this.userTypeStart;
}
/**
* 设置 开始 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @param userTypeStart
*/
public void setUserTypeStart(Integer userTypeStart){
this.userTypeStart = userTypeStart;
}
/**
* 获取 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeEnd
*/
public Integer getUserTypeEnd(){
return this.userTypeEnd;
}
/**
* 设置 结束 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @param userTypeEnd
*/
public void setUserTypeEnd(Integer userTypeEnd){
this.userTypeEnd = userTypeEnd;
}
/**
* 获取 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeIncrement
*/
public Integer getUserTypeIncrement(){
return this.userTypeIncrement;
}
/** /**
* 设置 增加 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 * 设置 创建用户名称
* @param userTypeIncrement * @param createUserName
*/ */
public void setUserTypeIncrement(Integer userTypeIncrement){ public RoleQuery createUserName(String createUserName){
this.userTypeIncrement = userTypeIncrement; setCreateUserName(createUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public RoleQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public RoleQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public RoleQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public RoleQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public RoleQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public RoleQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public RoleQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 用户类型,0:系统用户 1:代理商用户 2:品牌商用户
* @return userTypeList
*/
public List<Integer> getUserTypeList(){
return this.userTypeList;
}
/** /**
* 设置 用户类型,0:系统用户 1:代理商用户 2:品牌商用户 * 设置 创建用户名称
* @param userTypeList * @param updateUserName
*/ */
public void setUserTypeList(List<Integer> userTypeList){ public RoleQuery updateUserName(String updateUserName){
this.userTypeList = userTypeList; setUpdateUserName(updateUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public RoleQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 获取 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<RoleQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<RoleQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<RoleQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<RoleQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
/**
* 文件:RoleUserEntity.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import com.mortals.xhx.base.system.role.model.vo.RoleUserVo;
import lombok.Data;
import com.mortals.framework.model.BaseEntityLong;
/** /**
* <p>Title: 角色用户</p> * 角色用户业务实体对象
* <p>Description: RoleUserEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class RoleUserEntity extends RoleUserVo {
public class RoleUserEntity extends BaseEntityLong{ private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1547777703351L;
/**
/** 角色ID */ * 角色ID
private Long roleId; */
private Long roleId;
/** 用户ID */ /**
private Long userId; * 用户ID
*/
private Long userId;
public RoleUserEntity(){ /**
* 创建用户名称
} */
/** private String createUserName;
* 获取 角色ID /**
* @return roleId * 创建用户名称
*/ */
public Long getRoleId(){ private String updateUserName;
return this.roleId; @Override
} public int hashCode() {
return this.getId().hashCode();
/** }
* 设置 角色ID @Override
* @param roleId public boolean equals(Object obj) {
*/ if (obj == null) return false;
public void setRoleId(Long roleId){ if (obj instanceof RoleUserEntity) {
this.roleId = roleId; RoleUserEntity tmp = (RoleUserEntity) obj;
} if (this.getId() == tmp.getId()) {
return true;
/** }
* 获取 用户ID }
* @return userId return false;
*/ }
public Long getUserId(){
return this.userId; public void initAttrValue(){
} this.roleId = null;
this.userId = null;
/** this.createUserName = "";
* 设置 用户ID this.updateUserName = "";
* @param userId }
*/
public void setUserId(Long userId){
this.userId = userId;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof RoleUserEntity) {
RoleUserEntity tmp = (RoleUserEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",roleId:").append(getRoleId())
.append(",userId:").append(getUserId());
return sb.toString();
}
public void initAttrValue(){
this.roleId = null;
this.userId = null;
}
} }
\ No newline at end of file
/**
* 文件:RoleUserQuery.java
* 版本:1.0.0
* 日期:
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.role.model; package com.mortals.xhx.base.system.role.model;
import java.util.List; import java.util.List;
/**
* <p>Title: 角色用户</p>
* <p>Description: RoleUserQuery </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
public class RoleUserQuery extends RoleUserEntity{
private static final long serialVersionUID = 1547777703352L;
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 结束 序号,主键,自增长 */ /**
private Long idEnd; * 角色用户业务查询对象
*
* @author zxfei
* @date 2024-09-06
*/
public class RoleUserQuery extends RoleUserEntity {
/** 开始 序号,主键,自增长 */
private Long idStart;
/** 增加 序号,主键,自增长 */ /** 结束 序号,主键,自增长 */
private Long idIncrement; private Long idEnd;
/** 序号,主键,自增长 */ /** 增加 序号,主键,自增长 */
private List<Long> idList; private Long idIncrement;
/** 开始 角色ID */ /** 序号,主键,自增长列表 */
private Long roleIdStart; private List <Long> idList;
/** 结束 角色ID */ /** 序号,主键,自增长排除列表 */
private Long roleIdEnd; private List <Long> idNotList;
/** 增加 角色ID */ /** 开始 角色ID */
private Long roleIdIncrement; private Long roleIdStart;
/** 角色ID */ /** 结束 角色ID */
private List<Long> roleIdList; private Long roleIdEnd;
/** 开始 用户ID */ /** 增加 角色ID */
private Long userIdStart; private Long roleIdIncrement;
/** 结束 用户ID */ /** 角色ID列表 */
private Long userIdEnd; private List <Long> roleIdList;
/** 增加 用户ID */ /** 角色ID排除列表 */
private Long userIdIncrement; private List <Long> roleIdNotList;
/** 用户ID */ /** 开始 用户ID */
private List<Long> userIdList; private Long userIdStart;
/** 结束 用户ID */
private Long userIdEnd;
public RoleUserQuery(){ /** 增加 用户ID */
} private Long userIdIncrement;
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/** /** 用户ID列表 */
* 设置 开始 序号,主键,自增长 private List <Long> userIdList;
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/** /** 用户ID排除列表 */
* 获取 结束 序号,主键,自增长 private List <Long> userIdNotList;
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/** /** 开始 创建用户 */
* 设置 结束 序号,主键,自增长 private Long createUserIdStart;
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/** /** 结束 创建用户 */
* 获取 增加 序号,主键,自增长 private Long createUserIdEnd;
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/** /** 增加 创建用户 */
* 设置 增加 序号,主键,自增长 private Long createUserIdIncrement;
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/** /** 创建用户列表 */
* 获取 序号,主键,自增长 private List <Long> createUserIdList;
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/** /** 创建用户排除列表 */
* 设置 序号,主键,自增长 private List <Long> createUserIdNotList;
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/** /** 创建用户名称 */
* 获取 开始 角色ID private List<String> createUserNameList;
* @return roleIdStart
*/
public Long getRoleIdStart(){
return this.roleIdStart;
}
/** /** 创建用户名称排除列表 */
* 设置 开始 角色ID private List <String> createUserNameNotList;
* @param roleIdStart /** 开始 创建时间 */
*/ private String createTimeStart;
public void setRoleIdStart(Long roleIdStart){
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */
private List<String> updateUserNameList;
/** 创建用户名称排除列表 */
private List <String> updateUserNameNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<RoleUserQuery> orConditionList;
/** AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<RoleUserQuery> andConditionList;
public RoleUserQuery(){}
/**
* 获取 开始 序号,主键,自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号,主键,自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号,主键,自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号,主键,自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号,主键,自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 角色ID
* @return roleIdStart
*/
public Long getRoleIdStart(){
return this.roleIdStart;
}
/**
* 设置 开始 角色ID
* @param roleIdStart
*/
public void setRoleIdStart(Long roleIdStart){
this.roleIdStart = roleIdStart;
}
/**
* 获取 结束 角色ID
* @return $roleIdEnd
*/
public Long getRoleIdEnd(){
return this.roleIdEnd;
}
/**
* 设置 结束 角色ID
* @param roleIdEnd
*/
public void setRoleIdEnd(Long roleIdEnd){
this.roleIdEnd = roleIdEnd;
}
/**
* 获取 增加 角色ID
* @return roleIdIncrement
*/
public Long getRoleIdIncrement(){
return this.roleIdIncrement;
}
/**
* 设置 增加 角色ID
* @param roleIdIncrement
*/
public void setRoleIdIncrement(Long roleIdIncrement){
this.roleIdIncrement = roleIdIncrement;
}
/**
* 获取 角色ID
* @return roleIdList
*/
public List<Long> getRoleIdList(){
return this.roleIdList;
}
/**
* 设置 角色ID
* @param roleIdList
*/
public void setRoleIdList(List<Long> roleIdList){
this.roleIdList = roleIdList;
}
/**
* 获取 角色ID
* @return roleIdNotList
*/
public List<Long> getRoleIdNotList(){
return this.roleIdNotList;
}
/**
* 设置 角色ID
* @param roleIdNotList
*/
public void setRoleIdNotList(List<Long> roleIdNotList){
this.roleIdNotList = roleIdNotList;
}
/**
* 获取 开始 用户ID
* @return userIdStart
*/
public Long getUserIdStart(){
return this.userIdStart;
}
/**
* 设置 开始 用户ID
* @param userIdStart
*/
public void setUserIdStart(Long userIdStart){
this.userIdStart = userIdStart;
}
/**
* 获取 结束 用户ID
* @return $userIdEnd
*/
public Long getUserIdEnd(){
return this.userIdEnd;
}
/**
* 设置 结束 用户ID
* @param userIdEnd
*/
public void setUserIdEnd(Long userIdEnd){
this.userIdEnd = userIdEnd;
}
/**
* 获取 增加 用户ID
* @return userIdIncrement
*/
public Long getUserIdIncrement(){
return this.userIdIncrement;
}
/**
* 设置 增加 用户ID
* @param userIdIncrement
*/
public void setUserIdIncrement(Long userIdIncrement){
this.userIdIncrement = userIdIncrement;
}
/**
* 获取 用户ID
* @return userIdList
*/
public List<Long> getUserIdList(){
return this.userIdList;
}
/**
* 设置 用户ID
* @param userIdList
*/
public void setUserIdList(List<Long> userIdList){
this.userIdList = userIdList;
}
/**
* 获取 用户ID
* @return userIdNotList
*/
public List<Long> getUserIdNotList(){
return this.userIdNotList;
}
/**
* 设置 用户ID
* @param userIdNotList
*/
public void setUserIdNotList(List<Long> userIdNotList){
this.userIdNotList = userIdNotList;
}
/**
* 获取 开始 创建用户
* @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;
}
/**
* 获取 开始 创建时间
* @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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号,主键,自增长
* @param id
*/
public RoleUserQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号,主键,自增长
* @param idStart
*/
public RoleUserQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号,主键,自增长
* @param idEnd
*/
public RoleUserQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号,主键,自增长
* @param idIncrement
*/
public RoleUserQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号,主键,自增长
* @param idList
*/
public RoleUserQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号,主键,自增长
* @param idNotList
*/
public RoleUserQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 角色ID
* @param roleId
*/
public RoleUserQuery roleId(Long roleId){
setRoleId(roleId);
return this;
}
/**
* 设置 开始 角色ID
* @param roleIdStart
*/
public RoleUserQuery roleIdStart(Long roleIdStart){
this.roleIdStart = roleIdStart; this.roleIdStart = roleIdStart;
} return this;
}
/**
* 获取 结束 角色ID /**
* @return roleIdEnd * 设置 结束 角色ID
*/ * @param roleIdEnd
public Long getRoleIdEnd(){ */
return this.roleIdEnd; public RoleUserQuery roleIdEnd(Long roleIdEnd){
}
/**
* 设置 结束 角色ID
* @param roleIdEnd
*/
public void setRoleIdEnd(Long roleIdEnd){
this.roleIdEnd = roleIdEnd; this.roleIdEnd = roleIdEnd;
} return this;
}
/**
* 获取 增加 角色ID /**
* @return roleIdIncrement * 设置 增加 角色ID
*/ * @param roleIdIncrement
public Long getRoleIdIncrement(){ */
return this.roleIdIncrement; public RoleUserQuery roleIdIncrement(Long roleIdIncrement){
}
/**
* 设置 增加 角色ID
* @param roleIdIncrement
*/
public void setRoleIdIncrement(Long roleIdIncrement){
this.roleIdIncrement = roleIdIncrement; this.roleIdIncrement = roleIdIncrement;
} return this;
}
/**
* 获取 角色ID /**
* @return roleIdList * 设置 角色ID
*/ * @param roleIdList
public List<Long> getRoleIdList(){ */
return this.roleIdList; public RoleUserQuery roleIdList(List<Long> roleIdList){
} this.roleIdList = roleIdList;
return this;
/** }
* 设置 角色ID
* @param roleIdList /**
*/ * 设置 角色ID
public void setRoleIdList(List<Long> roleIdList){ * @param roleIdNotList
this.roleIdList = roleIdList; */
} public RoleUserQuery roleIdNotList(List<Long> roleIdNotList){
this.roleIdNotList = roleIdNotList;
/** return this;
* 获取 开始 用户ID }
* @return userIdStart
*/ /**
public Long getUserIdStart(){ * 设置 用户ID
return this.userIdStart; * @param userId
} */
public RoleUserQuery userId(Long userId){
/** setUserId(userId);
* 设置 开始 用户ID return this;
* @param userIdStart }
*/
public void setUserIdStart(Long userIdStart){ /**
* 设置 开始 用户ID
* @param userIdStart
*/
public RoleUserQuery userIdStart(Long userIdStart){
this.userIdStart = userIdStart; this.userIdStart = userIdStart;
} return this;
}
/**
* 获取 结束 用户ID /**
* @return userIdEnd * 设置 结束 用户ID
*/ * @param userIdEnd
public Long getUserIdEnd(){ */
return this.userIdEnd; public RoleUserQuery userIdEnd(Long userIdEnd){
}
/**
* 设置 结束 用户ID
* @param userIdEnd
*/
public void setUserIdEnd(Long userIdEnd){
this.userIdEnd = userIdEnd; this.userIdEnd = userIdEnd;
} return this;
}
/**
* 设置 增加 用户ID
* @param userIdIncrement
*/
public RoleUserQuery userIdIncrement(Long userIdIncrement){
this.userIdIncrement = userIdIncrement;
return this;
}
/**
* 设置 用户ID
* @param userIdList
*/
public RoleUserQuery userIdList(List<Long> userIdList){
this.userIdList = userIdList;
return this;
}
/**
* 设置 用户ID
* @param userIdNotList
*/
public RoleUserQuery userIdNotList(List<Long> userIdNotList){
this.userIdNotList = userIdNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public RoleUserQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public RoleUserQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public RoleUserQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public RoleUserQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public RoleUserQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public RoleUserQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 获取 增加 用户ID
* @return userIdIncrement
*/
public Long getUserIdIncrement(){
return this.userIdIncrement;
}
/** /**
* 设置 增加 用户ID * 设置 创建用户名称
* @param userIdIncrement * @param createUserName
*/ */
public void setUserIdIncrement(Long userIdIncrement){ public RoleUserQuery createUserName(String createUserName){
this.userIdIncrement = userIdIncrement; setCreateUserName(createUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public RoleUserQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public RoleUserQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public RoleUserQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public RoleUserQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public RoleUserQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public RoleUserQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public RoleUserQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 用户ID
* @return userIdList
*/
public List<Long> getUserIdList(){
return this.userIdList;
}
/** /**
* 设置 用户ID * 设置 创建用户名称
* @param userIdList * @param updateUserName
*/ */
public void setUserIdList(List<Long> userIdList){ public RoleUserQuery updateUserName(String updateUserName){
this.userIdList = userIdList; setUpdateUserName(updateUserName);
} return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public RoleUserQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 获取 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<RoleUserQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合,列表项之间是OR,项内容之间是AND,如:(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<RoleUserQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<RoleUserQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合,列表项之间是AND,项内容之间是OR,如:(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<RoleUserQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
import java.util.List;
/**
* 角色资源权限业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleAuthVo extends BaseEntityLong {
/** 序号,主键,自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
import java.util.List;
/**
* 角色用户业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleUserVo extends BaseEntityLong {
/** 序号,主键,自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import lombok.Data;
import java.util.List;
/**
* 角色信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleVo extends BaseEntityLong {
/** 序号,主键,自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
...@@ -9,10 +9,15 @@ ...@@ -9,10 +9,15 @@
package com.mortals.xhx.base.system.role.service; package com.mortals.xhx.base.system.role.service;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService; import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity; import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import com.mortals.xhx.base.system.role.model.RoleAuthQuery; import com.mortals.xhx.base.system.role.model.RoleAuthQuery;
import java.util.List;
/** /**
* <p>Title: 角色资源权限</p> * <p>Title: 角色资源权限</p>
* <p>Description: RoleAuthService service接口 </p> * <p>Description: RoleAuthService service接口 </p>
...@@ -24,5 +29,13 @@ import com.mortals.xhx.base.system.role.model.RoleAuthQuery; ...@@ -24,5 +29,13 @@ import com.mortals.xhx.base.system.role.model.RoleAuthQuery;
public interface RoleAuthService extends ICRUDService<RoleAuthEntity,Long> { public interface RoleAuthService extends ICRUDService<RoleAuthEntity,Long> {
/** 角色分配资源 */ /** 角色分配资源 */
void doDistributionSource(RoleAuthQuery query); void doDistributionSource(RoleAuthQuery query, Context context);
/** 角色分配菜单 */
void doDistributionMenu(RoleAuthQuery query, Context context);
/** 角色编辑菜单 */
List<MenuTreeSelect> editMenu(RoleAuthQuery query, Context context);
} }
\ No newline at end of file
...@@ -8,19 +8,33 @@ ...@@ -8,19 +8,33 @@
package com.mortals.xhx.base.system.role.service.impl; package com.mortals.xhx.base.system.role.service.impl;
import cn.hutool.core.util.StrUtil;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICacheService; import com.mortals.framework.service.ICacheService;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl; import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.util.DataUtil; import com.mortals.framework.util.DataUtil;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuQuery;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.menu.service.MenuService;
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.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.role.dao.RoleAuthDao; import com.mortals.xhx.base.system.role.dao.RoleAuthDao;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity; import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import com.mortals.xhx.base.system.role.model.RoleAuthQuery; import com.mortals.xhx.base.system.role.model.RoleAuthQuery;
import com.mortals.xhx.base.system.role.model.RoleUserQuery;
import com.mortals.xhx.base.system.role.service.RoleAuthService; import com.mortals.xhx.base.system.role.service.RoleAuthService;
import com.mortals.xhx.base.system.role.service.RoleUserService;
import com.mortals.xhx.common.key.RedisKey; import com.mortals.xhx.common.key.RedisKey;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import java.util.*; import java.util.*;
import java.util.stream.Collectors;
import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode; import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode;
...@@ -29,6 +43,7 @@ import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode; ...@@ -29,6 +43,7 @@ import static com.mortals.xhx.common.utils.MenuEncodeUtil.generateMenuUrlCode;
* <p>Description: RoleAuthServiceImpl service接口 </p> * <p>Description: RoleAuthServiceImpl service接口 </p>
* <p>Copyright: Copyright &reg; </p> * <p>Copyright: Copyright &reg; </p>
* <p>Company: </p> * <p>Company: </p>
*
* @author * @author
* @version 1.0.0 * @version 1.0.0
*/ */
...@@ -38,36 +53,153 @@ public class RoleAuthServiceImpl extends AbstractCRUDServiceImpl<RoleAuthDao, Ro ...@@ -38,36 +53,153 @@ public class RoleAuthServiceImpl extends AbstractCRUDServiceImpl<RoleAuthDao, Ro
@Autowired @Autowired
private ICacheService cacheService; private ICacheService cacheService;
@Autowired @Autowired
private MenuService menuService;
@Autowired
private RoleUserService roleUserService;
@Autowired
@Lazy
private ResourceService resourceService; private ResourceService resourceService;
@Override @Override
public void doDistributionSource(RoleAuthQuery query) { public void doDistributionSource(RoleAuthQuery query, Context context) {
if (ObjectUtils.isEmpty(query.getRoleId())) throw new AppException("角色不能为空!");
// 删除角色资源老数据 // 删除角色资源老数据
Long roleId = query.getRoleId(); Long roleId = query.getRoleId();
Map<String, Object> condition = new HashMap<>(); RoleAuthQuery roleAuthQuery = new RoleAuthQuery();
condition.put("roleId", roleId); roleAuthQuery.setRoleId(roleId);
this.dao.delete(condition); Long[] delIds = this.find(roleAuthQuery).stream()
.filter(f -> f.getMenuId() == null)
.map(f -> f.getId()).toArray(Long[]::new);
if (!ObjectUtils.isEmpty(delIds)) {
this.remove(delIds, context);
}
List<RoleAuthEntity> list = new ArrayList<>(); List<RoleAuthEntity> list = new ArrayList<>();
for (Long sourceId : query.getResourceIdList()) { for (Long sourceId : query.getResourceIdList()) {
RoleAuthEntity entity = new RoleAuthEntity(); RoleAuthEntity entity = new RoleAuthEntity();
entity.setRoleId(roleId); entity.setRoleId(roleId);
entity.setResourceId(sourceId); entity.setResourceId(sourceId);
entity.setCreateUserId(this.getContextUserId(context));
entity.setCreateTime(new Date());
list.add(entity); list.add(entity);
} }
this.dao.insertBatch(list); this.dao.insertBatch(list);
this.updateUserMenuUrlCache();
//查询所有有这个用户角色的用户
// this.find(new RoleAuthQuery().roleId(roleId)).stream().filter(f->f.get)
List<Long> userIdList = roleUserService.find(new RoleUserQuery().roleId(query.getRoleId())).stream()
.map(m -> m.getUserId())
.filter(f -> f != null)
.distinct().collect(Collectors.toList());
this.updateUserMenuUrlCache(userIdList);
}
@Override
public void doDistributionMenu(RoleAuthQuery query, Context context) {
if (ObjectUtils.isEmpty(query.getRoleId())) throw new AppException("角色不能为空!");
// 删除角色资源老数据
Long roleId = query.getRoleId();
RoleAuthQuery roleAuthQuery = new RoleAuthQuery();
roleAuthQuery.setRoleId(roleId);
Long[] delIds = this.find(roleAuthQuery).stream()
.filter(f -> f.getMenuId() != null)
.map(f -> f.getId()).toArray(Long[]::new);
if (!ObjectUtils.isEmpty(delIds)) {
this.remove(delIds, context);
}
List<RoleAuthEntity> list = new ArrayList<>();
for (Long menuId : query.getMenuIdList()) {
//todo 一个菜单可以对应多个资源
MenuEntity menuEntity = menuService.get(menuId, context);
if(!ObjectUtils.isEmpty(menuEntity)){
String resourceUrl = menuEntity.getResourceUrl();
if(!ObjectUtils.isEmpty(resourceUrl)){
List<String> split = StrUtil.split(resourceUrl, ",");
for (String s : split) {
RoleAuthEntity entity = new RoleAuthEntity();
entity.setRoleId(roleId);
entity.setMenuId(menuId);
entity.setCreateTime(new Date());
entity.setCreateUserId(1L);
//判断资源路径类型 如果是/xxx开头 查询资源是否存在,不存在则创建
if (StrUtil.startWith(s, "/")) {
//根据路径查询资源是否存在
ResourceEntity resourceEntity = resourceService.selectOne(new ResourceQuery().url(s));
if(ObjectUtils.isEmpty(resourceEntity)){
ResourceEntity resource = new ResourceEntity();
resource.initAttrValue();
resource.setName(menuEntity.getName());
resource.setGroupName("菜单自定义");
resource.setUrl(s);
resource.setCreateTime(new Date());
resource.setCreateUserId(1L);
resourceService.save(resource, context);
entity.setResourceId(resource.getId());
}else{
entity.setResourceId(resourceEntity.getId());
}
}else{
//查询下id是否存在 如果存在 添加
ResourceEntity resource = resourceService.get(DataUtil.converStr2Long(s, 0L), context);
if(ObjectUtils.isEmpty(resource)) continue;
entity.setResourceId(resource.getId());
}
list.add(entity);
}
}else{
RoleAuthEntity entity = new RoleAuthEntity();
entity.setRoleId(roleId);
entity.setMenuId(menuId);
entity.setCreateTime(new Date());
entity.setCreateUserId(1L);
list.add(entity);
}
}
}
this.dao.insertBatch(list);
List<Long> userIdList = roleUserService.find(new RoleUserQuery().roleId(query.getRoleId())).stream()
.map(m -> m.getUserId())
.filter(f -> f != null)
.distinct().collect(Collectors.toList());
this.updateUserMenuUrlCache(userIdList);
}
@Override
public List<MenuTreeSelect> editMenu(RoleAuthQuery query, Context context) {
if (ObjectUtils.isEmpty(query.getRoleId())) throw new AppException("角色不能为空!");
RoleAuthQuery roleAuthQuery = new RoleAuthQuery();
roleAuthQuery.setRoleId(query.getRoleId());
Set<Long> menuIdList = this.find(roleAuthQuery).stream()
.map(f -> f.getMenuId())
.filter(f -> f != null)
.collect(Collectors.toSet());
if (!ObjectUtils.isEmpty(menuIdList)) {
List<MenuEntity> allMenuList = menuService.find(new MenuQuery());
List<MenuTreeSelect> menuTreeSelects = menuService.buildMenuTreeChecked(allMenuList, menuIdList);
return menuTreeSelects;
}
return Collections.emptyList();
} }
private void updateUserMenuUrlCache() { private void updateUserMenuUrlCache(List<Long> userIdList) {
//更新用户菜单 for (Long userId : userIdList) {
Set<String> hkeys = cacheService.hkeys(RedisKey.KEY_USER_MENU_CACHE); Set<String> urls = resourceService.findUrlSetByUserId(userId);
for (String userId : hkeys) {
Set<String> urls = resourceService.findUrlSetByUserId(DataUtil.converStr2Long(userId, 0L));
String menuUrlCode = generateMenuUrlCode(urls); String menuUrlCode = generateMenuUrlCode(urls);
cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId, menuUrlCode); cacheService.hset(RedisKey.KEY_USER_MENU_CACHE, userId.toString(), menuUrlCode);
} }
} }
public static void main(String[] args) {
String s = "1";
System.out.println(StrUtil.split(s, ","));
}
} }
\ No newline at end of file
/** /**
* 文件:RoleServiceImpl.java * 文件:RoleServiceImpl.java
* 版本:1.0.0 * 版本:1.0.0
* 日期: * 日期:
* Copyright &reg; * Copyright &reg;
* All right reserved. * All right reserved.
*/ */
package com.mortals.xhx.base.system.role.service.impl; package com.mortals.xhx.base.system.role.service.impl;
...@@ -15,7 +15,6 @@ import com.mortals.xhx.base.system.role.dao.RoleDao; ...@@ -15,7 +15,6 @@ import com.mortals.xhx.base.system.role.dao.RoleDao;
import com.mortals.xhx.base.system.role.model.*; import com.mortals.xhx.base.system.role.model.*;
import com.mortals.xhx.base.system.role.service.RoleAuthService; import com.mortals.xhx.base.system.role.service.RoleAuthService;
import com.mortals.xhx.base.system.role.service.RoleService; import com.mortals.xhx.base.system.role.service.RoleService;
import com.mortals.xhx.base.system.role.service.RoleUserService; import com.mortals.xhx.base.system.role.service.RoleUserService;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
...@@ -27,7 +26,7 @@ import java.util.Arrays; ...@@ -27,7 +26,7 @@ import java.util.Arrays;
* <p>Description: RoleServiceImpl service接口 </p> * <p>Description: RoleServiceImpl service接口 </p>
* <p>Copyright: Copyright &reg; </p> * <p>Copyright: Copyright &reg; </p>
* <p>Company: </p> * <p>Company: </p>
* @author * @author
* @version 1.0.0 * @version 1.0.0
*/ */
@Service("roleService") @Service("roleService")
...@@ -56,5 +55,5 @@ public class RoleServiceImpl extends AbstractCRUDServiceImpl<RoleDao,RoleEntity, ...@@ -56,5 +55,5 @@ public class RoleServiceImpl extends AbstractCRUDServiceImpl<RoleDao,RoleEntity,
}).count(); }).count();
super.removeAfter(ids, context, result); super.removeAfter(ids, context, result);
} }
} }
\ No newline at end of file
...@@ -18,7 +18,6 @@ import com.mortals.xhx.base.system.role.dao.RoleUserDao; ...@@ -18,7 +18,6 @@ import com.mortals.xhx.base.system.role.dao.RoleUserDao;
import com.mortals.xhx.base.system.role.model.RoleUserEntity; import com.mortals.xhx.base.system.role.model.RoleUserEntity;
import com.mortals.xhx.base.system.role.model.RoleUserQuery; import com.mortals.xhx.base.system.role.model.RoleUserQuery;
import com.mortals.xhx.base.system.role.service.RoleUserService; import com.mortals.xhx.base.system.role.service.RoleUserService;
import com.mortals.xhx.common.key.RedisKey; import com.mortals.xhx.common.key.RedisKey;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
...@@ -58,6 +57,9 @@ public class RoleUserServiceImpl extends AbstractCRUDServiceImpl<RoleUserDao, Ro ...@@ -58,6 +57,9 @@ public class RoleUserServiceImpl extends AbstractCRUDServiceImpl<RoleUserDao, Ro
RoleUserEntity rolseUser = new RoleUserEntity(); RoleUserEntity rolseUser = new RoleUserEntity();
rolseUser.setRoleId(roleId); rolseUser.setRoleId(roleId);
rolseUser.setUserId(userId); rolseUser.setUserId(userId);
rolseUser.setCreateUserId(1L);
rolseUser.setCreateUserName("admin");
rolseUser.setCreateTime(new Date());
list.add(rolseUser); list.add(rolseUser);
} }
this.dao.insertBatch(list); this.dao.insertBatch(list);
...@@ -77,6 +79,9 @@ public class RoleUserServiceImpl extends AbstractCRUDServiceImpl<RoleUserDao, Ro ...@@ -77,6 +79,9 @@ public class RoleUserServiceImpl extends AbstractCRUDServiceImpl<RoleUserDao, Ro
RoleUserEntity rolseUser = new RoleUserEntity(); RoleUserEntity rolseUser = new RoleUserEntity();
rolseUser.setRoleId(roleId); rolseUser.setRoleId(roleId);
rolseUser.setUserId(userId); rolseUser.setUserId(userId);
rolseUser.setCreateUserId(1L);
rolseUser.setCreateUserName("admin");
rolseUser.setCreateTime(new Date());
list.add(rolseUser); list.add(rolseUser);
} }
this.dao.insertBatch(list); this.dao.insertBatch(list);
......
...@@ -3,19 +3,23 @@ package com.mortals.xhx.base.system.role.web; ...@@ -3,19 +3,23 @@ package com.mortals.xhx.base.system.role.web;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import com.mortals.xhx.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import com.mortals.xhx.base.system.role.model.RoleAuthQuery; import com.mortals.xhx.base.system.role.model.RoleAuthQuery;
import com.mortals.xhx.base.system.role.service.RoleAuthService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonMappingController; import java.util.HashMap;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity; import java.util.List;
import com.mortals.xhx.base.system.role.service.RoleAuthService; import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/** /**
* 角色资源权限 * 角色资源权限
...@@ -28,6 +32,9 @@ import javax.servlet.http.HttpServletResponse; ...@@ -28,6 +32,9 @@ import javax.servlet.http.HttpServletResponse;
@RequestMapping("role/auth") @RequestMapping("role/auth")
public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAuthService, RoleAuthEntity, Long> { public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAuthService, RoleAuthEntity, Long> {
@Autowired
private ResourceService resourceService;
public RoleAuthController() { public RoleAuthController() {
super.setModuleDesc("角色资源权限"); super.setModuleDesc("角色资源权限");
} }
...@@ -35,10 +42,11 @@ public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAu ...@@ -35,10 +42,11 @@ public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAu
/** /**
* 分配资源 * 分配资源
*/ */
@ApiOperation(value = "分配资源")
@PostMapping(value = "distributionSource") @PostMapping(value = "distributionSource")
public String distributionUser(@RequestBody RoleAuthQuery query) { public String distributionSource(@RequestBody RoleAuthQuery query) {
try { try {
service.doDistributionSource(query); service.doDistributionSource(query, this.getContext());
JSONObject ret = new JSONObject(); JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS); ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
return ret.toJSONString(); return ret.toJSONString();
...@@ -51,4 +59,66 @@ public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAu ...@@ -51,4 +59,66 @@ public class RoleAuthController extends BaseCRUDJsonBodyMappingController<RoleAu
} }
} }
/**
* 分配菜单
*/
@ApiOperation(value = "分配菜单")
@PostMapping(value = "distributionMenu")
public String distributionMenu(@RequestBody RoleAuthQuery query) {
try {
service.doDistributionMenu(query, this.getContext());
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();
}
}
/**
* 根据角色编辑菜单
*/
@ApiOperation(value = "根据角色编辑菜单")
@PostMapping(value = "editMenu")
public String editMenu(@RequestBody RoleAuthQuery query) {
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap<>();
try {
List<MenuTreeSelect> menuTreeSelects = service.editMenu(query, this.getContext());
ret.put(KEY_RESULT_DATA, menuTreeSelects);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
return ret.toJSONString();
} catch (Exception e) {
log.error("角色编辑菜单错误", e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 根据角色编辑资源
*/
@ApiOperation(value = "根据角色编辑资源")
@PostMapping(value = "editResource")
public String editResource(@RequestBody RoleAuthQuery query) {
JSONObject ret = new JSONObject();
try {
Map<String, List<ResourceEntity>> group = resourceService.group(query.getRoleId(), getContext());
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_DATA, group);
return ret.toJSONString();
} catch (Exception e) {
log.error("角色编辑资源错误", e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
} }
\ No newline at end of file
...@@ -5,20 +5,19 @@ import com.alibaba.fastjson.JSONObject; ...@@ -5,20 +5,19 @@ import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.common.IBaseEnum; import com.mortals.framework.common.IBaseEnum;
import com.mortals.framework.common.code.UserType; import com.mortals.framework.common.code.UserType;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.role.model.RoleQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.role.model.RoleEntity; import com.mortals.xhx.base.system.role.model.RoleEntity;
import com.mortals.xhx.base.system.role.model.RoleUserEntity; import com.mortals.xhx.base.system.role.model.RoleUserEntity;
import com.mortals.xhx.base.system.role.service.RoleService; import com.mortals.xhx.base.system.role.service.RoleService;
import com.mortals.xhx.base.system.role.service.RoleUserService; import com.mortals.xhx.base.system.role.service.RoleUserService;
import com.mortals.xhx.common.code.RoleType; import com.mortals.xhx.common.code.RoleType;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
...@@ -55,6 +54,7 @@ public class RoleController extends BaseCRUDJsonBodyMappingController<RoleServic ...@@ -55,6 +54,7 @@ public class RoleController extends BaseCRUDJsonBodyMappingController<RoleServic
* @param userId * @param userId
* @return * @return
*/ */
@ApiOperation(value = "根据用户id获取角色名称")
@PostMapping("roleNameByUserId") @PostMapping("roleNameByUserId")
public String getRoleNameByUserId(@RequestParam(value = "userId") Long userId) { public String getRoleNameByUserId(@RequestParam(value = "userId") Long userId) {
try{ try{
......
...@@ -7,26 +7,23 @@ import com.mortals.framework.ap.SysConstains; ...@@ -7,26 +7,23 @@ import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.role.model.RoleUserQuery;
import org.apache.commons.beanutils.MethodUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.role.model.RoleEntity; import com.mortals.xhx.base.system.role.model.RoleEntity;
import com.mortals.xhx.base.system.role.model.RoleUserEntity; import com.mortals.xhx.base.system.role.model.RoleUserEntity;
import com.mortals.xhx.base.system.role.model.RoleUserQuery;
import com.mortals.xhx.base.system.role.service.RoleService; import com.mortals.xhx.base.system.role.service.RoleService;
import com.mortals.xhx.base.system.role.service.RoleUserService; import com.mortals.xhx.base.system.role.service.RoleUserService;
import com.mortals.xhx.base.system.user.model.UserEntity; import com.mortals.xhx.base.system.user.model.UserEntity;
import com.mortals.xhx.base.system.user.model.UserQuery; import com.mortals.xhx.base.system.user.model.UserQuery;
import com.mortals.xhx.base.system.user.service.UserService; import com.mortals.xhx.base.system.user.service.UserService;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.beanutils.MethodUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
...@@ -98,6 +95,7 @@ public class RoleUserController extends BaseCRUDJsonBodyMappingController<RoleUs ...@@ -98,6 +95,7 @@ public class RoleUserController extends BaseCRUDJsonBodyMappingController<RoleUs
/** /**
* 分配用户 * 分配用户
*/ */
@ApiOperation(value = "分配用户")
@PostMapping(value = "distributionUser") @PostMapping(value = "distributionUser")
public String distributionUser(@RequestBody RoleUserQuery query) { public String distributionUser(@RequestBody RoleUserQuery query) {
try { try {
...@@ -117,6 +115,7 @@ public class RoleUserController extends BaseCRUDJsonBodyMappingController<RoleUs ...@@ -117,6 +115,7 @@ public class RoleUserController extends BaseCRUDJsonBodyMappingController<RoleUs
/** /**
* 分配角色 * 分配角色
*/ */
@ApiOperation(value = "分配角色")
@PostMapping(value = "distributionRole") @PostMapping(value = "distributionRole")
public String distributionRole(@RequestBody RoleUserQuery query) { public String distributionRole(@RequestBody RoleUserQuery query) {
try { try {
......
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.table.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.table.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.table.dao.TableIndexDao; import com.mortals.xhx.base.system.table.dao.TableIndexDao;
import com.mortals.xhx.base.system.table.model.TableIndexEntity; import com.mortals.xhx.base.system.table.model.TableIndexEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
...@@ -8,10 +8,10 @@ ...@@ -8,10 +8,10 @@
package com.mortals.xhx.base.system.table.model; package com.mortals.xhx.base.system.table.model;
import java.util.Date;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import java.util.Date;
/** /**
* <p>Title: 分表索引信息</p> * <p>Title: 分表索引信息</p>
* <p>Description: TableIndexEntity </p> * <p>Description: TableIndexEntity </p>
......
...@@ -20,7 +20,6 @@ import com.mortals.xhx.base.system.table.dao.TableIndexDao; ...@@ -20,7 +20,6 @@ import com.mortals.xhx.base.system.table.dao.TableIndexDao;
import com.mortals.xhx.base.system.table.model.TableIndexEntity; import com.mortals.xhx.base.system.table.model.TableIndexEntity;
import com.mortals.xhx.base.system.table.model.TableIndexQuery; import com.mortals.xhx.base.system.table.model.TableIndexQuery;
import com.mortals.xhx.base.system.table.service.TableIndexService; import com.mortals.xhx.base.system.table.service.TableIndexService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.*; import java.util.*;
......
...@@ -8,12 +8,11 @@ ...@@ -8,12 +8,11 @@
package com.mortals.xhx.base.system.table.web; package com.mortals.xhx.base.system.table.web;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonMappingController; import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.table.model.TableIndexEntity; import com.mortals.xhx.base.system.table.model.TableIndexEntity;
import com.mortals.xhx.base.system.table.service.TableIndexService; import com.mortals.xhx.base.system.table.service.TableIndexService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/** /**
* <p>Title: 分表索引信息</p> * <p>Title: 分表索引信息</p>
......
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.task.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.task.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.task.dao.TaskDao; import com.mortals.xhx.base.system.task.dao.TaskDao;
import com.mortals.xhx.base.system.task.model.TaskEntity; import com.mortals.xhx.base.system.task.model.TaskEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
* <p>Title: 任务信息</p> * <p>Title: 任务信息</p>
......
...@@ -8,11 +8,11 @@ ...@@ -8,11 +8,11 @@
package com.mortals.xhx.base.system.task.model; package com.mortals.xhx.base.system.task.model;
import java.util.Date;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.framework.service.ITask; import com.mortals.framework.service.ITask;
import java.util.Date;
/** /**
* <p>Title: 任务信息</p> * <p>Title: 任务信息</p>
* <p>Description: TaskEntity </p> * <p>Description: TaskEntity </p>
......
...@@ -4,17 +4,7 @@ ...@@ -4,17 +4,7 @@
package com.mortals.xhx.base.system.task.service.impl; package com.mortals.xhx.base.system.task.service.impl;
import java.util.Calendar; import cn.hutool.core.net.NetUtil;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.ap.GlobalSysInfo; import com.mortals.framework.ap.GlobalSysInfo;
import com.mortals.framework.common.code.ExcuteStatus; import com.mortals.framework.common.code.ExcuteStatus;
import com.mortals.framework.common.code.TaskExcuteStrategy; import com.mortals.framework.common.code.TaskExcuteStrategy;
...@@ -25,11 +15,16 @@ import com.mortals.framework.service.impl.AbstractCRUDServiceImpl; ...@@ -25,11 +15,16 @@ import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.springcloud.service.IApplicationStartedService; import com.mortals.framework.springcloud.service.IApplicationStartedService;
import com.mortals.framework.util.DateUtils; import com.mortals.framework.util.DateUtils;
import com.mortals.framework.util.StringUtils; import com.mortals.framework.util.StringUtils;
import com.mortals.framework.util.SystemUtil;
import com.mortals.xhx.base.system.task.dao.TaskDao; import com.mortals.xhx.base.system.task.dao.TaskDao;
import com.mortals.xhx.base.system.task.model.TaskEntity; import com.mortals.xhx.base.system.task.model.TaskEntity;
import com.mortals.xhx.base.system.task.model.TaskQuery; import com.mortals.xhx.base.system.task.model.TaskQuery;
import com.mortals.xhx.base.system.task.service.TaskService; import com.mortals.xhx.base.system.task.service.TaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/** /**
* <p> * <p>
...@@ -62,7 +57,7 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity ...@@ -62,7 +57,7 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity
private Thread thread = null; private Thread thread = null;
/** 日志打印时间,key:任务ID,value:最后一次打印日志时间 */ /** 日志打印时间,key:任务ID,value:最后一次打印日志时间 */
private Map<Long, Long> printLogTime = new HashMap<Long, Long>(); private Map<Long, Long> printLogTime = new HashMap<>();
@Autowired(required=false) @Autowired(required=false)
private TaskService taskService; private TaskService taskService;
...@@ -153,8 +148,10 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity ...@@ -153,8 +148,10 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity
@Override @Override
public void start() throws AppException { public void start() throws AppException {
final String localIp = SystemUtil.getLocalHostIp(); // final String localIp = SystemUtil.getLocalHostIp();
final String localIp = NetUtil.getLocalhostStr();
log.info("任务执行线程启动...-->" + localIp); log.info("任务执行线程启动...-->" + localIp);
log.info("other get Ip...-->" + NetUtil.getLocalhostStr());
thread = new Thread(() -> { thread = new Thread(() -> {
// 将本机上次执行而未完成的任务状态变更 // 将本机上次执行而未完成的任务状态变更
try { try {
...@@ -216,17 +213,17 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity ...@@ -216,17 +213,17 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity
} }
if (interimExcuteStatus != TaskInterimExcuteStatus.UNUSE.getValue() // 启用立即执行 if (interimExcuteStatus != TaskInterimExcuteStatus.UNUSE.getValue() // 启用立即执行
|| ((strategy == TaskExcuteStrategy.DAY.getValue() // 按天 || ((strategy == TaskExcuteStrategy.DAY.getValue() // 按天
|| (strategy == TaskExcuteStrategy.WEEK.getValue() || (strategy == TaskExcuteStrategy.WEEK.getValue()
&& week == excuteDate) && week == excuteDate)
// 按周 // 按周
|| (strategy == TaskExcuteStrategy.MONTH.getValue() || (strategy == TaskExcuteStrategy.MONTH.getValue()
&& (day == excuteDate && (day == excuteDate
|| (excuteDate > maxDay && day == maxDay))))// 按月 || (excuteDate > maxDay && day == maxDay))))// 按月
&& (excuteTime == currTime && (excuteTime == currTime
&& !lastExcuteTimeStr.equals(currDateTimeStr)) // 执行间隔最少为一天 && !lastExcuteTimeStr.equals(currDateTimeStr)) // 执行间隔最少为一天
) || (strategy == TaskExcuteStrategy.INTERVAL.getValue() // 按间隔时间 ) || (strategy == TaskExcuteStrategy.INTERVAL.getValue() // 按间隔时间
&& (lastExcuteTime == null || lastExcuteTime.getTime() && (lastExcuteTime == null || lastExcuteTime.getTime()
+ excuteDate * 1000 <= currDateTime.getTime()))) { + excuteDate * 1000 <= currDateTime.getTime()))) {
final boolean printLog = checkPrintLog(task); final boolean printLog = checkPrintLog(task);
Object excuteBean = GlobalSysInfo.getBeanByName(task.getExcuteService()); Object excuteBean = GlobalSysInfo.getBeanByName(task.getExcuteService());
if (excuteBean == null || !(excuteBean instanceof ITaskExcuteService)) { if (excuteBean == null || !(excuteBean instanceof ITaskExcuteService)) {
...@@ -261,7 +258,7 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity ...@@ -261,7 +258,7 @@ public class TaskServiceImpl extends AbstractCRUDServiceImpl<TaskDao, TaskEntity
log.error("执行任务失败-->" + excuteTask, e); log.error("执行任务失败-->" + excuteTask, e);
} }
if (strategy == TaskExcuteStrategy.INTERVAL.getValue()) { if (strategy == TaskExcuteStrategy.INTERVAL.getValue()) {
// 按间隔时间,更新执行时间,避免一直重复执行 // 按间隔时间,更新执行时间,避免一直重复执行
excuteTask.setLastExcuteTime(currDateTime); excuteTask.setLastExcuteTime(currDateTime);
} }
} finally { } finally {
......
package com.mortals.xhx.base.system.task.web; package com.mortals.xhx.base.system.task.web;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.task.model.TaskQuery;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.ap.GlobalSysInfo; import com.mortals.framework.ap.GlobalSysInfo;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.service.ITaskExcuteService; import com.mortals.framework.service.ITaskExcuteService;
import com.mortals.framework.web.BaseCRUDJsonMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.task.model.TaskEntity; import com.mortals.xhx.base.system.task.model.TaskEntity;
import com.mortals.xhx.base.system.task.model.TaskQuery;
import com.mortals.xhx.base.system.task.service.TaskService; import com.mortals.xhx.base.system.task.service.TaskService;
import com.mortals.xhx.common.code.DataSatusEnum; import com.mortals.xhx.common.code.DataSatusEnum;
import com.mortals.xhx.common.code.TaskExcuteStatusEnum; import com.mortals.xhx.common.code.TaskExcuteStatusEnum;
import com.mortals.xhx.common.code.TaskExcuteStrategyEnum; import com.mortals.xhx.common.code.TaskExcuteStrategyEnum;
import com.mortals.xhx.common.code.TaskInterimExcuteStatusEnum; import com.mortals.xhx.common.code.TaskInterimExcuteStatusEnum;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/** /**
* 任务信息 * 任务信息
......
...@@ -46,24 +46,12 @@ public interface UploadService extends IService { ...@@ -46,24 +46,12 @@ public interface UploadService extends IService {
*/ */
void fileDownload(String fileName, Boolean delete, HttpServletResponse response); void fileDownload(String fileName, Boolean delete, HttpServletResponse response);
/**
* 预览
* @param fileName
* @param response
*/
void preview(String fileName, HttpServletResponse response); void preview(String fileName, HttpServletResponse response);
/**
* 上传
* @param fileName
* @param response
*/
void uploadDownload(String fileName, HttpServletResponse response); void uploadDownload(String fileName, HttpServletResponse response);
/**
* 刪除
* @param fileName
*/
void deleteFile(String fileName); void deleteFile(String fileName);
} }
\ No newline at end of file
package com.mortals.xhx.base.system.upload.service.impl; package com.mortals.xhx.base.system.upload.service.impl;
import cn.hutool.core.io.FileUtil; import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.IUser; import com.mortals.framework.service.IUser;
import com.mortals.framework.util.StringUtils; import com.mortals.framework.util.StringUtils;
import com.mortals.xhx.base.system.upload.service.UploadService; import com.mortals.xhx.base.system.upload.service.UploadService;
import com.mortals.xhx.common.code.UploadFileType; import com.mortals.xhx.common.code.UploadFileType;
import com.mortals.xhx.utils.SpringUtils;
import lombok.Getter; import lombok.Getter;
import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.FilenameUtils;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
...@@ -44,6 +41,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -44,6 +41,7 @@ public class UploadServiceImpl implements UploadService {
private String filePath; private String filePath;
@Override @Override
public String saveFileUpload(MultipartFile tempFile, String prePath, IUser user) { public String saveFileUpload(MultipartFile tempFile, String prePath, IUser user) {
if (tempFile == null || tempFile.getSize() == 0) { if (tempFile == null || tempFile.getSize() == 0) {
...@@ -57,12 +55,10 @@ public class UploadServiceImpl implements UploadService { ...@@ -57,12 +55,10 @@ public class UploadServiceImpl implements UploadService {
log.error("文件上传大小超过限制,当前文件---" + tempFile.getSize() + ",允许大小----------" + type.getMaxSize()); log.error("文件上传大小超过限制,当前文件---" + tempFile.getSize() + ",允许大小----------" + type.getMaxSize());
throw new AppException("文件上传大小超过限制!"); throw new AppException("文件上传大小超过限制!");
} }
if (null != fileName && fileName.length() > 50) {
if (null != fileName && fileName.length() > 500) {
throw new AppException("文件名称过长,无法上传!"); throw new AppException("文件名称过长,无法上传!");
} }
String rootPath = this.filePath.endsWith("/") ? this.filePath : this.filePath + "/"; String rootPath = this.filePath.endsWith("/") ? this.filePath : this.filePath + "/";
String filePath = rootPath + (StringUtils.isEmpty(prePath) ? "" : prePath + "/"); String filePath = rootPath + (StringUtils.isEmpty(prePath) ? "" : prePath + "/");
File pathDir = new File(filePath); File pathDir = new File(filePath);
...@@ -74,7 +70,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -74,7 +70,7 @@ public class UploadServiceImpl implements UploadService {
File uploadFile = new File(filePathAll); File uploadFile = new File(filePathAll);
try { try {
log.info("文件正在储存,filepath:" + filePathAll); log.info("文件正在储存,filepath:"+filePathAll);
tempFile.transferTo(uploadFile); tempFile.transferTo(uploadFile);
} catch (Exception e) { } catch (Exception e) {
throw new AppException(e.getMessage()); throw new AppException(e.getMessage());
...@@ -85,10 +81,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -85,10 +81,7 @@ public class UploadServiceImpl implements UploadService {
@Override @Override
public String getFilePath(String path) { public String getFilePath(String path) {
// xxx/xxx/ String filePath = this.filePath.endsWith("/") ? this.filePath : this.filePath + "/";
String filePath = StrUtil.appendIfMissing(this.filePath, "/");
path =StrUtil.removePrefix(path, "/");
StrUtil.prependIfMissing(path, "/", "/");
return filePath + path; return filePath + path;
} }
...@@ -108,7 +101,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -108,7 +101,7 @@ public class UploadServiceImpl implements UploadService {
@Override @Override
public void preview(String fileName, HttpServletResponse response) { public void preview(String fileName, HttpServletResponse response) {
String filePath = this.filePath + "/file/preview/" + fileName; String filePath = this.filePath+"/file/preview/" + fileName;
try { try {
response.setContentType(MediaType.IMAGE_JPEG_VALUE); response.setContentType(MediaType.IMAGE_JPEG_VALUE);
setAttachmentResponseHeader(response, fileName); setAttachmentResponseHeader(response, fileName);
...@@ -122,11 +115,12 @@ public class UploadServiceImpl implements UploadService { ...@@ -122,11 +115,12 @@ public class UploadServiceImpl implements UploadService {
/** /**
* 下载文件名重新编码 * 下载文件名重新编码
* *
* @param response 响应对象 * @param response 响应对象
* @param realFileName 真实文件名 * @param realFileName 真实文件名
* @return * @return
*/ */
public void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException { public void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException
{
String percentEncodedFileName = percentEncode(realFileName); String percentEncodedFileName = percentEncode(realFileName);
StringBuilder contentDispositionValue = new StringBuilder(); StringBuilder contentDispositionValue = new StringBuilder();
...@@ -146,7 +140,8 @@ public class UploadServiceImpl implements UploadService { ...@@ -146,7 +140,8 @@ public class UploadServiceImpl implements UploadService {
* @param s 需要百分号编码的字符串 * @param s 需要百分号编码的字符串
* @return 百分号编码后的字符串 * @return 百分号编码后的字符串
*/ */
public String percentEncode(String s) throws UnsupportedEncodingException { public String percentEncode(String s) throws UnsupportedEncodingException
{
String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString()); String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString());
return encode.replaceAll("\\+", "%20"); return encode.replaceAll("\\+", "%20");
} }
...@@ -154,7 +149,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -154,7 +149,7 @@ public class UploadServiceImpl implements UploadService {
@Override @Override
public void uploadDownload(String fileName, HttpServletResponse response) { public void uploadDownload(String fileName, HttpServletResponse response) {
String filePath = this.filePath + fileName; String filePath = this.filePath+ fileName;
try { try {
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE); response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
setAttachmentResponseHeader(response, fileName); setAttachmentResponseHeader(response, fileName);
...@@ -166,7 +161,7 @@ public class UploadServiceImpl implements UploadService { ...@@ -166,7 +161,7 @@ public class UploadServiceImpl implements UploadService {
@Override @Override
public void deleteFile(String fileName) { public void deleteFile(String fileName) {
String filePath = this.filePath + fileName; String filePath = this.filePath+ fileName;
try { try {
FileUtil.del(filePath); FileUtil.del(filePath);
} catch (Exception e) { } catch (Exception e) {
...@@ -174,14 +169,4 @@ public class UploadServiceImpl implements UploadService { ...@@ -174,14 +169,4 @@ public class UploadServiceImpl implements UploadService {
} }
} }
public static void main(String[] args) {
String fileName="好.txt";
System.out.println(fileName.length());
}
} }
\ No newline at end of file
...@@ -2,11 +2,9 @@ package com.mortals.xhx.base.system.upload.web; ...@@ -2,11 +2,9 @@ package com.mortals.xhx.base.system.upload.web;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.framework.web.BaseController; import com.mortals.framework.web.BaseController;
import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import com.mortals.xhx.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.upload.service.UploadService; import com.mortals.xhx.base.system.upload.service.UploadService;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
...@@ -26,19 +24,13 @@ import java.util.Map; ...@@ -26,19 +24,13 @@ import java.util.Map;
@RestController @RestController
@RequestMapping("file") @RequestMapping("file")
public class UploadController extends BaseController { public class UploadController extends BaseController {
protected String moduleDesc = "";
@Resource @Resource
private UploadService uploadService; private UploadService uploadService;
public UploadController() {
this.setModuleDesc("资源信息");
}
public void setModuleDesc(String moduleDesc) {
this.moduleDesc = moduleDesc;
}
@RequestMapping(value = "upload") @RequestMapping(value = "upload")
@UnAuth
public String doFileUpload(HttpServletRequest request, UploadForm form) { public String doFileUpload(HttpServletRequest request, UploadForm form) {
Map<String, Object> model = new HashMap<>(); Map<String, Object> model = new HashMap<>();
String jsonStr = ""; String jsonStr = "";
...@@ -63,7 +55,8 @@ public class UploadController extends BaseController { ...@@ -63,7 +55,8 @@ public class UploadController extends BaseController {
@RequestMapping(value = "commonupload") @RequestMapping(value = "commonupload")
public String doFileUpload(MultipartFile file, @RequestParam(value = "prePath", defaultValue = "/file/fileupload") String prePath) { @UnAuth
public String doFileUpload(MultipartFile file, @RequestParam(value = "prePath",defaultValue = "file/fileupload") String prePath) {
Map<String, Object> model = new HashMap<>(); Map<String, Object> model = new HashMap<>();
String jsonStr = ""; String jsonStr = "";
try { try {
...@@ -108,7 +101,7 @@ public class UploadController extends BaseController { ...@@ -108,7 +101,7 @@ public class UploadController extends BaseController {
* @param fileName 文件名称 * @param fileName 文件名称
*/ */
@GetMapping("preview/{fileName}") @GetMapping("preview/{fileName}")
public void preView(@PathVariable(value = "fileName") String fileName, HttpServletResponse response) { public void preView(@PathVariable(value="fileName") String fileName, HttpServletResponse response) {
try { try {
uploadService.preview(fileName, response); uploadService.preview(fileName, response);
} catch (Exception e) { } catch (Exception e) {
...@@ -122,7 +115,7 @@ public class UploadController extends BaseController { ...@@ -122,7 +115,7 @@ public class UploadController extends BaseController {
* @param fileName 文件名称 * @param fileName 文件名称
*/ */
@GetMapping("fileupload/{fileName}") @GetMapping("fileupload/{fileName}")
public void fileupload(@PathVariable(value = "fileName") String fileName, HttpServletResponse response) { public void fileupload(@PathVariable(value="fileName") String fileName, HttpServletResponse response) {
try { try {
uploadService.uploadDownload(fileName, response); uploadService.uploadDownload(fileName, response);
} catch (Exception e) { } catch (Exception e) {
......
...@@ -8,11 +8,10 @@ ...@@ -8,11 +8,10 @@
package com.mortals.xhx.base.system.user.dao.ibatis; package com.mortals.xhx.base.system.user.dao.ibatis;
import com.mortals.xhx.base.system.user.dao.UserDao;
import com.mortals.xhx.base.system.user.model.UserEntity;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.framework.model.ParamDto; import com.mortals.framework.model.ParamDto;
import com.mortals.xhx.base.system.user.dao.UserDao;
import com.mortals.xhx.base.system.user.model.UserEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
import java.util.List; import java.util.List;
......
...@@ -2,11 +2,8 @@ package com.mortals.xhx.base.system.user.model.vo; ...@@ -2,11 +2,8 @@ package com.mortals.xhx.base.system.user.model.vo;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.model.model.ModelEntity;
import lombok.Data; import lombok.Data;
import java.util.List;
/** /**
* 用户信息业务视图对象 * 用户信息业务视图对象
* *
...@@ -15,7 +12,6 @@ import java.util.List; ...@@ -15,7 +12,6 @@ import java.util.List;
*/ */
@Data @Data
public class UserVo extends BaseEntityLong { public class UserVo extends BaseEntityLong {
/** /**
* 站点名称 * 站点名称
*/ */
...@@ -40,10 +36,4 @@ public class UserVo extends BaseEntityLong { ...@@ -40,10 +36,4 @@ public class UserVo extends BaseEntityLong {
* 过期时间 * 过期时间
*/ */
private Long expireTime; private Long expireTime;
private String oldPassword;
private String newPassword;
private String siteIds;
private List<ModelEntity> modleList;
} }
\ No newline at end of file
/** /**
* 文件:UserService.java * 文件:UserService.java
* 版本:1.0.0 * 版本:1.0.0
* 日期: * 日期:
* Copyright &reg; * Copyright &reg;
* All right reserved. * All right reserved.
*/ */
package com.mortals.xhx.base.system.user.service; package com.mortals.xhx.base.system.user.service;
...@@ -12,7 +12,6 @@ import com.mortals.framework.common.Rest; ...@@ -12,7 +12,6 @@ import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Result; import com.mortals.framework.model.Result;
import com.mortals.framework.service.ICRUDCacheService; import com.mortals.framework.service.ICRUDCacheService;
import com.mortals.framework.service.ICRUDService;
import com.mortals.framework.service.IUser; import com.mortals.framework.service.IUser;
import com.mortals.xhx.base.system.menu.model.MenuEntity; import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.user.dao.UserDao; import com.mortals.xhx.base.system.user.dao.UserDao;
...@@ -27,11 +26,11 @@ import java.util.Set; ...@@ -27,11 +26,11 @@ import java.util.Set;
* <p>Description: UserService service接口 </p> * <p>Description: UserService service接口 </p>
* <p>Copyright: Copyright &reg; </p> * <p>Copyright: Copyright &reg; </p>
* <p>Company: </p> * <p>Company: </p>
* @author * @author
* @version 1.0.0 * @version 1.0.0
*/ */
public interface UserService extends ICRUDCacheService<UserEntity, Long> { public interface UserService extends ICRUDCacheService<UserEntity,Long> {
/** /**
* 用户登录 * 用户登录
* *
...@@ -41,7 +40,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -41,7 +40,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
UserEntity doLogin(String loginName, String password, String loginIp) throws AppException; UserEntity doLogin(String loginName, String password, String loginIp) throws AppException;
/** /**
* 校验用户名与密码是否正确 * 校验用户名与密码是否正确
...@@ -51,7 +50,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -51,7 +50,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
UserEntity doCheckUser(String loginName, String password) throws AppException; UserEntity doCheckUser(String loginName, String password) throws AppException;
/** /**
* 检查用户是否存在 * 检查用户是否存在
...@@ -60,7 +59,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -60,7 +59,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @param userId 密码 * @param userId 密码
* @return * @return
*/ */
boolean existUser(String loginName, Long userId) throws AppException; boolean existUser(String loginName, Long userId) throws AppException;
/** /**
* 通过登录用户获取菜单功能权限 * 通过登录用户获取菜单功能权限
...@@ -68,7 +67,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -68,7 +67,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @param user * @param user
* @return * @return
*/ */
List<MenuEntity> findOutlookBarList(IUser user); List<MenuEntity> findOutlookBarList(IUser user);
/** /**
* 查询用户所有有权限的菜单ID * 查询用户所有有权限的菜单ID
...@@ -76,7 +75,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -76,7 +75,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @param userEntity * @param userEntity
* @return * @return
*/ */
Set<Long> findAllAuthIds(UserEntity userEntity) throws AppException; Set<Long> findAllAuthIds(UserEntity userEntity) throws AppException;
/** /**
* 查询用户记录 * 查询用户记录
...@@ -88,7 +87,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -88,7 +87,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
Result<UserEntity> find(Long platformId, UserEntity params, int currPage, int prePageResult) throws AppException; Result<UserEntity> find(Long platformId, UserEntity params, int currPage, int prePageResult) throws AppException;
/** /**
* 为客户创建用户 * 为客户创建用户
...@@ -103,8 +102,8 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -103,8 +102,8 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
UserEntity createUser(IUser currUser, Long customerId, String customerName, String loginName, String password, UserEntity createUser(IUser currUser, Long customerId, String customerName, String loginName, String password,
String userName, String mobile) throws AppException; String userName, String mobile) throws AppException;
/** /**
* 用户修改密码 * 用户修改密码
...@@ -115,7 +114,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -115,7 +114,7 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
* @return * @return
* @throws AppException * @throws AppException
*/ */
boolean updateUserPwd(String loginName, String oldPwd, String newPwd) throws AppException; boolean updateUserPwd(String loginName, String oldPwd, String newPwd) throws AppException;
void updateWidthDao(UserEntity userEntity); void updateWidthDao(UserEntity userEntity);
...@@ -124,5 +123,6 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> { ...@@ -124,5 +123,6 @@ public interface UserService extends ICRUDCacheService<UserEntity, Long> {
Rest<Void> refreshUser(); Rest<Void> refreshUser();
UserDao getUserDao(); UserDao getUserDao();
} }
\ No newline at end of file
...@@ -60,11 +60,12 @@ import java.util.stream.Collectors; ...@@ -60,11 +60,12 @@ import java.util.stream.Collectors;
@Service("userService") @Service("userService")
@Slf4j @Slf4j
public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserEntity, Long> implements UserService { public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserEntity, Long> implements UserService {
@Autowired @Autowired
private MenuService menuService; private MenuService menuService;
@Autowired @Autowired
private ResourceService resourceService; private ResourceService resourceService;
@Autowired @Autowired
private RoleUserService roleUserService; private RoleUserService roleUserService;
@Autowired @Autowired
...@@ -103,14 +104,21 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -103,14 +104,21 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
@Override @Override
protected void saveBefore(UserEntity entity, Context context) throws AppException { protected void saveBefore(UserEntity entity, Context context) throws AppException {
if (!ObjectUtils.isEmpty(entity.getLoginName()) && existUser(entity.getLoginName(), entity.getId())) {
throw new AppException("登录名已存在!");
}
this.doHandlerUser(entity); this.doHandlerUser(entity);
} }
@Override @Override
protected void updateBefore(UserEntity entity, Context context) throws AppException { protected void updateBefore(UserEntity entity, Context context) throws AppException {
if (entity.getId().longValue() == SysConstains.ADMIN_ID && !context.getUser().isAdmin()) { // if (entity.getId().longValue() == SysConstains.ADMIN_ID && !context.getUser().isAdmin()) {
throw new AppException("你没有权限执行该操作"); // throw new AppException("你没有权限执行该操作");
} // }
//更新不更新密码字段
entity.setLoginPwd(null);
this.doHandlerUser(entity); this.doHandlerUser(entity);
} }
...@@ -138,25 +146,25 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -138,25 +146,25 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
} }
@Override @Override
protected UserEntity findBefore(UserEntity params, Context context) throws AppException { protected void findAfter(UserEntity params, PageInfo pageInfo, Context context, List<UserEntity> list) throws AppException {
// if (StringUtils.isNotEmpty(params.getDeptIds())) { list.stream().peek(item -> {
// params.setDeptIds(StringUtils.fillWithMark(params.getDeptIds(), ",")); RoleUserQuery roleUserQuery = new RoleUserQuery();
// } roleUserQuery.setUserId(item.getId());
return super.findBefore(params, context); String roleIds = roleUserService.find(roleUserQuery).stream().map(RoleUserEntity::getRoleId).map(String::valueOf).collect(Collectors.joining(","));
item.setRoleIds(roleIds);
}).count();
super.findAfter(params, pageInfo, context, list);
} }
@Override
protected UserEntity findBefore(UserEntity params, PageInfo pageInfo, Context context) throws AppException {
// if (StringUtils.isNotEmpty(params.getDeptIds())) {
// params.setDeptIds(StringUtils.fillWithMark(params.getDeptIds(), ","));
// }
return super.findBefore(params, pageInfo, context);
}
public UserEntity findByLoginName(String loginName) { public UserEntity findByLoginName(String loginName) {
UserQuery params = new UserQuery(); UserQuery params = new UserQuery();
params.setLoginName(loginName); params.setLoginName(loginName);
return this.selectOne(params); List<UserEntity> userList = super.dao.getList(params);
if (userList != null && userList.size() > 0) {
return userList.get(0);
}
return null;
} }
@Override @Override
...@@ -172,7 +180,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -172,7 +180,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
} catch (Exception e) { } catch (Exception e) {
throw new AppException("密码验认出错!", e); throw new AppException("密码验认出错!", e);
} }
return sysUser; return sysUser;
} }
...@@ -216,7 +223,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -216,7 +223,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
urls.addAll(StringUtils.converStr2Set(url)); urls.addAll(StringUtils.converStr2Set(url));
} }
} }
Set<Long> authIds = new HashSet<Long>(); Set<Long> authIds = new HashSet<>();
Map<Long, MenuEntity> menuMap = new HashMap<Long, MenuEntity>(); Map<Long, MenuEntity> menuMap = new HashMap<Long, MenuEntity>();
List<MenuEntity> userModuleList = this.menuService.findAllEnable(); List<MenuEntity> userModuleList = this.menuService.findAllEnable();
for (MenuEntity sysModule : userModuleList) { for (MenuEntity sysModule : userModuleList) {
...@@ -224,6 +231,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -224,6 +231,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
continue; continue;
} }
menuMap.put(sysModule.getId(), sysModule); menuMap.put(sysModule.getId(), sysModule);
if (!user.isAdmin() && urls.contains(StringUtils.trim(sysModule.getUrl()))) { if (!user.isAdmin() && urls.contains(StringUtils.trim(sysModule.getUrl()))) {
authIds.add(sysModule.getId()); authIds.add(sysModule.getId());
} }
...@@ -264,16 +272,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -264,16 +272,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
return super.find(params, pageInfo, null); return super.find(params, pageInfo, null);
} }
@Override
protected void findAfter(UserEntity params, PageInfo pageInfo, Context context, List<UserEntity> list) throws AppException {
list.stream().peek(item -> {
RoleUserQuery roleUserQuery = new RoleUserQuery();
roleUserQuery.setUserId(item.getId());
String roleIds = roleUserService.find(roleUserQuery).stream().map(RoleUserEntity::getRoleId).map(String::valueOf).collect(Collectors.joining(","));
item.setRoleIds(roleIds);
}).count();
super.findAfter(params, pageInfo, context, list);
}
@Override @Override
...@@ -329,7 +327,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -329,7 +327,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
} }
try { try {
sysUser.setLoginPwd(SecurityUtil.md5DoubleEncoding(newPwd)); sysUser.setLoginPwd(SecurityUtil.md5DoubleEncoding(newPwd));
} catch (Exception e) { } catch (Exception e) {
throw new AppException("密码转换异常!", e); throw new AppException("密码转换异常!", e);
} }
...@@ -410,10 +407,11 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -410,10 +407,11 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
List<UserPdu> userPduList = resp.getData().getData(); List<UserPdu> userPduList = resp.getData().getData();
log.info("用户总数量:{}", userPduList.size()); log.info("用户总数量:{}", userPduList.size());
if (!ObjectUtils.isEmpty(userPduList)) { if (!ObjectUtils.isEmpty(userPduList)) {
Map<String, UserPdu> userPduMap = userPduList.stream().collect(Collectors.toMap(x -> x.getLoginName(), y -> y, (x, y) -> x));
List<UserEntity> newUserList = userPduList.stream().map(newUser -> { List<UserEntity> newUserList = userPduList.stream().map(newUser -> {
UserEntity userEntity = new UserEntity(); UserEntity userEntity = new UserEntity();
userEntity.initAttrValue(); userEntity.initAttrValue();
BeanUtils.copyProperties(newUser, userEntity, new String[]{"lastLoginTime", "lastLoginAddress"}); BeanUtils.copyProperties(newUser, userEntity, new String[]{"id", "lastLoginTime", "lastLoginAddress"});
return userEntity; return userEntity;
}).collect(Collectors.toList()); }).collect(Collectors.toList());
...@@ -423,7 +421,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -423,7 +421,6 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
item.setCreateUserId(1L); item.setCreateUserId(1L);
item.setCreateUserName("系统管理员"); item.setCreateUserName("系统管理员");
item.setCreateTime(new Date()); item.setCreateTime(new Date());
item.setId(item.getId());
return item; return item;
} else { } else {
//更新用户列表 //更新用户列表
...@@ -434,13 +431,18 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -434,13 +431,18 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
return item; return item;
} }
}).collect(Collectors.toList()); }).collect(Collectors.toList());
Map<Boolean, List<UserEntity>> saveUpdateCollect = saveUpdateUserList.stream().collect(Collectors.partitioningBy(x -> x.getUpdateUserId() == null)); Map<Boolean, List<UserEntity>> saveUpdateCollect = saveUpdateUserList.stream().collect(Collectors.partitioningBy(x -> x.getId() == null));
if (!ObjectUtils.isEmpty(saveUpdateCollect.get(true))) { if (!ObjectUtils.isEmpty(saveUpdateCollect.get(true))) {
//需要新增的用户 //需要新增的用户
log.info("需要新增用户数量:{}", saveUpdateCollect.get(true).size()); log.info("需要新增用户数量:{}", saveUpdateCollect.get(true).size());
saveUpdateCollect.get(true).stream().forEach(item -> { saveUpdateCollect.get(true).stream().forEach(item -> {
UserPdu pdu = userPduMap.get(item.getLoginName());
if(!ObjectUtils.isEmpty(pdu)){
item.setId(pdu.getId());
}
this.getUserDao().insert(item); this.getUserDao().insert(item);
this.putCache(item.getId() == null ? "" : item.getId().toString(), item); this.putCache(item.getId() == null ? "" : item.getId().toString(), item);
//更新默认用户角色
RoleUserQuery roleUserQuery = new RoleUserQuery(); RoleUserQuery roleUserQuery = new RoleUserQuery();
roleUserQuery.setUserId(item.getId()); roleUserQuery.setUserId(item.getId());
roleUserQuery.setRoleIdList(Arrays.asList(1L)); roleUserQuery.setRoleIdList(Arrays.asList(1L));
...@@ -466,6 +468,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -466,6 +468,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
this.updateUserList(userPduList); this.updateUserList(userPduList);
} }
//查找新增 与更新
} }
return Rest.ok(); return Rest.ok();
} }
...@@ -473,24 +476,15 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -473,24 +476,15 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
@Override @Override
public UserDao getUserDao() { public UserDao getUserDao() {
return this.getDao(); return getDao();
} }
public static void main(String[] args) throws Exception { @Override
//eba467f81fb265befdf1f6ab041d39ab 原始admin密码 protected void removeAfter(Long[] ids, Context context, int result) throws AppException {
super.removeAfter(ids, context, result);
RoleUserQuery roleUserQuery = new RoleUserQuery();
System.out.println(SecurityUtil.md5DoubleEncoding(" 123456 ")); roleUserQuery.setUserIdList(Arrays.asList(ids));
System.out.println(SecurityUtil.md5DoubleEncoding("123")); Long[] userIds = roleUserService.find(roleUserQuery).stream().map(RoleUserEntity::getId).toArray(Long[]::new);
// System.out.println(SecurityUtil.md5DoubleEncoding("Qt123456@")); roleUserService.remove(userIds, context);
/*
//宜宾一体化账号密码
System.out.println(SecurityUtil.md5DoubleEncoding("yibinYTH@123!@#"));
//P@ssw0rd123
System.out.println(SecurityUtil.md5DoubleEncoding("P@ssw0rd123"));*/
} }
} }
\ No newline at end of file
...@@ -9,7 +9,6 @@ import com.mortals.framework.common.code.UserType; ...@@ -9,7 +9,6 @@ import com.mortals.framework.common.code.UserType;
import com.mortals.framework.exception.AppException; import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context; import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.framework.annotation.Operlog; import com.mortals.xhx.base.framework.annotation.Operlog;
import com.mortals.xhx.base.system.role.model.RoleQuery; import com.mortals.xhx.base.system.role.model.RoleQuery;
import com.mortals.xhx.base.system.role.model.RoleUserEntity; import com.mortals.xhx.base.system.role.model.RoleUserEntity;
...@@ -22,14 +21,10 @@ import com.mortals.xhx.common.code.UserStatus; ...@@ -22,14 +21,10 @@ import com.mortals.xhx.common.code.UserStatus;
import io.jsonwebtoken.Claims; import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts; import io.jsonwebtoken.Jwts;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils; import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Base64; import java.util.Base64;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors; import java.util.stream.Collectors;
...@@ -43,7 +38,6 @@ import java.util.stream.Collectors; ...@@ -43,7 +38,6 @@ import java.util.stream.Collectors;
@RequestMapping("user") @RequestMapping("user")
public class UserController extends BaseCRUDJsonBodyMappingController<UserService, UserEntity, Long> { public class UserController extends BaseCRUDJsonBodyMappingController<UserService, UserEntity, Long> {
@Autowired @Autowired
private RoleService roleService; private RoleService roleService;
@Autowired @Autowired
...@@ -55,12 +49,10 @@ public class UserController extends BaseCRUDJsonBodyMappingController<UserServic ...@@ -55,12 +49,10 @@ public class UserController extends BaseCRUDJsonBodyMappingController<UserServic
@Override @Override
protected void init(Map<String, Object> model, Context context) { protected void init(Map<String, Object> model, Context context) {
Map<String, Object> statsus = new HashMap<String, Object>(); this.addDict(model, "userType", IBaseEnum.getEnumMap(UserType.class));
statsus.put("userType", IBaseEnum.getEnumMap(UserType.class)); this.addDict(model, "status", UserStatus.getEnumMap());
statsus.put("status", UserStatus.getEnumMap());
this.addDict(model, "roleIds", roleService.find(new RoleQuery()).stream().collect(Collectors.toMap(x -> x.getId().toString(), y -> y.getName()))); this.addDict(model, "roleIds", roleService.find(new RoleQuery()).stream().collect(Collectors.toMap(x -> x.getId().toString(), y -> y.getName())));
model.put(KEY_RESULT_DICT, statsus);
} }
@Override @Override
...@@ -83,6 +75,21 @@ public class UserController extends BaseCRUDJsonBodyMappingController<UserServic ...@@ -83,6 +75,21 @@ public class UserController extends BaseCRUDJsonBodyMappingController<UserServic
return super.editAfter(id, model, entity, context); return super.editAfter(id, model, entity, context);
} }
@Override
protected int saveAfter(UserEntity entity, Map<String, Object> model, Context context) throws AppException {
return super.saveAfter(entity, model, context);
}
// @Override
// protected void saveBefore(UserEntity entity, Map<String, Object> model, Context context) throws AppException {
// if (!ObjectUtils.isEmpty(entity.getLoginName()) && service.existUser(entity.getLoginName(), entity.getId())) {
// throw new AppException("登录名已存在!");
// }
// super.saveBefore(entity, model, context);
// }
@RequestMapping(value = "change/password", method = RequestMethod.POST) @RequestMapping(value = "change/password", method = RequestMethod.POST)
@Operlog(msg = "密码修改成功!") @Operlog(msg = "密码修改成功!")
public String changePassword(@RequestParam String oldPwd, @RequestParam String newPwd) { public String changePassword(@RequestParam String oldPwd, @RequestParam String newPwd) {
......
...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.valid.dao.ibatis; ...@@ -11,7 +11,6 @@ package com.mortals.xhx.base.system.valid.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis; import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.valid.dao.ValidCodeDao; import com.mortals.xhx.base.system.valid.dao.ValidCodeDao;
import com.mortals.xhx.base.system.valid.model.ValidCodeEntity; import com.mortals.xhx.base.system.valid.model.ValidCodeEntity;
import org.springframework.stereotype.Repository; import org.springframework.stereotype.Repository;
/** /**
......
...@@ -8,10 +8,10 @@ ...@@ -8,10 +8,10 @@
package com.mortals.xhx.base.system.valid.model; package com.mortals.xhx.base.system.valid.model;
import java.util.Date;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import java.util.Date;
/** /**
* <p>Title: 验证码信息</p> * <p>Title: 验证码信息</p>
* <p>Description: ValidCodeEntity </p> * <p>Description: ValidCodeEntity </p>
......
...@@ -16,7 +16,6 @@ import com.mortals.xhx.base.system.valid.dao.ValidCodeDao; ...@@ -16,7 +16,6 @@ import com.mortals.xhx.base.system.valid.dao.ValidCodeDao;
import com.mortals.xhx.base.system.valid.model.ValidCodeEntity; import com.mortals.xhx.base.system.valid.model.ValidCodeEntity;
import com.mortals.xhx.base.system.valid.model.ValidCodeQuery; import com.mortals.xhx.base.system.valid.model.ValidCodeQuery;
import com.mortals.xhx.base.system.valid.service.ValidCodeService; import com.mortals.xhx.base.system.valid.service.ValidCodeService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.Calendar; import java.util.Calendar;
......
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 权限类型 (0.无限制,1.无需登录查看,2.需要登录查看,3.需要角色权限查看)枚举类
*
* @author zxfei
*/
public enum AuthTypeEnum {
无限制(0, "无限制"),
无需登录查看(1, "无需登录查看"),
需要登录查看(2, "需要登录查看"),
需要角色权限查看(3, "需要角色权限查看");
private Integer value;
private String desc;
AuthTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static AuthTypeEnum getByValue(Integer value) {
for (AuthTypeEnum authTypeEnum : AuthTypeEnum.values()) {
if (authTypeEnum.getValue() == value) {
return authTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (AuthTypeEnum item : AuthTypeEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 是否常用菜单 (0.非常用,1.常用)枚举类
*
* @author zxfei
*/
public enum CommMenuEnum {
非常用(0, "非常用"),
常用(1, "常用");
private Integer value;
private String desc;
CommMenuEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static CommMenuEnum getByValue(Integer value) {
for (CommMenuEnum commMenuEnum : CommMenuEnum.values()) {
if (commMenuEnum.getValue() == value) {
return commMenuEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (CommMenuEnum item : CommMenuEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 客户使用状态枚举类
*/
public enum CustomerSatusEnum implements IBaseEnum {
NORMAL(1,"启用", SysConstains.STYLE_DEFAULT),
DISABLE(0,"禁用", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
CustomerSatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static CustomerSatusEnum getByValue(int value) {
for (CustomerSatusEnum e : CustomerSatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (CustomerSatusEnum item : CustomerSatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 客户来源枚举类
*/
public enum CustomerSrcEnum implements IBaseEnum {
ON_TRIAL(1,"申请试用", SysConstains.STYLE_DEFAULT),
SIGNING(2,"顾问签单", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
CustomerSrcEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static CustomerSrcEnum getByValue(int value) {
for (CustomerSrcEnum e : CustomerSrcEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (CustomerSrcEnum item : CustomerSrcEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备请求方式,1:新增,2:修改,3:删除,4:激活,5:启用,6:停用
*
* @author zxfei
*/
public enum DeviceMethodEnum {
ADD(1, "新增"),
UPDATE(2, "修改"),
DEL(3, "删除"),
ACTIVE(4, "激活"),
ENABLED(5, "启用"),
STOP(6, "停用"),
ONLINE(7, "上线"),
OFFLINE(8, "下线")
;
private Integer value;
private String desc;
DeviceMethodEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceMethodEnum getByValue(Integer value) {
for (DeviceMethodEnum deviceTypeEnum : DeviceMethodEnum.values()) {
if (deviceTypeEnum.getValue() == value) {
return deviceTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceMethodEnum item : DeviceMethodEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备来源(0.旧设备,1.新设备)枚举类
*
* @author zxfei
*/
public enum DeviceSourceEnum {
旧设备(0, "旧设备"),
新设备(1, "新设备");
private Integer value;
private String desc;
DeviceSourceEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceSourceEnum getByValue(Integer value) {
for (DeviceSourceEnum sourceEnum : DeviceSourceEnum.values()) {
if (sourceEnum.getValue() == value) {
return sourceEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceSourceEnum item : DeviceSourceEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备来源(0.子设备,1.网关设备,2.直连设备)枚举类
*
* @author zxfei
*/
public enum DeviceSrcEnum {
子设备(0, "子设备"),
网关设备(1, "网关设备"),
直连设备(2, "直连设备");
private Integer value;
private String desc;
DeviceSrcEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceSrcEnum getByValue(Integer value) {
for (DeviceSrcEnum deviceSrcEnum : DeviceSrcEnum.values()) {
if (deviceSrcEnum.getValue() == value) {
return deviceSrcEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceSrcEnum item : DeviceSrcEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 设备状态 (0.未激活,1.离线,2.在线)枚举类
*
* @author zxfei
*/
public enum DeviceStatusEnum {
未激活(0, "未激活"),
离线(1, "离线"),
在线(2, "在线");
private Integer value;
private String desc;
DeviceStatusEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DeviceStatusEnum getByValue(Integer value) {
for (DeviceStatusEnum deviceStatusEnum : DeviceStatusEnum.values()) {
if (deviceStatusEnum.getValue() == value) {
return deviceStatusEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DeviceStatusEnum item : DeviceStatusEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 启用状态 (0.停止,1.启用)枚举类
*
* @author zxfei
*/
public enum EnabledEnum {
停止(0, "停止"),
启用(1, "启用");
private Integer value;
private String desc;
EnabledEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static EnabledEnum getByValue(Integer value) {
for (EnabledEnum enabledEnum : EnabledEnum.values()) {
if (enabledEnum.getValue() == value) {
return enabledEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (EnabledEnum item : EnabledEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 评价等级
*/
public enum EvaluateLevelEnum implements IBaseEnum {
LEVEL_0(0,"未评价",SysConstains.STYLE_DEFAULT),
LEVEL_1(1,"非常不满意",SysConstains.STYLE_DEFAULT),
LEVEL_2(2,"不满意", SysConstains.STYLE_DEFAULT),
LEVEL_3(3,"基本满意",SysConstains.STYLE_DEFAULT),
LEVEL_4(4,"满意", SysConstains.STYLE_DEFAULT),
LEVEL_5(5,"完美解决问题", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
EvaluateLevelEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static EvaluateLevelEnum getByValue(int value) {
for (EvaluateLevelEnum e : EvaluateLevelEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (EvaluateLevelEnum item : EvaluateLevelEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 评价类型
*/
public enum EvaluateType implements IBaseEnum {
USEFUL(1,"有用", SysConstains.STYLE_DEFAULT),
USELESS(2,"没用", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
EvaluateType(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static EvaluateType getByValue(int value) {
for (EvaluateType e : EvaluateType.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (EvaluateType item : EvaluateType.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 是否推荐(0.未推荐,1.推荐)枚举类
*
* @author zxfei
*/
public enum IsRecommendEnum {
未推荐(0, "未推荐"),
推荐(1, "推荐");
private Integer value;
private String desc;
IsRecommendEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static IsRecommendEnum getByValue(Integer value) {
for (IsRecommendEnum isRecommendEnum : IsRecommendEnum.values()) {
if (isRecommendEnum.getValue() == value) {
return isRecommendEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (IsRecommendEnum item : IsRecommendEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 链接方式 (0.普通,1.弹出,2.脚本)枚举类
*
* @author zxfei
*/
public enum LinkTypeEnum {
普通(0, "普通"),
弹出(1, "弹出"),
脚本(2, "脚本");
private Integer value;
private String desc;
LinkTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static LinkTypeEnum getByValue(Integer value) {
for (LinkTypeEnum linkTypeEnum : LinkTypeEnum.values()) {
if (linkTypeEnum.getValue() == value) {
return linkTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (LinkTypeEnum item : LinkTypeEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 会员等级枚举类
*/
public enum MemberLevelEnum implements IBaseEnum {
NOT_OPEN(0,"未开启", SysConstains.STYLE_DEFAULT),
ON_TRIAL(1,"试用客户", SysConstains.STYLE_DEFAULT),
VIP(2,"VIP客户", SysConstains.STYLE_DEFAULT),
DESIGNER(3,"设计师", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
MemberLevelEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static MemberLevelEnum getByValue(int value) {
for (MemberLevelEnum e : MemberLevelEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (MemberLevelEnum item : MemberLevelEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 菜单类型 (0.目录,1.菜单,2.按钮)枚举类
*
* @author zxfei
*/
public enum MenuTypeEnum {
目录(0, "目录"),
菜单(1, "菜单"),
按钮(2, "按钮");
private Integer value;
private String desc;
MenuTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static MenuTypeEnum getByValue(Integer value) {
for (MenuTypeEnum menuTypeEnum : MenuTypeEnum.values()) {
if (menuTypeEnum.getValue() == value) {
return menuTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (MenuTypeEnum item : MenuTypeEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 方法name path枚举类
*
* @author zxfei
*/
public enum MethodNameEnum {
list("list", "列表"),
delete("delete", "删除"),
logicDelete("logicDelete", "逻辑删除"),
saveOrUpdate("save", "保存更新"),
batchSave("batchSave", "批量保存更新"),
info("info", "详细"),
exportExcel("exportExcel", "导出excel"),
importData("importData", "导入excel"),
downloadTemplate("downloadTemplate", "下载模板"),
view("view", "详情");
private String value;
private String desc;
MethodNameEnum(String value, String desc) {
this.value = value;
this.desc = desc;
}
public String getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static MethodNameEnum getByValue(String value) {
for (MethodNameEnum wySigninEnum : MethodNameEnum.values()) {
if (wySigninEnum.getValue() == value) {
return wySigninEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(String... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (MethodNameEnum item : MethodNameEnum.values()) {
try {
boolean hasE = false;
for (String e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 图片素材类型枚举
*/
public enum PictureTypeEnum implements IBaseEnum {
PICTURE(0,"普通图片", SysConstains.STYLE_DEFAULT),
ELEMENT(1,"素材图片", SysConstains.STYLE_DEFAULT),
BACKGROUND(2,"背景图片", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
PictureTypeEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static CustomerSatusEnum getByValue(int value) {
for (CustomerSatusEnum e : CustomerSatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (CustomerSatusEnum item : CustomerSatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 问题记录类型
*/
public enum QuestionRecordType implements IBaseEnum {
QUESTION(1,"提问", SysConstains.STYLE_DEFAULT),
ANSWER(2,"答复", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
QuestionRecordType(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static QuestionRecordType getByValue(int value) {
for (QuestionRecordType e : QuestionRecordType.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (QuestionRecordType item : QuestionRecordType.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 问答状态
*/
public enum QuestionStatusEnum implements IBaseEnum {
NOT_FINISHED(0,"未完成", SysConstains.STYLE_DEFAULT),
Finished(1,"已完成", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
QuestionStatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static QuestionStatusEnum getByValue(int value) {
for (QuestionStatusEnum e : QuestionStatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (QuestionStatusEnum item : QuestionStatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 查阅状态
*/
public enum ReadStatusEnum implements IBaseEnum {
READ(1,"已读", SysConstains.STYLE_DEFAULT),
UN_READ(0,"未读", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
ReadStatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static ReadStatusEnum getByValue(int value) {
for (ReadStatusEnum e : ReadStatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (ReadStatusEnum item : ReadStatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 客户建议回复状态
*/
public enum ReplyStatusEnum implements IBaseEnum {
UN_REPLY(0,"未回复", SysConstains.STYLE_DEFAULT),
REPLY(1,"已回复", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
ReplyStatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static ReplyStatusEnum getByValue(int value) {
for (ReplyStatusEnum e : ReplyStatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (ReplyStatusEnum item : ReplyStatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 发送方式
*/
public enum SendModeEnum implements IBaseEnum {
ON_SITE(1,"站内发送", SysConstains.STYLE_DEFAULT),
ON_SMS(2,"短信发送", SysConstains.STYLE_DEFAULT),
ALL(3,"同时发送", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
SendModeEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static SendModeEnum getByValue(int value) {
for (SendModeEnum e : SendModeEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (SendModeEnum item : SendModeEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 发送范围
*/
public enum SendScopeEnum implements IBaseEnum {
ALL(1,"所有人可见", SysConstains.STYLE_DEFAULT),
VIP(2,"VIP可见", SysConstains.STYLE_DEFAULT),
ORDINARY(3,"普通用户可见", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
SendScopeEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static SendScopeEnum getByValue(int value) {
for (SendScopeEnum e : SendScopeEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (SendScopeEnum item : SendScopeEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 发送状态
*/
public enum SendStatusEnum implements IBaseEnum {
UNSENT(0,"未发送", SysConstains.STYLE_DEFAULT),
SENT(1,"已发送", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
SendStatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static SendStatusEnum getByValue(int value) {
for (SendStatusEnum e : SendStatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (SendStatusEnum item : SendStatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
public enum SexEnum implements IBaseEnum {
MALE(1,"男性", SysConstains.STYLE_DEFAULT),
FEMALE(2,"女性", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
SexEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static SexEnum getByValue(int value) {
for (SexEnum e : SexEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (SexEnum item : SexEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 客户试用受理状态枚举类
*/
public enum TrialAcceptEnum implements IBaseEnum {
NOT_ACCEPTED(0,"未受理", SysConstains.STYLE_DEFAULT),
AGREE(1,"同意", SysConstains.STYLE_DEFAULT),
DISAGREE(2,"不同意", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
TrialAcceptEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static TrialAcceptEnum getByValue(int value) {
for (TrialAcceptEnum e : TrialAcceptEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (TrialAcceptEnum item : TrialAcceptEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 菜单显示状态 (0.显示,1.隐藏)枚举类
*
* @author zxfei
*/
public enum VisibleEnum {
显示(0, "显示"),
隐藏(1, "隐藏");
private Integer value;
private String desc;
VisibleEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static VisibleEnum getByValue(Integer value) {
for (VisibleEnum visibleEnum : VisibleEnum.values()) {
if (visibleEnum.getValue() == value) {
return visibleEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (VisibleEnum item : VisibleEnum.values()) {
try {
boolean hasE = false;
for (Integer e : eItem) {
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception ex) {
}
}
return resultMap;
}
}
\ No newline at end of file
package com.mortals.xhx.common.code;
import com.mortals.framework.ap.SysConstains;
import com.mortals.framework.common.IBaseEnum;
import java.util.LinkedHashMap;
import java.util.Map;
public enum WorkDesignStatusEnum implements IBaseEnum {
DRAFT(1,"草稿", SysConstains.STYLE_DEFAULT),
RELEASE(2,"发布", SysConstains.STYLE_DEFAULT),
;
private int value;
private String desc;
private String style;
WorkDesignStatusEnum(int value, String desc, String style) {
this.value = value;
this.desc = desc;
this.style = style;
}
@Override
public int getValue() {
return this.value;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public String getStyle() {
return this.style;
}
public static WorkDesignStatusEnum getByValue(int value) {
for (WorkDesignStatusEnum e : WorkDesignStatusEnum.values()) {
if (e.getValue() == value) {
return e;
}
}
return null;
}
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (WorkDesignStatusEnum item : WorkDesignStatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
...@@ -4,6 +4,9 @@ import cn.hutool.core.util.StrUtil; ...@@ -4,6 +4,9 @@ import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth; import com.mortals.framework.annotation.UnAuth;
import com.mortals.xhx.base.system.resource.model.ResourceEntity; import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import com.mortals.xhx.common.code.MethodNameEnum;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
...@@ -17,65 +20,46 @@ import java.lang.reflect.Method; ...@@ -17,65 +20,46 @@ import java.lang.reflect.Method;
import java.net.JarURLConnection; import java.net.JarURLConnection;
import java.net.URL; import java.net.URL;
import java.net.URLDecoder; import java.net.URLDecoder;
import java.util.*; import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry; import java.util.jar.JarEntry;
import java.util.jar.JarFile; import java.util.jar.JarFile;
import java.util.stream.Collectors;
@Slf4j
public class ControllerScanUtil { public class ControllerScanUtil {
/**
* 查看类路径
*/
public static final String[] ULR_VIEW = {"view", "info", "list", "get", "find", "export", "download",
"index", "bill"};
public static final String[] WHITE_URL = {"login", "test","file","securitycode"}; public static final String[] WHITE_URL = {"login", "test", "file", "securitycode"};
public static void main(String[] args) { public static void main(String[] args) {
List<Class<?>> classList = getAllClassByPackageName("com.mortals.xhx"); List<Class<?>> classList = getAllClassByPackageName("com.mortals.xhx.base.system.menu");
//System.out.println(classList); //获取到了所有的类 //System.out.println(classList); //获取到了所有的类
getAnnotationInfo(classList); List<ResourceEntity> list = getAnnotationInfo(classList);
log.info(JSONObject.toJSONString(list));
} }
public static List<ResourceEntity> getAnnotationInfo(List<Class<?>> clsList) { public static List<ResourceEntity> getAnnotationInfo(List<Class<?>> clsList) {
List<ResourceEntity> resourceArrayList = new ArrayList<>(); List<ResourceEntity> resourceArrayList = new ArrayList<>();
if (clsList != null && clsList.size() > 0) { if (clsList != null && clsList.size() > 0) {
for (Class<?> cls : clsList) { for (Class<?> cls : clsList) {
boolean exits = cls.isAnnotationPresent(RestController.class); boolean exits = cls.isAnnotationPresent(RestController.class);
if (!exits) { if (!exits) {
continue; continue;
} }
//白名单地址的 也不需要 //获取controller类,
ResourceEntity resourceViewEntity = new ResourceEntity();
resourceViewEntity.initAttrValue();
ResourceEntity resourceEditEntity = new ResourceEntity();
resourceEditEntity.initAttrValue();
Method substringMethod = null; Method substringMethod = null;
String result = ""; String result = "";
try { try {
substringMethod = cls.getMethod("getModuleDesc");
String packName = cls.getPackage().getName(); if(!ObjectUtils.isEmpty(substringMethod)){
if (StrUtil.contains(packName, "system")) { result = (String) substringMethod.invoke(cls.getDeclaredConstructor().newInstance());
//系统管理-xx管理-
substringMethod = cls.getMethod("getModuleDesc");
result = (String) substringMethod.invoke(cls.newInstance());
resourceViewEntity.setName("系统管理-" + result + "管理-查看");
resourceEditEntity.setName("系统管理-" + result + "管理-维护");
} else {
substringMethod = cls.getMethod("getModuleDesc");
result = (String) substringMethod.invoke(cls.newInstance());
resourceViewEntity.setName(result + "-查看");
resourceEditEntity.setName(result + "-维护");
} }
} catch (Exception e) { } catch (Exception e) {
log.error("反射获取controller类异常", e.getMessage());
} }
//获取基础路径
RequestMapping requestMappingCls = cls.getAnnotation(RequestMapping.class); RequestMapping requestMappingCls = cls.getAnnotation(RequestMapping.class);
String prefix = ""; String prefix = "";
if (requestMappingCls != null) { if (requestMappingCls != null) {
...@@ -96,105 +80,107 @@ public class ControllerScanUtil { ...@@ -96,105 +80,107 @@ public class ControllerScanUtil {
if (requestMappingCls != null) { if (requestMappingCls != null) {
result = StrUtil.removeSuffix(StrUtil.removePrefix(requestMappingCls.value()[0].toUpperCase(), "/"), "/") + "接口模块"; result = StrUtil.removeSuffix(StrUtil.removePrefix(requestMappingCls.value()[0].toUpperCase(), "/"), "/") + "接口模块";
} }
resourceViewEntity.setName(result + "-查看");
resourceEditEntity.setName(result + "-维护");
} }
Set<String> urlSet = new HashSet<>();
//获取类中的所有的方法 //获取类中的所有的方法 并生成resourceEntity
Method[] methods = cls.getDeclaredMethods(); Method[] methods = cls.getDeclaredMethods();
if (methods != null && methods.length > 0) { if (!ObjectUtils.isEmpty(methods)) {
for (Method method : methods) { for (Method method : methods) {
boolean unAuth = method.isAnnotationPresent(UnAuth.class); boolean unAuth = method.isAnnotationPresent(UnAuth.class);
if (unAuth) { if (unAuth) {
continue; continue;
} }
String name = "其它";
String url = "";
boolean mExits = method.isAnnotationPresent(RequestMapping.class); boolean mExits = method.isAnnotationPresent(RequestMapping.class);
if (mExits) { if (mExits) {
RequestMapping requestMapping = method.getAnnotation(RequestMapping.class); RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
String url = prefix + "/" + requestMapping.value()[0]; url = prefix + "/" + requestMapping.value()[0];
url = url.replaceAll("/+", "/");
urlSet.add(url);
} }
boolean mExits1 = method.isAnnotationPresent(GetMapping.class); boolean mExits1 = method.isAnnotationPresent(GetMapping.class);
if (mExits1) { if (mExits1) {
GetMapping getMapping = method.getAnnotation(GetMapping.class); GetMapping getMapping = method.getAnnotation(GetMapping.class);
String url = prefix + "/" + getMapping.value()[0]; url = prefix + "/" + getMapping.value()[0];
url = url.replaceAll("/+", "/");
urlSet.add(url);
} }
boolean mExits2 = method.isAnnotationPresent(PostMapping.class); boolean mExits2 = method.isAnnotationPresent(PostMapping.class);
if (mExits2) { if (mExits2) {
PostMapping postMapping = method.getAnnotation(PostMapping.class); PostMapping postMapping = method.getAnnotation(PostMapping.class);
String url = prefix + "/" + postMapping.value()[0]; url = prefix + "/" + postMapping.value()[0];
url = url.replaceAll("/+", "/");
urlSet.add(url);
} }
if (!ObjectUtils.isEmpty(url)){
ResourceEntity resourceEntity = buildResourceEntity( result, method, url, name);
resourceArrayList.add(resourceEntity);
}
} }
} }
//获取超类中的方法 //获取超类中的方法
Method[] superMethods = cls.getSuperclass().getDeclaredMethods(); Method[] superMethods = cls.getSuperclass().getDeclaredMethods();
if (superMethods != null && superMethods.length > 0) { if (!ObjectUtils.isEmpty(superMethods)) {
for (Method method : superMethods) { for (Method method : superMethods) {
boolean unAuth = method.isAnnotationPresent(UnAuth.class); boolean unAuth = method.isAnnotationPresent(UnAuth.class);
if (unAuth) { if (unAuth) {
continue; continue;
} }
String name = "其它";
String url = "";
boolean mExits = method.isAnnotationPresent(RequestMapping.class); boolean mExits = method.isAnnotationPresent(RequestMapping.class);
if (mExits) { if (mExits) {
RequestMapping requestMapping = method.getAnnotation(RequestMapping.class); RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
String url = prefix + "/" + requestMapping.value()[0]; url = prefix + "/" + requestMapping.value()[0];
url = url.replaceAll("/+", "/"); //判断路径是否存在枚举类中
urlSet.add(url); MethodNameEnum[] values = MethodNameEnum.values();
for (MethodNameEnum value : values) {
boolean contains = StrUtil.contains(requestMapping.value()[0], value.getValue());
if (contains) {
name = value.getDesc();
break;
}
}
} }
boolean mExits1 = method.isAnnotationPresent(GetMapping.class); boolean mExits1 = method.isAnnotationPresent(GetMapping.class);
if (mExits1) { if (mExits1) {
GetMapping getMapping = method.getAnnotation(GetMapping.class); GetMapping getMapping = method.getAnnotation(GetMapping.class);
String url = prefix + "/" + getMapping.value()[0]; url = prefix + "/" + getMapping.value()[0];
url = url.replaceAll("/+", "/"); //判断路径是否存在枚举类中
urlSet.add(url); MethodNameEnum[] values = MethodNameEnum.values();
for (MethodNameEnum value : values) {
boolean contains = StrUtil.contains(getMapping.value()[0], value.getValue());
if (contains) {
name = value.getDesc();
break;
}
}
} }
boolean mExits2 = method.isAnnotationPresent(PostMapping.class); boolean mExits2 = method.isAnnotationPresent(PostMapping.class);
if (mExits2) { if (mExits2) {
PostMapping postMapping = method.getAnnotation(PostMapping.class); PostMapping postMapping = method.getAnnotation(PostMapping.class);
String url = prefix + "/" + postMapping.value()[0]; url = prefix + "/" + postMapping.value()[0];
url = url.replaceAll("/+", "/"); MethodNameEnum[] values = MethodNameEnum.values();
urlSet.add(url); for (MethodNameEnum value : values) {
} boolean contains = StrUtil.contains(postMapping.value()[0], value.getValue());
} if (contains) {
} name = value.getDesc();
break;
if (!ObjectUtils.isEmpty(urlSet)) { }
Set<String> UrlViewSet = new HashSet<>();
Set<String> UrlEditSet = new HashSet<>();
for (String url : urlSet) {
String str = StrUtil.subAfter(url, "/", true);
boolean bool = false;
for (String checkStr : ULR_VIEW) {
boolean contains = StrUtil.contains(str.toLowerCase(), checkStr);
if (contains) {
UrlViewSet.add(url);
bool = true;
break;
} }
} }
if (!bool) {
UrlEditSet.add(url); if (!ObjectUtils.isEmpty(url)){
ResourceEntity resourceEntity = buildResourceEntity( result, method, url, name);
resourceArrayList.add(resourceEntity);
} }
} }
resourceViewEntity.setUrl(UrlViewSet.stream().collect(Collectors.joining(",")));
System.out.println(JSONObject.toJSONString(resourceViewEntity));
resourceArrayList.add(resourceViewEntity);
resourceEditEntity.setUrl(UrlEditSet.stream().collect(Collectors.joining(",")));
System.out.println(JSONObject.toJSONString(resourceEditEntity));
resourceArrayList.add(resourceEditEntity);
} }
} }
} }
...@@ -202,6 +188,25 @@ public class ControllerScanUtil { ...@@ -202,6 +188,25 @@ public class ControllerScanUtil {
return resourceArrayList; return resourceArrayList;
} }
private static ResourceEntity buildResourceEntity( String result, Method method, String url, String name) {
url = url.replaceAll("/+", "/");
//判断方法上是否有ApiOperation注解 有读取名称
ApiOperation annotation = method.getAnnotation(ApiOperation.class);
if (annotation != null) {
name = annotation.value();
}
ResourceEntity resourceEntity = new ResourceEntity();
resourceEntity.initAttrValue();
resourceEntity.setName(name);
resourceEntity.setGroupName(result);
resourceEntity.setUrl(url);
resourceEntity.setCreateTime(new Date());
resourceEntity.setCreateUserId(1L);
resourceEntity.setCreateUserName("admin");
return resourceEntity;
}
public static List<Class<?>> getAllClassByPackageName(String packageName) { public static List<Class<?>> getAllClassByPackageName(String packageName) {
// 获取当前包下以及子包下所以的类 // 获取当前包下以及子包下所以的类
List<Class<?>> returnClassList = getClasses(packageName); List<Class<?>> returnClassList = getClasses(packageName);
......
...@@ -3,6 +3,7 @@ package com.mortals.xhx.daemon.applicationservice; ...@@ -3,6 +3,7 @@ package com.mortals.xhx.daemon.applicationservice;
import com.mortals.framework.service.ICacheService; import com.mortals.framework.service.ICacheService;
import com.mortals.framework.springcloud.service.IApplicationStartedService; import com.mortals.framework.springcloud.service.IApplicationStartedService;
import com.mortals.framework.util.ThreadPool; import com.mortals.framework.util.ThreadPool;
import com.mortals.xhx.base.system.resource.service.ResourceService;
import com.mortals.xhx.base.system.user.service.UserService; import com.mortals.xhx.base.system.user.service.UserService;
import com.mortals.xhx.module.site.service.SiteService; import com.mortals.xhx.module.site.service.SiteService;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
...@@ -18,9 +19,9 @@ public class DemoStartedService implements IApplicationStartedService { ...@@ -18,9 +19,9 @@ public class DemoStartedService implements IApplicationStartedService {
@Autowired @Autowired
private ICacheService cacheService; private ICacheService cacheService;
@Autowired @Autowired
private SiteService siteService;
@Autowired
private UserService userService; private UserService userService;
@Autowired
private ResourceService resourceService;
@Override @Override
public void start() { public void start() {
...@@ -34,6 +35,12 @@ public class DemoStartedService implements IApplicationStartedService { ...@@ -34,6 +35,12 @@ public class DemoStartedService implements IApplicationStartedService {
} catch (Exception e) { } catch (Exception e) {
log.error("获取所有站点用户失败", e); log.error("获取所有站点用户失败", e);
} }
try {
resourceService.refreshResourceUrl("com.mortals.xhx", null);
} catch (Exception e) {
log.error("刷新资源失败", e);
}
} }
@Override @Override
......
<?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.menu.dao.ibatis.MenuDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MenuEntity" id="MenuEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="url" column="url" />
<result property="ancestors" column="ancestors" />
<result property="parentId" column="parentId" />
<result property="linkType" column="linkType" />
<result property="imgPath" column="imgPath" />
<result property="buttonImgPath" column="buttonImgPath" />
<result property="imgCommPath" column="imgCommPath" />
<result property="commMenu" column="commMenu" />
<result property="component" column="component" />
<result property="menuType" column="menuType" />
<result property="authType" column="authType" />
<result property="visible" column="visible" />
<result property="perms" column="perms" />
<result property="remark" column="remark" />
<result property="orderId" column="orderId" />
<result property="status" column="status" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
<result property="cache" column="cache" />
<result property="activeDir" column="activeDir" />
<result property="hideChildrenInMenu" column="hideChildrenInMenu" />
<result property="resourceUrl" column="resourceUrl" />
</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('name') or colPickMode == 1 and data.containsKey('name')))">
a.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,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ancestors') or colPickMode == 1 and data.containsKey('ancestors')))">
a.ancestors,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('parentId') or colPickMode == 1 and data.containsKey('parentId')))">
a.parentId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('linkType') or colPickMode == 1 and data.containsKey('linkType')))">
a.linkType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgPath') or colPickMode == 1 and data.containsKey('imgPath')))">
a.imgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('buttonImgPath') or colPickMode == 1 and data.containsKey('buttonImgPath')))">
a.buttonImgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgCommPath') or colPickMode == 1 and data.containsKey('imgCommPath')))">
a.imgCommPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('commMenu') or colPickMode == 1 and data.containsKey('commMenu')))">
a.commMenu,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('component') or colPickMode == 1 and data.containsKey('component')))">
a.component,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuType') or colPickMode == 1 and data.containsKey('menuType')))">
a.menuType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('authType') or colPickMode == 1 and data.containsKey('authType')))">
a.authType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('visible') or colPickMode == 1 and data.containsKey('visible')))">
a.visible,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('perms') or colPickMode == 1 and data.containsKey('perms')))">
a.perms,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('orderId') or colPickMode == 1 and data.containsKey('orderId')))">
a.orderId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status,
</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>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('cache') or colPickMode == 1 and data.containsKey('cache')))">
a.cache,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('activeDir') or colPickMode == 1 and data.containsKey('activeDir')))">
a.activeDir,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hideChildrenInMenu') or colPickMode == 1 and data.containsKey('hideChildrenInMenu')))">
a.hideChildrenInMenu,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceUrl') or colPickMode == 1 and data.containsKey('resourceUrl')))">
a.resourceUrl,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MenuEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_menu
(name,url,ancestors,parentId,linkType,imgPath,buttonImgPath,imgCommPath,commMenu,component,menuType,authType,visible,perms,remark,orderId,status,createTime,createUserId,createUserName,updateUserId,updateUserName,updateTime,cache,activeDir,hideChildrenInMenu,resourceUrl)
VALUES
(#{name},#{url},#{ancestors},#{parentId},#{linkType},#{imgPath},#{buttonImgPath},#{imgCommPath},#{commMenu},#{component},#{menuType},#{authType},#{visible},#{perms},#{remark},#{orderId},#{status},#{createTime},#{createUserId},#{createUserName},#{updateUserId},#{updateUserName},#{updateTime},#{cache},#{activeDir},#{hideChildrenInMenu},#{resourceUrl})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_menu
(name,url,ancestors,parentId,linkType,imgPath,buttonImgPath,imgCommPath,commMenu,component,menuType,authType,visible,perms,remark,orderId,status,createTime,createUserId,createUserName,updateUserId,updateUserName,updateTime,cache,activeDir,hideChildrenInMenu,resourceUrl)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.ancestors},#{item.parentId},#{item.linkType},#{item.imgPath},#{item.buttonImgPath},#{item.imgCommPath},#{item.commMenu},#{item.component},#{item.menuType},#{item.authType},#{item.visible},#{item.perms},#{item.remark},#{item.orderId},#{item.status},#{item.createTime},#{item.createUserId},#{item.createUserName},#{item.updateUserId},#{item.updateUserName},#{item.updateTime},#{item.cache},#{item.activeDir},#{item.hideChildrenInMenu},#{item.resourceUrl})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_menu 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('ancestors')) or (colPickMode==1 and !data.containsKey('ancestors'))">
a.ancestors=#{data.ancestors},
</if>
<if test="(colPickMode==0 and data.containsKey('parentId')) or (colPickMode==1 and !data.containsKey('parentId'))">
a.parentId=#{data.parentId},
</if>
<if test="(colPickMode==0 and data.containsKey('parentIdIncrement')) or (colPickMode==1 and !data.containsKey('parentIdIncrement'))">
a.parentId=ifnull(a.parentId,0) + #{data.parentIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('linkType')) or (colPickMode==1 and !data.containsKey('linkType'))">
a.linkType=#{data.linkType},
</if>
<if test="(colPickMode==0 and data.containsKey('linkTypeIncrement')) or (colPickMode==1 and !data.containsKey('linkTypeIncrement'))">
a.linkType=ifnull(a.linkType,0) + #{data.linkTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('imgPath')) or (colPickMode==1 and !data.containsKey('imgPath'))">
a.imgPath=#{data.imgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('buttonImgPath')) or (colPickMode==1 and !data.containsKey('buttonImgPath'))">
a.buttonImgPath=#{data.buttonImgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('imgCommPath')) or (colPickMode==1 and !data.containsKey('imgCommPath'))">
a.imgCommPath=#{data.imgCommPath},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenu')) or (colPickMode==1 and !data.containsKey('commMenu'))">
a.commMenu=#{data.commMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenuIncrement')) or (colPickMode==1 and !data.containsKey('commMenuIncrement'))">
a.commMenu=ifnull(a.commMenu,0) + #{data.commMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('component')) or (colPickMode==1 and !data.containsKey('component'))">
a.component=#{data.component},
</if>
<if test="(colPickMode==0 and data.containsKey('menuType')) or (colPickMode==1 and !data.containsKey('menuType'))">
a.menuType=#{data.menuType},
</if>
<if test="(colPickMode==0 and data.containsKey('menuTypeIncrement')) or (colPickMode==1 and !data.containsKey('menuTypeIncrement'))">
a.menuType=ifnull(a.menuType,0) + #{data.menuTypeIncrement},
</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('visible')) or (colPickMode==1 and !data.containsKey('visible'))">
a.visible=#{data.visible},
</if>
<if test="(colPickMode==0 and data.containsKey('visibleIncrement')) or (colPickMode==1 and !data.containsKey('visibleIncrement'))">
a.visible=ifnull(a.visible,0) + #{data.visibleIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('perms')) or (colPickMode==1 and !data.containsKey('perms'))">
a.perms=#{data.perms},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('orderId')) or (colPickMode==1 and !data.containsKey('orderId'))">
a.orderId=#{data.orderId},
</if>
<if test="(colPickMode==0 and data.containsKey('orderIdIncrement')) or (colPickMode==1 and !data.containsKey('orderIdIncrement'))">
a.orderId=ifnull(a.orderId,0) + #{data.orderIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</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('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('cache')) or (colPickMode==1 and !data.containsKey('cache'))">
a.cache=#{data.cache},
</if>
<if test="(colPickMode==0 and data.containsKey('cacheIncrement')) or (colPickMode==1 and !data.containsKey('cacheIncrement'))">
a.cache=ifnull(a.cache,0) + #{data.cacheIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('activeDir')) or (colPickMode==1 and !data.containsKey('activeDir'))">
a.activeDir=#{data.activeDir},
</if>
<if test="(colPickMode==0 and data.containsKey('hideChildrenInMenu')) or (colPickMode==1 and !data.containsKey('hideChildrenInMenu'))">
a.hideChildrenInMenu=#{data.hideChildrenInMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('hideChildrenInMenuIncrement')) or (colPickMode==1 and !data.containsKey('hideChildrenInMenuIncrement'))">
a.hideChildrenInMenu=ifnull(a.hideChildrenInMenu,0) + #{data.hideChildrenInMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('resourceUrl')) or (colPickMode==1 and !data.containsKey('resourceUrl'))">
a.resourceUrl=#{data.resourceUrl},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_menu as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="url=(case" suffix="ELSE url end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('url')) or (colPickMode==1 and !item.containsKey('url'))">
when a.id=#{item.id} then #{item.url}
</if>
</foreach>
</trim>
<trim prefix="ancestors=(case" suffix="ELSE ancestors end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ancestors')) or (colPickMode==1 and !item.containsKey('ancestors'))">
when a.id=#{item.id} then #{item.ancestors}
</if>
</foreach>
</trim>
<trim prefix="parentId=(case" suffix="ELSE parentId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('parentId')) or (colPickMode==1 and !item.containsKey('parentId'))">
when a.id=#{item.id} then #{item.parentId}
</when>
<when test="(colPickMode==0 and item.containsKey('parentIdIncrement')) or (colPickMode==1 and !item.containsKey('parentIdIncrement'))">
when a.id=#{item.id} then ifnull(a.parentId,0) + #{item.parentIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="linkType=(case" suffix="ELSE linkType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('linkType')) or (colPickMode==1 and !item.containsKey('linkType'))">
when a.id=#{item.id} then #{item.linkType}
</when>
<when test="(colPickMode==0 and item.containsKey('linkTypeIncrement')) or (colPickMode==1 and !item.containsKey('linkTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.linkType,0) + #{item.linkTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="imgPath=(case" suffix="ELSE imgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgPath')) or (colPickMode==1 and !item.containsKey('imgPath'))">
when a.id=#{item.id} then #{item.imgPath}
</if>
</foreach>
</trim>
<trim prefix="buttonImgPath=(case" suffix="ELSE buttonImgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('buttonImgPath')) or (colPickMode==1 and !item.containsKey('buttonImgPath'))">
when a.id=#{item.id} then #{item.buttonImgPath}
</if>
</foreach>
</trim>
<trim prefix="imgCommPath=(case" suffix="ELSE imgCommPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgCommPath')) or (colPickMode==1 and !item.containsKey('imgCommPath'))">
when a.id=#{item.id} then #{item.imgCommPath}
</if>
</foreach>
</trim>
<trim prefix="commMenu=(case" suffix="ELSE commMenu end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('commMenu')) or (colPickMode==1 and !item.containsKey('commMenu'))">
when a.id=#{item.id} then #{item.commMenu}
</when>
<when test="(colPickMode==0 and item.containsKey('commMenuIncrement')) or (colPickMode==1 and !item.containsKey('commMenuIncrement'))">
when a.id=#{item.id} then ifnull(a.commMenu,0) + #{item.commMenuIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="component=(case" suffix="ELSE component end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('component')) or (colPickMode==1 and !item.containsKey('component'))">
when a.id=#{item.id} then #{item.component}
</if>
</foreach>
</trim>
<trim prefix="menuType=(case" suffix="ELSE menuType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('menuType')) or (colPickMode==1 and !item.containsKey('menuType'))">
when a.id=#{item.id} then #{item.menuType}
</when>
<when test="(colPickMode==0 and item.containsKey('menuTypeIncrement')) or (colPickMode==1 and !item.containsKey('menuTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.menuType,0) + #{item.menuTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="authType=(case" suffix="ELSE authType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('authType')) or (colPickMode==1 and !item.containsKey('authType'))">
when a.id=#{item.id} then #{item.authType}
</when>
<when test="(colPickMode==0 and item.containsKey('authTypeIncrement')) or (colPickMode==1 and !item.containsKey('authTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.authType,0) + #{item.authTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="visible=(case" suffix="ELSE visible end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('visible')) or (colPickMode==1 and !item.containsKey('visible'))">
when a.id=#{item.id} then #{item.visible}
</when>
<when test="(colPickMode==0 and item.containsKey('visibleIncrement')) or (colPickMode==1 and !item.containsKey('visibleIncrement'))">
when a.id=#{item.id} then ifnull(a.visible,0) + #{item.visibleIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="perms=(case" suffix="ELSE perms end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('perms')) or (colPickMode==1 and !item.containsKey('perms'))">
when a.id=#{item.id} then #{item.perms}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="orderId=(case" suffix="ELSE orderId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('orderId')) or (colPickMode==1 and !item.containsKey('orderId'))">
when a.id=#{item.id} then #{item.orderId}
</when>
<when test="(colPickMode==0 and item.containsKey('orderIdIncrement')) or (colPickMode==1 and !item.containsKey('orderIdIncrement'))">
when a.id=#{item.id} then ifnull(a.orderId,0) + #{item.orderIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</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 prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="cache=(case" suffix="ELSE cache end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('cache')) or (colPickMode==1 and !item.containsKey('cache'))">
when a.id=#{item.id} then #{item.cache}
</when>
<when test="(colPickMode==0 and item.containsKey('cacheIncrement')) or (colPickMode==1 and !item.containsKey('cacheIncrement'))">
when a.id=#{item.id} then ifnull(a.cache,0) + #{item.cacheIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="activeDir=(case" suffix="ELSE activeDir end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('activeDir')) or (colPickMode==1 and !item.containsKey('activeDir'))">
when a.id=#{item.id} then #{item.activeDir}
</if>
</foreach>
</trim>
<trim prefix="hideChildrenInMenu=(case" suffix="ELSE hideChildrenInMenu end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('hideChildrenInMenu')) or (colPickMode==1 and !item.containsKey('hideChildrenInMenu'))">
when a.id=#{item.id} then #{item.hideChildrenInMenu}
</when>
<when test="(colPickMode==0 and item.containsKey('hideChildrenInMenuIncrement')) or (colPickMode==1 and !item.containsKey('hideChildrenInMenuIncrement'))">
when a.id=#{item.id} then ifnull(a.hideChildrenInMenu,0) + #{item.hideChildrenInMenuIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="resourceUrl=(case" suffix="ELSE resourceUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('resourceUrl')) or (colPickMode==1 and !item.containsKey('resourceUrl'))">
when a.id=#{item.id} then #{item.resourceUrl}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_menu where id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_menu where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批,针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_menu where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批,针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_menu where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取子节点 -->
<select id="selectChildrenMenuById" parameterType="String" resultMap="MenuEntity-Map">
select * from mortals_xhx_menu as a where find_in_set(#{menuId}, ancestors)
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('url')">
<if test="conditionParamRef.url != null and conditionParamRef.url != ''">
${_conditionType_} a.url like #{${_conditionParam_}.url}
</if>
<if test="conditionParamRef.url == null">
${_conditionType_} a.url is null
</if>
</if>
<if test="conditionParamRef.containsKey('urlList') and conditionParamRef.urlList.size() > 0">
${_conditionType_} a.url in
<foreach collection="conditionParamRef.urlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('urlNotList') and conditionParamRef.urlNotList.size() > 0">
${_conditionType_} a.url not in
<foreach collection="conditionParamRef.urlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ancestors')">
<if test="conditionParamRef.ancestors != null and conditionParamRef.ancestors != ''">
${_conditionType_} a.ancestors like #{${_conditionParam_}.ancestors}
</if>
<if test="conditionParamRef.ancestors == null">
${_conditionType_} a.ancestors is null
</if>
</if>
<if test="conditionParamRef.containsKey('ancestorsList') and conditionParamRef.ancestorsList.size() > 0">
${_conditionType_} a.ancestors in
<foreach collection="conditionParamRef.ancestorsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ancestorsNotList') and conditionParamRef.ancestorsNotList.size() > 0">
${_conditionType_} a.ancestors not in
<foreach collection="conditionParamRef.ancestorsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentId')">
<if test="conditionParamRef.parentId != null ">
${_conditionType_} a.parentId = #{${_conditionParam_}.parentId}
</if>
<if test="conditionParamRef.parentId == null">
${_conditionType_} a.parentId is null
</if>
</if>
<if test="conditionParamRef.containsKey('parentIdList') and conditionParamRef.parentIdList.size() > 0">
${_conditionType_} a.parentId in
<foreach collection="conditionParamRef.parentIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentIdNotList') and conditionParamRef.parentIdNotList.size() > 0">
${_conditionType_} a.parentId not in
<foreach collection="conditionParamRef.parentIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentIdStart') and conditionParamRef.parentIdStart != null">
${_conditionType_} a.parentId <![CDATA[ >= ]]> #{${_conditionParam_}.parentIdStart}
</if>
<if test="conditionParamRef.containsKey('parentIdEnd') and conditionParamRef.parentIdEnd != null">
${_conditionType_} a.parentId <![CDATA[ <= ]]> #{${_conditionParam_}.parentIdEnd}
</if>
<if test="conditionParamRef.containsKey('linkType')">
<if test="conditionParamRef.linkType != null ">
${_conditionType_} a.linkType = #{${_conditionParam_}.linkType}
</if>
<if test="conditionParamRef.linkType == null">
${_conditionType_} a.linkType is null
</if>
</if>
<if test="conditionParamRef.containsKey('linkTypeList') and conditionParamRef.linkTypeList.size() > 0">
${_conditionType_} a.linkType in
<foreach collection="conditionParamRef.linkTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('linkTypeNotList') and conditionParamRef.linkTypeNotList.size() > 0">
${_conditionType_} a.linkType not in
<foreach collection="conditionParamRef.linkTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('linkTypeStart') and conditionParamRef.linkTypeStart != null">
${_conditionType_} a.linkType <![CDATA[ >= ]]> #{${_conditionParam_}.linkTypeStart}
</if>
<if test="conditionParamRef.containsKey('linkTypeEnd') and conditionParamRef.linkTypeEnd != null">
${_conditionType_} a.linkType <![CDATA[ <= ]]> #{${_conditionParam_}.linkTypeEnd}
</if>
<if test="conditionParamRef.containsKey('imgPath')">
<if test="conditionParamRef.imgPath != null and conditionParamRef.imgPath != ''">
${_conditionType_} a.imgPath like #{${_conditionParam_}.imgPath}
</if>
<if test="conditionParamRef.imgPath == null">
${_conditionType_} a.imgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgPathList') and conditionParamRef.imgPathList.size() > 0">
${_conditionType_} a.imgPath in
<foreach collection="conditionParamRef.imgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgPathNotList') and conditionParamRef.imgPathNotList.size() > 0">
${_conditionType_} a.imgPath not in
<foreach collection="conditionParamRef.imgPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buttonImgPath')">
<if test="conditionParamRef.buttonImgPath != null and conditionParamRef.buttonImgPath != ''">
${_conditionType_} a.buttonImgPath like #{${_conditionParam_}.buttonImgPath}
</if>
<if test="conditionParamRef.buttonImgPath == null">
${_conditionType_} a.buttonImgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('buttonImgPathList') and conditionParamRef.buttonImgPathList.size() > 0">
${_conditionType_} a.buttonImgPath in
<foreach collection="conditionParamRef.buttonImgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buttonImgPathNotList') and conditionParamRef.buttonImgPathNotList.size() > 0">
${_conditionType_} a.buttonImgPath not in
<foreach collection="conditionParamRef.buttonImgPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgCommPath')">
<if test="conditionParamRef.imgCommPath != null and conditionParamRef.imgCommPath != ''">
${_conditionType_} a.imgCommPath like #{${_conditionParam_}.imgCommPath}
</if>
<if test="conditionParamRef.imgCommPath == null">
${_conditionType_} a.imgCommPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgCommPathList') and conditionParamRef.imgCommPathList.size() > 0">
${_conditionType_} a.imgCommPath in
<foreach collection="conditionParamRef.imgCommPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgCommPathNotList') and conditionParamRef.imgCommPathNotList.size() > 0">
${_conditionType_} a.imgCommPath not in
<foreach collection="conditionParamRef.imgCommPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenu')">
<if test="conditionParamRef.commMenu != null ">
${_conditionType_} a.commMenu = #{${_conditionParam_}.commMenu}
</if>
<if test="conditionParamRef.commMenu == null">
${_conditionType_} a.commMenu is null
</if>
</if>
<if test="conditionParamRef.containsKey('commMenuList') and conditionParamRef.commMenuList.size() > 0">
${_conditionType_} a.commMenu in
<foreach collection="conditionParamRef.commMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenuNotList') and conditionParamRef.commMenuNotList.size() > 0">
${_conditionType_} a.commMenu not in
<foreach collection="conditionParamRef.commMenuNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenuStart') and conditionParamRef.commMenuStart != null">
${_conditionType_} a.commMenu <![CDATA[ >= ]]> #{${_conditionParam_}.commMenuStart}
</if>
<if test="conditionParamRef.containsKey('commMenuEnd') and conditionParamRef.commMenuEnd != null">
${_conditionType_} a.commMenu <![CDATA[ <= ]]> #{${_conditionParam_}.commMenuEnd}
</if>
<if test="conditionParamRef.containsKey('component')">
<if test="conditionParamRef.component != null and conditionParamRef.component != ''">
${_conditionType_} a.component like #{${_conditionParam_}.component}
</if>
<if test="conditionParamRef.component == null">
${_conditionType_} a.component is null
</if>
</if>
<if test="conditionParamRef.containsKey('componentList') and conditionParamRef.componentList.size() > 0">
${_conditionType_} a.component in
<foreach collection="conditionParamRef.componentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('componentNotList') and conditionParamRef.componentNotList.size() > 0">
${_conditionType_} a.component not in
<foreach collection="conditionParamRef.componentNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuType')">
<if test="conditionParamRef.menuType != null ">
${_conditionType_} a.menuType = #{${_conditionParam_}.menuType}
</if>
<if test="conditionParamRef.menuType == null">
${_conditionType_} a.menuType is null
</if>
</if>
<if test="conditionParamRef.containsKey('menuTypeList') and conditionParamRef.menuTypeList.size() > 0">
${_conditionType_} a.menuType in
<foreach collection="conditionParamRef.menuTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuTypeNotList') and conditionParamRef.menuTypeNotList.size() > 0">
${_conditionType_} a.menuType not in
<foreach collection="conditionParamRef.menuTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuTypeStart') and conditionParamRef.menuTypeStart != null">
${_conditionType_} a.menuType <![CDATA[ >= ]]> #{${_conditionParam_}.menuTypeStart}
</if>
<if test="conditionParamRef.containsKey('menuTypeEnd') and conditionParamRef.menuTypeEnd != null">
${_conditionType_} a.menuType <![CDATA[ <= ]]> #{${_conditionParam_}.menuTypeEnd}
</if>
<if test="conditionParamRef.containsKey('authType')">
<if test="conditionParamRef.authType != null ">
${_conditionType_} a.authType = #{${_conditionParam_}.authType}
</if>
<if test="conditionParamRef.authType == null">
${_conditionType_} a.authType is null
</if>
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
${_conditionType_} a.authType in
<foreach collection="conditionParamRef.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeNotList') and conditionParamRef.authTypeNotList.size() > 0">
${_conditionType_} a.authType not in
<foreach collection="conditionParamRef.authTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeStart') and conditionParamRef.authTypeStart != null">
${_conditionType_} a.authType <![CDATA[ >= ]]> #{${_conditionParam_}.authTypeStart}
</if>
<if test="conditionParamRef.containsKey('authTypeEnd') and conditionParamRef.authTypeEnd != null">
${_conditionType_} a.authType <![CDATA[ <= ]]> #{${_conditionParam_}.authTypeEnd}
</if>
<if test="conditionParamRef.containsKey('visible')">
<if test="conditionParamRef.visible != null ">
${_conditionType_} a.visible = #{${_conditionParam_}.visible}
</if>
<if test="conditionParamRef.visible == null">
${_conditionType_} a.visible is null
</if>
</if>
<if test="conditionParamRef.containsKey('visibleList') and conditionParamRef.visibleList.size() > 0">
${_conditionType_} a.visible in
<foreach collection="conditionParamRef.visibleList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('visibleNotList') and conditionParamRef.visibleNotList.size() > 0">
${_conditionType_} a.visible not in
<foreach collection="conditionParamRef.visibleNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('visibleStart') and conditionParamRef.visibleStart != null">
${_conditionType_} a.visible <![CDATA[ >= ]]> #{${_conditionParam_}.visibleStart}
</if>
<if test="conditionParamRef.containsKey('visibleEnd') and conditionParamRef.visibleEnd != null">
${_conditionType_} a.visible <![CDATA[ <= ]]> #{${_conditionParam_}.visibleEnd}
</if>
<if test="conditionParamRef.containsKey('perms')">
<if test="conditionParamRef.perms != null and conditionParamRef.perms != ''">
${_conditionType_} a.perms like #{${_conditionParam_}.perms}
</if>
<if test="conditionParamRef.perms == null">
${_conditionType_} a.perms is null
</if>
</if>
<if test="conditionParamRef.containsKey('permsList') and conditionParamRef.permsList.size() > 0">
${_conditionType_} a.perms in
<foreach collection="conditionParamRef.permsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('permsNotList') and conditionParamRef.permsNotList.size() > 0">
${_conditionType_} a.perms not in
<foreach collection="conditionParamRef.permsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderId')">
<if test="conditionParamRef.orderId != null ">
${_conditionType_} a.orderId = #{${_conditionParam_}.orderId}
</if>
<if test="conditionParamRef.orderId == null">
${_conditionType_} a.orderId is null
</if>
</if>
<if test="conditionParamRef.containsKey('orderIdList') and conditionParamRef.orderIdList.size() > 0">
${_conditionType_} a.orderId in
<foreach collection="conditionParamRef.orderIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderIdNotList') and conditionParamRef.orderIdNotList.size() > 0">
${_conditionType_} a.orderId not in
<foreach collection="conditionParamRef.orderIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderIdStart') and conditionParamRef.orderIdStart != null">
${_conditionType_} a.orderId <![CDATA[ >= ]]> #{${_conditionParam_}.orderIdStart}
</if>
<if test="conditionParamRef.containsKey('orderIdEnd') and conditionParamRef.orderIdEnd != null">
${_conditionType_} a.orderId <![CDATA[ <= ]]> #{${_conditionParam_}.orderIdEnd}
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusNotList') and conditionParamRef.statusNotList.size() > 0">
${_conditionType_} a.status not in
<foreach collection="conditionParamRef.statusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('cache')">
<if test="conditionParamRef.cache != null ">
${_conditionType_} a.cache = #{${_conditionParam_}.cache}
</if>
<if test="conditionParamRef.cache == null">
${_conditionType_} a.cache is null
</if>
</if>
<if test="conditionParamRef.containsKey('cacheList') and conditionParamRef.cacheList.size() > 0">
${_conditionType_} a.cache in
<foreach collection="conditionParamRef.cacheList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('cacheNotList') and conditionParamRef.cacheNotList.size() > 0">
${_conditionType_} a.cache not in
<foreach collection="conditionParamRef.cacheNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('cacheStart') and conditionParamRef.cacheStart != null">
${_conditionType_} a.cache <![CDATA[ >= ]]> #{${_conditionParam_}.cacheStart}
</if>
<if test="conditionParamRef.containsKey('cacheEnd') and conditionParamRef.cacheEnd != null">
${_conditionType_} a.cache <![CDATA[ <= ]]> #{${_conditionParam_}.cacheEnd}
</if>
<if test="conditionParamRef.containsKey('activeDir')">
<if test="conditionParamRef.activeDir != null and conditionParamRef.activeDir != ''">
${_conditionType_} a.activeDir like #{${_conditionParam_}.activeDir}
</if>
<if test="conditionParamRef.activeDir == null">
${_conditionType_} a.activeDir is null
</if>
</if>
<if test="conditionParamRef.containsKey('activeDirList') and conditionParamRef.activeDirList.size() > 0">
${_conditionType_} a.activeDir in
<foreach collection="conditionParamRef.activeDirList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('activeDirNotList') and conditionParamRef.activeDirNotList.size() > 0">
${_conditionType_} a.activeDir not in
<foreach collection="conditionParamRef.activeDirNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenu')">
<if test="conditionParamRef.hideChildrenInMenu != null ">
${_conditionType_} a.hideChildrenInMenu = #{${_conditionParam_}.hideChildrenInMenu}
</if>
<if test="conditionParamRef.hideChildrenInMenu == null">
${_conditionType_} a.hideChildrenInMenu is null
</if>
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuList') and conditionParamRef.hideChildrenInMenuList.size() > 0">
${_conditionType_} a.hideChildrenInMenu in
<foreach collection="conditionParamRef.hideChildrenInMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuNotList') and conditionParamRef.hideChildrenInMenuNotList.size() > 0">
${_conditionType_} a.hideChildrenInMenu not in
<foreach collection="conditionParamRef.hideChildrenInMenuNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuStart') and conditionParamRef.hideChildrenInMenuStart != null">
${_conditionType_} a.hideChildrenInMenu <![CDATA[ >= ]]> #{${_conditionParam_}.hideChildrenInMenuStart}
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuEnd') and conditionParamRef.hideChildrenInMenuEnd != null">
${_conditionType_} a.hideChildrenInMenu <![CDATA[ <= ]]> #{${_conditionParam_}.hideChildrenInMenuEnd}
</if>
<if test="conditionParamRef.containsKey('resourceUrl')">
<if test="conditionParamRef.resourceUrl != null and conditionParamRef.resourceUrl != ''">
${_conditionType_} a.resourceUrl like #{${_conditionParam_}.resourceUrl}
</if>
<if test="conditionParamRef.resourceUrl == null">
${_conditionType_} a.resourceUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('resourceUrlList') and conditionParamRef.resourceUrlList.size() > 0">
${_conditionType_} a.resourceUrl in
<foreach collection="conditionParamRef.resourceUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('resourceUrlNotList') and conditionParamRef.resourceUrlNotList.size() > 0">
${_conditionType_} a.resourceUrl not in
<foreach collection="conditionParamRef.resourceUrlNotList" 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('parentIdList') and conditionParamRef.parentIdList.size() > 0">
field(a.parentId,
<foreach collection="conditionParamRef.parentIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('linkTypeList') and conditionParamRef.linkTypeList.size() > 0">
field(a.linkType,
<foreach collection="conditionParamRef.linkTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('commMenuList') and conditionParamRef.commMenuList.size() > 0">
field(a.commMenu,
<foreach collection="conditionParamRef.commMenuList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('menuTypeList') and conditionParamRef.menuTypeList.size() > 0">
field(a.menuType,
<foreach collection="conditionParamRef.menuTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
field(a.authType,
<foreach collection="conditionParamRef.authTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('visibleList') and conditionParamRef.visibleList.size() > 0">
field(a.visible,
<foreach collection="conditionParamRef.visibleList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('orderIdList') and conditionParamRef.orderIdList.size() > 0">
field(a.orderId,
<foreach collection="conditionParamRef.orderIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
field(a.status,
<foreach collection="conditionParamRef.statusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('cacheList') and conditionParamRef.cacheList.size() > 0">
field(a.cache,
<foreach collection="conditionParamRef.cacheList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuList') and conditionParamRef.hideChildrenInMenuList.size() > 0">
field(a.hideChildrenInMenu,
<foreach collection="conditionParamRef.hideChildrenInMenuList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('parentIdList') and conditionParamRef.parentIdList.size() > 0">
field(a.parentId,
<foreach collection="conditionParamRef.parentIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('linkTypeList') and conditionParamRef.linkTypeList.size() > 0">
field(a.linkType,
<foreach collection="conditionParamRef.linkTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('commMenuList') and conditionParamRef.commMenuList.size() > 0">
field(a.commMenu,
<foreach collection="conditionParamRef.commMenuList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('menuTypeList') and conditionParamRef.menuTypeList.size() > 0">
field(a.menuType,
<foreach collection="conditionParamRef.menuTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
field(a.authType,
<foreach collection="conditionParamRef.authTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('visibleList') and conditionParamRef.visibleList.size() > 0">
field(a.visible,
<foreach collection="conditionParamRef.visibleList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('orderIdList') and conditionParamRef.orderIdList.size() > 0">
field(a.orderId,
<foreach collection="conditionParamRef.orderIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
field(a.status,
<foreach collection="conditionParamRef.statusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('cacheList') and conditionParamRef.cacheList.size() > 0">
field(a.cache,
<foreach collection="conditionParamRef.cacheList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('hideChildrenInMenuList') and conditionParamRef.hideChildrenInMenuList.size() > 0">
field(a.hideChildrenInMenu,
<foreach collection="conditionParamRef.hideChildrenInMenuList" 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('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ancestors')">
a.ancestors
<if test='orderCol.ancestors != null and "DESC".equalsIgnoreCase(orderCol.ancestors)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('parentId')">
a.parentId
<if test='orderCol.parentId != null and "DESC".equalsIgnoreCase(orderCol.parentId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('linkType')">
a.linkType
<if test='orderCol.linkType != null and "DESC".equalsIgnoreCase(orderCol.linkType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgPath')">
a.imgPath
<if test='orderCol.imgPath != null and "DESC".equalsIgnoreCase(orderCol.imgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('buttonImgPath')">
a.buttonImgPath
<if test='orderCol.buttonImgPath != null and "DESC".equalsIgnoreCase(orderCol.buttonImgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgCommPath')">
a.imgCommPath
<if test='orderCol.imgCommPath != null and "DESC".equalsIgnoreCase(orderCol.imgCommPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('commMenu')">
a.commMenu
<if test='orderCol.commMenu != null and "DESC".equalsIgnoreCase(orderCol.commMenu)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('component')">
a.component
<if test='orderCol.component != null and "DESC".equalsIgnoreCase(orderCol.component)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('menuType')">
a.menuType
<if test='orderCol.menuType != null and "DESC".equalsIgnoreCase(orderCol.menuType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test='orderCol.authType != null and "DESC".equalsIgnoreCase(orderCol.authType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('visible')">
a.visible
<if test='orderCol.visible != null and "DESC".equalsIgnoreCase(orderCol.visible)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('perms')">
a.perms
<if test='orderCol.perms != null and "DESC".equalsIgnoreCase(orderCol.perms)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('orderId')">
a.orderId
<if test='orderCol.orderId != null and "DESC".equalsIgnoreCase(orderCol.orderId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>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>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('cache')">
a.cache
<if test='orderCol.cache != null and "DESC".equalsIgnoreCase(orderCol.cache)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('activeDir')">
a.activeDir
<if test='orderCol.activeDir != null and "DESC".equalsIgnoreCase(orderCol.activeDir)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('hideChildrenInMenu')">
a.hideChildrenInMenu
<if test='orderCol.hideChildrenInMenu != null and "DESC".equalsIgnoreCase(orderCol.hideChildrenInMenu)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('resourceUrl')">
a.resourceUrl
<if test='orderCol.resourceUrl != null and "DESC".equalsIgnoreCase(orderCol.resourceUrl)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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.menu.dao.ibatis.MenuDaoImpl">
<!-- 获取列表 -->
<select id="getListByUserId" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
where a.authType in(0,1,2) or a.id IN
(select menuId
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>
</mapper>
\ No newline at end of file
<?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.param.dao.ibatis.ParamDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="ParamEntity" id="ParamEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="firstOrganize" column="firstOrganize" />
<result property="secondOrganize" column="secondOrganize" />
<result property="paramKey" column="paramKey" />
<result property="paramValue" column="paramValue" />
<result property="validStatus" column="validStatus" />
<result property="modStatus" column="modStatus" />
<result property="displayType" column="displayType" />
<result property="remark" column="remark" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('firstOrganize') or colPickMode == 1 and data.containsKey('firstOrganize')))">
a.firstOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('secondOrganize') or colPickMode == 1 and data.containsKey('secondOrganize')))">
a.secondOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramKey') or colPickMode == 1 and data.containsKey('paramKey')))">
a.paramKey,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramValue') or colPickMode == 1 and data.containsKey('paramValue')))">
a.paramValue,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('validStatus') or colPickMode == 1 and data.containsKey('validStatus')))">
a.validStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('modStatus') or colPickMode == 1 and data.containsKey('modStatus')))">
a.modStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('displayType') or colPickMode == 1 and data.containsKey('displayType')))">
a.displayType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</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>
<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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="ParamEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,validStatus,modStatus,displayType,remark,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
(#{name},#{firstOrganize},#{secondOrganize},#{paramKey},#{paramValue},#{validStatus},#{modStatus},#{displayType},#{remark},#{createUserId},#{createUserName},#{createTime},#{updateUserId},#{updateUserName},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,validStatus,modStatus,displayType,remark,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.firstOrganize},#{item.secondOrganize},#{item.paramKey},#{item.paramValue},#{item.validStatus},#{item.modStatus},#{item.displayType},#{item.remark},#{item.createUserId},#{item.createUserName},#{item.createTime},#{item.updateUserId},#{item.updateUserName},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_param 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('firstOrganize')) or (colPickMode==1 and !data.containsKey('firstOrganize'))">
a.firstOrganize=#{data.firstOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('secondOrganize')) or (colPickMode==1 and !data.containsKey('secondOrganize'))">
a.secondOrganize=#{data.secondOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('paramKey')) or (colPickMode==1 and !data.containsKey('paramKey'))">
a.paramKey=#{data.paramKey},
</if>
<if test="(colPickMode==0 and data.containsKey('paramValue')) or (colPickMode==1 and !data.containsKey('paramValue'))">
a.paramValue=#{data.paramValue},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatus')) or (colPickMode==1 and !data.containsKey('validStatus'))">
a.validStatus=#{data.validStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatusIncrement')) or (colPickMode==1 and !data.containsKey('validStatusIncrement'))">
a.validStatus=ifnull(a.validStatus,0) + #{data.validStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatus')) or (colPickMode==1 and !data.containsKey('modStatus'))">
a.modStatus=#{data.modStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatusIncrement')) or (colPickMode==1 and !data.containsKey('modStatusIncrement'))">
a.modStatus=ifnull(a.modStatus,0) + #{data.modStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('displayType')) or (colPickMode==1 and !data.containsKey('displayType'))">
a.displayType=#{data.displayType},
</if>
<if test="(colPickMode==0 and data.containsKey('displayTypeIncrement')) or (colPickMode==1 and !data.containsKey('displayTypeIncrement'))">
a.displayType=ifnull(a.displayType,0) + #{data.displayTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_param as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="firstOrganize=(case" suffix="ELSE firstOrganize end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('firstOrganize')) or (colPickMode==1 and !item.containsKey('firstOrganize'))">
when a.id=#{item.id} then #{item.firstOrganize}
</if>
</foreach>
</trim>
<trim prefix="secondOrganize=(case" suffix="ELSE secondOrganize end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('secondOrganize')) or (colPickMode==1 and !item.containsKey('secondOrganize'))">
when a.id=#{item.id} then #{item.secondOrganize}
</if>
</foreach>
</trim>
<trim prefix="paramKey=(case" suffix="ELSE paramKey end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paramKey')) or (colPickMode==1 and !item.containsKey('paramKey'))">
when a.id=#{item.id} then #{item.paramKey}
</if>
</foreach>
</trim>
<trim prefix="paramValue=(case" suffix="ELSE paramValue end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paramValue')) or (colPickMode==1 and !item.containsKey('paramValue'))">
when a.id=#{item.id} then #{item.paramValue}
</if>
</foreach>
</trim>
<trim prefix="validStatus=(case" suffix="ELSE validStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('validStatus')) or (colPickMode==1 and !item.containsKey('validStatus'))">
when a.id=#{item.id} then #{item.validStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('validStatusIncrement')) or (colPickMode==1 and !item.containsKey('validStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.validStatus,0) + #{item.validStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="modStatus=(case" suffix="ELSE modStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('modStatus')) or (colPickMode==1 and !item.containsKey('modStatus'))">
when a.id=#{item.id} then #{item.modStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('modStatusIncrement')) or (colPickMode==1 and !item.containsKey('modStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.modStatus,0) + #{item.modStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="displayType=(case" suffix="ELSE displayType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('displayType')) or (colPickMode==1 and !item.containsKey('displayType'))">
when a.id=#{item.id} then #{item.displayType}
</when>
<when test="(colPickMode==0 and item.containsKey('displayTypeIncrement')) or (colPickMode==1 and !item.containsKey('displayTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.displayType,0) + #{item.displayTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</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 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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_param where id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_param where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批,针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_param where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批,针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_param where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete from mortals_xhx_param as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param 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_param as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('firstOrganize')">
<if test="conditionParamRef.firstOrganize != null and conditionParamRef.firstOrganize != ''">
${_conditionType_} a.firstOrganize like #{${_conditionParam_}.firstOrganize}
</if>
<if test="conditionParamRef.firstOrganize == null">
${_conditionType_} a.firstOrganize is null
</if>
</if>
<if test="conditionParamRef.containsKey('firstOrganizeList') and conditionParamRef.firstOrganizeList.size() > 0">
${_conditionType_} a.firstOrganize in
<foreach collection="conditionParamRef.firstOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('firstOrganizeNotList') and conditionParamRef.firstOrganizeNotList.size() > 0">
${_conditionType_} a.firstOrganize not in
<foreach collection="conditionParamRef.firstOrganizeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('secondOrganize')">
<if test="conditionParamRef.secondOrganize != null and conditionParamRef.secondOrganize != ''">
${_conditionType_} a.secondOrganize like #{${_conditionParam_}.secondOrganize}
</if>
<if test="conditionParamRef.secondOrganize == null">
${_conditionType_} a.secondOrganize is null
</if>
</if>
<if test="conditionParamRef.containsKey('secondOrganizeList') and conditionParamRef.secondOrganizeList.size() > 0">
${_conditionType_} a.secondOrganize in
<foreach collection="conditionParamRef.secondOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('secondOrganizeNotList') and conditionParamRef.secondOrganizeNotList.size() > 0">
${_conditionType_} a.secondOrganize not in
<foreach collection="conditionParamRef.secondOrganizeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramKey')">
<if test="conditionParamRef.paramKey != null and conditionParamRef.paramKey != ''">
${_conditionType_} a.paramKey like #{${_conditionParam_}.paramKey}
</if>
<if test="conditionParamRef.paramKey == null">
${_conditionType_} a.paramKey is null
</if>
</if>
<if test="conditionParamRef.containsKey('paramKeyList') and conditionParamRef.paramKeyList.size() > 0">
${_conditionType_} a.paramKey in
<foreach collection="conditionParamRef.paramKeyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramKeyNotList') and conditionParamRef.paramKeyNotList.size() > 0">
${_conditionType_} a.paramKey not in
<foreach collection="conditionParamRef.paramKeyNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramValue')">
<if test="conditionParamRef.paramValue != null and conditionParamRef.paramValue != ''">
${_conditionType_} a.paramValue like #{${_conditionParam_}.paramValue}
</if>
<if test="conditionParamRef.paramValue == null">
${_conditionType_} a.paramValue is null
</if>
</if>
<if test="conditionParamRef.containsKey('paramValueList') and conditionParamRef.paramValueList.size() > 0">
${_conditionType_} a.paramValue in
<foreach collection="conditionParamRef.paramValueList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramValueNotList') and conditionParamRef.paramValueNotList.size() > 0">
${_conditionType_} a.paramValue not in
<foreach collection="conditionParamRef.paramValueNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('validStatus')">
<if test="conditionParamRef.validStatus != null ">
${_conditionType_} a.validStatus = #{${_conditionParam_}.validStatus}
</if>
<if test="conditionParamRef.validStatus == null">
${_conditionType_} a.validStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('validStatusList') and conditionParamRef.validStatusList.size() > 0">
${_conditionType_} a.validStatus in
<foreach collection="conditionParamRef.validStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('validStatusNotList') and conditionParamRef.validStatusNotList.size() > 0">
${_conditionType_} a.validStatus not in
<foreach collection="conditionParamRef.validStatusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('validStatusStart') and conditionParamRef.validStatusStart != null">
${_conditionType_} a.validStatus <![CDATA[ >= ]]> #{${_conditionParam_}.validStatusStart}
</if>
<if test="conditionParamRef.containsKey('validStatusEnd') and conditionParamRef.validStatusEnd != null">
${_conditionType_} a.validStatus <![CDATA[ <= ]]> #{${_conditionParam_}.validStatusEnd}
</if>
<if test="conditionParamRef.containsKey('modStatus')">
<if test="conditionParamRef.modStatus != null ">
${_conditionType_} a.modStatus = #{${_conditionParam_}.modStatus}
</if>
<if test="conditionParamRef.modStatus == null">
${_conditionType_} a.modStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('modStatusList') and conditionParamRef.modStatusList.size() > 0">
${_conditionType_} a.modStatus in
<foreach collection="conditionParamRef.modStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('modStatusNotList') and conditionParamRef.modStatusNotList.size() > 0">
${_conditionType_} a.modStatus not in
<foreach collection="conditionParamRef.modStatusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('modStatusStart') and conditionParamRef.modStatusStart != null">
${_conditionType_} a.modStatus <![CDATA[ >= ]]> #{${_conditionParam_}.modStatusStart}
</if>
<if test="conditionParamRef.containsKey('modStatusEnd') and conditionParamRef.modStatusEnd != null">
${_conditionType_} a.modStatus <![CDATA[ <= ]]> #{${_conditionParam_}.modStatusEnd}
</if>
<if test="conditionParamRef.containsKey('displayType')">
<if test="conditionParamRef.displayType != null ">
${_conditionType_} a.displayType = #{${_conditionParam_}.displayType}
</if>
<if test="conditionParamRef.displayType == null">
${_conditionType_} a.displayType is null
</if>
</if>
<if test="conditionParamRef.containsKey('displayTypeList') and conditionParamRef.displayTypeList.size() > 0">
${_conditionType_} a.displayType in
<foreach collection="conditionParamRef.displayTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('displayTypeNotList') and conditionParamRef.displayTypeNotList.size() > 0">
${_conditionType_} a.displayType not in
<foreach collection="conditionParamRef.displayTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('displayTypeStart') and conditionParamRef.displayTypeStart != null">
${_conditionType_} a.displayType <![CDATA[ >= ]]> #{${_conditionParam_}.displayTypeStart}
</if>
<if test="conditionParamRef.containsKey('displayTypeEnd') and conditionParamRef.displayTypeEnd != null">
${_conditionType_} a.displayType <![CDATA[ <= ]]> #{${_conditionParam_}.displayTypeEnd}
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('validStatusList') and conditionParamRef.validStatusList.size() > 0">
field(a.validStatus,
<foreach collection="conditionParamRef.validStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('modStatusList') and conditionParamRef.modStatusList.size() > 0">
field(a.modStatus,
<foreach collection="conditionParamRef.modStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('displayTypeList') and conditionParamRef.displayTypeList.size() > 0">
field(a.displayType,
<foreach collection="conditionParamRef.displayTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('validStatusList') and conditionParamRef.validStatusList.size() > 0">
field(a.validStatus,
<foreach collection="conditionParamRef.validStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('modStatusList') and conditionParamRef.modStatusList.size() > 0">
field(a.modStatus,
<foreach collection="conditionParamRef.modStatusList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('displayTypeList') and conditionParamRef.displayTypeList.size() > 0">
field(a.displayType,
<foreach collection="conditionParamRef.displayTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('firstOrganize')">
a.firstOrganize
<if test='orderCol.firstOrganize != null and "DESC".equalsIgnoreCase(orderCol.firstOrganize)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('secondOrganize')">
a.secondOrganize
<if test='orderCol.secondOrganize != null and "DESC".equalsIgnoreCase(orderCol.secondOrganize)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paramKey')">
a.paramKey
<if test='orderCol.paramKey != null and "DESC".equalsIgnoreCase(orderCol.paramKey)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paramValue')">
a.paramValue
<if test='orderCol.paramValue != null and "DESC".equalsIgnoreCase(orderCol.paramValue)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('validStatus')">
a.validStatus
<if test='orderCol.validStatus != null and "DESC".equalsIgnoreCase(orderCol.validStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('modStatus')">
a.modStatus
<if test='orderCol.modStatus != null and "DESC".equalsIgnoreCase(orderCol.modStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('displayType')">
a.displayType
<if test='orderCol.displayType != null and "DESC".equalsIgnoreCase(orderCol.displayType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>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>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="groupName" column="groupName" />
<result property="url" column="url" />
<result property="authType" column="authType" />
<result property="sourceType" column="sourceType" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
a.groupName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('url') or colPickMode == 1 and data.containsKey('url')))">
a.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,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sourceType') or colPickMode == 1 and data.containsKey('sourceType')))">
a.sourceType,
</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>
<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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="ResourceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_resource
(name,groupName,url,authType,sourceType,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
(#{name},#{groupName},#{url},#{authType},#{sourceType},#{createUserId},#{createUserName},#{createTime},#{updateUserId},#{updateUserName},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_resource
(name,groupName,url,authType,sourceType,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.groupName},#{item.url},#{item.authType},#{item.sourceType},#{item.createUserId},#{item.createUserName},#{item.createTime},#{item.updateUserId},#{item.updateUserName},#{item.updateTime})
</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('groupName')) or (colPickMode==1 and !data.containsKey('groupName'))">
a.groupName=#{data.groupName},
</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('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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_resource as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="groupName=(case" suffix="ELSE groupName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
when a.id=#{item.id} then #{item.groupName}
</if>
</foreach>
</trim>
<trim prefix="url=(case" suffix="ELSE url end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('url')) or (colPickMode==1 and !item.containsKey('url'))">
when a.id=#{item.id} then #{item.url}
</if>
</foreach>
</trim>
<trim prefix="authType=(case" suffix="ELSE authType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('authType')) or (colPickMode==1 and !item.containsKey('authType'))">
when a.id=#{item.id} then #{item.authType}
</when>
<when test="(colPickMode==0 and item.containsKey('authTypeIncrement')) or (colPickMode==1 and !item.containsKey('authTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.authType,0) + #{item.authTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="sourceType=(case" suffix="ELSE sourceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('sourceType')) or (colPickMode==1 and !item.containsKey('sourceType'))">
when a.id=#{item.id} then #{item.sourceType}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceTypeIncrement')) or (colPickMode==1 and !item.containsKey('sourceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.sourceType,0) + #{item.sourceTypeIncrement}
</when>
</choose>
</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 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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="ResourceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_resource as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_resource where 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>
<!-- 根据主健列表删除一批,针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_resource where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批,针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_resource where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete 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()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupName')">
<if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
</if>
<if test="conditionParamRef.groupName == null">
${_conditionType_} a.groupName is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupNameList') and conditionParamRef.groupNameList.size() > 0">
${_conditionType_} a.groupName in
<foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupNameNotList') and conditionParamRef.groupNameNotList.size() > 0">
${_conditionType_} a.groupName not in
<foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('url')">
<if test="conditionParamRef.url != null and conditionParamRef.url != ''">
${_conditionType_} a.url like #{${_conditionParam_}.url}
</if>
<if test="conditionParamRef.url == null">
${_conditionType_} a.url is null
</if>
</if>
<if test="conditionParamRef.containsKey('urlList') and conditionParamRef.urlList.size() > 0">
${_conditionType_} a.url in
<foreach collection="conditionParamRef.urlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('urlNotList') and conditionParamRef.urlNotList.size() > 0">
${_conditionType_} a.url not in
<foreach collection="conditionParamRef.urlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authType')">
<if test="conditionParamRef.authType != null ">
${_conditionType_} a.authType = #{${_conditionParam_}.authType}
</if>
<if test="conditionParamRef.authType == null">
${_conditionType_} a.authType is null
</if>
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
${_conditionType_} a.authType in
<foreach collection="conditionParamRef.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeNotList') and conditionParamRef.authTypeNotList.size() > 0">
${_conditionType_} a.authType not in
<foreach collection="conditionParamRef.authTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeStart') and conditionParamRef.authTypeStart != null">
${_conditionType_} a.authType <![CDATA[ >= ]]> #{${_conditionParam_}.authTypeStart}
</if>
<if test="conditionParamRef.containsKey('authTypeEnd') and conditionParamRef.authTypeEnd != null">
${_conditionType_} a.authType <![CDATA[ <= ]]> #{${_conditionParam_}.authTypeEnd}
</if>
<if test="conditionParamRef.containsKey('sourceType')">
<if test="conditionParamRef.sourceType != null ">
${_conditionType_} a.sourceType = #{${_conditionParam_}.sourceType}
</if>
<if test="conditionParamRef.sourceType == null">
${_conditionType_} a.sourceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceTypeList') and conditionParamRef.sourceTypeList.size() > 0">
${_conditionType_} a.sourceType in
<foreach collection="conditionParamRef.sourceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sourceTypeNotList') and conditionParamRef.sourceTypeNotList.size() > 0">
${_conditionType_} a.sourceType not in
<foreach collection="conditionParamRef.sourceTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sourceTypeStart') and conditionParamRef.sourceTypeStart != null">
${_conditionType_} a.sourceType <![CDATA[ >= ]]> #{${_conditionParam_}.sourceTypeStart}
</if>
<if test="conditionParamRef.containsKey('sourceTypeEnd') and conditionParamRef.sourceTypeEnd != null">
${_conditionType_} a.sourceType <![CDATA[ <= ]]> #{${_conditionParam_}.sourceTypeEnd}
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
field(a.authType,
<foreach collection="conditionParamRef.authTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('sourceTypeList') and conditionParamRef.sourceTypeList.size() > 0">
field(a.sourceType,
<foreach collection="conditionParamRef.sourceTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
field(a.authType,
<foreach collection="conditionParamRef.authTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('sourceTypeList') and conditionParamRef.sourceTypeList.size() > 0">
field(a.sourceType,
<foreach collection="conditionParamRef.sourceTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('groupName')">
a.groupName
<if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test='orderCol.authType != null and "DESC".equalsIgnoreCase(orderCol.authType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sourceType')">
a.sourceType
<if test='orderCol.sourceType != null and "DESC".equalsIgnoreCase(orderCol.sourceType)'>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>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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.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" />
<result property="resourceId" column="resourceId" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('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('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>
<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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleAuthEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_auth
(roleId,menuId,resourceId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
(#{roleId},#{menuId},#{resourceId},#{createUserId},#{createUserName},#{createTime},#{updateUserId},#{updateUserName},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_auth
(roleId,menuId,resourceId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.menuId},#{item.resourceId},#{item.createUserId},#{item.createUserName},#{item.createTime},#{item.updateUserId},#{item.updateUserName},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_auth as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('menuId')) or (colPickMode==1 and !data.containsKey('menuId'))">
a.menuId=#{data.menuId},
</if>
<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('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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_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="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="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 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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_role_auth where id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_auth where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{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 from mortals_xhx_role_auth
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth 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_role_auth as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('roleId')">
<if test="conditionParamRef.roleId != null ">
${_conditionType_} a.roleId = #{${_conditionParam_}.roleId}
</if>
<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('menuId')">
<if test="conditionParamRef.menuId != null ">
${_conditionType_} a.menuId = #{${_conditionParam_}.menuId}
</if>
<if test="conditionParamRef.menuId == null">
${_conditionType_} a.menuId is null
</if>
</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.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('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
field(a.roleId,
<foreach collection="conditionParamRef.roleIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('roleId')">
a.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('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>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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.role.dao.ibatis.RoleDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleEntity" id="RoleEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="remark" column="remark" />
<result property="roleType" column="roleType" />
<result property="customerId" column="customerId" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleType') or colPickMode == 1 and data.containsKey('roleType')))">
a.roleType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('customerId') or colPickMode == 1 and data.containsKey('customerId')))">
a.customerId,
</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>
<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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role
(name,remark,roleType,customerId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
(#{name},#{remark},#{roleType},#{customerId},#{createUserId},#{createUserName},#{createTime},#{updateUserId},#{updateUserName},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role
(name,remark,roleType,customerId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.remark},#{item.roleType},#{item.customerId},#{item.createUserId},#{item.createUserName},#{item.createTime},#{item.updateUserId},#{item.updateUserName},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role 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('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('roleType')) or (colPickMode==1 and !data.containsKey('roleType'))">
a.roleType=#{data.roleType},
</if>
<if test="(colPickMode==0 and data.containsKey('roleTypeIncrement')) or (colPickMode==1 and !data.containsKey('roleTypeIncrement'))">
a.roleType=ifnull(a.roleType,0) + #{data.roleTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('customerId')) or (colPickMode==1 and !data.containsKey('customerId'))">
a.customerId=#{data.customerId},
</if>
<if test="(colPickMode==0 and data.containsKey('customerIdIncrement')) or (colPickMode==1 and !data.containsKey('customerIdIncrement'))">
a.customerId=ifnull(a.customerId,0) + #{data.customerIdIncrement},
</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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_role as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="roleType=(case" suffix="ELSE roleType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('roleType')) or (colPickMode==1 and !item.containsKey('roleType'))">
when a.id=#{item.id} then #{item.roleType}
</when>
<when test="(colPickMode==0 and item.containsKey('roleTypeIncrement')) or (colPickMode==1 and !item.containsKey('roleTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.roleType,0) + #{item.roleTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="customerId=(case" suffix="ELSE customerId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('customerId')) or (colPickMode==1 and !item.containsKey('customerId'))">
when a.id=#{item.id} then #{item.customerId}
</when>
<when test="(colPickMode==0 and item.containsKey('customerIdIncrement')) or (colPickMode==1 and !item.containsKey('customerIdIncrement'))">
when a.id=#{item.id} then ifnull(a.customerId,0) + #{item.customerIdIncrement}
</when>
</choose>
</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 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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete from mortals_xhx_role where id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批,针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_role where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批,针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_role where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete from mortals_xhx_role as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role 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_role as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
${_conditionType_} a.remark not in
<foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleType')">
<if test="conditionParamRef.roleType != null ">
${_conditionType_} a.roleType = #{${_conditionParam_}.roleType}
</if>
<if test="conditionParamRef.roleType == null">
${_conditionType_} a.roleType is null
</if>
</if>
<if test="conditionParamRef.containsKey('roleTypeList') and conditionParamRef.roleTypeList.size() > 0">
${_conditionType_} a.roleType in
<foreach collection="conditionParamRef.roleTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleTypeNotList') and conditionParamRef.roleTypeNotList.size() > 0">
${_conditionType_} a.roleType not in
<foreach collection="conditionParamRef.roleTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleTypeStart') and conditionParamRef.roleTypeStart != null">
${_conditionType_} a.roleType <![CDATA[ >= ]]> #{${_conditionParam_}.roleTypeStart}
</if>
<if test="conditionParamRef.containsKey('roleTypeEnd') and conditionParamRef.roleTypeEnd != null">
${_conditionType_} a.roleType <![CDATA[ <= ]]> #{${_conditionParam_}.roleTypeEnd}
</if>
<if test="conditionParamRef.containsKey('customerId')">
<if test="conditionParamRef.customerId != null ">
${_conditionType_} a.customerId = #{${_conditionParam_}.customerId}
</if>
<if test="conditionParamRef.customerId == null">
${_conditionType_} a.customerId is null
</if>
</if>
<if test="conditionParamRef.containsKey('customerIdList') and conditionParamRef.customerIdList.size() > 0">
${_conditionType_} a.customerId in
<foreach collection="conditionParamRef.customerIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('customerIdNotList') and conditionParamRef.customerIdNotList.size() > 0">
${_conditionType_} a.customerId not in
<foreach collection="conditionParamRef.customerIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('customerIdStart') and conditionParamRef.customerIdStart != null">
${_conditionType_} a.customerId <![CDATA[ >= ]]> #{${_conditionParam_}.customerIdStart}
</if>
<if test="conditionParamRef.containsKey('customerIdEnd') and conditionParamRef.customerIdEnd != null">
${_conditionType_} a.customerId <![CDATA[ <= ]]> #{${_conditionParam_}.customerIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('roleTypeList') and conditionParamRef.roleTypeList.size() > 0">
field(a.roleType,
<foreach collection="conditionParamRef.roleTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('customerIdList') and conditionParamRef.customerIdList.size() > 0">
field(a.customerId,
<foreach collection="conditionParamRef.customerIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('roleTypeList') and conditionParamRef.roleTypeList.size() > 0">
field(a.roleType,
<foreach collection="conditionParamRef.roleTypeList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('customerIdList') and conditionParamRef.customerIdList.size() > 0">
field(a.customerId,
<foreach collection="conditionParamRef.customerIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('roleType')">
a.roleType
<if test='orderCol.roleType != null and "DESC".equalsIgnoreCase(orderCol.roleType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('customerId')">
a.customerId
<if test='orderCol.customerId != null and "DESC".equalsIgnoreCase(orderCol.customerId)'>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>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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.role.dao.ibatis.RoleUserDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleUserEntity" id="RoleUserEntity-Map">
<id property="id" column="id" />
<result property="roleId" column="roleId" />
<result property="userId" column="userId" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateUserName" column="updateUserName" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
a.roleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userId') or colPickMode == 1 and data.containsKey('userId')))">
a.userId,
</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>
<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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserName') or colPickMode == 1 and data.containsKey('updateUserName')))">
a.updateUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleUserEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_user
(roleId,userId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
(#{roleId},#{userId},#{createUserId},#{createUserName},#{createTime},#{updateUserId},#{updateUserName},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_user
(roleId,userId,createUserId,createUserName,createTime,updateUserId,updateUserName,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.userId},#{item.createUserId},#{item.createUserName},#{item.createTime},#{item.updateUserId},#{item.updateUserName},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_user as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('userId')) or (colPickMode==1 and !data.containsKey('userId'))">
a.userId=#{data.userId},
</if>
<if test="(colPickMode==0 and data.containsKey('userIdIncrement')) or (colPickMode==1 and !data.containsKey('userIdIncrement'))">
a.userId=ifnull(a.userId,0) + #{data.userIdIncrement},
</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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserName')) or (colPickMode==1 and !data.containsKey('updateUserName'))">
a.updateUserName=#{data.updateUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_role_user 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="userId=(case" suffix="ELSE userId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('userId')) or (colPickMode==1 and !item.containsKey('userId'))">
when a.id=#{item.id} then #{item.userId}
</when>
<when test="(colPickMode==0 and item.containsKey('userIdIncrement')) or (colPickMode==1 and !item.containsKey('userIdIncrement'))">
when a.id=#{item.id} then ifnull(a.userId,0) + #{item.userIdIncrement}
</when>
</choose>
</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 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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateUserName=(case" suffix="ELSE updateUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUserName')) or (colPickMode==1 and !item.containsKey('updateUserName'))">
when a.id=#{item.id} then #{item.updateUserName}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role_user as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_user where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批,针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_role_user where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批,针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_role_user 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_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user 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_role_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND,集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR,集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="permissionSql != null and permissionSql != ''">
${permissionSql}
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('roleId')">
<if test="conditionParamRef.roleId != null ">
${_conditionType_} a.roleId = #{${_conditionParam_}.roleId}
</if>
<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('userId')">
<if test="conditionParamRef.userId != null ">
${_conditionType_} a.userId = #{${_conditionParam_}.userId}
</if>
<if test="conditionParamRef.userId == null">
${_conditionType_} a.userId is null
</if>
</if>
<if test="conditionParamRef.containsKey('userIdList') and conditionParamRef.userIdList.size() > 0">
${_conditionType_} a.userId in
<foreach collection="conditionParamRef.userIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userIdNotList') and conditionParamRef.userIdNotList.size() > 0">
${_conditionType_} a.userId not in
<foreach collection="conditionParamRef.userIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userIdStart') and conditionParamRef.userIdStart != null">
${_conditionType_} a.userId <![CDATA[ >= ]]> #{${_conditionParam_}.userIdStart}
</if>
<if test="conditionParamRef.containsKey('userIdEnd') and conditionParamRef.userIdEnd != null">
${_conditionType_} a.userId <![CDATA[ <= ]]> #{${_conditionParam_}.userIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('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>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateUserName')">
<if test="conditionParamRef.updateUserName != null and conditionParamRef.updateUserName != ''">
${_conditionType_} a.updateUserName like #{${_conditionParam_}.updateUserName}
</if>
<if test="conditionParamRef.updateUserName == null">
${_conditionType_} a.updateUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserNameList') and conditionParamRef.updateUserNameList.size() > 0">
${_conditionType_} a.updateUserName in
<foreach collection="conditionParamRef.updateUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserNameNotList') and conditionParamRef.updateUserNameNotList.size() > 0">
${_conditionType_} a.updateUserName not in
<foreach collection="conditionParamRef.updateUserNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('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('userIdList') and conditionParamRef.userIdList.size() > 0">
field(a.userId,
<foreach collection="conditionParamRef.userIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
a.${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
field(a.id,
<foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('roleIdList') and conditionParamRef.roleIdList.size() > 0">
field(a.roleId,
<foreach collection="conditionParamRef.roleIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('userIdList') and conditionParamRef.userIdList.size() > 0">
field(a.userId,
<foreach collection="conditionParamRef.userIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
field(a.createUserId,
<foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
field(a.updateUserId,
<foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
,
</if>
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('roleId')">
a.roleId
<if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('userId')">
a.userId
<if test='orderCol.userId != null and "DESC".equalsIgnoreCase(orderCol.userId)'>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>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserName')">
a.updateUserName
<if test='orderCol.updateUserName != null and "DESC".equalsIgnoreCase(orderCol.updateUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
<?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.menu.dao.ibatis.MenuDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MenuEntity" id="MenuEntity-Map">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="url" column="url" />
<result property="parentId" column="parentId" />
<result property="orderId" column="orderId" />
<result property="status" column="status" />
<result property="linkType" column="linkType" />
<result property="groupId" column="groupId" />
<result property="groupName" column="groupName" />
<result property="imgPath" column="imgPath" />
<result property="buttonImgPath" column="buttonImgPath" />
<result property="imgCommPath" column="imgCommPath" />
<result property="commMenu" column="commMenu" />
<result property="menuType" column="menuType" />
<result property="authType" column="authType" />
<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 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('parentId') or colPickMode == 1 and data.containsKey('parentId')))">
a.parentId as parentId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('orderId') or colPickMode == 1 and data.containsKey('orderId')))">
a.orderId as orderId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status as status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('linkType') or colPickMode == 1 and data.containsKey('linkType')))">
a.linkType as linkType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
a.groupId as groupId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
a.groupName as groupName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgPath') or colPickMode == 1 and data.containsKey('imgPath')))">
a.imgPath as imgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('buttonImgPath') or colPickMode == 1 and data.containsKey('buttonImgPath')))">
a.buttonImgPath as buttonImgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgCommPath') or colPickMode == 1 and data.containsKey('imgCommPath')))">
a.imgCommPath as imgCommPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('commMenu') or colPickMode == 1 and data.containsKey('commMenu')))">
a.commMenu as commMenu,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuType') or colPickMode == 1 and data.containsKey('menuType')))">
a.menuType as menuType,
</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('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>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="MenuEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,
linkType,groupId,groupName,imgPath,buttonImgPath,
imgCommPath,commMenu,menuType,authType,createTime,
createUserId,createUserName
)VALUES(#{name},#{url},#{parentId},#{orderId},#{status},
#{linkType},#{groupId},#{groupName},#{imgPath},#{buttonImgPath},
#{imgCommPath},#{commMenu},#{menuType},#{authType},#{createTime},
#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,
linkType,groupId,groupName,imgPath,buttonImgPath,
imgCommPath,commMenu,menuType,authType,createTime,
createUserId,createUserName
)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.parentId},#{item.orderId},#{item.status},
#{item.linkType},#{item.groupId},#{item.groupName},#{item.imgPath},#{item.buttonImgPath},
#{item.imgCommPath},#{item.commMenu},#{item.menuType},#{item.authType},#{item.createTime},
#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_menu 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('parentId')) or (colPickMode==1 and !data.containsKey('parentId'))">
a.parentId=#{data.parentId},
</if>
<if test="(colPickMode==0 and data.containsKey('parentIdIncrement')) or (colPickMode==1 and !data.containsKey('parentIdIncrement'))">
a.parentId=ifnull(a.parentId,0) + #{data.parentIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('orderId')) or (colPickMode==1 and !data.containsKey('orderId'))">
a.orderId=#{data.orderId},
</if>
<if test="(colPickMode==0 and data.containsKey('orderIdIncrement')) or (colPickMode==1 and !data.containsKey('orderIdIncrement'))">
a.orderId=ifnull(a.orderId,0) + #{data.orderIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('linkType')) or (colPickMode==1 and !data.containsKey('linkType'))">
a.linkType=#{data.linkType},
</if>
<if test="(colPickMode==0 and data.containsKey('linkTypeIncrement')) or (colPickMode==1 and !data.containsKey('linkTypeIncrement'))">
a.linkType=ifnull(a.linkType,0) + #{data.linkTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupId')) or (colPickMode==1 and !data.containsKey('groupId'))">
a.groupId=#{data.groupId},
</if>
<if test="(colPickMode==0 and data.containsKey('groupIdIncrement')) or (colPickMode==1 and !data.containsKey('groupIdIncrement'))">
a.groupId=ifnull(a.groupId,0) + #{data.groupIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupName')) or (colPickMode==1 and !data.containsKey('groupName'))">
a.groupName=#{data.groupName},
</if>
<if test="(colPickMode==0 and data.containsKey('imgPath')) or (colPickMode==1 and !data.containsKey('imgPath'))">
a.imgPath=#{data.imgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('buttonImgPath')) or (colPickMode==1 and !data.containsKey('buttonImgPath'))">
a.buttonImgPath=#{data.buttonImgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('imgCommPath')) or (colPickMode==1 and !data.containsKey('imgCommPath'))">
a.imgCommPath=#{data.imgCommPath},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenu')) or (colPickMode==1 and !data.containsKey('commMenu'))">
a.commMenu=#{data.commMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenuIncrement')) or (colPickMode==1 and !data.containsKey('commMenuIncrement'))">
a.commMenu=ifnull(a.commMenu,0) + #{data.commMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('menuType')) or (colPickMode==1 and !data.containsKey('menuType'))">
a.menuType=#{data.menuType},
</if>
<if test="(colPickMode==0 and data.containsKey('menuTypeIncrement')) or (colPickMode==1 and !data.containsKey('menuTypeIncrement'))">
a.menuType=ifnull(a.menuType,0) + #{data.menuTypeIncrement},
</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('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
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_menu as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_menu 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_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu 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_menu 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('parentId')">
<if test="condition.parentId != null ">
and a.parentId = #{condition.parentId}
</if>
<if test="condition.parentId == null">
and a.parentId is null
</if>
</if>
<if test="condition.containsKey('parentIdList')">
and a.parentId in
<foreach collection="condition.parentIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('parentIdStart') and condition.parentIdStart != null">
<![CDATA[ and a.parentId >= #{condition.parentIdStart} ]]>
</if>
<if test="condition.containsKey('parentIdEnd') and condition.parentIdEnd != null">
<![CDATA[ and a.parentId <= #{condition.parentIdEnd} ]]>
</if>
<if test="condition.containsKey('orderId')">
<if test="condition.orderId != null ">
and a.orderId = #{condition.orderId}
</if>
<if test="condition.orderId == null">
and a.orderId is null
</if>
</if>
<if test="condition.containsKey('orderIdList')">
and a.orderId in
<foreach collection="condition.orderIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('orderIdStart') and condition.orderIdStart != null">
<![CDATA[ and a.orderId >= #{condition.orderIdStart} ]]>
</if>
<if test="condition.containsKey('orderIdEnd') and condition.orderIdEnd != null">
<![CDATA[ and a.orderId <= #{condition.orderIdEnd} ]]>
</if>
<if test="condition.containsKey('status')">
<if test="condition.status != null ">
and a.status = #{condition.status}
</if>
<if test="condition.status == null">
and a.status is null
</if>
</if>
<if test="condition.containsKey('statusList')">
and a.status in
<foreach collection="condition.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('statusStart') and condition.statusStart != null">
<![CDATA[ and a.status >= #{condition.statusStart} ]]>
</if>
<if test="condition.containsKey('statusEnd') and condition.statusEnd != null">
<![CDATA[ and a.status <= #{condition.statusEnd} ]]>
</if>
<if test="condition.containsKey('linkType')">
<if test="condition.linkType != null ">
and a.linkType = #{condition.linkType}
</if>
<if test="condition.linkType == null">
and a.linkType is null
</if>
</if>
<if test="condition.containsKey('linkTypeList')">
and a.linkType in
<foreach collection="condition.linkTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('linkTypeStart') and condition.linkTypeStart != null">
<![CDATA[ and a.linkType >= #{condition.linkTypeStart} ]]>
</if>
<if test="condition.containsKey('linkTypeEnd') and condition.linkTypeEnd != null">
<![CDATA[ and a.linkType <= #{condition.linkTypeEnd} ]]>
</if>
<if test="condition.containsKey('groupId')">
<if test="condition.groupId != null ">
and a.groupId = #{condition.groupId}
</if>
<if test="condition.groupId == null">
and a.groupId is null
</if>
</if>
<if test="condition.containsKey('groupIdList')">
and a.groupId in
<foreach collection="condition.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('groupIdStart') and condition.groupIdStart != null">
<![CDATA[ and a.groupId >= #{condition.groupIdStart} ]]>
</if>
<if test="condition.containsKey('groupIdEnd') and condition.groupIdEnd != null">
<![CDATA[ and a.groupId <= #{condition.groupIdEnd} ]]>
</if>
<if test="condition.containsKey('groupName')">
<if test="condition.groupName != null and condition.groupName != ''">
and a.groupName like #{condition.groupName}
</if>
<if test="condition.groupName == null">
and a.groupName is null
</if>
</if>
<if test="condition.containsKey('groupNameList')">
and a.groupName in
<foreach collection="condition.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('imgPath')">
<if test="condition.imgPath != null and condition.imgPath != ''">
and a.imgPath like #{condition.imgPath}
</if>
<if test="condition.imgPath == null">
and a.imgPath is null
</if>
</if>
<if test="condition.containsKey('imgPathList')">
and a.imgPath in
<foreach collection="condition.imgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('buttonImgPath')">
<if test="condition.buttonImgPath != null and condition.buttonImgPath != ''">
and a.buttonImgPath like #{condition.buttonImgPath}
</if>
<if test="condition.buttonImgPath == null">
and a.buttonImgPath is null
</if>
</if>
<if test="condition.containsKey('buttonImgPathList')">
and a.buttonImgPath in
<foreach collection="condition.buttonImgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('imgCommPath')">
<if test="condition.imgCommPath != null and condition.imgCommPath != ''">
and a.imgCommPath like #{condition.imgCommPath}
</if>
<if test="condition.imgCommPath == null">
and a.imgCommPath is null
</if>
</if>
<if test="condition.containsKey('imgCommPathList')">
and a.imgCommPath in
<foreach collection="condition.imgCommPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('commMenu')">
<if test="condition.commMenu != null ">
and a.commMenu = #{condition.commMenu}
</if>
<if test="condition.commMenu == null">
and a.commMenu is null
</if>
</if>
<if test="condition.containsKey('commMenuList')">
and a.commMenu in
<foreach collection="condition.commMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('commMenuStart') and condition.commMenuStart != null">
<![CDATA[ and a.commMenu >= #{condition.commMenuStart} ]]>
</if>
<if test="condition.containsKey('commMenuEnd') and condition.commMenuEnd != null">
<![CDATA[ and a.commMenu <= #{condition.commMenuEnd} ]]>
</if>
<if test="condition.containsKey('menuType')">
<if test="condition.menuType != null ">
and a.menuType = #{condition.menuType}
</if>
<if test="condition.menuType == null">
and a.menuType is null
</if>
</if>
<if test="condition.containsKey('menuTypeList')">
and a.menuType in
<foreach collection="condition.menuTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('menuTypeStart') and condition.menuTypeStart != null">
<![CDATA[ and a.menuType >= #{condition.menuTypeStart} ]]>
</if>
<if test="condition.containsKey('menuTypeEnd') and condition.menuTypeEnd != null">
<![CDATA[ and a.menuType <= #{condition.menuTypeEnd} ]]>
</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('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>
</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('parentId')">
a.parentId
<if test="orderCol.parentId!= null">
${orderCol.parentId}
</if>
,
</if>
<if test="orderCol.containsKey('orderId')">
a.orderId
<if test="orderCol.orderId!= null">
${orderCol.orderId}
</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test="orderCol.status!= null">
${orderCol.status}
</if>
,
</if>
<if test="orderCol.containsKey('linkType')">
a.linkType
<if test="orderCol.linkType!= null">
${orderCol.linkType}
</if>
,
</if>
<if test="orderCol.containsKey('groupId')">
a.groupId
<if test="orderCol.groupId!= null">
${orderCol.groupId}
</if>
,
</if>
<if test="orderCol.containsKey('groupName')">
a.groupName
<if test="orderCol.groupName!= null">
${orderCol.groupName}
</if>
,
</if>
<if test="orderCol.containsKey('imgPath')">
a.imgPath
<if test="orderCol.imgPath!= null">
${orderCol.imgPath}
</if>
,
</if>
<if test="orderCol.containsKey('buttonImgPath')">
a.buttonImgPath
<if test="orderCol.buttonImgPath!= null">
${orderCol.buttonImgPath}
</if>
,
</if>
<if test="orderCol.containsKey('imgCommPath')">
a.imgCommPath
<if test="orderCol.imgCommPath!= null">
${orderCol.imgCommPath}
</if>
,
</if>
<if test="orderCol.containsKey('commMenu')">
a.commMenu
<if test="orderCol.commMenu!= null">
${orderCol.commMenu}
</if>
,
</if>
<if test="orderCol.containsKey('menuType')">
a.menuType
<if test="orderCol.menuType!= null">
${orderCol.menuType}
</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test="orderCol.authType!= null">
${orderCol.authType}
</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>
</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
<?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.param.dao.ibatis.ParamDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="ParamEntity" id="ParamEntity-Map">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="firstOrganize" column="firstOrganize" />
<result property="secondOrganize" column="secondOrganize" />
<result property="paramKey" column="paramKey" />
<result property="paramValue" column="paramValue" />
<result property="validStatus" column="validStatus" />
<result property="modStatus" column="modStatus" />
<result property="displayType" column="displayType" />
<result property="remark" column="remark" />
<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 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('firstOrganize') or colPickMode == 1 and data.containsKey('firstOrganize')))">
a.firstOrganize as firstOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('secondOrganize') or colPickMode == 1 and data.containsKey('secondOrganize')))">
a.secondOrganize as secondOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramKey') or colPickMode == 1 and data.containsKey('paramKey')))">
a.paramKey as paramKey,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramValue') or colPickMode == 1 and data.containsKey('paramValue')))">
a.paramValue as paramValue,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('validStatus') or colPickMode == 1 and data.containsKey('validStatus')))">
a.validStatus as validStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('modStatus') or colPickMode == 1 and data.containsKey('modStatus')))">
a.modStatus as modStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('displayType') or colPickMode == 1 and data.containsKey('displayType')))">
a.displayType as displayType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark as remark,
</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>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="ParamEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,
validStatus,modStatus,displayType,remark,createTime,
createUserId,createUserName
)VALUES(#{name},#{firstOrganize},#{secondOrganize},#{paramKey},#{paramValue},
#{validStatus},#{modStatus},#{displayType},#{remark},#{createTime},
#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,
validStatus,modStatus,displayType,remark,createTime,
createUserId,createUserName
)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.firstOrganize},#{item.secondOrganize},#{item.paramKey},#{item.paramValue},
#{item.validStatus},#{item.modStatus},#{item.displayType},#{item.remark},#{item.createTime},
#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_param 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('firstOrganize')) or (colPickMode==1 and !data.containsKey('firstOrganize'))">
a.firstOrganize=#{data.firstOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('secondOrganize')) or (colPickMode==1 and !data.containsKey('secondOrganize'))">
a.secondOrganize=#{data.secondOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('paramKey')) or (colPickMode==1 and !data.containsKey('paramKey'))">
a.paramKey=#{data.paramKey},
</if>
<if test="(colPickMode==0 and data.containsKey('paramValue')) or (colPickMode==1 and !data.containsKey('paramValue'))">
a.paramValue=#{data.paramValue},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatus')) or (colPickMode==1 and !data.containsKey('validStatus'))">
a.validStatus=#{data.validStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatusIncrement')) or (colPickMode==1 and !data.containsKey('validStatusIncrement'))">
a.validStatus=ifnull(a.validStatus,0) + #{data.validStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatus')) or (colPickMode==1 and !data.containsKey('modStatus'))">
a.modStatus=#{data.modStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatusIncrement')) or (colPickMode==1 and !data.containsKey('modStatusIncrement'))">
a.modStatus=ifnull(a.modStatus,0) + #{data.modStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('displayType')) or (colPickMode==1 and !data.containsKey('displayType'))">
a.displayType=#{data.displayType},
</if>
<if test="(colPickMode==0 and data.containsKey('displayTypeIncrement')) or (colPickMode==1 and !data.containsKey('displayTypeIncrement'))">
a.displayType=ifnull(a.displayType,0) + #{data.displayTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</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
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_param as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_param 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_param as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param 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_param 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('firstOrganize')">
<if test="condition.firstOrganize != null and condition.firstOrganize != ''">
and a.firstOrganize like #{condition.firstOrganize}
</if>
<if test="condition.firstOrganize == null">
and a.firstOrganize is null
</if>
</if>
<if test="condition.containsKey('firstOrganizeList')">
and a.firstOrganize in
<foreach collection="condition.firstOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('secondOrganize')">
<if test="condition.secondOrganize != null and condition.secondOrganize != ''">
and a.secondOrganize like #{condition.secondOrganize}
</if>
<if test="condition.secondOrganize == null">
and a.secondOrganize is null
</if>
</if>
<if test="condition.containsKey('secondOrganizeList')">
and a.secondOrganize in
<foreach collection="condition.secondOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('paramKey')">
<if test="condition.paramKey != null and condition.paramKey != ''">
and a.paramKey like #{condition.paramKey}
</if>
<if test="condition.paramKey == null">
and a.paramKey is null
</if>
</if>
<if test="condition.containsKey('paramKeyList')">
and a.paramKey in
<foreach collection="condition.paramKeyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('paramValue')">
<if test="condition.paramValue != null and condition.paramValue != ''">
and a.paramValue like #{condition.paramValue}
</if>
<if test="condition.paramValue == null">
and a.paramValue is null
</if>
</if>
<if test="condition.containsKey('paramValueList')">
and a.paramValue in
<foreach collection="condition.paramValueList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('validStatus')">
<if test="condition.validStatus != null ">
and a.validStatus = #{condition.validStatus}
</if>
<if test="condition.validStatus == null">
and a.validStatus is null
</if>
</if>
<if test="condition.containsKey('validStatusList')">
and a.validStatus in
<foreach collection="condition.validStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('validStatusStart') and condition.validStatusStart != null">
<![CDATA[ and a.validStatus >= #{condition.validStatusStart} ]]>
</if>
<if test="condition.containsKey('validStatusEnd') and condition.validStatusEnd != null">
<![CDATA[ and a.validStatus <= #{condition.validStatusEnd} ]]>
</if>
<if test="condition.containsKey('modStatus')">
<if test="condition.modStatus != null ">
and a.modStatus = #{condition.modStatus}
</if>
<if test="condition.modStatus == null">
and a.modStatus is null
</if>
</if>
<if test="condition.containsKey('modStatusList')">
and a.modStatus in
<foreach collection="condition.modStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('modStatusStart') and condition.modStatusStart != null">
<![CDATA[ and a.modStatus >= #{condition.modStatusStart} ]]>
</if>
<if test="condition.containsKey('modStatusEnd') and condition.modStatusEnd != null">
<![CDATA[ and a.modStatus <= #{condition.modStatusEnd} ]]>
</if>
<if test="condition.containsKey('displayType')">
<if test="condition.displayType != null ">
and a.displayType = #{condition.displayType}
</if>
<if test="condition.displayType == null">
and a.displayType is null
</if>
</if>
<if test="condition.containsKey('displayTypeList')">
and a.displayType in
<foreach collection="condition.displayTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('displayTypeStart') and condition.displayTypeStart != null">
<![CDATA[ and a.displayType >= #{condition.displayTypeStart} ]]>
</if>
<if test="condition.containsKey('displayTypeEnd') and condition.displayTypeEnd != null">
<![CDATA[ and a.displayType <= #{condition.displayTypeEnd} ]]>
</if>
<if test="condition.containsKey('remark')">
<if test="condition.remark != null and condition.remark != ''">
and a.remark like #{condition.remark}
</if>
<if test="condition.remark == null">
and a.remark is null
</if>
</if>
<if test="condition.containsKey('remarkList')">
and a.remark in
<foreach collection="condition.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</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>
</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('firstOrganize')">
a.firstOrganize
<if test="orderCol.firstOrganize!= null">
${orderCol.firstOrganize}
</if>
,
</if>
<if test="orderCol.containsKey('secondOrganize')">
a.secondOrganize
<if test="orderCol.secondOrganize!= null">
${orderCol.secondOrganize}
</if>
,
</if>
<if test="orderCol.containsKey('paramKey')">
a.paramKey
<if test="orderCol.paramKey!= null">
${orderCol.paramKey}
</if>
,
</if>
<if test="orderCol.containsKey('paramValue')">
a.paramValue
<if test="orderCol.paramValue!= null">
${orderCol.paramValue}
</if>
,
</if>
<if test="orderCol.containsKey('validStatus')">
a.validStatus
<if test="orderCol.validStatus!= null">
${orderCol.validStatus}
</if>
,
</if>
<if test="orderCol.containsKey('modStatus')">
a.modStatus
<if test="orderCol.modStatus!= null">
${orderCol.modStatus}
</if>
,
</if>
<if test="orderCol.containsKey('displayType')">
a.displayType
<if test="orderCol.displayType!= null">
${orderCol.displayType}
</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test="orderCol.remark!= null">
${orderCol.remark}
</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>
</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
<?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
<?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.role.dao.ibatis.RoleDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleEntity" id="RoleEntity-Map">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="remark" column="remark" />
<result property="roleType" column="roleType" />
<result property="customerId" column="customerId" />
<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('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark as remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleType') or colPickMode == 1 and data.containsKey('roleType')))">
a.roleType as roleType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('customerId') or colPickMode == 1 and data.containsKey('customerId')))">
a.customerId as customerId,
</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="RoleEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role
(name,remark,roleType,customerId,createTime,
createUserId,createUserName,userType
)VALUES(#{name},#{remark},#{roleType},#{customerId},#{createTime},
#{createUserId},#{createUserName},#{userType})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role
(name,remark,roleType,customerId,createTime,
createUserId,createUserName,userType
)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.remark},#{item.roleType},#{item.customerId},#{item.createTime},
#{item.createUserId},#{item.createUserName},#{item.userType})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role 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('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('roleType')) or (colPickMode==1 and !data.containsKey('roleType'))">
a.roleType=#{data.roleType},
</if>
<if test="(colPickMode==0 and data.containsKey('roleTypeIncrement')) or (colPickMode==1 and !data.containsKey('roleTypeIncrement'))">
a.roleType=ifnull(a.roleType,0) + #{data.roleTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('customerId')) or (colPickMode==1 and !data.containsKey('customerId'))">
a.customerId=#{data.customerId},
</if>
<if test="(colPickMode==0 and data.containsKey('customerIdIncrement')) or (colPickMode==1 and !data.containsKey('customerIdIncrement'))">
a.customerId=ifnull(a.customerId,0) + #{data.customerIdIncrement},
</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="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role 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_role as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role 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_role 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('remark')">
<if test="condition.remark != null and condition.remark != ''">
and a.remark like #{condition.remark}
</if>
<if test="condition.remark == null">
and a.remark is null
</if>
</if>
<if test="condition.containsKey('remarkList')">
and a.remark in
<foreach collection="condition.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('roleType')">
<if test="condition.roleType != null ">
and a.roleType = #{condition.roleType}
</if>
<if test="condition.roleType == null">
and a.roleType is null
</if>
</if>
<if test="condition.containsKey('roleTypeList')">
and a.roleType in
<foreach collection="condition.roleTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('roleTypeStart') and condition.roleTypeStart != null">
<![CDATA[ and a.roleType >= #{condition.roleTypeStart} ]]>
</if>
<if test="condition.containsKey('roleTypeEnd') and condition.roleTypeEnd != null">
<![CDATA[ and a.roleType <= #{condition.roleTypeEnd} ]]>
</if>
<if test="condition.containsKey('customerId')">
<if test="condition.customerId != null ">
and a.customerId = #{condition.customerId}
</if>
<if test="condition.customerId == null">
and a.customerId is null
</if>
</if>
<if test="condition.containsKey('customerIdList')">
and a.customerId in
<foreach collection="condition.customerIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('customerIdStart') and condition.customerIdStart != null">
<![CDATA[ and a.customerId >= #{condition.customerIdStart} ]]>
</if>
<if test="condition.containsKey('customerIdEnd') and condition.customerIdEnd != null">
<![CDATA[ and a.customerId <= #{condition.customerIdEnd} ]]>
</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('remark')">
a.remark
<if test="orderCol.remark!= null">
${orderCol.remark}
</if>
,
</if>
<if test="orderCol.containsKey('roleType')">
a.roleType
<if test="orderCol.roleType!= null">
${orderCol.roleType}
</if>
,
</if>
<if test="orderCol.containsKey('customerId')">
a.customerId
<if test="orderCol.customerId!= null">
${orderCol.customerId}
</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
<?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.role.dao.ibatis.RoleAuthDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleAuthEntity" id="RoleAuthEntity-Map">
<result property="id" column="id" />
<result property="roleId" column="roleId" />
<result property="resourceId" column="resourceId" />
</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('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
a.roleId as roleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceId') or colPickMode == 1 and data.containsKey('resourceId')))">
a.resourceId as resourceId,
</if>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="RoleAuthEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_auth
(roleId,resourceId
)VALUES(#{roleId},#{resourceId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_auth
(roleId,resourceId
)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.resourceId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_auth as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</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>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role_auth as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_auth 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_role_auth as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth 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_role_auth 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('roleId')">
<if test="condition.roleId != null ">
and a.roleId = #{condition.roleId}
</if>
<if test="condition.roleId == null">
and a.roleId is null
</if>
</if>
<if test="condition.containsKey('roleIdList')">
and a.roleId in
<foreach collection="condition.roleIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('roleIdStart') and condition.roleIdStart != null">
<![CDATA[ and a.roleId >= #{condition.roleIdStart} ]]>
</if>
<if test="condition.containsKey('roleIdEnd') and condition.roleIdEnd != null">
<![CDATA[ and a.roleId <= #{condition.roleIdEnd} ]]>
</if>
<if test="condition.containsKey('resourceId')">
<if test="condition.resourceId != null ">
and a.resourceId = #{condition.resourceId}
</if>
<if test="condition.resourceId == null">
and a.resourceId is null
</if>
</if>
<if test="condition.containsKey('resourceIdList')">
and a.resourceId in
<foreach collection="condition.resourceIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('resourceIdStart') and condition.resourceIdStart != null">
<![CDATA[ and a.resourceId >= #{condition.resourceIdStart} ]]>
</if>
<if test="condition.containsKey('resourceIdEnd') and condition.resourceIdEnd != null">
<![CDATA[ and a.resourceId <= #{condition.resourceIdEnd} ]]>
</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('roleId')">
a.roleId
<if test="orderCol.roleId!= null">
${orderCol.roleId}
</if>
,
</if>
<if test="orderCol.containsKey('resourceId')">
a.resourceId
<if test="orderCol.resourceId!= null">
${orderCol.resourceId}
</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
<?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.role.dao.ibatis.RoleUserDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleUserEntity" id="RoleUserEntity-Map">
<result property="id" column="id" />
<result property="roleId" column="roleId" />
<result property="userId" column="userId" />
</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('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
a.roleId as roleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userId') or colPickMode == 1 and data.containsKey('userId')))">
a.userId as userId,
</if>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="RoleUserEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_user
(roleId,userId
)VALUES(#{roleId},#{userId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_user
(roleId,userId
)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.userId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_user as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('userId')) or (colPickMode==1 and !data.containsKey('userId'))">
a.userId=#{data.userId},
</if>
<if test="(colPickMode==0 and data.containsKey('userIdIncrement')) or (colPickMode==1 and !data.containsKey('userIdIncrement'))">
a.userId=ifnull(a.userId,0) + #{data.userIdIncrement},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role_user as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_user 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_role_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user 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_role_user 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('roleId')">
<if test="condition.roleId != null ">
and a.roleId = #{condition.roleId}
</if>
<if test="condition.roleId == null">
and a.roleId is null
</if>
</if>
<if test="condition.containsKey('roleIdList')">
and a.roleId in
<foreach collection="condition.roleIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('roleIdStart') and condition.roleIdStart != null">
<![CDATA[ and a.roleId >= #{condition.roleIdStart} ]]>
</if>
<if test="condition.containsKey('roleIdEnd') and condition.roleIdEnd != null">
<![CDATA[ and a.roleId <= #{condition.roleIdEnd} ]]>
</if>
<if test="condition.containsKey('userId')">
<if test="condition.userId != null ">
and a.userId = #{condition.userId}
</if>
<if test="condition.userId == null">
and a.userId is null
</if>
</if>
<if test="condition.containsKey('userIdList')">
and a.userId in
<foreach collection="condition.userIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('userIdStart') and condition.userIdStart != null">
<![CDATA[ and a.userId >= #{condition.userIdStart} ]]>
</if>
<if test="condition.containsKey('userIdEnd') and condition.userIdEnd != null">
<![CDATA[ and a.userId <= #{condition.userIdEnd} ]]>
</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('roleId')">
a.roleId
<if test="orderCol.roleId!= null">
${orderCol.roleId}
</if>
,
</if>
<if test="orderCol.containsKey('userId')">
a.userId
<if test="orderCol.userId!= null">
${orderCol.userId}
</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
...@@ -330,7 +330,7 @@ ...@@ -330,7 +330,7 @@
</select> </select>
<!-- 根据主健删除 --> <!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto"> <delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_user as a where a.id=#{condition.id} delete from mortals_xhx_user where id=#{condition.id}
</delete> </delete>
<!-- 根据主健删除一批,针对单一主健有效 --> <!-- 根据主健删除一批,针对单一主健有效 -->
<delete id="deleteByKeys"> <delete id="deleteByKeys">
...@@ -341,7 +341,7 @@ ...@@ -341,7 +341,7 @@
</delete> </delete>
<!-- 根据paramDto删除一批 --> <!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto"> <delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_user as a delete from mortals_xhx_user as a
<trim suffixOverrides="where" suffix=""> <trim suffixOverrides="where" suffix="">
where where
<trim prefixOverrides="and" prefix=""> <trim prefixOverrides="and" prefix="">
......
...@@ -17,6 +17,10 @@ ...@@ -17,6 +17,10 @@
"baseUrl": "http://192.168.0.239:11071/base" "baseUrl": "http://192.168.0.239:11071/base"
}, },
"base-qionglai": {
"baseUrl": "http://172.54.191.130:11071/base"
},
"base-yanyuan-test": { "base-yanyuan-test": {
"baseUrl": "http://192.168.0.119:11078/base" "baseUrl": "http://192.168.0.119:11078/base"
}, },
......
...@@ -128,7 +128,7 @@ POST {{baseUrl}}/site/getAreaSitesBySite ...@@ -128,7 +128,7 @@ POST {{baseUrl}}/site/getAreaSitesBySite
Content-Type: application/json Content-Type: application/json
{ {
"areaName":"盐源县" "areaName":"达州东部经开区"
} }
###站点列表 ###站点列表
POST {{baseUrl}}/site/getAreaSitesBySite POST {{baseUrl}}/site/getAreaSitesBySite
......
...@@ -3,8 +3,8 @@ POST {{baseUrl}}/workman/doLogin ...@@ -3,8 +3,8 @@ POST {{baseUrl}}/workman/doLogin
Content-Type: application/json Content-Type: application/json
{ {
"loginName":"wangtao123", "loginName":"pengliaochuan",
"loginPwd":"123", "loginPwd":"123456",
"siteId": 1 "siteId": 1
} }
......
...@@ -109,6 +109,10 @@ ...@@ -109,6 +109,10 @@
<artifactId>lombok</artifactId> <artifactId>lombok</artifactId>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
<dependency>
<groupId>com.mortals.framework</groupId>
<artifactId>mortals-framework-annotation</artifactId>
</dependency>
</dependencies> </dependencies>
......
...@@ -209,6 +209,10 @@ ...@@ -209,6 +209,10 @@
<groupId>org.springframework</groupId> <groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId> <artifactId>spring-context</artifactId>
</dependency> </dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies> </dependencies>
<build> <build>
......
...@@ -147,6 +147,10 @@ ...@@ -147,6 +147,10 @@
<groupId>cn.hutool</groupId> <groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId> <artifactId>hutool-all</artifactId>
</dependency> </dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
</dependencies> </dependencies>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment