C++ 实现用户管理模块

最新推荐文章于 2025-02-24 12:33:24 发布
最新推荐文章于 2025-02-24 12:33:24 发布
阅读量730 收藏 11
点赞数 14
分类专栏： 个人经验 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58648890/article/details/143633336
版权

1. 项目需求与架构

在现代软件中，安全性和用户体验至关重要。为了满足这些需求，本项目设计了以下核心功能：

  • 用户角色管理：用户被分为超级管理员、工程师和操作员，不同角色有不同权限。
  • 登录、登出功能：支持记住密码、自动登录。
  • 自动登出检测：如果用户在一段时间内没有操作，系统将自动登出用户。
  • 数据安全：用户的会话文件加密存储，防止数据泄露。

2. 数据库设计

本系统采用SQLite作为数据存储，用户数据表设计如下：

CREATE TABLE IF NOT EXISTS users (
    username VARCHAR(50) PRIMARY KEY,
    password_hash VARCHAR(255) NOT NULL,
    role INT NOT NULL,
    session_timeout INT DEFAULT 30,
    session_expiration INT DEFAULT 72,
    last_login TIMESTAMP
);
  • username：用户的唯一标识。
  • password_hash：加密后的用户密码。
  • role：用户角色（0：超级管理员，1：工程师，2：操作员）。
  • session_timeout：无操作超时时间（分钟）。
  • session_expiration：会话过期时间（小时）。
  • last_login：上次登录时间，用于会话文件验证。

3. 功能实现

3.1. UserManager 类结构与主要功能

UserManager类是本项目的核心类，采用单例模式实现，确保系统中只有一个实例。主要功能包括用户登录、登出、自动检测无操作等。

class UserManager {
public:
    static UserManager& getInstance();  // 获取单例实例
    bool login(const std::string& username, const std::string& password, bool rememberMe = false);  // 用户登录
    void logout();  // 用户登出
    bool isLoggedIn() const;  // 获取用户登录状态
    bool createUser(const std::string& username, const std::string& password, UserRole role,
        int timeoutMinutes = 30, int expirationHours = 72);  // 创建新用户

    // 自动登出检测
    void initializeIdleDetection(HWND hwnd);
    void terminateIdleDetection();
    bool isInactiveTimeout() const;  // 检测是否超时
    void updateActivityTime();  // 更新活动时间
};

3.2. 登录与会话管理

用户登录

在登录时，UserManager会验证用户的凭证，并记录登录时间以供自动检测无操作超时。同时，如果用户选择了“记住密码”，则将用户信息保存到session.dat文件中。

bool UserManager::login(const std::string& username, const std::string& password, bool rememberMe) {
    // 查询用户信息
    std::string query = "SELECT username, password_hash, role, session_timeout, session_expiration FROM users WHERE username = '" + username + "'";
    auto result = m_pDB->fetchResults(query);

    if (result.empty() || result[0][1] != hashPassword(password)) {
        std::cerr << "Login failed: Invalid username or password." << std::endl;
        return false;
    }

    // 设置当前用户和会话信息
    m_strCurrentUser = username;
    m_enCurrentUserRole = static_cast<UserRole>(std::stoi(result[0][2]));
    m_tmSessionTimeout = std::chrono::minutes(std::stoi(result[0][3]));
    m_tmSessionExpiration = std::chrono::hours(std::stoi(result[0][4]));
    m_isLoggedIn = true;
    m_isRememberMe = rememberMe;

    updateActivityTime();
    saveSession();  // 保存会话
    return true;
}
加密与解密

会话文件内容加密，保护用户信息。使用一个简单的异或加密函数：

std::string UserManager::simpleEncryptDecrypt(const std::string& data, const std::string& key) {
    std::string result = data;
    for (size_t i = 0; i < data.size(); ++i) {
        result[i] ^= key[i % key.size()];  // 简单异或加密
    }
    return result;
}

3.3. 自动登出检测

为了自动检测用户无操作超时，本系统通过全局钩子捕获键盘和鼠标事件。每当检测到用户操作时，系统会更新最后活动时间。定时检查用户无操作时间，超过设定值即登出用户。

  • 钩子回调函数：在鼠标和键盘事件发生时更新活动时间。
