def entries_csv(request, sel_event_id):
entries = []
# Get event
event = get_object_or_404(Event, pk=sel_event_id)
# Find all compos and their top 3 entries
compos = Compo.objects.filter(event=event)
# Get the entries
for compo in compos:
compo_results = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
if len(compo_results) > 3:
entries = entries + compo_results[:3]
else:
entries = entries + compo_results
# Placements, copypasta
for entry in entries:
m = entry.get_rank()
if m == 1:
entry.placement = 'I'
if m == 2:
entry.placement = 'II'
if m == 3:
entry.placement = 'III'
# Respond with entries CSV (text/csv)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="instanssi_entries.csv"'
t = loader.get_template('admin_kompomaatti/entries_csv.txt')
response.write(t.render({
'entries': entries,
}))
return response
def json_event(request, event_id):
_event = get_object_or_404(Event, pk=int(event_id), archived=True)
# Get all compos that are active but not hidden from archive
entries_out = []
compos_out = []
for c in Compo.objects.filter(event=_event, active=True, hide_from_archive=False):
if c.show_voting_results:
entries = entrysort.sort_by_score(Entry.objects.filter(compo=c))
else:
entries = Entry.objects.filter(compo=c).order_by("name")
compos_out.append({"id": c.pk, "name": c.name, "entry_count": len(entries)})
for e in entries:
entries_out.append(
{
"id": e.id,
"compo_name": c.name,
"compo_id": c.pk,
"entry_name": e.name,
"entry_author": e.creator,
"entry_score": round(e.get_score(), 2),
"entry_rank": e.get_rank(),
"entry_result_url": get_url(e.entryfile.url),
"entry_source_url": get_url(e.sourcefile.url) if e.sourcefile else None,
"entry_youtube_url": e.youtube_url if e.youtube_url else None,
"entry_image_thumbnail": get_url(e.imagefile_thumbnail.url) if e.imagefile_thumbnail else None,
"entry_image_medium": get_url(e.imagefile_medium.url) if e.imagefile_medium else None,
"entry_image_original": get_url(e.imagefile_original.url) if e.imagefile_original else None,
}
)
return JsonResponse({"entries": entries_out, "compos": compos_out})
def results(request, sel_event_id):
# Get compos. competitions
compos = Compo.objects.filter(event_id=int(sel_event_id))
competitions = Competition.objects.filter(event_id=int(sel_event_id))
# Get the entries
compo_results = {}
for compo in compos:
compo_results[compo] = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
# Get competition participations
competition_results = {}
for competition in competitions:
rankby = '-score'
if competition.score_sort == 1:
rankby = 'score'
competition_results[competition.name] = \
CompetitionParticipation.objects.filter(competition=competition).order_by(rankby)
# Render response
return admin_render(request, "admin_kompomaatti/results.html", {
'compo_results': compo_results,
'competition_results': competition_results,
'selected_event_id': int(sel_event_id),
})
def slide_entries(request, sel_event_id, compo_id):
# Get the compo
c = get_object_or_404(Compo, pk=compo_id)
# Get the entries
s_entries = entrysort.sort_by_score(Entry.objects.filter(compo=c, disqualified=False))
i = 0
flip = False
f_entries = []
for entry in s_entries:
if flip: g = 180
else: g = 0
f_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'x': 0,
'y': -i * 2500,
'z': 0,
'rot_y': 0,
'rot_x': g,
'rot_z': 0,
})
i = i + 1
flip = not flip
# Render
return admin_render(request, 'admin_slides/slide_entries.html', {
'entries': f_entries,
'compo': c,
'last_y': - i * 2500,
'last_rot_x': flip,
'selected_event_id': int(sel_event_id),
})
def results(request, sel_event_id):
# Get compos. competitions
compos = Compo.objects.filter(event_id=int(sel_event_id))
competitions = Competition.objects.filter(event_id=int(sel_event_id))
# Get the entries
compo_results = {}
for compo in compos:
compo_results[compo] = entrysort.sort_by_score(
Entry.objects.filter(compo=compo))
# Get competition participations
competition_results = {}
for competition in competitions:
rankby = '-score'
if competition.score_sort == 1:
rankby = 'score'
competition_results[competition.name] = \
CompetitionParticipation.objects.filter(competition=competition).order_by(rankby)
# Render response
return admin_render(
request, "admin_kompomaatti/results.html", {
'compo_results': compo_results,
'competition_results': competition_results,
'selected_event_id': int(sel_event_id),
})
def json_event(request, event_id):
_event = get_object_or_404(Event, pk=int(event_id), archived=True)
# Get all compos that are active but not hidden from archive
entries_out = []
compos_out = []
for c in Compo.objects.filter(event=_event,
active=True,
hide_from_archive=False):
if c.show_voting_results:
entries = entrysort.sort_by_score(Entry.objects.filter(compo=c))
else:
entries = Entry.objects.filter(compo=c).order_by('name')
compos_out.append({
'id': c.pk,
'name': c.name,
'entry_count': len(entries)
})
for e in entries:
entries_out.append({
'id':
e.id,
'compo_name':
c.name,
'compo_id':
c.pk,
'entry_name':
e.name,
'entry_author':
e.creator,
'entry_score':
round(e.get_score(), 2),
'entry_rank':
e.get_rank(),
'entry_result_url':
get_url(e.entryfile.url),
'entry_source_url':
get_url(e.sourcefile.url) if e.sourcefile else None,
'entry_youtube_url':
e.youtube_url if e.youtube_url else None,
'entry_image_thumbnail':
get_url(e.imagefile_thumbnail.url)
if e.imagefile_thumbnail else None,
'entry_image_medium':
get_url(e.imagefile_medium.url)
if e.imagefile_medium else None,
'entry_image_original':
get_url(e.imagefile_original.url)
if e.imagefile_original else None
})
return JsonResponse({'entries': entries_out, 'compos': compos_out})
def slide_results(request, sel_event_id, compo_id):
# Get the compo
c = get_object_or_404(Compo, pk=compo_id)
# Get the entries
s_entries = entrysort.sort_by_score(
Entry.objects.filter(compo=c, disqualified=False))
i = 0
f_entries = []
for entry in reversed(s_entries[:3]):
f_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'platform': entry.platform,
'score': entry.get_score(),
'score_x': 0,
'score_y': i * 2000,
'score_z': i * 2000,
'info_x': 0,
'info_y': i * 2000 + 2000,
'info_z': i * 2000 + 2000,
'rank': entry.get_rank(),
})
i += 2
r_entries = []
for entry in s_entries[3:]:
r_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'score': entry.get_score(),
'rank': entry.get_rank(),
})
i += 1
# Render
return admin_render(
request, 'admin_slides/slide_results.html', {
'entries': f_entries,
'r_entries': r_entries,
'compo': c,
'endinfo_x': 0,
'endinfo_y': (i + 1) * 2000,
'endinfo_z': (i + 1) * 2000,
'last_x': 0,
'last_y': (i + 2) * 2000,
'last_z': (i + 2) * 2000,
'selected_event_id': int(sel_event_id),
})
def get_rank(self):
# If rank has been predefined, then use that
if self.archive_rank:
return self.archive_rank
# Otherwise calculate ranks by score
entries = entrysort.sort_by_score(Entry.objects.filter(compo=self.compo))
n = 1
for e in entries:
if e.id == self.id:
return n
n += 1
return n
def get_rank(self):
# If rank has been predefined, then use that
if self.archive_rank:
return self.archive_rank
# Otherwise calculate ranks by score
entries = entrysort.sort_by_score(Entry.objects.filter(compo=self.compo))
n = 1
for e in entries:
if e.id == self.id:
return n
n += 1
return n
def slide_results(request, sel_event_id, compo_id):
# Get the compo
c = get_object_or_404(Compo, pk=compo_id)
# Get the entries
s_entries = entrysort.sort_by_score(Entry.objects.filter(compo=c, disqualified=False))
i = 0
f_entries = []
for entry in reversed(s_entries[:3]):
f_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'score': entry.get_score(),
'score_x': 0,
'score_y': i * 2000,
'score_z': i * 2000,
'info_x': 0,
'info_y': i * 2000 + 2000,
'info_z': i * 2000 + 2000,
'rank': entry.get_rank(),
})
i = i + 2
r_entries = []
for entry in s_entries[3:]:
r_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'score': entry.get_score(),
'rank': entry.get_rank(),
})
i = i + 1
# Render
return admin_render(request, 'admin_slides/slide_results.html', {
'entries': f_entries,
'r_entries': r_entries,
'compo': c,
'endinfo_x': 0,
'endinfo_y': (i+1) * 2000,
'endinfo_z': (i+1) * 2000,
'last_x': 0,
'last_y': (i+2) * 2000,
'last_z': (i+2) * 2000,
'selected_event_id': int(sel_event_id),
})
def text_event(request, event_id):
_event = get_object_or_404(Event, pk=int(event_id), archived=True)
# Get all compos that are active but not hidden from archive
compos = []
for compo in Compo.objects.filter(event=_event, active=True, hide_from_archive=False):
if compo.show_voting_results:
compo.entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
compo.entries = Entry.objects.filter(compo=compo).order_by("name")
compos.append(compo)
# Render Event frontpage
return render(
request, "arkisto/results.txt", {"event": _event, "compos": compos}, content_type="text/plain; charset=utf-8"
)
def event(request, event_id):
# Get event
event_obj = get_object_or_404(Event, pk=event_id, archived=True)
# Filter compos, videos and competitions
compos_q = Compo.objects.filter(event=event_obj,
active=True,
hide_from_archive=False)
videos_q = OtherVideoCategory.objects.filter(
event=event_obj).order_by('name')
competitions_q = Competition.objects.filter(
event=event_obj, active=True, hide_from_archive=False).order_by('name')
# Get all compos that are active but not hidden from archive
compo_list = []
for compo in compos_q:
if compo.show_voting_results:
compo.entries = entrysort.sort_by_score(
Entry.objects.filter(compo=compo))
else:
compo.entries = Entry.objects.filter(compo=compo).order_by('name')
compo_list.append(copy(compo))
# Get other videos
video_list = []
for cat in videos_q:
cat.videos = OtherVideo.objects.filter(category=cat)
video_list.append(copy(cat))
# Get competitions
competition_list = []
for comp in competitions_q:
rankby = '-score'
if comp.score_sort == 1:
rankby = 'score'
comp.participants = CompetitionParticipation.objects.filter(
competition=comp).order_by(rankby)
competition_list.append(copy(comp))
# Render Event frontpage
return render(
request, 'arkisto/index.html', {
'event': event_obj,
'compos': compo_list,
'videos': video_list,
'competitions': competition_list,
})
def text_event(request, event_id):
_event = get_object_or_404(Event, pk=int(event_id), archived=True)
# Get all compos that are active but not hidden from archive
compos = []
for compo in Compo.objects.filter(event=_event, active=True, hide_from_archive=False):
if compo.show_voting_results:
compo.entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
compo.entries = Entry.objects.filter(compo=compo).order_by('name')
compos.append(compo)
# Render Event frontpage
return render(request, 'arkisto/results.txt', {
'event': _event,
'compos': compos,
}, content_type='text/plain; charset=utf-8')
def event(request, event_id):
# Get event
event_obj = get_object_or_404(Event, pk=event_id, archived=True)
# Filter compos, videos and competitions
compos_q = Compo.objects.filter(event=event_obj, active=True, hide_from_archive=False).order_by('name')
videos_q = OtherVideoCategory.objects.filter(event=event_obj).order_by('name')
competitions_q = Competition.objects.filter(event=event_obj, active=True, hide_from_archive=False).order_by('name')
# Get all compos that are active but not hidden from archive
compo_list = []
for compo in compos_q:
if compo.show_voting_results:
compo.entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
compo.entries = Entry.objects.filter(compo=compo).order_by('name')
compo_list.append(copy(compo))
# Get other videos
video_list = []
for cat in videos_q:
cat.videos = OtherVideo.objects.filter(category=cat)
video_list.append(copy(cat))
# Get competitions
competition_list = []
for comp in competitions_q:
rankby = '-score'
if comp.score_sort == 1:
rankby = 'score'
comp.participants = CompetitionParticipation.objects.filter(competition=comp).order_by(rankby)
competition_list.append(copy(comp))
# Render Event frontpage
return render(request, 'arkisto/index.html', {
'event': event_obj,
'compos': compo_list,
'videos': video_list,
'competitions': competition_list,
})
def slide_entries(request, sel_event_id, compo_id):
# Get the compo
c = get_object_or_404(Compo, pk=compo_id)
# Get the entries
s_entries = entrysort.sort_by_score(
Entry.objects.filter(compo=c, disqualified=False))
i = 0
flip = False
f_entries = []
for entry in s_entries:
if flip:
g = 180
else:
g = 0
f_entries.append({
'id': entry.id,
'creator': entry.creator,
'name': entry.name,
'platform': entry.platform,
'x': 0,
'y': -i * 2500,
'z': 0,
'rot_y': 0,
'rot_x': g,
'rot_z': 0,
})
i += 1
flip = not flip
# Render
return admin_render(
request, 'admin_slides/slide_entries.html', {
'entries': f_entries,
'compo': c,
'last_y': -i * 2500,
'last_rot_x': flip,
'selected_event_id': int(sel_event_id),
})
def entries_csv(request, sel_event_id):
entries = []
# Get event
event = get_object_or_404(Event, pk=sel_event_id)
# Find all compos and their top 3 entries
compos = Compo.objects.filter(event=event)
# Get the entries
for compo in compos:
compo_results = entrysort.sort_by_score(
Entry.objects.filter(compo=compo))
if len(compo_results) > 3:
entries = entries + compo_results[:3]
else:
entries = entries + compo_results
# Placements, copypasta
for entry in entries:
m = entry.get_rank()
if m == 1:
entry.placement = 'I'
if m == 2:
entry.placement = 'II'
if m == 3:
entry.placement = 'III'
# Respond with entries CSV (text/csv)
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename="instanssi_entries.csv"'
t = loader.get_template('admin_kompomaatti/entries_csv.txt')
c = Context({
'entries': entries,
})
response.write(t.render(c))
return response
def event(request, event_id):
# Get event
event = get_object_or_404(Event, pk=int(event_id), archived=True)
# Get all compos that are active but not hidden from archive
compos = Compo.objects.filter(event=event, active=True, hide_from_archive=False)
compolist = []
for compo in compos:
if compo.show_voting_results:
compo.entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
compo.entries = Entry.objects.filter(compo=compo).order_by('name')
compolist.append(compo)
# Get other videos
cats = OtherVideoCategory.objects.filter(event=event).order_by('name')
videolist = []
for cat in cats:
cat.videos = OtherVideo.objects.filter(category=cat)
videolist.append(cat)
# Get competitions
competitionlist = []
comps = Competition.objects.filter(event=event, active=True, hide_from_archive=False).order_by('name')
for comp in comps:
rankby = '-score'
if comp.score_sort == 1:
rankby = 'score'
comp.participants = CompetitionParticipation.objects.filter(competition=comp).order_by(rankby)
competitionlist.append(comp)
# Render Event frontpage
return render_to_response('arkisto/index.html', {
'event': event,
'compos': compolist,
'videos': videolist,
'competitionlist': competitionlist,
}, context_instance=RequestContext(request))
def compo_details(request, event_id, compo_id):
# Get compo
compo = compo_times_formatter(get_object_or_404(Compo, pk=compo_id, active=True, event=event_id))
# Check if user may vote (voting open, user has code)
can_vote = False
if request.user.is_active and request.user.is_authenticated():
try:
VoteCode.objects.get(associated_to=request.user, event=event_id)
can_vote = True
except VoteCode.DoesNotExist:
pass
# See if ticket is used as votecode
try:
TicketVoteCode.objects.get(associated_to=request.user, event=event_id)
can_vote = True
except TicketVoteCode.DoesNotExist:
pass
# Handle entry adding
if request.method == 'POST' and compo.is_adding_open():
# Make sure user is authenticated
if not request.user.is_active or not request.user.is_authenticated():
raise Http403
# Handle data
entryform = EntryForm(request.POST, request.FILES, compo=compo)
if entryform.is_valid():
entry = entryform.save(commit=False)
entry.user = request.user
entry.compo = compo
entry.save()
return HttpResponseRedirect(reverse('km:compo', args=(event_id, compo_id,)))
else:
entryform = EntryForm(compo=compo)
# Get entries, and only show them if voting has started
# (only show results if it has been allowed in model)
all_entries = []
if compo.has_voting_started:
if compo.show_voting_results:
all_entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
all_entries = Entry.objects.filter(compo=compo).order_by('name')
# Stuff for users that have logged in
my_entries = []
has_voted = False
if request.user.is_active and request.user.is_authenticated():
# Get all entries added by the user
my_entries = Entry.objects.filter(compo=compo, user=request.user)
# Check if user has already voted
if Vote.objects.filter(user=request.user, compo=compo).count() > 0:
has_voted = True
# Dump template
return render(request, 'kompomaatti/compo_details.html', {
'sel_event_id': int(event_id),
'compo': compo,
'entryform': entryform,
'can_vote': can_vote,
'all_entries': all_entries,
'my_entries': my_entries,
'has_voted': has_voted,
})
def compo_details(request, event_id, compo_id):
# Get compo
compo = compo_times_formatter(get_object_or_404(Compo, pk=compo_id, active=True, event=event_id))
# Check if user may vote (voting open, user has code)
can_vote = False
if request.user.is_active and request.user.is_authenticated:
# See if ticket is used as votecode
try:
TicketVoteCode.objects.get(associated_to=request.user, event=event_id)
can_vote = True
except TicketVoteCode.DoesNotExist:
pass
if not can_vote:
try:
VoteCodeRequest.objects.get(user=request.user, event=event_id, status=1)
can_vote = True
except VoteCodeRequest.DoesNotExist:
pass
# Handle entry adding
if request.method == 'POST' and compo.is_adding_open():
# Make sure user is authenticated
if not request.user.is_active or not request.user.is_authenticated:
raise Http403
# Handle data
entryform = EntryForm(request.POST, request.FILES, compo=compo)
if entryform.is_valid():
entry = entryform.save(commit=False)
entry.user = request.user
entry.compo = compo
entry.save()
return HttpResponseRedirect(reverse('km:compo', args=(event_id, compo_id,)))
else:
entryform = EntryForm(compo=compo)
# Get entries, and only show them if voting has started
# (only show results if it has been allowed in model)
all_entries = []
if compo.has_voting_started:
if compo.show_voting_results:
all_entries = entrysort.sort_by_score(Entry.objects.filter(compo=compo))
else:
all_entries = Entry.objects.filter(compo=compo).order_by('name')
# Stuff for users that have logged in
my_entries = []
has_voted = False
if request.user.is_active and request.user.is_authenticated:
# Get all entries added by the user
my_entries = Entry.objects.filter(compo=compo, user=request.user)
# Check if user has already voted
if Vote.objects.filter(user=request.user, compo=compo).count() > 0:
has_voted = True
# Dump template
return render(request, 'kompomaatti/compo_details.html', {
'sel_event_id': int(event_id),
'compo': compo,
'entryform': entryform,
'can_vote': can_vote,
'all_entries': all_entries,
'my_entries': my_entries,
'has_voted': has_voted,
})
