Skip to content

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

Revert "Revert "添加菜单资源配置"" 

This reverts commit 26ca1add.
parent 26ca1add
Show whitespace changes
Inline Side-by-side
Showing with 1873 additions and 3057 deletions
bill-manager/db/base.sql
View file @ ff768e7f
This source diff could not be displayed because it is too large. You can view the blob instead.
bill-manager/pom.xml
View file @ ff768e7f
......@@ -278,9 +278,6 @@
</execution>
</executions>
</plugin>
</plugins>
</build>
......
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuEntity.java
View file @ ff768e7f
/**
* 文件：MenuEntity.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
import java.util.ArrayList;
import java.math.BigDecimal;
import cn.hutool.core.date.DateUtil;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
import lombok.Data;
import java.util.List;
/**
* 菜单信息业务实体对象
*
* @author zxfei
* @date 2024-12-06
* <p>Title: 菜单信息</p>
* <p>Description: MenuEntity </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
@Data
public class MenuEntity extends MenuVo {
private static final long serialVersionUID = 1L;
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
*/
private String name;
public String getName() {
return this.name;
}
/**
* 路由地址
* 设置 菜单名称
* @param name
*/
private String url;
public void setName(String name) {
this.name = name;
}
/**
* 当前节点父id路径，“，”分割
* 获取 连接地址
* @return url
*/
private String ancestors;
public String getUrl() {
return this.url;
}
/**
* 父菜单ID，一级菜单的该字段值为-1
* 设置 连接地址
* @param url
*/
private Long parentId;
public void setUrl(String url) {
this.url = url;
}
/**
* 链接方式 (0.普通，1.弹出，2.脚本)
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentId
*/
private Integer linkType;
public Long getParentId() {
return this.parentId;
}
/**
* 主菜单图标，主菜单图标的css样式名
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
private String imgPath;
public void setParentId(Long parentId) {
this.parentId = parentId;
}
/**
* 按钮图标，按钮图标的css样式名
* 获取 排序编号
* @return orderId
*/
private String buttonImgPath;
public Integer getOrderId() {
return this.orderId;
}
/**
* 常用菜单图标，常用菜单图标的css样式名
* 设置 排序编号
* @param orderId
*/
private String imgCommPath;
public void setOrderId(Integer orderId) {
this.orderId = orderId;
}
/**
* 是否常用菜单 (0.非常用，1.常用)
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return status
*/
private Integer commMenu;
public Integer getStatus() {
return this.status;
}
/**
* vue组件路径
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param status
*/
private String component;
public void setStatus(Integer status) {
this.status = status;
}
/**
* 菜单类型 (0.目录，1.菜单，2.按钮)
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkType
*/
private Integer menuType;
public Integer getLinkType() {
return this.linkType;
}
/**
* 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkType
*/
private Integer authType;
public void setLinkType(Integer linkType) {
this.linkType = linkType;
}
/**
* 菜单显示状态 (0.显示，1.隐藏)
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupId
*/
private Integer visible;
public Integer getGroupId() {
return this.groupId;
}
/**
* 权限标识，多个逗号分割
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupId
*/
private String perms;
public void setGroupId(Integer groupId) {
this.groupId = groupId;
}
public Integer getGroupName() {
return groupName;
}
public void setGroupName(Integer groupName) {
this.groupName = groupName;
}
/**
* 备注信息
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPath
*/
private String remark;
public String getImgPath() {
return this.imgPath;
}
/**
* 排序编号
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
private Integer orderId;
public void setImgPath(String imgPath) {
this.imgPath = imgPath;
}
/**
* 菜单状态 (0.停用，1.启用)
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPath
*/
private Integer status;
public String getButtonImgPath() {
return this.buttonImgPath;
}
/**
* 创建用户名称
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
private String createUserName;
public void setButtonImgPath(String buttonImgPath) {
this.buttonImgPath = buttonImgPath;
}
/**
* 创建用户名称
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPath
*/
private String updateUserName;
public String getImgCommPath() {
return this.imgCommPath;
}
/**
* 是否启用缓存 (0.否，1.是)
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
private Integer cache;
public void setImgCommPath(String imgCommPath) {
this.imgCommPath = imgCommPath;
}
/**
* 激活目录
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenu
*/
private String activeDir;
public Integer getCommMenu() {
return this.commMenu;
}
/**
* 是否隐藏(0.否，1.是)
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenu
*/
private Integer hideChildrenInMenu;
public void setCommMenu(Integer commMenu) {
this.commMenu = commMenu;
}
/**
* 资源访问路径，多个逗号分割
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuType
*/
public Integer getMenuType() {
return this.menuType;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuType
*/
public void setMenuType(Integer menuType) {
this.menuType = menuType;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authType
*/
public Integer getAuthType() {
return this.authType;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authType
*/
public void setAuthType(Integer authType) {
this.authType = authType;
}
/**
* 获取 创建时间
* @return createTime
*/
private String resourceUrl;
@Override
public Date getCreateTime() {
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
@Override
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 获取 创建用户
* @return createUser
*/
@Override
public String getCreateUser() {
return this.createUser;
}
/**
* 设置 创建用户
* @param createUser
*/
@Override
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
@Override
public String getCreateUserName() {
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
@Override
public void setCreateUserName(String createUserName) {
this.createUserName = createUserName;
}
public List<MenuEntity> getChildList() {
return childList;
}
public void setChildList(List<MenuEntity> childList) {
this.childList = childList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj == null) {
return false;
}
if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj;
if (this.getId() == tmp.getId()) {
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.name = "";
this.url = "";
this.ancestors = "";
@Override
public String toString() {
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",url:").append(getUrl())
.append(",parentId:").append(getParentId())
.append(",orderId:").append(getOrderId())
.append(",status:").append(getStatus())
.append(",linkType:").append(getLinkType())
.append(",groupId:").append(getGroupId())
.append(",groupName:").append(getGroupName())
.append(",imgPath:").append(getImgPath())
.append(",buttonImgPath:").append(getButtonImgPath())
.append(",imgCommPath:").append(getImgCommPath())
.append(",commMenu:").append(getCommMenu())
.append(",menuType:").append(getMenuType())
.append(",authType:").append(getAuthType())
.append(",createTime:").append(getCreateTime())
.append(",createUser:").append(getCreateUser())
.append(",createUserName:").append(getCreateUserName());
return sb.toString();
}
@Override
public void initAttrValue() {
this.name = null;
this.url = null;
this.parentId = null;
this.orderId = 0;
this.status = 1;
this.linkType = 0;
this.imgPath = "";
this.buttonImgPath = "";
this.imgCommPath = "";
this.commMenu = 1;
this.component = "";
this.groupId = 1;
this.imgPath = null;
this.buttonImgPath = null;
this.imgCommPath = null;
this.commMenu = 0;
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;
this.resourceUrl = "";
this.createTime = null;
this.createUser = null;
this.createUserName = null;
}
}
\ No newline at end of file
bill-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuQuery.java
View file @ ff768e7f
package com.mortals.xhx.base.system.menu.model;
/**
* 文件：MenuQuery.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
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-12-06
*/
public class MenuQuery extends MenuEntity {
* <p>Title: 菜单信息</p>
* <p>Description: MenuQuery </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
public class MenuQuery extends MenuEntity{
private static final long serialVersionUID = 1547777703329L;
/** 开始 菜单ID，主键，自增长 */
private Long idStart;
......@@ -18,27 +27,15 @@ public class MenuQuery extends MenuEntity {
/** 增加 菜单ID，主键，自增长 */
private Long idIncrement;
/** 菜单ID，主键，自增长列表 */
private List <Long> idList;
/** 菜单ID，主键，自增长排除列表 */
private List <Long> idNotList;
/** 菜单ID，主键，自增长 */
private List<Long> idList;
/** 菜单名称 */
private List<String> nameList;
/** 菜单名称排除列表 */
private List <String> nameNotList;
/** 路由地址 */
/** 连接地址 */
private List<String> urlList;
/** 路由地址排除列表 */
private List <String> urlNotList;
/** 当前节点父id路径，“，”分割 */
private List<String> ancestorsList;
/** 当前节点父id路径，“，”分割排除列表 */
private List <String> ancestorsNotList;
/** 开始 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdStart;
......@@ -48,146 +45,104 @@ public class MenuQuery extends MenuEntity {
/** 增加 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdIncrement;
/** 父菜单ID，一级菜单的该字段值为-1列表 */
private List <Long> parentIdList;
/** 父菜单ID，一级菜单的该字段值为-1 */
private List<Long> parentIdList;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 结束 排序编号 */
private Integer orderIdEnd;
/** 增加 排序编号 */
private Integer orderIdIncrement;
/** 排序编号 */
private List<Integer> orderIdList;
/** 父菜单ID，一级菜单的该字段值为-1排除列表 */
private List <Long> parentIdNotList;
/** 开始 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusStart;
/** 结束 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusEnd;
/** 增加 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusIncrement;
/** 菜单状态，0：禁用，1：启用，默认1 */
private List<Integer> statusList;
/** 开始 链接方式 (0.普通，1.弹出，2.脚本) */
/** 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeStart;
/** 结束 链接方式 (0.普通，1.弹出，2.脚本) */
/** 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeEnd;
/** 增加 链接方式 (0.普通，1.弹出，2.脚本) */
/** 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeIncrement;
/** 链接方式 (0.普通，1.弹出，2.脚本)列表 */
private List <Integer> linkTypeList;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private List<Integer> linkTypeList;
/** 开始 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdStart;
/** 结束 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdEnd;
/** 链接方式 (0.普通，1.弹出，2.脚本)排除列表 */
private List <Integer> linkTypeNotList;
/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdIncrement;
/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
private List<Integer> groupIdList;
/** 分组名称 */
private List<String> groupNameList;
/** 主菜单图标，主菜单图标的css样式名 */
private List<String> imgPathList;
/** 主菜单图标，主菜单图标的css样式名排除列表 */
private List <String> imgPathNotList;
/** 按钮图标，按钮图标的css样式名 */
private List<String> buttonImgPathList;
/** 按钮图标，按钮图标的css样式名排除列表 */
private List <String> buttonImgPathNotList;
/** 常用菜单图标，常用菜单图标的css样式名 */
private List<String> imgCommPathList;
/** 常用菜单图标，常用菜单图标的css样式名排除列表 */
private List <String> imgCommPathNotList;
/** 开始 是否常用菜单 (0.非常用，1.常用) */
/** 开始 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuStart;
/** 结束 是否常用菜单 (0.非常用，1.常用) */
/** 结束 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuEnd;
/** 增加 是否常用菜单 (0.非常用，1.常用) */
/** 增加 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuIncrement;
/** 是否常用菜单 (0.非常用，1.常用)列表 */
private List <Integer> commMenuList;
/** 是否常用菜单 (0.非常用，1.常用)排除列表 */
private List <Integer> commMenuNotList;
/** vue组件路径 */
private List<String> componentList;
/** 是否常用菜单，0：非常用，1：常用，默认0 */
private List<Integer> commMenuList;
/** vue组件路径排除列表 */
private List <String> componentNotList;
/** 开始 菜单类型 (0.目录，1.菜单，2.按钮) */
/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeStart;
/** 结束 菜单类型 (0.目录，1.菜单，2.按钮) */
/** 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeEnd;
/** 增加 菜单类型 (0.目录，1.菜单，2.按钮) */
/** 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeIncrement;
/** 菜单类型 (0.目录，1.菜单，2.按钮)列表 */
private List <Integer> menuTypeList;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private List<Integer> menuTypeList;
/** 菜单类型 (0.目录，1.菜单，2.按钮)排除列表 */
private List <Integer> menuTypeNotList;
/** 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
/** 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeStart;
/** 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
/** 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeEnd;
/** 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看) */
/** 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeIncrement;
/** 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)列表 */
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;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private List<Integer> authTypeList;
/** 开始 创建时间 */
private String createTimeStart;
......@@ -204,91 +159,15 @@ public class MenuQuery extends MenuEntity {
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 创建用户 */
private List<Long> createUserIdList;
/** 创建用户名称 */
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，主键，自增长
* @return idStart
......@@ -307,7 +186,7 @@ public class MenuQuery extends MenuEntity {
/**
* 获取 结束 菜单ID，主键，自增长
* @return $idEnd
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
......@@ -353,23 +232,6 @@ public class MenuQuery extends MenuEntity {
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
......@@ -387,23 +249,7 @@ 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
*/
public List<String> getUrlList(){
......@@ -411,61 +257,13 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 路由地址
* 设置 连接地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 路由地址
* @return urlNotList
*/
public List<String> getUrlNotList(){
return this.urlNotList;
}
/**
* 设置 路由地址
* @param urlNotList
*/
public void setUrlNotList(List<String> urlNotList){
this.urlNotList = urlNotList;
}
/**
* 获取 当前节点父id路径，“，”分割
* @return ancestorsList
*/
public List<String> getAncestorsList(){
return this.ancestorsList;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsList
*/
public void setAncestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
}
/**
* 获取 当前节点父id路径，“，”分割
* @return ancestorsNotList
*/
public List<String> getAncestorsNotList(){
return this.ancestorsNotList;
}
/**
* 设置 当前节点父id路径，“，”分割
* @param ancestorsNotList
*/
public void setAncestorsNotList(List<String> ancestorsNotList){
this.ancestorsNotList = ancestorsNotList;
}
/**
* 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart
......@@ -484,7 +282,7 @@ public class MenuQuery extends MenuEntity {
/**
* 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return $parentIdEnd
* @return parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
......@@ -531,24 +329,135 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdNotList
* 获取 开始 排序编号
* @return orderIdStart
*/
public List<Long> getParentIdNotList(){
return this.parentIdNotList;
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 开始 菜单状态，0：禁用，1：启用，默认1
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态，0：禁用，1：启用，默认1
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态，0：禁用，1：启用，默认1
* @return statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态，0：禁用，1：启用，默认1
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态，0：禁用，1：启用，默认1
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态，0：禁用，1：启用，默认1
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return statusList
*/
public void setParentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 开始 链接方式 (0.普通，1.弹出，2.脚本)
* 获取 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
......@@ -556,7 +465,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 开始 链接方式 (0.普通，1.弹出，2.脚本)
* 设置 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
......@@ -564,15 +473,15 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 结束 链接方式 (0.普通，1.弹出，2.脚本)
* @return $linkTypeEnd
* 获取 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式 (0.普通，1.弹出，2.脚本)
* 设置 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
......@@ -580,7 +489,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 增加 链接方式 (0.普通，1.弹出，2.脚本)
* 获取 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
......@@ -588,7 +497,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 增加 链接方式 (0.普通，1.弹出，2.脚本)
* 设置 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
......@@ -596,7 +505,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
......@@ -604,7 +513,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
......@@ -612,120 +521,135 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 链接方式 (0.普通，1.弹出，2.脚本)
* @return linkTypeNotList
* 获取 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdStart
*/
public List<Integer> getLinkTypeNotList(){
return this.linkTypeNotList;
public Integer getGroupIdStart(){
return this.groupIdStart;
}
/**
* 设置 链接方式 (0.普通，1.弹出，2.脚本)
* @param linkTypeNotList
* 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdStart
*/
public void setLinkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
public void setGroupIdStart(Integer groupIdStart){
this.groupIdStart = groupIdStart;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
* 获取 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdEnd
*/
public List<String> getImgPathList(){
return this.imgPathList;
public Integer getGroupIdEnd(){
return this.groupIdEnd;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
* 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdEnd
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
public void setGroupIdEnd(Integer groupIdEnd){
this.groupIdEnd = groupIdEnd;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathNotList
* 获取 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdIncrement
*/
public List<String> getImgPathNotList(){
return this.imgPathNotList;
public Integer getGroupIdIncrement(){
return this.groupIdIncrement;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathNotList
* 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdIncrement
*/
public void setImgPathNotList(List<String> imgPathNotList){
this.imgPathNotList = imgPathNotList;
public void setGroupIdIncrement(Integer groupIdIncrement){
this.groupIdIncrement = groupIdIncrement;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
public List<Integer> getGroupIdList(){
return this.groupIdList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
public void setGroupIdList(List<Integer> groupIdList){
this.groupIdList = groupIdList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathNotList
* 获取 分组名称
* @return groupNameList
*/
public List<String> getButtonImgPathNotList(){
return this.buttonImgPathNotList;
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathNotList
* 设置 分组名称
* @param groupNameList
*/
public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.buttonImgPathNotList = buttonImgPathNotList;
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathNotList
* @return imgCommPathList
*/
public List<String> getImgCommPathNotList(){
return this.imgCommPathNotList;
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathNotList
* @param imgCommPathList
*/
public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathNotList = imgCommPathNotList;
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 开始 是否常用菜单 (0.非常用，1.常用)
* 获取 开始 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuStart
*/
public Integer getCommMenuStart(){
......@@ -733,7 +657,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 开始 是否常用菜单 (0.非常用，1.常用)
* 设置 开始 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
......@@ -741,15 +665,15 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 结束 是否常用菜单 (0.非常用，1.常用)
* @return $commMenuEnd
* 获取 结束 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单 (0.非常用，1.常用)
* 设置 结束 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
......@@ -757,7 +681,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 增加 是否常用菜单 (0.非常用，1.常用)
* 获取 增加 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
......@@ -765,7 +689,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 增加 是否常用菜单 (0.非常用，1.常用)
* 设置 增加 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
......@@ -773,7 +697,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 是否常用菜单 (0.非常用，1.常用)
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
......@@ -781,7 +705,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 是否常用菜单 (0.非常用，1.常用)
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
......@@ -789,56 +713,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 是否常用菜单 (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.按钮)
* 获取 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
......@@ -846,7 +721,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 开始 菜单类型 (0.目录，1.菜单，2.按钮)
* 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
......@@ -854,15 +729,15 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* @return $menuTypeEnd
* 获取 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型 (0.目录，1.菜单，2.按钮)
* 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
......@@ -870,7 +745,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
......@@ -878,7 +753,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 增加 菜单类型 (0.目录，1.菜单，2.按钮)
* 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
......@@ -886,7 +761,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 菜单类型 (0.目录，1.菜单，2.按钮)
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
......@@ -894,7 +769,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 菜单类型 (0.目录，1.菜单，2.按钮)
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
......@@ -902,24 +777,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 菜单类型 (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.需要角色权限查看)
* 获取 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
......@@ -927,7 +785,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 开始 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
......@@ -935,15 +793,15 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return $authTypeEnd
* 获取 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
......@@ -951,7 +809,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 获取 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
......@@ -959,7 +817,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 增加 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
......@@ -967,7 +825,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
......@@ -975,7 +833,7 @@ public class MenuQuery extends MenuEntity {
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
......@@ -983,1826 +841,116 @@ public class MenuQuery extends MenuEntity {
}
/**
* 获取 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @return authTypeNotList
*/
public List<Integer> getAuthTypeNotList(){
return this.authTypeNotList;
}
/**
* 设置 权限类型 (0.无限制，1.无需登录查看，2.需要登录查看，3.需要角色权限查看)
* @param authTypeNotList
*/
public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
}
/**
* 获取 开始 菜单显示状态 (0.显示，1.隐藏)
* @return visibleStart
*/
public Integer getVisibleStart(){
return this.visibleStart;
}
/**
* 设置 开始 菜单显示状态 (0.显示，1.隐藏)
* @param visibleStart
*/
public void setVisibleStart(Integer visibleStart){
this.visibleStart = visibleStart;
}
/**
* 获取 结束 菜单显示状态 (0.显示，1.隐藏)
* @return $visibleEnd
*/
public Integer getVisibleEnd(){
return this.visibleEnd;
}
/**
* 设置 结束 菜单显示状态 (0.显示，1.隐藏)
* @param visibleEnd
*/
public void setVisibleEnd(Integer visibleEnd){
this.visibleEnd = visibleEnd;
}
/**
* 获取 增加 菜单显示状态 (0.显示，1.隐藏)
* @return visibleIncrement
*/
public Integer getVisibleIncrement(){
return this.visibleIncrement;
}
/**
* 设置 增加 菜单显示状态 (0.显示，1.隐藏)
* @param visibleIncrement
*/
public void setVisibleIncrement(Integer visibleIncrement){
this.visibleIncrement = visibleIncrement;
}
/**
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleList
*/
public List<Integer> getVisibleList(){
return this.visibleList;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleList
*/
public void setVisibleList(List<Integer> visibleList){
this.visibleList = visibleList;
}
/**
* 获取 菜单显示状态 (0.显示，1.隐藏)
* @return visibleNotList
*/
public List<Integer> getVisibleNotList(){
return this.visibleNotList;
}
/**
* 设置 菜单显示状态 (0.显示，1.隐藏)
* @param visibleNotList
*/
public void setVisibleNotList(List<Integer> visibleNotList){
this.visibleNotList = visibleNotList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsList
*/
public List<String> getPermsList(){
return this.permsList;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsList
*/
public void setPermsList(List<String> permsList){
this.permsList = permsList;
}
/**
* 获取 权限标识，多个逗号分割
* @return permsNotList
*/
public List<String> getPermsNotList(){
return this.permsNotList;
}
/**
* 设置 权限标识，多个逗号分割
* @param permsNotList
*/
public void setPermsNotList(List<String> permsNotList){
this.permsNotList = permsNotList;
}
/**
* 获取 备注信息
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注信息
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 备注信息
* @return remarkNotList
*/
public List<String> getRemarkNotList(){
return this.remarkNotList;
}
/**
* 设置 备注信息
* @param remarkNotList
*/
public void setRemarkNotList(List<String> remarkNotList){
this.remarkNotList = remarkNotList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
* 获取 开始 创建时间
* @return createTimeStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 排序编号
* @return $orderIdEnd
* 获取 结束 创建时间
* @return createTimeEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 排序编号
* @return orderIdList
* 获取 结束 创建用户
* @return createUserIdEnd
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 排序编号
* @param orderIdList
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 排序编号
* @return orderIdNotList
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public List<Integer> getOrderIdNotList(){
return this.orderIdNotList;
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 排序编号
* @param orderIdNotList
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setOrderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 开始 菜单状态 (0.停用，1.启用)
* @return statusStart
* 获取 创建用户
* @return createUserIdList
*/
public Integer getStatusStart(){
return this.statusStart;
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 开始 菜单状态 (0.停用，1.启用)
* @param statusStart
* 设置 创建用户
* @param createUserIdList
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 结束 菜单状态 (0.停用，1.启用)
* @return $statusEnd
* 获取 创建用户名称
* @return createUserNameList
*/
public Integer getStatusEnd(){
return this.statusEnd;
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 结束 菜单状态 (0.停用，1.启用)
* @param statusEnd
* 设置 创建用户名称
* @param createUserNameList
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 增加 菜单状态 (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/user/service/impl/UserServiceImpl.java
View file @ ff768e7f
......@@ -243,7 +243,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
}
MenuEntity sysModuleParent = menuMap.get(sysModule.getParentId());
if (sysModuleParent != null) {
sysModuleParent.getChildren().add(sysModule);
sysModuleParent.getChildList().add(sysModule);
}
}
return outlookBar;
......@@ -378,6 +378,7 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
return Rest.ok();
}
@Override
public UserDao getUserDao() {
return getDao();
......@@ -391,8 +392,4 @@ public class UserServiceImpl extends AbstractCRUDCacheServiceImpl<UserDao, UserE
Long[] userIds = roleUserService.find(roleUserQuery).stream().map(RoleUserEntity::getId).toArray(Long[]::new);
roleUserService.remove(userIds, context);
}
public static void main(String[] args) throws Exception {
System.out.println(SecurityUtil.md5DoubleEncoding("wangdongmei@123"));
}
}
\ No newline at end of file
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