From 9dab564d3aaabda88efda5e3289392d0be716084 Mon Sep 17 00:00:00 2001 From: Aotrix <9aotrix@protonmail.com> Date: Mon, 17 Nov 2025 13:30:23 +0100 Subject: changed subprojects to submodules --- submodules/battleNetApi/CMakeLists.txt | 25 +++++ submodules/battleNetApi/include/apiUrl.hpp | 19 ++++ submodules/battleNetApi/include/hearthstoneApi.hpp | 43 +++++++++ submodules/battleNetApi/include/token.hpp | 25 +++++ submodules/battleNetApi/resources/token_info | 1 + submodules/battleNetApi/src/apiUrl.cpp | 40 ++++++++ submodules/battleNetApi/src/hearthstoneApi.cpp | 40 ++++++++ submodules/battleNetApi/src/token.cpp | 105 +++++++++++++++++++++ submodules/battleNetApi/tests/tests.cpp | 65 +++++++++++++ 9 files changed, 363 insertions(+) create mode 100644 submodules/battleNetApi/CMakeLists.txt create mode 100644 submodules/battleNetApi/include/apiUrl.hpp create mode 100644 submodules/battleNetApi/include/hearthstoneApi.hpp create mode 100644 submodules/battleNetApi/include/token.hpp create mode 100644 submodules/battleNetApi/resources/token_info create mode 100644 submodules/battleNetApi/src/apiUrl.cpp create mode 100644 submodules/battleNetApi/src/hearthstoneApi.cpp create mode 100644 submodules/battleNetApi/src/token.cpp create mode 100644 submodules/battleNetApi/tests/tests.cpp (limited to 'submodules') diff --git a/submodules/battleNetApi/CMakeLists.txt b/submodules/battleNetApi/CMakeLists.txt new file mode 100644 index 0000000..b4f6a48 --- /dev/null +++ b/submodules/battleNetApi/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.15) + +get_filename_component(FNAME ${CMAKE_SOURCE_DIR} NAME) +set(ProjectName ${FNAME}) + +project(${ProjectName} LANGUAGES CXX) + +set(CMAKE_COMPILE_COMMANDS ON) +set(CMAKE_CXX_STANDARD 20) +set(CXX_STANDARD_REQUIRED ON) +set(CMAKE_BUILD_TYPE Debug) +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20 -Wall") +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +add_definitions(-DSOURCE_DIR_PATH="${CMAKE_SOURCE_DIR}") + +set(INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include) +set(SRC + ${PROJECT_SOURCE_DIR}/src/hearthstoneApi.cpp + ${PROJECT_SOURCE_DIR}/src/token.cpp ${PROJECT_SOURCE_DIR}/src/apiUrl.cpp + ${PROJECT_SOURCE_DIR}/tests/tests.cpp) + +find_package(Catch2 3 REQUIRED) +add_executable(tests ${SRC}) +target_include_directories(tests PRIVATE ${INCLUDE_DIR}) +target_link_libraries(tests PRIVATE Catch2::Catch2WithMain curl) diff --git a/submodules/battleNetApi/include/apiUrl.hpp b/submodules/battleNetApi/include/apiUrl.hpp new file mode 100644 index 0000000..509b248 --- /dev/null +++ b/submodules/battleNetApi/include/apiUrl.hpp @@ -0,0 +1,19 @@ +#pragma once +#include +#include + +class ApiUrl { + public: + ApiUrl(const std::string &iContentType, const std::string &iRegion); + + void setRegion(const std::string &iRegion); + void setLocale(const std::string &iLocale); + void setGameMode(const std::string &iGameMode); + void setPageSize(const std::string &iPageSize); + std::string operator()() const; + + private: + std::string mContentType; + std::string mRegion; + std::unordered_map aParameters; +}; diff --git a/submodules/battleNetApi/include/hearthstoneApi.hpp b/submodules/battleNetApi/include/hearthstoneApi.hpp new file mode 100644 index 0000000..c11acc7 --- /dev/null +++ b/submodules/battleNetApi/include/hearthstoneApi.hpp @@ -0,0 +1,43 @@ +#pragma once +#include "token.hpp" +#include +#include +#include + +class HearthstoneApi { + public: + HearthstoneApi(Token &&iToken); + std::uint64_t numberOfCards(const std::string &iApiResponse) const; + + private: + std::string authorizationHeader(); + std::string makeApiRequest(const std::string &iUrl) const; + static size_t curlCallbackStringOutput(void *iContent, size_t iSize, size_t iNmemb, std::string *iS); + + /** + * @brief + * @param[in] iJsonContent The std::string which contains Json (Battle.net API response for instance) + * @param[in] iKeyValueRegex The regex used to retrieve value from (key, value) pair + * An example: "\"cardCount\":(\\d+)" + */ + template T valueInJson(const std::string &iJsonContent, const std::string &iKeyValueRegex) const { + const std::regex iRegex{iKeyValueRegex}; + std::smatch aMatches; + if (std::regex_search(iJsonContent, aMatches, iRegex)) { + const std::string kValueString{aMatches[1].str()}; + T aValue; + const auto kConversionStatus = + std::from_chars(kValueString.data(), kValueString.data() + kValueString.size(), aValue); + if (kConversionStatus.ec == std::errc{}) { + return aValue; + } + } + std::cerr << std::format("Unable to find value with regex: '{}'\n", iKeyValueRegex); + return 0; + } + + Token mToken; + std::string mAuthorizationHeader; // +#include + +class Token { + public: + Token(const std::string &iTokenFilePath, const std::string &iUsername, const std::string &iPassword); + std::string toString() const; + + private: + const std::string mFilePath; //!< Path to the token file + const std::string mUsername; //!< Username for Battle.net API + const std::string mPassword; //!< Password for Battle.net API + const std::string mToken; //!< Token value + + std::string getValidToken() const; + void refreshToken() const; + void writeNewTokenToFile() const; + void writeTokenToFile(const std::string &iToken) const; + std::string getValidTokenWithApi() const; + std::chrono::seconds getCurrentTime() const; + std::string extractTokenWithRegex(const std::string &iText, const std::string &iRegex) const; + static size_t curlCallbackStringOutput(void *iPtr, size_t iSize, size_t iNmemb, std::string *iUserData); + + friend class TokenTests; +}; diff --git a/submodules/battleNetApi/resources/token_info b/submodules/battleNetApi/resources/token_info new file mode 100644 index 0000000..dfc6889 --- /dev/null +++ b/submodules/battleNetApi/resources/token_info @@ -0,0 +1 @@ +EU20H8gsvH6cthwX0KnWM6LZW2tzoeIEi4 1763412154 diff --git a/submodules/battleNetApi/src/apiUrl.cpp b/submodules/battleNetApi/src/apiUrl.cpp new file mode 100644 index 0000000..3de13cd --- /dev/null +++ b/submodules/battleNetApi/src/apiUrl.cpp @@ -0,0 +1,40 @@ +#include "apiUrl.hpp" +#include + +ApiUrl::ApiUrl(const std::string &iContentType, const std::string &iRegion) + : mContentType{iContentType}, mRegion{iRegion} {} +void ApiUrl::setRegion(const std::string &iRegion) { + if (not iRegion.empty()) { + mRegion = iRegion; //!< The region of the data to receive, e.g. "eu" + } +} +void ApiUrl::setLocale(const std::string &iLocale) { + if (not iLocale.empty()) { + aParameters["locale"] = iLocale; //!< The locale to reflect in localized data, e.g. "fr_FR" or "ko_KR" + //!< If you do not supply a value, all translations are returned. + } +} +void ApiUrl::setGameMode(const std::string &iGameMode) { + if (not iGameMode.empty()) { + aParameters["gameMode"] = + iGameMode; //!< A recognized game mode, e.g. "constructed" + //!< @see https://community.developer.battle.net/documentation/hearthstone/guides/game-modes + } +} +void ApiUrl::setPageSize(const std::string &iPageSize) { + if (not iPageSize.empty()) { + aParameters["pageSize"] = iPageSize; //!< The number of results to choose per page, e.g. "40" + } +} +std::string ApiUrl::operator()() const { + std::string aFormattedParameters; + for (const auto &[key, value] : aParameters) { + aFormattedParameters += std::format("&{}={}", key, value); + } + if (not aFormattedParameters.empty()) { + aFormattedParameters[0] = '?'; + } + aFormattedParameters = + std::format("https://{}.api.blizzard.com/hearthstone/{}/{}", mRegion, mContentType, aFormattedParameters); + return aFormattedParameters; +} diff --git a/submodules/battleNetApi/src/hearthstoneApi.cpp b/submodules/battleNetApi/src/hearthstoneApi.cpp new file mode 100644 index 0000000..c34e6ad --- /dev/null +++ b/submodules/battleNetApi/src/hearthstoneApi.cpp @@ -0,0 +1,40 @@ +#include "hearthstoneApi.hpp" +#include +#include + +HearthstoneApi::HearthstoneApi(Token &&iToken) : mToken(iToken), mAuthorizationHeader(authorizationHeader()) {} + +std::uint64_t HearthstoneApi::numberOfCards(const std::string &iApiResponse) const { + const std::string aCardCountRegex{"\"cardCount\":(\\d+)"}; + return valueInJson(iApiResponse, aCardCountRegex); +} +std::string HearthstoneApi::authorizationHeader() { return std::format("Authorization: Bearer {}", mToken.toString()); } + +size_t HearthstoneApi::curlCallbackStringOutput(void *iContent, size_t iSize, size_t iNmemb, std::string *iS) { + const size_t kNewLength = iSize * iNmemb; + try { + iS->append(static_cast(iContent), kNewLength); + } catch (std::bad_alloc &e) { + // handle memory problem + return 0; + } + return kNewLength; +} + +std::string HearthstoneApi::makeApiRequest(const std::string &iUrl) const { + CURL *curl = curl_easy_init(); + std::string request_output; + if (curl) { + curl_easy_setopt(curl, CURLOPT_URL, iUrl.c_str()); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, &request_output); + struct curl_slist *chunk = nullptr; + chunk = curl_slist_append(chunk, mAuthorizationHeader.c_str()); + curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk); + curl_easy_perform(curl); + curl_easy_cleanup(curl); + } + return request_output; +} diff --git a/submodules/battleNetApi/src/token.cpp b/submodules/battleNetApi/src/token.cpp new file mode 100644 index 0000000..89f0d2a --- /dev/null +++ b/submodules/battleNetApi/src/token.cpp @@ -0,0 +1,105 @@ +#include "token.hpp" +#include +#include +#include +#include +#include +#include +#include +#include + +Token::Token(const std::string &iTokenFilePath, const std::string &iUsername, const std::string &iPassword) + : mFilePath{iTokenFilePath}, mUsername{iUsername}, mPassword{iPassword}, mToken{getValidToken()} {} + +std::string Token::toString() const { return mToken; } + +std::string Token::getValidToken() const { + refreshToken(); + std::ifstream aTokenFile{mFilePath}; + std::string aLine; + std::getline(aTokenFile, aLine); + const std::string kToken{aLine.substr(0, aLine.find(" "))}; + return kToken; +} + +void Token::refreshToken() const { + std::ifstream aTokenFile{mFilePath}; + std::string aLine; + std::getline(aTokenFile, aLine); + if (aLine.empty()) { + writeNewTokenToFile(); + } else { + const std::string kTimeLimitText{aLine.substr(aLine.find(" ") + 1)}; + long int aTimeLimit; + const auto kConversionStatus{ + std::from_chars(kTimeLimitText.data(), kTimeLimitText.data() + kTimeLimitText.size(), aTimeLimit)}; + if (kConversionStatus.ec == std::errc{}) { + const bool kTokenExpired{ + std::chrono::duration_cast(std::chrono::utc_clock::now().time_since_epoch()) + .count() >= aTimeLimit}; + if (kTokenExpired) { + writeNewTokenToFile(); + } + } + } +} + +void Token::writeNewTokenToFile() const { + const std::string kToken{getValidTokenWithApi()}; + if (not kToken.empty()) { + writeTokenToFile(kToken); + } +} + +void Token::writeTokenToFile(const std::string &iToken) const { + std::ofstream aTokenFile{mFilePath}; + std::chrono::seconds aExpiresAt{getCurrentTime() + std::chrono::hours(24)}; + aTokenFile << iToken << " " << aExpiresAt.count() << '\n'; +} + +std::string Token::getValidTokenWithApi() const { + CURL *aCurl{curl_easy_init()}; + std::string aTokenInfo; + if (aCurl) { + curl_easy_setopt(aCurl, CURLOPT_URL, "https://oauth.battle.net/token"); + curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(aCurl, CURLOPT_SSL_VERIFYHOST, 0L); + curl_easy_setopt(aCurl, CURLOPT_WRITEFUNCTION, curlCallbackStringOutput); + curl_easy_setopt(aCurl, CURLOPT_WRITEDATA, &aTokenInfo); + curl_easy_setopt(aCurl, CURLOPT_USERPWD, std::format("{}:{}", mUsername, mPassword).data()); + curl_easy_setopt(aCurl, CURLOPT_POSTFIELDS, "grant_type=client_credentials"); + CURLcode result_code{curl_easy_perform(aCurl)}; + curl_easy_cleanup(aCurl); + if (result_code != CURLE_OK) { + std::cerr << "ERROR: token request failed" << std::endl; + std::exit(EXIT_FAILURE); + } + } + + return extractTokenWithRegex(aTokenInfo, "\"access_token\":\"(\\w+)\""); +} + +std::chrono::seconds Token::getCurrentTime() const { + return std::chrono::duration_cast(std::chrono::utc_clock::now().time_since_epoch()); +} + +std::string Token::extractTokenWithRegex(const std::string &iText, const std::string &iRegex) const { + const std::regex kRegex{iRegex}; + std::smatch aMatches; + if (std::regex_search(iText, aMatches, kRegex)) { + return aMatches[1].str(); + } + std::cerr << std::format("Unable to retrieve token with regex '{}'", iRegex); + return ""; +} + +size_t Token::curlCallbackStringOutput(void *iPtr, size_t iSize, size_t iNmemb, std::string *iUserData) { + size_t newLength{iSize * iNmemb}; + try { + iUserData->append(static_cast(iPtr), newLength); + } catch (std::bad_alloc &e) { + // handle memory problem + return 0; + } + return newLength; +} diff --git a/submodules/battleNetApi/tests/tests.cpp b/submodules/battleNetApi/tests/tests.cpp new file mode 100644 index 0000000..74845c5 --- /dev/null +++ b/submodules/battleNetApi/tests/tests.cpp @@ -0,0 +1,65 @@ +#include "apiUrl.hpp" +#include "hearthstoneApi.hpp" +#include +#include +#include + +class TokenMock { + public: + TokenMock() + : mTokenFilePath{"resources/token_info"}, mUsername{"2b50f1123b424d5e9c21971a110fdd04"}, + mPassword{"MrMkhVMNdOeqPL4Q4XVQAsRPR14J7Yq6"}, mToken{mTokenFilePath, mUsername, mPassword} {} + std::string toString() const { return mToken.toString(); } + Token &getToken() { return mToken; } + + private: + const std::string mTokenFilePath; + const std::string mUsername; + const std::string mPassword; + Token mToken; +}; + +class HearthstoneApiMock { + public: + HearthstoneApiMock() : mHearthstoneApi(std::move(mToken.getToken())) {}; + std::string makeApiRequest(const std::string &iUrl) { return mHearthstoneApi.makeApiRequest(iUrl); } + std::uint64_t numberOfCards(const std::string &iApiResponse) { + return mHearthstoneApi.numberOfCards(iApiResponse); + }; + + private: + TokenMock mToken; + const HearthstoneApi mHearthstoneApi; +}; + +TEST_CASE("Retrieve API Token", "[getApiToken]") { + TokenMock aToken; + const std::string kTokenContent{aToken.toString()}; + const std::string::size_type kTokenSize{kTokenContent.size()}; + REQUIRE(kTokenSize >= 30); + REQUIRE(kTokenSize <= 40); +} + +TEST_CASE("Retrieve number of cards", "[getCardsCount]") { + HearthstoneApiMock aHearthstoneApi; + const std::string kContentType{"cards"}; + const std::string kRegion{"eu"}; + ApiUrl aApiUrl(kContentType, kRegion); + aApiUrl.setLocale("fr_FR"); + aApiUrl.setGameMode("constructed"); + aApiUrl.setPageSize("1"); + std::uint64_t kNumberOfCards{aHearthstoneApi.numberOfCards(aHearthstoneApi.makeApiRequest(aApiUrl()))}; + REQUIRE(kNumberOfCards == 5991); +} + +TEST_CASE("Retrieve cards", "[retrieveCards]") { + HearthstoneApiMock aHearthstoneApi; + const std::string kContentType{"cards"}; + const std::string kRegion{"eu"}; + ApiUrl aApiUrl(kContentType, kRegion); + aApiUrl.setLocale("fr_FR"); + aApiUrl.setGameMode("constructed"); + aApiUrl.setPageSize("10"); + const std::string kApiResponse{aHearthstoneApi.makeApiRequest(aApiUrl())}; + REQUIRE(kApiResponse.size() > 300); +} -- cgit v1.2.3