def parse_matches(self, submitter):
self.messages = []
if not self.is_valid():
self.messages.append(
Message(_('Entered data was invalid, no changes made.'),
type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
self.messages.append(
Message(error=error, field=self.fields[field].label))
return []
if not self.is_adm:
self.prematchgroup = PreMatchGroup(
date=self.cleaned_data['date'],
event=self.cleaned_data['eventtext'],
source=self.cleaned_data['source'],
contact=self.cleaned_data['contact'],
notes=self.cleaned_data['notes'],
game=self.cleaned_data['game'],
offline=self.cleaned_data['offline'],
)
self.prematchgroup.save()
error_lines, matches = [], []
for line in self.cleaned_data['matches'].splitlines():
if line.strip() == '':
continue
try:
parse_results = parse_match(line.strip(), allow_archon=False)
pla_query = parse_results['pla']
plb_query = parse_results['plb']
sca = parse_results['sca']
scb = parse_results['scb']
make_flag = 'MAKE' in parse_results['flags']
dup_flag = 'DUP' in parse_results['flags']
except pyparsing.ParseException as e:
self.messages.append(
Message(_("Could not parse '%(line)s' (%(error)s).") % {
'line': line,
'error': str(e)
},
type=Message.ERROR))
self.close_after = False
error_lines.append(line)
continue
pla_race_override = find_race_override(pla_query)
plb_race_override = find_race_override(plb_query)
try:
match = self.make_match(
pla_query,
plb_query,
pla_race_override,
plb_race_override,
sca,
scb,
make_flag,
dup_flag,
)
if match is None:
error_lines.append(line)
continue
except Exception as e:
self.messages.append(
Message(_("Error creating match '%(line)s' (%(error)s).") %
{
'line': line,
'error': str(e)
},
type=Message.ERROR))
self.close_after = False
error_lines.append(line)
continue
if self.is_adm:
match.submitter = submitter
matches.append(match)
for m in matches:
m.save()
if len(matches) > 0:
self.messages.append(
Message(ungettext_lazy('Successfully added %i match.',
'Successfully added %i matches.',
len(matches)) % len(matches),
type=Message.SUCCESS))
if self.close_after:
self.cleaned_data['eventobj'].close()
self.messages.append(
Message(_("Closed '%s'.") %
self.cleaned_data['eventobj'].fullname,
type=Message.SUCCESS))
elif self.requested_close_after:
self.messages.append(
Message(_("Did not close '%s'.") %
self.cleaned_data['eventobj'].fullname,
type=Message.INFO))
self.data = self.data.copy()
self.data['matches'] = '\n'.join(error_lines)
return matches
def player_info(request, choice=None):
base = base_ctx('Submit', 'Player Info', request)
if not base['adm']:
return redirect('/login/')
login_message(base)
if request.method == 'POST':
form = PlayerInfoForm(request.POST)
if form.is_valid():
player = form.commit()
base['messages'].append(
Message(
# Translators: Updated a player
text=_("Updated %s") % player_filter(player),
type=Message.SUCCESS))
page = 1
if 'page' in request.GET:
try:
page = int(request.GET['page'])
except:
pass
country = 'all' if 'country' not in request.GET else request.GET['country']
base['country'] = country
base['countries'] = country_list(Player.objects.all())
if country == 'all':
all_count = Player.objects.count()
else:
all_count = Player.objects.filter(country=country).count()
base["all_count"] = all_count
q = Player.objects.all()
if country != 'all':
q = q.filter(country=country)
queries = {
'birthday': q.filter(birthday__isnull=True),
'name': q.filter(name__isnull=True),
'country': q.filter(country__isnull=True)
}
base["subnav"] = [(_('Progress'), '/add/player_info/')]
if all_count == 0:
base['no_players'] = True
elif choice is not None and choice in ('birthday', 'name', 'country'):
q = queries[choice].extra(select=EXTRA_NULL_SELECT)\
.order_by(
"-null_curr",
"-current_rating__rating",
"id"
)
base["players"] = q[(page - 1) * 50:page * 50]
base["page"] = page
base["next_page"] = q.count() > page * 50
base["form"] = PlayerInfoForm()
else:
values = dict()
for k, v in queries.items():
c = all_count - v.count()
values[k] = {
'count': c,
'pctg': '%.2f' % (100 * float(c) / float(all_count))
}
values["birthday"]["title"] = _("Players with birthday")
values["name"]["title"] = _("Players with name")
values["country"]["title"] = _("Players with country")
base["values"] = list(values.items())
base["values"].sort(key=lambda x: x[0])
return render_to_response('player_info.djhtml', base)
def commit(self, post, submitter):
self.messages = []
if not self.is_valid():
self.messages.append(
Message(_('Entered data was invalid, no changes made.'),
type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
if field == '__all__':
self.messages.append(Message(error,
type=Message.ERROR))
else:
self.messages.append(
Message(error=error,
field=self.fields[field].label))
return
prematches = [
PreMatch.objects.get(id=int(key.split('-')[-1]))
for key in sorted(post.keys())
if key[0:6] == 'match-' and post[key] == 'y'
]
matches = []
for pm in prematches:
if not self.approve:
group = pm.group
pm.delete()
if not group.prematch_set.exists():
group.delete()
continue
if pm.pla is None:
pm.pla_string = post['match-%i-pla' % pm.id]
if pm.plb is None:
pm.plb_string = post['match-%i-plb' % pm.id]
pm.save()
for msg in fill_players(pm):
self.messages.append(Message(msg, type=Message.ERROR))
if pm.is_valid():
m = Match(
pla=pm.pla,
plb=pm.plb,
sca=pm.sca,
scb=pm.scb,
rca=pm.rca or (pm.pla.race if pm.pla.race != 'S' else 'R'),
rcb=pm.rcb or (pm.plb.race if pm.plb.race != 'S' else 'R'),
date=self.cleaned_data['date'] or pm.group.date,
eventobj=self.cleaned_data['eventobj'],
event=pm.group.event,
submitter=submitter,
offline=pm.group.offline,
game=pm.group.game,
)
if check_duplicates(m, self.cleaned_data['dup_flag']):
self.messages.append(
Message(
_("Could not make match %(pla)s vs %(plb)s: possible duplicate found."
) % {
'pla': m.pla.tag,
'plb': m.plb.tag
},
type=Message.ERROR,
))
continue
if 'R' in [m.rca, m.rcb]:
self.messages.append(
Message(
_("Unknown race in %(pla)s vs %(plb)s: set to random."
) % {
'pla': pla.tag,
'plb': plb.tag
},
type=Message.WARNING,
))
m.set_period()
m.set_ratings()
m.save()
matches.append(m)
group = pm.group
pm.delete()
if not group.prematch_set.exists():
group.delete()
else:
pm.save()
if self.approve and len(matches) > 0:
self.messages.append(
Message(ungettext_lazy('Successfully approved %i match.',
'Successfully approved %i matches.',
len(matches)) % len(matches),
type=Message.SUCCESS))
elif not self.approve and len(prematches) > 0:
self.messages.append(
Message(ungettext_lazy('Successfully rejected %i match.',
'Successfully rejected %i matches.',
len(prematches)) % len(prematches),
type=Message.SUCCESS))
def update(value, attr, setter, label):
if value != getattr(player, attr):
getattr(player, setter)(value)
# Translators: Changed something (a noun).
ret.append(
Message(_('Changed %s.') % label, type=Message.SUCCESS))
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__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 search(self, adm):
# {{{ Check validity (lol)
if not self.is_valid():
msgs = []
msgs.append(Message(_('Entered data was invalid, no changes made.'), type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
msgs.append(Message(error=error, field=self.fields[field].label))
return {'messages': msgs}
# }}}
matches = (
Match.objects.all().prefetch_related('message_set')
.prefetch_related('pla', 'plb', 'period', 'eventobj')
.annotate(Count('eventobj__match'))
)
# {{{ All the easy filtering
if self.cleaned_data['after'] is not None:
matches = matches.filter(date__gte=self.cleaned_data['after'])
if self.cleaned_data['before'] is not None:
matches = matches.filter(date__lte=self.cleaned_data['before'])
if self.cleaned_data['unassigned'] and adm:
matches = matches.filter(eventobj__isnull=True)
if self.cleaned_data['bestof'] == '3':
matches = matches.filter(Q(sca__gte=2) | Q(scb__gte=2))
elif self.cleaned_data['bestof'] == '5':
matches = matches.filter(Q(sca__gte=3) | Q(scb__gte=3))
if self.cleaned_data['offline'] != 'both':
matches = matches.filter(offline=(self.cleaned_data['offline']=='offline'))
if self.cleaned_data['game'] != 'all':
matches = matches.filter(game=self.cleaned_data['game'])
if self.cleaned_data['wcs_season'] != '':
if self.cleaned_data['wcs_season'] == 'all':
matches = matches.filter(
eventobj__uplink__parent__wcs_year__isnull=False
)
else:
matches = matches.filter(
eventobj__uplink__parent__wcs_year=int(self.cleaned_data['wcs_season'])
)
if self.cleaned_data['wcs_tier'] != '':
tiers = list(map(int, self.cleaned_data['wcs_tier']))
matches = matches.filter(
eventobj__uplink__parent__wcs_tier__in=tiers
)
# }}}
matches = matches.distinct()
# {{{ Filter by event
if self.cleaned_data['event'] != None:
lex = shlex.shlex(self.cleaned_data['event'], posix=True)
lex.wordchars += "'"
lex.quotes = '"'
terms = [s.strip() for s in list(lex) if s.strip() != '']
no_eventobj_q = Q(eventobj__isnull=True)
for term in terms:
no_eventobj_q &= Q(event__icontains=term)
matches = matches.filter(
no_eventobj_q |
Q(
eventobj__isnull=False,
eventobj__fullname__iregex=(
r"\s".join(r".*{}.*".format(term) for term in terms)
)
)
)
# }}}
ret = {'messages': []}
# {{{ Filter by players
lines = self.cleaned_data['players'].splitlines()
lineno, ok, players = -1, True, []
for line in lines:
lineno += 1
if line.strip() == '':
continue
pls = find_player(query=line, make=False)
if not pls.exists():
ret['messages'].append(Message(
# Translators: Matches here as in search matches.
_("No matches found: '%s'.") % line.strip(), type=Message.ERROR
))
ok = False
else:
if pls.count() > 1:
ret['messages'].append(NotUniquePlayerMessage(
line.strip(), pls, update=self['players'].auto_id,
updateline=lineno, type=Message.WARNING
))
players.append(list(pls))
if not ok:
return ret
pls = []
for p in players:
pls += p
if len(pls) > 1:
matches = matches.filter(pla__in=pls, plb__in=pls)
elif len(pls) == 1:
matches = matches.filter(Q(pla__in=pls) | Q(plb__in=pls))
# }}}
# {{{ Collect data
ret['count'] = matches.count()
if ret['count'] > 1000:
ret['messages'].append(Message(
_('Too many results (%i). Please add restrictions.') % ret['count'],
type=Message.ERROR
))
return ret
matches = matches.order_by('-eventobj__latest', '-eventobj__idx', '-date', 'event', 'id')
if 1 <= len(pls) <= 2:
ret['matches'] = display_matches(matches, date=True, fix_left=pls[0], eventcount=True)
ret['sc_my'], ret['sc_op'] = (
sum([m['pla']['score'] for m in ret['matches']]),
sum([m['plb']['score'] for m in ret['matches']]),
)
ret['msc_my'], ret['msc_op'] = (
sum([1 if m['pla']['score'] > m['plb']['score'] else 0 for m in ret['matches']]),
sum([1 if m['plb']['score'] > m['pla']['score'] else 0 for m in ret['matches']]),
)
ret['left'] = pls[0]
if len(pls) == 2:
ret['right'] = pls[1]
else:
ret['matches'] = display_matches(matches, date=True, eventcount=True)
return ret
def events(request, event_id=None):
# {{{ Get base context, redirect if necessary
if 'goto' in request.GET:
return redirect('/results/events/' + request.GET['goto'])
base = base_ctx('Results', 'By Event', request)
# }}}
# {{{ Display the main table if event ID is not given
if event_id is None:
root_events = (
Event.objects
.annotate(num_uplinks=Count("uplink"))
.filter(num_uplinks=1)
.order_by('name')
.only('id', 'name', 'big', 'category', 'fullname')
)
base.update({
'bigs': (
list(root_events.filter(big=True, category=CAT_INDIVIDUAL)) +
list(root_events.filter(big=True, category=CAT_TEAM)) +
list(root_events.filter(big=True, category=CAT_FREQUENT))
),
'smalls': (
list(root_events.filter(big=False, category=CAT_INDIVIDUAL).order_by('name')) +
list(root_events.filter(big=False, category=CAT_TEAM).order_by('name')) +
list(root_events.filter(big=False, category=CAT_FREQUENT).order_by('name'))
)
})
base['messages'].append(Message(
_('The events are organized in a hierarchical fashion. Thus, all GSL tournaments '
'are filed under GSL, all Code S under their respective seasons, all groups under '
'their respective Code S event, and so on.'),
type=Message.INFO
))
return render_to_response('events.djhtml', base)
# }}}
# {{{ Get object, generate messages, and ensure big is set. Find familial relationships.
event = get_object_or_404(Event, id=event_id)
base['messages'] += generate_messages(event)
matches = event.get_matchset()
if matches.count() > 200 and not event.big:
event.set_big(True)
base.update({
'event': event,
'siblings': event.get_parent().get_immediate_children().exclude(id=event.id)
if event.get_parent() else None,
'path': event.get_ancestors(id=True),
'children': event.get_immediate_children(),
})
# }}}
# {{{ Make forms
if base['adm']:
def check_form(formname, cl, check):
if request.method == 'POST' and check in request.POST:
f = cl(request=request, event=event)
base['messages'] += f.update_event(event)
else:
f = cl(event=event)
base[formname] = f
check_form('form', EventModForm, 'modevent')
check_form('addform', AddForm, 'addevent')
if event.has_children():
check_form('reorderform', ReorderForm, 'reorder')
if event.type == TYPE_EVENT:
check_form('ppform', PrizepoolModForm, 'modpp')
check_form('wcsform', WCSModForm, 'modwcs')
if not event.has_children() and event.get_immediate_matchset().exists():
check_form('stform', StoriesForm, 'modstory')
if 'close' in request.GET and request.GET['close'] == '1':
event.close()
base['messages'].append(Message(_('Sucessfully closed event.'), type=Message.SUCCESS))
# }}}
# {{{ Prizepool information for the public
total_earnings = Earnings.objects.filter(event__uplink__parent=event)
local_earnings = Earnings.objects.filter(event=event)
ranked_prize = local_earnings.exclude(placement=0)\
.order_by('-earnings', 'placement')
unranked_prize = list(
local_earnings.filter(placement=0).order_by('-earnings')
)
placements = get_placements(event)
prize_pool_table = list()
for k, g in groupby(ranked_prize, key=lambda x: x.earnings):
gl = list(g)
prize_pool_table.append((k, placements[k], gl, len(gl)))
if len(prize_pool_table) > 0:
base['ranked_prize'] = prize_pool_table
if len(unranked_prize) > 0:
base['unranked_prize'] = unranked_prize
currencies = list({r['currency'] for r in total_earnings.values('currency').distinct()})
base.update({
'prizepool': total_earnings.aggregate(Sum('earnings'))['earnings__sum'],
'nousdpp': len(currencies) > 1 or len(currencies) == 1 and currencies[0] != 'USD',
'prizepoolorig': [{
'pp': total_earnings.filter(currency=k).aggregate(Sum('origearnings'))['origearnings__sum'],
'cur': k,
} for k in currencies],
})
# }}}
# {{{ Other easy statistics
add_links = request.user.is_authenticated() and request.user.is_staff
base.update({
'game': etn(lambda: dict(GAMES)[matches.values('game').distinct()[0]['game']]),
'nmatches': matches.count(),
'ngames': sum(count_winloss_games(matches)),
'pvp_games': count_mirror_games(matches, 'P'),
'tvt_games': count_mirror_games(matches, 'T'),
'zvz_games': count_mirror_games(matches, 'Z'),
'matches': display_matches(
matches.prefetch_related('message_set')
.prefetch_related('pla', 'plb', 'eventobj')
.annotate(Count('eventobj__match'))
.order_by('-eventobj__latest', '-eventobj__idx', '-date', '-id')[0:200],
eventcount=True,
add_links=add_links
),
'nplayers': Player.objects.filter(
Q(id__in=matches.values('pla')) | Q(id__in=matches.values('plb'))
).count(),
})
offlines = list(matches.values('offline').distinct())
if len(offlines) > 1:
base['offline'] = _('Both')
elif len(offlines) == 1:
base['offline'] = _('Offline') if offlines[0]['offline'] else _('Online')
base['pvt_wins'], base['pvt_loss'] = count_matchup_games(matches, 'P', 'T')
base['pvz_wins'], base['pvz_loss'] = count_matchup_games(matches, 'P', 'Z')
base['tvz_wins'], base['tvz_loss'] = count_matchup_games(matches, 'T', 'Z')
base['tot_mirror'] = base['pvp_games'] + base['tvt_games'] + base['zvz_games']
# }}}
return render_to_response('eventres.djhtml', base)
def update(value, attr, setter, label):
if value != getattr(event, attr):
getattr(event, setter)(value)
ret.append(Message(_('Changed %s.') % label, type=Message.SUCCESS))
def update_event(self, event):
ret = []
if not self.is_valid():
ret.append(Message(_('Entered data was invalid, no changes made.'), type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
ret.append(Message(error=error, field=self.fields[field].label))
return ret
if self.cleaned_data['name'] != event.name:
event.update_name(self.cleaned_data['name'])
for e in event.get_children(id=False):
e.update_name()
ret.append(Message(_('Changed event name.'), type=Message.SUCCESS))
if self.cleaned_data['date'] is not None:
nchanged = event.get_matchset().update(date=self.cleaned_data['date'])
ret.append(Message(
ungettext_lazy('Changed date for %i match.', 'Changed date for %i matches.', nchanged)
% nchanged, type=Message.SUCCESS
))
if self.cleaned_data['game'] != 'nochange':
nchanged = event.get_matchset().update(game=self.cleaned_data['game'])
ret.append(Message(
ungettext_lazy(
'Changed game version for %i match.',
'Changed game version for %i matches.',
nchanged) % nchanged,
type=Message.SUCCESS
))
if self.cleaned_data['offline'] != 'nochange':
nchanged = event.get_matchset().update(offline=(self.cleaned_data['offline']=='offline'))
ret.append(Message(
ungettext_lazy(
'Changed on/offline for %i match.',
'Changed on/offline for %i matches.',
nchanged) % nchanged,
type=Message.SUCCESS
))
events = [event] if not self.cleaned_data['same_level'] else event.parent.get_immediate_children()
nchanged = 0
for e in events:
if e.type != self.cleaned_data['type']:
e.change_type(self.cleaned_data['type'])
nchanged += 1
if nchanged > 0:
ret.append(Message(
ungettext_lazy('Changed type for %i event.', 'Changed type for %i events.', nchanged)
% nchanged, type=Message.SUCCESS
))
def update(value, attr, setter, label):
if value != getattr(event, attr):
getattr(event, setter)(value)
ret.append(Message(_('Changed %s.') % label, type=Message.SUCCESS))
update(self.cleaned_data['homepage'], 'homepage', 'set_homepage', _('homepage'))
update(self.cleaned_data['tlpd_id'], 'tlpd_id', 'set_tlpd_id', _('TLPD ID'))
update(self.cleaned_data['lp_name'], 'lp_name', 'set_lp_name', _('Liquipedia title'))
update(self.cleaned_data['tl_thread'], 'tl_thread', 'set_tl_thread', _('TL thread'))
update(sum([int(a) for a in self.cleaned_data['tlpd_db']]), 'tlpd_db', 'set_tlpd_db', _('TLPD DBs'))
return ret
def update_event(self, event):
ret = []
if not self.is_valid():
ret.append(
Message(_('Entered data was invalid, no changes made.'),
type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
ret.append(
Message(error=error, field=self.fields[field].label))
return ret
# {{{ Gather data
ranked, unranked, ok = [], [], True
for line in self.cleaned_data['ranked'].split('\n'):
if line.strip() == '':
continue
try:
prize, player = self.line_to_data(line)
ranked.append({
'prize': prize,
'player': player,
'placement': 0
})
except Exception as e:
ret.append(Message(str(e), type=Message.ERROR))
ok = False
for line in self.cleaned_data['unranked'].split('\n'):
if line.strip() == '':
continue
try:
prize, player = self.line_to_data(line)
unranked.append({
'prize': prize,
'player': player,
'placement': -1
})
except Exception as e:
ret.append(Message(str(e), type=Message.ERROR))
ok = False
if not ok:
ret.append(
Message(_('Errors occured, no changes made.'),
type=Message.ERROR))
return ret
# }}}
# {{{ Fix placements of ranked prizes
ranked.sort(key=lambda a: a['placement'])
for i, e in enumerate(ranked):
ranked[i]['placement'] = i
# }}}
# {{{ Commit
try:
Earnings.set_earnings(event, ranked, self.cleaned_data['currency'],
True)
Earnings.set_earnings(event, unranked,
self.cleaned_data['currency'], False)
except RateNotFoundError as e:
ret.append(Message(str(e), type=Message.ERROR))
return ret
# }}}
# Translators: New prizepools added to the database.
ret.append(Message(_('New prizes committed.'), type=Message.SUCCESS))
return ret
def update_event(self, event):
ret = []
if not self.is_valid():
ret.append(
Message(_('Entered data was invalid, no changes made.'),
type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
ret.append(
Message(error=error, field=self.fields[field].label))
return ret
# {{{ Gather data
entries, ok = [], True
for line in self.cleaned_data['points'].split('\n'):
if line.strip() == '':
continue
try:
points, player = self.line_to_data(line)
entries.append({
'points': points,
'player': player,
'placement': 0
})
except Exception as e:
ret.append(Message(str(e), type=Message.ERROR))
ok = False
if not ok:
ret.append(
Message(_('Errors occured, no changes made.'),
type=Message.ERROR))
return ret
# }}}
# {{{ If not a WCS event, clear all data
if self.cleaned_data['year'] == 'None':
WCSPoints.set_points(event, [])
event.wcs_year = None
event.wcs_tier = None
event.save()
ret.append(Message(_('WCS data cleared'), type=Message.SUCCESS))
return ret
# }}}
# {{{ If a WCS event, set all data
entries.sort(key=lambda a: a['placement'])
for i, e in enumerate(entries):
e['placement'] = i
WCSPoints.set_points(event, entries)
event.wcs_year = int(self.cleaned_data['year'])
event.wcs_tier = int(self.cleaned_data['tier'])
event.save()
ret.append(Message(_('WCS data stored.'), type=Message.SUCCESS))
return ret
def update_event(self, event):
ret = []
if not self.is_valid():
ret.append(
Message(_('Entered data was invalid, no changes made.'),
type=Message.ERROR))
for field, errors in self.errors.items():
for error in errors:
ret.append(
Message(error=error, field=self.fields[field].label))
return ret
if self.action in ['upd', 'del']:
try:
print('id:', self.cleaned_data['story_id'])
story = Story.objects.get(id=self.cleaned_data['story_id'])
except:
ret.append(
Message(_('Story could not be found.'),
type=Message.ERROR))
return ret
if self.action == 'upd':
story.date = self.cleaned_data['date']
story.message = self.cleaned_data['text']
story.params = self.cleaned_data['params']
print(story.params)
if story.verify():
story.save()
ret.append(
Message(_('Story was successfully changed.'),
type=Message.SUCCESS))
else:
ret.append(
Message(_('Parameter verification failed.'),
type=Message.ERROR))
elif self.action == 'del':
story.delete()
ret.append(
Message(_('Story was successfully deleted.'),
type=Message.SUCCESS))
elif self.action == 'new':
story = Story(
player=Player.objects.get(id=self.cleaned_data['player']),
event=event,
date=self.cleaned_data['date'],
message=self.cleaned_data['text'],
params=self.cleaned_data['params'])
if story.verify():
story.save()
ret.append(
Message(_('Story was successfully created.'),
type=Message.SUCCESS))
else:
ret.append(
Message(_('Parameter verification failed.'),
type=Message.ERROR))
return ret
