Use std::chrono::steady_clock

1 files changed, 75 insertions, 36 deletions

diff --git a/battleNetApi/src/hearthstoneTokenBuilder.cpp b/battleNetApi/src/hearthstoneTokenBuilder.cpp
index 6307ba5..6b2d30c 100644
--- a/battleNetApi/src/hearthstoneTokenBuilder.cpp
+++ b/battleNetApi/src/hearthstoneTokenBuilder.cpp
@@ -5,15 +5,21 @@
 #include <iostream>
 #include <memory>
 
-namespace bnet {
-HearthstoneTokenBuilder::HearthstoneTokenBuilder(const std::span<std::string> &iJsonPaths) {
+namespace bnet
+{
+HearthstoneTokenBuilder::HearthstoneTokenBuilder(const std::span<std::string>& iJsonPaths)
+{
     _credentialJsonPaths.append_range(iJsonPaths);
 }
-HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
-    for (const std::string &aCredentialJsonPath : _credentialJsonPaths) {
+
+HearthstoneTokenBuilder& HearthstoneTokenBuilder::buildToken()
+{
+    for (const std::string& aCredentialJsonPath : _credentialJsonPaths)
+    {
         std::ifstream aCredentialJsonFile{aCredentialJsonPath};
         json aCredentialJson = json::parse(aCredentialJsonFile);
-        if (isTokenValid(aCredentialJson)) {
+        if (isTokenValid(aCredentialJson))
+        {
             _currentToken = std::make_shared<Token>();
             _currentToken->setText(aCredentialJson["Token"]["Content"]);
             _currentToken->setExpirationTime(
@@ -22,16 +28,20 @@ HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
         }
     }
 
-    if (!_allowBattleNetApiCall) {
+    if (!_allowBattleNetApiCall)
+    {
         return *this;
     }
 
-    for (const std::string &aCredentialJsonPath : _credentialJsonPaths) {
+    for (const std::string& aCredentialJsonPath : _credentialJsonPaths)
+    {
         std::ifstream aCredentialJsonFile{aCredentialJsonPath};
         json aCredentialJson = json::parse(aCredentialJsonFile);
-        _currentToken = std::make_shared<Token>(getTokenWithApi(aCredentialJson));
-        if (_currentToken) {
-            if (_allowUpdateSourceFile) {
+        _currentToken        = std::make_shared<Token>(getTokenWithApi(aCredentialJson));
+        if (_currentToken)
+        {
+            if (_allowUpdateSourceFile)
+            {
                 writeTokenToLocalFile(_currentToken, aCredentialJsonPath);
             }
             break;
@@ -40,31 +50,47 @@ HearthstoneTokenBuilder &HearthstoneTokenBuilder::buildToken() {
     return *this;
 }
 
-std::shared_ptr<Token> HearthstoneTokenBuilder::getToken() { return _currentToken; }
+std::shared_ptr<Token> HearthstoneTokenBuilder::getToken()
+{
+    return _currentToken;
+}
 
-HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowBattleNetApiCall() {
+HearthstoneTokenBuilder& HearthstoneTokenBuilder::allowBattleNetApiCall()
+{
     _allowBattleNetApiCall = true;
     return *this;
 }
-HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowUpdateSourceFile() {
+
+HearthstoneTokenBuilder& HearthstoneTokenBuilder::allowUpdateSourceFile()
+{
     _allowUpdateSourceFile = true;
     return *this;
 }
-HearthstoneTokenBuilder &HearthstoneTokenBuilder::allowExpiredToken() {
+
+HearthstoneTokenBuilder& HearthstoneTokenBuilder::allowExpiredToken()
+{
     _allowExpiredToken = true;
     return *this;
 }
-bool HearthstoneTokenBuilder::isUpdateSourceFileAllowed() const { return _allowUpdateSourceFile; }
 
-bool HearthstoneTokenBuilder::isTokenValid(const json &iTokenJson) const {
+bool HearthstoneTokenBuilder::isUpdateSourceFileAllowed() const
+{
+    return _allowUpdateSourceFile;
+}
+
+bool HearthstoneTokenBuilder::isTokenValid(const json& iTokenJson) const
+{
     if (not iTokenJson.contains("Token") or not iTokenJson["Token"].contains("ExpirationTime") or
-        not iTokenJson["Token"].contains("Content")) {
+        not iTokenJson["Token"].contains("Content"))
+    {
         return false;
     }
-    if (iTokenJson["Token"]["Content"].get<std::string>().length() < kTOKEN_CONTENT_MIN_LENGTH) {
+    if (iTokenJson["Token"]["Content"].get<std::string>().length() < kTOKEN_CONTENT_MIN_LENGTH)
+    {
         return false;
     }
-    if (_allowExpiredToken) {
+    if (_allowExpiredToken)
+    {
         return true;
     }
     const std::uint64_t kExpirationTime{iTokenJson["Token"]["ExpirationTime"]};
@@ -75,41 +101,52 @@ bool HearthstoneTokenBuilder::isTokenValid(const json &iTokenJson) const {
     return kCurrentTime <= kExpirationTime;
 }
 
-std::chrono::seconds HearthstoneTokenBuilder::getCurrentTime() const {
+std::chrono::seconds HearthstoneTokenBuilder::getCurrentTime() const
+{
     return std::chrono::duration_cast<std::chrono::seconds>(
-        std::chrono::utc_clock::now().time_since_epoch());
+        std::chrono::steady_clock::now().time_since_epoch());
 }
 
-Token HearthstoneTokenBuilder::getTokenWithApi(const std::string &iCredentialsJsonFilePath) const {
+Token HearthstoneTokenBuilder::getTokenWithApi(const std::string& iCredentialsJsonFilePath) const
+{
     std::ifstream aAgentJsonFile{iCredentialsJsonFilePath};
     json aCredentials = json::parse(aAgentJsonFile);
     return getTokenWithApi(aCredentials);
 }
 
-size_t HearthstoneTokenBuilder::curlCallbackStringOutput(void *iPtr, size_t iSize, size_t iNmemb,
-                                                         std::string *iUserData) {
+size_t HearthstoneTokenBuilder::curlCallbackStringOutput(void* iPtr,
+                                                         size_t iSize,
+                                                         size_t iNmemb,
+                                                         std::string* iUserData)
+{
     size_t newLength{iSize * iNmemb};
-    try {
-        iUserData->append(static_cast<char *>(iPtr), newLength);
-    } catch (std::bad_alloc &e) {
+    try
+    {
+        iUserData->append(static_cast<char*>(iPtr), newLength);
+    }
+    catch (std::bad_alloc& e)
+    {
         // handle memory problem
         return 0;
     }
     return newLength;
 }
 
-Token HearthstoneTokenBuilder::getTokenWithApi(const json &iCredentials) const {
+Token HearthstoneTokenBuilder::getTokenWithApi(const json& iCredentials) const
+{
     if (not iCredentials.contains("Agent") or not iCredentials["Agent"].contains("Username") or
-        not iCredentials["Agent"].contains("Password")) {
+        not iCredentials["Agent"].contains("Password"))
+    {
         std::cerr << "Please define Agent/Username and Agent/Password in the "
                      "JSON credentials file\n";
         std::exit(EXIT_FAILURE);
     }
     const std::string aAgentUsername{iCredentials["Agent"]["Username"]};
     const std::string aAgentPassword{iCredentials["Agent"]["Password"]};
-    CURL *aCurl{curl_easy_init()};
+    CURL* aCurl{curl_easy_init()};
     std::string aTokenInfo;
-    if (aCurl and not aAgentUsername.empty() and not aAgentPassword.empty()) {
+    if (aCurl and not aAgentUsername.empty() and not aAgentPassword.empty())
+    {
         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);
@@ -120,7 +157,8 @@ Token HearthstoneTokenBuilder::getTokenWithApi(const json &iCredentials) const {
         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) {
+        if (result_code != CURLE_OK)
+        {
             std::cerr << "ERROR: token request failed\n";
             std::exit(EXIT_FAILURE);
         }
@@ -131,11 +169,12 @@ Token HearthstoneTokenBuilder::getTokenWithApi(const json &iCredentials) const {
         .setLifetime(std::chrono::seconds{aTokenJson["expires_in"]});
 }
 
-void HearthstoneTokenBuilder::writeTokenToLocalFile(std::shared_ptr<Token> &iToken,
-                                                    const std::string &iTokenFileOutputPath) const {
+void HearthstoneTokenBuilder::writeTokenToLocalFile(std::shared_ptr<Token>& iToken,
+                                                    const std::string& iTokenFileOutputPath) const
+{
     std::ifstream aTokenFile{iTokenFileOutputPath};
-    json aCredentialsFile = json::parse(aTokenFile);
-    aCredentialsFile["Token"]["Content"] = iToken->text();
+    json aCredentialsFile                       = json::parse(aTokenFile);
+    aCredentialsFile["Token"]["Content"]        = iToken->text();
     aCredentialsFile["Token"]["ExpirationTime"] = iToken->expirationTime()->count();
     std::ofstream aTokenFileOutput{iTokenFileOutputPath};
     aTokenFileOutput << std::setw(4) << aCredentialsFile;