def import_players(self, player_index):
while (player_index < len(self.lines)
and len(self.lines[player_index].split(",")) > 1):
info = self.lines[player_index].split(",")
self.logger.debug(info, len(info))
if len(info) < 3:
raise InvalidField(payload={"details": "Missing a category"})
name = info[self.name_index].strip()
email = info[self.email_index].strip()
gender = info[self.gender_index].strip()
if not name.lower().startswith("ex."):
player = (DB.session.query(Player)
.filter(Player.email==email)).first()
if player is None:
self.logger.debug(name + " " + email + " " + gender)
player = Player(name, email,gender=gender)
DB.session.add(player)
self.logger.debug("Player was created")
else:
# this player is active
player.active = True
self.team.players.append(player)
if name == self.captain_name:
self.captain = player
else:
self.warnings.append("Player Example was left")
player_index += 1
return
def import_players(self, player_index):
"""Import a list of players"""
while (player_index < len(self.lines)
and len(self.lines[player_index].split(",")) > 1):
info = self.lines[player_index].split(",")
self.logger.debug(info, len(info))
if len(info) < 3:
raise InvalidField(payload={"details": "Missing a category"})
name = info[self.name_index].strip()
email = info[self.email_index].strip()
gender = info[self.gender_index].strip()
if not name.lower().startswith("ex."):
player = (DB.session.query(Player).filter(
Player.email == email)).first()
if player is None:
self.logger.debug(name + " " + email + " " + gender)
player = Player(name, email, gender=gender)
self.session.add(player)
self.logger.debug("Player was created")
else:
# this player is active
player.active = True
self.team.players.append(player)
if name == self.captain_name:
self.captain = player
else:
self.warnings.append("Player Example was left")
player_index += 1
return
def add_team_functional(self):
""" Add a team to the database using functions instead of methods"""
# parse out the parts - background, header, players
parts = parse_lines(self.lines)
self.warnings = parts['warnings']
# extract the background such a league, sponsor and color
background = extract_background(parts['background'])
# extract the players using the header as lookup
lookup = extract_column_indices_lookup(parts['header'])
players = extract_players(parts["players"], lookup)
self.warnings = self.warnings + players['warnings']
# add the players
player_models = []
for player_json in players['player_info']:
try:
if (player_json['player_id'] is None):
# need to create the player
player = Player(player_json['name'],
player_json['email'],
gender=player_json["gender"])
self.session.add(player)
self.session.commit()
else:
email = player_json['email']
player = Player.query.filter(
func.lower(Player.email) == func.lower(email)).first()
player_models.append(player.json())
except Exception as error:
player_info = "-".join(
[player_json["name"], player_json["email"]])
self.warnings.append(
INVALID_PLAYER.format(player_info, str(error)))
# get the team, create if does not exist
if background['team']['team_id'] is None:
team = Team(color=background['team']['color'],
sponsor_id=background['sponsor']['sponsor_id'],
league_id=background['league']['league_id'],
year=date.today().year)
self.session.add(team)
else:
# get the team and remove all players
team = Team.query.get(background['team']['team_id'])
team.players = []
set_captain = False
for player in player_models:
if (player["player_name"].lower() == background["captain"]
["player_name"].lower()):
set_captain = True
team.insert_player(player["player_id"], captain=True)
else:
team.insert_player(player["player_id"], captain=False)
if not set_captain:
self.warnings.append(CAPTAIN_NOT_ASSIGNED)
self.session.commit()
def post(self):
"""
POST request for Player List
Route: Routes['player']
Parameters :
player_name: The player's name (string)
gender: a one letter character representing gender (string)
email: the email of the player (string)
password: the password of the player(string)
active: 1 if player is active and 0 otherwise (int)
Returns:
if successful
status: 200
mimetype: application/json
data: the created player id (int)
if email is duplicate
status: NUESC
mimetype: application/json
data: None
if invalid field
status: IFSC
mimetype: application/json
data: None
othwerwise
status: 404
mimetype: application/json
data: None
"""
# create a new user
args = post_parser.parse_args()
gender = None
player_name = None
email = None
password = "******"
active = True
if args['player_name']:
player_name = args['player_name']
if args['gender']:
gender = args['gender']
if args['email']:
email = args['email']
if args['password']:
password = args['password']
if args['active']:
active = args['active'] == 1 if True else False
player = Player(player_name, email, gender, password, active=active)
DB.session.add(player)
DB.session.commit()
result = player.id
handle_table_change(Tables.PLAYER, item=player.json())
return Response(dumps(result), status=201, mimetype="application/json")
def pull_players(url):
"""
pull_players
Returns a lookup of players that were pulled
from the website into local DB
Parameters:
url: the url of the main site
Returns:
a dictionary lookup
for the website sponsor id to local player object
e.g. player_lookup = {1: Player(), etc..}
"""
_players = requests.get(url + "/api/players").json()
if isinstance(_players, dict):
_players = pull_all_pages(url, _players)
players_lookup = {}
for player in tqdm(_players, desc="Pulling players from {}".format(url)):
if (player['player_name'].lower() != "unassigned"):
temp = Player(player['player_name'],
create_email(player['player_name']),
gender=player['gender'],
active=False)
players_lookup[player['player_id']] = temp
DB.session.add(temp)
DB.session.commit()
return players_lookup
def create_and_login():
"""Creates a player if they do not exist and login them in."""
player_info = request.get_json(silent=True)
player = Player.query.filter(
Player.email == player_info.get('email')).first()
if player is None:
LOGGER.info(f"Adding player to league: {player_info}")
player = Player(player_info.get("player_name", str(uuid.uuid1())),
player_info.get("email"),
gender=player_info.get("gender", "m"))
DB.session.add(player)
DB.session.commit()
login_user(player)
return Response(json.dumps(player.json()),
200,
mimetype='application/json')
def init_database(mock, create_db):
"""
init_database
Initialize the database either by mocking data or copying main
website locally
Parameters:
mock: whether to mock some data for the current year
create_db: True if database should be created
Returns:
None
"""
if (create_db):
create_fresh_tables()
DB.session.add(Player("UNASSIGNED", UNASSIGNED_EMAIL, gender="F"))
DB.session.commit()
if (mock):
print("Adding mock data ...")
# add the unassigned bats player
mock_fun_count()
sponsor_lookup = mock_sponsors()
league = mock_league()
mock_teams_games(league, mock_division(), sponsor_lookup)
mock_teams_games(league, mock_division(division="Tuesday & Thursday"),
sponsor_lookup)
return
def testPlayerInit(self):
player_name = str(uuid.uuid1())
email = player_name + "@mlsb.ca"
Player(player_name, email)
Player(player_name, email, gender="m", password="******")
# now bad stuff
try:
Player(1, email)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
Player(player_name, 1)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
some_email = str(uuid.uuid1()) + "@mlsb.ca"
self.add_player(str(uuid.uuid1()), some_email)
Player(str(uuid.uuid1()), some_email)
self.assertEqual(False, True, "Should raise email exception")
except NonUniqueEmail:
pass
try:
Player(player_name, email, gender="XX")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
def testPlayerInit(self):
Player("Good Player", "*****@*****.**")
Player("Good Player",
"*****@*****.**",
gender="m",
password="******")
# now bad stuff
try:
Player(1, "*****@*****.**")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
Player("Good Player", 1)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
self.add_player("first player", "*****@*****.**")
Player("second player", "*****@*****.**")
self.assertEqual(False, True, "Should raise email exception")
except NonUniqueEmail:
pass
try:
Player("Good Player", "*****@*****.**", gender="XX")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
def init_database(mock, copy_locally, url, create_db):
"""
init_database
Initialize the database either by mocking data or copying main
website locally
Parameters:
mock: whether to mock some data for the current year
copy_locally: whether to copy the main website locally
url: the main website main url (https://www.mlsb.ca)
create_db: True if database should be created
Returns:
None
"""
if (create_db):
create_fresh_tables()
DB.session.add(Player("UNASSIGNED", UNASSIGNED_EMAIL, gender="F"))
pull_fun_count(url)
sponsor_lookup = pull_sponsors(url)
if (mock):
print("Adding mock data ...")
# add the unassigned bats player
league = mock_league()
mock_teams_games(league, sponsor_lookup)
league_2 = mock_league(league_name="Mock League 2")
mock_teams_games(league_2, sponsor_lookup)
else:
if (copy_locally):
print("Pulling a local copy of the given website")
player_lookup = pull_players(url)
league_lookup = pull_leagues(url)
team_lookup = pull_teams(url, player_lookup, sponsor_lookup,
league_lookup)
game_lookup = pull_games(url, team_lookup, league_lookup)
pull_bats(url, team_lookup, player_lookup, game_lookup)
pull_espys(url, team_lookup, sponsor_lookup)
return
def testPlayerUpdate(self):
p1 = Player("Good Player", "*****@*****.**")
p1.update(name="new name",
email="*****@*****.**",
gender="f",
password="******")
# now bad stuff
try:
p1.update(name=1, email="*****@*****.**")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
p1.update(name="Good Player", email=1)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
p2 = Player("first player", "*****@*****.**")
DB.session.add(p2)
DB.session.commit()
p1.update(name="second player", email="*****@*****.**")
self.assertEqual(False, True, "Should raise email exception")
except NonUniqueEmail:
pass
try:
p1.update(name="Good Player", email="*****@*****.**", gender="XX")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
def mock_teams_games(league, sponsor_lookup):
"""
mock_team_games
Mocks up some data for the league by add some players to a team,
then a few games to the league and a few scores for some games
Parameters:
league: the league object
sponsor_lookup: a dictionary lookup for a id to its given sponsor
Returns:
None
"""
# add some players
domain = "@" + league.name.replace(" ", "")
team_one_players = [
Player("Captain1", "captain1" + domain, gender="M"),
Player("MalePlayer1", "mp1" + domain, gender="M"),
Player("FemalePlayer1", "fp1" + domain, gender="F")
]
team_two_players = [
Player("Captain2", "captain2" + domain, gender="F"),
Player("MalePlayer2", "mp2" + domain, gender="M"),
Player("FemalePlayer2", "fp2" + domain, gender="F")
]
team_three_players = [
Player("Captain3", "captain3" + domain, gender="M"),
Player("MalePlayer3", "mp3" + domain, gender="M"),
Player("FemalePlayer3", "fp3" + domain, gender="F")
]
team_four_players = [
Player("Captain4", "captain4" + domain, gender="F"),
Player("MalePlayer4", "mp4" + domain, gender="M"),
Player("FemalePlayer4", "fp4" + domain, gender="F")
]
team_players = [
team_one_players, team_two_players, team_three_players,
team_four_players
]
for team in tqdm(team_players, desc="Adding mock Players"):
for player in team:
DB.session.add(player)
DB.session.commit()
# add four teams with some players
teams = [
Team(color="Black",
sponsor_id=random_value_lookup(sponsor_lookup).id,
league_id=league.id),
Team(color="Blue",
sponsor_id=random_value_lookup(sponsor_lookup).id,
league_id=league.id),
Team(color="Red",
sponsor_id=random_value_lookup(sponsor_lookup).id,
league_id=league.id),
Team(color="Green",
sponsor_id=random_value_lookup(sponsor_lookup).id,
league_id=league.id)
]
for i in tqdm(range(0, len(teams)), desc="Adding mock players to Teams"):
team = teams[i]
DB.session.add(team)
# add the players to the team
for player in team_players[i]:
team.insert_player(player.id, "captain" in player.name.lower())
DB.session.commit()
# add some random espsy to each team and
# create a lookup for team id to players
team_player_lookup = {}
random_prices = [9.99, 4.75, 100, 15.50, 12.99]
for i in tqdm(range(0, len(teams)), desc="Adding mock espys to Teams"):
team_player_lookup[team.id] = team_players[i]
team = teams[i]
for __ in range(0, 4):
points = random_value_list(random_prices)
espy = Espys(team.id,
sponsor_id=random_value_lookup(sponsor_lookup).id,
description="Purchase",
points=points)
DB.session.add(espy)
DB.session.commit()
# add some games between the teams
# need a bunch of games
today = datetime.date.today()
games = []
for day in range(-3, 3):
date_string = (today +
datetime.timedelta(days=day)).strftime("%Y-%m-%d")
status = "Completed" if day < 0 else "To Be Played"
games.append(
Game(date_string,
"10:00",
teams[0].id,
teams[1].id,
league.id,
status=status,
field="WP1"))
games.append(
Game(date_string,
"10:00",
teams[2].id,
teams[3].id,
league.id,
status=status,
field="WP2"))
games.append(
Game(date_string,
"11:00",
teams[0].id,
teams[2].id,
league.id,
status=status,
field="WP1"))
games.append(
Game(date_string,
"11:00",
teams[2].id,
teams[1].id,
league.id,
status=status,
field="WP2"))
games.append(
Game(date_string,
"12:00",
teams[0].id,
teams[3].id,
league.id,
status=status,
field="WP1"))
games.append(
Game(date_string,
"12:00",
teams[2].id,
teams[1].id,
league.id,
status=status,
field="WP2"))
for game in tqdm(games, "Adding mock games"):
DB.session.add(game)
DB.session.commit()
# now add a random score to the game
for game in tqdm(games[:18], desc="Mocking scores for games"):
add_random_score(game.id, game.away_team_id,
team_player_lookup[game.away_team_id])
add_random_score(game.id, game.home_team_id,
team_player_lookup[game.home_team_id])
DB.session.commit()
def testPlayerUpdate(self):
player_name = str(uuid.uuid1())
email = player_name + "@mlsb.ca"
new_player_name = str(uuid.uuid1())
new_email = new_player_name + "@mlsb.ca"
p1 = Player(player_name, email)
p1.update(name=new_player_name,
email=new_email,
gender="f",
password="******")
# now bad stuff
try:
p1.update(name=1, email=email)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
p1.update(name=player_name, email=1)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
some_email = str(uuid.uuid1()) + "@mlsb.ca"
self.add_player(str(uuid.uuid1()), some_email)
p1.update(name=str(uuid.uuid1()), email=some_email)
self.assertEqual(False, True, "Should raise email exception")
except NonUniqueEmail:
pass
try:
p1.update(name=player_name, email=email, gender="XX")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
def testPlayerUpdate(self):
p1 = Player("Good Player", "*****@*****.**")
p1.update(name="new name",
email="*****@*****.**",
gender="f",
password="******")
# now bad stuff
try:
p1.update(name=1, email="*****@*****.**")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
p1.update(name="Good Player", email=1)
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
try:
self.add_player("first player", "*****@*****.**")
p1.update(name="second player", email="*****@*****.**")
self.assertEqual(False, True, "Should raise email exception")
except NonUniqueEmail:
pass
try:
p1.update(name="Good Player", email="*****@*****.**", gender="XX")
self.assertEqual(False, True, "Should raise invalid field")
except InvalidField:
pass
