def api_search(request, q=''):
if q == '':
q = request.GET['q']
players = Player.objects.filter(tag__icontains=q)
d = []
for p in players:
dp = {'tag': p.tag, 'race': p.race}
if p.country != None and p.country != '':
dp['country'] = transformations.cc_to_cn(p.country)
try:
r = Rating.objects.filter(player=p).order_by('-period__id')[0]
dp['rating'] = r.rating
dp['rating_vp'] = r.rating_vp
dp['rating_vt'] = r.rating_vt
dp['rating_vz'] = r.rating_vz
dp['dev'] = r.dev
dp['dev_vp'] = r.dev_vp
dp['dev_vt'] = r.dev_vt
dp['dev_vz'] = r.dev_vz
except:
dp['rating'] = 0
dp['rating_vp'] = 0
dp['rating_vt'] = 0
dp['rating_vz'] = 0
dp['dev'] = 0.6
dp['dev_vp'] = 0.6
dp['dev_vt'] = 0.6
dp['dev_vz'] = 0.6
d.append(dp)
return HttpResponse(simplejson.dumps(d), mimetype='application/json')
def player_object(p, sparse=False):
dp = {'id': p.id, 'tag': p.tag, 'race': p.race}
if p.country is not None and p.country != '':
dp['country'] = transformations.cc_to_cn(p.country)
dp['country-iso'] = p.country
if sparse:
return dp
if p.name is not None:
dp['name'] = p.name
if p.birthday is not None:
dp['birthday'] = str(p.birthday)
dp['aliases'] = [a.name for a in p.alias_set.all()]
try:
team = p.groupmembership_set.filter(current=True, group__is_team=True)[0].group
dp['team'] = team_object(team, sparse=True)
except:
pass
return dp
def player(request, player_id):
# {{{ Get player object and base context, generate messages and make changes if needed
player = get_object_or_404(Player, id=player_id)
base = base_ctx('Ranking', 'Summary', request, context=player)
if request.method == 'POST' and base['adm']:
form = PlayerModForm(request)
base['messages'] += form.update_player(player)
else:
form = PlayerModForm(player=player)
base['messages'] += generate_messages(player)
# }}}
# {{{ Various easy data
matches = player.get_matchset()
recent = matches.filter(date__gte=(date.today() - relativedelta(months=2)))
base.update({
'player': player,
'form': form,
'first': etn(lambda: matches.earliest('date')),
'last': etn(lambda: matches.latest('date')),
'totalmatches': matches.count(),
'offlinematches': matches.filter(offline=True).count(),
'aliases': player.alias_set.all(),
'earnings': ntz(player.earnings_set.aggregate(Sum('earnings'))['earnings__sum']),
'team': player.get_current_team(),
'total': count_winloss_player(matches, player),
'vp': count_matchup_player(matches, player, P),
'vt': count_matchup_player(matches, player, T),
'vz': count_matchup_player(matches, player, Z),
'totalf': count_winloss_player(recent, player),
'vpf': count_matchup_player(recent, player, P),
'vtf': count_matchup_player(recent, player, T),
'vzf': count_matchup_player(recent, player, Z),
})
if player.country is not None:
base['countryfull'] = transformations.cc_to_cn(player.country)
# }}}
# {{{ Recent matches
matches = player.get_matchset(related=['rta','rtb','pla','plb','eventobj'])[0:10]
if matches.exists():
base['matches'] = display_matches(matches, fix_left=player, ratings=True)
# }}}
# {{{ Team memberships
team_memberships = list(player.groupmembership_set.filter(group__is_team=True).select_related('group'))
team_memberships.sort(key=lambda t: t.id, reverse=True)
team_memberships.sort(key=meandate, reverse=True)
team_memberships.sort(key=lambda t: t.current, reverse=True)
base['teammems'] = team_memberships
# }}}
# {{{ If the player has at least one rating
if player.current_rating:
ratings = total_ratings(player.rating_set.filter(period__computed=True)).select_related('period')
base.update({
'highs': (
ratings.latest('rating'),
ratings.latest('tot_vp'),
ratings.latest('tot_vt'),
ratings.latest('tot_vz'),
),
'recentchange': player.get_latest_rating_update(),
'firstrating': ratings.earliest('period'),
'rating': player.current_rating,
})
if player.current_rating.decay >= INACTIVE_THRESHOLD:
base['messages'].append(Message(msg_inactive % player.tag, 'Inactive', type=Message.INFO))
base['charts'] = base['recentchange'].period_id > base['firstrating'].period_id
else:
base['messages'].append(Message('%s has no rating yet.' % player.tag, type=Message.INFO))
base['charts'] = False
# }}}
# {{{ If the player has enough games to make a chart
if base['charts']:
ratings = (
total_ratings(player.rating_set.filter(period_id__lte=base['recentchange'].period_id))
.select_related('period__end')
.prefetch_related('prev__rta', 'prev__rtb')
.order_by('period')
)
# {{{ Add stories and other extra information
earliest = base['firstrating']
latest = base['recentchange']
# Look through team changes
teampoints = []
for mem in base['teammems']:
if mem.start and earliest.period.end < mem.start < latest.period.end:
teampoints.append({
'date': mem.start,
'rating': interp_rating(mem.start, ratings),
'data': [{'date': mem.start, 'team': mem.group, 'jol': 'joins'}],
})
if mem.end and earliest.period.end < mem.end < latest.period.end:
teampoints.append({
'date': mem.end,
'rating': interp_rating(mem.end, ratings),
'data': [{'date': mem.end, 'team': mem.group, 'jol': 'leaves'}],
})
teampoints.sort(key=lambda p: p['date'])
# Condense if team changes happened within 14 days
cur = 0
while cur < len(teampoints) - 1:
if (teampoints[cur+1]['date'] - teampoints[cur]['date']).days <= 14:
teampoints[cur]['data'].append(teampoints[cur+1]['data'][0])
del teampoints[cur+1]
else:
cur += 1
# Sort first by date, then by joined/left
for point in teampoints:
point['data'].sort(key=lambda a: a['jol'], reverse=True)
point['data'].sort(key=lambda a: a['date'])
# Look through stories
stories = player.story_set.all().select_related('event__fullname')
for s in stories:
if earliest.period.start < s.date < latest.period.start:
s.rating = interp_rating(s.date, ratings)
else:
s.skip = True
# }}}
base.update({
'ratings': add_counts(ratings),
'patches': PATCHES,
'stories': stories,
'teampoints': teampoints,
})
else:
base['messages'].append(Message(msg_nochart % player.tag, type=Message.INFO))
# }}}
base.update({"title": player.tag})
return render_to_response('player.html', base)
def countryfull(value):
if value is not None:
return transformations.cc_to_cn(value)
return value
def player(request, player_id):
# {{{ Get player object and base context, generate messages and make changes if needed
player = get_object_or_404(Player, id=player_id)
base = base_ctx('Ranking', 'Summary', request, context=player)
if request.method == 'POST' and 'modplayer' in request.POST and base['adm']:
modform = PlayerModForm(request)
base['messages'] += modform.update_player(player)
else:
modform = PlayerModForm(player=player)
base['messages'] += generate_messages(player)
# }}}
# {{{ Various easy data
matches = player.get_matchset()
recent = matches.filter(date__gte=(date.today() - relativedelta(months=2)))
base.update({
'player':
player,
'modform':
modform,
'first':
etn(lambda: matches.earliest('date')),
'last':
etn(lambda: matches.latest('date')),
'totalmatches':
matches.count(),
'offlinematches':
matches.filter(offline=True).count(),
'aliases':
player.alias_set.all(),
'earnings':
ntz(player.earnings_set.aggregate(Sum('earnings'))['earnings__sum']),
'team':
player.get_current_team(),
'total':
count_winloss_player(matches, player),
'vp':
count_matchup_player(matches, player, P),
'vt':
count_matchup_player(matches, player, T),
'vz':
count_matchup_player(matches, player, Z),
'totalf':
count_winloss_player(recent, player),
'vpf':
count_matchup_player(recent, player, P),
'vtf':
count_matchup_player(recent, player, T),
'vzf':
count_matchup_player(recent, player, Z),
})
base['riv_nem_vic'] = zip_longest(player.rivals, player.nemesis,
player.victim)
if player.country is not None:
base['countryfull'] = transformations.cc_to_cn(player.country)
# }}}
# {{{ Recent matches
matches = player.get_matchset(
related=['rta', 'rtb', 'pla', 'plb', 'eventobj'])[0:10]
if matches.exists():
base['matches'] = display_matches(matches,
fix_left=player,
ratings=True)
# }}}
# {{{ Team memberships
team_memberships = list(
player.groupmembership_set.filter(
group__is_team=True).select_related('group'))
team_memberships.sort(key=lambda t: t.id, reverse=True)
team_memberships.sort(key=meandate, reverse=True)
team_memberships.sort(key=lambda t: t.current, reverse=True)
base['teammems'] = team_memberships
# }}}
# {{{ If the player has at least one rating
if player.current_rating:
ratings = total_ratings(player.rating_set.filter(
period__computed=True)).select_related('period')
base.update({
'highs': (
ratings.latest('rating'),
ratings.latest('tot_vp'),
ratings.latest('tot_vt'),
ratings.latest('tot_vz'),
),
'recentchange':
player.get_latest_rating_update(),
'firstrating':
ratings.earliest('period'),
'rating':
player.current_rating,
})
if player.current_rating.decay >= INACTIVE_THRESHOLD:
base['messages'].append(
Message(msg_inactive % player.tag,
'Inactive',
type=Message.INFO))
base['charts'] = base['recentchange'].period_id > base[
'firstrating'].period_id
else:
base['messages'].append(
Message(_('%s has no rating yet.') % player.tag,
type=Message.INFO))
base['charts'] = False
# }}}
# {{{ If the player has enough games to make a chart
if base['charts']:
ratings = (total_ratings(
player.rating_set.filter(
period_id__lte=base['recentchange'].period_id)).select_related(
'period').prefetch_related('prev__rta',
'prev__rtb').order_by('period'))
# {{{ Add stories and other extra information
earliest = base['firstrating']
latest = base['recentchange']
# Look through team changes
teampoints = []
for mem in base['teammems']:
if mem.start and earliest.period.end < mem.start < latest.period.end:
teampoints.append({
'date':
mem.start,
'rating':
interp_rating(mem.start, ratings),
'data': [{
'date': mem.start,
'team': mem.group,
'jol': _('joins')
}],
})
if mem.end and earliest.period.end < mem.end < latest.period.end:
teampoints.append({
'date':
mem.end,
'rating':
interp_rating(mem.end, ratings),
'data': [{
'date': mem.end,
'team': mem.group,
'jol': _('leaves')
}],
})
teampoints.sort(key=lambda p: p['date'])
# Condense if team changes happened within 14 days
cur = 0
while cur < len(teampoints) - 1:
if (teampoints[cur + 1]['date'] -
teampoints[cur]['date']).days <= 14:
teampoints[cur]['data'].append(teampoints[cur + 1]['data'][0])
del teampoints[cur + 1]
else:
cur += 1
# Sort first by date, then by joined/left
for point in teampoints:
point['data'].sort(key=lambda a: a['jol'], reverse=True)
point['data'].sort(key=lambda a: a['date'])
# Look through stories
stories = player.story_set.all().select_related('event')
for s in stories:
if earliest.period.start < s.date < latest.period.start:
s.rating = interp_rating(s.date, ratings)
else:
s.skip = True
# }}}
base.update({
'ratings': add_counts(ratings),
'patches': PATCHES,
'stories': stories,
'teampoints': teampoints,
})
else:
base['messages'].append(
Message(msg_nochart % player.tag, type=Message.INFO))
# }}}
return render_to_response('player.djhtml', base)
def player(request, player_id):
# {{{ Get player object and base context, generate messages and make changes if needed
player = get_object_or_404(Player, id=player_id)
base = base_ctx("Ranking", "Summary", request, context=player)
if request.method == "POST" and "modplayer" in request.POST and base["adm"]:
modform = PlayerModForm(request)
base["messages"] += modform.update_player(player)
else:
modform = PlayerModForm(player=player)
base["messages"] += generate_messages(player)
# }}}
# {{{ Various easy data
matches = player.get_matchset()
recent = matches.filter(date__gte=(date.today() - relativedelta(months=2)))
base.update(
{
"player": player,
"modform": modform,
"first": etn(lambda: matches.earliest("date")),
"last": etn(lambda: matches.latest("date")),
"totalmatches": matches.count(),
"offlinematches": matches.filter(offline=True).count(),
"aliases": player.alias_set.all(),
"earnings": ntz(player.earnings_set.aggregate(Sum("earnings"))["earnings__sum"]),
"team": player.get_current_team(),
"total": count_winloss_player(matches, player),
"vp": count_matchup_player(matches, player, P),
"vt": count_matchup_player(matches, player, T),
"vz": count_matchup_player(matches, player, Z),
"totalf": count_winloss_player(recent, player),
"vpf": count_matchup_player(recent, player, P),
"vtf": count_matchup_player(recent, player, T),
"vzf": count_matchup_player(recent, player, Z),
}
)
riv = player.rivals or []
nem = player.nemesis or []
vic = player.victim or []
base["riv_nem_vic"] = zip_longest(riv, nem, vic)
if player.country is not None:
base["countryfull"] = transformations.cc_to_cn(player.country)
# }}}
# {{{ Recent matches
matches = player.get_matchset(related=["rta", "rtb", "pla", "plb", "eventobj"])[0:10]
if matches.exists():
base["matches"] = display_matches(matches, fix_left=player, ratings=True)
# }}}
# {{{ Team memberships
team_memberships = list(player.groupmembership_set.filter(group__is_team=True).select_related("group"))
team_memberships.sort(key=lambda t: t.id, reverse=True)
team_memberships.sort(key=meandate, reverse=True)
team_memberships.sort(key=lambda t: t.current, reverse=True)
base["teammems"] = team_memberships
# }}}
# {{{ If the player has at least one rating
if player.current_rating:
ratings = total_ratings(player.rating_set.filter(period__computed=True)).select_related("period")
base.update(
{
"highs": (
ratings.latest("rating"),
ratings.latest("tot_vp"),
ratings.latest("tot_vt"),
ratings.latest("tot_vz"),
),
"recentchange": player.get_latest_rating_update(),
"firstrating": ratings.earliest("period"),
"rating": player.current_rating,
}
)
if player.current_rating.decay >= INACTIVE_THRESHOLD:
base["messages"].append(Message(msg_inactive % player.tag, "Inactive", type=Message.INFO))
base["charts"] = base["recentchange"].period_id > base["firstrating"].period_id
else:
base["messages"].append(Message(_("%s has no rating yet.") % player.tag, type=Message.INFO))
base["charts"] = False
# }}}
# {{{ If the player has enough games to make a chart
if base["charts"]:
ratings = (
total_ratings(player.rating_set.filter(period_id__lte=base["recentchange"].period_id))
.select_related("period__end")
.prefetch_related("prev__rta", "prev__rtb")
.order_by("period")
)
# {{{ Add stories and other extra information
earliest = base["firstrating"]
latest = base["recentchange"]
# Look through team changes
teampoints = []
for mem in base["teammems"]:
if mem.start and earliest.period.end < mem.start < latest.period.end:
teampoints.append(
{
"date": mem.start,
"rating": interp_rating(mem.start, ratings),
"data": [{"date": mem.start, "team": mem.group, "jol": _("joins")}],
}
)
if mem.end and earliest.period.end < mem.end < latest.period.end:
teampoints.append(
{
"date": mem.end,
"rating": interp_rating(mem.end, ratings),
"data": [{"date": mem.end, "team": mem.group, "jol": _("leaves")}],
}
)
teampoints.sort(key=lambda p: p["date"])
# Condense if team changes happened within 14 days
cur = 0
while cur < len(teampoints) - 1:
if (teampoints[cur + 1]["date"] - teampoints[cur]["date"]).days <= 14:
teampoints[cur]["data"].append(teampoints[cur + 1]["data"][0])
del teampoints[cur + 1]
else:
cur += 1
# Sort first by date, then by joined/left
for point in teampoints:
point["data"].sort(key=lambda a: a["jol"], reverse=True)
point["data"].sort(key=lambda a: a["date"])
# Look through stories
stories = player.story_set.all().select_related("event__fullname")
for s in stories:
if earliest.period.start < s.date < latest.period.start:
s.rating = interp_rating(s.date, ratings)
else:
s.skip = True
# }}}
base.update({"ratings": add_counts(ratings), "patches": PATCHES, "stories": stories, "teampoints": teampoints})
else:
base["messages"].append(Message(msg_nochart % player.tag, type=Message.INFO))
# }}}
return render_to_response("player.djhtml", base)
def player(request, player_id):
player = get_object_or_404(Player, id=player_id)
base = base_ctx('Ranking', '%s:' % player.tag, request, context=player)
base.update(csrf(request))
# Make modifications
if 'op' in request.POST and request.POST['op'] == 'Submit' and base['adm'] == True:
tag = request.POST['tag']
country = request.POST['country']
name = request.POST['fullname']
if name == '':
name = None
akas = request.POST['AKA']
if akas != '':
aka = [s for s in akas.split(',')]
else:
aka = None
birthday = request.POST['birthday']
if birthday == '':
birthday = None
sc2c = request.POST['SC2C']
if sc2c == '':
sc2c = None
tlpdkr = request.POST['TLPDKR']
if tlpdkr == '':
tlpdkr = None
tlpdin = request.POST['TLPDIN']
if tlpdin == '':
tlpdin = None
sc2e = request.POST['SC2E']
if sc2e == '':
sc2e = None
lp = request.POST['LP']
if lp == '':
lp = None
if tag != '':
player.set_tag(tag)
player.set_country(country)
player.set_name(name)
player.set_birthday(birthday)
player.set_aliases(aka)
player.update_external_links(sc2c, tlpdkr, tlpdin, sc2e, lp)
countries = []
for k, v in data.ccn_to_cn.iteritems():
countries.append([k, v, data.ccn_to_cca2[k]])
countries.sort(key=lambda a: a[1])
base['countries'] = countries
try:
base['team'] = Team.objects.filter(active=True, teammembership__player=player, teammembership__current=True)[0]
except:
pass
try:
base['first'] = Match.objects.filter(Q(pla=player) | Q(plb=player)).order_by('date')[0]
base['last'] = Match.objects.filter(Q(pla=player) | Q(plb=player)).order_by('-date')[0]
except:
pass
base['totalmatches'] = Match.objects.filter(Q(pla=player) | Q(plb=player)).count()
base['offlinematches'] = Match.objects.filter(Q(pla=player) | Q(plb=player), offline=True).count()
base['aliases'] = Alias.objects.filter(player=player)
earnings = Earnings.objects.filter(player=player)
base['earnings'] = earnings.aggregate(Sum('earnings'))['earnings__sum']
# Winrates
matches_a = Match.objects.filter(pla=player)
matches_b = Match.objects.filter(plb=player)
def ntz(n):
return n if n is not None else 0
a = matches_a.aggregate(Sum('sca'), Sum('scb'))
b = matches_b.aggregate(Sum('sca'), Sum('scb'))
base['total'] = (ntz(a['sca__sum']) + ntz(b['scb__sum']), ntz(a['scb__sum']) + ntz(b['sca__sum']))
a = matches_a.filter(rcb='P').aggregate(Sum('sca'), Sum('scb'))
b = matches_b.filter(rca='P').aggregate(Sum('sca'), Sum('scb'))
base['vp'] = (ntz(a['sca__sum']) + ntz(b['scb__sum']), ntz(a['scb__sum']) + ntz(b['sca__sum']))
a = matches_a.filter(rcb='T').aggregate(Sum('sca'), Sum('scb'))
b = matches_b.filter(rca='T').aggregate(Sum('sca'), Sum('scb'))
base['vt'] = (ntz(a['sca__sum']) + ntz(b['scb__sum']), ntz(a['scb__sum']) + ntz(b['sca__sum']))
a = matches_a.filter(rcb='Z').aggregate(Sum('sca'), Sum('scb'))
b = matches_b.filter(rca='Z').aggregate(Sum('sca'), Sum('scb'))
base['vz'] = (ntz(a['sca__sum']) + ntz(b['scb__sum']), ntz(a['scb__sum']) + ntz(b['sca__sum']))
# Career highs
try:
base['highs'] = (Rating.objects.filter(player=player).order_by('-rating')[0],\
Rating.objects.filter(player=player).extra(select={'d':'rating+rating_vp'}).order_by('-d')[0],\
Rating.objects.filter(player=player).extra(select={'d':'rating+rating_vt'}).order_by('-d')[0],\
Rating.objects.filter(player=player).extra(select={'d':'rating+rating_vz'}).order_by('-d')[0])
except:
pass
try:
countryfull = transformations.cc_to_cn(player.country)
except:
countryfull = ''
rating = Rating.objects.filter(player=player).order_by('period').select_related('period')
base['charts'] = rating.count >= 2
if base['charts']:
try:
last_adjust = Rating.objects.filter(player=player, decay=0).order_by('-period')[0]
rating = rating.filter(period_id__lte=last_adjust.period_id)
except:
pass
base['ratings'] = rating
base['patches'] = PATCHES
recentchange = Rating.objects.filter(player=player, decay=0).order_by('-period')
if recentchange.exists():
base['recentchange'] = recentchange[0]
firstrating = Rating.objects.filter(player=player).order_by('period')
if firstrating.exists():
base['firstrating'] = firstrating[0]
if not rating.exists():
base.update({'player': player, 'countryfull': countryfull})
return render_to_response('player.html', base)
rating = rating.order_by('-period')[0]
matches = Match.objects.filter(Q(pla=player) | Q(plb=player))\
.select_related('pla__rating').select_related('plb__rating')\
.select_related('period')\
.extra(where=['abs(datediff(date,\'%s\')) < 90' % datetime.datetime.now()])\
.order_by('-date', '-id')[0:10]
if matches.exists():
base['matches'] = display_matches(matches, fix_left=player, ratings=True)
def meandate(tm):
if tm.start != None and tm.end != None:
return (tm.start.toordinal() + tm.end.toordinal())/2
elif tm.start != None:
return tm.start.toordinal()
elif tm.end != None:
return tm.end.toordinal()
else:
return 1000000
teammems = list(TeamMembership.objects.filter(player=player).extra(select={'mid': '(start+end)/2'}))
teammems = sorted(teammems, key=lambda t: t.id, reverse=True)
teammems = sorted(teammems, key=meandate, reverse=True)
teammems = sorted(teammems, key=lambda t: t.current, reverse=True)
base.update({'player': player, 'countryfull': countryfull, 'rating': rating, 'teammems': teammems})
return render_to_response('player.html', base)