LRESULT CALLBACK UserManager::LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        UserManager::getInstance().updateActivityTime();
    }
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

LRESULT CALLBACK UserManager::LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        UserManager::getInstance().updateActivityTime();
    }
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

4. 使用示例

在对话框初始化时启动UserManager的自动检测功能，并尝试从会话文件加载上次会话状态：

BOOL CMyDlg::OnInitDialog() {
    CDialogEx::OnInitDialog();
    UserManager& userManager = UserManager::getInstance();

    userManager.initializeIdleDetection(AfxGetMainWnd()->m_hWnd);
    SetTimer(1, 60000, nullptr);

    if (userManager.loadSession()) {
        CString strText;
        strText.Format(_T("%s logged in..."), userManager.getCurrentUser().c_str());
        AfxMessageBox(strText);
    } else {
        AfxMessageBox(_T("Please log in..."));
    }

    return TRUE;
}

当定时器检测到超时无操作时，将自动登出用户：

void CMyDlg::OnTimer(UINT_PTR nIDEvent) {
    if (nIDEvent == 1) {
        UserManager& userManager = UserManager::getInstance();
        if (userManager.isLoggedIn() && userManager.isInactiveTimeout()) {
            AfxMessageBox(_T("You have been logged out automatically due to inactivity."));
            userManager.logout();
        }
    }
    CDialogEx::OnTimer(nIDEvent);
}

窗口销毁时，终止无操作检测，清除鼠标和键盘钩子：

void CBondServoDlg::OnDestroy()
{
	CDialogEx::OnDestroy();
	
#if !defined(_DEBUG)
	// 清除 UserManager 的无操作检测
	UserManager::getInstance().terminateIdleDetection();
	KillTimer(1);
#endif
}

5. 完整代码

#ifndef USER_MANAGER_H
#define USER_MANAGER_H

#include <string>
#include <memory>
#include <chrono>
#include <windows.h>
#include "Database.h"

// 用户角色定义
enum class UserRole {
    SuperAdmin = 0,     // 超级管理员
    Engineer,           // 工程师
    Operator            // 操作员
};

// 用户管理类，采用单例模式
class UserManager {
public:
    static UserManager& getInstance();

    UserManager(const UserManager&) = delete;
    UserManager& operator=(const UserManager&) = delete;

    // 用户操作
    bool login(const std::string& username, const std::string& password, bool rememberMe = false);
    void logout();
    bool isLoggedIn() const;
    bool createUser(const std::string& username, const std::string& password, UserRole role,
        std::chrono::minutes timeout = std::chrono::minutes(30),
        std::chrono::hours expiration = std::chrono::hours(72));
    bool deleteUser(const std::string& username);
    std::vector<std::vector<std::string>> getUsers();
    bool setUsers(const std::vector<std::vector<std::string>>& usersData);
    bool changeUsername(const std::string& currentUsername, const std::string& newUsername);
    bool changePassword(const std::string& username, const std::string& newPassword);
    bool changeUserRole(const std::string& username, UserRole newRole);
    bool changeUserSessionTimeout(const std::string& username, int newTimeoutMinutes);
    bool changeUserSessionExpiration(const std::string& username, int newExpirationHours);

    // 会话文件操作
    bool loadSession();     // 从会话文件加载会话信息
    void saveSession();     // 保存会话信息到文件
    void clearSession();    // 清除会话文件

    // 配置文件夹路径管理
    static std::string getConfigFolderPath();
    static std::string getSessionFilePath();
    static std::string getDatabaseFilePath();

    // 更新最后活动时间（用于无操作超时检测）
    void updateActivityTime();

    // 设置用户的无操作超时时间
    void setSessionTimeout(std::chrono::minutes timeout);

    // 检查是否无操作超时
    bool isInactiveTimeout() const;

    // 初始化无操作检测（设置全局钩子和定时器）
    void initializeIdleDetection(HWND hwnd);

    // 终止无操作检测（清除钩子和定时器）
    void terminateIdleDetection();

	// 获取当前登录用户名
	std::string getCurrentUser() const;

	// 获取当前登录用户角色
	UserRole getCurrentUserRole() const;

	// 获取当前登录用户的无操作超时时间
	std::chrono::minutes getSessionTimeout() const;

