342 lines
12 KiB
Python
342 lines
12 KiB
Python
"""Team match management routes for regular season matches.
|
|
|
|
Uses polymorphic isinstance checks instead of role-string comparisons.
|
|
"""
|
|
|
|
from flask import Blueprint, flash, jsonify, render_template, request, url_for
|
|
from flask_babel import gettext as _
|
|
from flask_login import current_user, login_required
|
|
from marshmallow import ValidationError
|
|
|
|
from app.api import json_endpoint
|
|
from app.extensions import db
|
|
from app.forms import flash_validation_errors, form_payload
|
|
from app.models import (
|
|
Admin,
|
|
AppSettings,
|
|
Coach,
|
|
Manager,
|
|
OrgTeam,
|
|
Player,
|
|
TeamMatch,
|
|
TeamMatchParticipant,
|
|
TeamPlayer,
|
|
)
|
|
from app.pagination import paginate
|
|
from app.permissions import coach_org_teams, representative_org_teams, visible_org_teams
|
|
from app.responders import respond_after_change
|
|
from app.routes.matches import default_end_time
|
|
from app.services.scheduling import notify_participants, zip_participants
|
|
from app.time_utils import utc_now_naive
|
|
from app.validators import TeamMatchSchema
|
|
|
|
team_matches_bp = Blueprint('team_matches', __name__, url_prefix='/team-matches')
|
|
|
|
|
|
def can_manage_team_match(team):
|
|
"""Whether the current user can manage matches for this team.
|
|
|
|
Everyone who administers the team, plus the player named as its
|
|
responsible. Narrower than administering the team itself: a responsible
|
|
schedules and edits matches, but does not touch the roster.
|
|
"""
|
|
return current_user.can_manage_team_matches(team)
|
|
|
|
|
|
def season_locked():
|
|
"""Return True when the regular season is inactive for non-admins.
|
|
|
|
Admins bypass the lock. Coaches and managers may only schedule regular
|
|
season matches while the season is active.
|
|
"""
|
|
if isinstance(current_user, Admin):
|
|
return False
|
|
return not AppSettings.get_bool('season_active', default=False)
|
|
|
|
|
|
@team_matches_bp.route('')
|
|
@login_required
|
|
def list_matches():
|
|
"""List all team matches visible to the current user."""
|
|
filter_team_id = request.args.get('team_id', type=int)
|
|
|
|
# A manager administers every team, so the listing shows them all;
|
|
# visible_org_teams() only reports the teams they are attached to.
|
|
if isinstance(current_user, (Admin, Manager)):
|
|
teams = OrgTeam.query.order_by(OrgTeam.name).all()
|
|
matches_query = TeamMatch.query
|
|
elif isinstance(current_user, (Coach, Player)):
|
|
teams = visible_org_teams(current_user)
|
|
team_ids = [t.id for t in teams]
|
|
matches_query = (
|
|
TeamMatch.query.filter(
|
|
TeamMatch.org_team_id.in_(team_ids),
|
|
)
|
|
if team_ids
|
|
else TeamMatch.query.filter(TeamMatch.id == -1)
|
|
)
|
|
else:
|
|
teams = []
|
|
matches_query = TeamMatch.query.filter(TeamMatch.id == -1)
|
|
|
|
if filter_team_id:
|
|
matches_query = matches_query.filter(TeamMatch.org_team_id == filter_team_id)
|
|
|
|
# Pagination also bounds the per-match participant loop below, which is
|
|
# the N+1 the constat pointed at (MNT-10 combined with MNT-14).
|
|
matches_page = paginate(matches_query.order_by(TeamMatch.date.desc(), TeamMatch.id))
|
|
matches = matches_page.items
|
|
|
|
match_data = []
|
|
for tm in matches:
|
|
confirmed, total = tm.get_confirmed_count()
|
|
participants = []
|
|
for p in tm.participants.all():
|
|
participants.append(
|
|
{
|
|
'id': p.id,
|
|
'player': p.player,
|
|
'is_confirmed': p.is_confirmed,
|
|
}
|
|
)
|
|
match_data.append(
|
|
{
|
|
'match': tm,
|
|
'participants': participants,
|
|
'confirmed_count': confirmed,
|
|
'total_count': total,
|
|
}
|
|
)
|
|
|
|
return render_template(
|
|
'pages/team_matches.html',
|
|
teams=teams,
|
|
match_data=match_data,
|
|
pagination=matches_page,
|
|
now=utc_now_naive(),
|
|
)
|
|
|
|
|
|
@team_matches_bp.route('/<int:team_id>/create', methods=['GET', 'POST'])
|
|
@login_required
|
|
def create_match(team_id):
|
|
"""Create a new regular-season team match."""
|
|
team = db.get_or_404(OrgTeam, team_id)
|
|
if season_locked():
|
|
flash(
|
|
'The regular season is not active. Begin a season before scheduling matches.', 'warning'
|
|
)
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
if not can_manage_team_match(team):
|
|
flash(_('You do not have permission to schedule matches for this team.'), 'danger')
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
team_players = TeamPlayer.query.filter_by(org_team_id=team_id).all()
|
|
prefill_date = request.args.get('date', '')
|
|
is_practice = request.args.get('type') == 'practice'
|
|
default_title = 'Practice' if is_practice else f'Team Match — {team.name}'
|
|
|
|
if is_practice and request.method == 'GET':
|
|
|
|
class TryoutProxy:
|
|
def __init__(self, team_obj):
|
|
self.id = 0
|
|
self.title = team_obj.name
|
|
self.date = ''
|
|
self.game = ''
|
|
self.target_org_team = team_obj
|
|
|
|
proxy_tryout = TryoutProxy(team)
|
|
all_players = [tp.player for tp in team_players if tp.player]
|
|
|
|
return render_template(
|
|
'pages/match_form.html',
|
|
tryout=proxy_tryout,
|
|
teams=[],
|
|
all_players=all_players,
|
|
prefill_date=prefill_date,
|
|
is_practice=True,
|
|
team_id=team_id,
|
|
team=team,
|
|
)
|
|
|
|
if request.method == 'POST':
|
|
payload = form_payload(list_fields=(), optional_blank=())
|
|
# A practice has no opponent, whatever the form sent.
|
|
payload.setdefault('title', default_title)
|
|
if is_practice:
|
|
payload.pop('opponent', None)
|
|
|
|
try:
|
|
data = TeamMatchSchema().load(payload)
|
|
except ValidationError as err:
|
|
flash_validation_errors(err)
|
|
return render_template(
|
|
'pages/team_match_form.html',
|
|
team=team,
|
|
team_players=team_players,
|
|
prefill_date=prefill_date,
|
|
is_practice=is_practice,
|
|
)
|
|
|
|
start_time = data['start_time']
|
|
end_time = data['end_time'] or default_end_time(data['date'], start_time)
|
|
|
|
team_match = TeamMatch(
|
|
org_team_id=team_id,
|
|
title=data['title'],
|
|
description=data['description'],
|
|
opponent=data['opponent'],
|
|
date=data['date'],
|
|
start_time=start_time,
|
|
end_time=end_time,
|
|
location=data['location'],
|
|
created_by=current_user.id,
|
|
)
|
|
db.session.add(team_match)
|
|
db.session.flush()
|
|
|
|
notified_participant_ids = []
|
|
for tp in team_players:
|
|
participant = TeamMatchParticipant(
|
|
team_match_id=team_match.id,
|
|
player_id=tp.player_id,
|
|
)
|
|
db.session.add(participant)
|
|
db.session.flush()
|
|
notified_participant_ids.append(participant.id)
|
|
|
|
db.session.commit()
|
|
|
|
notify_participants(
|
|
title=team_match.title,
|
|
date=team_match.date,
|
|
start_time=start_time,
|
|
end_time=end_time,
|
|
participants=zip_participants(
|
|
[tp.player_id for tp in team_players], notified_participant_ids
|
|
),
|
|
fallback_id=team_match.id,
|
|
)
|
|
|
|
flash(
|
|
_('Team match "%(title)s" scheduled successfully!', title=team_match.title), 'success'
|
|
)
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
return render_template('pages/team_match_form.html', team=team, team_players=team_players)
|
|
|
|
|
|
@team_matches_bp.route('/<int:match_id>/edit', methods=['GET', 'POST'])
|
|
@login_required
|
|
def edit_match(match_id):
|
|
"""Edit an existing team match."""
|
|
team_match = db.get_or_404(TeamMatch, match_id)
|
|
team = team_match.org_team
|
|
|
|
if not can_manage_team_match(team):
|
|
flash(_('You do not have permission to edit this match.'), 'danger')
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
if request.method == 'POST':
|
|
# The three date and time fields used to be checked one at a time,
|
|
# each flashing and redirecting on its own: a form with two mistakes
|
|
# took two round trips to be told about both. One schema now, every
|
|
# problem reported at once and in place.
|
|
#
|
|
# Known limit: the re-render reads the stored record, so what was
|
|
# typed is not echoed back. Repopulating the form from the
|
|
# submission is a separate change to the template.
|
|
try:
|
|
data = TeamMatchSchema().load(form_payload(list_fields=(), optional_blank=()))
|
|
except ValidationError as err:
|
|
flash_validation_errors(err)
|
|
return render_template(
|
|
'pages/team_match_form.html', match=team_match, team=team, team_players=[]
|
|
)
|
|
|
|
team_match.title = data['title']
|
|
team_match.description = data['description']
|
|
team_match.opponent = data['opponent']
|
|
team_match.date = data['date']
|
|
team_match.start_time = data['start_time']
|
|
team_match.end_time = data['end_time'] or default_end_time(data['date'], data['start_time'])
|
|
team_match.location = data['location']
|
|
team_match.status = data['status']
|
|
|
|
db.session.commit()
|
|
flash(_('Match updated successfully!'), 'success')
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
return render_template(
|
|
'pages/team_match_form.html', match=team_match, team=team, team_players=[]
|
|
)
|
|
|
|
|
|
@team_matches_bp.route('/<int:match_id>/delete', methods=['POST'])
|
|
@login_required
|
|
def delete_match(match_id):
|
|
"""Delete a team match."""
|
|
team_match = db.get_or_404(TeamMatch, match_id)
|
|
team = team_match.org_team
|
|
if season_locked():
|
|
flash(
|
|
'The regular season is not active. Begin a season before deleting matches.', 'warning'
|
|
)
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
if not can_manage_team_match(team):
|
|
flash(_('You do not have permission to delete this match.'), 'danger')
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
db.session.delete(team_match)
|
|
db.session.commit()
|
|
flash(_('Match deleted successfully.'), 'success')
|
|
return respond_after_change(url_for('team_matches.list_matches'))
|
|
|
|
|
|
@team_matches_bp.route('/api/manageable-teams')
|
|
@json_endpoint
|
|
@login_required
|
|
def api_manageable_teams():
|
|
"""API endpoint returning teams the current user can schedule matches for."""
|
|
if isinstance(current_user, (Admin, Manager)):
|
|
teams = OrgTeam.query.order_by(OrgTeam.name).all()
|
|
elif isinstance(current_user, Coach):
|
|
teams = coach_org_teams(current_user)
|
|
elif isinstance(current_user, Player):
|
|
# A responsible schedules matches for their own team(s) only.
|
|
teams = representative_org_teams(current_user)
|
|
else:
|
|
return jsonify([])
|
|
|
|
return jsonify([{'id': t.id, 'name': t.name} for t in teams])
|
|
|
|
|
|
@team_matches_bp.route('/<int:match_id>/toggle-presence/<int:participant_id>', methods=['POST'])
|
|
@json_endpoint
|
|
@login_required
|
|
def toggle_presence(match_id, participant_id):
|
|
"""Toggle is_confirmed for a team match participant."""
|
|
team_match = db.get_or_404(TeamMatch, match_id)
|
|
team = team_match.org_team
|
|
|
|
participant = db.get_or_404(TeamMatchParticipant, participant_id)
|
|
if participant.team_match_id != match_id:
|
|
return jsonify({'error': 'Participant does not belong to this match'}), 400
|
|
|
|
can_toggle = can_manage_team_match(team) or participant.player_id == current_user.id
|
|
if not can_toggle:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
participant.is_confirmed = not participant.is_confirmed
|
|
db.session.commit()
|
|
return jsonify(
|
|
{
|
|
'participant_id': participant.id,
|
|
'is_confirmed': participant.is_confirmed,
|
|
'player_name': participant.player.username if participant.player else 'Unknown',
|
|
}
|
|
)
|