Merge pull request #8 from DataStrike/7-mise-en-place-de-la-récup-dun-fichier

mise en place de la récup dun fichier

Author: Zat-Code

src/log_analyser/log_analyser.py

@@ -5,10 +5,11 @@
 
 class LogAnalyser:
 
-    def __init__(self, path_csv, name) -> None:
+    def __init__(self, path, name, team_id) -> None:
 
-        self.path_csv = path_csv
+        self.path_csv = "{}/{}".format(path, name)
         self.name = name
+        self.team_id = team_id
 
         self.date = self.name2datetime()
 
@@ -48,8 +49,10 @@ def process_map_start(self, data):
                        "map_type": data[4],
                        "team1_name": data[5],
                        "team2_name": data[6],
-                       "score_team1": 0,
-                       "score_team2": 0,
+                       "team1_score": 0,
+                       "team2_score": 0,
+                       "team_id": self.team_id,
+                       "events": []
                        })
 
         self.actions = {"match_start": self.process_map_start,

src/log_analyser/objects/map.py

@@ -14,8 +14,10 @@ def __init__(self, **kwargs):
                        "map_type": str,
                        "team1_name": str,
                        "team2_name": str,
-                       "score_team1": int,
-                       "score_team2": int,
+                       "team1_score": int,
+                       "team2_score": int,
+                       "team_id": str,
+                       "events": list,
                        }
 
         super().__init__(data_schema, **kwargs)
@@ -27,12 +29,15 @@ def add_round(self, data):
         teams = {}
         teams[self.team1_name] = Team.from_json({"name": self.team1_name, "players": {}})
         teams[self.team2_name] = Team.from_json({"name": self.team2_name, "players": {}})
-        self.rounds.append(Round.from_json({"teams": teams, "start_time": data[2], "objective_captured": [], "objective_progress": []}))
+        self.rounds.append(Round.from_json({"teams": teams, "start_time": data[2], "end_time": "", "objective_captured": [], "objective_progress": []}))
+
+        # self.events.append({"type": "round_start", "timestamp": data[2], "value": 1, "description": "Round {} start".format(len(self.rounds))})
 
         self.actual_round += 1
 
         print("###### NEW ROUND {} #######".format(self.actual_round))
 
+
     def add_player(self, data):
 
         if data["player_name"] in self.rounds[self.actual_round].teams[data["team_name"]].players:
@@ -74,15 +79,22 @@ def add_kill(self, data):
         self.rounds[self.actual_round].teams[data[3]].players[data[4]].characters[data[5]].add_kill(killer_data)
         self.rounds[self.actual_round].teams[data[6]].players[data[7]].characters[data[8]].add_death(victim_data)
 
+        team = self.find_team_for_player(data[4])
+
+        if team == list(self.rounds[self.actual_round].teams.keys())[0]:
+            self.events.append({"type": "kill_team1", "timestamp": data[2], "value": 1, "description": "{} kill {}".format(data[4], data[7])})
+        else:
+            self.events.append({"type": "kill_team2", "timestamp": data[2], "value": 1,
+                                "description": "{} kill {}".format(data[4], data[7])})
     def add_player_stat(self, data):
 
         # self.create_if_player_and_caracter_not_exist(data[4], data[5], data[6])
 
-        player_data = {"eliminations": data[6], "final_blows": data[7], "deaths": data[8], "damage": data[9],
-                       "barrier_damage": data[10], "hero_damage": data[11], "healing": data[12], "healing_receive": data[13],
-                       "self_healing": data[14], "damage_taken": data[15], "damage_blocked": data[16], "defensive_assist": data[17],
-                       "offensive_assists": data[18], "ultimated_earn": data[19], "ultimates_used": data[20], "solo_kills": data[23],
-                       "critical_hits_accuracy": data[28], "weapon_accuracy": data[37], "hero_time_played": data[38]}
+        player_data = {"eliminations": data[7], "final_blows": data[8], "deaths": data[9], "damage": data[10],
+                       "barrier_damage": data[11], "hero_damage": data[12], "healing": data[13], "healing_receive": data[14],
+                       "self_healing": data[15], "damage_taken": data[16], "damage_blocked": data[17], "defensive_assist": data[18],
+                       "offensive_assists": data[19], "ultimated_earn": data[20], "ultimates_used": data[21], "solo_kills": data[24],
+                       "critical_hits_accuracy": data[29], "weapon_accuracy": data[38], "hero_time_played": data[39]}
 
         if player_data["hero_time_played"] != "0" and data[6] in self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters:
             self.rounds[self.actual_round].teams[data[4]].players[data[5]].characters[data[6]].add_character_stats(player_data)
@@ -139,22 +151,34 @@ def add_objective_progress(self, data):
 
     def end_round(self, data):
 
-        end_round_data = {"time": data[2], "score_team1": data[5], "score_team2": data[6]}
-
+        end_round_data = {"time": data[2], "team1_score": data[5], "team2_score": data[6]}
+        self.rounds[self.actual_round].end_time = data[2]
         for team in self.rounds[self.actual_round].teams:
             for player in self.rounds[self.actual_round].teams[team].players:
                 for character in self.rounds[self.actual_round].teams[team].players[player].characters:
                     if not "end" in self.rounds[self.actual_round].teams[team].players[player].characters[character].played_time[-1]:
                         self.rounds[self.actual_round].teams[team].players[player].characters[character].played_time[-1]["end"] = end_round_data["time"]
 
 
-        self.score_team1 = end_round_data["score_team1"]
-        self.score_team2 = end_round_data["score_team2"]
+        self.team1_score = end_round_data["team1_score"]
+        self.team2_score = end_round_data["team2_score"]
+        print(" score team 1 : ", self.team1_score)
+        print(" score team 2 : ", self.team2_score)
         print("###### END ROUND {} #######\n".format(self.actual_round))
 
+
     def end_map(self, data):
 
-        end_map_data = {"time": data[2], "score_team1": data[4], "score_team2": data[5]}
+        end_map_data = {"time": data[2], "team1_score": data[4], "team2_score": data[5]}
+
+        self.team1_score = end_map_data["team1_score"]
+        self.team2_score = end_map_data["team2_score"]
+
+
+    def find_team_for_player(self, player_name):
+
+        for team in self.rounds[self.actual_round].teams:
+            if player_name in self.rounds[self.actual_round].teams[team].players:
+                return team
 
-        self.score_team1 = end_map_data["score_team1"]
-        self.score_team2 = end_map_data["score_team2"]
+        return None

src/log_analyser/objects/object.py

@@ -56,7 +56,7 @@ def export_json(self):
             else:
                 dict_class_final[key] = self.export_json_recursive(value)
         # return json.dumps(dict_class_final, indent=4, sort_keys=True, default=str)
-        return json.dumps(dict_class_final, skipkeys=False, ensure_ascii=True, check_circular=True)
+        return dict_class_final
     def convert_timefile_to_datetime(self, time_string):
 
 

src/log_analyser/objects/round.py

@@ -8,6 +8,7 @@ def __init__(self, **kwargs):
 
         data_schema = {"teams": dict,
                        "start_time": str,
+                       "end_time": str,
                        "objective_captured": list,
                        "objective_progress": list
                        }

src/main.py

@@ -22,10 +22,24 @@ def __init__(self):
     def on_callback_test(self, topic, data):
         print("message receive : ", topic, data)
 
-        la = LogAnalyser('logs/Log-2023-12-22-21-12-32.txt', "Log-2023-12-22-21-12-32.txt")
-        la.run()
-        self.producer_thread.send("analyse.report", la.map.export_json())
+        filePath = data["filePath"]
+        fileName = data["fileName"]
+        teamId = data["teamId"]
 
+        if self.check_txt_extension(fileName):
+
+            la = LogAnalyser(filePath, fileName, teamId)
+            la.run()
+            if la.map != None:
+                self.producer_thread.send("analyse.report", la.map.export_json())
+            else:
+                self.producer_thread.send("analyse.report", {"error": "File txt not correct"})
+
+        else:
+            self.producer_thread.send("analyse.report", {"error": "File extension not correct"})
+
+    def check_txt_extension(self, filename):
+        return filename.lower().endswith('.txt')
     def run(self):
 
         while self.running: