Moved to javascript codebase

1 files changed, 0 insertions, 194 deletions

diff --git a/app/controller.py b/app/controller.py
deleted file mode 100644
index d5bdbcb..0000000
--- a/app/controller.py
+++ /dev/null
@@ -1,194 +0,0 @@
-from math import floor
-from app import app, db
-from datetime import date
-from typing import Sequence
-from pandas import DataFrame
-from operator import attrgetter
-from sqlalchemy import func, select, not_
-from app.model import (
-    Player,
-    Court,
-    Game,
-    DisplayGame,
-)
-from app.utilities import (
-    get_placeholder_games,
-    get_team_games,
-    get_shuffle_games,
-    separate_teams_and_players,
-    initialize_random_database,
-    initialize_default_players,
-)
-
-
-class Courts:
-    def __init__(self):
-        with app.app_context():
-            db.session.query(Court).delete()
-            for _ in range(app.config["COURT_COUNT"]):
-                db.session.add(Court())
-            db.session.commit()
-
-    def get(self, id: int) -> Court:
-        court = db.session.get(Court, id)
-        if court is None:
-            raise ValueError(f"Court not found: {id}")
-        return court
-
-    def toggle(self, id: int) -> Court:
-        court = self.get(id)
-        court.status = not court.status
-        db.session.commit()
-        return court
-
-    def active(self):
-        return db.session.query(Court).where(Court.status).all()
-
-    def inactive(self):
-        return db.session.query(Court).where(not_(Court.status)).all()
-
-    def all(self) -> list[Court]:
-        return db.session.query(Court).order_by(Court.id).all()
-
-
-class Players:
-    def __init__(self) -> None:
-        with app.app_context():
-            if len(self.regulars()) == 0:
-                initialize_random_database()
-
-    def update(self, data: DataFrame):
-        initialize_default_players()
-        for entry in data.to_dict("records"):
-            args = entry | {"status": False}
-            db.session.add(Player(**args))  # type: ignore
-        db.session.commit()
-
-    def get(self, id: int) -> Player:
-        player = db.session.get(Player, id)
-        if player is None:
-            raise ValueError(f"Player not found: {id}")
-        return player
-
-    def toggle(self, id: int) -> Player:
-        player = self.get(id)
-        player.status = not player.status
-        db.session.commit()
-        return player
-
-    def regulars(self) -> list[Player]:
-        filter_list = list(app.config["GUESTS"].keys()) + list(
-            app.config["DEFAULTS"].keys()
-        )
-        return (
-            db.session.query(Player)
-            .where(Player.id > 1)
-            .where(Player.first_name.not_in(filter_list))
-            .order_by(Player.first_name, Player.last_name)
-            .all()
-        )
-
-    def guests(self) -> list[Player]:
-        return (
-            db.session.query(Player)
-            .where(Player.id > 1)
-            .where(Player.first_name.in_(app.config["GUESTS"].keys()))
-            .order_by(Player.first_name, Player.last_name)
-            .all()
-        )
-
-    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 Session:
-    levels: int = 10
-    teams: bool = False
-    proposal: list[DisplayGame] = []
-
-    def _today(self):
-        games = (
-            db.session.query(Game).filter(func.date(Game.date) == date.today()).all()
-        )
-        return games
-
-    def __init__(self):
-        with app.app_context():
-            db.create_all()
-            self.courts = Courts()
-            self.players = Players()
-            if len(self._today()) == 0:
-                query = select(Player).where(Player.first_name == "---")
-                player = db.session.scalars(query).first()
-                if player is None:
-                    raise ValueError("Database isn't initialized.")
-                player_data = {f"player_{i + 1}": player.id for i in range(4)}
-                for court in self.courts.all():
-                    args = {"round_id": 0, "court_id": court.id} | player_data
-                    db.session.add(Game(**args))
-                db.session.commit()
-
-    def round(self) -> int:
-        games = self._today()
-        round_id = max([game.round_id for game in games])
-        if round_id is None:
-            raise ValueError("Database isn't initialized")
-        return round_id
-
-    def current_round(self) -> list[DisplayGame]:
-        games = (
-            db.session.query(Game)
-            .filter(func.date(Game.date) == date.today())
-            .filter(Game.round_id == self.round())
-            .order_by(Game.court_id)
-            .all()
-        )
-        games = [DisplayGame(game) for game in games]
-        return games
-
-    def propose(self) -> list[DisplayGame]:
-        reserved_courts = self.courts.inactive()
-        reserved_games = get_placeholder_games(reserved_courts, "RESERVED")
-        active_courts = self.courts.active()
-        active_players = self.players.active()
-        game_count = floor(len(active_players) / app.config["PLAYERS_PER_COURT"])
-        game_count = min(len(active_courts), game_count)
-        used_courts = active_courts[:game_count]
-        unused_courts = active_courts[game_count:]
-        blank_games = get_placeholder_games(unused_courts, "---")
-        active_teams = {}
-        if self.teams:
-            active_teams, active_players = separate_teams_and_players(active_players)
-        team_courts = used_courts[: len(active_teams)]
-        shuffle_courts = used_courts[len(active_teams) :]
-        team_games = get_team_games(team_courts, active_teams)
-        shuffle_games = get_shuffle_games(shuffle_courts, active_players, self.levels)
-        self.proposal = shuffle_games + team_games + blank_games + reserved_games
-        self.proposal.sort(key=attrgetter("court.id"))
-        return self.proposal
-
-    def confirm(self) -> list[DisplayGame]:
-        if len(self.proposal) == 0:
-            return self.current_round()
-        round_id = self.round() + 1
-        for game in self.proposal:
-            db.session.add(game.to_game(round_id))
-        db.session.commit()
-        self.proposal = []
-        return self.current_round()
-
-    def reset(self) -> list[DisplayGame]:
-        db.session.query(Game).filter(func.date(Game.date) == date.today()).delete()
-        db.session.commit()
-        self.__init__()
-        return self.current_round()