	// 获取当前登录用户的会话过期时间
	std::chrono::hours getSessionExpiration() const;

private:
    UserManager();
    ~UserManager();

    // 初始化数据库连接和用户表
    bool initializeDatabase();

    // 哈希密码，用于加密用户密码
    std::string hashPassword(const std::string& password);

    // 加密和解密函数
    std::string simpleEncryptDecrypt(const std::string& data, const std::string& key);

    // 键盘和鼠标钩子函数
    static LRESULT CALLBACK LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam);
    static LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);

    // 属性定义
    std::string m_strCurrentUser;                     // 当前登录用户名
    UserRole m_enCurrentUserRole;                     // 当前登录用户角色
    bool m_isLoggedIn;                                // 是否已登录
    bool m_isRememberMe;                              // 是否记住登录状态

    std::chrono::time_point<std::chrono::system_clock> m_tpLastLogin;     // 上次登录时间
    std::chrono::time_point<std::chrono::system_clock> m_tpLastActivity;  // 最后活动时间
    std::chrono::minutes m_tmSessionTimeout;          // 无操作超时时间
    std::chrono::hours m_tmSessionExpiration;         // 会话过期时间
    HHOOK m_hMouseHook;                               // 鼠标钩子句柄
    HHOOK m_hKeyboardHook;                            // 键盘钩子句柄

    std::unique_ptr<BL::Database> m_pDB;              // 数据库接口
};

#endif // USER_MANAGER_H

#include "stdafx.h"
#include "UserManager.h"
#include <chrono>
#include <iostream>
#include <fstream>
#include <ctime>
#include <sstream>

const std::string SESSION_FILE = "session.dat";
const std::string DATABASE_FILE = "BondServo.db";

const std::string INITIAL_ADMIN_USERNAME = "admin";
const std::string INITIAL_ADMIN_PASSWORD = "admin";

// 获取单例实例
UserManager& UserManager::getInstance() {
    static UserManager instance;
    return instance;
}

UserManager::UserManager()
    : m_isLoggedIn(false), m_isRememberMe(false), m_tmSessionTimeout(std::chrono::minutes(30)),
    m_tmSessionExpiration(std::chrono::hours(72)), m_hMouseHook(nullptr), m_hKeyboardHook(nullptr),
    m_pDB(std::make_unique<BL::SQLiteDatabase>()) {
    initializeDatabase();
}

UserManager::~UserManager() {
    terminateIdleDetection();
}

// 初始化数据库，创建用户表并插入初始管理员用户
bool UserManager::initializeDatabase() {
    std::string dbFilePath = getDatabaseFilePath();
    if (!m_pDB->connect(dbFilePath, true)) {
        throw std::runtime_error("Failed to connect to database.");
    }

    std::string createTableQuery = R"(
        CREATE TABLE IF NOT EXISTS users (
            username VARCHAR(50) PRIMARY KEY,
            password_hash VARCHAR(255) NOT NULL,
            role INT NOT NULL,
            session_timeout INT DEFAULT 30,
            session_expiration INT DEFAULT 72,
            last_login TIMESTAMP
        )
    )";
    m_pDB->executeQuery(createTableQuery);

    std::string checkAdminQuery = "SELECT COUNT(*) FROM users WHERE role = 0";
    auto result = m_pDB->fetchResults(checkAdminQuery);

    if (result.empty() || result[0][0] == "0") {
        std::string insertAdminQuery = "INSERT INTO users (username, password_hash, role, session_timeout, session_expiration) VALUES ('" +
            INITIAL_ADMIN_USERNAME + "', '" + hashPassword(INITIAL_ADMIN_PASSWORD) + "', 0, 30, 72)";
        m_pDB->executeQuery(insertAdminQuery);
    }

    return true;
}

// 对密码进行哈希处理
std::string UserManager::hashPassword(const std::string& password) {
    return std::to_string(std::hash<std::string>{}(password));
}

// 简单的加密和解密函数
std::string UserManager::simpleEncryptDecrypt(const std::string& data, const std::string& key) {
    std::string result = data;
    for (size_t i = 0; i < data.size(); ++i) {
        result[i] ^= key[i % key.size()];  // 简单异或加密
    }
    return result;
}

