Skip to content

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

添加菜单资源配置

parent ff768e7f
Show whitespace changes
Inline Side-by-side
Showing with 2908 additions and 1337 deletions
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuEntity.java
View file @ f9826940
/**
* 文件：MenuEntity.java
* 版本：1.0.0
* 日期：
* Copyright ®
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model; package com.mortals.xhx.base.system.menu.model;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
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.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-12-06
* @author
* @version 1.0.0
*/
public class MenuEntity extends BaseEntityLong{
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) { @Data
this.url = url; public class MenuEntity extends MenuVo {
} private static final long serialVersionUID = 1L;
/**
* 获取 父菜单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) { private String name;
this.status = status;
}
/** /**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 路由地址
* @return linkType
*/ */
public Integer getLinkType() { private String url;
return this.linkType;
}
/** /**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 * 当前节点父id路径，“，”分割
* @param linkType
*/ */
public void setLinkType(Integer linkType) { private String ancestors;
this.linkType = linkType;
}
/** /**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1 * 父菜单ID，一级菜单的该字段值为-1
* @return groupId
*/ */
public Integer getGroupId() { private Long parentId;
return this.groupId;
}
/** /**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1 * 链接方式 (0.普通，1.弹出，2.脚本)
* @param groupId
*/ */
public void setGroupId(Integer groupId) { private Integer linkType;
this.groupId = groupId;
}
public Integer getGroupName() {
return groupName;
}
public void setGroupName(Integer groupName) {
this.groupName = groupName;
}
/** /**
* 获取 主菜单图标，主菜单图标的css样式名 * 主菜单图标，主菜单图标的css样式名
* @return imgPath
*/ */
public String getImgPath() { private String imgPath;
return this.imgPath;
}
/** /**
* 设置 主菜单图标，主菜单图标的css样式名 * 按钮图标，按钮图标的css样式名
* @param imgPath
*/ */
public void setImgPath(String imgPath) { private String buttonImgPath;
this.imgPath = imgPath;
}
/** /**
* 获取 按钮图标，按钮图标的css样式名 * 常用菜单图标，常用菜单图标的css样式名
* @return buttonImgPath
*/ */
public String getButtonImgPath() { private String imgCommPath;
return this.buttonImgPath;
}
/** /**
* 设置 按钮图标，按钮图标的css样式名 * 是否常用菜单 (0.非常用，1.常用)
* @param buttonImgPath
*/ */
public void setButtonImgPath(String buttonImgPath) { private Integer commMenu;
this.buttonImgPath = buttonImgPath;
}
/** /**
* 获取 常用菜单图标，常用菜单图标的css样式名 * vue组件路径
* @return imgCommPath
*/ */
public String getImgCommPath() { private String component;
return this.imgCommPath;
}
/** /**
* 设置 常用菜单图标，常用菜单图标的css样式名 * 菜单类型 (0.目录，1.菜单，2.按钮)
* @param imgCommPath
*/ */
public void setImgCommPath(String imgCommPath) { private Integer menuType;
this.imgCommPath = imgCommPath;
}
/** /**
* 获取 是否常用菜单，0：非常用，1：常用，默认0 * 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return commMenu
*/ */
public Integer getCommMenu() { private Integer authType;
return this.commMenu;
}
/** /**
* 设置 是否常用菜单，0：非常用，1：常用，默认0 * 菜单显示状态 (0.显示，1.隐藏)
* @param commMenu
*/ */
public void setCommMenu(Integer commMenu) { private Integer visible;
this.commMenu = commMenu;
}
/** /**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 权限标识，多个逗号分割
* @return menuType
*/ */
public Integer getMenuType() { private String perms;
return this.menuType;
}
/** /**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 备注信息
* @param menuType
*/ */
public void setMenuType(Integer menuType) { private String remark;
this.menuType = menuType;
}
/** /**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 排序编号
* @return authType
*/ */
public Integer getAuthType() { private Integer orderId;
return this.authType;
}
/** /**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 * 菜单状态 (0.停用，1.启用)
* @param authType
*/ */
public void setAuthType(Integer authType) { private Integer status;
this.authType = authType;
}
/** /**
* 获取 创建时间 * 创建用户名称
* @return createTime
*/ */
@Override private String createUserName;
public Date getCreateTime() {
return this.createTime;
}
/** /**
* 设置 创建时间 * 创建用户名称
* @param createTime
*/ */
@Override private String updateUserName;
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/** /**
* 获取 创建用户 * 是否启用缓存 (0.否，1.是)
* @return createUser
*/ */
@Override private Integer cache;
public String getCreateUser() {
return this.createUser;
}
/** /**
* 设置 创建用户 * 激活目录
* @param createUser
*/ */
@Override private String activeDir;
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
/** /**
* 获取 创建用户名称 * 是否隐藏(0.否，1.是)
* @return createUserName
*/ */
@Override private Integer hideChildrenInMenu;
public String getCreateUserName() {
return this.createUserName;
}
/** /**
* 设置 创建用户名称 * 资源访问路径，多个逗号分割
* @param createUserName
*/ */
@Override private String resourceUrl;
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 = "";
this.cache = 0;
this.activeDir = "";
this.hideChildrenInMenu = 0;
this.resourceUrl = "";
} }
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuQuery.java
View file @ f9826940
/**
* 文件：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-12-06
* @author */
* @version 1.0.0 public class MenuQuery extends MenuEntity {
*/
public class MenuQuery extends MenuEntity{
private static final long serialVersionUID = 1547777703329L;
/** 开始 菜单ID，主键，自增长 */ /** 开始 菜单ID，主键，自增长 */
private Long idStart; private Long idStart;
...@@ -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 */ /** 父菜单ID，一级菜单的该字段值为-1排除列表 */
private Integer statusStart; private List <Long> parentIdNotList;
/** 结束 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusEnd;
/** 增加 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusIncrement;
/** 菜单状态，0：禁用，1：启用，默认1 */
private List<Integer> statusList;
/** 开始 链接方式，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 */
private Integer groupIdEnd;
/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */ /** 链接方式 (0.普通，1.弹出，2.脚本)排除列表 */
private Integer groupIdIncrement; private List <Integer> linkTypeNotList;
/** 分组编号，使用菜单分隔符按该值分隔，默认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;
/** vue组件路径 */
private List<String> componentList;
/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */ /** 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：需要登录查看，3：需要角色权限查看，默认3 */ /** 菜单类型 (0.目录，1.菜单，2.按钮)排除列表 */
private List <Integer> menuTypeNotList;
/** 开始 权限类型 (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,91 @@ public class MenuQuery extends MenuEntity{ ...@@ -159,15 +204,91 @@ 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;
/** 开始 是否启用缓存 (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;
/** 资源访问路径，多个逗号分割 */
private List<String> resourceUrlList;
/** 资源访问路径，多个逗号分割排除列表 */
private List <String> resourceUrlNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MenuQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MenuQuery> andConditionList;
public MenuQuery(){}
public MenuQuery(){
}
/** /**
* 获取 开始 菜单ID，主键，自增长 * 获取 开始 菜单ID，主键，自增长
* @return idStart * @return idStart
...@@ -186,7 +307,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -186,7 +307,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 +353,23 @@ public class MenuQuery extends MenuEntity{ ...@@ -232,6 +353,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 +387,23 @@ public class MenuQuery extends MenuEntity{ ...@@ -249,7 +387,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 +411,61 @@ public class MenuQuery extends MenuEntity{ ...@@ -257,13 +411,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 +484,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -282,7 +484,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 +531,24 @@ public class MenuQuery extends MenuEntity{ ...@@ -329,135 +531,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 +556,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -465,7 +556,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 +564,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -473,15 +564,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 +580,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -489,7 +580,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 +588,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -497,7 +588,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 +596,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -505,7 +596,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 +604,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -513,7 +604,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,115 +612,84 @@ public class MenuQuery extends MenuEntity{ ...@@ -521,115 +612,84 @@ 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;
}
/**
* 获取 分组名称
* @return groupNameList
*/
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
} }
/** /**
* 获取 按钮图标，按钮图标的css样式名 * 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList * @return buttonImgPathNotList
*/ */
public List<String> getButtonImgPathList(){ public List<String> getButtonImgPathNotList(){
return this.buttonImgPathList; return this.buttonImgPathNotList;
} }
/** /**
* 设置 按钮图标，按钮图标的css样式名 * 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList * @param buttonImgPathNotList
*/ */
public void setButtonImgPathList(List<String> buttonImgPathList){ public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.buttonImgPathList = buttonImgPathList; this.buttonImgPathNotList = buttonImgPathNotList;
} }
/** /**
...@@ -649,7 +709,23 @@ public class MenuQuery extends MenuEntity{ ...@@ -649,7 +709,23 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 开始 是否常用菜单，0：非常用，1：常用，默认0 * 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathNotList
*/
public List<String> getImgCommPathNotList(){
return this.imgCommPathNotList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathNotList
*/
public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathNotList = imgCommPathNotList;
}
/**
* 获取 开始 是否常用菜单 (0.非常用，1.常用)
* @return commMenuStart * @return commMenuStart
*/ */
public Integer getCommMenuStart(){ public Integer getCommMenuStart(){
...@@ -657,7 +733,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -657,7 +733,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 +741,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -665,15 +741,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 +757,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -681,7 +757,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 是否常用菜单，0：非常用，1：常用，默认0 * 获取 增加 是否常用菜单 (0.非常用，1.常用)
* @return commMenuIncrement * @return commMenuIncrement
*/ */
public Integer getCommMenuIncrement(){ public Integer getCommMenuIncrement(){
...@@ -689,7 +765,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -689,7 +765,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 +773,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -697,7 +773,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 +781,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -705,7 +781,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 +789,56 @@ public class MenuQuery extends MenuEntity{ ...@@ -713,7 +789,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 +846,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -721,7 +846,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 +854,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -729,15 +854,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 +870,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -745,7 +870,7 @@ public class MenuQuery extends MenuEntity{
} }
/** /**
* 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 * 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @return menuTypeIncrement * @return menuTypeIncrement
*/ */
public Integer getMenuTypeIncrement(){ public Integer getMenuTypeIncrement(){
...@@ -753,7 +878,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -753,7 +878,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 +886,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -761,7 +886,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 +894,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -769,7 +894,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 +902,24 @@ public class MenuQuery extends MenuEntity{ ...@@ -777,7 +902,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 +927,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -785,7 +927,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 +935,15 @@ public class MenuQuery extends MenuEntity{ ...@@ -793,15 +935,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 +951,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -809,7 +951,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 +959,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -817,7 +959,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 +967,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -825,7 +967,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 +975,7 @@ public class MenuQuery extends MenuEntity{ ...@@ -833,7 +975,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 +983,1826 @@ public class MenuQuery extends MenuEntity{ ...@@ -841,116 +983,1826 @@ 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 createUserNameList * @return permsList
*/ */
public List<String> getCreateUserNameList(){ public List<String> getPermsList(){
return this.createUserNameList; return this.permsList;
} }
/** /**
* 设置 创建用户名称 * 设置 权限标识，多个逗号分割
* @param createUserNameList * @param permsList
*/ */
public void setCreateUserNameList(List<String> createUserNameList){ public void setPermsList(List<String> permsList){
this.createUserNameList = createUserNameList; this.permsList = permsList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsNotList
*/
public List<String> getPermsNotList(){
return this.permsNotList;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsNotList
*/
public void setPermsNotList(List<String> permsNotList){
this.permsNotList = permsNotList;
}
/**
* 获取 备注信息
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注信息
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注信息
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注信息
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return $orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 排序编号
* @return orderIdNotList
*/
public List<Integer> getOrderIdNotList(){
return this.orderIdNotList;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public void setOrderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
}
/**
* 获取 开始 菜单状态 (0.停用，1.启用)
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态 (0.停用，1.启用)
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
} }
/**
* 获取 增加 菜单状态 (0.停用，1.启用)
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态 (0.停用，1.启用)
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 菜单状态 (0.停用，1.启用)
* @return statusNotList
*/
public List<Integer> getStatusNotList(){
return this.statusNotList;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusNotList
*/
public void setStatusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 创建用户名称
* @return createUserNameNotList
*/
public List<String> getCreateUserNameNotList(){
return this.createUserNameNotList;
}
/**
* 设置 创建用户名称
* @param createUserNameNotList
*/
public void setCreateUserNameNotList(List<String> createUserNameNotList){
this.createUserNameNotList = createUserNameNotList;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 创建用户名称
* @return updateUserNameList
*/
public List<String> getUpdateUserNameList(){
return this.updateUserNameList;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public void setUpdateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
}
/**
* 获取 创建用户名称
* @return updateUserNameNotList
*/
public List<String> getUpdateUserNameNotList(){
return this.updateUserNameNotList;
}
/**
* 设置 创建用户名称
* @param updateUserNameNotList
*/
public void setUpdateUserNameNotList(List<String> updateUserNameNotList){
this.updateUserNameNotList = updateUserNameNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 开始 是否启用缓存 (0.否，1.是)
* @return cacheStart
*/
public Integer getCacheStart(){
return this.cacheStart;
}
/**
* 设置 开始 是否启用缓存 (0.否，1.是)
* @param cacheStart
*/
public void setCacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
}
/**
* 获取 结束 是否启用缓存 (0.否，1.是)
* @return $cacheEnd
*/
public Integer getCacheEnd(){
return this.cacheEnd;
}
/**
* 设置 结束 是否启用缓存 (0.否，1.是)
* @param cacheEnd
*/
public void setCacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
}
/**
* 获取 增加 是否启用缓存 (0.否，1.是)
* @return cacheIncrement
*/
public Integer getCacheIncrement(){
return this.cacheIncrement;
}
/**
* 设置 增加 是否启用缓存 (0.否，1.是)
* @param cacheIncrement
*/
public void setCacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
}
/**
* 获取 是否启用缓存 (0.否，1.是)
* @return cacheList
*/
public List<Integer> getCacheList(){
return this.cacheList;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheList
*/
public void setCacheList(List<Integer> cacheList){
this.cacheList = cacheList;
}
/**
* 获取 是否启用缓存 (0.否，1.是)
* @return cacheNotList
*/
public List<Integer> getCacheNotList(){
return this.cacheNotList;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheNotList
*/
public void setCacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
}
/**
* 获取 激活目录
* @return activeDirList
*/
public List<String> getActiveDirList(){
return this.activeDirList;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public void setActiveDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
}
/**
* 获取 激活目录
* @return activeDirNotList
*/
public List<String> getActiveDirNotList(){
return this.activeDirNotList;
}
/**
* 设置 激活目录
* @param activeDirNotList
*/
public void setActiveDirNotList(List<String> activeDirNotList){
this.activeDirNotList = activeDirNotList;
}
/**
* 获取 开始 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuStart
*/
public Integer getHideChildrenInMenuStart(){
return this.hideChildrenInMenuStart;
}
/**
* 设置 开始 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuStart
*/
public void setHideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
}
/**
* 获取 结束 是否隐藏(0.否，1.是)
* @return $hideChildrenInMenuEnd
*/
public Integer getHideChildrenInMenuEnd(){
return this.hideChildrenInMenuEnd;
}
/**
* 设置 结束 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuEnd
*/
public void setHideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
}
/**
* 获取 增加 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuIncrement
*/
public Integer getHideChildrenInMenuIncrement(){
return this.hideChildrenInMenuIncrement;
}
/**
* 设置 增加 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuIncrement
*/
public void setHideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
}
/**
* 获取 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuList
*/
public List<Integer> getHideChildrenInMenuList(){
return this.hideChildrenInMenuList;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuList
*/
public void setHideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
}
/**
* 获取 是否隐藏(0.否，1.是)
* @return hideChildrenInMenuNotList
*/
public List<Integer> getHideChildrenInMenuNotList(){
return this.hideChildrenInMenuNotList;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuNotList
*/
public void setHideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
}
/**
* 获取 资源访问路径，多个逗号分割
* @return resourceUrlList
*/
public List<String> getResourceUrlList(){
return this.resourceUrlList;
}
/**
* 设置 资源访问路径，多个逗号分割
* @param resourceUrlList
*/
public void setResourceUrlList(List<String> resourceUrlList){
this.resourceUrlList = resourceUrlList;
}
/**
* 获取 资源访问路径，多个逗号分割
* @return resourceUrlNotList
*/
public List<String> getResourceUrlNotList(){
return this.resourceUrlNotList;
}
/**
* 设置 资源访问路径，多个逗号分割
* @param resourceUrlNotList
*/
public void setResourceUrlNotList(List<String> resourceUrlNotList){
this.resourceUrlNotList = resourceUrlNotList;
}
/**
* 设置 菜单ID，主键，自增长
* @param id
*/
public MenuQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
public MenuQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
public MenuQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
public MenuQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idList
*/
public MenuQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public MenuQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 菜单名称
* @param name
*/
public MenuQuery name(String name){
setName(name);
return this;
}
/**
* 设置 菜单名称
* @param nameList
*/
public MenuQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 路由地址
* @param url
*/
public MenuQuery url(String url){
setUrl(url);
return this;
}
/**
* 设置 路由地址
* @param urlList
*/
public MenuQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestors
*/
public MenuQuery ancestors(String ancestors){
setAncestors(ancestors);
return this;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
public MenuQuery ancestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public MenuQuery parentId(Long parentId){
setParentId(parentId);
return this;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public MenuQuery parentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
return this;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public MenuQuery parentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
return this;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public MenuQuery parentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
public MenuQuery parentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
public MenuQuery parentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
return this;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkType
*/
public MenuQuery linkType(Integer linkType){
setLinkType(linkType);
return this;
}
/**
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeStart
*/
public MenuQuery linkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
return this;
}
/**
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeEnd
*/
public MenuQuery linkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
return this;
}
/**
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeIncrement
*/
public MenuQuery linkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
return this;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeList
*/
public MenuQuery linkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
return this;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeNotList
*/
public MenuQuery linkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
return this;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
public MenuQuery imgPath(String imgPath){
setImgPath(imgPath);
return this;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public MenuQuery imgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
public MenuQuery buttonImgPath(String buttonImgPath){
setButtonImgPath(buttonImgPath);
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public MenuQuery buttonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
public MenuQuery imgCommPath(String imgCommPath){
setImgCommPath(imgCommPath);
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public MenuQuery imgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenu
*/
public MenuQuery commMenu(Integer commMenu){
setCommMenu(commMenu);
return this;
}
/**
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* @param commMenuStart
*/
public MenuQuery commMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
return this;
}
/**
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* @param commMenuEnd
*/
public MenuQuery commMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
return this;
}
/**
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* @param commMenuIncrement
*/
public MenuQuery commMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuList
*/
public MenuQuery commMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
return this;
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* @param commMenuNotList
*/
public MenuQuery commMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
return this;
}
/**
* 设置 vue组件路径
* @param component
*/
public MenuQuery component(String component){
setComponent(component);
return this;
}
/**
* 设置 vue组件路径
* @param componentList
*/
public MenuQuery componentList(List<String> componentList){
this.componentList = componentList;
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuType
*/
public MenuQuery menuType(Integer menuType){
setMenuType(menuType);
return this;
}
/**
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeStart
*/
public MenuQuery menuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
return this;
}
/**
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeEnd
*/
public MenuQuery menuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
return this;
}
/**
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeIncrement
*/
public MenuQuery menuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeList
*/
public MenuQuery menuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
return this;
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* @param menuTypeNotList
*/
public MenuQuery menuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authType
*/
public MenuQuery authType(Integer authType){
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeStart
*/
public MenuQuery authTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
return this;
}
/**
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeEnd
*/
public MenuQuery authTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
return this;
}
/**
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeIncrement
*/
public MenuQuery authTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeList
*/
public MenuQuery authTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
return this;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
public MenuQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
return this;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visible
*/
public MenuQuery visible(Integer visible){
setVisible(visible);
return this;
}
/**
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
public MenuQuery visibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
return this;
}
/**
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
public MenuQuery visibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
return this;
}
/**
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
public MenuQuery visibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
return this;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleList
*/
public MenuQuery visibleList(List<Integer> visibleList){
this.visibleList = visibleList;
return this;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleNotList
*/
public MenuQuery visibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
return this;
}
/**
* 设置 权限标识，多个逗号分割
* @param perms
*/
public MenuQuery perms(String perms){
setPerms(perms);
return this;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsList
*/
public MenuQuery permsList(List<String> permsList){
this.permsList = permsList;
return this;
}
/**
* 设置 备注信息
* @param remark
*/
public MenuQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注信息
* @param remarkList
*/
public MenuQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 排序编号
* @param orderId
*/
public MenuQuery orderId(Integer orderId){
setOrderId(orderId);
return this;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public MenuQuery orderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
return this;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public MenuQuery orderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
return this;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public MenuQuery orderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
return this;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public MenuQuery orderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
return this;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
return this;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param status
*/
public MenuQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
*/
public MenuQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
*/
public MenuQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 菜单状态 (0.停用，1.启用)
* @param statusIncrement
*/
public MenuQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusList
*/
public MenuQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
/**
* 设置 菜单状态 (0.停用，1.启用)
* @param statusNotList
*/
public MenuQuery statusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MenuQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MenuQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MenuQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MenuQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MenuQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public MenuQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public MenuQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public MenuQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public MenuQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public MenuQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public MenuQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public MenuQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public MenuQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 设置 创建用户名称
* @param updateUserName
*/
public MenuQuery updateUserName(String updateUserName){
setUpdateUserName(updateUserName);
return this;
}
/**
* 设置 创建用户名称
* @param updateUserNameList
*/
public MenuQuery updateUserNameList(List<String> updateUserNameList){
this.updateUserNameList = updateUserNameList;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cache
*/
public MenuQuery cache(Integer cache){
setCache(cache);
return this;
}
/**
* 设置 开始 是否启用缓存 (0.否，1.是)
* @param cacheStart
*/
public MenuQuery cacheStart(Integer cacheStart){
this.cacheStart = cacheStart;
return this;
}
/**
* 设置 结束 是否启用缓存 (0.否，1.是)
* @param cacheEnd
*/
public MenuQuery cacheEnd(Integer cacheEnd){
this.cacheEnd = cacheEnd;
return this;
}
/**
* 设置 增加 是否启用缓存 (0.否，1.是)
* @param cacheIncrement
*/
public MenuQuery cacheIncrement(Integer cacheIncrement){
this.cacheIncrement = cacheIncrement;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheList
*/
public MenuQuery cacheList(List<Integer> cacheList){
this.cacheList = cacheList;
return this;
}
/**
* 设置 是否启用缓存 (0.否，1.是)
* @param cacheNotList
*/
public MenuQuery cacheNotList(List<Integer> cacheNotList){
this.cacheNotList = cacheNotList;
return this;
}
/**
* 设置 激活目录
* @param activeDir
*/
public MenuQuery activeDir(String activeDir){
setActiveDir(activeDir);
return this;
}
/**
* 设置 激活目录
* @param activeDirList
*/
public MenuQuery activeDirList(List<String> activeDirList){
this.activeDirList = activeDirList;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenu
*/
public MenuQuery hideChildrenInMenu(Integer hideChildrenInMenu){
setHideChildrenInMenu(hideChildrenInMenu);
return this;
}
/**
* 设置 开始 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuStart
*/
public MenuQuery hideChildrenInMenuStart(Integer hideChildrenInMenuStart){
this.hideChildrenInMenuStart = hideChildrenInMenuStart;
return this;
}
/**
* 设置 结束 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuEnd
*/
public MenuQuery hideChildrenInMenuEnd(Integer hideChildrenInMenuEnd){
this.hideChildrenInMenuEnd = hideChildrenInMenuEnd;
return this;
}
/**
* 设置 增加 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuIncrement
*/
public MenuQuery hideChildrenInMenuIncrement(Integer hideChildrenInMenuIncrement){
this.hideChildrenInMenuIncrement = hideChildrenInMenuIncrement;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuList
*/
public MenuQuery hideChildrenInMenuList(List<Integer> hideChildrenInMenuList){
this.hideChildrenInMenuList = hideChildrenInMenuList;
return this;
}
/**
* 设置 是否隐藏(0.否，1.是)
* @param hideChildrenInMenuNotList
*/
public MenuQuery hideChildrenInMenuNotList(List<Integer> hideChildrenInMenuNotList){
this.hideChildrenInMenuNotList = hideChildrenInMenuNotList;
return this;
}
/**
* 设置 资源访问路径，多个逗号分割
* @param resourceUrl
*/
public MenuQuery resourceUrl(String resourceUrl){
setResourceUrl(resourceUrl);
return this;
}
/**
* 设置 资源访问路径，多个逗号分割
* @param resourceUrlList
*/
public MenuQuery resourceUrlList(List<String> resourceUrlList){
this.resourceUrlList = resourceUrlList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MenuQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<MenuQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<MenuQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<MenuQuery> andConditionList){
this.andConditionList = andConditionList;
}
} }
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/vo/MenuVo.java
View file @ f9826940
...@@ -23,6 +23,8 @@ public class MenuVo extends BaseEntityLong { ...@@ -23,6 +23,8 @@ public class MenuVo extends BaseEntityLong {
/** 子菜单信息业务 */ /** 子菜单信息业务 */
private List<MenuEntity> children = new ArrayList<>(); private List<MenuEntity> children = new ArrayList<>();
private List<MenuEntity> childList = new ArrayList<>();
private Integer type; private Integer type;
/** /**
......
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