Back to working

1 files changed, 34 insertions, 171 deletions

diff --git a/app/model.py b/app/model.py
index 2f8c609..3ec663e 100644
--- a/app/model.py
+++ b/app/model.py
@@ -1,14 +1,9 @@
-from math import floor
 from app import app, db
-from pandas import read_csv
-from dataclasses import dataclass
 from sqlalchemy.orm import Mapped
 from datetime import date, datetime
-from random import randint, getrandbits
-from typing import Tuple, Optional, Sequence
+from typing import Optional, Annotated
 from sqlalchemy.orm import mapped_column as mc
-from names import get_first_name, get_last_name
-from sqlalchemy import String, Boolean, Integer, ForeignKey, select
+from sqlalchemy import String, Boolean, Integer, ForeignKey
 
 
 class User(db.Model):
@@ -28,48 +23,10 @@ class Court(db.Model):
         return f"Court {self.id} is {"active" if self.status else "inactive"}"
 
 
-class Courts:
-
-    def __init__(self):
-        with app.app_context():
-            if app.config["COURT_COUNT"] is not None:
-                db.session.query(Court).delete()
-                for i in range(int(app.config["COURT_COUNT"])):
-                    db.session.add(Court())
-                db.session.commit()
-
-    def get(self, id: int) -> bool:
-        court = db.session.get(Court, id)
-        if court is None:
-            raise ValueError(f"Court {id} doesn't exist.")
-        return court.status
-
-    def toggle(self, id: int) -> bool:
-        court = db.session.get(Court, id)
-        if court is None:
-            raise ValueError(f"Court {id} doesn't exist.")
-        new_status = not court.status
-        court.status = new_status
-        db.session.commit()
-        return new_status
-
-    def active(self):
-        return db.session.query(Court).where(Court.status).all()
-
-    def all(self) -> list[Court]:
-        courts = [court for court in db.session.query(Court).order_by(Court.id)]
-        return courts
-
-    def reset(self):
-        for court in db.session.scalars(select(Court)):
-            court.status = True
-        db.session.commit()
-
-
 class Player(db.Model):
     id: Mapped[int] = mc(primary_key=True)
-    first_name: Mapped[str] = mc(String(64), index=True, default="---")
-    last_name: Mapped[str] = mc(String(64), index=True, default="---")
+    first_name: Mapped[str] = mc(String(64), index=True)
+    last_name: Mapped[str] = mc(String(64), index=True)
     team: Mapped[int] = mc(Integer, index=True)
     status: Mapped[bool] = mc(Boolean)
     level: Mapped[int] = mc(Integer)
@@ -94,111 +51,6 @@ class Player(db.Model):
         return f"{self.first_name} {self.last_name} is {"active" if self.status else "inactive"}"
 
 
