Skip to content

B
bill-platform
Commit deda7b7b authored by 赵啸非's avatar 赵啸非
Browse files
Options

修改权限菜单资源

parent 43e84720
Show whitespace changes
Inline Side-by-side
Showing with 11641 additions and 5618 deletions
bill-manager/db/add.sql
View file @ deda7b7b
...@@ -255,3 +255,120 @@ CREATE TABLE mortals_xhx_access_stat_log( ...@@ -255,3 +255,120 @@ CREATE TABLE mortals_xhx_access_stat_log(
`update_time` datetime COMMENT '更新时间', `update_time` datetime COMMENT '更新时间',
PRIMARY KEY (`id`) PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='统计日志表'; ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='统计日志表';
-- ----------------------------
-- 资源信息业务表
-- ----------------------------
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`)
) 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`)
) 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`)
,KEY `createUserId` (`createUserId`) 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`)
,KEY `createUserId` (`createUserId`) 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(512) COMMENT '权限标识，多个逗号分割',
`remark` varchar(512) COMMENT '备注信息',
`orderId` int(4) COMMENT '排序编号',
`status` tinyint(2) DEFAULT '1' COMMENT '菜单状态 (0.停用，1.启用)',
`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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='菜单信息业务';
bill-manager/pom.xml
View file @ deda7b7b
...@@ -194,6 +194,12 @@ ...@@ -194,6 +194,12 @@
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>1.6.14</version>
</dependency>
</dependencies> </dependencies>
......
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuEntity.java
View file @ deda7b7b
/**
* 文件：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 java.util.List;
import java.util.ArrayList; import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date; import java.util.Date;
import java.util.List; import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
import lombok.Data;
/** /**
* <p>Title: 菜单信息</p> * 菜单信息业务实体对象
* <p>Description: MenuEntity </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-06
* @author */
* @version 1.0.0 @Data
*/ public class MenuEntity extends MenuVo {
public class MenuEntity extends BaseEntityLong{ private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1547777703328L;
/** 菜单名称 */
private String name;
/** 连接地址 */
private String url;
/** 父菜单ID，一级菜单的该字段值为-1 */
private Long parentId;
/** 排序编号 */
private Integer orderId;
/** 菜单状态，0：禁用，1：启用，默认1 */
private Integer status;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkType;
/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupId;
/** 分组名称 */
private Integer groupName;
/** 主菜单图标，主菜单图标的css样式名 */
private String imgPath;
/** 按钮图标，按钮图标的css样式名 */
private String buttonImgPath;
/** 常用菜单图标，常用菜单图标的css样式名 */
private String imgCommPath;
/** 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenu;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuType;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authType;
/** 创建时间 */
private Date createTime;
/** 创建用户 */
private String createUser;
/** 创建用户名称 */
private String createUserName;
private Integer type;
private List<MenuEntity> childList = new ArrayList<MenuEntity>();
public MenuEntity() {
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
/**
* 获取 菜单名称
* @return name
*/
public String getName() {
return this.name;
}
/**
* 设置 菜单名称
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取 连接地址
* @return url
*/
public String getUrl() {
return this.url;
}
/**
* 设置 连接地址
* @param url
*/
public void setUrl(String url) {
this.url = url;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentId
*/
public Long getParentId() {
return this.parentId;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public void setParentId(Long parentId) {
this.parentId = parentId;
}
/**
* 获取 排序编号
* @return orderId
*/
public Integer getOrderId() {
return this.orderId;
}
/**
* 设置 排序编号
* @param orderId
*/
public void setOrderId(Integer orderId) {
this.orderId = orderId;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return status
*/
public Integer getStatus() {
return this.status;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param status
*/
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) { private String name;
this.groupId = groupId;
}
public Integer getGroupName() {
return groupName;
}
public void setGroupName(Integer groupName) {
this.groupName = groupName;
}
/** /**
* 获取 主菜单图标，主菜单图标的css样式名 * 路由地址
* @return imgPath
*/ */
public String getImgPath() { private String url;
return this.imgPath;
}
/** /**
* 设置 主菜单图标，主菜单图标的css样式名 * 当前节点父id路径，“，”分割
* @param imgPath
*/ */
public void setImgPath(String imgPath) { private String ancestors;
this.imgPath = imgPath;
}
/** /**
* 获取 按钮图标，按钮图标的css样式名 * 父菜单ID，一级菜单的该字段值为-1
* @return buttonImgPath
*/ */
public String getButtonImgPath() { private Long parentId;
return this.buttonImgPath;
}
/** /**
* 设置 按钮图标，按钮图标的css样式名 * 链接方式 (0.普通，1.弹出，2.脚本)
* @param buttonImgPath
*/ */
public void setButtonImgPath(String buttonImgPath) { private Integer linkType;
this.buttonImgPath = buttonImgPath;
}
/** /**
* 获取 常用菜单图标，常用菜单图标的css样式名 * 主菜单图标，主菜单图标的css样式名
* @return imgCommPath
*/ */
public String getImgCommPath() { private String imgPath;
return this.imgCommPath;
}
/** /**
* 设置 常用菜单图标，常用菜单图标的css样式名 * 按钮图标，按钮图标的css样式名
* @param imgCommPath
*/ */
public void setImgCommPath(String imgCommPath) { private String buttonImgPath;
this.imgCommPath = imgCommPath;
}
/** /**
* 获取 是否常用菜单，0：非常用，1：常用，默认0 * 常用菜单图标，常用菜单图标的css样式名
* @return commMenu
*/ */
public Integer getCommMenu() { private String imgCommPath;
return this.commMenu;
}
/** /**
* 设置 是否常用菜单，0：非常用，1：常用，默认0 * 是否常用菜单 (0.非常用，1.常用)
* @param commMenu
*/ */
public void setCommMenu(Integer commMenu) { private Integer commMenu;
this.commMenu = commMenu;
}
/** /**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * vue组件路径
* @return menuType
*/ */
public Integer getMenuType() { private String component;
return this.menuType;
}
/** /**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuType
*/ */
public void setMenuType(Integer menuType) { private Integer menuType;
this.menuType = menuType;
}
/** /**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authType
*/ */
public Integer getAuthType() { private Integer authType;
return this.authType;
}
/** /**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 菜单显示状态 (0.显示，1.隐藏)
* @param authType
*/ */
public void setAuthType(Integer authType) { private Integer visible;
this.authType = authType;
}
/** /**
* 获取 创建时间 * 权限标识，多个逗号分割
* @return createTime
*/ */
@Override private String perms;
public Date getCreateTime() {
return this.createTime;
}
/** /**
* 设置 创建时间 * 备注信息
* @param createTime
*/ */
@Override private String remark;
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/** /**
* 获取 创建用户 * 排序编号
* @return createUser
*/ */
@Override private Integer orderId;
public String getCreateUser() {
return this.createUser;
}
/** /**
* 设置 创建用户 * 菜单状态 (0.停用，1.启用)
* @param createUser
*/ */
@Override private Integer status;
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
/** /**
* 获取 创建用户名称 * 创建用户名称
* @return createUserName
*/ */
@Override private String createUserName;
public String getCreateUserName() {
return this.createUserName;
}
/** /**
* 设置 创建用户名称 * 创建用户名称
* @param createUserName
*/ */
@Override private String updateUserName;
public void setCreateUserName(String createUserName) {
this.createUserName = createUserName;
}
public List<MenuEntity> getChildList() {
return childList;
}
public void setChildList(List<MenuEntity> childList) {
this.childList = childList;
}
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (obj == null) { if (obj == null) return false;
return false;
}
if (obj instanceof MenuEntity) { if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj; MenuEntity tmp = (MenuEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; return false;
} }
@Override public void initAttrValue(){
public String toString() { this.name = "";
StringBuilder sb = new StringBuilder(""); this.url = "";
sb.append("id:").append(getId()) this.ancestors = "";
.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.parentId = null;
this.orderId = 0;
this.status = 1;
this.linkType = 0; this.linkType = 0;
this.groupId = 1; this.imgPath = "";
this.imgPath = null; this.buttonImgPath = "";
this.buttonImgPath = null; this.imgCommPath = "";
this.imgCommPath = null; this.commMenu = 1;
this.commMenu = 0; this.component = "";
this.menuType = 0; this.menuType = 0;
this.authType = 3; this.authType = 3;
this.createTime = null; this.visible = 0;
this.createUser = null; this.perms = "";
this.createUserName = null; this.remark = "";
this.orderId = 0;
this.status = 1;
this.createUserName = "";
this.updateUserName = "";
} }
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuQuery.java
View file @ deda7b7b
/**
* 文件：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;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
/** /**
* <p>Title: 菜单信息</p> * 菜单信息业务查询对象
* <p>Description: MenuQuery </p> *
* <p>Copyright: Copyright &reg; </p> * @author zxfei
* <p>Company: </p> * @date 2024-09-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;
...@@ -27,15 +18,27 @@ public class MenuQuery extends MenuEntity{ ...@@ -27,15 +18,27 @@ public class MenuQuery extends MenuEntity{
/** 增加 菜单ID，主键，自增长 */ /** 增加 菜单ID，主键，自增长 */
private Long idIncrement; private Long idIncrement;
/** 菜单ID，主键，自增长 */ /** 菜单ID，主键，自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 菜单ID，主键，自增长排除列表 */
private List <Long> idNotList;
/** 菜单名称 */ /** 菜单名称 */
private List<String> nameList; private List<String> nameList;
/** 连接地址 */ /** 菜单名称排除列表 */
private List <String> nameNotList;
/** 路由地址 */
private List<String> urlList; private List<String> urlList;
/** 路由地址排除列表 */
private List <String> urlNotList;
/** 当前节点父id路径，“，”分割 */
private List<String> ancestorsList;
/** 当前节点父id路径，“，”分割排除列表 */
private List <String> ancestorsNotList;
/** 开始 父菜单ID，一级菜单的该字段值为-1 */ /** 开始 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdStart; private Long parentIdStart;
...@@ -45,104 +48,146 @@ public class MenuQuery extends MenuEntity{ ...@@ -45,104 +48,146 @@ public class MenuQuery extends MenuEntity{
/** 增加 父菜单ID，一级菜单的该字段值为-1 */ /** 增加 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdIncrement; private Long parentIdIncrement;
/** 父菜单ID，一级菜单的该字段值为-1 */ /** 父菜单ID，一级菜单的该字段值为-1列表 */
private List<Long> parentIdList; private List <Long> parentIdList;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 结束 排序编号 */
private Integer orderIdEnd;
/** 增加 排序编号 */
private Integer orderIdIncrement;
/** 排序编号 */
private List<Integer> orderIdList;
/** 开始 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusStart;
/** 结束 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusEnd;
/** 增加 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusIncrement;
/** 菜单状态，0：禁用，1：启用，默认1 */ /** 父菜单ID，一级菜单的该字段值为-1排除列表 */
private List<Integer> statusList; private List <Long> parentIdNotList;
/** 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */ /** 开始 链接方式 (0.普通，1.弹出，2.脚本) */
private Integer linkTypeStart; private Integer linkTypeStart;
/** 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */ /** 结束 链接方式 (0.普通，1.弹出，2.脚本) */
private Integer linkTypeEnd; private Integer linkTypeEnd;
/** 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */ /** 增加 链接方式 (0.普通，1.弹出，2.脚本) */
private Integer linkTypeIncrement; private Integer linkTypeIncrement;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */ /** 链接方式 (0.普通，1.弹出，2.脚本)列表 */
private List<Integer> linkTypeList; private List <Integer> linkTypeList;
/** 开始 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdStart;
/** 结束 分组编号，使用菜单分隔符按该值分隔，默认1 */ /** 链接方式 (0.普通，1.弹出，2.脚本)排除列表 */
private Integer groupIdEnd; private List <Integer> linkTypeNotList;
/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdIncrement;
/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
private List<Integer> groupIdList;
/** 分组名称 */
private List<String> groupNameList;
/** 主菜单图标，主菜单图标的css样式名 */ /** 主菜单图标，主菜单图标的css样式名 */
private List<String> imgPathList; private List<String> imgPathList;
/** 主菜单图标，主菜单图标的css样式名排除列表 */
private List <String> imgPathNotList;
/** 按钮图标，按钮图标的css样式名 */ /** 按钮图标，按钮图标的css样式名 */
private List<String> buttonImgPathList; private List<String> buttonImgPathList;
/** 按钮图标，按钮图标的css样式名排除列表 */
private List <String> buttonImgPathNotList;
/** 常用菜单图标，常用菜单图标的css样式名 */ /** 常用菜单图标，常用菜单图标的css样式名 */
private List<String> imgCommPathList; private List<String> imgCommPathList;
/** 开始 是否常用菜单，0：非常用，1：常用，默认0 */ /** 常用菜单图标，常用菜单图标的css样式名排除列表 */
private List <String> imgCommPathNotList;
/** 开始 是否常用菜单 (0.非常用，1.常用) */
private Integer commMenuStart; private Integer commMenuStart;
/** 结束 是否常用菜单，0：非常用，1：常用，默认0 */ /** 结束 是否常用菜单 (0.非常用，1.常用) */
private Integer commMenuEnd; private Integer commMenuEnd;
/** 增加 是否常用菜单，0：非常用，1：常用，默认0 */ /** 增加 是否常用菜单 (0.非常用，1.常用) */
private Integer commMenuIncrement; private Integer commMenuIncrement;
/** 是否常用菜单，0：非常用，1：常用，默认0 */ /** 是否常用菜单 (0.非常用，1.常用)列表 */
private List<Integer> commMenuList; private List <Integer> commMenuList;
/** 是否常用菜单 (0.非常用，1.常用)排除列表 */
private List <Integer> commMenuNotList;
/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */ /** vue组件路径 */
private List<String> componentList;
/** vue组件路径排除列表 */
private List <String> componentNotList;
/** 开始 菜单类型 (0.目录，1.菜单，2.按钮) */
private Integer menuTypeStart; private Integer menuTypeStart;
/** 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */ /** 结束 菜单类型 (0.目录，1.菜单，2.按钮) */
private Integer menuTypeEnd; private Integer menuTypeEnd;
/** 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */ /** 增加 菜单类型 (0.目录，1.菜单，2.按钮) */
private Integer menuTypeIncrement; private Integer menuTypeIncrement;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */ /** 菜单类型 (0.目录，1.菜单，2.按钮)列表 */
private List<Integer> menuTypeList; private List <Integer> menuTypeList;
/** 菜单类型 (0.目录，1.菜单，2.按钮)排除列表 */
private List <Integer> menuTypeNotList;
/** 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeStart; private Integer authTypeStart;
/** 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeEnd; private Integer authTypeEnd;
/** 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeIncrement; private Integer authTypeIncrement;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)列表 */
private List<Integer> authTypeList; private List <Integer> authTypeList;
/** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)排除列表 */
private List <Integer> authTypeNotList;
/** 开始 菜单显示状态 (0.显示，1.隐藏) */
private Integer visibleStart;
/** 结束 菜单显示状态 (0.显示，1.隐藏) */
private Integer visibleEnd;
/** 增加 菜单显示状态 (0.显示，1.隐藏) */
private Integer visibleIncrement;
/** 菜单显示状态 (0.显示，1.隐藏)列表 */
private List <Integer> visibleList;
/** 菜单显示状态 (0.显示，1.隐藏)排除列表 */
private List <Integer> visibleNotList;
/** 权限标识，多个逗号分割 */
private List<String> permsList;
/** 权限标识，多个逗号分割排除列表 */
private List <String> permsNotList;
/** 备注信息 */
private List<String> remarkList;
/** 备注信息排除列表 */
private List <String> remarkNotList;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 结束 排序编号 */
private Integer orderIdEnd;
/** 增加 排序编号 */
private Integer orderIdIncrement;
/** 排序编号列表 */
private List <Integer> orderIdList;
/** 排序编号排除列表 */
private List <Integer> orderIdNotList;
/** 开始 菜单状态 (0.停用，1.启用) */
private Integer statusStart;
/** 结束 菜单状态 (0.停用，1.启用) */
private Integer statusEnd;
/** 增加 菜单状态 (0.停用，1.启用) */
private Integer statusIncrement;
/** 菜单状态 (0.停用，1.启用)列表 */
private List <Integer> statusList;
/** 菜单状态 (0.停用，1.启用)排除列表 */
private List <Integer> statusNotList;
/** 开始 创建时间 */ /** 开始 创建时间 */
private String createTimeStart; private String createTimeStart;
...@@ -159,15 +204,51 @@ public class MenuQuery extends MenuEntity{ ...@@ -159,15 +204,51 @@ public class MenuQuery extends MenuEntity{
/** 增加 创建用户 */ /** 增加 创建用户 */
private Long createUserIdIncrement; private Long createUserIdIncrement;
/** 创建用户 */ /** 创建用户列表 */
private List<Long> createUserIdList; private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 创建用户名称 */ /** 创建用户名称 */
private List<String> createUserNameList; private List<String> createUserNameList;
/** 创建用户名称排除列表 */
private List <String> createUserNameNotList;
/** 开始 更新用户 */
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<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(){}
public MenuQuery(){
}
/** /**
* 获取 开始 菜单ID，主键，自增长 * 获取 开始 菜单ID，主键，自增长
* @return idStart * @return idStart
...@@ -186,7 +267,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -186,7 +267,7 @@ public class MenuQuery extends MenuEntity{
/** /**
* 获取 结束 菜单ID，主键，自增长 * 获取 结束 菜单ID，主键，自增长
* @return idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
...@@ -232,6 +313,23 @@ public class MenuQuery extends MenuEntity{ ...@@ -232,6 +313,23 @@ public class MenuQuery extends MenuEntity{
this.idList = 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 * @return nameList
...@@ -249,7 +347,23 @@ public class MenuQuery extends MenuEntity{ ...@@ -249,7 +347,23 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 连接地址 * 获取 菜单名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 菜单名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 路由地址
* @return urlList * @return urlList
*/ */
public List<String> getUrlList(){ public List<String> getUrlList(){
...@@ -257,13 +371,61 @@ public class MenuQuery extends MenuEntity{ ...@@ -257,13 +371,61 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 连接地址 * 设置 路由地址
* @param urlList * @param urlList
*/ */
public void setUrlList(List<String> urlList){ public void setUrlList(List<String> urlList){
this.urlList = 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 * 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart * @return parentIdStart
...@@ -282,7 +444,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -282,7 +444,7 @@ public class MenuQuery extends MenuEntity{
/** /**
* 获取 结束 父菜单ID，一级菜单的该字段值为-1 * 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return parentIdEnd * @return $parentIdEnd
*/ */
public Long getParentIdEnd(){ public Long getParentIdEnd(){
return this.parentIdEnd; return this.parentIdEnd;
...@@ -329,135 +491,24 @@ public class MenuQuery extends MenuEntity{ ...@@ -329,135 +491,24 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 排序编号 * 获取 父菜单ID，一级菜单的该字段值为-1
* @return orderIdStart * @return parentIdNotList
*/
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){ public List<Long> getParentIdNotList(){
this.statusIncrement = statusIncrement; return this.parentIdNotList;
} }
/** /**
* 获取 菜单状态，0：禁用，1：启用，默认1 * 设置 父菜单ID，一级菜单的该字段值为-1
* @return statusList * @param parentIdNotList
*/ */
public List<Integer> getStatusList(){ public void setParentIdNotList(List<Long> parentIdNotList){
return this.statusList; this.parentIdNotList = parentIdNotList;
} }
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/** /**
* 获取 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 获取 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeStart * @return linkTypeStart
*/ */
public Integer getLinkTypeStart(){ public Integer getLinkTypeStart(){
...@@ -465,7 +516,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -465,7 +516,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart * @param linkTypeStart
*/ */
public void setLinkTypeStart(Integer linkTypeStart){ public void setLinkTypeStart(Integer linkTypeStart){
...@@ -473,15 +524,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -473,15 +524,15 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 获取 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeEnd * @return $linkTypeEnd
*/ */
public Integer getLinkTypeEnd(){ public Integer getLinkTypeEnd(){
return this.linkTypeEnd; return this.linkTypeEnd;
} }
/** /**
* 设置 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd * @param linkTypeEnd
*/ */
public void setLinkTypeEnd(Integer linkTypeEnd){ public void setLinkTypeEnd(Integer linkTypeEnd){
...@@ -489,7 +540,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -489,7 +540,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 获取 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeIncrement * @return linkTypeIncrement
*/ */
public Integer getLinkTypeIncrement(){ public Integer getLinkTypeIncrement(){
...@@ -497,7 +548,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -497,7 +548,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement * @param linkTypeIncrement
*/ */
public void setLinkTypeIncrement(Integer linkTypeIncrement){ public void setLinkTypeIncrement(Integer linkTypeIncrement){
...@@ -505,7 +556,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -505,7 +556,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeList * @return linkTypeList
*/ */
public List<Integer> getLinkTypeList(){ public List<Integer> getLinkTypeList(){
...@@ -513,7 +564,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -513,7 +564,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeList * @param linkTypeList
*/ */
public void setLinkTypeList(List<Integer> linkTypeList){ public void setLinkTypeList(List<Integer> linkTypeList){
...@@ -521,135 +572,120 @@ public class MenuQuery extends MenuEntity{ ...@@ -521,135 +572,120 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 分组编号，使用菜单分隔符按该值分隔，默认1 * 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return groupIdStart * @return linkTypeNotList
*/ */
public Integer getGroupIdStart(){ public List<Integer> getLinkTypeNotList(){
return this.groupIdStart; return this.linkTypeNotList;
} }
/** /**
* 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1 * 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param groupIdStart * @param linkTypeNotList
*/ */
public void setGroupIdStart(Integer groupIdStart){ public void setLinkTypeNotList(List<Integer> linkTypeNotList){
this.groupIdStart = groupIdStart; this.linkTypeNotList = linkTypeNotList;
} }
/** /**
* 获取 结束 分组编号，使用菜单分隔符按该值分隔，默认1 * 获取 主菜单图标，主菜单图标的css样式名
* @return groupIdEnd * @return imgPathList
*/ */
public Integer getGroupIdEnd(){ public List<String> getImgPathList(){
return this.groupIdEnd; return this.imgPathList;
} }
/** /**
* 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1 * 设置 主菜单图标，主菜单图标的css样式名
* @param groupIdEnd * @param imgPathList
*/ */
public void setGroupIdEnd(Integer groupIdEnd){ public void setImgPathList(List<String> imgPathList){
this.groupIdEnd = groupIdEnd; this.imgPathList = imgPathList;
} }
/** /**
* 获取 增加 分组编号，使用菜单分隔符按该值分隔，默认1 * 获取 主菜单图标，主菜单图标的css样式名
* @return groupIdIncrement * @return imgPathNotList
*/ */
public Integer getGroupIdIncrement(){ public List<String> getImgPathNotList(){
return this.groupIdIncrement; return this.imgPathNotList;
} }
/** /**
* 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1 * 设置 主菜单图标，主菜单图标的css样式名
* @param groupIdIncrement * @param imgPathNotList
*/ */
public void setGroupIdIncrement(Integer groupIdIncrement){ public void setImgPathNotList(List<String> imgPathNotList){
this.groupIdIncrement = groupIdIncrement; this.imgPathNotList = imgPathNotList;
} }
/** /**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1 * 获取 按钮图标，按钮图标的css样式名
* @return groupIdList * @return buttonImgPathList
*/ */
public List<Integer> getGroupIdList(){ public List<String> getButtonImgPathList(){
return this.groupIdList; return this.buttonImgPathList;
} }
/** /**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1 * 设置 按钮图标，按钮图标的css样式名
* @param groupIdList * @param buttonImgPathList
*/ */
public void setGroupIdList(List<Integer> groupIdList){ public void setButtonImgPathList(List<String> buttonImgPathList){
this.groupIdList = groupIdList; this.buttonImgPathList = buttonImgPathList;
} }
/** /**
* 获取 分组名称 * 获取 按钮图标，按钮图标的css样式名
* @return groupNameList * @return buttonImgPathNotList
*/ */
public List<String> getGroupNameList(){ public List<String> getButtonImgPathNotList(){
return this.groupNameList; return this.buttonImgPathNotList;
} }
/** /**
* 设置 分组名称 * 设置 按钮图标，按钮图标的css样式名
* @param groupNameList * @param buttonImgPathNotList
*/ */
public void setGroupNameList(List<String> groupNameList){ public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.groupNameList = groupNameList; this.buttonImgPathNotList = buttonImgPathNotList;
} }
/** /**
* 获取 主菜单图标，主菜单图标的css样式名 * 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgPathList * @return imgCommPathList
*/ */
public List<String> getImgPathList(){ public List<String> getImgCommPathList(){
return this.imgPathList; return this.imgCommPathList;
} }
/** /**
* 设置 主菜单图标，主菜单图标的css样式名 * 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgPathList * @param imgCommPathList
*/
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){ public void setImgCommPathList(List<String> imgCommPathList){
this.buttonImgPathList = buttonImgPathList; this.imgCommPathList = imgCommPathList;
} }
/** /**
* 获取 常用菜单图标，常用菜单图标的css样式名 * 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList * @return imgCommPathNotList
*/ */
public List<String> getImgCommPathList(){ public List<String> getImgCommPathNotList(){
return this.imgCommPathList; return this.imgCommPathNotList;
} }
/** /**
* 设置 常用菜单图标，常用菜单图标的css样式名 * 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList * @param imgCommPathNotList
*/ */
public void setImgCommPathList(List<String> imgCommPathList){ public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathList = imgCommPathList; this.imgCommPathNotList = imgCommPathNotList;
} }
/** /**
* 获取 开始 是否常用菜单，0：非常用，1：常用，默认0 * 获取 开始 是否常用菜单 (0.非常用，1.常用)
* @return commMenuStart * @return commMenuStart
*/ */
public Integer getCommMenuStart(){ public Integer getCommMenuStart(){
...@@ -657,7 +693,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -657,7 +693,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 开始 是否常用菜单，0：非常用，1：常用，默认0 * 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart * @param commMenuStart
*/ */
public void setCommMenuStart(Integer commMenuStart){ public void setCommMenuStart(Integer commMenuStart){
...@@ -665,15 +701,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -665,15 +701,15 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 结束 是否常用菜单，0：非常用，1：常用，默认0 * 获取 结束 是否常用菜单 (0.非常用，1.常用)
* @return commMenuEnd * @return $commMenuEnd
*/ */
public Integer getCommMenuEnd(){ public Integer getCommMenuEnd(){
return this.commMenuEnd; return this.commMenuEnd;
} }
/** /**
* 设置 结束 是否常用菜单，0：非常用，1：常用，默认0 * 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd * @param commMenuEnd
*/ */
public void setCommMenuEnd(Integer commMenuEnd){ public void setCommMenuEnd(Integer commMenuEnd){
...@@ -681,7 +717,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -681,7 +717,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 是否常用菜单，0：非常用，1：常用，默认0 * 获取 增加 是否常用菜单 (0.非常用，1.常用)
* @return commMenuIncrement * @return commMenuIncrement
*/ */
public Integer getCommMenuIncrement(){ public Integer getCommMenuIncrement(){
...@@ -689,7 +725,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -689,7 +725,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 增加 是否常用菜单，0：非常用，1：常用，默认0 * 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement * @param commMenuIncrement
*/ */
public void setCommMenuIncrement(Integer commMenuIncrement){ public void setCommMenuIncrement(Integer commMenuIncrement){
...@@ -697,7 +733,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -697,7 +733,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 是否常用菜单，0：非常用，1：常用，默认0 * 获取 是否常用菜单 (0.非常用，1.常用)
* @return commMenuList * @return commMenuList
*/ */
public List<Integer> getCommMenuList(){ public List<Integer> getCommMenuList(){
...@@ -705,7 +741,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -705,7 +741,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 是否常用菜单，0：非常用，1：常用，默认0 * 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuList * @param commMenuList
*/ */
public void setCommMenuList(List<Integer> commMenuList){ public void setCommMenuList(List<Integer> commMenuList){
...@@ -713,7 +749,56 @@ public class MenuQuery extends MenuEntity{ ...@@ -713,7 +749,56 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 获取 是否常用菜单 (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 * @return menuTypeStart
*/ */
public Integer getMenuTypeStart(){ public Integer getMenuTypeStart(){
...@@ -721,7 +806,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -721,7 +806,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart * @param menuTypeStart
*/ */
public void setMenuTypeStart(Integer menuTypeStart){ public void setMenuTypeStart(Integer menuTypeStart){
...@@ -729,15 +814,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -729,15 +814,15 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 获取 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeEnd * @return $menuTypeEnd
*/ */
public Integer getMenuTypeEnd(){ public Integer getMenuTypeEnd(){
return this.menuTypeEnd; return this.menuTypeEnd;
} }
/** /**
* 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd * @param menuTypeEnd
*/ */
public void setMenuTypeEnd(Integer menuTypeEnd){ public void setMenuTypeEnd(Integer menuTypeEnd){
...@@ -745,7 +830,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -745,7 +830,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeIncrement * @return menuTypeIncrement
*/ */
public Integer getMenuTypeIncrement(){ public Integer getMenuTypeIncrement(){
...@@ -753,7 +838,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -753,7 +838,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement * @param menuTypeIncrement
*/ */
public void setMenuTypeIncrement(Integer menuTypeIncrement){ public void setMenuTypeIncrement(Integer menuTypeIncrement){
...@@ -761,7 +846,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -761,7 +846,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeList * @return menuTypeList
*/ */
public List<Integer> getMenuTypeList(){ public List<Integer> getMenuTypeList(){
...@@ -769,7 +854,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -769,7 +854,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeList * @param menuTypeList
*/ */
public void setMenuTypeList(List<Integer> menuTypeList){ public void setMenuTypeList(List<Integer> menuTypeList){
...@@ -777,7 +862,24 @@ public class MenuQuery extends MenuEntity{ ...@@ -777,7 +862,24 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 菜单类型 (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 * @return authTypeStart
*/ */
public Integer getAuthTypeStart(){ public Integer getAuthTypeStart(){
...@@ -785,7 +887,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -785,7 +887,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart * @param authTypeStart
*/ */
public void setAuthTypeStart(Integer authTypeStart){ public void setAuthTypeStart(Integer authTypeStart){
...@@ -793,15 +895,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -793,15 +895,15 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeEnd * @return $authTypeEnd
*/ */
public Integer getAuthTypeEnd(){ public Integer getAuthTypeEnd(){
return this.authTypeEnd; return this.authTypeEnd;
} }
/** /**
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd * @param authTypeEnd
*/ */
public void setAuthTypeEnd(Integer authTypeEnd){ public void setAuthTypeEnd(Integer authTypeEnd){
...@@ -809,7 +911,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -809,7 +911,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeIncrement * @return authTypeIncrement
*/ */
public Integer getAuthTypeIncrement(){ public Integer getAuthTypeIncrement(){
...@@ -817,7 +919,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -817,7 +919,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement * @param authTypeIncrement
*/ */
public void setAuthTypeIncrement(Integer authTypeIncrement){ public void setAuthTypeIncrement(Integer authTypeIncrement){
...@@ -825,7 +927,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -825,7 +927,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeList * @return authTypeList
*/ */
public List<Integer> getAuthTypeList(){ public List<Integer> getAuthTypeList(){
...@@ -833,7 +935,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -833,7 +935,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList * @param authTypeList
*/ */
public void setAuthTypeList(List<Integer> authTypeList){ public void setAuthTypeList(List<Integer> authTypeList){
...@@ -841,116 +943,1454 @@ public class MenuQuery extends MenuEntity{ ...@@ -841,116 +943,1454 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 创建时间 * 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return createTimeStart * @return authTypeNotList
*/ */
public String getCreateTimeStart(){ public List<Integer> getAuthTypeNotList(){
return this.createTimeStart; return this.authTypeNotList;
} }
/** /**
* 设置 开始 创建时间 * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param createTimeStart * @param authTypeNotList
*/ */
public void setCreateTimeStart(String createTimeStart){ public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.createTimeStart = createTimeStart; this.authTypeNotList = authTypeNotList;
} }
/** /**
* 获取 结束 创建时间 * 获取 开始 菜单显示状态 (0.显示，1.隐藏)
* @return createTimeEnd * @return visibleStart
*/ */
public String getCreateTimeEnd(){ public Integer getVisibleStart(){
return this.createTimeEnd; return this.visibleStart;
} }
/** /**
* 设置 结束 创建时间 * 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param createTimeEnd * @param visibleStart
*/ */
public void setCreateTimeEnd(String createTimeEnd){ public void setVisibleStart(Integer visibleStart){
this.createTimeEnd = createTimeEnd; this.visibleStart = visibleStart;
} }
/** /**
* 获取 开始 创建用户 * 获取 结束 菜单显示状态 (0.显示，1.隐藏)
* @return createUserIdStart * @return $visibleEnd
*/ */
public Long getCreateUserIdStart(){ public Integer getVisibleEnd(){
return this.createUserIdStart; return this.visibleEnd;
} }
/** /**
* 设置 开始 创建用户 * 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param createUserIdStart * @param visibleEnd
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public void setVisibleEnd(Integer visibleEnd){
this.createUserIdStart = createUserIdStart; this.visibleEnd = visibleEnd;
} }
/** /**
* 获取 结束 创建用户 * 获取 增加 菜单显示状态 (0.显示，1.隐藏)
* @return createUserIdEnd * @return visibleIncrement
*/ */
public Long getCreateUserIdEnd(){ public Integer getVisibleIncrement(){
return this.createUserIdEnd; return this.visibleIncrement;
} }
/** /**
* 设置 结束 创建用户 * 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param createUserIdEnd * @param visibleIncrement
*/ */
public void setCreateUserIdEnd(Long createUserIdEnd){ public void setVisibleIncrement(Integer visibleIncrement){
this.createUserIdEnd = createUserIdEnd; this.visibleIncrement = visibleIncrement;
} }
/** /**
* 获取 增加 创建用户 * 获取 菜单显示状态 (0.显示，1.隐藏)
* @return createUserIdIncrement * @return visibleList
*/ */
public Long getCreateUserIdIncrement(){ public List<Integer> getVisibleList(){
return this.createUserIdIncrement; return this.visibleList;
} }
/** /**
* 设置 增加 创建用户 * 设置 菜单显示状态 (0.显示，1.隐藏)
* @param createUserIdIncrement * @param visibleList
*/ */
public void setCreateUserIdIncrement(Long createUserIdIncrement){ public void setVisibleList(List<Integer> visibleList){
this.createUserIdIncrement = createUserIdIncrement; this.visibleList = visibleList;
} }
/** /**
* 获取 创建用户 * 获取 菜单显示状态 (0.显示，1.隐藏)
* @return createUserIdList * @return visibleNotList
*/ */
public List<Long> getCreateUserIdList(){ public List<Integer> getVisibleNotList(){
return this.createUserIdList; return this.visibleNotList;
} }
/** /**
* 设置 创建用户 * 设置 菜单显示状态 (0.显示，1.隐藏)
* @param createUserIdList * @param visibleNotList
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public void setVisibleNotList(List<Integer> visibleNotList){
this.createUserIdList = createUserIdList; this.visibleNotList = visibleNotList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsList
*/
public List<String> getPermsList(){
return this.permsList;
} }
/** /**
* 获取 创建用户名称 * 设置 权限标识，多个逗号分割
* @return createUserNameList * @param permsList
*/ */
public List<String> getCreateUserNameList(){ public void setPermsList(List<String> permsList){
return this.createUserNameList; this.permsList = permsList;
} }
/** /**
* 设置 创建用户名称 * 获取 权限标识，多个逗号分割
* @param createUserNameList * @return permsNotList
*/ */
public void setCreateUserNameList(List<String> createUserNameList){ public List<String> getPermsNotList(){
this.createUserNameList = createUserNameList; 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;
}
/**
* 设置 菜单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;
}
/**
* 获取 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
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuTreeSelect.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.menu.model;
import java.lang.reflect.Type;
import java.util.List;
import java.util.ArrayList;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import java.io.Serializable;
import java.util.stream.Collectors;
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 org.springframework.util.ObjectUtils;
/**
* 菜单信息业务前端映射树结构实体类
*
* @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;
/**
* 子节点
*/
@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();
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"));
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
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/vo/MenuVo.java 0 → 100644
View file @ deda7b7b
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 java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 菜单信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class MenuVo extends BaseEntityLong {
/** 菜单ID，主键，自增长列表 */
private List <Long> idList;
/** 子菜单信息业务 */
private List<MenuEntity> children = new ArrayList<>();
private Integer type;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/service/impl/MenuServiceImpl.java
View file @ deda7b7b
...@@ -87,7 +87,7 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity ...@@ -87,7 +87,7 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
} }
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId()); MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) { if (sysModuleParent != null) {
sysModuleParent.getChildList().add(sysModule); sysModuleParent.getChildren().add(sysModule);
} }
} }
return outlookBar; return outlookBar;
...@@ -110,7 +110,7 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity ...@@ -110,7 +110,7 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
} }
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId()); MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) { if (sysModuleParent != null) {
sysModuleParent.getChildList().add(sysModule); sysModuleParent.getChildren().add(sysModule);
} }
} }
return outlookBar; return outlookBar;
......
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/web/MenuController.java
View file @ deda7b7b
...@@ -8,6 +8,8 @@ import com.mortals.framework.model.OrderCol; ...@@ -8,6 +8,8 @@ import com.mortals.framework.model.OrderCol;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController; import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.menu.model.MenuQuery; import com.mortals.xhx.base.system.menu.model.MenuQuery;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import com.mortals.framework.web.BaseCRUDJsonMappingController; import com.mortals.framework.web.BaseCRUDJsonMappingController;
...@@ -64,6 +66,7 @@ public class MenuController extends BaseCRUDJsonBodyMappingController<MenuServic ...@@ -64,6 +66,7 @@ public class MenuController extends BaseCRUDJsonBodyMappingController<MenuServic
/** /**
* 改变状态 * 改变状态
*/ */
@ApiOperation(value = "改变状态", notes = "改变状态")
@RequestMapping(value = "change/status") @RequestMapping(value = "change/status")
public String changeStatus(@RequestBody MenuEntity query) { public String changeStatus(@RequestBody MenuEntity query) {
JSONObject ret = new JSONObject(); JSONObject ret = new JSONObject();
...@@ -97,6 +100,7 @@ public class MenuController extends BaseCRUDJsonBodyMappingController<MenuServic ...@@ -97,6 +100,7 @@ public class MenuController extends BaseCRUDJsonBodyMappingController<MenuServic
/** /**
* 更换排序 * 更换排序
*/ */
@ApiOperation(value = "更换排序")
@PostMapping(value = "upOrDown") @PostMapping(value = "upOrDown")
public String upOrDownTopicList(@RequestBody MenuEntity query) { public String upOrDownTopicList(@RequestBody MenuEntity query) {
JSONObject ret = new JSONObject(); JSONObject ret = new JSONObject();
......
bill-manager/src/main/java/com/mortals/xhx/base/system/param/model/ParamEntity.java
View file @ deda7b7b
/**
* 文件：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 java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.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 firstOrganize;
/** 二级组织，如：基础配置 */
private String secondOrganize;
/** 参数键，全局唯一 */
private String paramKey;
/** 参数值 */
private String paramValue;
/** 参数有效状态，0：禁用，1：启用，默认1 */
private Integer validStatus;
/** 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 */
private Integer modStatus;
/** 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 */
private Integer displayType;
/** 备注 */
private String remark;
/** 创建时间 */
private Date createTime;
/** 创建用户ID */
private Long createUserId;
/** 创建用户名称 */
private String createUserName;
public ParamEntity(){
}
/**
* 获取 参数名称
* @return name
*/
public String getName(){
return this.name;
}
/**
* 设置 参数名称
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 一级组织，如：平台配置
* @return firstOrganize
*/
public String getFirstOrganize(){
return this.firstOrganize;
}
/**
* 设置 一级组织，如：平台配置
* @param firstOrganize
*/
public void setFirstOrganize(String firstOrganize){
this.firstOrganize = firstOrganize;
}
/**
* 获取 二级组织，如：基础配置
* @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){ private String name;
this.modStatus = modStatus;
}
/** /**
* 获取 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 一级组织，如：平台配置
* @return displayType
*/ */
public Integer getDisplayType(){ private String firstOrganize;
return this.displayType;
}
/** /**
* 设置 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 二级组织，如：基础配置
* @param displayType
*/ */
public void setDisplayType(Integer displayType){ private String secondOrganize;
this.displayType = displayType;
}
/** /**
* 获取 备注 * 参数键，全局唯一
* @return remark
*/ */
public String getRemark(){ private String paramKey;
return this.remark;
}
/** /**
* 设置 备注 * 参数值
* @param remark
*/ */
public void setRemark(String remark){ private String paramValue;
this.remark = remark;
}
/** /**
* 获取 创建时间 * 参数有效状态(0.禁用，1.启用)
* @return createTime
*/ */
public Date getCreateTime(){ private Integer validStatus;
return this.createTime;
}
/** /**
* 设置 创建时间 * 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param createTime
*/ */
public void setCreateTime(Date createTime){ private Integer modStatus;
this.createTime = createTime;
}
/** /**
* 获取 创建用户ID * 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @return createUserId
*/ */
public Long getCreateUserId(){ private Integer displayType;
return this.createUserId;
}
/** /**
* 设置 创建用户ID * 备注
* @param createUserId
*/ */
public void setCreateUserId(Long createUserId){ private String remark;
this.createUserId = createUserId;
}
/** /**
* 获取 创建用户名称 * 创建用户名称
* @return createUserName
*/ */
public String getCreateUserName(){ private String createUserName;
return this.createUserName;
}
/** /**
* 设置 创建用户名称 * 创建用户名称
* @param createUserName
*/ */
public void setCreateUserName(String createUserName){ private String updateUserName;
this.createUserName = createUserName;
}
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (obj == null) if (obj == null) return false;
return false;
if (obj instanceof ParamEntity) { if (obj instanceof ParamEntity) {
ParamEntity tmp = (ParamEntity) obj; ParamEntity tmp = (ParamEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; 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(){ public void initAttrValue(){
this.name = null; this.name = "";
this.firstOrganize = null; this.firstOrganize = "";
this.secondOrganize = null; this.secondOrganize = "";
this.paramKey = null; this.paramKey = "";
this.paramValue = null; this.paramValue = "";
this.validStatus = 1; this.validStatus = 1;
this.modStatus = 4; this.modStatus = 4;
this.displayType = 0; this.displayType = 0;
this.remark = null; this.remark = "";
this.createTime = null; this.createUserName = "";
this.createUserId = null; this.updateUserName = "";
this.createUserName = null;
} }
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/param/model/ParamQuery.java
View file @ deda7b7b
/**
* 文件：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;
import com.mortals.xhx.base.system.param.model.ParamEntity;
/** /**
* <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 static final long serialVersionUID = 1536307966364L;
/** 开始 序号，主键，自增长 */ /** 开始 序号，主键，自增长 */
private Long idStart; private Long idStart;
...@@ -28,87 +18,147 @@ public class ParamQuery extends ParamEntity{ ...@@ -28,87 +18,147 @@ public class ParamQuery extends ParamEntity{
/** 增加 序号，主键，自增长 */ /** 增加 序号，主键，自增长 */
private Long idIncrement; private Long idIncrement;
/** 序号，主键，自增长 */ /** 序号，主键，自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 参数名称 */ /** 参数名称 */
private List<String> nameList; private List<String> nameList;
/** 参数名称排除列表 */
private List <String> nameNotList;
/** 一级组织，如：平台配置 */ /** 一级组织，如：平台配置 */
private List<String> firstOrganizeList; private List<String> firstOrganizeList;
/** 一级组织，如：平台配置排除列表 */
private List <String> firstOrganizeNotList;
/** 二级组织，如：基础配置 */ /** 二级组织，如：基础配置 */
private List<String> secondOrganizeList; private List<String> secondOrganizeList;
/** 二级组织，如：基础配置排除列表 */
private List <String> secondOrganizeNotList;
/** 参数键，全局唯一 */ /** 参数键，全局唯一 */
private List<String> paramKeyList; private List<String> paramKeyList;
/** 参数键，全局唯一排除列表 */
private List <String> paramKeyNotList;
/** 参数值 */ /** 参数值 */
private List<String> paramValueList; private List<String> paramValueList;
/** 开始 参数有效状态，0：禁用，1：启用，默认1 */ /** 参数值排除列表 */
private List <String> paramValueNotList;
/** 开始 参数有效状态(0.禁用，1.启用) */
private Integer validStatusStart; private Integer validStatusStart;
/** 结束 参数有效状态，0：禁用，1：启用，默认1 */ /** 结束 参数有效状态(0.禁用，1.启用) */
private Integer validStatusEnd; private Integer validStatusEnd;
/** 增加 参数有效状态，0：禁用，1：启用，默认1 */ /** 增加 参数有效状态(0.禁用，1.启用) */
private Integer validStatusIncrement; private Integer validStatusIncrement;
/** 参数有效状态，0：禁用，1：启用，默认1 */ /** 参数有效状态(0.禁用，1.启用)列表 */
private List<Integer> validStatusList; private List <Integer> validStatusList;
/** 参数有效状态(0.禁用，1.启用)排除列表 */
private List <Integer> validStatusNotList;
/** 开始 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 */ /** 开始 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除) */
private Integer modStatusStart; private Integer modStatusStart;
/** 结束 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 */ /** 结束 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除) */
private Integer modStatusEnd; private Integer modStatusEnd;
/** 增加 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 */ /** 增加 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除) */
private Integer modStatusIncrement; private Integer modStatusIncrement;
/** 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 */ /** 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)列表 */
private List<Integer> modStatusList; private List <Integer> modStatusList;
/** 开始 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 */ /** 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)排除列表 */
private List <Integer> modStatusNotList;
/** 开始 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框) */
private Integer displayTypeStart; private Integer displayTypeStart;
/** 结束 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 */ /** 结束 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框) */
private Integer displayTypeEnd; private Integer displayTypeEnd;
/** 增加 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 */ /** 增加 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框) */
private Integer displayTypeIncrement; private Integer displayTypeIncrement;
/** 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 */ /** 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)列表 */
private List<Integer> displayTypeList; private List <Integer> displayTypeList;
/** 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)排除列表 */
private List <Integer> displayTypeNotList;
/** 备注 */ /** 备注 */
private List<String> remarkList; private List<String> remarkList;
/** 备注排除列表 */
private List <String> remarkNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 创建用户名称 */
private List<String> createUserNameList;
/** 创建用户名称排除列表 */
private List <String> createUserNameNotList;
/** 开始 创建时间 */ /** 开始 创建时间 */
private String createTimeStart; private String createTimeStart;
/** 结束 创建时间 */ /** 结束 创建时间 */
private String createTimeEnd; private String createTimeEnd;
/** 开始 创建用户ID */ /** 开始 更新用户 */
private Long createUserIdStart; private Long updateUserIdStart;
/** 结束 创建用户ID */ /** 结束 更新用户 */
private Long createUserIdEnd; private Long updateUserIdEnd;
/** 增加 创建用户ID */ /** 增加 更新用户 */
private Long createUserIdIncrement; private Long updateUserIdIncrement;
/** 创建用户ID */ /** 更新用户列表 */
private List<Long> createUserIdList; private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 创建用户名称 */ /** 创建用户名称 */
private List<String> createUserNameList; 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(){}
public ParamQuery(){
}
/** /**
* 获取 开始 序号，主键，自增长 * 获取 开始 序号，主键，自增长
* @return idStart * @return idStart
...@@ -127,7 +177,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -127,7 +177,7 @@ public class ParamQuery extends ParamEntity{
/** /**
* 获取 结束 序号，主键，自增长 * 获取 结束 序号，主键，自增长
* @return idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
...@@ -173,6 +223,23 @@ public class ParamQuery extends ParamEntity{ ...@@ -173,6 +223,23 @@ public class ParamQuery extends ParamEntity{
this.idList = 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 * @return nameList
...@@ -189,6 +256,22 @@ public class ParamQuery extends ParamEntity{ ...@@ -189,6 +256,22 @@ public class ParamQuery extends ParamEntity{
this.nameList = 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 * @return firstOrganizeList
...@@ -205,6 +288,22 @@ public class ParamQuery extends ParamEntity{ ...@@ -205,6 +288,22 @@ public class ParamQuery extends ParamEntity{
this.firstOrganizeList = 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 * @return secondOrganizeList
...@@ -221,6 +320,22 @@ public class ParamQuery extends ParamEntity{ ...@@ -221,6 +320,22 @@ public class ParamQuery extends ParamEntity{
this.secondOrganizeList = 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 * @return paramKeyList
...@@ -237,6 +352,22 @@ public class ParamQuery extends ParamEntity{ ...@@ -237,6 +352,22 @@ public class ParamQuery extends ParamEntity{
this.paramKeyList = 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 * @return paramValueList
...@@ -254,7 +385,23 @@ public class ParamQuery extends ParamEntity{ ...@@ -254,7 +385,23 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 开始 参数有效状态，0：禁用，1：启用，默认1 * 获取 参数值
* @return paramValueNotList
*/
public List<String> getParamValueNotList(){
return this.paramValueNotList;
}
/**
* 设置 参数值
* @param paramValueNotList
*/
public void setParamValueNotList(List<String> paramValueNotList){
this.paramValueNotList = paramValueNotList;
}
/**
* 获取 开始 参数有效状态(0.禁用，1.启用)
* @return validStatusStart * @return validStatusStart
*/ */
public Integer getValidStatusStart(){ public Integer getValidStatusStart(){
...@@ -262,7 +409,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -262,7 +409,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 开始 参数有效状态，0：禁用，1：启用，默认1 * 设置 开始 参数有效状态(0.禁用，1.启用)
* @param validStatusStart * @param validStatusStart
*/ */
public void setValidStatusStart(Integer validStatusStart){ public void setValidStatusStart(Integer validStatusStart){
...@@ -270,15 +417,15 @@ public class ParamQuery extends ParamEntity{ ...@@ -270,15 +417,15 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 结束 参数有效状态，0：禁用，1：启用，默认1 * 获取 结束 参数有效状态(0.禁用，1.启用)
* @return validStatusEnd * @return $validStatusEnd
*/ */
public Integer getValidStatusEnd(){ public Integer getValidStatusEnd(){
return this.validStatusEnd; return this.validStatusEnd;
} }
/** /**
* 设置 结束 参数有效状态，0：禁用，1：启用，默认1 * 设置 结束 参数有效状态(0.禁用，1.启用)
* @param validStatusEnd * @param validStatusEnd
*/ */
public void setValidStatusEnd(Integer validStatusEnd){ public void setValidStatusEnd(Integer validStatusEnd){
...@@ -286,7 +433,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -286,7 +433,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 增加 参数有效状态，0：禁用，1：启用，默认1 * 获取 增加 参数有效状态(0.禁用，1.启用)
* @return validStatusIncrement * @return validStatusIncrement
*/ */
public Integer getValidStatusIncrement(){ public Integer getValidStatusIncrement(){
...@@ -294,7 +441,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -294,7 +441,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 增加 参数有效状态，0：禁用，1：启用，默认1 * 设置 增加 参数有效状态(0.禁用，1.启用)
* @param validStatusIncrement * @param validStatusIncrement
*/ */
public void setValidStatusIncrement(Integer validStatusIncrement){ public void setValidStatusIncrement(Integer validStatusIncrement){
...@@ -302,7 +449,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -302,7 +449,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 参数有效状态，0：禁用，1：启用，默认1 * 获取 参数有效状态(0.禁用，1.启用)
* @return validStatusList * @return validStatusList
*/ */
public List<Integer> getValidStatusList(){ public List<Integer> getValidStatusList(){
...@@ -310,7 +457,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -310,7 +457,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 参数有效状态，0：禁用，1：启用，默认1 * 设置 参数有效状态(0.禁用，1.启用)
* @param validStatusList * @param validStatusList
*/ */
public void setValidStatusList(List<Integer> validStatusList){ public void setValidStatusList(List<Integer> validStatusList){
...@@ -318,7 +465,24 @@ public class ParamQuery extends ParamEntity{ ...@@ -318,7 +465,24 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 开始 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 获取 参数有效状态(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 * @return modStatusStart
*/ */
public Integer getModStatusStart(){ public Integer getModStatusStart(){
...@@ -326,7 +490,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -326,7 +490,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 开始 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 设置 开始 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusStart * @param modStatusStart
*/ */
public void setModStatusStart(Integer modStatusStart){ public void setModStatusStart(Integer modStatusStart){
...@@ -334,15 +498,15 @@ public class ParamQuery extends ParamEntity{ ...@@ -334,15 +498,15 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 结束 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 获取 结束 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @return modStatusEnd * @return $modStatusEnd
*/ */
public Integer getModStatusEnd(){ public Integer getModStatusEnd(){
return this.modStatusEnd; return this.modStatusEnd;
} }
/** /**
* 设置 结束 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 设置 结束 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusEnd * @param modStatusEnd
*/ */
public void setModStatusEnd(Integer modStatusEnd){ public void setModStatusEnd(Integer modStatusEnd){
...@@ -350,7 +514,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -350,7 +514,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 增加 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 获取 增加 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @return modStatusIncrement * @return modStatusIncrement
*/ */
public Integer getModStatusIncrement(){ public Integer getModStatusIncrement(){
...@@ -358,7 +522,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -358,7 +522,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 增加 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 设置 增加 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusIncrement * @param modStatusIncrement
*/ */
public void setModStatusIncrement(Integer modStatusIncrement){ public void setModStatusIncrement(Integer modStatusIncrement){
...@@ -366,7 +530,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -366,7 +530,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 获取 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @return modStatusList * @return modStatusList
*/ */
public List<Integer> getModStatusList(){ public List<Integer> getModStatusList(){
...@@ -374,7 +538,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -374,7 +538,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 参数修改状态，0：隐藏，1：页面仅查看，2：页面可修改，3：页面可删除，4：页面可修改删除，默认4 * 设置 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusList * @param modStatusList
*/ */
public void setModStatusList(List<Integer> modStatusList){ public void setModStatusList(List<Integer> modStatusList){
...@@ -382,7 +546,24 @@ public class ParamQuery extends ParamEntity{ ...@@ -382,7 +546,24 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 开始 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 获取 参数修改状态，(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 * @return displayTypeStart
*/ */
public Integer getDisplayTypeStart(){ public Integer getDisplayTypeStart(){
...@@ -390,7 +571,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -390,7 +571,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 开始 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 设置 开始 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeStart * @param displayTypeStart
*/ */
public void setDisplayTypeStart(Integer displayTypeStart){ public void setDisplayTypeStart(Integer displayTypeStart){
...@@ -398,15 +579,15 @@ public class ParamQuery extends ParamEntity{ ...@@ -398,15 +579,15 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 结束 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 获取 结束 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @return displayTypeEnd * @return $displayTypeEnd
*/ */
public Integer getDisplayTypeEnd(){ public Integer getDisplayTypeEnd(){
return this.displayTypeEnd; return this.displayTypeEnd;
} }
/** /**
* 设置 结束 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 设置 结束 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeEnd * @param displayTypeEnd
*/ */
public void setDisplayTypeEnd(Integer displayTypeEnd){ public void setDisplayTypeEnd(Integer displayTypeEnd){
...@@ -414,7 +595,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -414,7 +595,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 增加 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 获取 增加 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @return displayTypeIncrement * @return displayTypeIncrement
*/ */
public Integer getDisplayTypeIncrement(){ public Integer getDisplayTypeIncrement(){
...@@ -422,7 +603,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -422,7 +603,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 增加 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 设置 增加 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeIncrement * @param displayTypeIncrement
*/ */
public void setDisplayTypeIncrement(Integer displayTypeIncrement){ public void setDisplayTypeIncrement(Integer displayTypeIncrement){
...@@ -430,7 +611,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -430,7 +611,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 获取 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @return displayTypeList * @return displayTypeList
*/ */
public List<Integer> getDisplayTypeList(){ public List<Integer> getDisplayTypeList(){
...@@ -438,7 +619,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -438,7 +619,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 展现类型，0：普通文本框，1：多行文本框，2：开关，3：块输入框，4：密码输入框，默认：0 * 设置 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeList * @param displayTypeList
*/ */
public void setDisplayTypeList(List<Integer> displayTypeList){ public void setDisplayTypeList(List<Integer> displayTypeList){
...@@ -446,55 +627,56 @@ public class ParamQuery extends ParamEntity{ ...@@ -446,55 +627,56 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 备注 * 获取 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @return remarkList * @return displayTypeNotList
*/ */
public List<String> getRemarkList(){ public List<Integer> getDisplayTypeNotList(){
return this.remarkList; return this.displayTypeNotList;
} }
/** /**
* 设置 备注 * 设置 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param remarkList * @param displayTypeNotList
*/ */
public void setRemarkList(List<String> remarkList){ public void setDisplayTypeNotList(List<Integer> displayTypeNotList){
this.remarkList = remarkList; this.displayTypeNotList = displayTypeNotList;
} }
/** /**
* 获取 开始 创建时间 * 获取 备注
* @return createTimeStart * @return remarkList
*/ */
public String getCreateTimeStart(){ public List<String> getRemarkList(){
return this.createTimeStart; return this.remarkList;
} }
/** /**
* 设置 开始 创建时间 * 设置 备注
* @param createTimeStart * @param remarkList
*/ */
public void setCreateTimeStart(String createTimeStart){ public void setRemarkList(List<String> remarkList){
this.createTimeStart = createTimeStart; this.remarkList = remarkList;
} }
/** /**
* 获取 结束 创建时间 * 获取 备注
* @return createTimeEnd * @return remarkNotList
*/ */
public String getCreateTimeEnd(){ public List<String> getRemarkNotList(){
return this.createTimeEnd; return this.remarkNotList;
} }
/** /**
* 设置 结束 创建时间 * 设置 备注
* @param createTimeEnd * @param remarkNotList
*/ */
public void setCreateTimeEnd(String createTimeEnd){ public void setRemarkNotList(List<String> remarkNotList){
this.createTimeEnd = createTimeEnd; this.remarkNotList = remarkNotList;
} }
/** /**
* 获取 开始 创建用户ID * 获取 开始 创建用户
* @return createUserIdStart * @return createUserIdStart
*/ */
public Long getCreateUserIdStart(){ public Long getCreateUserIdStart(){
...@@ -502,7 +684,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -502,7 +684,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 开始 创建用户ID * 设置 开始 创建用户
* @param createUserIdStart * @param createUserIdStart
*/ */
public void setCreateUserIdStart(Long createUserIdStart){ public void setCreateUserIdStart(Long createUserIdStart){
...@@ -510,15 +692,15 @@ public class ParamQuery extends ParamEntity{ ...@@ -510,15 +692,15 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 结束 创建用户ID * 获取 结束 创建用户
* @return createUserIdEnd * @return $createUserIdEnd
*/ */
public Long getCreateUserIdEnd(){ public Long getCreateUserIdEnd(){
return this.createUserIdEnd; return this.createUserIdEnd;
} }
/** /**
* 设置 结束 创建用户ID * 设置 结束 创建用户
* @param createUserIdEnd * @param createUserIdEnd
*/ */
public void setCreateUserIdEnd(Long createUserIdEnd){ public void setCreateUserIdEnd(Long createUserIdEnd){
...@@ -526,7 +708,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -526,7 +708,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 增加 创建用户ID * 获取 增加 创建用户
* @return createUserIdIncrement * @return createUserIdIncrement
*/ */
public Long getCreateUserIdIncrement(){ public Long getCreateUserIdIncrement(){
...@@ -534,7 +716,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -534,7 +716,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 增加 创建用户ID * 设置 增加 创建用户
* @param createUserIdIncrement * @param createUserIdIncrement
*/ */
public void setCreateUserIdIncrement(Long createUserIdIncrement){ public void setCreateUserIdIncrement(Long createUserIdIncrement){
...@@ -542,7 +724,7 @@ public class ParamQuery extends ParamEntity{ ...@@ -542,7 +724,7 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 获取 创建用户ID * 获取 创建用户
* @return createUserIdList * @return createUserIdList
*/ */
public List<Long> getCreateUserIdList(){ public List<Long> getCreateUserIdList(){
...@@ -550,13 +732,30 @@ public class ParamQuery extends ParamEntity{ ...@@ -550,13 +732,30 @@ public class ParamQuery extends ParamEntity{
} }
/** /**
* 设置 创建用户ID * 设置 创建用户
* @param createUserIdList * @param createUserIdList
*/ */
public void setCreateUserIdList(List<Long> createUserIdList){ public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = 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 * @return createUserNameList
...@@ -573,5 +772,707 @@ public class ParamQuery extends ParamEntity{ ...@@ -573,5 +772,707 @@ public class ParamQuery extends ParamEntity{
this.createUserNameList = 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;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public ParamQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public ParamQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public ParamQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 参数名称
* @param name
*/
public ParamQuery name(String name){
setName(name);
return this;
}
/**
* 设置 参数名称
* @param nameList
*/
public ParamQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 一级组织，如：平台配置
* @param firstOrganize
*/
public ParamQuery firstOrganize(String firstOrganize){
setFirstOrganize(firstOrganize);
return this;
}
/**
* 设置 一级组织，如：平台配置
* @param firstOrganizeList
*/
public ParamQuery firstOrganizeList(List<String> firstOrganizeList){
this.firstOrganizeList = firstOrganizeList;
return this;
}
/**
* 设置 二级组织，如：基础配置
* @param secondOrganize
*/
public ParamQuery secondOrganize(String secondOrganize){
setSecondOrganize(secondOrganize);
return this;
}
/**
* 设置 二级组织，如：基础配置
* @param secondOrganizeList
*/
public ParamQuery secondOrganizeList(List<String> secondOrganizeList){
this.secondOrganizeList = secondOrganizeList;
return this;
}
/**
* 设置 参数键，全局唯一
* @param paramKey
*/
public ParamQuery paramKey(String paramKey){
setParamKey(paramKey);
return this;
}
/**
* 设置 参数键，全局唯一
* @param paramKeyList
*/
public ParamQuery paramKeyList(List<String> paramKeyList){
this.paramKeyList = paramKeyList;
return this;
}
/**
* 设置 参数值
* @param paramValue
*/
public ParamQuery paramValue(String paramValue){
setParamValue(paramValue);
return this;
}
/**
* 设置 参数值
* @param paramValueList
*/
public ParamQuery paramValueList(List<String> paramValueList){
this.paramValueList = paramValueList;
return this;
}
/**
* 设置 参数有效状态(0.禁用，1.启用)
* @param validStatus
*/
public ParamQuery validStatus(Integer validStatus){
setValidStatus(validStatus);
return this;
}
/**
* 设置 开始 参数有效状态(0.禁用，1.启用)
* @param validStatusStart
*/
public ParamQuery validStatusStart(Integer validStatusStart){
this.validStatusStart = validStatusStart;
return this;
}
/**
* 设置 结束 参数有效状态(0.禁用，1.启用)
* @param validStatusEnd
*/
public ParamQuery validStatusEnd(Integer validStatusEnd){
this.validStatusEnd = validStatusEnd;
return this;
}
/**
* 设置 增加 参数有效状态(0.禁用，1.启用)
* @param validStatusIncrement
*/
public ParamQuery validStatusIncrement(Integer validStatusIncrement){
this.validStatusIncrement = validStatusIncrement;
return this;
}
/**
* 设置 参数有效状态(0.禁用，1.启用)
* @param validStatusList
*/
public ParamQuery validStatusList(List<Integer> validStatusList){
this.validStatusList = validStatusList;
return this;
}
/**
* 设置 参数有效状态(0.禁用，1.启用)
* @param validStatusNotList
*/
public ParamQuery validStatusNotList(List<Integer> validStatusNotList){
this.validStatusNotList = validStatusNotList;
return this;
}
/**
* 设置 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatus
*/
public ParamQuery modStatus(Integer modStatus){
setModStatus(modStatus);
return this;
}
/**
* 设置 开始 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusStart
*/
public ParamQuery modStatusStart(Integer modStatusStart){
this.modStatusStart = modStatusStart;
return this;
}
/**
* 设置 结束 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusEnd
*/
public ParamQuery modStatusEnd(Integer modStatusEnd){
this.modStatusEnd = modStatusEnd;
return this;
}
/**
* 设置 增加 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusIncrement
*/
public ParamQuery modStatusIncrement(Integer modStatusIncrement){
this.modStatusIncrement = modStatusIncrement;
return this;
}
/**
* 设置 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusList
*/
public ParamQuery modStatusList(List<Integer> modStatusList){
this.modStatusList = modStatusList;
return this;
}
/**
* 设置 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)
* @param modStatusNotList
*/
public ParamQuery modStatusNotList(List<Integer> modStatusNotList){
this.modStatusNotList = modStatusNotList;
return this;
}
/**
* 设置 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayType
*/
public ParamQuery displayType(Integer displayType){
setDisplayType(displayType);
return this;
}
/**
* 设置 开始 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeStart
*/
public ParamQuery displayTypeStart(Integer displayTypeStart){
this.displayTypeStart = displayTypeStart;
return this;
}
/**
* 设置 结束 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeEnd
*/
public ParamQuery displayTypeEnd(Integer displayTypeEnd){
this.displayTypeEnd = displayTypeEnd;
return this;
}
/**
* 设置 增加 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeIncrement
*/
public ParamQuery displayTypeIncrement(Integer displayTypeIncrement){
this.displayTypeIncrement = displayTypeIncrement;
return this;
}
/**
* 设置 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeList
*/
public ParamQuery displayTypeList(List<Integer> displayTypeList){
this.displayTypeList = displayTypeList;
return this;
}
/**
* 设置 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)
* @param displayTypeNotList
*/
public ParamQuery displayTypeNotList(List<Integer> displayTypeNotList){
this.displayTypeNotList = displayTypeNotList;
return this;
}
/**
* 设置 备注
* @param remark
*/
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;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public ParamQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public ParamQuery createUserIdIncrement(Long 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;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public ParamQuery createUserName(String createUserName){
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;
}
/**
* 设置 创建用户名称
* @param updateUserName
*/
public ParamQuery updateUserName(String updateUserName){
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
bill-manager/src/main/java/com/mortals/xhx/base/system/param/model/vo/ParamVo.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.param.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.param.model.ParamEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 参数信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class ParamVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/param/web/ParamController.java
View file @ deda7b7b
...@@ -35,7 +35,6 @@ import java.util.Map; ...@@ -35,7 +35,6 @@ import java.util.Map;
public class ParamController extends BaseCRUDJsonBodyMappingController<ParamService, ParamEntity, Long> { public class ParamController extends BaseCRUDJsonBodyMappingController<ParamService, ParamEntity, Long> {
public ParamController() { public ParamController() {
super.setFormClass(ParamForm.class);
super.setModuleDesc("参数信息"); super.setModuleDesc("参数信息");
} }
...@@ -59,8 +58,4 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ ...@@ -59,8 +58,4 @@ public class ParamController extends BaseCRUDJsonBodyMappingController<ParamServ
return result; return result;
} }
public static void main(String[] args) {
FileUtil.delete("E:\\pic\\1.png");
}
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/param/web/ParamForm.java deleted 100644 → 0
View file @ 43e84720
/**
* 文件：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
bill-manager/src/main/java/com/mortals/xhx/base/system/resource/model/ResourceEntity.java
View file @ deda7b7b
/**
* 文件：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 java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date; import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong; import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.resource.model.vo.ResourceVo;
import lombok.Data;
/** /**
* <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 url;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authType;
/** 资源类型，0：系统资源，1：开放资源，默认0 */
private Integer sourceType;
/** 创建时间 */
private Date createTime;
/** 创建用户 */
private Long createUserId;
/** 创建用户名称 */
private String createUserName;
/** 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 */
private Integer userType;
public ResourceEntity(){
}
/**
* 获取 名称
* @return name
*/
public String getName(){
return this.name;
}
/**
* 设置 名称
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 连接地址，多个地址以逗号分隔
* @return url
*/
public String getUrl(){
return this.url;
}
/**
* 设置 连接地址，多个地址以逗号分隔
* @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(){ private String name;
return this.createTime;
}
/** /**
* 设置 创建时间 * 分组名称
* @param createTime
*/ */
public void setCreateTime(Date createTime){ private String groupName;
this.createTime = createTime;
}
/** /**
* 获取 创建用户 * 连接地址，多个地址以逗号分隔
* @return createUserId
*/ */
public Long getCreateUserId(){ private String url;
return this.createUserId;
}
/**
* 设置 创建用户
* @param createUserId
*/
public void setCreateUserId(Long createUserId){
this.createUserId = createUserId;
}
/** /**
* 获取 创建用户名称 * 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return createUserName
*/ */
public String getCreateUserName(){ private Integer authType;
return this.createUserName;
}
/** /**
* 设置 创建用户名称 * 资源类型，(0.系统资源，1.开放资源)
* @param createUserName
*/ */
public void setCreateUserName(String createUserName){ private Integer sourceType;
this.createUserName = createUserName;
}
/** /**
* 获取 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 创建用户名称
* @return userType
*/ */
public Integer getUserType(){ private String createUserName;
return this.userType;
}
/** /**
* 设置 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 创建用户名称
* @param userType
*/ */
public void setUserType(Integer userType){ private String updateUserName;
this.userType = userType;
}
@Override @Override
public int hashCode() { public int hashCode() {
return this.getId().hashCode(); return this.getId().hashCode();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (obj == null) if (obj == null) return false;
return false;
if (obj instanceof ResourceEntity) { if (obj instanceof ResourceEntity) {
ResourceEntity tmp = (ResourceEntity) obj; ResourceEntity tmp = (ResourceEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) { if (this.getId() == tmp.getId()) {
return true; return true;
} }
} }
return false; 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(){ public void initAttrValue(){
this.name = null; this.name = "";
this.url = null; this.groupName = "";
this.url = "";
this.authType = 3; this.authType = 3;
this.sourceType = 0; this.sourceType = 0;
this.createTime = null; this.createUserName = "";
this.createUserId = null; this.updateUserName = "";
this.createUserName = null;
this.userType = null;
} }
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/resource/model/ResourceQuery.java
View file @ deda7b7b
/**
* 文件：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;
import com.mortals.xhx.base.system.resource.model.ResourceEntity;
/** /**
* <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;
...@@ -27,44 +18,56 @@ public class ResourceQuery extends ResourceEntity { ...@@ -27,44 +18,56 @@ public class ResourceQuery extends ResourceEntity {
/** 增加 菜单ID，主键，自增长 */ /** 增加 菜单ID，主键，自增长 */
private Long idIncrement; private Long idIncrement;
/** 菜单ID，主键，自增长 */ /** 菜单ID，主键，自增长列表 */
private List<Long> idList; private List <Long> idList;
/** 菜单ID，主键，自增长排除列表 */
private List <Long> idNotList;
/** 名称 */ /** 名称 */
private List<String> nameList; private List<String> nameList;
/** 名称排除列表 */
private List <String> nameNotList;
/** 分组名称 */
private List<String> groupNameList;
/** 分组名称排除列表 */
private List <String> groupNameNotList;
/** 连接地址，多个地址以逗号分隔 */ /** 连接地址，多个地址以逗号分隔 */
private List<String> urlList; private List<String> urlList;
/** 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 连接地址，多个地址以逗号分隔排除列表 */
private List <String> urlNotList;
/** 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeStart; private Integer authTypeStart;
/** 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeEnd; private Integer authTypeEnd;
/** 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
private Integer authTypeIncrement; private Integer authTypeIncrement;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */ /** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)列表 */
private List<Integer> authTypeList; private List <Integer> authTypeList;
/** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)排除列表 */
private List <Integer> authTypeNotList;
/** 开始 资源类型，0：系统资源，1：开放资源，默认0 */ /** 开始 资源类型，(0.系统资源，1.开放资源) */
private Integer sourceTypeStart; private Integer sourceTypeStart;
/** 结束 资源类型，0：系统资源，1：开放资源，默认0 */ /** 结束 资源类型，(0.系统资源，1.开放资源) */
private Integer sourceTypeEnd; private Integer sourceTypeEnd;
/** 增加 资源类型，0：系统资源，1：开放资源，默认0 */ /** 增加 资源类型，(0.系统资源，1.开放资源) */
private Integer sourceTypeIncrement; private Integer sourceTypeIncrement;
/** 资源类型，0：系统资源，1：开放资源，默认0 */ /** 资源类型，(0.系统资源，1.开放资源)列表 */
private List<Integer> sourceTypeList; private List <Integer> sourceTypeList;
/** 开始 创建时间 */ /** 资源类型，(0.系统资源，1.开放资源)排除列表 */
private String createTimeStart; private List <Integer> sourceTypeNotList;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */ /** 开始 创建用户 */
private Long createUserIdStart; private Long createUserIdStart;
...@@ -75,27 +78,57 @@ public class ResourceQuery extends ResourceEntity { ...@@ -75,27 +78,57 @@ public class ResourceQuery extends ResourceEntity {
/** 增加 创建用户 */ /** 增加 创建用户 */
private Long createUserIdIncrement; private Long createUserIdIncrement;
/** 创建用户 */ /** 创建用户列表 */
private List<Long> createUserIdList; private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 创建用户名称 */ /** 创建用户名称 */
private List<String> createUserNameList; private List<String> createUserNameList;
/** 开始 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 */ /** 创建用户名称排除列表 */
private Integer userTypeStart; private List <String> createUserNameNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 */ /** 结束 创建时间 */
private Integer userTypeEnd; private String createTimeEnd;
/** 增加 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 */ /** 开始 更新用户 */
private Integer userTypeIncrement; private Long updateUserIdStart;
/** 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 */ /** 结束 更新用户 */
private List<Integer> userTypeList; 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<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(){}
public ResourceQuery(){
}
/** /**
* 获取 开始 菜单ID，主键，自增长 * 获取 开始 菜单ID，主键，自增长
* @return idStart * @return idStart
...@@ -114,7 +147,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -114,7 +147,7 @@ public class ResourceQuery extends ResourceEntity {
/** /**
* 获取 结束 菜单ID，主键，自增长 * 获取 结束 菜单ID，主键，自增长
* @return idEnd * @return $idEnd
*/ */
public Long getIdEnd(){ public Long getIdEnd(){
return this.idEnd; return this.idEnd;
...@@ -160,6 +193,23 @@ public class ResourceQuery extends ResourceEntity { ...@@ -160,6 +193,23 @@ public class ResourceQuery extends ResourceEntity {
this.idList = 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 * @return nameList
...@@ -176,6 +226,54 @@ public class ResourceQuery extends ResourceEntity { ...@@ -176,6 +226,54 @@ public class ResourceQuery extends ResourceEntity {
this.nameList = 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 * @return urlList
...@@ -193,7 +291,23 @@ public class ResourceQuery extends ResourceEntity { ...@@ -193,7 +291,23 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 连接地址，多个地址以逗号分隔
* @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 * @return authTypeStart
*/ */
public Integer getAuthTypeStart(){ public Integer getAuthTypeStart(){
...@@ -201,7 +315,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -201,7 +315,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart * @param authTypeStart
*/ */
public void setAuthTypeStart(Integer authTypeStart){ public void setAuthTypeStart(Integer authTypeStart){
...@@ -209,15 +323,15 @@ public class ResourceQuery extends ResourceEntity { ...@@ -209,15 +323,15 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeEnd * @return $authTypeEnd
*/ */
public Integer getAuthTypeEnd(){ public Integer getAuthTypeEnd(){
return this.authTypeEnd; return this.authTypeEnd;
} }
/** /**
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd * @param authTypeEnd
*/ */
public void setAuthTypeEnd(Integer authTypeEnd){ public void setAuthTypeEnd(Integer authTypeEnd){
...@@ -225,7 +339,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -225,7 +339,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeIncrement * @return authTypeIncrement
*/ */
public Integer getAuthTypeIncrement(){ public Integer getAuthTypeIncrement(){
...@@ -233,7 +347,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -233,7 +347,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement * @param authTypeIncrement
*/ */
public void setAuthTypeIncrement(Integer authTypeIncrement){ public void setAuthTypeIncrement(Integer authTypeIncrement){
...@@ -241,7 +355,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -241,7 +355,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeList * @return authTypeList
*/ */
public List<Integer> getAuthTypeList(){ public List<Integer> getAuthTypeList(){
...@@ -249,7 +363,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -249,7 +363,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList * @param authTypeList
*/ */
public void setAuthTypeList(List<Integer> authTypeList){ public void setAuthTypeList(List<Integer> authTypeList){
...@@ -257,7 +371,24 @@ public class ResourceQuery extends ResourceEntity { ...@@ -257,7 +371,24 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 开始 资源类型，0：系统资源，1：开放资源，默认0 * 获取 权限类型 (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 * @return sourceTypeStart
*/ */
public Integer getSourceTypeStart(){ public Integer getSourceTypeStart(){
...@@ -265,7 +396,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -265,7 +396,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 开始 资源类型，0：系统资源，1：开放资源，默认0 * 设置 开始 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeStart * @param sourceTypeStart
*/ */
public void setSourceTypeStart(Integer sourceTypeStart){ public void setSourceTypeStart(Integer sourceTypeStart){
...@@ -273,15 +404,15 @@ public class ResourceQuery extends ResourceEntity { ...@@ -273,15 +404,15 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 结束 资源类型，0：系统资源，1：开放资源，默认0 * 获取 结束 资源类型，(0.系统资源，1.开放资源)
* @return sourceTypeEnd * @return $sourceTypeEnd
*/ */
public Integer getSourceTypeEnd(){ public Integer getSourceTypeEnd(){
return this.sourceTypeEnd; return this.sourceTypeEnd;
} }
/** /**
* 设置 结束 资源类型，0：系统资源，1：开放资源，默认0 * 设置 结束 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeEnd * @param sourceTypeEnd
*/ */
public void setSourceTypeEnd(Integer sourceTypeEnd){ public void setSourceTypeEnd(Integer sourceTypeEnd){
...@@ -289,7 +420,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -289,7 +420,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 增加 资源类型，0：系统资源，1：开放资源，默认0 * 获取 增加 资源类型，(0.系统资源，1.开放资源)
* @return sourceTypeIncrement * @return sourceTypeIncrement
*/ */
public Integer getSourceTypeIncrement(){ public Integer getSourceTypeIncrement(){
...@@ -297,7 +428,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -297,7 +428,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 增加 资源类型，0：系统资源，1：开放资源，默认0 * 设置 增加 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeIncrement * @param sourceTypeIncrement
*/ */
public void setSourceTypeIncrement(Integer sourceTypeIncrement){ public void setSourceTypeIncrement(Integer sourceTypeIncrement){
...@@ -305,7 +436,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -305,7 +436,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 资源类型，0：系统资源，1：开放资源，默认0 * 获取 资源类型，(0.系统资源，1.开放资源)
* @return sourceTypeList * @return sourceTypeList
*/ */
public List<Integer> getSourceTypeList(){ public List<Integer> getSourceTypeList(){
...@@ -313,7 +444,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -313,7 +444,7 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 设置 资源类型，0：系统资源，1：开放资源，默认0 * 设置 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeList * @param sourceTypeList
*/ */
public void setSourceTypeList(List<Integer> sourceTypeList){ public void setSourceTypeList(List<Integer> sourceTypeList){
...@@ -321,36 +452,21 @@ public class ResourceQuery extends ResourceEntity { ...@@ -321,36 +452,21 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 开始 创建时间 * 获取 资源类型，(0.系统资源，1.开放资源)
* @return createTimeStart * @return sourceTypeNotList
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/ */
public void setCreateTimeStart(String createTimeStart){ public List<Integer> getSourceTypeNotList(){
this.createTimeStart = createTimeStart; return this.sourceTypeNotList;
} }
/** /**
* 获取 结束 创建时间 * 设置 资源类型，(0.系统资源，1.开放资源)
* @return createTimeEnd * @param sourceTypeNotList
*/ */
public String getCreateTimeEnd(){ public void setSourceTypeNotList(List<Integer> sourceTypeNotList){
return this.createTimeEnd; this.sourceTypeNotList = sourceTypeNotList;
} }
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/** /**
* 获取 开始 创建用户 * 获取 开始 创建用户
...@@ -370,7 +486,7 @@ public class ResourceQuery extends ResourceEntity { ...@@ -370,7 +486,7 @@ public class ResourceQuery extends ResourceEntity {
/** /**
* 获取 结束 创建用户 * 获取 结束 创建用户
* @return createUserIdEnd * @return $createUserIdEnd
*/ */
public Long getCreateUserIdEnd(){ public Long getCreateUserIdEnd(){
return this.createUserIdEnd; return this.createUserIdEnd;
...@@ -416,6 +532,23 @@ public class ResourceQuery extends ResourceEntity { ...@@ -416,6 +532,23 @@ public class ResourceQuery extends ResourceEntity {
this.createUserIdList = 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 * @return createUserNameList
...@@ -433,68 +566,595 @@ public class ResourceQuery extends ResourceEntity { ...@@ -433,68 +566,595 @@ public class ResourceQuery extends ResourceEntity {
} }
/** /**
* 获取 开始 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 获取 创建用户名称
* @return userTypeStart * @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;
return this;
}
/**
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
public ResourceQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
public ResourceQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param 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;
}
/**
* 设置 名称
* @param name
*/
public ResourceQuery name(String name){
setName(name);
return this;
}
/**
* 设置 名称
* @param nameList
*/
public ResourceQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 分组名称
* @param groupName
*/
public ResourceQuery groupName(String groupName){
setGroupName(groupName);
return this;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public ResourceQuery groupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
return this;
}
/**
* 设置 连接地址，多个地址以逗号分隔
* @param url
*/
public ResourceQuery url(String url){
setUrl(url);
return this;
}
/**
* 设置 连接地址，多个地址以逗号分隔
* @param urlList
*/
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;
return this;
}
/**
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
public ResourceQuery authTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
return this;
}
/**
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
public ResourceQuery authTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList
*/
public ResourceQuery authTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
public ResourceQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
return this;
}
/**
* 设置 资源类型，(0.系统资源，1.开放资源)
* @param sourceType
*/
public ResourceQuery sourceType(Integer sourceType){
setSourceType(sourceType);
return this;
}
/**
* 设置 开始 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeStart
*/
public ResourceQuery sourceTypeStart(Integer sourceTypeStart){
this.sourceTypeStart = sourceTypeStart;
return this;
}
/**
* 设置 结束 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeEnd
*/
public ResourceQuery sourceTypeEnd(Integer sourceTypeEnd){
this.sourceTypeEnd = sourceTypeEnd;
return this;
}
/**
* 设置 增加 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeIncrement
*/
public ResourceQuery sourceTypeIncrement(Integer sourceTypeIncrement){
this.sourceTypeIncrement = sourceTypeIncrement;
return this;
}
/**
* 设置 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeList
*/
public ResourceQuery sourceTypeList(List<Integer> sourceTypeList){
this.sourceTypeList = sourceTypeList;
return this;
}
/**
* 设置 资源类型，(0.系统资源，1.开放资源)
* @param sourceTypeNotList
*/
public ResourceQuery sourceTypeNotList(List<Integer> sourceTypeNotList){
this.sourceTypeNotList = sourceTypeNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public ResourceQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public ResourceQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public ResourceQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public ResourceQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param 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 createUserName
*/
public ResourceQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public ResourceQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/ */
public Integer getUserTypeStart(){ public ResourceQuery updateUserId(Long updateUserId){
return this.userTypeStart; setUpdateUserId(updateUserId);
return this;
} }
/** /**
* 设置 开始 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 开始 更新用户
* @param userTypeStart * @param updateUserIdStart
*/ */
public void setUserTypeStart(Integer userTypeStart){ public ResourceQuery updateUserIdStart(Long updateUserIdStart){
this.userTypeStart = userTypeStart; this.updateUserIdStart = updateUserIdStart;
return this;
} }
/** /**
* 获取 结束 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 结束 更新用户
* @return userTypeEnd * @param updateUserIdEnd
*/ */
public Integer getUserTypeEnd(){ public ResourceQuery updateUserIdEnd(Long updateUserIdEnd){
return this.userTypeEnd; this.updateUserIdEnd = updateUserIdEnd;
return this;
} }
/** /**
* 设置 结束 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 增加 更新用户
* @param userTypeEnd * @param updateUserIdIncrement
*/ */
public void setUserTypeEnd(Integer userTypeEnd){ public ResourceQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.userTypeEnd = userTypeEnd; this.updateUserIdIncrement = updateUserIdIncrement;
return this;
} }
/** /**
* 获取 增加 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 更新用户
* @return userTypeIncrement * @param updateUserIdList
*/ */
public Integer getUserTypeIncrement(){ public ResourceQuery updateUserIdList(List<Long> updateUserIdList){
return this.userTypeIncrement; this.updateUserIdList = updateUserIdList;
return this;
} }
/** /**
* 设置 增加 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 更新用户
* @param userTypeIncrement * @param updateUserIdNotList
*/ */
public void setUserTypeIncrement(Integer userTypeIncrement){ public ResourceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.userTypeIncrement = userTypeIncrement; this.updateUserIdNotList = updateUserIdNotList;
return this;
} }
/** /**
* 获取 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 创建用户名称
* @return userTypeList * @param updateUserName
*/ */
public List<Integer> getUserTypeList(){ public ResourceQuery updateUserName(String updateUserName){
return this.userTypeList; setUpdateUserName(updateUserName);
return this;
} }
/** /**
* 设置 用户类型，0：系统用户 1:代理商用户 2:品牌商用户 * 设置 创建用户名称
* @param userTypeList * @param updateUserNameList
*/ */
public void setUserTypeList(List<Integer> userTypeList){ public ResourceQuery updateUserNameList(List<String> updateUserNameList){
this.userTypeList = userTypeList; 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<ResourceQuery> 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<ResourceQuery> 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<ResourceQuery> 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<ResourceQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/resource/model/vo/ResourceVo.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.resource.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 资源信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class ResourceVo extends BaseEntityLong {
/** 菜单ID，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/resource/service/impl/ResourceServiceImpl.java
View file @ deda7b7b
...@@ -125,37 +125,6 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re ...@@ -125,37 +125,6 @@ public class ResourceServiceImpl extends AbstractCRUDServiceImpl<ResourceDao, Re
resourceEntity.setCreateUserId(this.getContextUserId(context)); resourceEntity.setCreateUserId(this.getContextUserId(context));
resourceEntity.setCreateTime(new Date()); resourceEntity.setCreateTime(new Date());
this.save(resourceEntity, context); 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);
}
}
} }
} }
......
bill-manager/src/main/java/com/mortals/xhx/base/system/resource/web/ResourceController.java
View file @ deda7b7b
...@@ -14,6 +14,7 @@ import com.mortals.xhx.base.system.resource.model.ResourceEntity; ...@@ -14,6 +14,7 @@ import com.mortals.xhx.base.system.resource.model.ResourceEntity;
import com.mortals.xhx.base.system.resource.service.ResourceService; import com.mortals.xhx.base.system.resource.service.ResourceService;
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.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
...@@ -57,6 +58,7 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour ...@@ -57,6 +58,7 @@ public class ResourceController extends BaseCRUDJsonBodyMappingController<Resour
* *
* @return * @return
*/ */
@ApiOperation(value = "获取所有资源")
@PostMapping("allResources") @PostMapping("allResources")
public String allResources(int userType) { public String allResources(int userType) {
JSONObject ret = new JSONObject(); JSONObject ret = new JSONObject();
......
bill-manager/src/main/java/com/mortals/xhx/base/system/role/model/vo/RoleAuthVo.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.role.model.RoleAuthEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 角色资源权限业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleAuthVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/role/model/vo/RoleUserVo.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.role.model.RoleUserEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 角色用户业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleUserVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/role/model/vo/RoleVo.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.base.system.role.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.role.model.RoleEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import com.mortals.framework.annotation.Excel;
import java.math.BigDecimal;
import java.util.Date;
/**
* 角色信息业务视图对象
*
* @author zxfei
* @date 2024-09-06
*/
@Data
public class RoleVo extends BaseEntityLong {
/** 序号，主键，自增长列表 */
private List <Long> idList;
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/user/service/impl/UserServiceImpl.java
View file @ deda7b7b
...@@ -243,7 +243,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE ...@@ -243,7 +243,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
} }
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId()); MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) { if (sysModuleParent != null) {
sysModuleParent.getChildList().add(sysModule); sysModuleParent.getChildren().add(sysModule);
} }
} }
return outlookBar; return outlookBar;
......
bill-manager/src/main/java/com/mortals/xhx/common/code/AuthTypeEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/code/CommMenuEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/code/DisplayTypeEnum.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 展现类型 (0.普通文本框，1.多行文本框，2.开关，3.块输入框)枚举类
*
* @author zxfei
*/
public enum DisplayTypeEnum {
普通文本框(0, "普通文本框"),
多行文本框(1, "多行文本框"),
开关(2, "开关"),
块输入框(3, "块输入框");
private Integer value;
private String desc;
DisplayTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DisplayTypeEnum getByValue(Integer value) {
for (DisplayTypeEnum displayTypeEnum : DisplayTypeEnum.values()) {
if (displayTypeEnum.getValue() == value) {
return displayTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (DisplayTypeEnum item : DisplayTypeEnum.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
bill-manager/src/main/java/com/mortals/xhx/common/code/LinkTypeEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/code/MenuTypeEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/code/MethodNameEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/code/ModStatusEnum.java
View file @ deda7b7b
...@@ -4,69 +4,63 @@ import java.util.LinkedHashMap; ...@@ -4,69 +4,63 @@ import java.util.LinkedHashMap;
import java.util.Map; import java.util.Map;
/** /**
* 参数修改状态 * 参数修改状态，(0.隐藏，1.页面仅查看，2.页面可修改，3.页面可删除，4.页面可修改删除)枚举类
* @author *
* * @author zxfei
*/ */
public enum ModStatusEnum { public enum ModStatusEnum {
/** 页面隐藏 */ 隐藏(0, "隐藏"),
HIDDEN(0, "隐藏"), 页面仅查看(1, "页面仅查看"),
/** 页面可查看 */ 页面可修改(2, "页面可修改"),
VIEW(1, "查看"), 页面可删除(3, "页面可删除"),
/** 页面可修改 */ 页面可修改删除(4, "页面可修改删除");
EDIT(2, "修改"), private Integer value;
/** 页面可删除 */
DELETE(3, "删除"),
/** 页面可修改删除 */
EDITANDDELETE(4, "修改删除");
private int value;
private String desc; private String desc;
ModStatusEnum(Integer value, String desc) {
ModStatusEnum(int value, String desc) {
this.value = value; this.value = value;
this.desc = desc; this.desc = desc;
} }
public Integer getValue() {
public int getValue() {
return this.value; return this.value;
} }
public String getDesc() { public String getDesc() {
return desc; return this.desc;
} }
public static ModStatusEnum getByValue(int value) { public static ModStatusEnum getByValue(Integer value) {
for (ModStatusEnum modStatus : ModStatusEnum.values()) { for (ModStatusEnum modStatusEnum : ModStatusEnum.values()) {
if (modStatus.getValue() == value) { if (modStatusEnum.getValue() == value) {
return modStatus; return modStatusEnum;
} }
} }
return null; return null;
} }
/** /**
* 获取Map集合 * 获取Map集合
*
* @param eItem 不包含项 * @param eItem 不包含项
* @return * @return
*/ */
public static Map<String,String> getEnumMap(int... eItem) { public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>(); Map<String, String> resultMap = new LinkedHashMap<>();
for (ModStatusEnum item : ModStatusEnum.values()) { for (ModStatusEnum item : ModStatusEnum.values()) {
try{ try {
boolean hasE = false; boolean hasE = false;
for (int e : eItem){ for (Integer e : eItem) {
if(item.getValue()==e){ if (item.getValue() == e) {
hasE = true; hasE = true;
break; break;
} }
} }
if(!hasE){ if (!hasE) {
resultMap.put(item.getValue()+"", item.getDesc()); resultMap.put(item.getValue() + "", item.getDesc());
} }
}catch(Exception ex){ } catch (Exception ex) {
} }
} }
return resultMap; return resultMap;
......
bill-manager/src/main/java/com/mortals/xhx/common/code/RoleTypeEnum.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 角色类型 (0.系统内置角色,1.默认系统角色.2.普通角色)枚举类
*
* @author zxfei
*/
public enum RoleTypeEnum {
系统内置角色(0, "系统内置角色"),
默认系统角色(1, "默认系统角色");
private Integer value;
private String desc;
RoleTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static RoleTypeEnum getByValue(Integer value) {
for (RoleTypeEnum roleTypeEnum : RoleTypeEnum.values()) {
if (roleTypeEnum.getValue() == value) {
return roleTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (RoleTypeEnum item : RoleTypeEnum.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
bill-manager/src/main/java/com/mortals/xhx/common/code/SourceTypeEnum.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 资源类型，(0.系统资源，1.开放资源)枚举类
*
* @author zxfei
*/
public enum SourceTypeEnum {
系统资源(0, "系统资源"),
开放资源(1, "开放资源");
private Integer value;
private String desc;
SourceTypeEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static SourceTypeEnum getByValue(Integer value) {
for (SourceTypeEnum sourceTypeEnum : SourceTypeEnum.values()) {
if (sourceTypeEnum.getValue() == value) {
return sourceTypeEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (SourceTypeEnum item : SourceTypeEnum.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
bill-manager/src/main/java/com/mortals/xhx/common/code/StatusEnum.java
View file @ deda7b7b
...@@ -4,12 +4,12 @@ import java.util.LinkedHashMap; ...@@ -4,12 +4,12 @@ import java.util.LinkedHashMap;
import java.util.Map; import java.util.Map;
/** /**
* 启用状态 (0.停止，1.启用)枚举类 * 菜单状态 (0.停用，1.启用)枚举类
* *
* @author zxfei * @author zxfei
*/ */
public enum StatusEnum { public enum StatusEnum {
停止(0, "停止"), 停用(0, "停用"),
启用(1, "启用"); 启用(1, "启用");
private Integer value; private Integer value;
private String desc; private String desc;
......
bill-manager/src/main/java/com/mortals/xhx/common/code/ValidStatusEnum.java 0 → 100644
View file @ deda7b7b
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 参数有效状态(0.禁用，1.启用)枚举类
*
* @author zxfei
*/
public enum ValidStatusEnum {
禁用(0, "禁用"),
启用(1, "启用");
private Integer value;
private String desc;
ValidStatusEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public Integer getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static ValidStatusEnum getByValue(Integer value) {
for (ValidStatusEnum validStatusEnum : ValidStatusEnum.values()) {
if (validStatusEnum.getValue() == value) {
return validStatusEnum;
}
}
return null;
}
/**
* 获取Map集合
*
* @param eItem 不包含项
* @return
*/
public static Map<String, String> getEnumMap(Integer... eItem) {
Map<String, String> resultMap = new LinkedHashMap<>();
for (ValidStatusEnum item : ValidStatusEnum.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
bill-manager/src/main/java/com/mortals/xhx/common/code/VisibleEnum.java 0 → 100644
View file @ deda7b7b
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
bill-manager/src/main/java/com/mortals/xhx/common/utils/ControllerScanUtil.java
View file @ deda7b7b
...@@ -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,66 +20,46 @@ import java.lang.reflect.Method; ...@@ -17,66 +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();
resourceEditEntity.setSourceType(1);
Method substringMethod = null; Method substringMethod = null;
String result = ""; String result = "";
try { try {
String packName = cls.getPackage().getName();
if (StrUtil.contains(packName, "system")) {
//系统管理-xx管理-
substringMethod = cls.getMethod("getModuleDesc"); substringMethod = cls.getMethod("getModuleDesc");
result = (String) substringMethod.invoke(cls.newInstance()); result = (String) substringMethod.invoke(cls.getDeclaredConstructor().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);
} }
//获取基础路径
RequestMapping requestMappingCls = cls.getAnnotation(RequestMapping.class); RequestMapping requestMappingCls = cls.getAnnotation(RequestMapping.class);
String prefix = ""; String prefix = "";
if (requestMappingCls != null) { if (requestMappingCls != null) {
...@@ -97,105 +80,107 @@ public class ControllerScanUtil { ...@@ -97,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 (!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) { if (contains) {
UrlViewSet.add(url); name = value.getDesc();
bool = true;
break; break;
} }
} }
if (!bool) {
UrlEditSet.add(url);
} }
}
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); if (!ObjectUtils.isEmpty(url)){
ResourceEntity resourceEntity = buildResourceEntity( result, method, url, name);
resourceArrayList.add(resourceEntity);
}
}
} }
} }
} }
...@@ -203,6 +188,25 @@ public class ControllerScanUtil { ...@@ -203,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);
......
bill-manager/src/main/resources/sqlmap/base/system/MenuMapper.xml 0 → 100644
View file @ deda7b7b
<?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" />
</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>
</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)
VALUES
(#{name},#{url},#{ancestors},#{parentId},#{linkType},#{imgPath},#{buttonImgPath},#{imgCommPath},#{commMenu},#{component},#{menuType},#{authType},#{visible},#{perms},#{remark},#{orderId},#{status},#{createTime},#{createUserId},#{createUserName},#{updateUserId},#{updateUserName},#{updateTime})
</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)
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})
</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>
</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>
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 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>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<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 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="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>
</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>
<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>
<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>
</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
bill-manager/src/main/resources/sqlmap/base/system/ParamMapper.xml 0 → 100644
View file @ deda7b7b
<?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 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>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<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 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()">
<!-- 条件映射-普通条件 -->
<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
bill-manager/src/main/resources/sqlmap/base/system/ResourceMapper.xml 0 → 100644
View file @ deda7b7b
<?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 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>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<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 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()">
<!-- 条件映射-普通条件 -->
<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
bill-manager/src/main/resources/sqlmap/base/system/RoleAuthMapper.xml 0 → 100644
View file @ deda7b7b
<?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 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>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_role_auth where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_role_auth where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_role_auth as a
<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
bill-manager/src/main/resources/sqlmap/base/system/RoleMapper.xml 0 → 100644
View file @ deda7b7b
<?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 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>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<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 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()">
<!-- 条件映射-普通条件 -->
<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
bill-manager/src/main/resources/sqlmap/base/system/RoleUserMapper.xml 0 → 100644
View file @ deda7b7b
<?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
bill-manager/src/main/resources/sqlmap/base/system/menu.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/main/resources/sqlmap/base/system/param.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/main/resources/sqlmap/base/system/resource.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/main/resources/sqlmap/base/system/role.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/main/resources/sqlmap/base/system/roleAuth.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/main/resources/sqlmap/base/system/roleUser.xml deleted 100644 → 0
View file @ 43e84720
<?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
bill-manager/src/test/java/com/mortals/httpclient/system.http
View file @ deda7b7b
...@@ -70,13 +70,23 @@ Content-Type: application/json ...@@ -70,13 +70,23 @@ Content-Type: application/json
"createTimeEnd": "2024-07-29" "createTimeEnd": "2024-07-29"
} }
###所有
POST {{baseUrl}}/stat/stat
Content-Type: application/json
{
"createTimeStart": "2024-07-01",
"createTimeEnd": "2024-06-61",
"accessId": 17
}
###所有 ###所有
POST {{baseUrl}}/access/stat POST {{baseUrl}}/access/stat
Content-Type: application/json Content-Type: application/json
{ {
"accessTimeStart": "2023-01-01", "accessTimeStart": "2023-01-01",
"accessTimeEnd": "2024-08-05" "accessTimeEnd": "2024-08-22"
} }
......
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