// 从会话文件加载会话信息
bool UserManager::loadSession() {
    std::ifstream sessionFile(getSessionFilePath(), std::ios::binary);
    if (!sessionFile.is_open()) {
        return false;
    }

    // 从文件读取加密数据
    std::string encryptedData((std::istreambuf_iterator<char>(sessionFile)), std::istreambuf_iterator<char>());
    sessionFile.close();

    // 解密数据
    std::string decryptedData = simpleEncryptDecrypt(encryptedData, "my_secret_key");

    // 解析解密的数据
    std::istringstream sessionData(decryptedData);
    std::string username;
    std::time_t lastLoginTime;
    int timeoutMinutes;
    int expirationHours;

    sessionData >> username >> lastLoginTime >> timeoutMinutes >> expirationHours;

    // 验证时间戳有效性
    auto now = std::chrono::system_clock::now();
    auto lastLogin = std::chrono::system_clock::from_time_t(lastLoginTime);
    auto sessionDuration = std::chrono::duration_cast<std::chrono::hours>(now - lastLogin);

    if (sessionDuration > std::chrono::hours(expirationHours)) {
        clearSession();
        return false;
    }

    // 恢复会话数据
    m_strCurrentUser = username;
    m_tpLastLogin = lastLogin;
    m_tmSessionTimeout = std::chrono::minutes(timeoutMinutes);
    m_tmSessionExpiration = std::chrono::hours(expirationHours);
    m_isLoggedIn = true;
    m_isRememberMe = true;
    updateActivityTime();

    return true;
}

// 保存会话信息到文件
void UserManager::saveSession() {
    if (!m_isRememberMe) {
        return;
    }

    // 原始会话数据
    std::stringstream sessionData;
    std::time_t lastLoginTime = std::chrono::system_clock::to_time_t(m_tpLastLogin);
    sessionData << m_strCurrentUser << " " << lastLoginTime << " "
        << m_tmSessionTimeout.count() << " " << m_tmSessionExpiration.count();

    // 加密数据
    std::string encryptedData = simpleEncryptDecrypt(sessionData.str(), "my_secret_key");

    // 写入加密数据到文件
    std::ofstream sessionFile(getSessionFilePath(), std::ios::binary);
    if (sessionFile.is_open()) {
        sessionFile << encryptedData;
        sessionFile.close();
    }
}

// 清除会话文件
void UserManager::clearSession() {
    std::remove(getSessionFilePath().c_str());
}

// 获取程序路径下的config文件夹路径
std::string UserManager::getConfigFolderPath() {
    char path[MAX_PATH];
    GetModuleFileName(NULL, path, MAX_PATH);
    std::string exePath = std::string(path).substr(0, std::string(path).find_last_of("\\/"));
    std::string configPath = exePath + "\\Config\\";

    // 检查并创建config文件夹
    DWORD fileAttr = GetFileAttributes(configPath.c_str());
    if (fileAttr == INVALID_FILE_ATTRIBUTES) {
        CreateDirectory(configPath.c_str(), NULL);
    }

    return configPath;
}

// 获取session.dat文件路径
std::string UserManager::getSessionFilePath() {
    return getConfigFolderPath() + SESSION_FILE;
}

// 获取数据库文件路径
std::string UserManager::getDatabaseFilePath() {
    return getConfigFolderPath() + DATABASE_FILE;
}

// 登录方法
bool UserManager::login(const std::string& username, const std::string& password, bool rememberMeFlag) {
    std::string query = "SELECT username, password_hash, role, session_timeout, session_expiration FROM users WHERE username = '" + username + "'";
    auto result = m_pDB->fetchResults(query);

    if (result.empty() || result[0][1] != hashPassword(password)) {
        std::cerr << "Login failed: Invalid username or password." << std::endl;
        return false;
    }

    m_strCurrentUser = username;
    m_enCurrentUserRole = static_cast<UserRole>(std::stoi(result[0][2]));
    m_tmSessionTimeout = std::chrono::minutes(std::stoi(result[0][3]));
    m_tmSessionExpiration = std::chrono::hours(std::stoi(result[0][4]));
    m_isLoggedIn = true;
    m_isRememberMe = rememberMeFlag;
    updateActivityTime();
    m_tpLastLogin = std::chrono::system_clock::now();

    std::string updateLoginTime = "UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE username = '" + username + "'";
    m_pDB->executeQuery(updateLoginTime);

    saveSession();
    return true;
}

