Added the history and reset functionality

1 files changed, 37 insertions, 165 deletions

diff --git a/src/match_up/model.py b/src/match_up/model.py
index 9b2dce7..abce73c 100644
--- a/src/match_up/model.py
+++ b/src/match_up/model.py
@@ -3,85 +3,25 @@ from typing import Tuple
 from os.path import join, isfile
 from dataclasses import dataclass
 from importlib.resources import path
-from pandas import read_csv, DataFrame
 from sqlalchemy.orm import sessionmaker
-from random import randint, getrandbits
-from names import get_first_name, get_last_name
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy import create_engine, Column, String, Integer, not_
-
-MIN_LEVEL = 1
-MAX_LEVEL = 10
-DEFAULT_COURTS = 12
-PLAYER_PER_COURT = 4
-
-
-Base = declarative_base()
-
-
-class Player(Base):
-    __tablename__ = "players"
-    id = Column("id", Integer, primary_key=True)
-    first = Column("first", String)
-    last = Column("last", String)
-    level = Column("level", Integer)
-    status = Column("status", Integer)
-    count = Column("count", Integer)
-
-    def __init__(
-        self,
-        id: int = None,
-        first: str = "",
-        last: str = "",
-        level: int = None,
-        status: bool = None,
-        count: int = None,
-    ):
-        self.id = id
-        self.first = first
-        self.last = last
-        self.status = status
-        self.level = level
-        self.count = count
-
-    def __repr__(self):
-        status = "active" if self.status else "inactive"
-        return f"{self.first} {self.last} (Level {self.level}) is {status} and has played {self.count} games"
-
-
-class DisplayPlayer:
-    id: int
-    first: str
-    last: str
-    status: bool
-
-    def __init__(self, player: Player):
-        self.id = player.id
-        self.first = player.first
-        self.last = player.last
-        self.status = player.status
-
-    def __repr__(self):
-        status = "active" if self.status else "inactive"
-        return f"{self.first} {self.last} is {status}"
-
-
-@dataclass
-class Team:
-    player1: DisplayPlayer
-    player2: DisplayPlayer
-
-
-@dataclass
-class Game:
-    court: int
-    team1: Team
-    team2: Team
+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 = DEFAULT_COURTS
+    total: int = 12
 
     def __post_init__(self) -> None:
         self.courts = {i + 1: True for i in range(self.total)}
@@ -89,7 +29,7 @@ class CourtList:
     def get_court_status(self, court_number: int) -> bool:
         return self.courts[court_number]
 
-    def toggle_court_status(self, court_number: int) -> None:
+    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
@@ -103,46 +43,36 @@ class CourtList:
         return active_courts, inactive_courts
 
 
-def _textualize_guest(level, value) -> str:
-    match level:
-        case 1:
-            text = "Beginners"
-        case 3:
-            text = "Novices"
-        case 5:
-            text = "Intermediates"
-    if value == 1:
-        text = text[:-1]
-    return f"{value} {text}"
-
-
 class PlayerList:
-    guests: dict = {1: 0, 3: 0, 5: 0}
+    guest_count: dict = {1: 0, 3: 0, 5: 0}
 
-    def __init__(self, csv_location: str = None) -> None:
+    def __init__(self, csv_location=None) -> None:
+        with path("match_up") as p:
+            self.db_location = join(p, "players.db")
+        db_file_found = True
+        if not isfile(self.db_location):
+            db_file_found = False
         self._init_database()
         if csv_location is not None:
-            self._init_database_from_csv(read_csv(csv_location))
+            _init_database_from_csv(self.session, csv_location)
         else:
-            if not isfile(self.db_location):
-                self._init_random_database()
+            if not db_file_found:
+                _init_random_database(self.session)
 
     def _init_database(self):
-        with path("match_up") as p:
-            self.db_location = join(p, "players.db")
         engine = create_engine("sqlite:///" + self.db_location, echo=True)
-        Base.metadata.create_all(bind=engine)
+        BASE.metadata.create_all(bind=engine)
         self.session = sessionmaker(bind=engine)()
 
     def increment_guests(self, level: int):
-        self.guests[level] = self.guests[level] + 1
-        return _textualize_guest(level, self.guests[level])
+        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.guests[level] == 0:
+        if self.guest_count[level] == 0:
             return 0
-        self.guests[level] = self.guests[level] - 1
-        return _textualize_guest(level, self.guests[level])
+        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
@@ -153,7 +83,7 @@ class PlayerList:
         self.session.commit()
         return DisplayPlayer(player)
 
-    def get_all_players(self) -> list[Player]:
+    def get_all_players(self) -> list[DisplayPlayer]:
         all_players = [
             DisplayPlayer(p)
             for p in self.session.query(Player)
@@ -167,51 +97,20 @@ class PlayerList:
         possible_games = floor(total_players / PLAYER_PER_COURT)
         return possible_games
 
-    def get_players(self, rounds: int = 0) -> list[Player]:
+    def get_players(self) -> list[Player]:
         active_players = (
             self.session.query(Player)
             .order_by(Player.first, Player.last)
             .filter(not_(Player.status == 0))
             .all()
         )
-        low_guests = [
-            Player(
-                id=1000 + i,
-                first=f"Beginner",
-                last=f"{i}",
-                level=1,
-                status=True,
-                count=rounds,
-            )
-            for i in range(1, self.guests[1] + 1)
-        ]
-        mid_guests = [
-            Player(
-                id=2000 + i,
-                first=f"Novice",
-                last=f"{i}",
-                level=4,
-                status=True,
-                count=rounds,
-            )
-            for i in range(1, self.guests[3] + 1)
-        ]
-        high_guests = [
-            Player(
-                id=3000 + i,
-                first=f"Intermediate",
-                last=f"{i}",
-                level=7,
-                status=True,
-                count=rounds,
-            )
-            for i in range(1, self.guests[5] + 1)
-        ]
-        return active_players + low_guests + mid_guests + high_guests
+        guests = generate_guests(self.guest_count)
+        return active_players + guests
 
     def get_guests(self):
         return {
-            level: _textualize_guest(level, self.guests[level]) for level in self.guests
+            level: _textualize_guest(level, self.guest_count[level])
+            for level in self.guest_count
         }
 
     def increment_game_count(self, player_ids: list[int]):
@@ -231,30 +130,3 @@ class PlayerList:
         for player in players:
             player.status = 0
         self.session.commit()
-
-    def _init_database_from_csv(self, data: DataFrame) -> None:
-        self.session.query(Player).delete()
-        for _, entry in data.iterrows():
-            player = Player(
-                id=entry["id"],
-                first=entry["first"],
-                last=entry["last"],
-                level=entry["skill"],
-                status=False,
-                count=0,
-            )
-            self.session.add(player)
-        self.session.commit()
-
-    def _init_random_database(self, player_count: int = 80) -> None:
-        for i in range(player_count):
-            player = Player(
-                id=i,
-                first=get_first_name(),
-                last=get_last_name(),
-                level=randint(MIN_LEVEL, MAX_LEVEL),
-                status=getrandbits(1),
-                count=0,
-            )
-            self.session.add(player)
-        self.session.commit()