Merge branch 'develop' into 'main'2.0

Database and javascript timer implemented

See merge request KaranJayachandra/match_up!11

1 files changed, 132 insertions, 0 deletions

diff --git a/src/match_up/model.py b/src/match_up/model.py
new file mode 100644
index 0000000..c42823b
--- /dev/null
+++ b/src/match_up/model.py
@@ -0,0 +1,132 @@
+from math import floor
+from typing import Tuple
+from os.path import isfile
+from dataclasses import dataclass
+from importlib.resources import path
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import create_engine, not_
+from match_up.utilities import (
+    generate_guests,
+    _init_database_from_csv,
+    _init_random_database,
+    _textualize_guest,
+)
+from match_up.data import (
+    Player,
+    DisplayPlayer,
+    PLAYER_PER_COURT,
+    BASE,
+)
+
+
+@dataclass
+class CourtList:
+    total: int = 12
+
+    def __post_init__(self) -> None:
+        self.courts = {i + 1: True for i in range(self.total)}
+
+    def get_court_status(self, court_number: int) -> bool:
+        return self.courts[court_number]
+
+    def toggle_court_status(self, court_number: int) -> bool:
+        new_status = not self.courts[court_number]
+        self.courts[court_number] = new_status
+        return new_status
+
+    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
+
+
+class PlayerList:
+    guest_count: dict = {1: 0, 3: 0, 5: 0}
+
+    def __init__(self, csv_location=None) -> None:
+        with path("match_up", "players.db") as p:
+            self.db_location = p
+        db_file_found = True
+        if not isfile(self.db_location):
+            db_file_found = False
+        self._init_database()
+        if csv_location is not None:
+            _init_database_from_csv(self.session, csv_location)
+        else:
+            if not db_file_found:
+                _init_random_database(self.session)
+
+    def _init_database(self):
+        engine = create_engine("sqlite:///" + str(self.db_location))
+        BASE.metadata.create_all(bind=engine)
+        self.session = sessionmaker(bind=engine)()
+
+    def increment_guests(self, level: int):
+        self.guest_count[level] = self.guest_count[level] + 1
+        return _textualize_guest(level, self.guest_count[level])
+
+    def decrement_guests(self, level: int):
+        if self.guest_count[level] == 0:
+            return 0
+        self.guest_count[level] = self.guest_count[level] - 1
+        return _textualize_guest(level, self.guest_count[level])
+
+    def get_player_status(self, id: int) -> bool:
+        return self.session.query(Player).filter(Player.id == id).first().status
+
+    def toggle_player_status(self, id: int) -> DisplayPlayer:
+        player = self.session.query(Player).filter(Player.id == id).first()
+        player.status = not player.status
+        self.session.commit()
+        return DisplayPlayer(player)
+
+    def get_all_players(self) -> list[DisplayPlayer]:
+        all_players = [
+            DisplayPlayer(p)
+            for p in self.session.query(Player)
+            .order_by(Player.first, Player.last)
+            .all()
+        ]
+        return all_players
+
+    def get_possible_game_count(self) -> int:
+        total_players = len(self.get_players())
+        possible_games = floor(total_players / PLAYER_PER_COURT)
+        return possible_games
+
+    def get_players(self) -> list[Player]:
+        active_players = (
+            self.session.query(Player)
+            .order_by(Player.first, Player.last)
+            .filter(not_(Player.status == 0))
+            .all()
+        )
+        guests = generate_guests(self.guest_count)
+        return active_players + guests
+
+    def get_guests(self):
+        return {
+            level: _textualize_guest(level, self.guest_count[level])
+            for level in self.guest_count
+        }
+
+    def increment_game_count(self, player_ids: list[int]):
+        players = self.session.query(Player).filter(Player.id.in_(player_ids))
+        for player in players:
+            player.count += 1
+        self.session.commit()
+
+    def reset_game_count(self):
+        players = self.session.query(Player)
+        for player in players:
+            player.count = 0
+        self.session.commit()
+
+    def reset_all_players(self):
+        players = self.session.query(Player)
+        for player in players:
+            player.status = 0
+        self.session.commit()