// 登出方法
void UserManager::logout() {
    if (m_isLoggedIn) {
        std::cout << "User logged out: " << m_strCurrentUser << std::endl;
        m_strCurrentUser.clear();
        m_isLoggedIn = false;
        m_isRememberMe = false;
        clearSession();
    }
}

// 返回当前用户的登录状态
bool UserManager::isLoggedIn() const {
    return m_isLoggedIn;
}

// 创建新用户，仅超级管理员有权限
bool UserManager::createUser(const std::string& username, const std::string& password, UserRole role,
    std::chrono::minutes timeout, std::chrono::hours expiration) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can create new users." << std::endl;
        return false;
    }

    std::string query = "INSERT INTO users (username, password_hash, role, session_timeout, session_expiration) VALUES ('" +
        username + "', '" + hashPassword(password) + "', " + std::to_string(static_cast<int>(role)) + ", " +
        std::to_string(timeout.count()) + ", " + std::to_string(expiration.count()) + ")";
    return m_pDB->executeQuery(query);
}

// 删除用户，仅超级管理员有权限，且不能删除自己
bool UserManager::deleteUser(const std::string& username) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can delete users." << std::endl;
        return false;
    }
    if (username == m_strCurrentUser) {
        std::cerr << "SuperAdmin cannot delete their own account." << std::endl;
        return false;
    }

    std::string query = "DELETE FROM users WHERE username = '" + username + "'";
    return m_pDB->executeQuery(query);
}

// 获取所有用户信息，仅超级管理员有权限
std::vector<std::vector<std::string>> UserManager::getUsers() {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can retrieve user data." << std::endl;
        return {};
    }

    // 查询整个用户表
    std::string query = "SELECT username, password_hash, role, session_timeout, session_expiration, last_login FROM users";
    return m_pDB->fetchResults(query);
}

// 设置整个用户表的数据，仅超级管理员有权限
bool UserManager::setUsers(const std::vector<std::vector<std::string>>& usersData) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can set user data." << std::endl;
        return false;
    }

    // 清空用户表
    std::string deleteQuery = "DELETE FROM users";
    if (!m_pDB->executeQuery(deleteQuery)) {
        std::cerr << "Failed to clear the users table." << std::endl;
        return false;
    }

    // 插入新的用户数据
    for (const auto& user : usersData) {
        if (user.size() != 6) {
            std::cerr << "Invalid data format for user. Each user must have 6 fields." << std::endl;
            return false;
        }

        std::string insertQuery = "INSERT INTO users (username, password_hash, role, session_timeout, session_expiration, last_login) VALUES ('" +
            user[0] + "', '" + user[1] + "', " + user[2] + ", " + user[3] + ", " + user[4] + ", '" + user[5] + "')";

        if (!m_pDB->executeQuery(insertQuery)) {
            std::cerr << "Failed to insert user: " << user[0] << std::endl;
            return false;
        }
    }

    return true;
}

// 修改用户名，仅超级管理员有权限
bool UserManager::changeUsername(const std::string& currentUsername, const std::string& newUsername) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can change usernames." << std::endl;
        return false;
    }

    std::string query = "UPDATE users SET username = '" + newUsername + "' WHERE username = '" + currentUsername + "'";
    bool success = m_pDB->executeQuery(query);

    // 如果是当前登录用户修改自己的用户名，更新成员变量并保存会话文件
    if (success && m_strCurrentUser == currentUsername) {
        m_strCurrentUser = newUsername;

        // 如果“记住密码”已启用，更新会话文件
        if (m_isRememberMe) {
            saveSession();
        }
    }
    return success;
}

// 修改用户密码（仅允许当前用户或超级管理员）
bool UserManager::changePassword(const std::string& username, const std::string& newPassword) {
    if (username != m_strCurrentUser && m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Permission denied: Only the user or SuperAdmin can change passwords." << std::endl;
        return false;
    }

    std::string query = "UPDATE users SET password_hash = '" + hashPassword(newPassword) +
        "' WHERE username = '" + username + "'";
    bool success = m_pDB->executeQuery(query);

    // 如果是当前用户修改自己的密码，退出登录并清除会话文件
    if (success && m_strCurrentUser == username) {
        logout();
        std::cout << "Password changed successfully. Please log in again." << std::endl;
    }

    return success;
}

