def get(self, *args):
self.get_template_values()
if not users.is_current_user_admin():
self.redirect(users.create_login_url(self.request.uri))
return
if len(args) > 0:
admin = args[0]
if "flush" == admin:
perm_cached_class(None, flush=True)
if "fifa" == admin:
Fifa2014.init_tree()
perm_cached_class(None, flush=True)
self.redirect('/admin/team')
elif "team" == admin:
if len(args) > 1:
self.template_values['team'] = Team.all().filter('short =',args[1]).get()
self.render('admin/team')
else:
self.template_values['teams'] = Team.all()
self.render('admin/teams')
elif "game" == admin:
if len(args) > 1:
game = SingleGame.byKey(args[1])
if self.request.get('save') == "Submit":
game.homeTeam_ref = Team.byKey(self.request.get('homeTeam'))
game.awayTeam_ref = Team.byKey(self.request.get('awayTeam'))
game.put()
self.template_values['game'] = game
self.template_values['teams'] = Team.all()
self.render('admin/game')
pass
else:
self.template_values['groupgames'] = GroupGame.all().order('name')
self.template_values['singlegames'] = SingleGame.all().order('time')
self.render('admin/games')
elif "user" == admin:
if len(args) > 1:
pass
else:
self.template_values['users'] = LocalUser.all()
#print pool.score_group(self.current_user(),Fifa2014().result,Fifa2014().tournament)
self.render('admin/users')
elif "result" == admin:
if self.request.get('save') == "Submit":
user = LocalUser.get(self.request.get('filter_user'))
singlegame = SingleGame.byKey(self.request.get('filter_game'))
singlegame.results(nocache=True)
result = user.singlegame_result(singlegame)
result.homeScore = int(self.request.get('homeScore'))
result.awayScore = int(self.request.get('awayScore'))
result.locked = True
result.put()
pool.flush_singlegame(singlegame)
user.singleresults(nocache=True)
self.template_values['users'] = LocalUser.actives()
self.template_values['singlegames'] = [{'key':game.key(),
'groupname':game.group().name,
'time':game.time,
'homeTeam':game.homeTeam(),
'awayTeam':game.awayTeam()} for game in SingleGame.everything().itervalues() if game.homeTeam()]
self.template_values['singlegames'].sort(cmp=lambda x,y: cmp(x['time'], y['time']))
self.template_values['singlegames'].sort(cmp=lambda x,y: cmp(x['groupname'], y['groupname']))
betQuery = Result.all()
groupbetQuery = GroupResult.all()
filter_game_key = self.request.get("filter_game")
if filter_game_key:
filter_game = SingleGame.everything()[filter_game_key]
self.template_values['filter_game'] = filter_game
betQuery = betQuery.filter("singlegame = ",filter_game)
groupbetQuery = groupbetQuery.filter("singlegame = ",filter_game)
filter_user_key = self.request.get("filter_user")
if filter_user_key:
filter_user = LocalUser.get(filter_user_key)
self.template_values['filter_user'] = filter_user
betQuery = betQuery.filter("user = "******"user = ",filter_user)
self.template_values['bets'] = betQuery.fetch(32)
self.template_values['groupbets'] = groupbetQuery.fetch(32)
self.render('admin/bets')
else:
self.render('admin/layout')
else:
self.render('admin/layout')
def save(self, user):
results = user.singleresults()
for argument in self.request.arguments():
match = re.match(r'^(homeScore|awayScore)\.(.*)$', argument)
if match:
name, key = match.groups()
try:
singlegame = SingleGame.byKey(key)
singlegame.results(nocache=True)
result = user.singlegame_result(singlegame)
except db.BadKeyError:
continue
except KeyError:
continue
if self.request.get(argument) != '':
if name == 'homeScore' and result.homeScore != int(self.request.get(argument)):
result.homeScore = int(self.request.get(argument))
elif name == 'awayScore' and result.awayScore != int(self.request.get(argument)):
result.awayScore = int(self.request.get(argument))
else:
continue
result.put()
for argument in self.request.arguments():
match = re.match(r'^lock\.(.*)$', argument)
if match:
key = match.group(1)
try:
singlegame = SingleGame.byKey(key)
singlegame.results(nocache=True)
pool.flush_singlegame(singlegame)
result = user.singlegame_result(singlegame)
except db.BadKeyError:
continue
except KeyError:
continue
if result.homeScore >= 0 and result.awayScore >= 0 and not result.locked:
result.locked = True
result.put()
groupinit = []
for argument in self.request.arguments():
match = re.match(r'^draw\.(.*)\.([0-9]+)$', argument)
if match:
key, idx = match.groups()
try:
groupgame = GroupGame.byKey(key)
except KeyError:
continue
except db.BadKeyError:
continue
groupresult = user.groupgame_result(groupgame)
if groupresult not in groupinit:
groupinit.append(groupresult)
groupresult.draw_order = [rank.team.name for rank in groupresult.get_ranks()]
groupresult.draw_order[int(idx)] = self.request.get(argument)
for argument in self.request.arguments():
match = re.match(r'grouplock\.(.*)$', argument)
if match:
key = match.group(1)
try:
groupgame = GroupGame.byKey(key)
except KeyError:
print "KeyError"
continue
except db.BadKeyError:
print "BadKeyError"
continue
pool.flush_groupgame(groupgame)
groupresult = user.groupgame_result(groupgame)
groupresult.locked = True
groupresult.put()
user.groupresults(nocache=True)
user.singleresults(nocache=True)