Merge branch 'feature/db' into 'develop'

Full Functionality

See merge request KaranJayachandra/match_up!2

1 files changed, 97 insertions, 144 deletions

diff --git a/model.py b/model.py
index c83bcfd..c69ba48 100644
--- a/model.py
+++ b/model.py
@@ -1,183 +1,136 @@
 from math import floor
 from csv import reader
-from pathlib import Path
-from random import sample
-from operator import attrgetter
+from typing import Tuple
+from time import time, strftime
 from dataclasses import dataclass
 
-
-@dataclass
-class Court:
-    number: int
-    status: bool
-
-
-@dataclass
-class CourtList:
-    total: int
-
-    def __post_init__(self):
-        self.courts = [Court(i + 1, True) for i in range(self.total)]
-
-    def get_court(self, court_number: int):
-        return [court for court in self.courts if court.number == court_number]
-
-    def toggle_court(self, court_number: int):
-        self.courts = [
-            (
-                Court(
-                    number=court_number,
-                    status=not court.status,
-                )
-                if court_number == court.number
-                else court
-            )
-            for court in self.courts
-        ]
+MIN_LEVEL = 1
+MAX_LEVEL = 10
+PLAYER_PER_COURT = 4
 
 
 @dataclass
 class Player:
     name: str
-    skill: int = 0
-    status: bool = True
-
-
-def create_player_from_row(row: list[str]) -> Player:
-    return Player(name=row[0], skill=row[1], status=(row[2] == "True"))
-
-
-class PlayerList:
-
-    def __init__(self, location: Path = "players.csv"):
-        with open(location, newline="") as file:
-            data_reader = reader(file)
-            next(data_reader, None)
-            players = [create_player_from_row(row) for row in data_reader]
-        players.sort(key=attrgetter("name"))
-        self.players = players
-
-    def get_player(self, player_request: str):
-        players = [player for player in self.players if player.name == player_request]
-        players.sort(key=attrgetter("name"))
-        return players
-
-    def get_active_players(self):
-        players = [player for player in self.players if player.status]
-        players.sort(key=attrgetter("name"))
-        return players
-
-    def toggle_player(self, player_request: Player):
-        self.players = [
-            (
-                Player(
-                    name=player.name,
-                    skill=player.skill,
-                    status=not player.status,
-                )
-                if player.name == player_request
-                else player
-            )
-            for player in self.players
-        ]
-
-    def __str__(self):
-        display_string = ""
-        for player in self.players:
-            display_string += player.__str__() + "\n"
-        return display_string
+    skill: int = 1
+    status: bool = False
 
 
 @dataclass
 class Team:
-    player1: Player
-    player2: Player
+    player1: str
+    player2: str
 
 
 @dataclass
 class Game:
-    court: Court
+    court: int
     team1: Team
     team2: Team
 
 
-DUMMY_PLAYER = Player(name="-")
-DUMMY_TEAM = Team(player1=DUMMY_PLAYER, player2=DUMMY_PLAYER)
+@dataclass
+class CourtList:
+    total: int
 
+    def __post_init__(self) -> None:
+        self.courts = {i + 1: True for i in range(self.total)}
 
-def create_dummy_games(courts: list[Court]):
-    return [Game(court, DUMMY_TEAM, DUMMY_TEAM) for court in courts]
+    def get_court_status(self, court_number: int) -> bool:
+        return self.courts[court_number]
 
+    def toggle_court_status(self, court_number: int) -> None:
+        new_status = not self.courts[court_number]
+        self.courts[court_number] = new_status
+        return new_status
 
-RESERVED_PLAYER = Player(name="Reserved")
-RESERVED_TEAM = Team(player1=RESERVED_PLAYER, player2=RESERVED_PLAYER)
+    def get_courts(self) -> dict:
+        return self.courts
 
+    def separate_courts(self) -> Tuple[dict, dict]:
+        active_courts = {k: v for k, v in self.courts.items() if v}
+        inactive_courts = {k: v for k, v in self.courts.items() if not v}
+        return active_courts, inactive_courts
 
-def create_reserved_games(courts: list[Court]):
-    return [Game(court, RESERVED_TEAM, RESERVED_TEAM) for court in courts]
 
+@dataclass
+class PlayerList:
+    location: str
+    guests: int = 0
 