// 更改用户角色，仅超级管理员有权限
bool UserManager::changeUserRole(const std::string& username, UserRole newRole) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can change user roles." << std::endl;
        return false;
    }

    // 防止管理员更改自己的角色
    if (m_strCurrentUser == username) {
        std::cerr << "SuperAdmin cannot change their own role." << std::endl;
        return false;
    }

    std::string query = "UPDATE users SET role = " + std::to_string(static_cast<int>(newRole)) +
        " WHERE username = '" + username + "'";
    return m_pDB->executeQuery(query);
}

// 修改用户的 session_timeout，仅超级管理员有权限
bool UserManager::changeUserSessionTimeout(const std::string& username, int newTimeoutMinutes) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can change session timeout." << std::endl;
        return false;
    }

    std::string query = "UPDATE users SET session_timeout = " + std::to_string(newTimeoutMinutes) +
        " WHERE username = '" + username + "'";
    bool success = m_pDB->executeQuery(query);
    // 如果是当前登录用户修改自己的超时设置，更新成员变量
    if (success && m_strCurrentUser == username) {
        m_tmSessionTimeout = std::chrono::minutes(newTimeoutMinutes);

        if (m_isRememberMe) {
            saveSession();
        }
    }
    return success;
}

// 修改用户的 session_expiration，仅超级管理员有权限
bool UserManager::changeUserSessionExpiration(const std::string& username, int newExpirationHours) {
    if (m_enCurrentUserRole != UserRole::SuperAdmin) {
        std::cerr << "Only SuperAdmin can change session expiration." << std::endl;
        return false;
    }

    std::string query = "UPDATE users SET session_expiration = " + std::to_string(newExpirationHours) +
        " WHERE username = '" + username + "'";
    bool success = m_pDB->executeQuery(query);
    // 如果是当前登录用户修改自己的过期设置，更新成员变量
    if (success && m_strCurrentUser == username) {
        m_tmSessionExpiration = std::chrono::hours(newExpirationHours);

        if (m_isRememberMe) {
            saveSession();
        }
    }
    return success;
}

// 更新最后活动时间，用于无操作超时检测
void UserManager::updateActivityTime() {
    m_tpLastActivity = std::chrono::system_clock::now();
    std::cout << "Activity updated at: " << std::chrono::system_clock::to_time_t(m_tpLastActivity) << std::endl;
}

// 设置无操作超时时间
void UserManager::setSessionTimeout(std::chrono::minutes timeout) {
    m_tmSessionTimeout = timeout;
}

// 检查是否超过无操作超时时间
bool UserManager::isInactiveTimeout() const {
    auto now = std::chrono::system_clock::now();
    auto elapsedSeconds = std::chrono::duration_cast<std::chrono::seconds>(now - m_tpLastActivity).count();
    return elapsedSeconds > m_tmSessionTimeout.count() * 60;
}

// 初始化无操作检测，包括设置全局鼠标和键盘钩子
void UserManager::initializeIdleDetection(HWND hwnd) {
    updateActivityTime();
    m_hMouseHook = SetWindowsHookEx(WH_MOUSE_LL, LowLevelMouseProc, (HINSTANCE) nullptr, 0);
    m_hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, (HINSTANCE) nullptr, 0);
    ::SetTimer(hwnd, 1, 60000, nullptr);
}

// 终止无操作检测，清除鼠标和键盘钩子
void UserManager::terminateIdleDetection() {
    if (m_hMouseHook) {
        UnhookWindowsHookEx(m_hMouseHook);
        m_hMouseHook = nullptr;
    }
    if (m_hKeyboardHook) {
        UnhookWindowsHookEx(m_hKeyboardHook);
        m_hKeyboardHook = nullptr;
    }
    ::KillTimer(nullptr, 1);
}

// 获取当前登录用户名
std::string UserManager::getCurrentUser() const {
	return m_strCurrentUser;
}