-def initialize_random_database(
-    player_count: int = 80, guest_per_level: int = 4
-) -> None:
-    db.session.add(Player(**{"id": 0, "first_name": "---", "last_name": ""}))
-    db.session.add(Player(**{"id": 1, "first_name": "RESERVED", "last_name": ""}))
-    total_teams = 5
-    players_per_team = 5
-    for i in range(player_count):
-        if i < total_teams * players_per_team:
-            team = floor(i / players_per_team) + 1
-        else:
-            team = 0
-        args = {
-            "first_name": get_first_name(),
-            "last_name": get_last_name(),
-            "team": team,
-            "status": bool(getrandbits(1)),
-            "level": randint(
-                app.config["MIN_PLAYER_LEVEL"], app.config["MAX_PLAYER_LEVEL"]
-            ),
-        }
-        db.session.add(Player(**args))
-    meta_data = {"first_name": "Guest", "team": 0, "status": False}
-    for level_id, level in enumerate(app.config["GUEST_LEVELS"]):
-        for player_id in range(guest_per_level):
-            unique_id = (level_id * guest_per_level) + player_id + 1
-            args = meta_data | {"last_name": str(unique_id), "level": level}
-            db.session.add(Player(**args))
-    db.session.commit()
-
-
-class Players:
-
-    def __init__(self) -> None:
-        with app.app_context():
-            if app.config["DATABASE_CSV"] is not None:
-                data = read_csv(app.config["DATABASE_CSV"])
-                db.session.query(Player).delete()
-                db.session.add(
-                    Player(**{"id": 0, "first_name": "---", "last_name": ""})
-                )
-                db.session.add(
-                    Player(**{"id": 1, "first_name": "RESERVED", "last_name": ""})
-                )
-                for entry in data.to_dict("records"):
-                    args = entry | {"status": False}
-                    db.session.add(Player(**args))  # type: ignore
-                db.session.commit()
-            else:
-                if len(self.all()) == 0:
-                    initialize_random_database()
-
-    def default_id(self):
-        query = select(Player).where(Player.first_name == "---")
-        player = db.session.scalars(query).first()
-        if player is None:
-            raise ValueError(f"Database isn't initialized.")
-        return player.id
-
-    def reserved_id(self):
-        query = select(Player).where(Player.first_name == "RESERVED")
-        player = db.session.scalars(query).first()
-        if player is None:
-            raise ValueError(f"Database isn't initialized.")
-        return player.id
-
-    def get(self, id: int) -> bool:
-        player = db.session.get(Player, id)
-        if player is None:
-            raise ValueError(f"User {id} doesn't exist.")
-        return player.status
-
-    def toggle(self, id: int) -> Player:
-        player = db.session.get(Player, id)
-        if player is None:
-            raise ValueError(f"User {id} doesn't exist.")
-        player.status = not player.status
-        db.session.commit()
-        return player
-
-    def all(self) -> Tuple[list[Player], list[Player]]:
-        players = (
-            db.session.query(Player)
-            .where(Player.id > 1)
-            .order_by(Player.first_name, Player.last_name)
-        )
-        regulars = [p for p in players if p.first_name != "Guest"]
-        guests = [p for p in players if p.first_name == "Guest"]
-        guests.sort(key=lambda x: int(x.last_name))
-        return regulars, guests
-
-    def active(self) -> Sequence[Player]:
-        query = (
-            select(Player)
-            .where(Player.status)
-            .order_by(Player.first_name, Player.last_name)
-        )
-        return db.session.scalars(query).all()
-
-    def reset(self):
-        for player in db.session.scalars(select(Player)):
-            player.status = False
-        db.session.commit()
-
-
 class Game(db.Model):
     id: Mapped[int] = mc(primary_key=True)
     round_id: Mapped[int] = mc(Integer, index=True)
@@ -211,14 +63,15 @@ class Game(db.Model):
 
     def __init__(
         self,
-        round_id: int,
+        round_id: Optional[int],
         court_id: int,
         player_1: int,
         player_2: int,
         player_3: int,
         player_4: int,
     ):
-        self.round_id = round_id
+        if round_id is not None:
+            self.round_id = round_id
         self.court_id = court_id
         self.player_1 = player_1
         self.player_2 = player_2
@@ -226,22 +79,32 @@ class Game(db.Model):
         self.player_4 = player_4
 
 
-class DisplayPlayer:
-
-    def __init__(self, player: Player):
-        self.id = player.id
-        self.first_name = player.first_name
-        self.last_name = player.last_name
-
-
-@dataclass
-class DisplayTeam:
-    player_1: DisplayPlayer
-    player_2: DisplayPlayer
+class DisplayGame:
+    court: Court
+    team_1: Annotated[list[Player], 2]
+    team_2: Annotated[list[Player], 2]
 
+    def __init__(self, game: Game):
+        court = db.session.get(Court, game.court_id)
+        if court is None:
+            raise ValueError(f"Unknown court")
+        self.court = court
+        players = []
+        for i in range(4):
+            player_id = getattr(game, f"player_{i+1}")
+            p = db.session.get(Player, player_id)
+            if p is None:
+                raise ValueError(f"Player ID: {player_id} mismatch.")
+            players.append(p)
+        self.team_1 = players[:2]
+        self.team_2 = players[2:]
 
-@dataclass
-class DisplayGame:
-    court_id: int
-    team_1: DisplayTeam
-    team_2: DisplayTeam
+    def to_game(self, round_id) -> Game:
+        return Game(
+            round_id,
+            self.court.id,
+            self.team_1[0].id,
+            self.team_1[1].id,
+            self.team_2[0].id,
+            self.team_2[1].id,
+        )