Qt 全流程实战企业级项目 - 云对象存储浏览器(完整24章)

吉太
• 阅读 150

下载地址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 对象


    • 1、更改此账户的 StpLogic 对象


    • 2、put 到全局 StpLogic 集合中


    • 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 INTO tb_user SET username = #{username}, password = #{password}, name = #{name}, sex = #{sex}, tel = #{tel}, email=#{email}, hiredate = #{hiredate}, role = #{role}, root = false, dept_id = #{deptId}, status = #{status}, create_time = NOW() @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 } }, ] }

点赞
收藏
评论区
推荐文章
荀勗 荀勗
6个月前
SpringBoot 3 + Flutter3 实战低代码运营管理-10章
SpringBoot3Flutter3实战低代码运营管理10章地址1:https://pan.baidu.com/s/1Uay0bc6ghAVf401tOdXiQ提取码:sqcs地址2:https://pan.baidu.com/s/1l3kJpBzm9
荀勗 荀勗
5个月前
[24章]Qt 全流程实战企业级项目 - 云对象存储浏览器
下载地址1:https://pan.baidu.com/s/180fnOsA0EwGXcLb3icyw提取码:laa9下载地址2:https://pan.baidu.com/s/1adwzeyb1CKJrGiu2zpolQ提取码:a5p2Qt开发浏览器全流
赵颜 赵颜
5个月前
[16章]SpringBoot2 仿B站高性能前端+后端项目(2023新版)
资料地址1:https://pan.baidu.com/s/1cxQDKIi7iu1mGmjRr9a0Mw提取码:tz5s资料地址2:https://pan.baidu.com/s/1DjmuC6Id4oUCNVbxfgcMg提取码:qtf3今天给大家讲讲
赵颜 赵颜
5个月前
[15章]深入学习小程序框架底层原理,培养双线程思维
学习地址1:https://pan.baidu.com/s/1ridzu0mrj1vrfT07fdReuw提取码:3zd2学习地址2:https://pan.baidu.com/s/1SChnJCGf03sybLfyAnkCA提取码:c862前端高手特训从
赵嬷嬷 赵嬷嬷
4个月前
[16章]慕课甄选-2024年Flutter零基础极速入门到进阶实战
学习地址1:https://pan.baidu.com/s/1iOH2xMvdMyBAJla5PeHuUg提取码:hjhi学习地址2:https://pan.baidu.com/s/1Iwj10AL7jdum19WQz1jdA提取码:0n8xFlutter
鲍二家的 鲍二家的
2个月前
AI Agent智能应用从0到1定制开发(12章)
学习地址1:https://pan.baidu.com/s/1ccnoXsPCUg4eP5rSrD0UA提取码:o0mu学习地址2:https://pan.baidu.com/s/1JYJ6dMkwgx0XWQnCM6Q0A提取码:2m68AIAgent已
双寿 双寿
2个月前
[12章]AI Agent智能应用从0到1定制开发
学习地址1:https://pan.baidu.com/s/15IbktHy54IdZRg3g7PWWKQ提取码:v7lt学习地址2:https://pan.baidu.com/s/1JYJ6dMkwgx0XWQnCM6Q0A提取码:2m68AIAgent
吉太 吉太
2个月前
AI Agent智能应用从0到1定制开发[12章]
下载地址1:https://pan.baidu.com/s/15IbktHy54IdZRg3g7PWWKQ提取码:v7lt下载地址2:https://pan.baidu.com/s/1itYcy6EHYLRZSvj2D5e00A提取码:9jdp一、那为啥最
鲍二家的 鲍二家的
1个月前
[7章]Go从入门到进阶,大厂案例全流程实践
学习地址1:https://pan.baidu.com/s/1kZq7Rc7PHBRYEzWL85FCA提取码:0udi学习地址2:https://pan.baidu.com/s/1Rr5G2U3YSbwhFTLMHH2keA提取码:j0viGo语言高效、
鲍二家的 鲍二家的
1个月前
音视频高手突围课--WebRTC企业级高性能后台服务实战
地址1:https://pan.baidu.com/s/13NbZaZ8ufTXELagi8WQyHQ提取码:2o5i地址2:https://pan.baidu.com/s/1VrKcjKdz0qmVlufrwBtsQ提取码:tylx本文以共享桌面项目为驱