Write ratings to database.

Author: Sneer-ra2

CMakeLists.txt

@@ -1,6 +1,6 @@
 
 cmake_minimum_required(VERSION 3.14)
-project(CnCNet_ELO VERSION 1.0.2 LANGUAGES CXX)
+project(CnCNet_ELO VERSION 1.0.3 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

databaseconnection.cpp

@@ -842,3 +842,107 @@ uint32_t DatabaseConnection::getBaseAccount(const std::set<uint32_t>& userIds, c
     Log::fatal() << "No base account found among user ids " << userIds << ".";
     throw std::runtime_error("No base account. Cannot continue;");
 }
+
+/*!
+ */
+void DatabaseConnection::writePlayerRatings(
+    gamemodes::GameMode gameMode,
+    const Players &players,
+    std::map<uint32_t, uint32_t> activeRanks,
+    std::map<uint32_t, uint32_t> allTimeRanks)
+{
+    try
+    {
+        // Check if expected columns exist.
+        std::set<std::string> requiredColumns = {
+            "user_id", "ladder_id", "rating", "elo_rank",
+            "alltime_rank", "rated_games", "active", "created_at", "updated_at"
+        };
+
+        std::unique_ptr<sql::PreparedStatement> checkStmt(
+            _connection->prepareStatement(R"SQL(
+                SELECT COLUMN_NAME
+                FROM information_schema.columns
+                WHERE table_schema = DATABASE() AND table_name = 'user_ratings'
+            )SQL")
+        );
+
+        std::unique_ptr<sql::ResultSet> columnResult(checkStmt->executeQuery());
+        std::set<std::string> actualColumns;
+
+        while (columnResult->next())
+        {
+            actualColumns.insert(columnResult->getString("COLUMN_NAME"));
+        }
+
+        for (const std::string &col : requiredColumns)
+        {
+            if (!actualColumns.contains(col))
+            {
+                Log::warning() << "Unable to write player ratings due to missing column '" << col << "' in 'user_ratings'.";
+                return;
+            }
+        }
+
+        // Clear table.
+        std::unique_ptr<sql::PreparedStatement> truncateStmt(
+            _connection->prepareStatement("TRUNCATE TABLE user_ratings")
+        );
+        truncateStmt->execute();
+        Log::info() << "Table 'user_ratings' truncated.";
+
+        // Get ladder id.
+        uint32_t ladderId = 0;
+        std::unique_ptr<sql::PreparedStatement> ladderStmt(
+            _connection->prepareStatement("SELECT id FROM ladders WHERE abbreviation = ? LIMIT 1")
+        );
+        ladderStmt->setString(1, _ladder);
+        std::unique_ptr<sql::ResultSet> ladderResult(ladderStmt->executeQuery());
+
+        if (ladderResult->next())
+        {
+             ladderId = ladderResult->getUInt("id");
+        }
+        else
+        {
+            Log::fatal() << "Ladder '" << _ladder << "' not found in table 'ladders'.";
+            return;
+        }
+
+        // Prepare statement to save user data.
+        std::unique_ptr<sql::PreparedStatement> insertStmt(
+            _connection->prepareStatement(R"SQL(
+                INSERT INTO user_ratings
+                (user_id, ladder_id, rating, elo_rank, alltime_rank, rated_games, active, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, NOW(), NOW())
+            )SQL")
+        );
+
+        for (uint32_t userId : players.userIds())
+        {
+            const Player &player = players[userId];
+            uint32_t gameCount = player.gameCount();
+            double elo = (gameMode == gamemodes::Blitz2v2) ? player.elo(factions::Combined) : player.maxRating(!player.isActive());
+            if (elo < 0.0)
+            {
+                // Try to get any rating, even if the player was never active.
+                elo = player.elo(factions::Combined);
+            }
+            insertStmt->setUInt(1, userId);
+            insertStmt->setUInt(2, ladderId);
+            insertStmt->setInt(3, static_cast<int>(std::round(elo)));
+            insertStmt->setUInt(4, activeRanks.contains(userId) ? activeRanks[userId] : 0);
+            insertStmt->setUInt(5, allTimeRanks.contains(userId) ? allTimeRanks[userId] : 0);
+            insertStmt->setUInt(6, gameCount);
+            insertStmt->setBoolean(7, player.isActive());
+
+            insertStmt->execute();
+        }
+
+        Log::info() << "Player ratings written to 'user_ratings'.";
+    }
+    catch (sql::SQLException &e)
+    {
+        Log::fatal() << "Error while writing user ratings: " << e.what();
+    }
+}

databaseconnection.h

@@ -72,6 +72,9 @@ class DatabaseConnection
     //! one of the invalid user ids.
     uint32_t getBaseAccount(const std::set<uint32_t>& userIds, const std::set<uint32_t> &invalidUserIds);
 
+    //! Write data to table user_ratings;
+    void writePlayerRatings(gamemodes::GameMode gameMode, const Players &players, std::map<uint32_t, uint32_t> activeRanks, std::map<uint32_t, uint32_t> allTimeRanks);
+
 private:
     //! Is the connection ready?
     bool _ready;

main.cpp

@@ -339,14 +339,14 @@ int main(int argc, char* argv[])
 
     Log::info(lastProcessedGame != nullptr) << "Last game processed: " << *lastProcessedGame;
 
-    if (!options.dryRun)
-    {
-        players.exportActivePlayers(options.outputDirectory, options.gameMode);
-        players.exportBestOfAllTime(options.outputDirectory, options.gameMode);
-        players.exportMostDaysActive(options.outputDirectory, options.gameMode);
-        players.exportAlphabeticalOrder(options.outputDirectory, options.gameMode);
-        players.exportNewPlayers(options.outputDirectory, options.gameMode);
-    }
+    if (options.dryRun)
+        return 0;
+
+    std::map<uint32_t, uint32_t> activeRanks = players.exportActivePlayers(options.outputDirectory, options.gameMode);
+    std::map<uint32_t, uint32_t> allTimeRanks = players.exportBestOfAllTime(options.outputDirectory, options.gameMode);
+    players.exportMostDaysActive(options.outputDirectory, options.gameMode);
+    players.exportAlphabeticalOrder(options.outputDirectory, options.gameMode);
+    players.exportNewPlayers(options.outputDirectory, options.gameMode);
 
     for (auto it = ignoredMaps.begin(); it != ignoredMaps.end(); ++it)
     {
@@ -374,6 +374,12 @@ int main(int argc, char* argv[])
         stats.exportMapsPlayed(options.outputDirectory);
         players.exportPlayerDetails(options.outputDirectory, {}, games, options.ladderAbbreviation);
     }
+    Log::info() << "Exported map stats.";
+
+    // Player ratings.
+    Log::info() << "Updating table `user_ratings`.";
+    connection.writePlayerRatings(options.gameMode, players, activeRanks, allTimeRanks);
 
+    Log::info() << "All done.";
     return 0;
 }

