Server/SourceFiles/Services/TokenService.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Services/TokenService.cpp
109 строк4 KB
Shymer123
Initial commit: LumenServer
20 июн 2026, 12:43
20 июн 2026, 12:43173f14c
#include "TokenService.h"
#include "Core/Utils/UuidGenerator.h"
#include <jwt-cpp/traits/nlohmann-json/defaults.h>
#include <iostream>

namespace Services {

    TokenService::TokenService(Storage::Db::Repositories::SessionRepository& sessionRepo,
                               const Core::Settings::SecuritySettings& securitySettings)
        : m_sessionRepo(sessionRepo), m_securitySettings(securitySettings)
    {}

    Tokens TokenService::generateTokens(const std::string& userId, const std::string& deviceId)
    {
        auto jti = Core::Utils::generate_uuid();

        auto accessToken = jwt::create<jwt::traits::nlohmann_json>()
                .set_issuer("auth-server")
                .set_type("JWT")
                .set_payload_claim("user_id", jwt::claim(userId))
                .set_payload_claim("jti", jwt::claim(jti))
                .set_payload_claim("device_id", jwt::claim(deviceId.empty() ? "unknown" : deviceId))
                .set_expires_at(std::chrono::system_clock::now() + std::chrono::minutes(static_cast<int64_t>(15)))
                .sign(jwt::algorithm::hs256{m_securitySettings.jwtSecretKey()});

        auto refreshToken = Core::Utils::generate_uuid();
        std::string deviceInfo = generateDeviceInfo();
        std::string finalDeviceId = deviceId.empty() ? Core::Utils::generate_uuid() : deviceId;

        m_sessionRepo.updateOrCreateSession(userId, finalDeviceId, refreshToken, jti, deviceInfo);

        return {accessToken, refreshToken, finalDeviceId};
    }

    std::optional<Tokens> TokenService::refreshTokens(const std::string& refreshToken, const std::string& deviceId)
    {
        auto session = m_sessionRepo.findByRefreshToken(refreshToken);
        if(!session) return std::nullopt;
        if(session->device_id != deviceId) return std::nullopt;

    //    m_sessionRepo.deleteSession(refreshToken);
        return generateTokens(session->user_id, session->device_id);
    }

    bool TokenService::revokeRefreshToken(const std::string& refreshToken)
    {
        auto session = m_sessionRepo.findByRefreshToken(refreshToken);
        if(!session) return false;

        return m_sessionRepo.removeSession(session->user_id, session->device_id);
    }

    bool TokenService::revokeUserDeviceSession(const std::string& userId, const std::string& deviceId)
    {
        return m_sessionRepo.removeSession(userId, deviceId);
    }

    std::optional<std::string> TokenService::validateAccessToken(const std::string& token)
    {
        try {
            auto decoded = jwt::decode(token);
            jwt::verify()
                .allow_algorithm(jwt::algorithm::hs256{m_securitySettings.jwtSecretKey()})
                .with_issuer("auth-server")
                .verify(decoded);

            return decoded.get_payload_claim("user_id").as_string();
        } catch(...) {
            return std::nullopt;
        }
    }

    std::optional<Storage::Db::Repositories::SessionRecord>
    TokenService::getSessionByRefreshToken(const std::string& refreshToken)
    {
        return m_sessionRepo.findByRefreshToken(refreshToken);
    }

    std::optional<std::string> TokenService::getUserIdFromToken(const std::string& token)
    {
        try {
            auto decoded = jwt::decode(token);
            return decoded.get_payload_claim("user_id").as_string();
        } catch (...) {
            return std::nullopt;
        }
    }

    std::vector<Storage::Db::Repositories::SessionRecord> TokenService::getUserSessions(const std::string& userId)
    {
        return m_sessionRepo.getUserSessions(userId);
    }

    bool TokenService::updateLastActivity(const std::string& userId, const std::string& deviceId)
    {
        return m_sessionRepo.updateLastActivity(userId, deviceId);
    }

    std::string TokenService::generateDeviceInfo()
    {
        return "Unknown Device";
    }

//    bool TokenService::revokeRefreshToken(const std::string& refreshToken)
//    {
//        return m_sessionRepo.deleteSession(refreshToken);
//    }

} // namespace Services