下载地址1：https://pan.baidu.com/s/180fnOsA0EwGXcLb3i_cy-w 提取码：laa9
下载地址2：https://pan.baidu.com/s/1H83NzaPMey81mF1paR6ffA 提取码：ki87
设计说明：
创建一个按钮或菜单项，用于触发查看网页源代码的操作。
在点击按钮或菜单项时，获取当前加载的网页的源代码。
显示源代码的文本内容，可以使用一个文本编辑器或类似的控件来展示源代码。
提供适当的界面布局，以便用户可以方便地查看和浏览源代码。
首先，我们需要在QT Creator中创建一个新的QT Widgets应用程序项目。在项目中，我们需要添加一个QLabel控件和两个QPushButton控件，分别用于打开和保存图像文件。
我们想要让内容区的高度实现适配，CSS这条路是走不通的，只能寻求于TS代码了。
//计算网页可见区域的高度
function resetDocumentClientHeight() {
//获取网页可见区域的高度
siteContent.documentClientHeight = document.documentElement.clientHeight;
}
//计算内容区卡片控件高度
function loadSiteContentViewHeight() {
//卡片控件高度 = 网页可见区域高度 - 导航区高度 - 卡片控件上下外填充 - 上下边框
let height = siteContent.documentClientHeight - 50 - 30 - 2;
if (route.meta.isTab) {
//如果引用的Vue页面需要Tab控件，卡片控件高度还要减去40
height -= 40;
}
//保存卡片控件高度
siteContent.height = height
//声明CSS样式
siteContent.siteContentViewHeight = { minHeight: height + 'px' };
}
//浏览器尺寸发生变化的回调函数
window.onresize = () => {
//更新保存的网页可见区域高度
siteContent.documentClientHeight = document.documentElement.clientHeight;
//重新计算内容区的高度
loadSiteContentViewHeight();
};
在com.example.his.api.config.sa_token包中，创建StpCustomerUtil.java类。这个类的代码，拷贝自SaToken官方文档，我只是换了个类名改了type变量值而已。
package com.example.his.api.config.sa_token;
import java.util.List;
import org.springframework.stereotype.Component;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.fun.SaFunction;
import cn.dev33.satoken.listener.SaTokenEventCenter;
import cn.dev33.satoken.session.SaSession;
import cn.dev33.satoken.stp.SaLoginModel;
import cn.dev33.satoken.stp.SaTokenInfo;
import cn.dev33.satoken.stp.StpLogic;
/**
* Sa-Token 权限认证工具类 （业务端使用）
*/
@Component
public class StpCustomerUtil {
private StpCustomerUtil() {
}
/**
* 账号类型标识
*/
public static final String TYPE = "customer";
/**
* 底层的 StpLogic 对象
*/
public static StpLogic stpLogic = new StpLogic(TYPE);
/**
* 获取当前 StpLogic 的账号类型
*
* @return See Note
*/
public static String getLoginType() {
return stpLogic.getLoginType();
}
/**
* 重置 StpLogic 对象
* <br> 1、更改此账户的 StpLogic 对象
* <br> 2、put 到全局 StpLogic 集合中
* <br> 3、发送日志
*
* @param newStpLogic /
*/
public static void setStpLogic(StpLogic newStpLogic) {
// 重置此账户的 StpLogic 对象
stpLogic = newStpLogic;
// 添加到全局 StpLogic 集合中
// 以便可以通过 SaManager.getStpLogic(type) 的方式来全局获取到这个 StpLogic
SaManager.putStpLogic(newStpLogic);
// $$ 全局事件
SaTokenEventCenter.doSetStpLogic(stpLogic);
}
/**
* 获取 StpLogic 对象
*
* @return /
*/
public static StpLogic getStpLogic() {
return stpLogic;
}
// ------------------- 获取token 相关 -------------------
/**
* 返回token名称
*
* @return 此StpLogic的token名称
*/
public static String getTokenName() {
return stpLogic.getTokenName();
}
/**
* 在当前会话写入当前TokenValue
*
* @param tokenValue token值
*/
public static void setTokenValue(String tokenValue) {
stpLogic.setTokenValue(tokenValue);
}
/**
* 在当前会话写入当前TokenValue
*
* @param tokenValue token值
* @param cookieTimeout Cookie存活时间(秒)
*/
public static void setTokenValue(String tokenValue, int cookieTimeout) {
stpLogic.setTokenValue(tokenValue, cookieTimeout);
}
/**
* 获取当前TokenValue
*
* @return 当前tokenValue
*/
public static String getTokenValue() {
return stpLogic.getTokenValue();
}
/**
* 获取当前TokenValue (不裁剪前缀)
*
* @return /
*/
public static String getTokenValueNotCut() {
return stpLogic.getTokenValueNotCut();
}
/**
* 获取当前会话的Token信息
*
* @return token信息
*/
public static SaTokenInfo getTokenInfo() {
return stpLogic.getTokenInfo();
}
// ------------------- 登录相关操作 -------------------
// --- 登录
/**
* 会话登录
*
* @param id 账号id，建议的类型：（long | int | String）
*/
public static void login(Object id) {
stpLogic.login(id);
}
/**
* 会话登录，并指定登录设备类型
*
* @param id 账号id，建议的类型：（long | int | String）
* @param device 设备类型
*/
public static void login(Object id, String device) {
stpLogic.login(id, device);
}
/**
* 会话登录，并指定是否 [记住我]
*
* @param id 账号id，建议的类型：（long | int | String）
* @param isLastingCookie 是否为持久Cookie
*/
public static void login(Object id, boolean isLastingCookie) {
stpLogic.login(id, isLastingCookie);
}
/**
* 会话登录，并指定此次登录token的有效期, 单位:秒
*
* @param id 账号id，建议的类型：（long | int | String）
* @param timeout 此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
*/
public static void login(Object id, long timeout) {
stpLogic.login(id, timeout);
}
/**
* 会话登录，并指定所有登录参数Model
*
* @param id 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
*/
public static void login(Object id, SaLoginModel loginModel) {
stpLogic.login(id, loginModel);
}
/**
* 创建指定账号id的登录会话
*
* @param id 登录id，建议的类型：（long | int | String）
* @return 返回会话令牌
*/
public static String createLoginSession(Object id) {
return stpLogic.createLoginSession(id);
}
/**
* 创建指定账号id的登录会话
*
* @param id 登录id，建议的类型：（long | int | String）
* @param loginModel 此次登录的参数Model
* @return 返回会话令牌
*/
public static String createLoginSession(Object id, SaLoginModel loginModel) {
return stpLogic.createLoginSession(id, loginModel);
}
// --- 注销
/**
* 会话注销
*/
public static void logout() {
stpLogic.logout();
}
/**
* 会话注销，根据账号id
*
* @param loginId 账号id
*/
public static void logout(Object loginId) {
stpLogic.logout(loginId);
}
/**
* 会话注销，根据账号id 和 设备类型
*
* @param loginId 账号id
* @param device 设备类型 (填null代表注销所有设备类型)
*/
public static void logout(Object loginId, String device) {
stpLogic.logout(loginId, device);
}
/**
* 会话注销，根据指定 Token
*
* @param tokenValue 指定token
*/
public static void logoutByTokenValue(String tokenValue) {
stpLogic.logoutByTokenValue(tokenValue);
}
/**
* 踢人下线，根据账号id
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
*/
public static void kickout(Object loginId) {
stpLogic.kickout(loginId);
}
/**
* 踢人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param loginId 账号id
* @param device 设备类型 (填null代表踢出所有设备类型)
*/
public static void kickout(Object loginId, String device) {
stpLogic.kickout(loginId, device);
}
/**
* 踢人下线，根据指定 Token
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-5 </p>
*
* @param tokenValue 指定token
*/
public static void kickoutByTokenValue(String tokenValue) {
stpLogic.kickoutByTokenValue(tokenValue);
}
/**
* 顶人下线，根据账号id 和 设备类型
* <p> 当对方再次访问系统时，会抛出NotLoginException异常，场景值=-4 </p>
*
* @param loginId 账号id
* @param device 设备类型 (填null代表顶替所有设备类型)
*/
public static void replaced(Object loginId, String device) {
stpLogic.replaced(loginId, device);
}
// 查询相关
/**
* 当前会话是否已经登录
*
* @return 是否已登录
*/
public static boolean isLogin() {
return stpLogic.isLogin();
}
/**
* 检验当前会话是否已经登录，如未登录，则抛出异常
*/
public static void checkLogin() {
stpLogic.checkLogin();
}
/**
* 获取当前会话账号id, 如果未登录，则抛出异常
*
* @return 账号id
*/
public static Object getLoginId() {
return stpLogic.getLoginId();
}
/**
* 获取当前会话账号id, 如果未登录，则返回默认值
*
* @param <T> 返回类型
* @param defaultValue 默认值
* @return 登录id
*/
public static <T> T getLoginId(T defaultValue) {
return stpLogic.getLoginId(defaultValue);
}
/**
* 获取当前会话账号id, 如果未登录，则返回null
*
* @return 账号id
*/
public static Object getLoginIdDefaultNull() {
return stpLogic.getLoginIdDefaultNull();
}
/**
* 获取当前会话账号id, 并转换为String类型
*
* @return 账号id
*/
public static String getLoginIdAsString() {
return stpLogic.getLoginIdAsString();
}
/**
* 获取当前会话账号id, 并转换为int类型
*
* @return 账号id
*/
public static int getLoginIdAsInt() {
return stpLogic.getLoginIdAsInt();
}
/**
* 获取当前会话账号id, 并转换为long类型
*
* @return 账号id
*/
public static long getLoginIdAsLong() {
return stpLogic.getLoginIdAsLong();
}
/**
* 获取指定Token对应的账号id，如果未登录，则返回 null
*
* @param tokenValue token
* @return 账号id
*/
public static Object getLoginIdByToken(String tokenValue) {
return stpLogic.getLoginIdByToken(tokenValue);
}
/**
* 获取当前 Token 的扩展信息（此函数只在jwt模式下生效）
*
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String key) {
return stpLogic.getExtra(key);
}
/**
* 获取指定 Token 的扩展信息（此函数只在jwt模式下生效）
*
* @param tokenValue 指定的 Token 值
* @param key 键值
* @return 对应的扩展数据
*/
public static Object getExtra(String tokenValue, String key) {
return stpLogic.getExtra(tokenValue, key);
}
// ------------------- User-Session 相关 -------------------
/**
* 获取指定账号id的Session, 如果Session尚未创建，isCreate=是否新建并返回
*
* @param loginId 账号id
* @param isCreate 是否新建
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId, boolean isCreate) {
return stpLogic.getSessionByLoginId(loginId, isCreate);
}
/**
* 获取指定key的Session, 如果Session尚未创建，则返回null
*
* @param sessionId SessionId
* @return Session对象
*/
public static SaSession getSessionBySessionId(String sessionId) {
return stpLogic.getSessionBySessionId(sessionId);
}
/**
* 获取指定账号id的Session，如果Session尚未创建，则新建并返回
*
* @param loginId 账号id
* @return Session对象
*/
public static SaSession getSessionByLoginId(Object loginId) {
return stpLogic.getSessionByLoginId(loginId);
}
/**
* 获取当前会话的Session, 如果Session尚未创建，isCreate=是否新建并返回
*
* @param isCreate 是否新建
* @return Session对象
*/
public static SaSession getSession(boolean isCreate) {
return stpLogic.getSession(isCreate);
}
/**
* 获取当前会话的Session，如果Session尚未创建，则新建并返回
*
* @return Session对象
*/
public static SaSession getSession() {
return stpLogic.getSession();
}
// ------------------- Token-Session 相关 -------------------
/**
* 获取指定Token-Session，如果Session尚未创建，则新建并返回
*
* @param tokenValue Token值
* @return Session对象
*/
public static SaSession getTokenSessionByToken(String tokenValue) {
return stpLogic.getTokenSessionByToken(tokenValue);
}
/**
* 获取当前Token-Session，如果Session尚未创建，则新建并返回
*
* @return Session对象
*/
public static SaSession getTokenSession() {
return stpLogic.getTokenSession();
}
/**
* 获取当前匿名 Token-Session （可在未登录情况下使用的Token-Session）
*
* @return Token-Session 对象
*/
public static SaSession getAnonTokenSession() {
return stpLogic.getAnonTokenSession();
}
// ------------------- [临时有效期] 验证相关 -------------------
/**
* 检查当前token 是否已经[临时过期]，如果已经过期则抛出异常
*/
public static void checkActivityTimeout() {
stpLogic.checkActivityTimeout();
}
/**
* 续签当前token：(将 [最后操作时间] 更新为当前时间戳)
* <h1>请注意: 即使token已经 [临时过期] 也可续签成功，
* 如果此场景下需要提示续签失败，可在此之前调用 checkActivityTimeout() 强制检查是否过期即可 </h1>
*/
public static void updateLastActivityToNow() {
stpLogic.updateLastActivityToNow();
}
// ------------------- 过期时间相关 -------------------
/**
* 获取当前登录者的 token 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getTokenTimeout() {
return stpLogic.getTokenTimeout();
}
/**
* 获取当前登录者的 User-Session 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getSessionTimeout() {
return stpLogic.getSessionTimeout();
}
/**
* 获取当前 Token-Session 剩余有效时间 (单位: 秒)
*
* @return token剩余有效时间
*/
public static long getTokenSessionTimeout() {
return stpLogic.getTokenSessionTimeout();
}
/**
* 获取当前 token [临时过期] 剩余有效时间 (单位: 秒)
*
* @return token [临时过期] 剩余有效时间
*/
public static long getTokenActivityTimeout() {
return stpLogic.getTokenActivityTimeout();
}
/**
* 对当前 Token 的 timeout 值进行续期
*
* @param timeout 要修改成为的有效时间 (单位: 秒)
*/
public static void renewTimeout(long timeout) {
stpLogic.renewTimeout(timeout);
}
/**
* 对指定 Token 的 timeout 值进行续期
*
* @param tokenValue 指定token
* @param timeout 要修改成为的有效时间 (单位: 秒)
*/
public static void renewTimeout(String tokenValue, long timeout) {
stpLogic.renewTimeout(tokenValue, timeout);
}
// ------------------- 角色验证操作 -------------------
/**
* 获取：当前账号的角色集合
*
* @return /
*/
public static List<String> getRoleList() {
return stpLogic.getRoleList();
}
/**
* 获取：指定账号的角色集合
*
* @param loginId 指定账号id
* @return /
*/
public static List<String> getRoleList(Object loginId) {
return stpLogic.getRoleList(loginId);
}
/**
* 判断：当前账号是否拥有指定角色, 返回true或false
*
* @param role 角色标识
* @return 是否含有指定角色标识
*/
public static boolean hasRole(String role) {
return stpLogic.hasRole(role);
}
/**
* 判断：指定账号是否含有指定角色标识, 返回true或false
*
* @param loginId 账号id
* @param role 角色标识
* @return 是否含有指定角色标识
*/
public static boolean hasRole(Object loginId, String role) {
return stpLogic.hasRole(loginId, role);
}
/**
* 判断：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
*
* @param roleArray 角色标识数组
* @return true或false
*/
public static boolean hasRoleAnd(String... roleArray) {
return stpLogic.hasRoleAnd(roleArray);
}
/**
* 判断：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
*
* @param roleArray 角色标识数组
* @return true或false
*/
public static boolean hasRoleOr(String... roleArray) {
return stpLogic.hasRoleOr(roleArray);
}
/**
* 校验：当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
*
* @param role 角色标识
*/
public static void checkRole(String role) {
stpLogic.checkRole(role);
}
/**
* 校验：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
*
* @param roleArray 角色标识数组
*/
public static void checkRoleAnd(String... roleArray) {
stpLogic.checkRoleAnd(roleArray);
}
/**
* 校验：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可]
*
* @param roleArray 角色标识数组
*/
public static void checkRoleOr(String... roleArray) {
stpLogic.checkRoleOr(roleArray);
}
// ------------------- 权限验证操作 -------------------
/**
* 获取：当前账号的权限码集合
*
* @return /
*/
public static List<String> getPermissionList() {
return stpLogic.getPermissionList();
}
/**
* 获取：指定账号的权限码集合
*
* @param loginId 指定账号id
* @return /
*/
public static List<String> getPermissionList(Object loginId) {
return stpLogic.getPermissionList(loginId);
}
/**
* 判断：当前账号是否含有指定权限, 返回true或false
*
* @param permission 权限码
* @return 是否含有指定权限
*/
public static boolean hasPermission(String permission) {
return stpLogic.hasPermission(permission);
}
/**
* 判断：指定账号id是否含有指定权限, 返回true或false
*
* @param loginId 账号id
* @param permission 权限码
* @return 是否含有指定权限
*/
public static boolean hasPermission(Object loginId, String permission) {
return stpLogic.hasPermission(loginId, permission);
}
/**
* 判断：当前账号是否含有指定权限, [指定多个，必须全部具有]
*
* @param permissionArray 权限码数组
* @return true 或 false
*/
public static boolean hasPermissionAnd(String... permissionArray) {
return stpLogic.hasPermissionAnd(permissionArray);
}
/**
* 判断：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
*
* @param permissionArray 权限码数组
* @return true 或 false
*/
public static boolean hasPermissionOr(String... permissionArray) {
return stpLogic.hasPermissionOr(permissionArray);
}
/**
* 校验：当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException
*
* @param permission 权限码
*/
public static void checkPermission(String permission) {
stpLogic.checkPermission(permission);
}
/**
* 校验：当前账号是否含有指定权限 [指定多个，必须全部验证通过]
*
* @param permissionArray 权限码数组
*/
public static void checkPermissionAnd(String... permissionArray) {
stpLogic.checkPermissionAnd(permissionArray);
}
/**
* 校验：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
*
* @param permissionArray 权限码数组
*/
public static void checkPermissionOr(String... permissionArray) {
stpLogic.checkPermissionOr(permissionArray);
}
// ------------------- id 反查token 相关操作 -------------------
/**
* 获取指定账号id的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
*
* @param loginId 账号id
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId) {
return stpLogic.getTokenValueByLoginId(loginId);
}
/**
* 获取指定账号id指定设备类型端的tokenValue
* <p> 在配置为允许并发登录时，此方法只会返回队列的最后一个token，
* 如果你需要返回此账号id的所有token，请调用 getTokenValueListByLoginId
*
* @param loginId 账号id
* @param device 设备类型
* @return token值
*/
public static String getTokenValueByLoginId(Object loginId, String device) {
return stpLogic.getTokenValueByLoginId(loginId, device);
}
/**
* 获取指定账号id的tokenValue集合
*
* @param loginId 账号id
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId) {
return stpLogic.getTokenValueListByLoginId(loginId);
}
/**
* 获取指定账号id指定设备类型端的tokenValue 集合
*
* @param loginId 账号id
* @param device 设备类型
* @return 此loginId的所有相关token
*/
public static List<String> getTokenValueListByLoginId(Object loginId, String device) {
return stpLogic.getTokenValueListByLoginId(loginId, device);
}
/**
* 返回当前会话的登录设备类型
*
* @return 当前令牌的登录设备类型
*/
public static String getLoginDevice() {
return stpLogic.getLoginDevice();
}
// ------------------- 会话管理 -------------------
/**
* 根据条件查询Token
*
* @param keyword 关键字
* @param start 开始处索引
* @param size 获取数量 (-1代表一直获取到末尾)
* @param sortType 排序类型（true=正序，false=反序）
* @return token集合
*/
public static List<String> searchTokenValue(String keyword, int start, int size, boolean sortType) {
return stpLogic.searchTokenValue(keyword, start, size, sortType);
}
/**
* 根据条件查询SessionId
*
* @param keyword 关键字
* @param start 开始处索引
* @param size 获取数量 (-1代表一直获取到末尾)
* @param sortType 排序类型（true=正序，false=反序）
* @return sessionId集合
*/
public static List<String> searchSessionId(String keyword, int start, int size, boolean sortType) {
return stpLogic.searchSessionId(keyword, start, size, sortType);
}
/**
* 根据条件查询Token专属Session的Id
*
* @param keyword 关键字
* @param start 开始处索引
* @param size 获取数量 (-1代表一直获取到末尾)
* @param sortType 排序类型（true=正序，false=反序）
* @return sessionId集合
*/
public static List<String> searchTokenSessionId(String keyword, int start, int size, boolean sortType) {
return stpLogic.searchTokenSessionId(keyword, start, size, sortType);
}
// ------------------- 账号封禁 -------------------
/**
* 封禁：指定账号
* <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
*
* @param loginId 指定账号id
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, long time) {
stpLogic.disable(loginId, time);
}
/**
* 判断：指定账号是否已被封禁 (true=已被封禁, false=未被封禁)
*
* @param loginId 账号id
* @return /
*/
public static boolean isDisable(Object loginId) {
return stpLogic.isDisable(loginId);
}
/**
* 校验：指定账号是否已被封禁，如果被封禁则抛出异常
*
* @param loginId 账号id
*/
public static void checkDisable(Object loginId) {
stpLogic.checkDisable(loginId);
}
/**
* 获取：指定账号剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
*
* @param loginId 账号id
* @return /
*/
public static long getDisableTime(Object loginId) {
return stpLogic.getDisableTime(loginId);
}
/**
* 解封：指定账号
*
* @param loginId 账号id
*/
public static void untieDisable(Object loginId) {
stpLogic.untieDisable(loginId);
}
// ------------------- 分类封禁 -------------------
/**
* 封禁：指定账号的指定服务
* <p> 此方法不会直接将此账号id踢下线，如需封禁后立即掉线，请追加调用 StpUtil.logout(id)
*
* @param loginId 指定账号id
* @param service 指定服务
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disable(Object loginId, String service, long time) {
stpLogic.disable(loginId, service, time);
}
/**
* 判断：指定账号的指定服务 是否已被封禁 (true=已被封禁, false=未被封禁)
*
* @param loginId 账号id
* @param service 指定服务
* @return /
*/
public static boolean isDisable(Object loginId, String service) {
return stpLogic.isDisable(loginId, service);
}
/**
* 校验：指定账号 指定服务 是否已被封禁，如果被封禁则抛出异常
*
* @param loginId 账号id
* @param services 指定服务，可以指定多个
*/
public static void checkDisable(Object loginId, String... services) {
stpLogic.checkDisable(loginId, services);
}
/**
* 获取：指定账号 指定服务 剩余封禁时间，单位：秒（-1=永久封禁，-2=未被封禁）
*
* @param loginId 账号id
* @param service 指定服务
* @return see note
*/
public static long getDisableTime(Object loginId, String service) {
return stpLogic.getDisableTime(loginId, service);
}
/**
* 解封：指定账号、指定服务
*
* @param loginId 账号id
* @param services 指定服务，可以指定多个
*/
public static void untieDisable(Object loginId, String... services) {
stpLogic.untieDisable(loginId, services);
}
// ------------------- 阶梯封禁 -------------------
/**
* 封禁：指定账号，并指定封禁等级
*
* @param loginId 指定账号id
* @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, int level, long time) {
stpLogic.disableLevel(loginId, level, time);
}
/**
* 封禁：指定账号的指定服务，并指定封禁等级
*
* @param loginId 指定账号id
* @param service 指定封禁服务
* @param level 指定封禁等级
* @param time 封禁时间, 单位: 秒 （-1=永久封禁）
*/
public static void disableLevel(Object loginId, String service, int level, long time) {
stpLogic.disableLevel(loginId, service, level, time);
}
/**
* 判断：指定账号是否已被封禁到指定等级
*
* @param loginId 指定账号id
* @param level 指定封禁等级
* @return /
*/
public static boolean isDisableLevel(Object loginId, int level) {
return stpLogic.isDisableLevel(loginId, level);
}
/**
* 判断：指定账号的指定服务，是否已被封禁到指定等级
*
* @param loginId 指定账号id
* @param service 指定封禁服务
* @param level 指定封禁等级
* @return /
*/
public static boolean isDisableLevel(Object loginId, String service, int level) {
return stpLogic.isDisableLevel(loginId, service, level);
}
/**
* 校验：指定账号是否已被封禁到指定等级（如果已经达到，则抛出异常）
*
* @param loginId 指定账号id
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, int level) {
stpLogic.checkDisableLevel(loginId, level);
}
/**
* 校验：指定账号的指定服务，是否已被封禁到指定等级（如果已经达到，则抛出异常）
*
* @param loginId 指定账号id
* @param service 指定封禁服务
* @param level 封禁等级 （只有 封禁等级 ≥ 此值 才会抛出异常）
*/
public static void checkDisableLevel(Object loginId, String service, int level) {
stpLogic.checkDisableLevel(loginId, service, level);
}
/**
* 获取：指定账号被封禁的等级，如果未被封禁则返回-2
*
* @param loginId 指定账号id
* @return /
*/
public static int getDisableLevel(Object loginId) {
return stpLogic.getDisableLevel(loginId);
}
/**
* 获取：指定账号的 指定服务 被封禁的等级，如果未被封禁则返回-2
*
* @param loginId 指定账号id
* @param service 指定封禁服务
* @return /
*/
public static int getDisableLevel(Object loginId, String service) {
return stpLogic.getDisableLevel(loginId, service);
}
// ------------------- 身份切换 -------------------
/**
* 临时切换身份为指定账号id
*
* @param loginId 指定loginId
*/
public static void switchTo(Object loginId) {
stpLogic.switchTo(loginId);
}
/**
* 结束临时切换身份
*/
public static void endSwitch() {
stpLogic.endSwitch();
}
/**
* 当前是否正处于[身份临时切换]中
*
* @return 是否正处于[身份临时切换]中
*/
public static boolean isSwitch() {
return stpLogic.isSwitch();
}
/**
* 在一个代码段里方法内，临时切换身份为指定账号id
*
* @param loginId 指定账号id
* @param function 要执行的方法
*/
public static void switchTo(Object loginId, SaFunction function) {
stpLogic.switchTo(loginId, function);
}
// ------------------- 二级认证 -------------------
/**
* 在当前会话 开启二级认证
*
* @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(long safeTime) {
stpLogic.openSafe(safeTime);
}
/**
* 在当前会话 开启二级认证
*
* @param service 业务标识
* @param safeTime 维持时间 (单位: 秒)
*/
public static void openSafe(String service, long safeTime) {
stpLogic.openSafe(service, safeTime);
}
/**
* 当前会话 是否处于二级认证时间内
*
* @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe() {
return stpLogic.isSafe();
}
/**
* 当前会话 是否处于二级认证时间内
*
* @param service 业务标识
* @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String service) {
return stpLogic.isSafe(service);
}
/**
* 指定 Token 是否处于二级认证时间内
*
* @param tokenValue Token 值
* @param service 业务标识
* @return true=二级认证已通过, false=尚未进行二级认证或认证已超时
*/
public static boolean isSafe(String tokenValue, String service) {
return stpLogic.isSafe(tokenValue, service);
}
/**
* 检查当前会话是否已通过二级认证，如未通过则抛出异常
*/
public static void checkSafe() {
stpLogic.checkSafe();
}
/**
* 检查当前会话是否已通过二级认证，如未通过则抛出异常
*
* @param service 业务标识
*/
public static void checkSafe(String service) {
stpLogic.checkSafe(service);
}
/**
* 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
*
* @return 剩余有效时间
*/
public static long getSafeTime() {
return stpLogic.getSafeTime();
}
/**
* 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
*
* @param service 业务标识
* @return 剩余有效时间
*/
public static long getSafeTime(String service) {
return stpLogic.getSafeTime(service);
}
/**
* 在当前会话 结束二级认证
*/
public static void closeSafe() {
stpLogic.closeSafe();
}
/**
* 在当前会话 结束二级认证
*
* @param service 业务标识
*/
public static void closeSafe(String service) {
stpLogic.closeSafe(service);
}
}
为了接收前端Ajax提交的数据，我们需要创建封装类，也便于做后端验证。在com.example.his.api.mis.controller.form包中，创建LoginForm.java类。
package com.example.his.api.mis.controller.form;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
@Data
public class LoginForm {
@NotBlank(message = "username不能为空")
@Pattern(regexp = "^[a-zA-Z0-9]{5,50}$", message = "username内容不正确")
private String username;
@NotBlank(message = "password不能为空")
@Pattern(regexp = "^[a-zA-Z0-9]{6,20}$", message = "password内容不正确")
private String password;
}
在这个示例中，我们使用了QFileDialog控件来打开和保存图像文件。在打开图像文件时，我们使用QImage类来加载图像文件，并将其设置为QLabel控件的Pixmap。在保存图像文件时，我们使用QPixmap类来获取QLabel控件的Pixmap，并将其保存为文件。
最后，我们需要在MainWindow类的构造函数中设置QLabel控件的大小策略和缩放模式，以确保图像可以正确地显示。下面是一个示例：
<insert id="insert" parameterType="com.example.his.api.db.dao.UserDao">
INSERT INTO tb_user
SET username = #{username},
password = #{password},
name = #{name},
sex = #{sex},
tel = #{tel},
email=#{email},
hiredate = #{hiredate},
role = #{role},
root = false,
<if test="deptId!=null">
dept_id = #{deptId},
</if>
status = #{status},
create_time = NOW()
</insert>
@Service
public class UserServiceImpl implements UserService {
……
@Override
@Transactional
public int insert(UserEntity user) {
MD5 md5 = MD5.create();
String temp = md5.digestHex(user.getUsername());
String tempStart = StrUtil.subWithLength(temp, 0, 6);
String tempEnd = StrUtil.subSuf(temp, temp.length() - 3);
String password = md5.digestHex(tempStart + user.getPassword() + tempEnd).toUpperCase();
user.setPassword(password);
int rows = userDao.insert(user);
return rows;
}
}
在UserDao.xml文件中，定义SQL语句更新用户状态（2状态为离职）。
@Service
public class UserServiceImpl implements UserService {
……
@Override
@Transactional
public int dismiss(int userId) {
int rows = userDao.dismiss(userId);
return rows;
}
}
在src/views/mis目录中找到我们之前创建的dept.vue页面，该页面的路由已经配置了，我们回顾一下。
{
path: '/mis',
name: 'Main',
component: () => import('../views/mis/main.vue'),
children: [
……,
{
path: 'dept',
name: 'MisDept',
component: () => import('../views/mis/dept.vue'),
meta: {
title: '部门管理',
isTab: true
}
},
]
}
这是一个创建于 的文章，其中的信息可能已经有所发展或是发生改变。
- 请尽量让自己的回复能够对别人有帮助
- 支持 Markdown 格式, **粗体**、~~删除线~~、
`单行代码` - 支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
- 图片支持拖拽、截图粘贴等方式上传
今日阅读排行
一周阅读排行