Add rank display

Author: Philaeux

src/dota_notes/data/states/game_state.py

@@ -157,6 +157,12 @@ def enrich_players_with_stratz_info(self, json):
             if f"p{player.steam_id}" in json["data"]:
                 extra_info = json["data"][f"p{player.steam_id}"]
 
+                if ("performance" in extra_info and extra_info["performance"] is not None
+                        and "rank" in extra_info["performance"] and extra_info["performance"]["rank"] is not None
+                        and isinstance(extra_info["performance"]["rank"], int)):
+                    player.medal = extra_info["performance"]["rank"]
+                else:
+                    player.medal = 0
                 if "matchCount" in extra_info and extra_info["matchCount"] is not None:
                     player.match_count = extra_info["matchCount"]
                 if "steamAccount" in extra_info and extra_info["steamAccount"] is not None:

src/dota_notes/data/states/player_state.py

@@ -6,6 +6,7 @@ class PlayerState(QObject):
     steam_id = 0
     avatar = ""
     account_level = None
+    medal = None
     country_code = ""
     name = ""
     pro_name = None
@@ -21,10 +22,9 @@ class PlayerState(QObject):
     destroys_items = False
     note = ""
 
-    ATTRIBUTES_FOR_COPY = ["steam_id", "avatar", "account_level", "country_code",
+    ATTRIBUTES_FOR_COPY = ["steam_id", "avatar", "account_level", "medal", "country_code",
                            "pro_name", "custom_name", "match_count", "smurf", "smurf_stratz",
-                           "is_racist",
-                           "is_sexist", "is_toxic", "is_feeder", "gives_up", "destroys_items", "note"]
+                           "is_racist", "is_sexist", "is_toxic", "is_feeder", "gives_up", "destroys_items", "note"]
 
     def copy_from(self, from_object):
         """Copy attributes from another object into this
@@ -55,6 +55,8 @@ def enrich_with_stratz_account_info(self, account):
             self.name = account["name"]
         else:
             self.name = "< HIDDEN ACCOUNT >"
+        if "isAnonymous" in account and isinstance(account["isAnonymous"], bool) and account["isAnonymous"]:
+            self.medal = 0
 
         if "proSteamAccount" in account and account["proSteamAccount"] is not None:
             pro_steam_account = account["proSteamAccount"]

src/dota_notes/helpers.py

@@ -22,6 +22,7 @@ def get_steam_live_game_stats(api_key, server_id):
         print(f"Error occurred while fetching data: {e}")
         return None
 
+
 def exec_stratz_graphql_query(token: str, query: str):
     """Execute a graphql query on stratz endpoint.
 
