def get_runnerlist( self, no_refresh=False ):
key = self.get_runnerlist_memkey( )
runnerlist = memcache.get( key )
if runnerlist is None and not no_refresh:
# Build the runnerlist, which is a list of dictionaries where each
# dict gives the username and number of pbs for that user.
# The list is sorted by numbers of pbs for the user.
runnerlist = [ ]
try:
q = db.Query( runners.Runners,
projection=('username', 'gravatar', 'num_pbs') )
q.ancestor( runners.key() )
q.order( '-num_pbs' )
q.order( 'username' )
for runner in q.run( limit=100000 ):
runnerlist.append(
dict( username = runner.username,
username_code = util.get_code( runner.username ),
num_pbs = runner.num_pbs,
gravatar_url = util.get_gravatar_url(
runner.gravatar ) ) )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return self.OVER_QUOTA_ERROR
if memcache.set( key, runnerlist ):
logging.debug( "Set runnerlist in memcache" )
else:
logging.warning( "Failed to set new runnerlist in memcache" )
def get( self, game_code ):
user = self.get_user( )
# Make sure this game exists
game_model = self.get_game_model( game_code )
if not game_model:
self.error( 404 )
self.render( "404.html", user=user )
return
# Find out if this user has run this game
if user is not None:
user_has_run = self.get_user_has_run( user.username,
game_model.game )
else:
user_has_run = False
gamepage = self.get_gamepage( game_model.game )
# Add gravatar images to the gamepage
for d in gamepage:
for run in d['infolist']:
runner = self.get_runner( util.get_code( run['username'] ) )
if runner is not None:
run['gravatar_url'] = util.get_gravatar_url(
runner.gravatar, size=20 )
if self.format == 'html':
self.render( "gamepage.html", user=user, game=game_model.game,
game_code=game_code, gamepage=gamepage,
user_has_run=user_has_run )
elif self.format == 'json':
self.render_json( gamepage )
def get(self):
user = self.get_user()
return_url = self.request.get('from')
if not return_url:
return_url = "/"
elif user is not None and user.is_mod:
# Mod is editing a user's profile, possibly his or her own
username_code = return_url.split('/')[-1]
user = self.get_runner(username_code)
if user is not None:
# Editing profile
params = dict(user=user,
youtube=user.youtube,
twitch=user.twitch,
return_url=return_url)
if user.twitter:
params['twitter'] = '@' + user.twitter
if user.gravatar:
params['gravatar'] = '<private email>'
params['gravatar_url'] = util.get_gravatar_url(
user.gravatar, 30)
if user.timezone is not None:
params['timezone'] = user.timezone
self.render("signup.html",
timezones=pytz.common_timezones,
**params)
else:
# New user
self.render("signup.html",
return_url=return_url,
timezones=pytz.common_timezones)
def get( self ):
user = self.get_user( )
return_url = self.request.get( 'from' )
if not return_url:
return_url = "/"
elif user is not None and user.is_mod:
# Mod is editing a user's profile, possibly his or her own
username_code = return_url.split( '/' )[ -1 ]
user = self.get_runner( username_code )
if user is not None:
# Editing profile
params = dict( user=user,
youtube=user.youtube,
twitch=user.twitch,
return_url=return_url )
if user.twitter:
params['twitter'] = '@' + user.twitter
if user.gravatar:
params['gravatar'] = '<private email>'
params['gravatar_url'] = util.get_gravatar_url( user.gravatar,
30 )
if user.timezone is not None:
params['timezone'] = user.timezone
self.render( "signup.html", timezones=pytz.common_timezones,
**params )
else:
# New user
self.render( "signup.html", return_url=return_url,
timezones=pytz.common_timezones )
def get_runnerlist(self, no_refresh=False):
key = self.get_runnerlist_memkey()
runnerlist = memcache.get(key)
if runnerlist is None and not no_refresh:
# Build the runnerlist, which is a list of dictionaries where each
# dict gives the username and number of pbs for that user.
# The list is sorted by numbers of pbs for the user.
runnerlist = []
try:
q = db.Query(runners.Runners,
projection=('username', 'gravatar', 'num_pbs'))
q.ancestor(runners.key())
q.order('-num_pbs')
q.order('username')
for runner in q.run(limit=100000):
runnerlist.append(
dict(username=runner.username,
username_code=util.get_code(runner.username),
num_pbs=runner.num_pbs,
gravatar_url=util.get_gravatar_url(
runner.gravatar)))
except apiproxy_errors.OverQuotaError, msg:
logging.error(msg)
return self.OVER_QUOTA_ERROR
if memcache.set(key, runnerlist):
logging.debug("Set runnerlist in memcache")
else:
logging.warning("Failed to set new runnerlist in memcache")
def get_runnerlist(self, no_refresh=False):
key = self.get_runnerlist_memkey()
runnerlist = memcache.get(key)
if runnerlist is None and not no_refresh:
# Build the runnerlist, which is a list of dictionaries where each
# dict gives the username and number of pbs for that user.
# The list is sorted by numbers of pbs for the user.
runnerlist = []
q = db.Query(runners.Runners, projection=("username", "gravatar", "num_pbs"))
q.ancestor(runners.key())
q.order("-num_pbs")
q.order("username")
for runner in q.run(limit=100000):
runnerlist.append(
dict(
username=runner.username,
username_code=util.get_code(runner.username),
num_pbs=runner.num_pbs,
gravatar_url=util.get_gravatar_url(runner.gravatar),
)
)
if memcache.set(key, runnerlist):
logging.debug("Set runnerlist in memcache")
else:
logging.warning("Failed to set new runnerlist in memcache")
elif runnerlist is not None:
logging.debug("Got runnerlist from memcache")
return runnerlist
def get_runnerlist( self, page_num ):
key = self.get_runnerlist_memkey( )
data = memcache.get( key )
if data is None:
data = dict( )
res = data.get( page_num )
if res is None:
# Build the runnerlist, which is a list of dictionaries where each
# dict gives the username and number of pbs for that user.
# The list is sorted by numbers of pbs for the user.
res = dict( page_num=page_num,
runnerlist=[ ],
has_next=True )
try:
q = db.Query( runners.Runners,
projection=['username', 'gravatar', 'num_pbs'] )
q.ancestor( runners.key() )
q.order( '-num_pbs' )
q.order( 'username' )
c = memcache.get( self.get_runnerlist_cursor_memkey(
page_num ) )
if c:
try:
q.with_cursor( start_cursor=c )
except BadRequestError:
res['page_num'] = 1
else:
res['page_num'] = 1
for runner in q.run( limit=self.PAGE_LIMIT ):
res['runnerlist'].append(
dict( username = runner.username,
username_code = util.get_code( runner.username ),
num_pbs = runner.num_pbs,
gravatar_url = util.get_gravatar_url(
runner.gravatar ) ) )
c = q.cursor( )
cursor_key = self.get_runnerlist_cursor_memkey(
res['page_num'] + 1 )
if memcache.set( cursor_key, c ):
logging.debug( "Set " + cursor_key + " in memcache" )
else:
logging.warning( "Failed to set new " + cursor_key
+ " in memcache" )
if len( res['runnerlist'] ) < self.PAGE_LIMIT:
res['has_next'] = False
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return self.OVER_QUOTA_ERROR
data[ res['page_num'] ] = res
if memcache.set( key, data ):
logging.debug( "Set " + key + " in memcache" )
else:
logging.warning( "Failed to set new " + key + " in memcache" )
def post(self):
challenge = self.request.get('recaptcha_challenge_field')
response = self.request.get('recaptcha_response_field')
remoteip = environ['REMOTE_ADDR']
cResponse = captcha.submit(challenge, response,
'6LfrwroSAAAAADfwZ2WtvUV0zdbyV3BzAfRTzaDr',
remoteip)
# Create a new comment
message = Comment()
message.nickname = self.request.get('nickname')
message.email = self.request.get('email')
message.gravatar = get_gravatar_url(message.email.encode('utf-8'))
message.website = self.request.get('website')
message.msg = self.request.get('msg')
message.ref_msg = self.request.get('refMsg')
message.ref_name = self.request.get('refName')
id = self.request.get('id')
message.article = Article.all().filter('id =', id).get()
show_cancel = self.request.get('cancel')
msgid = 0 if self.request.get('msgId') == '' else int(self.request.get('msgId'))
if cResponse.is_valid:
rep = re.compile('^http://', re.IGNORECASE)
message.website = re.sub(rep, '', message.website)
# Escape the content
message.msg = escape_str(message.msg)
message.escaped_msg = message.msg.replace('\\', '\\\\')
message.ref_msg = escape_str(message.ref_msg)
message.put()
self.redirect('/article/' + message.article.permalink)
else:
self.captcha_error = 'Please try again'
self.save_nickname = message.nickname
self.save_email = message.email
self.save_website = message.website
self.save_msg = message.msg
self.save_ref = message.ref_msg
self.save_refname = message.ref_name
self.save_showcancel = show_cancel
self.save_msgid = msgid
self.get()
def yield_page(self, tname, tvals):
user = users.get_current_user()
if user is None:
self.redirect(users.create_login_url(self.request.uri))
else:
player = Player.get_player(user)
context = {
"username": user.nickname(),
'user': user,
"player": player,
"gravatar_url": get_gravatar_url(user.email()),
"logout_url": users.create_logout_url("/"),
"tname":tname
}
context.update(tvals)
cpath = os.path.join(os.path.dirname(__file__), 'templates/%s.html' % tname)
self.response.out.write(template.render(cpath, context))
def get(self, game_code):
user = self.get_user()
# Have to take the code of the game code because of percent
# encoded plusses
game_code = util.get_code(game_code)
# Make sure this game exists
game_model = self.get_game_model(game_code)
if not game_model:
self.error(404)
self.render("404.html", user=user)
return
# Find out if this user has run this game
if user is not None:
user_has_run = self.get_user_has_run(user.username,
game_model.game)
else:
user_has_run = False
gamepage = self.get_gamepage(game_model.game)
# Add gravatar images to the gamepage
for d in gamepage:
for run in d['infolist']:
runner = self.get_runner(util.get_code(run['username']))
if runner is not None:
run['gravatar_url'] = util.get_gravatar_url(
runner.gravatar, size=20)
if self.format == 'html':
self.render("gamepage.html",
user=user,
game=game_model.game,
game_code=game_code,
gamepage=gamepage,
user_has_run=user_has_run)
elif self.format == 'json':
self.render_json(gamepage)
def get( self, game_code ):
try:
user = self.get_user( )
if user == self.OVER_QUOTA_ERROR:
user = None
# Have to take the code of the game code because of percent
# encoded plusses
game_code = util.get_code( game_code )
# Make sure this game exists
game_model = self.get_game_model( game_code )
if not game_model:
self.error( 404 )
self.render( "404.html", user=user )
return
if game_model == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
# Find out if this user has run this game
if user is not None:
user_has_run = self.get_user_has_run( user.username,
game_model.game )
if user_has_run == self.OVER_QUOTA_ERROR:
user_has_run = False
else:
user_has_run = False
# Look for a specific category to display
category_code = self.request.get( 'c' )
if category_code:
category_code = util.get_code( category_code )
else:
category_code = None
# Grab the categories with their codes
categories = [ ]
category = None
for this_category in game_model.categories( ):
this_category_code = util.get_code( this_category )
categories.append( dict( category=this_category,
category_code=this_category_code ) )
if category_code == this_category_code:
category = this_category
categories.sort( key=itemgetter( 'category_code' ) )
# Grab the page num
page_num = self.request.get( 'page' )
try:
page_num = int( page_num )
except ValueError:
page_num = 1
gamepage = self.get_gamepage( game_model.game, category, page_num )
if gamepage == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
page_num = gamepage['page_num']
# Add gravatar images to the gamepage
d = gamepage['d']
if d is not None:
for run in d['infolist']:
runner = self.get_runner( util.get_code(
run['username'] ) )
if runner == self.OVER_QUOTA_ERROR:
self.error( 403 )
if self.format == 'html':
self.render( "403.html", user=user )
return
if runner is not None:
run['gravatar_url'] = util.get_gravatar_url(
runner.gravatar, size=20 )
if len( d['infolist'] ) <= 0 and page_num == 1:
# Delete this category for the game model
gameinfolist = json.loads( game_model.info )
for i, gameinfo in enumerate( gameinfolist ):
if category == gameinfo['category']:
del gameinfolist[ i ]
logging.info( 'Removed ' + category
+ ' from ' + game_model.game )
if len( gameinfolist ) == 0:
# Remove the game
game = game_model.game
game_model.delete( )
logging.info( game + " deleted" )
self.update_cache_game_model( game_code, None )
# From gamelist in memcache too
cached_gamelists = self.get_cached_gamelists( )
if cached_gamelists is not None:
done = False
for page_num, res in cached_gamelists.iteritems( ):
if done:
break
for i, d in enumerate( res['gamelist'] ):
if d['game'] == game:
del cached_gamelists[ page_num ]['gamelist'][ i ]
done = True
break
self.update_cache_gamelist(
cached_gamelists )
self.error( 404 )
self.render( "404.html", user=user )
return
else:
# Update game
game_model.info = json.dumps( gameinfolist )
game_model.put( )
self.update_cache_game_model( game_code,
game_model )
break
has_prev = False
if page_num > 1:
has_prev = True
if self.format == 'html':
self.render( "gamepage.html", user=user, game=game_model.game,
game_code=game_code, d=d, categories=categories,
user_has_run=user_has_run, has_prev=has_prev,
has_next=gamepage['has_next'], page_num=page_num )
elif self.format == 'json':
if d is None:
self.render_json( categories )
else:
self.render_json( d )
except DeadlineExceededError, msg:
logging.error( msg )
self.error( 403 )
self.render( "deadline_exceeded.html", user=user )
def get(self, username_code):
user = self.get_user()
q = self.request.get('q', default_value=None)
# Make sure the runner exists
runner = self.get_runner(username_code)
if runner is None:
self.error(404)
self.render("404.html", user=user)
return
username = runner.username
gravatar = util.get_gravatar_url(runner.gravatar, size=120)
if q == 'view-all':
# List all runs for this runner
runlist = self.get_runlist_for_runner(username)
if self.format == 'html':
self.render("listruns.html",
user=user,
runner=runner,
username_code=username_code,
runlist=runlist,
gravatar=gravatar)
elif self.format == 'json':
self.render_json(runlist)
else:
# By default, list pbs for this runner
pblist = self.get_pblist(username)
# We are also going to list the best known times for each game.
# Let's gather those times here and add them to the pblist info.
for pb in pblist:
game_model = self.get_game_model(pb['game_code'])
if game_model is None:
logging.error("No game_model for game " + pb['game'])
continue
gameinfolist = json.loads(game_model.info)
for runinfo in pb['infolist']:
# Find the matching gameinfo
for gameinfo in gameinfolist:
if gameinfo['category'] == runinfo['category']:
runinfo['bk_runner'] = gameinfo.get('bk_runner')
runinfo['bk_time'] = util.seconds_to_timestr(
gameinfo.get('bk_seconds'))
runinfo['bk_video'] = gameinfo.get('bk_video')
break
if runner.visible_columns:
visible_columns = json.loads(runner.visible_columns)
else:
visible_columns = util.get_default_visible_columns()
if self.format == 'html':
self.render("runnerpage.html",
user=user,
runner=runner,
username_code=username_code,
pblist=pblist,
gravatar=gravatar,
visible_columns=visible_columns)
elif self.format == 'json':
self.render_json(pblist)
def post( self ):
user = self.get_user( )
if user == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html" )
return
username = self.request.get( 'username' )
password = self.request.get( 'password' )
verify = self.request.get( 'verify' )
twitter = self.request.get( 'twitter' )
if twitter[ 0:1 ] == '@':
twitter = twitter[ 1: ]
youtube = self.request.get( 'youtube' )
youtube = youtube.split( '/' )[ -1 ]
twitch = self.request.get( 'twitch' )
twitch = twitch.split( '/' )[ -1 ]
hitbox = self.request.get( 'hitbox' )
hitbox = hitbox.split( '/' )[ -1 ]
timezone = self.request.get( 'timezone' )
gravatar = self.request.get( 'gravatar' )
if user is not None:
username_code = util.get_code( user.username )
else:
username_code = util.get_code( username )
return_url = self.request.get( 'from' )
if not return_url:
return_url = "/"
elif user is not None and user.is_mod:
# Mod is editing a user's profile, possibly his or her own
username_code = return_url.split( '/' )[ -1 ]
user = self.get_runner( username_code )
if user == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html" )
return
params = dict( user = user,
username = username,
password = password,
verify = verify,
twitter = twitter,
youtube = youtube,
twitch = twitch,
hitbox = hitbox,
gravatar = gravatar,
timezone = timezone,
return_url = return_url )
valid = True
if user is None and not valid_username( username ):
params['user_error'] = ( "Username must be between "
+ "1 and 20 alphanumeric, dash, or "
+ "underscore characters." )
valid = False
elif user is None:
# Check if username already exists
runner = self.get_runner( username_code )
if runner == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
if runner is not None:
params['user_error'] = "That user already exists."
valid = False
if not valid_password( password ):
if user is None or len( password ) > 0:
params['pass_error'] = ( "Password must be between "
+ "3 and 20 characters." )
valid = False
if password != verify:
params['ver_error'] = "Passwords do not match."
valid = False
if gravatar != "" and not valid_email( gravatar ):
if( user is None or not user.gravatar
or gravatar != '<private email>' ):
params['gravatar_error'] = "That's not a valid email."
valid = False
if user is not None and gravatar == '<private email>':
params['gravatar_url'] = util.get_gravatar_url( user.gravatar,
30 )
if timezone != '' and timezone not in pytz.common_timezones:
params['timezone_error'] = "Invalid timezone."
valid = False
if not valid:
self.render( "signup.html", timezones=pytz.common_timezones,
**params )
return
if not user:
# Add a new runner to the database
runner = runners.Runners( username = username,
password = util.make_pw_hash(
username_code, password ),
twitter = twitter,
youtube = youtube,
twitch = twitch,
hitbox = hitbox,
timezone = timezone,
num_pbs = 0,
parent = runners.key(),
key_name = username_code )
if gravatar:
runner.gravatar = hashlib.md5( gravatar.lower( ) ).hexdigest( )
runner.put( )
# Update runner in memcache
self.update_cache_runner( username_code, runner )
# Update runnerlist in memcache. Note that this puts the runner
# at the end of the list, rather than in alphabetical order among
# those runners with 0 pbs. The runner will be sorted properly
# if the memcache gets flushed, which is good enough
runnerlist = self.get_runnerlist( no_refresh=True )
if runnerlist == self.OVER_QUOTA_ERROR:
self.update_cache_runnerlist( None )
elif runnerlist is not None:
runnerlist.append( dict( username = username,
username_code = username_code,
num_pbs = 0,
gravatar_url = util.get_gravatar_url(
runner.gravatar ) ) )
self.update_cache_runnerlist( runnerlist )
# Update runs for runner in memcache
self.update_cache_runlist_for_runner( username, [ ] )
self.login( username_code )
else:
# Editing the current user
if len( password ) > 0:
user.password = util.make_pw_hash( username_code, password )
user.twitter = twitter
user.youtube = youtube
user.twitch = twitch
user.hitbox = hitbox
user.timezone = timezone
if gravatar and gravatar != '<private email>':
user.gravatar = hashlib.md5( gravatar.lower( ) ).hexdigest( )
elif not gravatar:
user.gravatar = None
user.put( )
# Update user in memcache
self.update_cache_runner( username_code, user )
# Update runnerlist in memcache if gravatar updated
if gravatar != '<private email>':
runnerlist = self.get_runnerlist( no_refresh=True )
if runnerlist == self.OVER_QUOTA_ERROR:
self.update_cache_runnerlist( None )
elif runnerlist is not None:
for runnerdict in runnerlist:
if runnerdict['username'] == user.username:
runnerdict['gravatar_url'] = util.get_gravatar_url(
user.gravatar )
break
self.update_cache_runnerlist( runnerlist )
self.redirect( return_url )
def post(self):
user = self.get_user()
if user == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html")
return
username = self.request.get('username')
password = self.request.get('password')
verify = self.request.get('verify')
twitter = self.request.get('twitter')
if twitter[0:1] == '@':
twitter = twitter[1:]
youtube = self.request.get('youtube')
youtube = youtube.split('/')[-1]
twitch = self.request.get('twitch')
twitch = twitch.split('/')[-1]
hitbox = self.request.get('hitbox')
hitbox = hitbox.split('/')[-1]
timezone = self.request.get('timezone')
gravatar = self.request.get('gravatar')
if user is not None:
username_code = util.get_code(user.username)
else:
username_code = util.get_code(username)
return_url = self.request.get('from')
if not return_url:
return_url = "/"
elif user is not None and user.is_mod:
# Mod is editing a user's profile, possibly his or her own
username_code = return_url.split('/')[-1]
user = self.get_runner(username_code)
if user == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html")
return
params = dict(user=user,
username=username,
password=password,
verify=verify,
twitter=twitter,
youtube=youtube,
twitch=twitch,
hitbox=hitbox,
gravatar=gravatar,
timezone=timezone,
return_url=return_url)
valid = True
if user is None and not valid_username(username):
params['user_error'] = ("Username must be between " +
"1 and 20 alphanumeric, dash, or " +
"underscore characters.")
valid = False
elif user is None:
# Check if username already exists
runner = self.get_runner(username_code)
if runner == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html", user=user)
return
if runner is not None:
params['user_error'] = "That user already exists."
valid = False
if not valid_password(password):
if user is None or len(password) > 0:
params['pass_error'] = ("Password must be between " +
"3 and 20 characters.")
valid = False
if password != verify:
params['ver_error'] = "Passwords do not match."
valid = False
if gravatar != "" and not valid_email(gravatar):
if (user is None or not user.gravatar
or gravatar != '<private email>'):
params['gravatar_error'] = "That's not a valid email."
valid = False
if user is not None and gravatar == '<private email>':
params['gravatar_url'] = util.get_gravatar_url(user.gravatar, 30)
if timezone != '' and timezone not in pytz.common_timezones:
params['timezone_error'] = "Invalid timezone."
valid = False
if not valid:
self.render("signup.html",
timezones=pytz.common_timezones,
**params)
return
if not user:
# Add a new runner to the database
runner = runners.Runners(username=username,
password=util.make_pw_hash(
username_code, password),
twitter=twitter,
youtube=youtube,
twitch=twitch,
hitbox=hitbox,
timezone=timezone,
num_pbs=0,
parent=runners.key(),
key_name=username_code)
if gravatar:
runner.gravatar = hashlib.md5(gravatar.lower()).hexdigest()
runner.put()
# Update runner in memcache
self.update_cache_runner(username_code, runner)
# Update runnerlist in memcache. Note that this puts the runner
# at the end of the list, rather than in alphabetical order among
# those runners with 0 pbs. The runner will be sorted properly
# if the memcache gets flushed, which is good enough
runnerlist = self.get_runnerlist(no_refresh=True)
if runnerlist == self.OVER_QUOTA_ERROR:
self.update_cache_runnerlist(None)
elif runnerlist is not None:
runnerlist.append(
dict(username=username,
username_code=username_code,
num_pbs=0,
gravatar_url=util.get_gravatar_url(runner.gravatar)))
self.update_cache_runnerlist(runnerlist)
# Update runs for runner in memcache
self.update_cache_runlist_for_runner(username, [])
self.login(username_code)
else:
# Editing the current user
if len(password) > 0:
user.password = util.make_pw_hash(username_code, password)
user.twitter = twitter
user.youtube = youtube
user.twitch = twitch
user.hitbox = hitbox
user.timezone = timezone
if gravatar and gravatar != '<private email>':
user.gravatar = hashlib.md5(gravatar.lower()).hexdigest()
elif not gravatar:
user.gravatar = None
user.put()
# Update user in memcache
self.update_cache_runner(username_code, user)
# Update runnerlist in memcache if gravatar updated
if gravatar != '<private email>':
runnerlist = self.get_runnerlist(no_refresh=True)
if runnerlist == self.OVER_QUOTA_ERROR:
self.update_cache_runnerlist(None)
elif runnerlist is not None:
for runnerdict in runnerlist:
if runnerdict['username'] == user.username:
runnerdict['gravatar_url'] = util.get_gravatar_url(
user.gravatar)
break
self.update_cache_runnerlist(runnerlist)
self.redirect(return_url)
def get( self, username_code ):
try:
user = self.get_user( )
if user == self.OVER_QUOTA_ERROR:
user = None
q = self.request.get( 'q', default_value=None )
t = self.request.get( 't', default_value=None )
show_all = False
page_num = 1
if t == 'show-all':
show_all = True
else:
# Grab the page num
page_num = self.request.get( 'page', default_value=1 )
try:
page_num = int( page_num )
except ValueError:
page_num = 1
# Make sure the runner exists
runner = self.get_runner( username_code )
if runner is None:
self.error( 404 )
self.render( "404.html", user=user )
return
if runner == self.OVER_QUOTA_ERROR:
self.error( 403 )
if self.format == 'html':
self.render( "403.html", user=user )
return
username = runner.username
gravatar = util.get_gravatar_url( runner.gravatar, size=120 )
if q == 'view-all':
# List all runs for this runner
res = self.get_runlist_for_runner( username, page_num )
if res == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
elif self.format == 'html':
self.render( "listruns.html", user=user, runner=runner,
username_code=username_code,
runlist=res['runlist'],
page_num=res['page_num'],
has_next=res['has_next'],
has_prev=(res['page_num'] > 1),
gravatar=gravatar )
elif self.format == 'json':
self.render_json( res['runlist'] )
else:
# By default, list pbs for this runner
res = self.get_pblist( username, page_num, show_all )
if res == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
# We are also going to list the best known times for each game.
# Let's gather those times here and add them to the pblist
# info.
pblist = res['pblist']
for pb in pblist:
game_model = self.get_game_model( pb['game_code'] )
if game_model is None:
logging.error( "No game_model for game " + pb['game'] )
continue
if game_model == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
gameinfolist = json.loads( game_model.info )
for runinfo in pb['infolist']:
# Find the matching gameinfo
for gameinfo in gameinfolist:
if gameinfo['category'] == runinfo['category']:
runinfo['bk_runner'] = gameinfo.get(
'bk_runner' )
runinfo['bk_time'] = util.seconds_to_timestr(
gameinfo.get( 'bk_seconds' ) )
runinfo['bk_video'] = gameinfo.get(
'bk_video' )
break
if runner.visible_columns:
visible_columns = json.loads( runner.visible_columns )
else:
visible_columns = util.get_default_visible_columns( )
if self.format == 'html':
self.render( "runnerpage.html", user=user, runner=runner,
username_code=username_code, pblist=pblist,
gravatar=gravatar, page_num=res['page_num'],
has_next=res['has_next'],
has_prev=( res['page_num'] > 1 ),
visible_columns=visible_columns,
show_all=res['show_all'] )
elif self.format == 'json':
self.render_json( pblist )
except DeadlineExceededError, msg:
logging.error( msg )
self.error( 403 )
self.render( "deadline_exceeded.html", user=user )
def get( self, game_code ):
try:
user = self.get_user( )
if user == self.OVER_QUOTA_ERROR:
user = None
# Have to take the code of the game code because of percent
# encoded plusses
game_code = util.get_code( game_code )
# Make sure this game exists
game_model = self.get_game_model( game_code )
if not game_model:
self.error( 404 )
self.render( "404.html", user=user )
return
if game_model == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
# Find out if this user has run this game
if user is not None:
user_has_run = self.get_user_has_run( user.username,
game_model.game )
if user_has_run == self.OVER_QUOTA_ERROR:
user_has_run = False
else:
user_has_run = False
gamepage = self.get_gamepage( game_model.game )
if gamepage == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html", user=user )
return
# Add gravatar images to the gamepage
for d in gamepage:
for run in d['infolist']:
runner = self.get_runner( util.get_code(
run['username'] ) )
if runner == self.OVER_QUOTA_ERROR:
self.error( 403 )
if self.format == 'html':
self.render( "403.html", user=user )
return
if runner is not None:
run['gravatar_url'] = util.get_gravatar_url(
runner.gravatar, size=20 )
if self.format == 'html':
self.render( "gamepage.html", user=user, game=game_model.game,
game_code=game_code, gamepage=gamepage,
user_has_run=user_has_run )
elif self.format == 'json':
self.render_json( gamepage )
except DeadlineExceededError, msg:
logging.error( msg )
self.error( 403 )
self.render( "deadline_exceeded.html", user=user )
def get(self, game_code):
try:
user = self.get_user()
if user == self.OVER_QUOTA_ERROR:
user = None
# Have to take the code of the game code because of percent
# encoded plusses
game_code = util.get_code(game_code)
# Make sure this game exists
game_model = self.get_game_model(game_code)
if not game_model:
self.error(404)
self.render("404.html", user=user)
return
if game_model == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html", user=user)
return
# Find out if this user has run this game
if user is not None:
user_has_run = self.get_user_has_run(user.username,
game_model.game)
if user_has_run == self.OVER_QUOTA_ERROR:
user_has_run = False
else:
user_has_run = False
gamepage = self.get_gamepage(game_model.game)
if gamepage == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html", user=user)
return
# Add gravatar images to the gamepage
for d in gamepage:
for run in d['infolist']:
runner = self.get_runner(util.get_code(run['username']))
if runner == self.OVER_QUOTA_ERROR:
self.error(403)
if self.format == 'html':
self.render("403.html", user=user)
return
if runner is not None:
run['gravatar_url'] = util.get_gravatar_url(
runner.gravatar, size=20)
if self.format == 'html':
self.render("gamepage.html",
user=user,
game=game_model.game,
game_code=game_code,
gamepage=gamepage,
user_has_run=user_has_run)
elif self.format == 'json':
self.render_json(gamepage)
except DeadlineExceededError, msg:
logging.error(msg)
self.error(403)
self.render("deadline_exceeded.html", user=user)
