def get(self):
user = users.get_current_user()
if user:
log_out_url = users.create_logout_url("/")
coach = Coach.all().filter("user ="******"<img src='http://www.oldworldfootball.com/%s'/>" % (
match.teamAlogo)
return html
def logoB_getter(match):
html = "<img src='http://www.oldworldfootball.com/%s'/>" % (
match.teamBlogo)
return html
def nameA_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
html = "%s (%s - %s)" % (match.teamA, match.teamAcoach,
match.teamArace)
return html
def nameB_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
html = "%s (%s - %s)" % (match.teamB, match.teamBcoach,
match.teamBrace)
return html
def key_name_getter(prediction):
return prediction.key().name()
def choice_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
#html = "<img src='./get_wager_pic?keyname=%s&team=A'/>" % (prediction.key().name())
html = "<img src='http://www.oldworldfootball.com/%s'/>" % (
match.teamAlogo)
if not match.gamePlayed:
html += "<input type='radio' name='%schoice' value='-1' %s>" % (
match.key().name(), prediction.isChecked(-1))
html += "<input type='radio' name='%schoice' value='0' %s>" % (
match.key().name(), prediction.isChecked(0))
html += "<input type='radio' name='%schoice' value='1' %s>" % (
match.key().name(), prediction.isChecked(1))
else:
html += "<input type='radio' name='%schoice' value='-1' disabled %s>" % (
match.key().name(), prediction.isChecked(-1))
html += "<input type='radio' name='%schoice' value='0' disabled %s>" % (
match.key().name(), prediction.isChecked(0))
html += "<input type='radio' name='%schoice' value='1' disabled %s>" % (
match.key().name(), prediction.isChecked(1))
html += "<img src='http://www.oldworldfootball.com/%s'/>" % (
match.teamBlogo)
#html += "<img src='./get_wager_pic?keyname=%s&team=B'/>" % (prediction.key().name())
return html
# Bypassing table.html Django template to create this table
# Table requires Jquery code for sortable entires and wagers
# Hidden input tags are also used with form.
prediction_list = OFL_Prediction.all().filter(
"season =",
season).filter("week =", week).ancestor(coach).filter(
"gameScored =", False).order("-wager")
columns = ["Wager", "Away Team", "Prediction", "Home Team"]
table_html = []
table_html.append('''
<table class="ofl_pickem schedule_table">
<thead>
<tr>''')
for column in columns:
table_html.append(
'<th style="text-align: center;"> %s </th>' % column)
table_html.append('''
</tr>
</thead>
<tbody id="sortable">''')
k = 0
for prediction in prediction_list:
table_html.append('<tr class="row_%s">' % k)
table_html.append(
'<input type="hidden" name="row_%s" value="%s">' %
(k, prediction.key().name()))
table_html.append(
"<input type='hidden' class='row_%s' name='%svalue' value='%s'>"
% (k, prediction.key().name(), prediction.wager))
table_html.append(
'<td class="row_%s" style="text -align: center;">%s</td>'
% (k, prediction.wager))
table_html.append(
'<td style="text-align: center;">%s</td>' %
nameA_getter(prediction))
table_html.append(
'<td style="text-align: center;">%s</td>' %
choice_getter(prediction))
table_html.append(
'<td style="text-align: center;">%s</td>' %
nameB_getter(prediction))
k += 1
table_html.append('</tbody>\n</table>')
table_html = "\n".join(table_html)
played_table = Table(
columns=[
# profile
Column("Points", "Points Earned",
attrgetter("points")),
Column("Wager", "Wager Placed", attrgetter("wager")),
Column("Away Team",
"Away Team",
nameA_getter,
center=True),
Column("Prediction",
"Your Prediction",
choice_getter,
center=True),
Column("Home Team",
"Home Team",
nameB_getter,
center=True),
],
query=OFL_Prediction.all().filter(
"season =",
season).filter("week =", week).ancestor(coach).filter(
"gameScored =", True).order("-points"),
id="played_table",
cls="tablesorter",
)
def logo_getter(standing):
coach = Coach.get_by_key_name(standing.get_coach_name())
img = "<img src='%s' />" % coach.get_logo_url(
) # FIXME: thumb is broken
return "<div style='background-color: %(color)s'>%(img)s</div>" % {
'color': coach.color,
'img': img
}
def name_getter(standing):
coach = Coach.get_by_key_name(standing.get_coach_name())
return "<a class='leader_link' rel='leader_coach' href='%s'>%s</a>" % (
coach.get_box_href(), coach.key().name())
leader_table = {}
query = OFLPickemStats.all().order('-all_time').fetch(10)
label = "alltime"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Score", "Score", attrgetter("all_time")),
],
query=query,
cls="leader_table",
)
query = OFLPickemSeasonRecord.all().filter(
"season =", season).order("-points").fetch(10)
label = "season"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Score", "Score", attrgetter("points")),
],
query=query,
cls="leader_table",
)
query = OFLPickemWeekRecord.all().filter("week =", week).filter(
"season =", season).order("-points").fetch(10)
label = "week"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Score", "Score", attrgetter("points")),
],
query=query,
cls="leader_table",
)
query = OFLPickemStats.all().order('-matches').fetch(10)
label = "alltime_matches"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Matches", "Matches Predicted",
attrgetter("matches")),
],
query=query,
cls="leader_table",
)
query = OFLPickemSeasonRecord.all().filter(
"season =", season).order("-matches").fetch(10)
label = "season_matches"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Matches", "Matches Predicted",
attrgetter("matches")),
],
query=query,
cls="leader_table",
)
query = OFLPickemWeekRecord.all().filter("week =", week).filter(
"season =", season).order("-matches").fetch(10)
label = "week_matches"
leader_table[label] = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Matches", "Matches Predicted",
attrgetter("matches")),
],
query=query,
cls="leader_table",
)
else:
log_in_url = users.create_login_url("/")
# render and update
#--------------------------------------------------------------------#
ofl_pickem_page = misc.render('ofl_pickem_page.html', locals())
self.update(ofl_pickem_page)
self.response.out.write(ofl_pickem_page)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
if self.emit(self.response.out):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
season, week = misc.get_ofl_season_and_week()
ofl_week = (season - 1) * 16 + week
def name_getter(team):
return "<a rel='team' href='%s'>%s</a>" % (team.get_box_href(),
team.key().name())
def race_getter(team):
return "<img title='%s' src='%s' />" % (
team.race.key().name(), team.race.get_image_src(thumb=True))
def coach_getter(team):
if team.coach:
return "<a rel='coach' href='%s'>%s</a>" % (
team.coach.get_box_href(), team.coach.key().name())
else:
return "<i>Unknown</i>"
def awp_getter(team):
return "%0.3f" % team.awp
def glicko_getter(team):
return "%4.0f" % team.glicko_r
def status_getter(team):
html = []
matches = team.matches
if team.pre_wins != None:
matches += team.pre_wins + team.pre_draws + team.pre_losses
#if (team.status or matches > ofl_week or not team.coach):
# html.append("<span class='red_text'>OFL Ineligible</span>")
if not team.coach:
html.append("<span class='orange_text'>(Unclaimed!)</span>")
elif team.test_flag(models.TeamProfile.INCONSISTENT_FLAG):
html.append(
"<span class='red_text'>(Inconsistent Data!)</span>")
# elif team.test_flag(models.TeamProfile.INELIGIBLE_FLAG):
# html.append("<span class='orange_text'>(Exceeds Quota)</b>")
elif team.test_flag(models.TeamProfile.PRE_LE_FLAG):
html.append(
"<span class='yellow_text'>(Incomplete History)</span>")
# else:
# html.append("<span class='orange_text'>(Ahead of OFL Schedule)</b>")
else:
html.append("<span class='green_text'>Consistent Data</span>")
if team.pre_wins != None:
html.append(
"<span class='yellow_text'>(Pre-LE history validated: %sW-%sD-%sL)</span>"
% (team.pre_wins, team.pre_draws, team.pre_losses))
return " ".join(html)
#def get_ave_getter(attr):
# def ave_getter(team):
# return "%.1f" % (float(getattr(team, attr)) / team.matches)
# return ave_getter
tables = {}
#Getting rid of retired table
#for label in ("active", "retired"):
#Taking for loop out, and removing an indent from tables line
label = "active"
tables[label] = Table(
columns=[
# profile
Column(" ", "Race", race_getter, center=True),
Column("Team Name", "Team name", name_getter),
Column("Coach", "Coach", coach_getter),
Column("TV",
"Team value (approximate)",
attrgetter("tv"),
divider=True),
# record
Column("Pl", "Matches played", attrgetter("matches")),
Column("W", "Matches won", attrgetter("wins")),
Column("D", "Matches drawn", attrgetter("draws")),
Column("L", "Matches lost", attrgetter("losses"),
divider=True),
# rankings
Column("AWP", "Adjusted win percentage", awp_getter),
Column("TPts", "Tournament Points", attrgetter("tpts")),
Column("Rating", "Glicko Rating", glicko_getter, divider=True),
Column("Status & Eligibility",
"OFTL/OFL Status and/or Eligibility", status_getter),
## touchdowns
#Column("TD+", "Touchdowns for", attrgetter("tds_for")),
#Column("TD-", "Touchdowns against", attrgetter("tds_against")),
#Column("<span class='over'>TD+</span>", "Average touchdowns for",
# get_ave_getter("tds_for")),
#Column("<span class='over'>TD-</span>", "Average touchdowns against",
# get_ave_getter("tds_against")),
## casualties
#Column("C+", "Casualties for", attrgetter("cas_for")),
#Column("C-", "Casualties against", attrgetter("cas_against")),
#Column("<span class='over'>C+</span>", "Average casualties for",
# get_ave_getter("cas_for")),
#Column("<span class='over'>C-</span>", "Average casualties against",
# get_ave_getter("cas_against")),
],
#query = models.Team.all().filter("retired =", label == "retired").filter(
# "matches >", 0).order("-matches"),
query=models.Team.all().filter("matches >",
0).order("-matches").fetch(50),
id="team-standings-table",
cls="tablesorter",
)
# render and update
#--------------------------------------------------------------------#
league_standings = misc.render('league_standings.html', locals())
self.update(league_standings)
self.response.out.write(league_standings)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
if self.emit(self.response.out):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
def logo_getter(standing):
coach = standing.coach_stats.parent()
img = "<img src='%s' />" % coach.get_logo_url(
) # FIXME: thumb is broken
return "<div style='background-color: %(color)s'>%(img)s</div>" % {
'color': coach.color,
'img': img
}
def name_getter(standing):
coach = standing.coach_stats.parent()
return "<a class='leader_link' rel='leader_coach' href='%s'>%s</a>" % (
coach.get_box_href(), coach.key().name())
leader_info = []
for leader in CoachLeader.all().order('display_order'):
query = CoachLeaderStanding.all().ancestor(leader).order(
'-score').fetch(10)
leader_table = Table(
columns=[
Column(" ", "Logo", logo_getter, center=True),
Column("Coach Name", "Coach name", name_getter),
Column("Score", "Score", attrgetter("score")),
],
query=query,
cls="leader_table",
)
def get_left_header(tuple):
subquery, which = tuple
return which.capitalize()
def getter(stat):
def getter_closure(tuple):
subquery, which = tuple
html = []
for i, standing in enumerate(subquery):
attr = getattr(standing.coach_stats,
"%s_%s" % (stat, which))
html.append(
"<span class='leader_info leader_info_%s'>%s</span>"
% (i + 1, attr))
return "\n".join(html)
return getter_closure
def played_getter(tuple):
subquery, which = tuple
html = []
for i, standing in enumerate(subquery):
attr = getattr(standing.coach_stats, "matches")
html.append(
"<span class='leader_info leader_info_%s'>%s</span>" %
(i + 1, attr))
return "\n".join(html)
leader_stats_table = Table(
columns=[
Column("", "", get_left_header),
Column("Pl", "Matches played", played_getter),
Column("TD", "Touchdowns", getter("tds")),
Column("P", "Pass completions", getter("passes")),
Column("YP", "Yards passing", getter("pyards")),
Column("R", "Pass receptions", getter("rec")),
Column("YR", "Yards rushing", getter("ryards")),
Column("K", "Kills", getter("kills")),
Column("C", "Casualties", getter("cas")),
Column("KO", "Knock outs", getter("ko")),
Column("T", "Tackles", getter("tckl")),
Column("I", "Interceptions", getter("int")),
],
query=((query, "for"), (query, "against")),
cls="fancytable leader_stats_table",
)
teams = [s.coach_stats for s in query]
team_names = [
"%s<i style='font-weight: normal'>, %s - %s - %s</i>" %
(s.coach_stats.parent().key().name()
if s.coach_stats.parent() else "Unknown", s.coach_stats.wins,
s.coach_stats.draws, s.coach_stats.losses) for s in query
]
leader_info.append(
(leader, leader_table, leader_stats_table, teams, team_names))
coach_leaders = misc.render('coach_leaders.html', locals())
self.update(coach_leaders)
self.response.out.write(coach_leaders)
def get_coach_tournament_table(coach):
my_tournaments = []
for tournament in Tournament.all().filter("owner =", coach):
if tournament.winning_team:
# this tournament has already completed
continue
my_tournaments.append(tournament)
def trophy_getter(tournament):
if tournament.pic:
return "<img src='get_trophy?size=thumb&tournament_key=%s' />" % tournament.key(
)
return ""
def name_getter(tournament):
return "<a rel='coach_tournaments' href='%s'>%s</a>" % (
tournament.get_box_href(), tournament.key().name())
def status_getter(tournament):
if tournament.winning_team:
team = tournament.winning_team
return "Winner: <a rel='winning_teams' href='%s'>%s</a>" % (
team.get_box_href(), team.key().name())
if tournament.started:
return "In progress"
return "Open"
def forfeit_getter(tournament):
enrolled = TournamentMembership.all().ancestor(tournament)
pending_matches = list(
TournamentMatchUp.all().ancestor(tournament).filter(
"match_lookup !=", None))
if pending_matches:
html = [
'<form class="ajax_form" action="/forfeit_team" method="post">'
]
html.append('<select name="mm_key">')
for match_up in pending_matches:
for mm in match_up.tournamentmatchupmembership_set.order(
"__key__"):
html.append('<option value="%s">%s</option>' %
(mm.key(), mm.membership.team.key().name()))
html.append('</select>')
html.append('<input type="submit" value="Forfeits!"/>')
html.append('</form>')
return "\n".join(html)
elif enrolled:
html = [
'<form class="ajax_form" action="/force_withdraw" method="post">'
]
html.append('<select name="membership_key">')
for member in enrolled:
html.append('<option value="%s">%s</option>' %
(member.key(), member.team.key().name()))
html.append('</select>')
html.append('<input type="submit" value="Withdraws!"/>')
html.append('</form>')
return "\n".join(html)
else:
return "<i>No teams enrolled</i>"
def start_getter(tournament):
if tournament.started:
return '<i>Tournament already started</i>'
elif TournamentMembership.all().ancestor(tournament).count() < 4:
return '<i>Insufficient enrollment</i>'
else:
if tournament.seed_by == "Custom":
return """<input class='change_seeding' type='submit' value='Seed and Start!'
id='tournament_seeding_%s' /""" % tournament.key()
else:
html = [
'<form class="ajax_form" action="/start_tournament" method="post">'
]
html.append(
'<input type="hidden" name="tournament_key" value="%s" />'
% (tournament.key()))
html.append('<input type="submit" value="Start!"/>')
html.append('</form>')
return "\n".join(html)
def cancel_getter(tournament):
if not tournament.started:
html = [
'<form class="ajax_form" action="/cancel_tournament" method="post">'
]
html.append(
'<input type="hidden" name="tournament_key" value="%s" />' %
(tournament.key()))
html.append('<input type="submit" value="Cancel"/>')
html.append('</form>')
return "\n".join(html)
else:
return '<i>Tournament already started</i>'
if my_tournaments:
return Table(
columns=[
Column("", "Trophy Image", trophy_getter, center=True),
Column("Name", "Tournament name", name_getter),
Column("Status", "Status", status_getter),
Column("Forfeit/Withdraw Team",
"Choose a team to withdraw from this tournament",
forfeit_getter),
Column("Start Early", "Start the tournament early",
start_getter),
Column("Cancel", "Cancel the tournament before it starts",
cancel_getter),
],
query=my_tournaments,
cls="tablesorter coach_tournaments_table",
)
else:
return None
def get_coach_team_table(coach):
def name_getter(team):
if team.matches:
return "<a rel='coach_teams' href='%s'>%s</a>" % (
team.get_box_href(), team.key().name())
else:
return "<b>%s</b> <i>(pre-registered)</i>" % (team.key().name())
def logo_getter(team):
img = ""
if team.custom_logo:
img = "<img src='get_logo?size=thumb&team_key=%s' />" % team.key()
return """<div class='link change_logo'
id='team_logo_%(team_key)s'>%(img)s</div>""" % {
'img': img,
'team_key': team.key()
}
def bio_getter(team):
if team.bio and team.bio.strip():
if len(team.bio) > 40:
bio = "%s..." % team.bio[:40]
else:
bio = team.bio
else:
bio = "<i>None</i>"
return "<span class='link change_bio' id='team_bio_%(team_key)s'>%(bio)s</span>" % {
'bio': bio,
'team_key': team.key()
}
def retire_getter(team):
if team.get_active_tournament_membership():
return "<i>Active in tournament</i>"
#else:
# return "Available"
html = ['<form class="ajax_form" action="/retire_team" method="post">']
html.append('<input type="hidden" name="team_key" value="%s" />' %
(team.key()))
#if not team.matches:
#html.append('<input type="submit" value="Delete"/>')
#elif team.retired:
#html.append('<input type="submit" value="Unretire"/>')
#else:
#html.append('<input type="submit" value="Retire"/>')
html.append('</form>')
return "\n".join(html)
return Table(
columns=[
Column("TV", "Team value (approximate)", attrgetter("tv")),
Column("Team Name", "Team name", name_getter),
Column("Custom Logo", "Custom team logo", logo_getter),
Column("Biography", "Team bio", bio_getter),
Column("Status", "Tournament Activity", retire_getter),
],
query=Team.all().filter("retired =", False).filter("coach =", coach),
cls="tablesorter coach_team_table",
)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
coach_key = db.Key.from_path("Coach",
self.request.get("coach_key_name"))
if self.emit(self.response.out, coach_key):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
coach = Coach.get(coach_key)
if not coach:
return
coach_stats = CoachStats.all().ancestor(coach).get()
# win/draw/loss bars and banner text color
#--------------------------------------------------------------------#
longest_bar_length = max(coach_stats.wins, coach_stats.draws,
coach_stats.losses)
banner_text_color = misc.get_contrasting_monochrome(coach.color)
# team_table
#--------------------------------------------------------------------#
def name_getter(team):
return "<a rel='team' href='%s'>%s</a>" % (team.get_box_href(),
team.key().name())
def race_getter(team):
return "<img title='%s' src='%s' />" % (
team.race.key().name(), team.race.get_image_src(thumb=True))
def awp_getter(team):
return "%0.3f" % team.awp
def glicko_getter(team):
return "%4.0f" % team.glicko_r
teams = query = Team.all().filter("coach =",
coach).filter("matches >",
0).order("-matches")
team_table = Table(
columns=[
# profile
Column(" ", "Race", race_getter, center=True),
Column("Team Name", "Team name", name_getter),
Column("TV",
"Team value (approximate)",
attrgetter("tv"),
divider=True),
# record
Column("Pl", "Matches played", attrgetter("matches")),
Column("W", "Matches won", attrgetter("wins")),
Column("D", "Matches drawn", attrgetter("draws")),
Column("L", "Matches lost", attrgetter("losses"),
divider=True),
# rankings
Column("AWP", "Adjusted win percentage", awp_getter),
Column("TPts", "Tournament Points", attrgetter("tpts")),
Column("Rating", "Glicko Rating", glicko_getter, divider=True),
## touchdowns
#Column("TD+", "Touchdowns for", attrgetter("tds_for")),
#Column("TD-", "Touchdowns against", attrgetter("tds_against")),
#Column("<span class='over'>TD+</span>", "Average touchdowns for",
# get_ave_getter("tds_for")),
#Column("<span class='over'>TD-</span>", "Average touchdowns against",
# get_ave_getter("tds_against")),
## casualties
#Column("C+", "Casualties for", attrgetter("cas_for")),
#Column("C-", "Casualties against", attrgetter("cas_against")),
#Column("<span class='over'>C+</span>", "Average casualties for",
# get_ave_getter("cas_for")),
#Column("<span class='over'>C-</span>", "Average casualties against",
# get_ave_getter("cas_against")),
],
query=teams,
id="%s-team-table" % coach.key(),
cls="tablesorter",
)
# coach_stat_table
#--------------------------------------------------------------------#
def get_left_header(tuple):
coach_stats, which = tuple
return which.capitalize()
def getter(stat):
def getter_closure(tuple):
coach_stats, which = tuple
attr = getattr(coach_stats, "%s_%s" % (stat, which))
return (("<span class='tot_stat'>%d</span>" % attr) +
("<span class='ave_stat'>%.1f</span>" %
(attr / float(coach_stats.matches))))
return getter_closure
stat_table = Table(
columns=[
Column(
"<span class='link' id='%s-show-averages-toggle'></span>" %
coach.key(), "", get_left_header),
Column("TD", "Touchdowns", getter("tds")),
Column("P", "Pass completions", getter("passes")),
Column("YP", "Yards passing", getter("pyards")),
Column("R", "Pass receptions", getter("rec")),
Column("YR", "Yards rushing", getter("ryards")),
Column("K", "Kills", getter("kills")),
Column("C", "Casualties", getter("cas")),
Column("KO", "Knock outs", getter("ko")),
Column("S", "Stuns", getter("stun")),
Column("T", "Tackles", getter("tckl")),
Column("I", "Interceptions", getter("int")),
],
query=((coach_stats, "for"), (coach_stats, "against")),
cls="fancytable stats",
)
# match_tables
#--------------------------------------------------------------------#
def name_getter(record):
if record.team.key() == team.key():
return team.key().name()
else:
return "<a rel='team_opponents' href='%s'>%s</a>" % (
record.team.get_box_href(), record.team.key().name())
def race_getter(record):
return "<img src='%s' />" % record.team.race.get_image_src(
thumb=True)
def link_getter(record):
return """
<a rel='team_matches' href='%s'>
<span class="go_to_arrow" title='Go to match page'>→</span></a>""" % (
record.get_match().get_box_href())
def glicko_getter(record):
return "%4.0f" % record.glicko_r
match_columns = [
Column(" ", "Race", race_getter, center=True),
Column("Team", "Team name", name_getter),
Column("Rating", "Team rating", glicko_getter),
Column("TV", "Team value", attrgetter("tv_for")),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K", "Kills", attrgetter("kills_for")),
Column("C", "Casualties", attrgetter("cas_for")),
Column("KO", "Knock outs", attrgetter("ko_for")),
Column("S", "Stuns", attrgetter("stun_for")),
Column("T", "Tackles", attrgetter("tckl_for")),
Column("I", "Interceptions", attrgetter("int_for")),
Column("", "", link_getter, center=True, rowspan=2)
]
# get matches from match_records and sort in order of most recent
result = []
for team in teams:
for record in TeamRecord.all().filter("team =", team):
if record is not None:
result.append(record)
matches = sorted([record.get_match() for record in result],
key=lambda m: m.created,
reverse=True)[:30]
match_tables = []
for match in matches:
# sort with this team's match record first
match_records = sorted(match.get_team_records_query(),
key=lambda mr: mr.team.coach == coach,
reverse=True)
result_map = {1: "WIN!", 0: "DRAW", -1: "LOSS"}
coach_flag = 0
if match_records[1].team.coach:
if coach.key() == match_records[1].team.coach.key():
coach_flag = 1
title = "(%s) <b>%s-%s %s</b> %s vs. %s" % (
match.created.date(), match_records[0].tds_for,
match_records[1].tds_for,
result_map[match_records[coach_flag].result],
match_records[0].team.key().name(),
match_records[1].team.key().name())
if match.disconnect:
title += " (Disconnect/Forfeit)"
match_table = Table(columns=match_columns,
query=match_records,
cls="tablesorter match_stats",
title=title)
match_tables.append((match.get_box_href(), match_table))
# active_member = team.get_active_tournament_membership()
# active_tournament = active_member.parent() if active_member else None
# render and update (TODO: move to bottom after implementing bottom code)
#--------------------------------------------------------------------#
coach_box = misc.render('coach_box.html', locals())
self.update(coach_box, coach_key)
self.response.out.write(coach_box)
def get_coach_player_tables(coach):
def name_getter(player):
return "<a rel='coach_players' href='%s'>%s</a>" % (
player.get_box_href(), player.name)
def position_getter(player):
return player.position.key().name()
def pic_getter(player):
img = ""
if player.pic:
img = "<img src='get_pic?size=thumb&player_key=%s' />" % player.key(
)
return """<div class='link change_pic'
id='player_pic_%(player_key)s'>%(img)s</div>""" % {
'img': img,
'player_key': player.key()
}
def bio_getter(player):
if player.bio and player.bio.strip():
if len(player.bio) > 40:
bio = "%s..." % player.bio[:40]
else:
bio = player.bio
else:
bio = "<i>None</i>"
return "<span class='link change_bio' id='player_bio_%(player_key)s'>%(bio)s</span>" % {
'bio': bio,
'player_key': player.key()
}
def retired_getter(player):
if player.retired:
return "Yes"
else:
return "No"
coach_player_tables = []
for team in Team.all().filter("coach =",
coach).filter("matches >",
0).filter("retired =", False):
table = Table(
columns=[
Column("#", "Player number", attrgetter("number"),
center=True),
Column("Player Name", "Player name", name_getter),
Column("Position", "Player position", position_getter),
Column("Retired", "Retired", retired_getter),
Column("Level", "Level", attrgetter("level")),
Column("Picture", "Player picture", pic_getter),
Column("Biography", "Player bio", bio_getter),
],
query=team.player_set,
id="coach_player_table_for_team_%s" % team.key(),
cls="tablesorter coach_player_table",
title=team.key().name(),
)
coach_player_tables.append(table)
return coach_player_tables
def get(self):
user = users.get_current_user()
if user:
log_out_url = users.create_logout_url("/")
coach = Coach.all().filter("user ="******"schedule").split("-")
if not season or not week:
season, week = misc.get_ofl_season_and_week()
season += 3
else:
season = int(season)
week = int(week)
parser = OFLScheduleParser()
ofl_info = urlfetch.fetch(
"http://www.shalkith.com/bloodbowl/processSchedule.php?s=%s&w=%s"
% (season, week))
parser.feed(ofl_info.content)
update_schedule_entries(coach, season, week, parser.data)
sort_wagers(coach, season, week)
def logoA_getter(match):
html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
match.teamAlogo)
return html
def logoB_getter(match):
html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
match.teamBlogo)
return html
def nameA_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
html = "%s (%s)" % (match.teamA, match.teamAcoach)
return html
def nameB_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
html = "%s (%s)" % (match.teamB, match.teamBcoach)
return html
def key_name_getter(prediction):
return prediction.key().name()
def choice_getter(prediction):
match = OFL_Match.get_by_key_name(prediction.key().name())
html = "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
match.teamAlogo)
if not match.gamePlayed:
html += "<input type='radio' name='%schoice' value='-1' %s>" % (
match.key().name(), prediction.isChecked(-1))
html += "<input type='radio' name='%schoice' value='0' %s>" % (
match.key().name(), prediction.isChecked(0))
html += "<input type='radio' name='%schoice' value='1' %s>" % (
match.key().name(), prediction.isChecked(1))
else:
html += "<input type='radio' name='%schoice' value='-1' disabled %s>" % (
match.key().name(), prediction.isChecked(-1))
html += "<input type='radio' name='%schoice' value='0' disabled %s>" % (
match.key().name(), prediction.isChecked(0))
html += "<input type='radio' name='%schoice' value='1' disabled %s>" % (
match.key().name(), prediction.isChecked(1))
html += "<img src='http://www.shalkith.com/bloodbowl/%s'/>" % (
match.teamBlogo)
return html
# Bypassing table.html Django template to create this table
# Table requires Jquery code for sortable entires and wagers
# Hidden input tags are also used with form.
prediction_list = OFL_Prediction.all().filter(
"season =",
season).filter("week =", week).ancestor(coach).filter(
"gameScored =", False).order("-wager")
columns = ["Wager", "Away Team", "Prediction", "Home Team"]
table_html = []
table_html.append('''
<table class="ofl_pickem schedule_table">
<thead>
<tr>''')
for column in columns:
table_html.append(
'<th style="text-align: center;"> %s </th>' % column)
table_html.append('''
</tr>
</thead>
<tbody id="sortable">''')
k = 0
for prediction in prediction_list:
table_html.append('<tr class="row_%s">' % k)
table_html.append(
'<input type="hidden" name="row_%s" value="%s">' %
(k, prediction.key().name()))
table_html.append(
"<input type='hidden' class='row_%s' name='%svalue' value='%s'>"
% (k, prediction.key().name(), prediction.wager))
table_html.append(
'<td class="row_%s" style="text -align: center;">%s</td>'
% (k, prediction.wager))
table_html.append(
'<td style="text-align: center;">%s</td>' %
nameA_getter(prediction))
table_html.append(
'<td style="text-align: center;">%s</td>' %
choice_getter(prediction))
table_html.append(
'<td style="text-align: center;">%s</td>' %
nameB_getter(prediction))
k += 1
table_html.append('</tbody>\n</table>')
table_html = "\n".join(table_html)
played_table = Table(
columns=[
# profile
Column("Points", "Points Earned",
attrgetter("points")),
Column("Wager", "Wager Placed", attrgetter("wager")),
Column("Away Team",
"Away Team",
nameA_getter,
center=True),
Column("Prediction",
"Your Prediction",
choice_getter,
center=True),
Column("Home Team",
"Home Team",
nameB_getter,
center=True),
],
query=OFL_Prediction.all().filter(
"season =",
season).filter("week =", week).ancestor(coach).filter(
"gameScored =", True).order("-points"),
id="played_table",
cls="tablesorter",
)
else:
log_in_url = users.create_login_url("/")
# render and update
#--------------------------------------------------------------------#
ofl_pickem_page = misc.render('ofl_pickem_box.html', locals())
self.update(ofl_pickem_page)
self.response.out.write(ofl_pickem_page)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
player_key = db.Key.from_path("Player",
self.request.get("player_key_name"))
if self.emit(self.response.out, player_key):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
player = Player.get(player_key)
if not player:
return
# player card
#--------------------------------------------------------------------#
banner_text_color = misc.get_contrasting_monochrome(player.team.color)
attr_table = Table(
columns=[
Column("MV", "Movement Allowance", attrgetter("mv")),
Column("ST", "Strength", attrgetter("st")),
Column("AG", "Agility", attrgetter("ag")),
Column("AV", "Armor Value", attrgetter("av")),
],
query=(player, ),
cls="attr",
)
injuries = []
for injury_key in player.injuries:
injury = db.get(injury_key)
if injury.key().name() == "Dead":
injuries.append("DEAD")
elif injury.permanent:
injuries.append("%s (%s)" %
(injury.key().name(), injury.effect))
injuries = ", ".join(x for x in injuries)
skills = [k.name() for k in player.skills]
if player.level_up_pending:
skills.append("<i>Pending Level-Up</i>")
skills = ", ".join(skills)
# stat_table
#--------------------------------------------------------------------#
def get_left_header(tuple):
player, which = tuple
return which.capitalize()
def getter(stat):
def getter_closure(tuple):
player, which = tuple
try:
attr = getattr(player, "%s_%s" % (stat, which))
ave_attr = attr if player.played == 0 else attr / float(
player.played)
return """<div class='tot_stat'>%d</div>
<div class='ave_stat'>%.1f</div>""" % (attr, ave_attr)
except AttributeError:
return "-"
return getter_closure
stat_table = Table(
columns=[
Column(
"<span class='link' id='%s-show-averages-toggle'></span>" %
player.key(), "", get_left_header),
Column("TD", "Touchdowns", getter("tds")),
Column("P", "Pass completions", getter("passes")),
Column("YP", "Yards passing", getter("pyards")),
Column("R", "Pass receptions", getter("rec")),
Column("YR", "Yards rushing", getter("ryards")),
Column("K", "Kills", getter("kills")),
Column("C", "Casualties", getter("cas")),
Column("KO", "Knock outs", getter("ko")),
Column("S", "Stuns", getter("stun")),
Column("T", "Tackles", getter("tckl")),
Column("I", "Interceptions", getter("int")),
],
query=((player, "for"), (player, "against")),
cls="fancytable stats",
)
# match_table
#--------------------------------------------------------------------#
def name_getter(record):
opponent = record.team_record.opponent_record.team
return "<a rel='player_opponents' href='%s'>%s</a>" % (
opponent.get_box_href(), opponent.key().name())
def race_getter(record):
opponent = record.team_record.opponent_record.team
return "<img src='%s' />" % opponent.race.get_image_src(thumb=True)
def date_getter(record):
return record.get_match().created.date()
def link_getter(record):
return """
<a rel='player_matches' href='%s'>
<span class='go_to_arrow' title='Go to match page'>→</span></a>""" % (
record.get_match().get_box_href())
match_table = Table(
columns=[
Column("Date", "Match date", date_getter),
Column("Opponent", "Opponent name", name_getter),
Column(" ", "Race", race_getter, center=True),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("MVP", "Most Valuable Player Awards",
attrgetter("mvps")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K+", "Kills for", attrgetter("kills_for")),
Column("C+", "Casualties for", attrgetter("cas_for")),
Column("KO+", "Knock outs for", attrgetter("ko_for")),
Column("S+", "Stuns for", attrgetter("stun_for")),
Column("T+", "Tackles for", attrgetter("tckl_for")),
Column("I+", "Interceptions for", attrgetter("int_for")),
Column("K-", "Kills against", attrgetter("kills_against")),
Column("C-", "Casualties against", attrgetter("cas_against")),
Column("KO-", "Knock outs against", attrgetter("ko_against")),
Column("S-", "Stuns against", attrgetter("stun_against")),
Column("T-", "Tackles against", attrgetter("tckl_against")),
Column("I-", "Interceptions against",
attrgetter("int_against")),
Column("", "", link_getter, center=True)
],
query=player.playerrecord_set.filter("played =", 1),
cls="tablesorter match_stats",
)
# render and update
#--------------------------------------------------------------------#
player_box = misc.render('player_box.html', locals())
self.update(player_box, player_key)
self.response.out.write(player_box)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
if self.emit(self.response.out):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
def name_getter(racestats):
return racestats.race.key().name()
def race_getter(racestats):
return "<img title='%s' src='%s' />" % (racestats.race.key().name(
), racestats.race.get_image_src(thumb=True))
def awp_getter(racestats):
return "%0.3f" % racestats.awp
def percent_getter(attr):
def ave_getter(racestats):
if (racestats.matches > 0):
return "%.1f" % (float(getattr(racestats, attr)) * 100 /
racestats.matches)
return 0
return ave_getter
def get_ave_getter(attr):
def ave_getter(racestats):
if (racestats.matches > 0):
return "%.1f" % (float(getattr(racestats, attr)) /
racestats.matches)
return 0
return ave_getter
tables = {}
label = "active"
tables[label] = Table(
columns=[
# profile
Column(" ", "Logo", race_getter, center=True),
Column("Race", "Race", name_getter, divider=True),
Column("#Teams", "Number of Teams",
attrgetter("num_of_teams")),
Column("Matches", "Matches played", attrgetter("matches")),
Column("Wins", "Wins", attrgetter("wins")),
Column("Draws", "Draws", attrgetter("draws")),
Column("Losses", "Losses", attrgetter("losses")),
Column("AWP", "Adjusted Win Percentage", awp_getter),
Column("Win%", "Win Percentage", percent_getter("wins")),
Column("Draw%", "Draw Percentage", percent_getter("draws")),
Column("Loss%", "Loss Percentage", percent_getter("losses")),
Column("TPts",
"Tournament Points",
attrgetter("tpts"),
divider=True),
],
query=models.RaceStats.all().order("-awp"),
id="race-standings-table",
cls="tablesorter",
)
label = "average"
tables[label] = Table(
columns=[
# profile
Column(" ", "Logo", race_getter, center=True),
Column("Race", "Race", name_getter, divider=True),
Column("#Tm", "Number of Teams", attrgetter("num_of_teams")),
Column("AWP",
"Adjusted Win Percentage",
awp_getter,
divider=True),
Column("TD+", "Average Touchdowns", get_ave_getter("tds_for")),
Column("P+", "Average Pass completions",
get_ave_getter("passes_for")),
Column("YP+", "Average Yards passing",
get_ave_getter("pyards_for")),
Column("R+", "Average Pass receptions",
get_ave_getter("rec_for")),
Column("YR+", "Average Yards rushing",
get_ave_getter("ryards_for")),
Column("K+", "Average Kills", get_ave_getter("kills_for")),
Column("C+", "Average Casualties", get_ave_getter("cas_for")),
Column("KO+", "Average Knock outs", get_ave_getter("ko_for")),
Column("S+", "Average Stuns", get_ave_getter("stun_for")),
Column("T+", "Average Tackles", get_ave_getter("tckl_for")),
Column("I+",
"Average Interceptions",
get_ave_getter("int_for"),
divider=True),
Column("TD-", "Average Touchdowns",
get_ave_getter("tds_against")),
Column("P-", "Average Pass completions",
get_ave_getter("passes_against")),
Column("YP-", "Average Yards passing",
get_ave_getter("pyards_against")),
Column("R-", "Average Pass receptions",
get_ave_getter("rec_against")),
Column("YR-", "Average Yards rushing",
get_ave_getter("ryards_against")),
Column("K-", "Average Kills", get_ave_getter("kills_against")),
Column("C-", "Average Casualties",
get_ave_getter("cas_against")),
Column("KO-", "Average Knock outs",
get_ave_getter("ko_against")),
Column("S-", "Average Stuns", get_ave_getter("stun_against")),
Column("T-", "Average Tackles",
get_ave_getter("tckl_against")),
Column("I-", "Average Interceptions",
get_ave_getter("int_against")),
],
query=models.RaceStats.all().order("-awp"),
id="race-average-table",
cls="tablesorter",
)
label = "stats"
tables[label] = Table(
columns=[
# profile
Column(" ", "Logo", race_getter, center=True),
Column("Race", "Race", name_getter, divider=True),
Column("#Tm", "Number of Teams", attrgetter("num_of_teams")),
Column("AWP",
"Adjusted Win Percentage",
awp_getter,
divider=True),
Column("TD+", "Average Touchdowns", attrgetter("tds_for")),
Column("P+", "Average Pass completions",
attrgetter("passes_for")),
Column("YP+", "Average Yards passing",
attrgetter("pyards_for")),
Column("R+", "Average Pass receptions", attrgetter("rec_for")),
Column("YR+", "Average Yards rushing",
attrgetter("ryards_for")),
Column("K+", "Average Kills", attrgetter("kills_for")),
Column("C+", "Average Casualties", attrgetter("cas_for")),
Column("KO+", "Average Knock outs", attrgetter("ko_for")),
Column("S+", "Average Stuns", attrgetter("stun_for")),
Column("T+", "Average Tackles", attrgetter("tckl_for")),
Column("I+",
"Average Interceptions",
attrgetter("int_for"),
divider=True),
Column("TD-", "Average Touchdowns", attrgetter("tds_against")),
Column("P-", "Average Pass completions",
attrgetter("passes_against")),
Column("YP-", "Average Yards passing",
attrgetter("pyards_against")),
Column("R-", "Average Pass receptions",
attrgetter("rec_against")),
Column("YR-", "Average Yards rushing",
attrgetter("ryards_against")),
Column("K-", "Average Kills", attrgetter("kills_against")),
Column("C-", "Average Casualties", attrgetter("cas_against")),
Column("KO-", "Average Knock outs", attrgetter("ko_against")),
Column("S-", "Average Stuns", attrgetter("stun_against")),
Column("T-", "Average Tackles", attrgetter("tckl_against")),
Column("I-", "Average Interceptions",
attrgetter("int_against")),
],
query=models.RaceStats.all().order("-awp"),
id="race-stats-table",
cls="tablesorter",
)
# render and update
#--------------------------------------------------------------------#
general_statistics = misc.render('general_statistics.html', locals())
self.update(general_statistics)
self.response.out.write(general_statistics)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
match_key = db.Key(self.request.get("match_key"))
if self.emit(self.response.out, match_key):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
match = Match.get(match_key)
if not match:
return
home_record, away_record = match.get_team_records_query().fetch(2)
match_data = MatchData(match)
# team_match_table
#--------------------------------------------------------------------#
def team_name_getter(record):
return "<a rel='match_teams' href='%s'>%s</a>" % (
record.team.get_box_href(), record.team.key().name())
def race_getter(record):
return "<img src='%s' />" % record.team.race.get_image_src(
thumb=True)
def glicko_getter(record):
return "%4.0f" % record.glicko_r
team_match_table = Table(
columns=[
Column(" ", "Race", race_getter, center=True),
Column("Team", "Team name", team_name_getter),
Column("Rating", "Team rating", glicko_getter),
Column("TV", "Team value", attrgetter("tv_for")),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K", "Kills", attrgetter("kills_for")),
Column("C", "Casualties", attrgetter("cas_for")),
Column("KO", "Knock outs", attrgetter("ko_for")),
Column("S", "Stuns", attrgetter("stun_for")),
Column("T", "Tackles", attrgetter("tckl_for")),
Column("I", "Interceptions", attrgetter("int_for")),
],
query=match.get_team_records_query(),
cls="tablesorter team_match_table",
)
# player_match_tables
#--------------------------------------------------------------------#
def number_getter(record):
return record.player.number
def player_name_getter(record):
return record.player.get_box_anchor("match_players")
def position_getter(record):
position = record.player.position
if position.starplayer:
return "<b>Star Player</b>"
else:
return position.key().name()
player_records = match.get_player_records_query().filter("played =", 1)
team_player_records = {}
for record in player_records:
team_player_records.setdefault(
record.team_record.team.key().name(), []).append(record)
player_match_tables = []
for team_name, record_set in team_player_records.items():
table = Table(
columns=[
Column("#", "Player number", number_getter, center=True),
Column("Player", "Player name", player_name_getter),
Column("Position", "Player position", position_getter),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("MVP", "Most Valuable Player Awards",
attrgetter("mvps")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K+", "Kills for", attrgetter("kills_for")),
Column("C+", "Casualties for", attrgetter("cas_for")),
Column("KO+", "Knock outs for", attrgetter("ko_for")),
Column("S+", "Stuns for", attrgetter("stun_for")),
Column("T+", "Tackles for", attrgetter("tckl_for")),
Column("I+", "Interceptions for", attrgetter("int_for")),
Column("K-", "Kills against", attrgetter("kills_against")),
Column("C-", "Casualties against",
attrgetter("cas_against")),
Column("KO-", "Knock outs against",
attrgetter("ko_against")),
Column("S-", "Stuns against", attrgetter("stun_against")),
Column("T-", "Tackles against",
attrgetter("tckl_against")),
Column("I-", "Interceptions against",
attrgetter("int_against")),
],
query=record_set,
cls="tablesorter player_match_table",
)
player_match_tables.append((team_name, table))
# injury_table
#--------------------------------------------------------------------#
def team_name_getter(record):
return record.team_record.team.key().name()
def injury_name_getter(record):
for injury_key in record.match_injuries:
injury = Injury.get(injury_key)
if injury.permanent:
break
return injury.key().name()
def injury_effect_getter(record):
for injury_key in record.match_injuries:
injury = Injury.get(injury_key)
if injury.permanent:
break
return injury.effect
injured_player_records = [
r for r in player_records if r.match_injuries
]
if injured_player_records:
injury_table = Table(
columns=[
Column("#", "Player number", number_getter, center=True),
Column("Team", "Team name", team_name_getter),
Column("Player", "Player name", player_name_getter),
Column("Position", "Player position", position_getter),
Column("SPP", "Star player points", attrgetter("spp")),
Column("Level", "Level", attrgetter("level")),
Column("Injury", "Injury name", injury_name_getter),
Column("Effect", "Injury effect", injury_effect_getter),
],
query=injured_player_records,
cls="tablesorter injury_table",
)
else:
injury_table = None
# render and update
#--------------------------------------------------------------------#
match_box = misc.render('match_box.html', locals())
self.update(match_box, match_key)
self.response.out.write(match_box)
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
team_key = db.Key.from_path("Team", self.request.get("team_key_name"))
if self.emit(self.response.out, team_key):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
team = Team.get(team_key)
if not team:
return
# win/draw/loss bars and banner text color
#--------------------------------------------------------------------#
longest_bar_length = max(team.wins, team.draws, team.losses)
banner_text_color = misc.get_contrasting_monochrome(team.color)
# player_table
#--------------------------------------------------------------------#
def position_getter(player):
return player.position.key().name()
def name_getter(player):
if player.played:
return "<a rel='team_players' href='%s'>%s</a>" % (
player.get_box_href(), player.name)
else:
return "<b>" + player.name + "</b>"
def mng_getter(player):
if player.missing_next_game:
return "<img src='images/logos/thumb/logo_neutre_10.png' />"
else:
return ""
player_table = Table(
columns=[
Column("#", "Player number", attrgetter("number"),
center=True),
Column("MNG", "Missing next game", mng_getter, center=True),
Column("Player", "Player name", name_getter),
Column("Position",
"Player position",
position_getter,
divider=True),
Column("MV", "Movement allowance", attrgetter("mv")),
Column("ST", "Strength", attrgetter("st")),
Column("AG", "Agility", attrgetter("ag")),
Column("AV", "Armor value", attrgetter("av"), divider=True),
Column("SPP", "Star player points", attrgetter("spp")),
Column("Level", "Level", attrgetter("level"), divider=True),
Column("Pl", "Matches played", attrgetter("played")),
Column("MVP", "Most Valuable Player awards",
attrgetter("mvps")),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K", "Kills", attrgetter("kills_for")),
Column("C", "Casualties", attrgetter("cas_for")),
Column("KO", "Knock outs", attrgetter("ko_for")),
Column("S", "Stuns", attrgetter("stun_for")),
Column("T", "Tackles", attrgetter("tckl_for")),
Column("I",
"Interceptions",
attrgetter("int_for"),
divider=True),
Column("Value", "Player value", attrgetter("value")),
],
query=team.player_set.filter("retired =", False),
id="%s-player-table" % team.key(),
cls="tablesorter",
)
# stat_table
#--------------------------------------------------------------------#
def get_left_header(tuple):
team, which = tuple
return which.capitalize()
def getter(stat):
def getter_closure(tuple):
team, which = tuple
attr = getattr(team, "%s_%s" % (stat, which))
return (("<span class='tot_stat'>%d</span>" % attr) +
("<span class='ave_stat'>%.1f</span>" %
(attr / float(team.matches))))
return getter_closure
stat_table = Table(
columns=[
Column(
"<span class='link' id='%s-show-averages-toggle'></span>" %
team.key(), "", get_left_header),
Column("TD", "Touchdowns", getter("tds")),
Column("P", "Pass completions", getter("passes")),
Column("YP", "Yards passing", getter("pyards")),
Column("R", "Pass receptions", getter("rec")),
Column("YR", "Yards rushing", getter("ryards")),
Column("K", "Kills", getter("kills")),
Column("C", "Casualties", getter("cas")),
Column("KO", "Knock outs", getter("ko")),
Column("S", "Stuns", getter("stun")),
Column("T", "Tackles", getter("tckl")),
Column("I", "Interceptions", getter("int")),
],
query=((team, "for"), (team, "against")),
cls="fancytable stats",
)
# match_tables
#--------------------------------------------------------------------#
def name_getter(record):
if record.team.key() == team.key():
return team.key().name()
else:
return "<a rel='team_opponents' href='%s'>%s</a>" % (
record.team.get_box_href(), record.team.key().name())
def race_getter(record):
return "<img src='%s' />" % record.team.race.get_image_src(
thumb=True)
def link_getter(record):
return """
<a rel='team_matches' href='%s'>
<span class="go_to_arrow" title='Go to match page'>→</span></a>""" % (
record.get_match().get_box_href())
def glicko_getter(record):
return "%4.0f" % record.glicko_r
match_columns = [
Column(" ", "Race", race_getter, center=True),
Column("Team", "Team name", name_getter),
Column("Rating", "Team rating", glicko_getter),
Column("TV", "Team value", attrgetter("tv_for")),
Column("TD", "Touchdowns", attrgetter("tds_for")),
Column("P", "Pass completions", attrgetter("passes_for")),
Column("YP", "Yards passing", attrgetter("pyards_for")),
Column("R", "Pass receptions", attrgetter("rec_for")),
Column("YR", "Yards rushing", attrgetter("ryards_for")),
Column("K", "Kills", attrgetter("kills_for")),
Column("C", "Casualties", attrgetter("cas_for")),
Column("KO", "Knock outs", attrgetter("ko_for")),
Column("S", "Stuns", attrgetter("stun_for")),
Column("T", "Tackles", attrgetter("tckl_for")),
Column("I", "Interceptions", attrgetter("int_for")),
Column("", "", link_getter, center=True, rowspan=2)
]
# get matches from match_records and sort in order of most recent
matches = sorted(
[record.get_match() for record in team.teamrecord_set],
key=lambda m: m.created,
reverse=True)
match_tables = []
for match in matches:
# sort with this team's match record first
match_records = sorted(match.get_team_records_query(),
key=lambda mr: mr.team.key() == team.key(),
reverse=True)
result_map = {1: "WIN!", 0: "DRAW", -1: "LOSS"}
title = "(%s) <b>%s-%s %s</b> vs. %s" % (
match.created.date(), match_records[0].tds_for,
match_records[1].tds_for, result_map[match_records[0].result],
match_records[1].team.key().name())
if match.disconnect:
title += " (Disconnect/Forfeit)"
match_table = Table(columns=match_columns,
query=match_records,
cls="tablesorter match_stats",
title=title)
match_tables.append((match.get_box_href(), match_table))
active_member = team.get_active_tournament_membership()
active_tournament = active_member.parent() if active_member else None
# render and update
#--------------------------------------------------------------------#
team_box = misc.render('team_box.html', locals())
self.update(team_box, team_key)
self.response.out.write(team_box)