def dispatch(self, request, *args, **kwargs):
fixture_id = self.kwargs['fixture_id']
fixture = get_object_or_404(Fixture, pk=fixture_id)
if not can_administrate_competition(request.user.id, fixture.competition.id):
raise Http404
return super(RearrangementCreate, self).dispatch(request, *args, **kwargs)
def can_submit_match_card(user, fixture):
can_manage_team_a = False
can_administrate = False
from nehlwebsite.utils.auth_utils import can_manage_club, can_administrate_competition
if user.is_authenticated:
if can_manage_club(user.id, fixture.team_a.club.id):
can_manage_team_a = True
if can_administrate_competition(user.id, fixture.competition.id):
can_administrate = True
if not (can_administrate or can_manage_team_a):
return False
else:
return True
def detail(request, rearrangement_id):
rearrangement_request = get_object_or_404(RearrangementRequest, pk=rearrangement_id)
user = request.user
can_administrate = False
if can_administrate_competition(user.id, rearrangement_request.original_fixture.competition.id):
can_administrate = True
response = None
if rearrangement_request.rearrangementresponse_set.count() > 0:
response = rearrangement_request.rearrangementresponse_set.first()
context = {'fixture': rearrangement_request.original_fixture,
'response': response,
'rearrangement': rearrangement_request,
'can_administrate': can_administrate}
return render(request, 'rearrangements/detail.html', context)
def index(request):
rearrangement_requests = RearrangementRequest.objects.all().order_by('-date_time_created')
user = request.user
can_administrate = False
if rearrangement_requests.count() > 0:
if can_administrate_competition(user.id, rearrangement_requests.first().original_fixture.competition.id):
can_administrate = True
else:
can_administrate = True
if not can_administrate:
return HttpResponseForbidden()
paginator = Paginator(rearrangement_requests, 10)
page = request.GET.get('page')
rearrangement_requests = paginator.get_page(page)
return render(request, 'rearrangements/index.html', {'rearrangements': rearrangement_requests})
def submit_result(request, fixture_id):
fixture = get_object_or_404(Fixture, pk=fixture_id)
can_manage_fixture = False
can_administrate = False
user = request.user
if can_manage_club(user.id, fixture.team_a.club.id):
can_manage_fixture = True
if can_manage_club(user.id, fixture.team_b.club.id):
can_manage_fixture = True
if can_administrate_competition(user.id, fixture.competition.id):
can_administrate = True
if not can_manage_fixture and not can_administrate:
return HttpResponseForbidden()
if request.method == "POST":
form = SubmitResultForm(data=request.POST, fixture=fixture)
if form.is_valid():
from fixtures.utils.general import fill_fixture_result
form.instance.fixture = fixture
form.instance = fill_fixture_result(form.instance)
saved = form.save()
fixture.result = saved
fixture.save()
return redirect('fixtures:detail', fixture_id=fixture.id)
elif request.method == "GET":
form = SubmitResultForm(fixture)
else:
return HttpResponseBadRequest()
context = {'form': form, 'fixture': fixture}
return render(request, 'fixtures/submit_result.html', context)
def post(self, request, *args, **kwargs):
if not can_administrate_competition(request.user.id, kwargs['competition']):
return HttpResponseForbidden()
return super().post(request, *args, **kwargs)
def detail(request, fixture_id):
fixture = get_object_or_404(Fixture, pk=fixture_id)
can_manage_fixture = False
can_manage_team_a = False
can_manage_team_b = False
can_administrate = False
rearrangements_allowed = has_config_item(fixture.competition,
'rearrangements_allowed')
user = request.user
if fixture.metadata is None:
fixture.metadata = FixtureMetadata()
if user.is_authenticated:
if can_manage_club(user.id, fixture.team_a.club.id):
can_manage_fixture = True
can_manage_team_a = True
if can_manage_club(user.id, fixture.team_b.club.id):
can_manage_fixture = True
can_manage_team_b = True
if can_administrate_competition(user.id, fixture.competition.id):
can_administrate = True
metadata = fixture.metadata
has_occurred = fixture.date <= datetime.now().date()
squad_a_selected = metadata.squad_a_selected
squad_b_selected = metadata.squad_b_selected
squads_selected = squad_a_selected and squad_b_selected
can_select_squad_a = not squad_a_selected and (can_manage_team_a
or can_administrate)
can_select_squad_b = not squad_b_selected and (
(can_manage_team_a and has_occurred) or can_manage_team_b
or can_administrate)
match_card_completed = squads_selected and metadata.match_card_image is not None \
and metadata.personal_penalties_submitted and metadata.scorers_submitted
can_complete_card = squads_selected and not match_card_completed and has_occurred \
and (can_manage_team_a or can_administrate)
is_cancelled = fixture.fixturecancellation_set.count() > 0
squad_a = Appearance.objects.filter(fixture=fixture, team=fixture.team_a)
squad_b = Appearance.objects.filter(fixture=fixture, team=fixture.team_b)
squads = itertools.zip_longest(squad_a, squad_b)
context = {
'fixture': fixture,
'squads': squads,
'can_manage': can_manage_fixture,
'can_select_squad_a': can_select_squad_a,
'can_select_squad_b': can_select_squad_b,
'can_complete_card': can_complete_card,
'squad_a_selected': squad_a_selected,
'squad_b_selected': squad_b_selected,
'squads_selected': squads_selected,
'card_complete': match_card_completed,
'can_administrate': can_administrate,
'has_occurred': has_occurred,
'rearrangements_allowed': rearrangements_allowed,
'is_cancelled': is_cancelled
}
return render(request, 'fixtures/detail.html', context)
def respond(request, rearrangement_id):
rearrangement_request = get_object_or_404(RearrangementRequest, pk=rearrangement_id)
user = request.user
can_administrate = False
if can_administrate_competition(user.id, rearrangement_request.original_fixture.competition.id):
can_administrate = True
if not can_administrate:
return HttpResponseForbidden()
if request.method == 'POST':
form = RearrangementResponseForm(request.POST)
if form.is_valid():
rearrangement_request.status = form.cleaned_data['answer']
rearrangement_response = RearrangementResponse(
answer=form.cleaned_data['answer'],
reason=form.cleaned_data['reason'],
request=rearrangement_request,
responder=user
)
if form.cleaned_data['answer'] == 'Approved':
old_fixture = rearrangement_request.original_fixture
old_fixture.pk = None
old_fixture.date = rearrangement_request.new_date_time.date()
old_fixture.save()
rearrangement = FixtureRearrangement(
creator=user,
from_fixture=rearrangement_request.original_fixture,
to_fixture=old_fixture,
reason=rearrangement_request.reason
)
rearrangement.save()
rearrangement_request.save()
fixture = rearrangement_request.original_fixture
rearrangement_response.save()
email_context = {'response': rearrangement_response, 'fixture': fixture}
msg_plain = render_to_string('email/all/fixture_rearrangement_response.txt', email_context)
msg_html = render_to_string('email/all/fixture_rearrangement_response.html', email_context)
subject = 'Rearrangement Request'
email_main_club_contacts(fixture.team_a.club, subject, msg_plain, msg_html)
email_main_club_contacts(fixture.team_b.club, subject, msg_plain, msg_html)
parent_competition = get_most_senior_parent_competition(fixture.competition)
email_competition_admins(parent_competition, subject, msg_plain, msg_html)
email_notifications([user.email], subject, msg_plain, msg_html)
return redirect('rearrangements:detail', rearrangement_id=rearrangement_id)
elif request.method == 'GET':
form = RearrangementResponseForm()
else:
return HttpResponseBadRequest()
return render(request, 'rearrangements/respond.html', {'form': form})
