Skip to content

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

添加菜单资源配置

parent 10b6bfe8
Hide whitespace changes
Inline Side-by-side
Showing with 2661 additions and 2110 deletions
bill-manager/db/add.sql
View file @ 26ab28b3
......@@ -344,31 +344,35 @@ CREATE TABLE mortals_xhx_role_user(
-- ----------------------------
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`)
`id` bigint(20) AUTO_INCREMENT COMMENT '菜单ID，主键，自增长',
`name` varchar(50) COMMENT '菜单名称',
`url` varchar(256) COMMENT '路由地址',
`ancestors` varchar(255) COMMENT '当前节点父id路径，“，”分割',
`parentId` bigint(20) COMMENT '父菜单ID，一级菜单的该字段值为-1',
`linkType` tinyint(2) DEFAULT '0' COMMENT '链接方式 (0.普通，1.弹出，2.脚本)',
`imgPath` varchar(128) COMMENT '主菜单图标，主菜单图标的css样式名',
`buttonImgPath` varchar(128) COMMENT '按钮图标，按钮图标的css样式名',
`imgCommPath` varchar(128) COMMENT '常用菜单图标，常用菜单图标的css样式名',
`commMenu` tinyint(2) DEFAULT '1' COMMENT '是否常用菜单 (0.非常用，1.常用)',
`component` varchar(128) COMMENT 'vue组件路径',
`menuType` tinyint(2) DEFAULT '0' COMMENT '菜单类型 (0.目录，1.菜单，2.按钮)',
`authType` tinyint(2) DEFAULT '3' COMMENT '权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)',
`visible` tinyint(2) DEFAULT '0' COMMENT '菜单显示状态 (0.显示，1.隐藏)',
`perms` varchar(128) COMMENT '权限标识，多个逗号分割',
`orderId` int(4) COMMENT '排序编号',
`status` tinyint(2) DEFAULT '1' COMMENT '菜单状态 (0.停用，1.启用)',
`cache` tinyint(2) DEFAULT '0' COMMENT '是否启用缓存 (0.否，1.是)',
`activeDir` varchar(128) COMMENT '激活目录',
`hideChildrenInMenu` tinyint(2) DEFAULT '0' COMMENT '是否隐藏(0.否，1.是)',
`remark` varchar(512) COMMENT '备注信息',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`createUserName` varchar(50) COMMENT '创建用户名称',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateUserName` varchar(50) COMMENT '创建用户名称',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='菜单信息业务';
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuEntity.java
View file @ 26ab28b3
......@@ -10,94 +10,106 @@ import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
import lombok.Data;
/**
* 菜单信息业务实体对象
*
* @author zxfei
* @date 2024-09-06
*/
* 菜单信息业务实体对象
*
* @author zxfei
* @date 2024-09-11
*/
@Data
public class MenuEntity extends MenuVo {
private static final long serialVersionUID = 1L;
/**
* 菜单名称
*/
* 菜单名称
*/
private String name;
/**
* 路由地址
*/
* 路由地址
*/
private String url;
/**
* 当前节点父id路径，“，”分割
*/
* 当前节点父id路径，“，”分割
*/
private String ancestors;
/**
* 父菜单ID，一级菜单的该字段值为-1
*/
* 父菜单ID，一级菜单的该字段值为-1
*/
private Long parentId;
/**
* 链接方式 (0.普通，1.弹出，2.脚本)
*/
* 链接方式 (0.普通，1.弹出，2.脚本)
*/
private Integer linkType;
/**
* 主菜单图标，主菜单图标的css样式名
*/
* 主菜单图标，主菜单图标的css样式名
*/
private String imgPath;
/**
* 按钮图标，按钮图标的css样式名
*/
* 按钮图标，按钮图标的css样式名
*/
private String buttonImgPath;
/**
* 常用菜单图标，常用菜单图标的css样式名
*/
* 常用菜单图标，常用菜单图标的css样式名
*/
private String imgCommPath;
/**
* 是否常用菜单 (0.非常用，1.常用)
*/
* 是否常用菜单 (0.非常用，1.常用)
*/
private Integer commMenu;
/**
* vue组件路径
*/
* vue组件路径
*/
private String component;
/**
* 菜单类型 (0.目录，1.菜单，2.按钮)
*/
* 菜单类型 (0.目录，1.菜单，2.按钮)
*/
private Integer menuType;
/**
* 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
*/
* 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
*/
private Integer authType;
/**
* 菜单显示状态 (0.显示，1.隐藏)
*/
* 菜单显示状态 (0.显示，1.隐藏)
*/
private Integer visible;
/**
* 权限标识，多个逗号分割
*/
* 权限标识，多个逗号分割
*/
private String perms;
/**
* 备注信息
*/
* 备注信息
*/
private String remark;
/**
* 排序编号
*/
* 排序编号
*/
private Integer orderId;
/**
* 菜单状态 (0.停用，1.启用)
*/
* 菜单状态 (0.停用，1.启用)
*/
private Integer status;
/**
* 创建用户名称
*/
* 创建用户名称
*/
private String createUserName;
/**
* 创建用户名称
*/
* 创建用户名称
*/
private String updateUserName;
/**
* 是否启用缓存 (0.否，1.是)
*/
private Integer cache;
/**
* 激活目录
*/
private String activeDir;
/**
* 是否隐藏(0.否，1.是)
*/
private Integer hideChildrenInMenu;
@Override
public int hashCode() {
return this.getId().hashCode();
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
......@@ -105,31 +117,34 @@ public class MenuEntity extends MenuVo {
if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
return true;
}
}
return false;
}
public void initAttrValue(){
this.name = "";
this.url = "";
this.ancestors = "";
this.parentId = null;
this.linkType = 0;
this.imgPath = "";
this.buttonImgPath = "";
this.imgCommPath = "";
this.commMenu = 1;
this.component = "";
this.menuType = 0;
this.authType = 3;
this.visible = 0;
this.perms = "";
this.remark = "";
this.orderId = 0;
this.status = 1;
this.createUserName = "";
this.updateUserName = "";
this.name = "";
this.url = "";
this.ancestors = "";
this.parentId = null;
this.linkType = 0;
this.imgPath = "";
this.buttonImgPath = "";
this.imgCommPath = "";
this.commMenu = 1;
this.component = "";
this.menuType = 0;
this.authType = 3;
this.visible = 0;
this.perms = "";
this.remark = "";
this.orderId = 0;
this.status = 1;
this.createUserName = "";
this.updateUserName = "";
this.cache = 0;
this.activeDir = "";
this.hideChildrenInMenu = 0;
}
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuQuery.java
View file @ 26ab28b3
......@@ -3,11 +3,11 @@ package com.mortals.xhx.base.system.menu.model;
import java.util.List;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
/**
* 菜单信息业务查询对象
*
* @author zxfei
* @date 2024-09-06
*/
* 菜单信息业务查询对象
*
* @author zxfei
* @date 2024-09-11
*/
public class MenuQuery extends MenuEntity {
/** 开始 菜单ID，主键，自增长 */
private Long idStart;
......@@ -241,6 +241,41 @@ public class MenuQuery extends MenuEntity {
/** 结束 更新时间 */
private String updateTimeEnd;
/** 开始 是否启用缓存 (0.否，1.是) */
private Integer cacheStart;
/** 结束 是否启用缓存 (0.否，1.是) */
private Integer cacheEnd;
/** 增加 是否启用缓存 (0.否，1.是) */
private Integer cacheIncrement;
/** 是否启用缓存 (0.否，1.是)列表 */
private List <Integer> cacheList;
/** 是否启用缓存 (0.否，1.是)排除列表 */
private List <Integer> cacheNotList;
/** 激活目录 */
private List<String> activeDirList;
/** 激活目录排除列表 */
private List <String> activeDirNotList;
/** 开始 是否隐藏(0.否，1.是) */
private Integer hideChildrenInMenuStart;
/** 结束 是否隐藏(0.否，1.是) */
private Integer hideChildrenInMenuEnd;
/** 增加 是否隐藏(0.否，1.是) */
private Integer hideChildrenInMenuIncrement;
/** 是否隐藏(0.否，1.是)列表 */
private List <Integer> hideChildrenInMenuList;
/** 是否隐藏(0.否，1.是)排除列表 */
private List <Integer> hideChildrenInMenuNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MenuQuery> orConditionList;
......@@ -250,2145 +285,2466 @@ public class MenuQuery extends MenuEntity {
public MenuQuery(){}
/**
* 获取 开始 菜单ID，主键，自增长
* @return idStart
*/
* 获取 开始 菜单ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 菜单ID，主键，自增长
* @return $idEnd
*/
* 获取 结束 菜单ID，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 菜单ID，主键，自增长
* @return idIncrement
*/
* 获取 增加 菜单ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 菜单ID，主键，自增长
* @return idList
*/
* 获取 菜单ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 菜单ID，主键，自增长
* @param idList
*/
* 设置 菜单ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 菜单ID，主键，自增长
* @return idNotList
*/
* 获取 菜单ID，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 菜单名称
* @return nameList
*/
* 获取 菜单名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 菜单名称
* @param nameList
*/
* 设置 菜单名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 菜单名称
* @return nameNotList
*/
* 获取 菜单名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 菜单名称
* @param nameNotList
*/
* 设置 菜单名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 路由地址
* @return urlList
*/
* 获取 路由地址
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 路由地址
* @param urlList
*/
* 设置 路由地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 路由地址
* @return urlNotList
*/
* 获取 路由地址
* @return urlNotList
*/
public List<String> getUrlNotList(){
return this.urlNotList;
}
/**
* 设置 路由地址
* @param urlNotList
*/
* 设置 路由地址
* @param urlNotList
*/
public void setUrlNotList(List<String> urlNotList){
this.urlNotList = urlNotList;
}
/**
* 获取 当前节点父id路径，“，”分割
* @return ancestorsList
*/
* 获取 当前节点父id路径，“，”分割
* @return ancestorsList
*/
public List<String> getAncestorsList(){
return this.ancestorsList;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
public void setAncestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
}
/**
* 获取 当前节点父id路径，“，”分割
* @return ancestorsNotList
*/
* 获取 当前节点父id路径，“，”分割
* @return ancestorsNotList
*/
public List<String> getAncestorsNotList(){
return this.ancestorsNotList;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsNotList
*/
* 设置 当前节点父id路径，“，”分割
* @param ancestorsNotList
*/
public void setAncestorsNotList(List<String> ancestorsNotList){
this.ancestorsNotList = ancestorsNotList;
}
/**
* 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart
*/
* 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart
*/
public Long getParentIdStart(){
return this.parentIdStart;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public void setParentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
}
/**
* 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return $parentIdEnd
*/
* 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return $parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public void setParentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
}
/**
* 获取 增加 父菜单ID，一级菜单的该字段值为-1
* @return parentIdIncrement
*/
* 获取 增加 父菜单ID，一级菜单的该字段值为-1
* @return parentIdIncrement
*/
public Long getParentIdIncrement(){
return this.parentIdIncrement;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public void setParentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdList
*/
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdList
*/
public List<Long> getParentIdList(){
return this.parentIdList;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
public void setParentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdNotList
*/
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdNotList
*/
public List<Long> getParentIdNotList(){
return this.parentIdNotList;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
public void setParentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
}
/**
* 获取 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeStart
*/
* 获取 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
return this.linkTypeStart;
}
/**
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart
*/
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
}
/**
* 获取 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @return $linkTypeEnd
*/
* 获取 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @return $linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd
*/
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
}
/**
* 获取 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeIncrement
*/
* 获取 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
return this.linkTypeIncrement;
}
/**
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement
*/
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
}
/**
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeList
*/
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
return this.linkTypeList;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeList
*/
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
}
/**
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeNotList
*/
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeNotList
*/
public List<Integer> getLinkTypeNotList(){
return this.linkTypeNotList;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeNotList
*/
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeNotList
*/
public void setLinkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathNotList
*/
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathNotList
*/
public List<String> getImgPathNotList(){
return this.imgPathNotList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathNotList
*/
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathNotList
*/
public void setImgPathNotList(List<String> imgPathNotList){
this.imgPathNotList = imgPathNotList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
*/
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathNotList
*/
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathNotList
*/
public List<String> getButtonImgPathNotList(){
return this.buttonImgPathNotList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathNotList
*/
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathNotList
*/
public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.buttonImgPathNotList = buttonImgPathNotList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList
*/
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathNotList
*/
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathNotList
*/
public List<String> getImgCommPathNotList(){
return this.imgCommPathNotList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathNotList
*/
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathNotList
*/
public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathNotList = imgCommPathNotList;
}
/**
* 获取 开始 是否常用菜单 (0.非常用，1.常用)
* @return commMenuStart
*/
* 获取 开始 是否常用菜单 (0.非常用，1.常用)
* @return commMenuStart
*/
public Integer getCommMenuStart(){
return this.commMenuStart;
}
/**
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart
*/
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
}
/**
* 获取 结束 是否常用菜单 (0.非常用，1.常用)
* @return $commMenuEnd
*/
* 获取 结束 是否常用菜单 (0.非常用，1.常用)
* @return $commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd
*/
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
}
/**
* 获取 增加 是否常用菜单 (0.非常用，1.常用)
* @return commMenuIncrement
*/
* 获取 增加 是否常用菜单 (0.非常用，1.常用)
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
return this.commMenuIncrement;
}
/**
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement
*/
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
}
/**
* 获取 是否常用菜单 (0.非常用，1.常用)
* @return commMenuList
*/
* 获取 是否常用菜单 (0.非常用，1.常用)
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
return this.commMenuList;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuList
*/
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
}
/**
* 获取 是否常用菜单 (0.非常用，1.常用)
* @return commMenuNotList
*/
* 获取 是否常用菜单 (0.非常用，1.常用)
* @return commMenuNotList
*/
public List<Integer> getCommMenuNotList(){
return this.commMenuNotList;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuNotList
*/
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuNotList
*/
public void setCommMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
}
/**
* 获取 vue组件路径
* @return componentList
*/
* 获取 vue组件路径
* @return componentList
*/
public List<String> getComponentList(){
return this.componentList;
}
/**
* 设置 vue组件路径
* @param componentList
*/
* 设置 vue组件路径
* @param componentList
*/
public void setComponentList(List<String> componentList){
this.componentList = componentList;
}
/**
* 获取 vue组件路径
* @return componentNotList
*/
* 获取 vue组件路径
* @return componentNotList
*/
public List<String> getComponentNotList(){
return this.componentNotList;
}
/**
* 设置 vue组件路径
* @param componentNotList
*/
* 设置 vue组件路径
* @param componentNotList
*/
public void setComponentNotList(List<String> componentNotList){
this.componentNotList = componentNotList;
}
/**
* 获取 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeStart
*/
* 获取 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
return this.menuTypeStart;
}
/**
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart
*/
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
}
/**
* 获取 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @return $menuTypeEnd
*/
* 获取 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @return $menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd
*/
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
}
/**
* 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeIncrement
*/
* 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
return this.menuTypeIncrement;
}
/**
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement
*/
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
}
/**
* 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeList
*/
* 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
return this.menuTypeList;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeList
*/
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
}
/**
* 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeNotList
*/
* 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeNotList
*/
public List<Integer> getMenuTypeNotList(){
return this.menuTypeNotList;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeNotList
*/
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeNotList
*/
public void setMenuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
}
/**
* 获取 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeStart
*/
* 获取 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart
*/
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return $authTypeEnd
*/
* 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return $authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeIncrement
*/
* 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeList
*/
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList
*/
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeNotList
*/
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeNotList
*/
public List<Integer> getAuthTypeNotList(){
return this.authTypeNotList;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
}
/**
* 获取 开始 菜单显示状态 (0.显示，1.隐藏)
* @return visibleStart
*/
* 获取 开始 菜单显示状态 (0.显示，1.隐藏)
* @return visibleStart
*/
public Integer getVisibleStart(){
return this.visibleStart;
}
/**
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
public void setVisibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
}
/**
* 获取 结束 菜单显示状态 (0.显示，1.隐藏)
* @return $visibleEnd
*/
* 获取 结束 菜单显示状态 (0.显示，1.隐藏)
* @return $visibleEnd
*/
public Integer getVisibleEnd(){
return this.visibleEnd;
}
/**
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
public void setVisibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
}
/**
* 获取 增加 菜单显示状态 (0.显示，1.隐藏)
* @return visibleIncrement
*/
* 获取 增加 菜单显示状态 (0.显示，1.隐藏)
* @return visibleIncrement
*/
public Integer getVisibleIncrement(){
return this.visibleIncrement;
}
/**
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
public void setVisibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
}
/**
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleList
*/
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleList
*/
public List<Integer> getVisibleList(){
return this.visibleList;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleList
*/
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleList
*/
public void setVisibleList(List<Integer> visibleList){
this.visibleList = visibleList;
}
/**
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleNotList
*/
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleNotList
*/
public List<Integer> getVisibleNotList(){
return this.visibleNotList;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleNotList
*/
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleNotList
*/
public void setVisibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsList
*/
* 获取 权限标识，多个逗号分割
* @return permsList
*/
public List<String> getPermsList(){
return this.permsList;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsList
*/
* 设置 权限标识，多个逗号分割
* @param permsList
*/
public void setPermsList(List<String> permsList){
this.permsList = permsList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsNotList
*/
* 获取 权限标识，多个逗号分割
* @return permsNotList
*/
public List<String> getPermsNotList(){
return this.permsNotList;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsNotList
*/
* 设置 权限标识，多个逗号分割
* @param permsNotList
*/
public void setPermsNotList(List<String> permsNotList){
this.permsNotList = permsNotList;
}
/**
* 获取 备注信息
* @return remarkList
*/
* 获取 备注信息
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注信息
* @param remarkList
*/
* 设置 备注信息
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注信息
* @return remarkNotList
*/
* 获取 备注信息
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注信息
* @param remarkNotList
*/
* 设置 备注信息
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return $orderIdEnd
*/
* 获取 结束 排序编号
* @return $orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 排序编号
* @return orderIdNotList
*/
* 获取 排序编号
* @return orderIdNotList
*/
public List<Integer> getOrderIdNotList(){
return this.orderIdNotList;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
* 设置 排序编号
* @param orderIdNotList
*/
public void setOrderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
}
/**
* 获取 开始 菜单状态 (0.停用，1.启用)
* @return statusStart
*/
* 获取 开始 菜单状态 (0.停用，1.启用)
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态 (0.停用，1.启用)
* @return $statusEnd
*/
* 获取 结束 菜单状态 (0.停用，1.启用)
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态 (0.停用，1.启用)
* @return statusIncrement
*/
* 获取 增加 菜单状态 (0.停用，1.启用)
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态 (0.停用，1.启用)
* @return statusList
*/
* 获取 菜单状态 (0.停用，1.启用)
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusList
*/
* 设置 菜单状态 (0.停用，1.启用)
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 菜单状态 (0.停用，1.启用)
* @return statusNotList
*/
* 获取 菜单状态 (0.停用，1.启用)
* @return statusNotList
*/
public List<Integer> getStatusNotList(){
return this.statusNotList;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusNotList
*/
* 设置 菜单状态 (0.停用，1.启用)
* @param statusNotList
*/
public void setStatusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 创建用户名称
* @return createUserNameNotList
*/
* 获取 创建用户名称
* @return createUserNameNotList
*/
public List<String> getCreateUserNameNotList(){
return this.createUserNameNotList;
}
/**
* 设置 创建用户名称
* @param createUserNameNotList
*/
* 设置 创建用户名称
* @param createUserNameNotList
*/
public void setCreateUserNameNotList(List<String> createUserNameNotList){
this.createUserNameNotList = createUserNameNotList;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 菜单ID，主键，自增长
* @param id
*/
* 获取 开始 是否启用缓存 (0.否，1.是)
* @return cacheStart
*/
public Integer getCacheStart(){
return this.cacheStart;
}
/**
* 设置 开始 是否启用缓存 (0.否，1.是)
* @param cacheStart
*/
public void setCacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
}
/**
* 获取 结束 是否启用缓存 (0.否，1.是)
* @return $cacheEnd
*/
public Integer getCacheEnd(){
return this.cacheEnd;
}
/**
* 设置 结束 是否启用缓存 (0.否，1.是)
* @param cacheEnd
*/
public void setCacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
}
/**
* 获取 增加 是否启用缓存 (0.否，1.是)
* @return cacheIncrement
*/
public Integer getCacheIncrement(){
return this.cacheIncrement;
}
/**
* 设置 增加 是否启用缓存 (0.否，1.是)
* @param cacheIncrement
*/
public void setCacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
}
/**
* 获取 是否启用缓存 (0.否，1.是)
* @return cacheList
*/
public List<Integer> getCacheList(){
return this.cacheList;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheList
*/
public void setCacheList(List<Integer> cacheList){
this.cacheList = cacheList;
}
/**
* 获取 是否启用缓存 (0.否，1.是)
* @return cacheNotList
*/
public List<Integer> getCacheNotList(){
return this.cacheNotList;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheNotList
*/
public void setCacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
}
/**
* 获取 激活目录
* @return activeDirList
*/
public List<String> getActiveDirList(){
return this.activeDirList;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public void setActiveDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
}
/**
* 获取 激活目录
* @return activeDirNotList
*/
public List<String> getActiveDirNotList(){
return this.activeDirNotList;
}
/**
* 设置 激活目录
* @param activeDirNotList
*/
public void setActiveDirNotList(List<String> activeDirNotList){
this.activeDirNotList = activeDirNotList;
}
/**
* 获取 开始 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuStart
*/
public Integer getHideChildrenInMenuStart(){
return this.hideChildrenInMenuStart;
}
/**
* 设置 开始 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuStart
*/
public void setHideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
}
/**
* 获取 结束 是否隐藏(0.否，1.是)
* @return $hideChildrenInMenuEnd
*/
public Integer getHideChildrenInMenuEnd(){
return this.hideChildrenInMenuEnd;
}
/**
* 设置 结束 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuEnd
*/
public void setHideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
}
/**
* 获取 增加 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuIncrement
*/
public Integer getHideChildrenInMenuIncrement(){
return this.hideChildrenInMenuIncrement;
}
/**
* 设置 增加 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuIncrement
*/
public void setHideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
}
/**
* 获取 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuList
*/
public List<Integer> getHideChildrenInMenuList(){
return this.hideChildrenInMenuList;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuList
*/
public void setHideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
}
/**
* 获取 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuNotList
*/
public List<Integer> getHideChildrenInMenuNotList(){
return this.hideChildrenInMenuNotList;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuNotList
*/
public void setHideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
}
/**
* 设置 菜单ID，主键，自增长
* @param id
*/
public MenuQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
setId(id);
return this;
}
/**
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
public MenuQuery idStart(Long idStart){
this.idStart = idStart;
return this;
this.idStart = idStart;
return this;
}
/**
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
public MenuQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
public MenuQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idList
*/
* 设置 菜单ID，主键，自增长
* @param idList
*/
public MenuQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public MenuQuery idNotList(List<Long> idNotList){
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public MenuQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
}
/**
* 设置 菜单名称
* @param name
*/
/**
* 设置 菜单名称
* @param name
*/
public MenuQuery name(String name){
setName(name);
return this;
return this;
}
/**
* 设置 菜单名称
* @param nameList
*/
* 设置 菜单名称
* @param nameList
*/
public MenuQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
return this;
}
/**
* 设置 路由地址
* @param url
*/
/**
* 设置 路由地址
* @param url
*/
public MenuQuery url(String url){
setUrl(url);
return this;
return this;
}
/**
* 设置 路由地址
* @param urlList
*/
* 设置 路由地址
* @param urlList
*/
public MenuQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
return this;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestors
*/
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestors
*/
public MenuQuery ancestors(String ancestors){
setAncestors(ancestors);
return this;
return this;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
public MenuQuery ancestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
return this;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public MenuQuery parentId(Long parentId){
setParentId(parentId);
return this;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
setParentId(parentId);
return this;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public MenuQuery parentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
return this;
this.parentIdStart = parentIdStart;
return this;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public MenuQuery parentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
return this;
this.parentIdEnd = parentIdEnd;
return this;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public MenuQuery parentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
return this;
this.parentIdIncrement = parentIdIncrement;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
* 设置 父菜单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){
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
public MenuQuery parentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
return this;
}
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkType
*/
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkType
*/
public MenuQuery linkType(Integer linkType){
setLinkType(linkType);
return this;
}
/**
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart
*/
setLinkType(linkType);
return this;
}
/**
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart
*/
public MenuQuery linkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
return this;
this.linkTypeStart = linkTypeStart;
return this;
}
/**
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd
*/
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd
*/
public MenuQuery linkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
return this;
this.linkTypeEnd = linkTypeEnd;
return this;
}
/**
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement
*/
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement
*/
public MenuQuery linkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
return this;
this.linkTypeIncrement = linkTypeIncrement;
return this;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeList
*/
* 设置 链接方式 (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){
return this;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeNotList
*/
public MenuQuery linkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
return this;
}
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
public MenuQuery imgPath(String imgPath){
setImgPath(imgPath);
return this;
return this;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public MenuQuery imgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
return this;
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
public MenuQuery buttonImgPath(String buttonImgPath){
setButtonImgPath(buttonImgPath);
return this;
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public MenuQuery buttonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
return this;
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
public MenuQuery imgCommPath(String imgCommPath){
setImgCommPath(imgCommPath);
return this;
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public MenuQuery imgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
return this;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenu
*/
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenu
*/
public MenuQuery commMenu(Integer commMenu){
setCommMenu(commMenu);
return this;
}
/**
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart
*/
setCommMenu(commMenu);
return this;
}
/**
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart
*/
public MenuQuery commMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
return this;
this.commMenuStart = commMenuStart;
return this;
}
/**
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd
*/
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd
*/
public MenuQuery commMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
return this;
this.commMenuEnd = commMenuEnd;
return this;
}
/**
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement
*/
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement
*/
public MenuQuery commMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
return this;
this.commMenuIncrement = commMenuIncrement;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuList
*/
* 设置 是否常用菜单 (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){
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuNotList
*/
public MenuQuery commMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
return this;
}
}
/**
* 设置 vue组件路径
* @param component
*/
/**
* 设置 vue组件路径
* @param component
*/
public MenuQuery component(String component){
setComponent(component);
return this;
return this;
}
/**
* 设置 vue组件路径
* @param componentList
*/
* 设置 vue组件路径
* @param componentList
*/
public MenuQuery componentList(List<String> componentList){
this.componentList = componentList;
return this;
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuType
*/
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuType
*/
public MenuQuery menuType(Integer menuType){
setMenuType(menuType);
return this;
}
/**
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart
*/
setMenuType(menuType);
return this;
}
/**
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart
*/
public MenuQuery menuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
return this;
this.menuTypeStart = menuTypeStart;
return this;
}
/**
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd
*/
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd
*/
public MenuQuery menuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
return this;
this.menuTypeEnd = menuTypeEnd;
return this;
}
/**
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement
*/
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement
*/
public MenuQuery menuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
return this;
this.menuTypeIncrement = menuTypeIncrement;
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeList
*/
* 设置 菜单类型 (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){
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeNotList
*/
public MenuQuery menuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
return this;
}
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authType
*/
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authType
*/
public MenuQuery authType(Integer authType){
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart
*/
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart
*/
public MenuQuery authTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
return this;
this.authTypeStart = authTypeStart;
return this;
}
/**
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
public MenuQuery authTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
return this;
this.authTypeEnd = authTypeEnd;
return this;
}
/**
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
public MenuQuery authTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
return this;
this.authTypeIncrement = authTypeIncrement;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList
*/
* 设置 权限类型 (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){
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
public MenuQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
return this;
}
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visible
*/
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visible
*/
public MenuQuery visible(Integer visible){
setVisible(visible);
return this;
}
/**
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
setVisible(visible);
return this;
}
/**
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
public MenuQuery visibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
return this;
this.visibleStart = visibleStart;
return this;
}
/**
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
public MenuQuery visibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
return this;
this.visibleEnd = visibleEnd;
return this;
}
/**
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
public MenuQuery visibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
return this;
this.visibleIncrement = visibleIncrement;
return this;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleList
*/
* 设置 菜单显示状态 (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){
return this;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleNotList
*/
public MenuQuery visibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
return this;
}
}
/**
* 设置 权限标识，多个逗号分割
* @param perms
*/
/**
* 设置 权限标识，多个逗号分割
* @param perms
*/
public MenuQuery perms(String perms){
setPerms(perms);
return this;
return this;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsList
*/
* 设置 权限标识，多个逗号分割
* @param permsList
*/
public MenuQuery permsList(List<String> permsList){
this.permsList = permsList;
return this;
return this;
}
/**
* 设置 备注信息
* @param remark
*/
/**
* 设置 备注信息
* @param remark
*/
public MenuQuery remark(String remark){
setRemark(remark);
return this;
return this;
}
/**
* 设置 备注信息
* @param remarkList
*/
* 设置 备注信息
* @param remarkList
*/
public MenuQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
return this;
}
/**
* 设置 排序编号
* @param orderId
*/
* 设置 排序编号
* @param orderId
*/
public MenuQuery orderId(Integer orderId){
setOrderId(orderId);
return this;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
setOrderId(orderId);
return this;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public MenuQuery orderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
return this;
this.orderIdStart = orderIdStart;
return this;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
* 设置 结束 排序编号
* @param orderIdEnd
*/
public MenuQuery orderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
return this;
this.orderIdEnd = orderIdEnd;
return this;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public MenuQuery orderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
return this;
this.orderIdIncrement = orderIdIncrement;
return this;
}
/**
* 设置 排序编号
* @param orderIdList
*/
* 设置 排序编号
* @param orderIdList
*/
public MenuQuery orderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
return this;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
return this;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
return this;
}
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param status
*/
* 设置 菜单状态 (0.停用，1.启用)
* @param status
*/
public MenuQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
setStatus(status);
return this;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
public MenuQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
public MenuQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
public MenuQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusList
*/
* 设置 菜单状态 (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){
return this;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusNotList
*/
public MenuQuery statusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
return this;
}
}
/**
* 设置 创建用户
* @param createUserId
*/
* 设置 创建用户
* @param createUserId
*/
public MenuQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MenuQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MenuQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MenuQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public MenuQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
}
/**
* 设置 创建用户名称
* @param createUserName
*/
/**
* 设置 创建用户名称
* @param createUserName
*/
public MenuQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
* 设置 创建用户名称
* @param createUserNameList
*/
public MenuQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
* 设置 更新用户
* @param updateUserId
*/
public MenuQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public MenuQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public MenuQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public MenuQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
* 设置 更新用户
* @param updateUserIdList
*/
public MenuQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MenuQuery updateUserIdNotList(List<Long> updateUserIdNotList){
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MenuQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
}
/**
* 设置 创建用户名称
* @param updateUserName
*/
/**
* 设置 创建用户名称
* @param updateUserName
*/
public MenuQuery updateUserName(String updateUserName){
setUpdateUserName(updateUserName);
return this;
return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
* 设置 创建用户名称
* @param updateUserNameList
*/
public MenuQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cache
*/
public MenuQuery cache(Integer cache){
setCache(cache);
return this;
}
/**
* 设置 开始 是否启用缓存 (0.否，1.是)
* @param cacheStart
*/
public MenuQuery cacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
return this;
}
/**
* 设置 结束 是否启用缓存 (0.否，1.是)
* @param cacheEnd
*/
public MenuQuery cacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
return this;
}
/**
* 设置 增加 是否启用缓存 (0.否，1.是)
* @param cacheIncrement
*/
public MenuQuery cacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheList
*/
public MenuQuery cacheList(List<Integer> cacheList){
this.cacheList = cacheList;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheNotList
*/
public MenuQuery cacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
return this;
}
/**
* 设置 激活目录
* @param activeDir
*/
public MenuQuery activeDir(String activeDir){
setActiveDir(activeDir);
return this;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public MenuQuery activeDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenu
*/
public MenuQuery hideChildrenInMenu(Integer hideChildrenInMenu){
setHideChildrenInMenu(hideChildrenInMenu);
return this;
}
/**
* 设置 开始 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuStart
*/
public MenuQuery hideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
return this;
}
/**
* 设置 结束 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuEnd
*/
public MenuQuery hideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
return this;
}
/**
* 设置 增加 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuIncrement
*/
public MenuQuery hideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuList
*/
public MenuQuery hideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuNotList
*/
public MenuQuery hideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MenuQuery> getOrConditionList(){
return this.orConditionList;
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<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
*/
* 获取 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
*/
* 设置 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;
}
......
bill-manager/src/main/resources/sqlmap/base/system/MenuMapper.xml
View file @ 26ab28b3
This source diff could not be displayed because it is too large. You can view the blob instead.
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