@@ -62,9 +63,13 @@ def stratz_get_players_info(token: str, players: list[int]):
     full_query = f"""fragment playerProfile on PlayerType {{
                        steamAccountId
                        matchCount
+                       performance {{
+                         rank
+                       }}
                        steamAccount {{
                          avatar
                          name
+                         isAnonymous
                          dotaAccountLevel
                          smurfFlag
                          countryCode
@@ -147,6 +152,7 @@ def stratz_get_live_game(token: str, match_id: int):
                           }}
                           countryCode
                           name
+                          isAnonymous
                         }}
                       }}
                     }}

src/dota_notes/ui/app_qt.py

@@ -18,16 +18,24 @@
 
 
 class QtApp:
-    """Qt application process"""
+    """Qt application process
+
+    Attributes
+        dota_notes: link to the main object of the application
+        app: QT app
+        window: QT Main window of the application
+        last_selected_index: index of the last selected player
+        last_selected_player: data of the last selected player
+    """
 
     def __init__(self, dota_notes):
         self.dota_notes = dota_notes
 
         # Build Qt app components
         self.app = QApplication(sys.argv)
         self.window = MainWindow()
-        self.lastSelectedIndex = 0
-        self.lastSelectedState = None
+        self.last_selected_index = 0
+        self.last_selected_player = None
 
         # Connect actions
         self.window.actionSettings.triggered.connect(self.on_open_settings)
@@ -60,6 +68,7 @@ def __init__(self, dota_notes):
         self.window.show()
 
     def run(self):
+        """Start the QT application, enter the event loop and add a periodic dequeue of messages"""
         timer = QTimer()
         timer.timeout.connect(self.process_queues)
         timer.start(100)
@@ -68,6 +77,7 @@ def run(self):
         return return_code
 
     def process_queues(self):
+        """Periodic process that checks message queues and process necessary jobs"""
         while not self.dota_notes.message_queue_qt.empty():
             message = self.dota_notes.message_queue_qt.get(block=False)
             if isinstance(message, MessageGSI):
@@ -90,6 +100,7 @@ def process_queues(self):
                     self.window.draw_status_message("No game found for player " + self.window.inputSteamId.text())
 
     def on_open_settings(self):
+        """User opens the settings panel"""
         settings = self.dota_notes.settings
         self.window.comboBoxSettingsMode.setCurrentText(settings.software_mode)
         self.window.lineEditStratzToken.setText(settings.stratz_token)
@@ -99,6 +110,7 @@ def on_open_settings(self):
         self.window.centralStackedWidget.setCurrentIndex(1)
 
     def on_settings_save(self):
+        """User saves settings modifications"""
         settings = self.dota_notes.settings
         settings.software_mode = self.window.comboBoxSettingsMode.currentText()
         settings.stratz_token = self.window.lineEditStratzToken.text()
@@ -111,30 +123,36 @@ def on_settings_save(self):
         self.window.centralStackedWidget.setCurrentIndex(0)
 
     def on_settings_cancel(self):
+        """User cancels settings modifications"""
         self.window.centralStackedWidget.setCurrentIndex(0)
 
     def on_connect_client(self):
+        """User clicks on connect button"""
         self.window.buttonConnect.setVisible(False)
         message = MessageConnect(self.dota_notes.settings.steam_user, self.dota_notes.settings.steam_password)
         self.dota_notes.message_queue_dota.put(message)
 
     def on_disconnect_client(self):
+        """User clicks on disconnect button"""
         message = MessageDisconnect()
         self.dota_notes.message_queue_dota.put(message)
 
     def on_label_click(self, label_name, label_text):
+        """User clicks on a specific label"""
         row = 0
         for char in label_name:
             if char.isdigit():
                 row = int(char)
         self.on_select_player(row)
 
     def on_select_player(self, player_slot):
-        self.lastSelectedIndex = player_slot
-        self.lastSelectedState = self.dota_notes.state.players[player_slot]
-        self.window.draw_details_with_player(self.lastSelectedState)
+        """User select a player to have info off"""
+        self.last_selected_index = player_slot
+        self.last_selected_player = self.dota_notes.state.players[player_slot]
+        self.window.draw_details_with_player(self.last_selected_player)
 
     def on_steam_live(self):
+        """Look for a live game a player is in"""
         steam_id = self.window.inputSteamId.text()
         if self.is_valid_search(steam_id):
             steam_id = SteamID(steam_id)
@@ -204,13 +222,14 @@ def on_stratz_info(self):
         if json is not None:
             self.dota_notes.state.enrich_players_with_stratz_info(json)
             self.window.draw_match_with_state(self.dota_notes.state)
-            self.on_select_player(self.lastSelectedIndex)
+            self.on_select_player(self.last_selected_index)
             self.window.draw_status_message("Updated player with Stratz info.")
         else:
             self.window.draw_status_message("Error while fetching player info from Stratz.")
 
     def on_save_player_details(self):
-        player_state = self.lastSelectedState
+        """User press 'save' on the player detail page"""
+        player_state = self.last_selected_player
         player_state.custom_name = self.window.inputDetailsCustomName.text()
         player_state.smurf = self.window.comboBoxDetailsSmurf.currentText()
         player_state.is_racist = self.window.checkBoxDetailsRacist.isChecked()
@@ -220,7 +239,7 @@ def on_save_player_details(self):
         player_state.gives_up = self.window.checkBoxDetailsGivesUp.isChecked()
         player_state.destroys_items = self.window.checkBoxDetailsDestroysItems.isChecked()
         player_state.note = self.window.inputDetailsNote.toPlainText()
-        self.window.draw_match_player(self.lastSelectedIndex, player_state)
+        self.window.draw_match_player(self.last_selected_index, player_state)
         with Session(self.dota_notes.database.engine) as session:
             player_info = session.get(PlayerEntity, str(player_state.steam_id))
             if player_info is None: