1 files changed, 48 insertions, 58 deletions

diff --git a/app/utilities.py b/app/utilities.py
index e324161..00dc14a 100644
--- a/app/utilities.py
+++ b/app/utilities.py
@@ -1,7 +1,7 @@
-from typing import Tuple
+from app import app, db
+from typing import Tuple, Sequence
 from random import shuffle, sample
-from app.data import Player, DisplayPlayer, Team, Game
-from app.data import MAX_LEVEL, PLAYER_PER_COURT
+from app.model import Player, DisplayPlayer, Court, DisplayGame, DisplayTeam
 
 
 def _shuffle_two_lists(a: list, b: list) -> Tuple[list, list]:
@@ -25,76 +25,34 @@ def sample_list(indices: list, cost: list[int], count=None) -> list:
     return indices
 
 
-def _create_placeholders(courts: dict, name: str) -> list[Game]:
-    dummy_player = Player(id=-1, first=name)
-    dummy_team = Team(
-        player1=DisplayPlayer(dummy_player), player2=DisplayPlayer(dummy_player)
-    )
-    games = [Game(court, dummy_team, dummy_team) for court in courts]
-    return games
-
-
 def _normalize_skill(level: int, new_max: int) -> int:
-    new_level = round((new_max - 1) * (level / MAX_LEVEL)) + 1
+    new_level = round((new_max - 1) * (level / app.config["MAX_PLAYER_LEVEL"])) + 1
     return new_level
 
 
-def _select_players(players: list[Player], count: int) -> list[Player]:
+def select_players(players: Sequence[Player], count: int) -> list[Player]:
     identifiers = [player.id for player in players]
-    play_count = [int(player.count) for player in players]
+    play_count = [int(player.id) for player in players]
     ids = sample_list(identifiers, play_count, count)
     selected_players = [player for player in players if player.id in ids]
     return selected_players
 
 
-def _create_groups_of_four_players(
-    players: list[Player], new_max: int
-) -> list[list[Player]]:
+def group_by_four(players: list[Player], new_max: int) -> list[list[Player]]:
     identifiers = [player.id for player in players]
     player_levels = [_normalize_skill(int(player.level), new_max) for player in players]
     identifiers = sample_list(identifiers, player_levels)
     court_players = []
-    for i in range(0, len(players), PLAYER_PER_COURT):
-        court_ids = identifiers[i : i + PLAYER_PER_COURT]
+    for i in range(0, len(players), app.config["PLAYERS_PER_COURT"]):
+        court_ids = identifiers[i : i + app.config["PLAYERS_PER_COURT"]]
         selected_players = [player for player in players if player.id in court_ids]
         court_players.append(selected_players)
     return court_players
 
 
-def _create_shuffle_games(
-    courts: dict, players: list[Player], levels: int
-) -> list[Game]:
-    court_players = _create_groups_of_four_players(players, levels)
-    games = []
-    for court, players in zip(courts, court_players):
-        team1 = Team(
-            player1=DisplayPlayer(players[0]), player2=DisplayPlayer(players[3])
-        )
-        team2 = Team(
-            player1=DisplayPlayer(players[1]), player2=DisplayPlayer(players[2])
-        )
-        games.append(Game(court, team1, team2))
-    return games
-
-
-def _create_team_games(courts: dict, teams: dict) -> tuple[list[Game], list[Player]]:
-    games = []
-    selected_players = []
-    for court, (_, players) in zip(courts, teams.items()):
-        players = sample(players, PLAYER_PER_COURT)
-        selected_players += players
-        players.sort(key=lambda x: x.level, reverse=True)
-        team1 = Team(
-            player1=DisplayPlayer(players[0]), player2=DisplayPlayer(players[3])
-        )
-        team2 = Team(
-            player1=DisplayPlayer(players[1]), player2=DisplayPlayer(players[2])
-        )
-        games.append(Game(court, team1, team2))
-    return games, selected_players
-
-
-def separate_teams_and_players(players: list[Player]) -> Tuple[dict, list[Player]]:
+def separate_teams_and_players(
+    players: Sequence[Player],
+) -> tuple[dict[int, list[Player]], list[Player]]:
     unique_team_id = {player.team for player in players}
     grouped_players_by_team = {team_id: [] for team_id in unique_team_id}
     for player in players:
@@ -117,7 +75,39 @@ def separate_teams_and_players(players: list[Player]) -> Tuple[dict, list[Player
     return active_teams, players_without_team
 
 
-def split_courts(courts: dict, n) -> Tuple[dict, dict]:
-    first_half = {k: v for (k, v) in [x for x in courts.items()][:n]}
-    second_half = {k: v for (k, v) in [x for x in courts.items()][n:]}
-    return first_half, second_half
+def get_placeholder_games(courts: list[Court], name: str) -> list[DisplayGame]:
+    p = db.session.query(Player).where(Player.first_name == name).first()
+    if p is None:
+        raise ValueError(f"Database isn't initialized.")
+    dummy_team = DisplayTeam(DisplayPlayer(p), DisplayPlayer(p))
+    games = [DisplayGame(court.id, dummy_team, dummy_team) for court in courts]
+    return games
+
+
+def get_team_games(
+    courts: list[Court], teams: dict[int, list[Player]]
+) -> list[DisplayGame]:
+    games = []
+    for court, (_, players) in zip(courts, teams.items()):
+        players = sample(players, app.config["PLAYER_PER_COURT"])
+        players.sort(key=lambda x: x.level, reverse=True)
+        dp = [DisplayPlayer(p) for p in players]
+        games.append(
+            DisplayGame(court.id, DisplayTeam(dp[0], dp[3]), DisplayTeam(dp[1], dp[2]))
+        )
+    return games
+
+
+def get_shuffle_games(
+    courts: list[Court], players: Sequence[Player], total_levels: int
+) -> list[DisplayGame]:
+    required_player_count = len(courts) * app.config["PLAYER_PER_COURT"]
+    selected_players = select_players(players, required_player_count)
+    court_players = group_by_four(selected_players, total_levels)
+    games = []
+    for court, players in zip(courts, court_players):
+        dp = [DisplayPlayer(p) for p in players]
+        games.append(
+            DisplayGame(court.id, DisplayTeam(dp[0], dp[3]), DisplayTeam(dp[1], dp[2]))
+        )
+    return games