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 create_fine(
self,
banker: bool,
post_data: dict,
team_uuid: uuid,
) -> None:
if not banker:
raise AuthorizationError(error_code='player_unauthorized')
cost = post_data.get('cost', None)
label = post_data.get('label', None)
if ((cost is None or not cost) or (label is None or not label)):
raise ModelCreationError(error_code='missing_parameter')
team = Team.get_team_by_uuid(self, team_uuid=team_uuid)
if not team:
raise EntityNotFound(error_code='team_not_found')
fine = Fine(uuid=str(uuid.uuid4()),
label=post_data['label'],
cost=post_data['cost'],
team_uuid=team.uuid)
db.session.add(fine)
db.session.commit()
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_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,
}
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 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_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')
if not payload['cost'] or not payload['label']:
raise ModelCreationError(error_code='missing_parameter')
fine.label = payload['label']
fine.cost = payload['cost']
db.session.commit()
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 get_all_fines_by_team(
self,
team_uuid,
filters,
):
fines = Fine.get_all_fines_by_team(team_uuid)
total_rows = Fine.get_all_fines_by_team(team_uuid)
# FILTER BY LABEL
if filters.get('filter'):
return {
'fines':
Fine.get_fine_by_label_from_list(
fines,
filters.get('filter'),
),
'total_rows':
total_rows,
}
if int(filters.get('currentPage')) == 1:
fines = Fine.get_fines_limit_from_list(
fines,
int(filters.get('perPage')),
)
else:
from_last_fine = Fine.get_fine_by_uuid(
uuid=filters.get('lastUuid'), )
if not from_last_fine:
raise EntityNotFound(error_code='last_fine_not_found')
fines = Fine.get_fines_other_page_from_list(
fines,
from_last_fine,
int(filters.get('perPage')),
)
return {
'fines': fines,
'total_rows': total_rows,
}
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 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),
)