-PLAYER_PER_COURT = 4
+    def __post_init__(self) -> None:
+        with open("data/" + self.location, newline="") as file:
+            pointer = reader(file)
+            next(pointer, None)
+            players = {
+                id: Player(row[0], int(row[1])) for id, row in enumerate(pointer)
+            }
+        self.guest_id_start = len(players) + 1
+        self.players = players
 
+    def increment_guests(self):
+        self.guests = self.guests + 1
+        return self.guests
 
-def create_single_game(court: Court, players: list[Player]):
-    team1 = Team(player1=players[0], player2=players[3])
-    team2 = Team(player1=players[1], player2=players[2])
-    return Game(court, team1, team2)
+    def decrement_guests(self):
+        if self.guests == 0:
+            return 0
+        self.guests = self.guests - 1
+        return self.guests
 
+    def get_player_status(self, player_number: int) -> bool:
+        return self.players[player_number].status
 
-def create_possible_games(court_list: list[Court], players: list[Player]):
-    clumped_players = [
-        players[i : i + PLAYER_PER_COURT]
-        for i in range(0, len(players), PLAYER_PER_COURT)
-    ]
-    games = [
-        create_single_game(court, clump)
-        for court, clump in zip(court_list, clumped_players)
-    ]
-    return games
+    def toggle_player_status(self, player_number: int) -> Tuple[bool, str]:
+        new_status = not self.players[player_number].status
+        self.players[player_number].status = new_status
+        return new_status, self.players[player_number].name
+
+    def get_players(self) -> dict:
+        return self.players
+
+    def get_possible_game_count(self) -> int:
+        total_players = len(self.get_potential_players())
+        possible_games = floor(total_players / PLAYER_PER_COURT)
+        return possible_games
+
+    def get_potential_players(self) -> dict:
+        players = {k: v for k, v in self.players.items() if v.status}
+        guests = {
+            self.guest_id_start + k: Player(name=f"Guest {k}")
+            for k in range(1, self.guests + 1)
+        }
+        players.update(guests)
+        return players
 
 
 @dataclass
-class GameList:
+class Timer:
+    ref: float = None
+    running: bool = False
+    max_mins: int = 1
+    default: str = ("00", "00")
+
+    def __post_init__(self):
+        self.max_seconds = self.max_mins * 60
 
-    def clear(self, court_list: CourtList):
-        courts = court_list.courts
-        active_courts = [court for court in courts if court.status]
-        inactive_courts = [court for court in courts if not court.status]
-        dummy_games = create_dummy_games(active_courts)
-        reserved_games = create_reserved_games(inactive_courts)
-        games = dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
-        self.games = games
+    def start(self):
+        self.ref = time() + self.max_seconds
+        self.running = True
 
-    def create_random_games(self, court_list: CourtList, player_list: PlayerList):
-        active_players = player_list.get_active_players()
-        active_courts = [court for court in court_list.courts if court.status]
-        inactive_courts = [court for court in court_list.courts if not court.status]
-        possible_games = floor(len(active_players) / PLAYER_PER_COURT)
-        current_players = sample(active_players, possible_games * PLAYER_PER_COURT)
-        active_games = create_possible_games(
-            active_courts[:possible_games], current_players
-        )
-        dummy_games = create_dummy_games(active_courts[possible_games:])
-        reserved_games = create_reserved_games(inactive_courts)
-        games = active_games + dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
-        self.games = games
+    def stop(self):
+        self.ref = None
+        self.running = False
 
-    def create_skilled_games(self, court_list: CourtList, player_list: PlayerList):
-        active_players = player_list.get_active_players()
-        active_courts = [court for court in court_list.courts if court.status]
-        inactive_courts = [court for court in court_list.courts if not court.status]
-        possible_games = floor(len(active_players) / PLAYER_PER_COURT)
-        current_players = sample(active_players, possible_games * PLAYER_PER_COURT)
-        current_players.sort(key=attrgetter("skill"))
-        active_games = create_possible_games(
-            active_courts[:possible_games], current_players
-        )
-        dummy_games = create_dummy_games(active_courts[possible_games:])
-        reserved_games = create_reserved_games(inactive_courts)
-        games = active_games + dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
-        self.games = games
+    def get(self):
+        if not self.running:
+            return self.default
+        total_seconds = self.ref - time()
+        if total_seconds < 0:
+            self.stop()
+            return self.default
+        mins = f"{int(total_seconds // 60):02d}"
+        secs = f"{int(total_seconds % 60):02d}"
+        print(mins)
+        print(secs)
+        return mins, secs