1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
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()
|