players.cpp

@@ -40,6 +40,21 @@ bool Players::exists(const std::string &playerName)
     return _nickToUserId.contains(playerName);
 }
 
+/*!
+ */
+std::vector<uint32_t> Players::userIds() const
+{
+    std::vector<uint32_t> userIds;
+    userIds.reserve(_players.size());
+
+    for (const auto& [userId, player] : _players)
+    {
+        userIds.push_back(userId);
+    }
+
+    return userIds;
+}
+
 /*!
  */
 Player& Players::operator[](uint32_t index)
@@ -208,10 +223,11 @@ uint32_t Players::activePlayerCount() const
 
 /*!
  */
-void Players::exportActivePlayers(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const
+std::map<uint32_t, uint32_t> Players::exportActivePlayers(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const
 {
     Log::info() << "Exporting list of active players.";
 
+    std::map<uint32_t, uint32_t> rankByUserId;
     using json = nlohmann::json;
     json data = json::object();
 
@@ -353,24 +369,28 @@ void Players::exportActivePlayers(const std::filesystem::path &directory, gamemo
         }
 
         players.push_back(jsonPlayer);
+        rankByUserId[player->userId()] = i + 1;
     }
 
     data["data"] = players;
 
     std::ofstream stream(directory / (gamemodes::shortName(gameMode) + "_active_players.json"));
     stream << std::setw(4) << data << std::endl;
     stream.close();
+
+    return rankByUserId;
 }
 
 /*!
  */
-void Players::exportBestOfAllTime(
+std::map<uint32_t, uint32_t> Players::exportBestOfAllTime(
     const std::filesystem::path &directory,
     gamemodes::GameMode gameMode) const
 {
     Log::info() << "Exporting best players of all time.";
 
     std::vector<const Player*> filteredAndSortedPlayers;
+    std::map<uint32_t, uint32_t> rankByUserId;
 
     for (auto it = _players.cbegin(); it != _players.cend(); ++it)
     {
@@ -434,12 +454,15 @@ void Players::exportBestOfAllTime(
         jsonPlayer["status"] = player->isActive() ? "ACTIVE" : "INACTIVE";
 
         players.push_back(jsonPlayer);
+        rankByUserId[player->userId()] = i + 1;
     }
     data["data"] = players;
 
     std::ofstream stream(directory / (gamemodes::shortName(gameMode) + "_bestofalltime.json"));
     stream << std::setw(4) << data << std::endl;
     stream.close();
+
+    return rankByUserId;
 }
 
 /*!

players.h

@@ -34,6 +34,9 @@ class Players
     //! Returns 0 if no player is found.
     uint32_t userId(const std::string &nick, const std::string &ladderName) const;
 
+    //! Get all user ids.
+    std::vector<uint32_t> userIds() const;
+
     //! Get the index of a player based on his alias.
     //! Returns 0 if no player is found.
     uint32_t userIdFromAlias(const std::string &alias) const;
@@ -68,10 +71,11 @@ class Players
     // Exporting methods for actual rankings.
 public:
     //! Export list of active players, sorted by rating. The is the actual ELO list.
-    void exportActivePlayers(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const;
+    //! Returns rank for each user id.
+    std::map<uint32_t, uint32_t> exportActivePlayers(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const;
 
-    //! Make list of best players of all time.
-    void exportBestOfAllTime(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const;
+    //! Make list of best players of all time. Returns rank for each user id.
+    std::map<uint32_t, uint32_t> exportBestOfAllTime(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const;
 
     //! Most active players aka most loyal players.
     void exportMostDaysActive(const std::filesystem::path &directory, gamemodes::GameMode gameMode) const;