def get_table(self):
tournament = self.get_tournament()
table = TabbycatTableBuilder(view=self, sort_key="Name")
table.add_adjudicator_columns(tournament.adjudicator_set.all())
feedback_data = []
for adj in tournament.adjudicator_set.all():
count = adj.adjudicatorfeedback_set.count()
feedback_data.append({
'text':
ungettext("%(count)d feedback", "%(count)d feedbacks", count) %
{
'count': count
},
'link':
reverse_tournament('adjfeedback-view-on-adjudicator',
tournament,
kwargs={'pk': adj.id}),
})
table.add_column("Feedbacks", feedback_data)
return table
def get_table(self):
t = self.tournament
table = TabbycatTableBuilder(view=self, sort_key='team')
teams = t.team_set.all().select_related(
'institution').prefetch_related('break_categories', 'speaker_set')
table.add_team_columns(teams)
break_categories = t.breakcategory_set.all()
for bc in break_categories:
table.add_column({
'title': bc.name,
'key': bc.name
}, [{
'component': 'check-cell',
'checked':
True if bc in team.break_categories.all() else False,
'id': team.id,
'type': bc.id
} for team in teams])
return table
def get_table(self):
t = self.get_tournament()
table = TabbycatTableBuilder(view=self, sort_key='team')
speakers = Speaker.objects.filter(team__tournament=t).select_related(
'team', 'team__institution').prefetch_related('categories')
table.add_speaker_columns(speakers, categories=False)
table.add_team_columns([speaker.team for speaker in speakers])
speaker_categories = self.get_tournament().speakercategory_set.all()
for sc in speaker_categories:
table.add_column(
sc.name,
[{
'component': 'check-cell',
'checked':
True if sc in speaker.categories.all() else False,
'id': speaker.id,
'type': sc.id
} for speaker in speakers])
return table
def get_table_by_debate(self):
debates = self.round.debate_set_with_prefetches(results=True,
wins=True)
populate_confirmed_ballots(
debates,
motions=True,
results=self.round.ballots_per_debate == 'per-adj')
table = TabbycatTableBuilder(view=self, sort_key="venue")
table.add_debate_venue_columns(debates)
table.add_debate_results_columns(debates)
if not (self.tournament.pref('teams_in_debate') == 'bp'
and self.round.is_break_round):
table.add_debate_ballot_link_column(debates)
table.add_debate_adjudicators_column(debates, show_splits=True)
if self.tournament.pref('show_motions_in_results'):
table.add_debate_motion_column(debates)
return table
def get_table(self):
round = self.get_round()
table = TabbycatTableBuilder(view=self, sort_key=self.sort_key)
queryset = utils.annotate_availability(self.get_queryset(), round)
table.add_checkbox_columns([inst.available for inst in queryset],
[inst.id for inst in queryset],
"Active Now")
if round.prev:
table.add_column(
"Active in %s" % round.prev.abbreviation,
[{
'sort': inst.prev_available,
'icon': 'glyphicon-ok' if inst.prev_available else ''
} for inst in queryset])
self.add_description_columns(table, queryset)
return table
def get_table(cls, view, participant):
"""On adjudicator record pages, the table is the previous debates table."""
table = TabbycatTableBuilder(view=view,
title=view.table_title,
sort_key="round")
debateadjs = DebateAdjudicator.objects.filter(
adjudicator=participant, ).select_related(
'debate__round', 'debate__round__tournament').prefetch_related(
Prefetch('debate__debateadjudicator_set',
queryset=DebateAdjudicator.objects.select_related(
'adjudicator__institution')),
'debate__debateteam_set__team__speaker_set',
'debate__round__motion_set',
)
if not table.admin and not view.tournament.pref(
'all_results_released') and not table.private_url:
debateadjs = debateadjs.filter(
debate__round__draw_status=Round.STATUS_RELEASED,
debate__round__silent=False,
debate__round__completed=True,
)
elif table.private_url:
debateadjs = debateadjs.filter(
debate__round__draw_status=Round.STATUS_RELEASED)
debates = [da.debate for da in debateadjs]
populate_wins(debates)
populate_confirmed_ballots(debates, motions=True, results=True)
table.add_round_column([debate.round for debate in debates])
table.add_debate_results_columns(debates)
table.add_debate_adjudicators_column(debates,
show_splits=True,
highlight_adj=participant)
if table.admin or view.tournament.pref('public_motions'):
table.add_debate_motion_column(debates)
table.add_debate_ballot_link_column(debates)
return table
def get_table(self):
table = TabbycatTableBuilder(view=self, sort_key="rk")
try:
standings, rounds = self.get_standings()
except StandingsError as e:
messages.error(self.request, self.get_standings_error_message(e))
logger.exception("Error generating standings: " + str(e))
return table
table.add_ranking_columns(standings)
table.add_team_columns([info.team for info in standings],
show_break_categories=True)
table.add_standings_results_columns(standings, rounds,
self.show_ballots())
table.add_metric_columns(
standings,
integer_score_columns=self.integer_score_columns(rounds))
return table
def get_table(self):
table = TabbycatTableBuilder(view=self, sort_key=self.sort_key)
queryset = utils.annotate_availability(self.get_queryset(), self.round)
self.annotate_checkins(queryset, self.tournament)
table.add_column({
'key': 'active',
'title': _("Active Now")
}, [{
'component': 'check-cell',
'checked': inst.available,
'sort': inst.available,
'id': inst.id,
'prev': inst.prev_available if self.round.prev else False,
'checked_in': inst.checked_in,
'type': 0,
} for inst in queryset])
if self.round.prev:
title = _("Active in %(prev_round)s") % {
'prev_round': self.round.prev.abbreviation
}
table.add_column({
'key': 'active',
'title': title
}, [{
'sort': inst.prev_available,
'icon': 'check' if inst.prev_available else ''
} for inst in queryset])
checked_in_header = {'key': "tournament", 'title': _('Checked-In')}
checked_in_data = [{
'sort': inst.checked_in,
'icon': inst.checked_icon,
'tooltip': inst.checked_tooltip,
} for inst in queryset]
table.add_column(checked_in_header, checked_in_data)
self.add_description_columns(table, queryset)
return table
def get_table(self, mixed_participants=False):
table = TabbycatTableBuilder(view=self, sort_key='name')
queryset = self.get_queryset()
default_send_queryset = self.get_default_send_queryset()
table.add_column({
'key': 'send',
'title': _("Send Email")
}, [{
'component': 'check-cell',
'checked': self.default_send(p, default_send_queryset),
'id': p.id,
'name': 'recipients',
'value': p.id,
'noSave': True,
'type': self.get_person_type(p, mixed=mixed_participants),
} for p in queryset])
table.add_column(
{
'key': 'name',
'tooltip': _("Participant"),
'icon': 'user'
}, [{
'text': p.name,
'class': 'no-wrap' if len(p.name) < 20 else '',
} for p in queryset])
table.add_column(
{
'key': 'email',
'tooltip': _("Email address"),
'icon': 'mail'
}, [{
'text': p.email if p.email else _("Not Provided"),
'class': 'small' if p.email else 'small text-warning',
} for p in queryset])
return table
def get_table(self):
round = self.get_round()
table = TabbycatTableBuilder(view=self, sort_key=self.sort_key)
queryset = utils.annotate_availability(self.get_queryset(), round)
table.add_column(_("Active Now"), [{
'component': 'check-cell',
'checked': inst.available,
'sort': inst.available,
'id': inst.id,
'prev': inst.prev_available if round.prev else False,
'type': 0,
} for inst in queryset])
if round.prev:
table.add_column(_("Active in %(prev_round)s") % {'prev_round': round.prev.abbreviation}, [{
'sort': inst.prev_available,
'icon': 'check' if inst.prev_available else ''
} for inst in queryset])
self.add_description_columns(table, queryset)
return table
def get_table(self):
teams = self.tournament.team_set.all()
rounds = self.tournament.prelim_rounds()
tsas = dict()
for tsa in TeamSideAllocation.objects.filter(round__in=rounds):
try:
tsas[(tsa.team.id,
tsa.round.seq)] = get_side_name(self.tournament,
tsa.side, 'abbr')
except ValueError:
pass
table = TabbycatTableBuilder(view=self)
table.add_team_columns(teams)
headers = [round.abbreviation for round in rounds]
data = [[tsas.get((team.id, round.seq), "—") for round in rounds]
for team in teams]
table.add_columns(headers, data)
return table
def get_adjudicators_table(self):
tournament = self.tournament
def _build_url(adjudicator, url_name):
if adjudicator.url_key is None:
return {'text': _("no URL"), 'class': 'text-warning'}
path = reverse_tournament(url_name, tournament, kwargs={'url_key': adjudicator.url_key})
return {'text': self.request.build_absolute_uri(path), 'class': 'small'}
adjudicators = Adjudicator.objects.all() if tournament.pref('share_adjs') else tournament.adjudicator_set.all()
table = TabbycatTableBuilder(view=self, title=_("Adjudicators"), sort_key="name")
table.add_adjudicator_columns(adjudicators, show_institutions=False, show_metadata=False)
table.add_column(
{'key': 'feedback-url', 'title': _("Feedback URL")},
[_build_url(adj, 'adjfeedback-public-add-from-adjudicator-randomised') for adj in adjudicators]
)
table.add_column(
{'key': 'ballot-url', 'title': _("Ballot URL")},
[_build_url(adj, 'results-public-ballotset-new-randomised') for adj in adjudicators]
)
return table
def get_table(self):
tournament = self.get_tournament()
teams = tournament.team_set.all()
rounds = tournament.prelim_rounds()
tpas = dict()
for tpa in TeamPositionAllocation.objects.filter(round__in=rounds):
try:
tpas[(tpa.team.id, tpa.round.seq)] = get_position_name(
tournament, self.TPA_MAP[tpa.position], 'abbr')
except ValueError:
pass
table = TabbycatTableBuilder(view=self)
table.add_team_columns(teams)
headers = [round.abbreviation for round in rounds]
data = [[tpas.get((team.id, round.id), "—") for round in rounds]
for team in teams]
table.add_columns(headers, data)
return table
def get_speakers_table(self):
tournament = self.tournament
def _build_url(speaker):
path = reverse_tournament('adjfeedback-public-add-from-team-randomised', tournament,
kwargs={'url_key': speaker.team.url_key})
return self.request.build_absolute_uri(path)
speakers = self.get_speakers_to_email()
title = _("Speakers who will be sent e-mails (%(n)s)") % {'n': speakers.count()}
table = TabbycatTableBuilder(view=self, title=title, sort_key="team")
table.add_speaker_columns(speakers, categories=False)
table.add_team_columns([speaker.team for speaker in speakers])
table.add_column(
{'key': 'title', 'title': _("Email")},
[speaker.email for speaker in speakers]
)
table.add_column(
{'key': 'feedback-url', 'title': _("Feedback URL")},
[_build_url(speaker) for speaker in speakers]
)
return table
def get_adjudicators_table(self, url_type, url_name, url_header):
tournament = self.get_tournament()
def _build_url(adjudicator):
path = reverse_tournament(url_name,
tournament,
kwargs={'url_key': adjudicator.url_key})
return self.request.build_absolute_uri(path)
adjudicators = self.get_adjudicators_to_email(url_type)
title = _("Adjudicators who will be sent e-mails (%(n)s)") % {
'n': adjudicators.count()
}
table = TabbycatTableBuilder(view=self,
title=title,
sort_key=_("Name"))
table.add_adjudicator_columns(adjudicators,
hide_institution=True,
hide_metadata=True)
table.add_column(_("Email"), [adj.email for adj in adjudicators])
table.add_column(url_header, [_build_url(adj) for adj in adjudicators])
return table
def get_table(self):
"""On team record pages, the table is the results table."""
tournament = self.get_tournament()
teamscores = TeamScore.objects.filter(
debate_team__team=self.object,
ballot_submission__confirmed=True,
debate_team__debate__round__draw_status=Round.STATUS_RELEASED
).select_related('debate_team__debate__round').prefetch_related(
Prefetch('debate_team__debate__debateadjudicator_set',
queryset=DebateAdjudicator.objects.select_related(
'adjudicator__institution')),
'debate_team__debate__debateteam_set')
if not tournament.pref('all_results_released'):
teamscores = teamscores.filter(
debate_team__debate__round__silent=False,
debate_team__debate__round__seq__lt=tournament.current_round.
seq)
debates = [ts.debate_team.debate for ts in teamscores]
populate_opponents([ts.debate_team for ts in teamscores])
populate_confirmed_ballots(debates, motions=True, ballotsets=True)
table = TabbycatTableBuilder(view=self,
title="Results",
sort_key="Round")
table.add_round_column([debate.round for debate in debates])
table.add_debate_result_by_team_columns(teamscores)
table.add_debate_adjudicators_column(debates, show_splits=True)
if self.admin or tournament.pref('public_motions'):
table.add_motion_column([
debate.confirmed_ballot.motion
if debate.confirmed_ballot else None for debate in debates
])
table.add_debate_ballot_link_column(debates)
return table
def get_table(self):
t = self.tournament
table = TabbycatTableBuilder(view=self, sort_key='team')
teams = t.team_set.all().select_related(
'institution').prefetch_related('break_categories', 'speaker_set')
speaker_categories = t.speakercategory_set.order_by('seq')
nspeaker_annotations = {}
for sc in speaker_categories:
nspeaker_annotations['nspeakers_%s' % sc.slug] = Count(
'speaker', filter=Q(speaker__categories=sc))
teams = teams.annotate(**nspeaker_annotations)
table.add_team_columns(teams)
break_categories = t.breakcategory_set.order_by('seq')
for bc in break_categories:
table.add_column({'title': bc.name, 'key': bc.slug}, [{
'component': 'check-cell',
'checked': True if bc in team.break_categories.all() else False,
'sort': True if bc in team.break_categories.all() else False,
'id': team.id,
'type': bc.slug,
} for team in teams])
# Provide list of members within speaker categories for convenient entry
for sc in speaker_categories:
table.add_column({'title': _('%s Speakers') % sc.name, 'key': sc.name + "_speakers"}, [{
'text': getattr(team, 'nspeakers_%s' % sc.slug, 'N/A'),
'tooltip': ngettext(
'Team has %(nspeakers)s speaker with the %(category)s speaker category assigned',
'Team has %(nspeakers)s speakers with the %(category)s speaker category assigned',
getattr(team, 'nspeakers_%s' % sc.slug, 0),
) % {'nspeakers': getattr(team, 'nspeakers_%s' % sc.slug, 'N/A'), 'category': sc.name},
} for team in teams])
return table
def get_table(self):
"""On adjudicator record pages, the table is the previous debates table."""
tournament = self.get_tournament()
debateadjs = DebateAdjudicator.objects.filter(
adjudicator=self.object,
debate__round__draw_status=Round.STATUS_RELEASED).select_related(
'debate__round').prefetch_related(
Prefetch('debate__debateadjudicator_set',
queryset=DebateAdjudicator.objects.select_related(
'adjudicator__institution')),
'debate__debateteam_set__team__speaker_set')
if not tournament.pref('all_results_released'):
debateadjs = debateadjs.filter(
debate__round__silent=False,
debate__round__seq__lt=tournament.current_round.seq,
)
debates = [da.debate for da in debateadjs]
populate_wins(debates)
populate_confirmed_ballots(debates, motions=True, ballotsets=True)
table = TabbycatTableBuilder(view=self,
title="Previous Rounds",
sort_key="Round")
table.add_round_column([debate.round for debate in debates])
table.add_debate_results_columns(debates)
table.add_debate_adjudicators_column(debates,
show_splits=True,
highlight_adj=self.object)
if self.admin or tournament.pref('public_motions'):
table.add_motion_column([
debate.confirmed_ballot.motion
if debate.confirmed_ballot else None for debate in debates
])
table.add_debate_ballot_link_column(debates)
return table
def get_teams_table(self):
tournament = self.get_tournament()
def _build_url(team):
if team.url_key is None:
return {'text': _("no URL"), 'class': 'text-warning'}
path = reverse_tournament(
'adjfeedback-public-add-from-team-randomised',
tournament,
kwargs={'url_key': team.url_key})
return {
'text': self.request.build_absolute_uri(path),
'class': 'small'
}
teams = tournament.team_set.all()
table = TabbycatTableBuilder(view=self,
title=_("Teams"),
sort_key=_("Team"))
table.add_team_columns(teams)
table.add_column(_("Feedback URL"),
[_build_url(team) for team in teams])
return table
def get_table(self):
adjudicators = self.tournament.adjudicator_set.annotate(
feedback_count=Count('adjudicatorfeedback'))
table = TabbycatTableBuilder(view=self, sort_key="name")
table.add_adjudicator_columns(adjudicators)
feedback_data = []
for adj in adjudicators:
count = adj.feedback_count
feedback_data.append({
'text':
ngettext("%(count)d feedback", "%(count)d feedbacks", count) %
{
'count': count
},
'link':
reverse_tournament('adjfeedback-view-on-adjudicator',
self.tournament,
kwargs={'pk': adj.id}),
})
table.add_column({
'key': 'feedbacks',
'title': _("Feedbacks")
}, feedback_data)
return table
def get_table(self):
standings, rounds = self.get_standings()
table = TabbycatTableBuilder(view=self, sort_key="Rk")
# Easiest to redact info here before passing to column constructors
if hasattr(self, 'public_page_preference'):
for info in standings:
if info.speaker.anonymous:
info.speaker.anonymise = True
info.speaker.team.anonymise = True
table.add_ranking_columns(standings)
table.add_speaker_columns([info.speaker for info in standings])
table.add_team_columns([info.speaker.team for info in standings])
scores_headers = [round.abbreviation for round in rounds]
scores_data = [
list(map(metricformat, standing.scores)) for standing in standings
]
table.add_columns(scores_headers, scores_data)
table.add_metric_columns(standings)
return table
def get_tables(self):
tournament = self.tournament
use_code_names = use_team_code_names_data_entry(
self.tournament, self.tabroom)
teams_table = TabbycatTableBuilder(view=self,
sort_key="team",
title=_("A Team"))
add_link_data = [{
'text': team_name_for_data_entry(team, use_code_names),
'link': self.get_from_team_link(team)
} for team in tournament.team_set.all()]
header = {'key': 'team', 'title': _("Team")}
teams_table.add_column(header, add_link_data)
if tournament.pref('show_team_institutions'):
teams_table.add_column(
{
'key': 'institution',
'icon': 'home',
'tooltip': _("Institution"),
}, [
team.institution.code
if team.institution else TabbycatTableBuilder.BLANK_TEXT
for team in tournament.team_set.all()
])
if tournament.pref('share_adjs'):
adjudicators = Adjudicator.objects.filter(
Q(tournament=tournament) | Q(tournament__isnull=True))
else:
adjudicators = tournament.adjudicator_set.all()
adjs_table = TabbycatTableBuilder(view=self,
sort_key="adjudicator",
title=_("An Adjudicator"))
if tournament.pref('share_adjs'):
adjudicators = Adjudicator.objects.filter(
Q(tournament=tournament) | Q(tournament__isnull=True))
else:
adjudicators = tournament.adjudicator_set.all()
add_link_data = [{
'text': adj.name,
'link': self.get_from_adj_link(adj),
} for adj in adjudicators]
header = {'key': 'adjudicator', 'title': _("Adjudicator")}
adjs_table.add_column(header, add_link_data)
if tournament.pref('show_adjudicator_institutions'):
adjs_table.add_column(
{
'key': 'institution',
'icon': 'home',
'tooltip': _("Institution"),
}, [
adj.institution.code
if adj.institution else TabbycatTableBuilder.BLANK_TEXT
for adj in adjudicators
])
return [teams_table, adjs_table]
def get_tables(self):
tables = []
# notifications.sentmessage_set.first().emailstatus_set.first().latest_statuses will be a list
notifications = self.tournament.bulknotification_set.select_related(
'round', ).prefetch_related(
Prefetch(
'sentmessage_set',
queryset=SentMessage.objects.select_related(
'recipient', ).prefetch_related(
Prefetch(
'emailstatus_set',
queryset=EmailStatus.objects.order_by(
'-timestamp'),
to_attr='statuses',
)),
))
for notification in notifications:
if notification.round is not None:
subtitle = notification.round.name
else:
subtitle = _("@ %s") % timezone.localtime(
notification.timestamp).strftime("%a, %d %b %Y %H:%M:%S")
table = TabbycatTableBuilder(
view=self,
title=notification.get_event_display().title(),
subtitle=subtitle)
emails_recipient = []
emails_status = []
emails_time = []
for sentmessage in notification.sentmessage_set.all():
emails_recipient.append(
sentmessage.recipient.name if sentmessage.
recipient else self.UNKNOWN_RECIPIENT_CELL)
if len(sentmessage.statuses) > 0:
latest_status = sentmessage.statuses[0] # already ordered
status_cell = {
"text": latest_status.get_event_display(),
"class": self._get_event_class(latest_status.event),
"popover": {
"title":
_("Timeline"),
"content":
self._create_status_timeline(sentmessage.statuses),
},
}
emails_status.append(status_cell)
emails_time.append(latest_status.timestamp)
else:
emails_status.append(self.NA_CELL)
emails_time.append(self.NA_CELL)
table.add_column(
{
'key': 'name',
'tooltip': _("Participant"),
'icon': 'user'
}, emails_recipient)
table.add_column({
'key': 'name',
'title': _("Status")
}, emails_status)
table.add_column({'key': 'name', 'title': _("Time")}, emails_time)
tables.append(table)
return tables
def get_table(self):
table = TabbycatTableBuilder(view=self, sort_key='name')
table.add_adjudicator_columns(self.tournament.adjudicator_set.filter(breaking=True))
return table
