def delete_fine(
self,
payload: dict,
) -> None:
if not payload['banker']:
raise AuthorizationError(error_code='player_unauthorized')
fine = Fine.get_fine_by_uuid(uuid=payload['fine_uuid'])
if not fine:
raise EntityNotFound(error_code='fine_not_found')
Player.delete_player_fines_by_uuid(fine_uuid=fine.uuid)
Fine.delete_fine(fine=fine)
def test_players_from_single_team(n=10):
fake = Faker(locale="fr_FR")
fake.seed(42)
team = test_team()
database.db.session.add(team)
database.db.session.commit()
fine = test_fine(team_uuid=team.uuid)
database.db.session.add(fine)
database.db.session.commit()
association = PlayerFines(player_fines_id=str(uuid.uuid4()))
association.fine = fine
players = []
for i in range(n):
player = Player(
uuid=str(uuid.uuid4()),
first_name=fake.first_name(),
last_name=fake.last_name(),
email=fake.email(),
password=Passwords.hash_password(fake.password()),
banker=False,
team_uuid=team.uuid,
)
player.fines.append(association)
players.append(player)
return players
def delete_player_fines(
self,
banker: bool,
player_uuid: uuid,
) -> bool:
if not banker:
raise AuthorizationError(error_code='player_unauthorized')
player = Player.get_player_by_uuid(player_uuid=player_uuid)
if not player:
raise EntityNotFound(error_code='player_not_found')
Player.delete_player_fines(player_uuid)
return True
def update_player_fine(
self,
payload: dict,
) -> dict:
if not payload['banker']:
raise AuthorizationError(error_code='player_unauthorized')
player = Player.get_player_by_uuid(player_uuid=payload['player_uuid'])
if not player:
raise EntityNotFound(error_code='player_not_found')
if not payload['fine_uuid']:
raise ModelCreationError(error_code='missing_parameter')
fine = Fine.get_fine_by_uuid(uuid=payload['fine_uuid'])
if not fine:
raise EntityNotFound(error_code='fine_not_found')
player_fine = PlayerFines(player_fines_id=str(uuid.uuid4()))
player_fine.fine = fine
player.fines.append(player_fine)
db.session.commit()
return player.to_dict()
def signup_player(
self,
player_info,
):
player_uuid = str(uuid.uuid4())
password = player_info.get('password', None)
first_name = player_info.get('first_name', None)
last_name = player_info.get('last_name', None)
email = player_info.get('email', None)
add_team = player_info.get('add_team', None)
team_uuid = player_info.get('get_team', None)
if ((password is None or not password)
or (first_name is None or not first_name)
or (last_name is None or not last_name)
or (email is None or not email)
or ((add_team is None) and (team_uuid is None))):
raise ModelCreationError(error_code='missing_parameter')
if ((add_team is not None and not add_team)
or (team_uuid is not None and not is_uuid(team_uuid))):
raise ModelCreationError(error_code='invalid_parameter')
if not Passwords.is_password_valid(password):
raise ModelCreationError(error_code='invalid_password')
if 'add_team' in player_info:
banker = True
team_uuid = TeamModelRepository.create_team(
self,
team_name=add_team,
)
else:
team = Team.get_team_by_uuid(
self,
team_uuid=team_uuid,
)
if not team:
raise EntityNotFound(error_code='team_not_found')
banker = False
player = Player(
uuid=player_uuid,
first_name=first_name,
last_name=last_name,
email=email,
password=Passwords.hash_password(password),
banker=banker,
team_uuid=team_uuid,
)
db.session.add(player)
db.session.commit()
return {"player_uuid": player_uuid, "team_uuid": team_uuid}
def get_player_fines(
self,
player_uuid: uuid,
) -> collections:
result = []
player = Player.get_player_by_uuid(player_uuid=player_uuid)
if not player:
raise EntityNotFound(error_code='player_not_found')
player_fines = Player.get_player_fines_by_uuid(player_uuid=player_uuid)
for player_fine in player_fines:
result.append(player_fine.fine.label, )
# return the count of each fines a player has
# ex: {'toto':2, 'titi':1}
final_result = collections.Counter(result)
return final_result
def data_player(team_uuid: uuid) -> Player:
player = Player(
uuid=str(uuid.uuid4()),
first_name='Example',
last_name='Player',
email='*****@*****.**',
password=Passwords.hash_password(TEST_PASSWORD),
banker=False,
team_uuid=team_uuid,
)
return player
def test_player():
team_uuid = str(uuid.uuid4())
team = Team(uuid=team_uuid, label='sdv')
database.db.session.add(team)
player = Player(
uuid=str(uuid.uuid4()),
first_name='Example',
last_name='Player',
email='*****@*****.**',
password=Passwords.hash_password(TEST_PASSWORD),
banker=False,
team_uuid=team_uuid,
)
return player
def send_fines_to_players_email(
self,
banker: bool,
team_uuid: uuid,
) -> None:
if not banker:
raise AuthorizationError(error_code='player_unauthorized')
team = Team.get_team_by_uuid(team_uuid=team_uuid)
if not team:
raise EntityNotFound(error_code='team_not_found')
players = Player.get_players_by_team(team_uuid=team_uuid)
for player in players:
fine_cost = Player.get_player_fine_cost(player_uuid=player.uuid)
mail.send_email(
from_email='*****@*****.**',
to_email=player.email,
subject='Caisse noire payment',
text='You have to pay {} € this month'.format(fine_cost),
)
def signin_player(
self,
player_info,
):
password = player_info.get('password', None)
email = player_info.get('email', None)
if ((password is None or not password)
or (email is None or not email)):
raise ModelCreationError(error_code='missing_parameter')
player = Player.get_player_by_email(player_email=email)
if not player:
raise EntityNotFound(error_code='player_not_found')
token = Passwords.generate_token(player, password)
return jsonify({
'token': token.decode('UTF-8'),
'banker': player.banker,
})
def get_all_players_from_team(
self,
team_uuid,
additional_filters,
):
total_players = Player.get_total_players_by_team(team_uuid)
if not total_players:
raise EntityNotFound(error_code='team_not_found')
players = Player.get_all_players_by_team(team_uuid)
if (additional_filters.get('lastUuid')
and additional_filters.get('lastUuid') != ''):
from_last_uuid = Player.get_player_by_uuid(
player_uuid=additional_filters.get('lastUuid'))
if not from_last_uuid:
raise EntityNotFound(error_code='player_not_found')
# FILTER BY FIRST NAME OR LAST NAME
if (additional_filters.get('filter')
and additional_filters.get('filter') != ''):
players = Player.get_player_by_name(
players=players, filter=additional_filters.get('filter'))
return {
'players': players,
'total_rows': total_players,
}
# FIRST PAGE
if int(additional_filters.get('currentPage')) == 1:
players = Player.get_players_by_limit_per_page(
players=players, limit=int(additional_filters.get('perPage')))
else:
players = Player.get_players_by_lastuuid(
players=players,
from_last_uuid=from_last_uuid,
limit=int(additional_filters.get('perPage')))
return {
'players': players,
'total_rows': total_players,
}