// 获取当前登录用户角色
UserRole UserManager::getCurrentUserRole() const {
	return m_enCurrentUserRole;
}

// 获取当前登录用户的无操作超时时间
std::chrono::minutes UserManager::getSessionTimeout() const {
	return m_tmSessionTimeout;
}

// 获取当前登录用户的会话过期时间
std::chrono::hours UserManager::getSessionExpiration() const {
	return m_tmSessionExpiration;
}

// 全局鼠标钩子回调，记录活动时间
LRESULT CALLBACK UserManager::LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        UserManager::getInstance().updateActivityTime();
        std::cout << "Mouse event detected. Activity time updated." << std::endl;
    }
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

// 全局键盘钩子回调，记录活动时间
LRESULT CALLBACK UserManager::LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        UserManager::getInstance().updateActivityTime();
        std::cout << "Keyboard event detected. Activity time updated." << std::endl;
    }
    return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

6. 总结

本项目提供了一个基本的C++用户管理系统，支持自动登出和会话文件加密等功能，适合在需要用户认证和会话管理的应用场景中使用。

用户管理系统_c++实现
君子以阅川的博客
09-10 1860
用户管理系统_c++实现
c++windows用户管理
11-23
c++ 操作Windows用户，对用户的增加，用户组的修改，用户权限的管理，函数很全
C++ 用户管理模块
08-07
一个C++ 写的用户权限管理模块，可以实现用户权限的定制，权限监测、用户的增删改查，不使用数据库，所有信息都是用DES加密写入用户信息文件中。防信息篡改
【C++】C++ 餐厅管理系统（管理员+消费者等 多角色）（源码+数据文件）【独一无二】
最新发布
NSJ85的博客
02-24 697
模块化设计整个系统根据角色功能划分模块，每个模块（消费者、收银员、厨师、服务员、老板、系统管理员）各自实现一部分业务逻辑，既便于代码维护又利于后续功能扩展。数据结构与链表使用订单（Ticket）和菜品（DishNode）均采用链表存储，便于动态增删，同时全局固定数组维护餐位和菜单信息，实现简单而直观的数据管理。文件持久化系统在读取和退出时进行数据的文件持久化，保证程序重启后能够恢复上一次的状态。简易交互界面通过菜单驱动的方式，使用。
C++简单实现用户管理系统
11-26
https://blog.csdn.net/qq_39979646/article/details/110148287
用户权限管理模块（C++实现）
05-25
1.使用C++实现的权限管理模块 2.单例模式实现，方便集成 3.实现了root和普通用户区别，添加新用户，修改密码 4.用户名密码以加密文档形式存在本地文件
C++实现通讯录管理系统
08-25
C++实现通讯录管理系统 本文主要介绍了使用C++语言实现通讯录管理系统的设计和实现。通讯录管理系统是一个基本的信息管理系统，旨在存储和管理个人通讯录信息。通过本文，我们将学习如何使用C++语言设计和实现...
C++实现老板键模块开发指南
10-14
C++实现老板键模块开发指南详细解析了如何设计和实现一个功能丰富的老板键模块。老板键是一种特殊热键，它的组合可以由用户自定义，用于在特定情况下快速触发一系列预设操作，从而达到某种目的，如暂停游戏或隐藏...
C++实现商品管理程序
08-25
C++实现商品管理程序 本文将详细介绍C++实现商品管理程序，主要包括商品信息的计算、排序、查询及显示功能。程序的设计目的是培养学生综合利用C++语言进行程序设计的能力，熟悉数组的操作，加强函数的运用，掌握...
基于C++实现的简易银行账户管理系统的设计与实现
02-12
内容概要：本文档介绍了一套用C++编程语言编写的简易银行账户管理系统。该系统的目的是创建一个基本但完整的用户交互环境，使得终端用户能够创建自己的银行账户，完成存款、取款、查询余额以及退出等主要银行业务...
C++实现简易通讯录
Faith_xzc
02-19 708
功能和效果图 功能 通讯录实现联系人查找，添加联系人，删除联系人，联系人信息修改 效果图 实现代码 创建结构体 typedef struct News { string name; //姓名 string sex; //性别 string address; //地址 int tell; //电话 }News; 查找联系人 int search(News *a) { s...
用户管理系统
02-12
老师评为优的C#结课大作业！ 该系统主要实现系用户的管理，包括：增加用户、删除用户、修改用户信息和查询用户。系统功能如下： （1）登录，用户需经过登录界面进入系统。 （2）增加用户，超级用户登录进入系统后可以增加用户。 （3）删除用户，超级用户登录进入系统后可以删除其它用户（不能删除当前的登录用户）。 （4）修改用户信息，超级用户登录进入系统后可以修改用户信息。 （5）查询用户，用户登录进系统后，可以按条件查询用户。 普通用户登录进入系统后，只能修改自己的信息，不能增加、修改和删除用户。可以按条件查询用户。
权限管理系统 C/S模式C++ 完整程序，源代码
10-08
权限管理系统 C/S模式C++ 完整程序，源代码
基于C++权限管理源码
05-17
c++实现权限管理源代码，课程设计必备好材料
C++、MFC图书馆管理系统之（301用户管理）（源代码）
11-16
1、本项目为visual studio工具创建并编译，建议使用visual studio 2022版本打开。 2、程序使用的数据库为mysql 8.0.22 x86 win32，ODBC版本为8.0.12 x86 win32。 3、运行程序前需要在mysql中创建数据库libraryMgn，然后在mysql中执行一下程序目录下的librarymgn.sql文件。 4、程序运行前需要修改一下config.ini配置文件，配置一下连接mysql的ip、端口、用户名、密码、数据库名等信息，请勿随意修改该配置文件。 5、本程序主要功能为用户管理，乃图书馆管理系统中的一部分，后续会不断上传该系统的其他部分源码，欢迎关注。 6、本程序的开发语言及框架为：C++、MFC。 7、本程序是N年前开发的，受限于本人当时的技术能力，难免会有一些bug。 8、本程序目录下有详细的项目运行说明，请按步骤执行，确保项目能正常运行。 9、本程序重写了多个控件的实现，对学习MFC编程有很大的帮助和借鉴作用。 10、本程序仅供学习交流，请勿用于任何商业场景，由于使用本程序造成的任何损失需自行承担。
基于Visual C++之Windows核心编程代码分析（2）实现Windows用户管理
flyingleo1981的专栏
12-08 1073
在Windows编程中间，我们经常需要添加用户，删除用户，添加用户组等等功能，那些功能如何实现呢，我们请见实现代码与注释分析     [cpp] view plain copy /* UNICODE */   #ifndef UNICODE   #define UNICODE   #endif   /* 头文件 */   #incl
c++实现一个简单的人员管理系统
Johnhanny的博客
01-05 1296
c++一个简单的人员管理系统
Qt/C++编写物联网管理平台31-用户权限管理
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
05-25 4641
一、前言 随着需求的不断变化，功能的增多，在用户信息这块，除了需要用户登录退出验证以外，还需要有个简单的用户权限逻辑处理，比如限定某些用户只有查看权限，没有删除记录、清空记录、系统设置的权限，与之相对应的就是用户信息表中，存储有该用户具备哪些权限，当该用户登录成功以后，对应的权限应用到各个界面逻辑中，一般都是在触发了对应的显示或者单击后处理，比如不具备删除记录权限，则在对应的删除记录代码中过滤处理，判断当前登录的用户是否具备该权限，不具备则弹出提示，不做处理。还有一个就是切换界面的时候，没有到该界面的权限弹
QT(C++)权限管理平台源码功能说明：包括用户管理、角色管理、角色权限管理
SoZfpIdS的博客
10-20 1798
QT(C++)权限管理平台源码的主要功能包括用户管理、角色管理、角色权限管理、菜单管理和日志管理等功能。QT是一个跨平台的C++应用程序开发框架，它提供了一套完整的工具链来实现GUI程序的开发和部署，而MYSQL57则是一个流行的开源关系型数据库管理系统，它能够提供高效的数据存储和管理服务。QT(C++)权限管理平台源码是一个全方位的权限管理平台，它具备完善的功能、强大的开发工具、广泛的运行平台和详细的开发文档；功能说明：包括用户管理、角色管理、角色权限管理、菜单管理 、日志管理?：数据库字典，源码说明。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值