def get_gamelist(self, no_refresh=False):
key = self.get_gamelist_memkey()
gamelist = memcache.get(key)
if gamelist is None and not no_refresh:
# Build the gamelist, which is a list of dictionaries where each
# dict gives the game, game_code and number of pbs for that game.
# The list is sorted by numbers of pbs for the game
gamelist = []
q = db.Query(games.Games, projection=('game', 'num_pbs'))
q.ancestor(games.key())
q.order('-num_pbs')
q.order('game')
for game_model in q.run(limit=10000):
if game_model.num_pbs <= 0:
break
gamelist.append(
dict(game=game_model.game,
game_code=util.get_code(game_model.game),
num_pbs=game_model.num_pbs))
if memcache.set(key, gamelist):
logging.debug("Set gamelist in memcache")
else:
logging.warning("Failed to set new gamelist in memcache")
elif gamelist is not None:
logging.debug("Got gamelist from memcache")
return gamelist
def get_gamelist( self, no_refresh=False, get_num_pbs=True ):
key = self.get_gamelist_memkey( get_num_pbs )
gamelist = memcache.get( key )
if gamelist is None and not no_refresh:
# Build the gamelist, which is a list of dictionaries where each
# dict gives the game, game_code and number of pbs for that game.
# The list is sorted by numbers of pbs for the game
gamelist = [ ]
projection = [ 'game' ]
if get_num_pbs:
projection.append( 'num_pbs' )
try:
q = db.Query( games.Games, projection=projection )
q.ancestor( games.key() )
if get_num_pbs:
q.order( '-num_pbs' )
q.order( 'game' )
for game_model in q.run( limit=10000 ):
if get_num_pbs and game_model.num_pbs <= 0:
break
if get_num_pbs:
d = dict( game = game_model.game,
game_code = util.get_code( game_model.game ),
num_pbs = game_model.num_pbs )
gamelist.append( d )
else:
gamelist.append( str( game_model.game ) )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return self.OVER_QUOTA_ERROR
if memcache.set( key, gamelist ):
logging.debug( "Set " + key + " in memcache" )
else:
logging.warning( "Failed to set new " + key + " in memcache" )
def get_gamelist(self, no_refresh=False):
key = self.get_gamelist_memkey()
gamelist = memcache.get(key)
if gamelist is None and not no_refresh:
# Build the gamelist, which is a list of dictionaries where each
# dict gives the game, game_code and number of pbs for that game.
# The list is sorted by numbers of pbs for the game
gamelist = []
q = db.Query(games.Games, projection=("game", "num_pbs"))
q.ancestor(games.key())
q.order("-num_pbs")
q.order("game")
for game_model in q.run(limit=10000):
if game_model.num_pbs <= 0:
break
gamelist.append(
dict(game=game_model.game, game_code=util.get_code(game_model.game), num_pbs=game_model.num_pbs)
)
if memcache.set(key, gamelist):
logging.debug("Set gamelist in memcache")
else:
logging.warning("Failed to set new gamelist in memcache")
elif gamelist is not None:
logging.debug("Got gamelist from memcache")
return gamelist
def get_gamelist( self, page_num ):
key = self.get_gamelist_memkey( )
data = memcache.get( key )
if data is None:
data = dict( )
res = data.get( page_num )
if res is None:
# Build the gamelist, which is a list of dictionaries where each
# dict gives the game, game_code and number of pbs for that game.
# The list is sorted by numbers of pbs for the game
res = dict( page_num=page_num )
gamelist = [ ]
projection = [ 'game', 'num_pbs' ]
try:
q = db.Query( games.Games, projection=projection )
q.ancestor( games.key() )
q.order( '-num_pbs' )
q.order( 'game' )
c = memcache.get( self.get_gamelist_cursor_memkey( page_num ) )
if c:
try:
q.with_cursor( start_cursor=c )
except BadRequestError:
res['page_num'] = 1
else:
# Send the user back to the first page
res['page_num'] = 1
for game_model in q.run( limit=self.PAGE_LIMIT ):
if game_model.num_pbs <= 0:
break
d = dict( game = game_model.game,
game_code = util.get_code( game_model.game ),
num_pbs = game_model.num_pbs )
gamelist.append( d )
c = q.cursor( )
cursor_key = self.get_gamelist_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( gamelist ) >= self.PAGE_LIMIT:
res['has_next'] = True
else:
res['has_next'] = False
res['gamelist'] = gamelist
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 put_new_game(self, game):
# Add a new game to the database
try:
game_model = games.Games(game=game, info=json.dumps([]), parent=games.key(), key_name=util.get_code(game))
except db.BadValueError:
return False
game_model.put()
logging.warning("Put new game " + game + " in database.")
return True
def get_game_model(self, game_code):
if not game_code:
return None
key = self.get_game_model_memkey(game_code)
game_model = memcache.get(key)
if game_model is None:
# Not in memcache, so get the game from datastore
game_model = games.Games.get_by_key_name(game_code, parent=games.key())
if memcache.set(key, game_model):
logging.debug("Set game_model in memcache for game_code " + game_code)
else:
logging.warning("Failed to set game_model for game_code " + game_code + " in memcache")
else:
logging.debug("Got game_model for game_code " + game_code + " from memcache")
return game_model
def put_new_game(self, game):
# Add a new game to the database
try:
game_model = games.Games(game=game,
info=json.dumps([]),
parent=games.key(),
key_name=util.get_code(game))
except db.BadValueError:
return False
game_model.put()
logging.warning("Put new game " + game + " in database.")
# Update memcache
self.update_gamelist_snp_put(game)
return True
def get_game_model( self, game_code ):
if not game_code:
return None
key = self.get_game_model_memkey( game_code )
game_model = memcache.get( key )
if game_model is None:
# Not in memcache, so get the game from datastore
try:
game_model = games.Games.get_by_key_name( game_code,
parent=games.key() )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return self.OVER_QUOTA_ERROR
if memcache.set( key, game_model ):
logging.debug( "Set game_model in memcache for game_code "
+ game_code )
else:
logging.warning( "Failed to set game_model for game_code "
+ game_code + " in memcache" )
def get_game_model(self, game_code):
if not game_code:
return None
key = self.get_game_model_memkey(game_code)
game_model = memcache.get(key)
if game_model is None:
# Not in memcache, so get the game from datastore
game_model = games.Games.get_by_key_name(game_code,
parent=games.key())
if memcache.set(key, game_model):
logging.debug("Set game_model in memcache for game_code " +
game_code)
else:
logging.warning("Failed to set game_model for game_code " +
game_code + " in memcache")
else:
logging.debug("Got game_model for game_code " + game_code +
" from memcache")
return game_model
def get_game_model(self, game_code):
if not game_code:
return None
key = self.get_game_model_memkey(game_code)
game_model = memcache.get(key)
if game_model is None:
# Not in memcache, so get the game from datastore
try:
game_model = games.Games.get_by_key_name(game_code,
parent=games.key())
except apiproxy_errors.OverQuotaError, msg:
logging.error(msg)
return self.OVER_QUOTA_ERROR
if memcache.set(key, game_model):
logging.debug("Set game_model in memcache for game_code " +
game_code)
else:
logging.warning("Failed to set game_model for game_code " +
game_code + " in memcache")
def get_categories(self, no_refresh=False):
key = self.get_categories_memkey()
categories = memcache.get(key)
if categories is None and not no_refresh:
# Not in memcache, so get the categories for every game
categories = dict()
q = db.Query(games.Games)
q.ancestor(games.key())
for game_model in q.run(limit=10000):
gameinfolist = json.loads(game_model.info)
categories[str(game_model.game)] = []
for gameinfo in gameinfolist:
categories[str(game_model.game)].append(str(gameinfo["category"]))
# Sort the categories for each game in alphabetical order
categories[str(game_model.game)].sort()
if memcache.set(key, categories):
logging.debug("Set " + key + " in memcache")
else:
logging.warning("Failed to set " + key + " in memcache")
elif categories is not None:
logging.debug("Got " + key + " from memcache")
return categories
def get_categories(self, no_refresh=False):
key = self.get_categories_memkey()
categories = memcache.get(key)
if categories is None and not no_refresh:
# Not in memcache, so get the categories for every game
categories = dict()
q = db.Query(games.Games)
q.ancestor(games.key())
for game_model in q.run(limit=10000):
gameinfolist = json.loads(game_model.info)
categories[str(game_model.game)] = []
for gameinfo in gameinfolist:
categories[str(game_model.game)].append(
str(gameinfo['category']))
# Sort the categories for each game in alphabetical order
categories[str(game_model.game)].sort()
if memcache.set(key, categories):
logging.debug("Set " + key + " in memcache")
else:
logging.warning("Failed to set " + key + " in memcache")
elif categories is not None:
logging.debug("Got " + key + " from memcache")
return categories
def get_categories( self, no_refresh=False ):
key = self.get_categories_memkey( )
categories = memcache.get( key )
if categories is None and not no_refresh:
# Not in memcache, so get the categories for every game
categories = dict( )
try:
q = db.Query( games.Games )
q.ancestor( games.key() )
for game_model in q.run( limit=10000 ):
gameinfolist = json.loads( game_model.info )
categories[ str( game_model.game ) ] = [ ]
for gameinfo in gameinfolist:
categories[ str( game_model.game ) ].append(
str( gameinfo['category'] ) )
# Sort the categories for each game in alphabetical order
categories[ str( game_model.game ) ].sort( )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return self.OVER_QUOTA_ERROR
if memcache.set( key, categories ):
logging.debug( "Set " + key + " in memcache" )
else:
logging.warning( "Failed to set " + key + " in memcache" )
def get_categories(self, no_refresh=False):
key = self.get_categories_memkey()
categories = memcache.get(key)
if categories is None and not no_refresh:
# Not in memcache, so get the categories for every game
categories = dict()
try:
q = db.Query(games.Games)
q.ancestor(games.key())
for game_model in q.run(limit=10000):
gameinfolist = json.loads(game_model.info)
categories[str(game_model.game)] = []
for gameinfo in gameinfolist:
categories[str(game_model.game)].append(
str(gameinfo['category']))
# Sort the categories for each game in alphabetical order
categories[str(game_model.game)].sort()
except apiproxy_errors.OverQuotaError, msg:
logging.error(msg)
return self.OVER_QUOTA_ERROR
if memcache.set(key, categories):
logging.debug("Set " + key + " in memcache")
else:
logging.warning("Failed to set " + key + " in memcache")
def update_games_put(self, params, delta_num_pbs):
user = params['user']
game_model = params['game_model']
game = params['game']
category = params['category']
game_code = params['game_code']
category_found = params['category_found']
seconds = params['seconds']
datestr = params['datestr']
video = params['video']
is_bkt = params['is_bkt']
if game_model is None:
# Add a new game to the database
d = dict(category=category,
bk_runner=None,
bk_seconds=None,
bk_datestr=None,
bk_video=None,
bk_updater=None)
if is_bkt:
d['bk_runner'] = user.username
d['bk_seconds'] = seconds
d['bk_datestr'] = datestr
d['bk_video'] = video
d['bk_updater'] = user.username
game_model = games.Games(game=game,
info=json.dumps([d]),
num_pbs=1,
parent=games.key(),
key_name=game_code)
game_model.put()
logging.warning("Put new game " + game + " with " + " category " +
category + " in database.")
# Update memcache
self.update_cache_game_model(game_code, game_model)
categories = self.get_categories(no_refresh=True)
if categories is not None and categories != self.OVER_QUOTA_ERROR:
categories[str(game)] = [str(category)]
self.update_cache_categories(categories)
return
game_model.num_pbs += delta_num_pbs
if not category_found:
# Add a new category for this game in the database
info = json.loads(game_model.info)
d = dict(category=category,
bk_runner=None,
bk_seconds=None,
bk_video=None)
if is_bkt:
d['bk_runner'] = user.username
d['bk_seconds'] = seconds
d['bk_datestr'] = datestr
d['bk_video'] = video
d['bk_updater'] = user.username
info.append(d)
game_model.info = json.dumps(info)
game_model.put()
logging.debug("Added category " + category + " to game " + game +
" in database.")
# Update memcache
self.update_cache_game_model(game_code, game_model)
categories = self.get_categories(no_refresh=True)
if categories is not None and categories != self.OVER_QUOTA_ERROR:
categories[str(game)].append(str(category))
categories[str(game)].sort()
self.update_cache_categories(categories)
return
if is_bkt:
# Update the best known time for this game, category
gameinfolist = json.loads(game_model.info)
for gameinfo in gameinfolist:
if gameinfo['category'] == category:
gameinfo['bk_runner'] = user.username
gameinfo['bk_seconds'] = seconds
gameinfo['bk_datestr'] = datestr
gameinfo['bk_video'] = video
gameinfo['bk_updater'] = user.username
game_model.info = json.dumps(gameinfolist)
logging.debug("Updated best known time for game " + game +
", category " + category + " in database")
break
if is_bkt or delta_num_pbs != 0:
# We made some changes, so store in db and update memcache
game_model.put()
self.update_cache_game_model(game_code, game_model)
def change_categories( self, params ):
res = ''
# Grab the old game model
old_game_code = util.get_code( params['old_game'] )
if old_game_code == params['new_game_code']:
old_game_model = params['new_game_model']
else:
old_game_model = self.get_game_model( old_game_code )
if old_game_model is None:
return "Did not find game [" + params['old_game'] + "]"
if params['new_game_model'] is None:
# New game does not exist, so create it
params['new_game_model'] = games.Games(
game = params['new_game'],
info = json.dumps( [ ] ),
num_pbs = 0,
parent = games.key( ),
key_name = params['new_game_code'] )
res += ( 'Created new game model for game [' + params['new_game']
+ ']<br>' )
if not params['new_category_found']:
# Add the new category to the new game model
gameinfolist = json.loads( params['new_game_model'].info )
d = dict( category=params['new_category'],
bk_runner=None,
bk_seconds=None,
bk_video=None,
bk_datestr=None,
bk_updater=None )
gameinfolist.append( d )
params['new_game_model'].info = json.dumps( gameinfolist )
res += 'Added new category [' + params['new_category'] + ']<br>'
# Grab the gameinfo for the old game
oldgameinfolist = json.loads( old_game_model.info )
oldgameinfo = None
for g in oldgameinfolist:
if( util.get_code( params['old_category'] ) == util.get_code(
g['category'] ) ):
oldgameinfo = g
break
if oldgameinfo is None:
return "Did not find old category [" + params['old_category'] + ']'
# Grab the gameinfo for the new game
newgameinfolist = json.loads( params['new_game_model'].info )
newgameinfo = None
for g in newgameinfolist:
if( util.get_code( params['new_category'] ) == util.get_code(
g['category'] ) ):
newgameinfo = g
break
if newgameinfo is None:
return "Did not find new category [" + params['new_category'] + ']'
# Update best known time if necessary
if( oldgameinfo.get( 'bk_seconds' ) is not None
and ( newgameinfo.get( 'bk_seconds' ) is None
or oldgameinfo.get( 'bk_seconds' )
< newgameinfo.get( 'bk_seconds' ) ) ):
newgameinfo['bk_seconds'] = oldgameinfo.get( 'bk_seconds' )
newgameinfo['bk_runner'] = oldgameinfo.get( 'bk_runner' )
newgameinfo['bk_datestr'] = oldgameinfo.get( 'bk_datestr' )
newgameinfo['bk_video'] = oldgameinfo.get( 'bk_video' )
newgameinfo['bk_updater'] = oldgameinfo.get( 'bk_updater' )
params['new_game_model'].info = json.dumps( newgameinfolist )
res += 'Updated bkt<br>'
# Update num_pbs for old game, new game
res += ( 'Previous num_pbs for old game, category = '
+ str( old_game_model.num_pbs ) + '<br>' )
res += ( 'Previous num_pbs for new game, category = '
+ str( params['new_game_model'].num_pbs ) + '<br>' )
q = db.Query( runs.Runs, projection=['username'], distinct=True )
q.ancestor( runs.key() )
q.filter( 'game =', params['old_game'] )
q.filter( 'category =', params['old_category'] )
for run in q.run( limit=1000 ):
old_game_model.num_pbs -= 1
q2 = db.Query( runs.Runs )
q2.ancestor( runs.key() )
q2.filter( 'game =', params['new_game'] )
q2.filter( 'category =', params['new_category'] )
q2.filter( 'username ='******'new_game_model'].num_pbs += 1
else:
# Need to decrement runner's num_pbs
runner = self.get_runner( util.get_code( run.username ) )
runner.num_pbs -= 1
runner.put( )
res += ( "Updated " + run.username + " num_pbs from "
+ str( runner.num_pbs + 1 ) + " to "
+ str( runner.num_pbs ) + "<br>" )
res += ( 'Updated num_pbs for old game, category = '
+ str( old_game_model.num_pbs ) + '<br>' )
res += ( 'Updated num_pbs for new game, category = '
+ str( params['new_game_model'].num_pbs ) + '<br>' )
# Update old, new game models in database
old_game_model.put( )
if old_game_code != params['new_game_code']:
params['new_game_model'].put( )
# Change the runs
res += "<br>Changed runs:<br>"
q = db.Query( runs.Runs )
q.ancestor( runs.key() )
q.filter( 'game =', params['old_game'] )
q.filter( 'category =', params['old_category'] )
for run in q.run( limit = 10000 ):
# Update the run
run.game = params['new_game']
run.category = params['new_category']
run.put( )
res += ( 'Runner=' + run.username + ' time='
+ util.seconds_to_timestr( run.seconds ) + '<br>' )
if not memcache.flush_all( ):
res += "Failed to flush memcache<br>"
# All dun
return res
def change_categories( self, params ):
res = ''
# Grab the old game model
old_game_code = util.get_code( params['old_game'] )
if old_game_code == params['new_game_code']:
old_game_model = params['new_game_model']
else:
old_game_model = self.get_game_model( old_game_code )
if old_game_model == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html" )
return
if old_game_model is None:
return "Did not find game [" + params['old_game'] + "]"
if params['new_game_model'] is None:
# New game does not exist, so create it
params['new_game_model'] = games.Games(
game = params['new_game'],
info = json.dumps( [ ] ),
num_pbs = 0,
parent = games.key( ),
key_name = params['new_game_code'] )
res += ( 'Created new game model for game [' + params['new_game']
+ ']<br>' )
if not params['new_category_found']:
# Add the new category to the new game model
gameinfolist = json.loads( params['new_game_model'].info )
d = dict( category=params['new_category'],
bk_runner=None,
bk_seconds=None,
bk_video=None,
bk_datestr=None,
bk_updater=None )
gameinfolist.append( d )
params['new_game_model'].info = json.dumps( gameinfolist )
res += 'Added new category [' + params['new_category'] + ']<br>'
# Grab the gameinfo for the old game
oldgameinfolist = json.loads( old_game_model.info )
oldgameinfo = None
for g in oldgameinfolist:
if( util.get_code( params['old_category'] ) == util.get_code(
g['category'] ) ):
oldgameinfo = g
break
if oldgameinfo is None:
return "Did not find old category [" + params['old_category'] + ']'
# Grab the gameinfo for the new game
newgameinfolist = json.loads( params['new_game_model'].info )
newgameinfo = None
for g in newgameinfolist:
if( util.get_code( params['new_category'] ) == util.get_code(
g['category'] ) ):
newgameinfo = g
break
if newgameinfo is None:
return "Did not find new category [" + params['new_category'] + ']'
# Update best known time if necessary
if( oldgameinfo.get( 'bk_seconds' ) is not None
and ( newgameinfo.get( 'bk_seconds' ) is None
or oldgameinfo.get( 'bk_seconds' )
< newgameinfo.get( 'bk_seconds' ) ) ):
newgameinfo['bk_seconds'] = oldgameinfo.get( 'bk_seconds' )
newgameinfo['bk_runner'] = oldgameinfo.get( 'bk_runner' )
newgameinfo['bk_datestr'] = oldgameinfo.get( 'bk_datestr' )
newgameinfo['bk_video'] = oldgameinfo.get( 'bk_video' )
newgameinfo['bk_updater'] = oldgameinfo.get( 'bk_updater' )
params['new_game_model'].info = json.dumps( newgameinfolist )
res += 'Updated bkt<br>'
if not memcache.flush_all( ):
res += "Failed to flush memcache<br>"
# Update num_pbs for old game, new game
res += ( 'Previous num_pbs for old game, category = '
+ str( old_game_model.num_pbs ) + '<br>' )
res += ( 'Previous num_pbs for new game, category = '
+ str( params['new_game_model'].num_pbs ) + '<br>' )
try:
q = db.Query( runs.Runs, projection=['username'], distinct=True )
q.ancestor( runs.key() )
q.filter( 'game =', params['old_game'] )
q.filter( 'category =', params['old_category'] )
for run in q.run( limit=1000 ):
old_game_model.num_pbs -= 1
q2 = db.Query( runs.Runs )
q2.ancestor( runs.key() )
q2.filter( 'game =', params['new_game'] )
q2.filter( 'category =', params['new_category'] )
q2.filter( 'username ='******'new_game_model'].num_pbs += 1
else:
# Need to decrement runner's num_pbs
runner = self.get_runner( util.get_code( run.username ) )
if runner == self.OVER_QUOTA_ERROR:
return 'Over quota error'
runner.num_pbs -= 1
runner.put( )
res += ( "Updated " + run.username + " num_pbs from "
+ str( runner.num_pbs + 1 ) + " to "
+ str( runner.num_pbs ) + "<br>" )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
return "Ran out of quota"
def get( self ):
QUERY_LIMIT = 1000
cursor_key = 'fixerupper-cursor'
# Make sure it's me
user = self.get_user( )
if not user:
self.error( 404 )
self.render( "404.html", user=user )
return
elif user == self.OVER_QUOTA_ERROR:
self.error( 403 )
self.render( "403.html" )
return
elif user.username != "rggibson":
self.error( 404 )
self.render( "404.html", user=user )
return
c = self.request.get( 'c', default_value=None )
try:
# Add missing games and categories back in + update num_pbs
q = db.Query( runs.Runs, projection=[ 'game', 'category',
'username' ],
distinct=True )
q.ancestor( runs.key( ) )
q.order( 'game' )
if c is None:
c = memcache.get( cursor_key )
if c:
try:
q.with_cursor( start_cursor=c )
logging.info( "Fixer upper using cursor " + c )
except BadRequestErro:
logging.error( "FixerUpper failed to use cursor" )
pass
game_model = None
categories = None
infolist = None
old_num_pbs = None
do_update = None
cursor_to_save = c
prev_cursor = c
num_runs = 0
for run in q.run( limit=QUERY_LIMIT ):
if game_model is None or game_model.game != run.game:
# New game
if game_model is not None:
# Save previous game model
game_model.info = json.dumps( infolist )
if do_update or game_model.num_pbs != old_num_pbs:
game_model.put( )
self.update_cache_game_model( game_code,
game_model )
cursor_to_save = prev_cursor
game_code = util.get_code( run.game )
game_model = self.get_game_model( game_code )
if game_model is None:
# Make a new game model
game_model = games.Games( game=run.game,
info=json.dumps( [ ] ),
num_pbs=0,
parent=games.key(),
key_name=game_code )
logging.info( "Fixerupper put new game " + run.game
+ " in datastore." )
categories = game_model.categories( )
infolist = json.loads( game_model.info )
old_num_pbs = game_model.num_pbs
do_update = False
game_model.num_pbs = 0
game_model.num_pbs += 1
if run.category not in categories:
# Add category
infolist.append( dict( category=run.category,
bk_runner=None,
bk_seconds=None, bk_datestr=None,
bk_video=None, bk_updater=None ) )
logging.info( "Fixerupper added category " + run.category
+ " to " + run.game )
categories.append( run.category )
do_update = True
prev_cursor = q.cursor( )
num_runs += 1
if game_model is not None and num_runs < QUERY_LIMIT:
# Save last game model
game_model.info = json.dumps( infolist )
game_model.put( )
self.update_cache_game_model( game_code, game_model )
cursor_to_save = prev_cursor
if cursor_to_save == memcache.get( cursor_key ):
logging.error( "No games updated by FixerUpper." )
if game_model is not None:
logging.error( "Last game was " + game_model.game )
self.write( "FixerUpper failed to update any games<br>" )
return
if memcache.set( cursor_key, cursor_to_save ):
s = "FixerUpper finished and saved cursor " + cursor_to_save
if game_model is not None:
s += "<br>Last game was " + game_model.game
self.write( s )
else:
self.write( "FixerUpper finished but failed to save cursor "
+ cursor_to_save )
except apiproxy_errors.OverQuotaError, msg:
logging.error( msg )
self.write( "FixerUpper failed with over quota error<br>" )
return
def change_categories(self, params):
res = ''
# Grab the old game model
old_game_code = util.get_code(params['old_game'])
if old_game_code == params['new_game_code']:
old_game_model = params['new_game_model']
else:
old_game_model = self.get_game_model(old_game_code)
if old_game_model == self.OVER_QUOTA_ERROR:
self.error(403)
self.render("403.html")
return
if old_game_model is None:
return "Did not find game [" + params['old_game'] + "]"
if params['new_game_model'] is None:
# New game does not exist, so create it
params['new_game_model'] = games.Games(
game=params['new_game'],
info=json.dumps([]),
num_pbs=0,
parent=games.key(),
key_name=params['new_game_code'])
res += ('Created new game model for game [' + params['new_game'] +
']<br>')
if not params['new_category_found']:
# Add the new category to the new game model
gameinfolist = json.loads(params['new_game_model'].info)
d = dict(category=params['new_category'],
bk_runner=None,
bk_seconds=None,
bk_video=None,
bk_datestr=None,
bk_updater=None)
gameinfolist.append(d)
params['new_game_model'].info = json.dumps(gameinfolist)
res += 'Added new category [' + params['new_category'] + ']<br>'
# Grab the gameinfo for the old game
oldgameinfolist = json.loads(old_game_model.info)
oldgameinfo = None
for g in oldgameinfolist:
if (util.get_code(params['old_category']) == util.get_code(
g['category'])):
oldgameinfo = g
break
if oldgameinfo is None:
return "Did not find old category [" + params['old_category'] + ']'
# Grab the gameinfo for the new game
newgameinfolist = json.loads(params['new_game_model'].info)
newgameinfo = None
for g in newgameinfolist:
if (util.get_code(params['new_category']) == util.get_code(
g['category'])):
newgameinfo = g
break
if newgameinfo is None:
return "Did not find new category [" + params['new_category'] + ']'
# Update best known time if necessary
if (oldgameinfo.get('bk_seconds') is not None and
(newgameinfo.get('bk_seconds') is None or
oldgameinfo.get('bk_seconds') < newgameinfo.get('bk_seconds'))):
newgameinfo['bk_seconds'] = oldgameinfo.get('bk_seconds')
newgameinfo['bk_runner'] = oldgameinfo.get('bk_runner')
newgameinfo['bk_datestr'] = oldgameinfo.get('bk_datestr')
newgameinfo['bk_video'] = oldgameinfo.get('bk_video')
newgameinfo['bk_updater'] = oldgameinfo.get('bk_updater')
params['new_game_model'].info = json.dumps(newgameinfolist)
res += 'Updated bkt<br>'
if not memcache.flush_all():
res += "Failed to flush memcache<br>"
# Update num_pbs for old game, new game
res += ('Previous num_pbs for old game, category = ' +
str(old_game_model.num_pbs) + '<br>')
res += ('Previous num_pbs for new game, category = ' +
str(params['new_game_model'].num_pbs) + '<br>')
try:
q = db.Query(runs.Runs, projection=['username'], distinct=True)
q.ancestor(runs.key())
q.filter('game =', params['old_game'])
q.filter('category =', params['old_category'])
for run in q.run(limit=1000):
old_game_model.num_pbs -= 1
q2 = db.Query(runs.Runs)
q2.ancestor(runs.key())
q2.filter('game =', params['new_game'])
q2.filter('category =', params['new_category'])
q2.filter('username ='******'new_game_model'].num_pbs += 1
else:
# Need to decrement runner's num_pbs
runner = self.get_runner(util.get_code(run.username))
if runner == self.OVER_QUOTA_ERROR:
return 'Over quota error'
runner.num_pbs -= 1
runner.put()
res += ("Updated " + run.username + " num_pbs from " +
str(runner.num_pbs + 1) + " to " +
str(runner.num_pbs) + "<br>")
except apiproxy_errors.OverQuotaError, msg:
logging.error(msg)
return "Ran out of quota"
def update_games_put( self, params, delta_num_pbs ):
user = params['user']
game_model = params['game_model']
game = params['game']
category = params['category']
game_code = params['game_code']
category_found = params['category_found']
seconds = params['seconds']
datestr = params['datestr']
video = params['video']
is_bkt = params['is_bkt']
if game_model is None:
# Add a new game to the database
d = dict( category=category, bk_runner=None, bk_seconds=None,
bk_datestr=None, bk_video=None, bk_updater=None )
if is_bkt:
d['bk_runner'] = user.username
d['bk_seconds'] = seconds
d['bk_datestr'] = datestr
d['bk_video'] = video
d['bk_updater'] = user.username
game_model = games.Games( game = game,
info = json.dumps( [ d ] ),
num_pbs = 1,
parent = games.key(),
key_name = game_code )
game_model.put( )
logging.warning( "Put new game " + game + " with "
+ " category " + category + " in database." )
# Update memcache
self.update_cache_game_model( game_code, game_model )
categories = self.get_categories( no_refresh=True )
if categories is not None:
categories[ str( game ) ] = [ str( category ) ]
self.update_cache_categories( categories )
return
game_model.num_pbs += delta_num_pbs
if not category_found:
# Add a new category for this game in the database
info = json.loads( game_model.info )
d = dict( category=category, bk_runner=None, bk_seconds=None,
bk_video=None )
if is_bkt:
d['bk_runner'] = user.username
d['bk_seconds'] = seconds
d['bk_datestr'] = datestr
d['bk_video'] = video
d['bk_updater'] = user.username
info.append( d )
game_model.info = json.dumps( info )
game_model.put( )
logging.debug( "Added category " + category + " to game "
+ game + " in database." )
# Update memcache
self.update_cache_game_model( game_code, game_model )
categories = self.get_categories( no_refresh=True )
if categories is not None:
categories[ str( game ) ].append( str( category ) )
categories[ str( game ) ].sort( )
self.update_cache_categories( categories )
return
if is_bkt:
# Update the best known time for this game, category
gameinfolist = json.loads( game_model.info )
for gameinfo in gameinfolist:
if gameinfo['category'] == category:
gameinfo['bk_runner'] = user.username
gameinfo['bk_seconds'] = seconds
gameinfo['bk_datestr'] = datestr
gameinfo['bk_video'] = video
gameinfo['bk_updater'] = user.username
game_model.info = json.dumps( gameinfolist )
logging.debug( "Updated best known time for game "
+ game + ", category " + category
+ " in database" )
break
if is_bkt or delta_num_pbs != 0:
# We made some changes, so store in db and update memcache
game_model.put( )
self.update_cache_game_model( game_code, game_model )
def change_categories(self, params):
res = ""
# Grab the old game model
old_game_code = util.get_code(params["old_game"])
if old_game_code == params["new_game_code"]:
old_game_model = params["new_game_model"]
else:
old_game_model = self.get_game_model(old_game_code)
if old_game_model is None:
return "Did not find game [" + params["old_game"] + "]"
if params["new_game_model"] is None:
# New game does not exist, so create it
params["new_game_model"] = games.Games(
game=params["new_game"],
info=json.dumps([]),
num_pbs=0,
parent=games.key(),
key_name=params["new_game_code"],
)
res += "Created new game model for game [" + params["new_game"] + "]<br>"
if not params["new_category_found"]:
# Add the new category to the new game model
gameinfolist = json.loads(params["new_game_model"].info)
d = dict(
category=params["new_category"],
bk_runner=None,
bk_seconds=None,
bk_video=None,
bk_datestr=None,
bk_updater=None,
)
gameinfolist.append(d)
params["new_game_model"].info = json.dumps(gameinfolist)
res += "Added new category [" + params["new_category"] + "]<br>"
# Grab the gameinfo for the old game
oldgameinfolist = json.loads(old_game_model.info)
oldgameinfo = None
for g in oldgameinfolist:
if util.get_code(params["old_category"]) == util.get_code(g["category"]):
oldgameinfo = g
break
if oldgameinfo is None:
return "Did not find old category [" + params["old_category"] + "]"
# Grab the gameinfo for the new game
newgameinfolist = json.loads(params["new_game_model"].info)
newgameinfo = None
for g in newgameinfolist:
if util.get_code(params["new_category"]) == util.get_code(g["category"]):
newgameinfo = g
break
if newgameinfo is None:
return "Did not find new category [" + params["new_category"] + "]"
# Update best known time if necessary
if oldgameinfo.get("bk_seconds") is not None and (
newgameinfo.get("bk_seconds") is None or oldgameinfo.get("bk_seconds") < newgameinfo.get("bk_seconds")
):
newgameinfo["bk_seconds"] = oldgameinfo.get("bk_seconds")
newgameinfo["bk_runner"] = oldgameinfo.get("bk_runner")
newgameinfo["bk_datestr"] = oldgameinfo.get("bk_datestr")
newgameinfo["bk_video"] = oldgameinfo.get("bk_video")
newgameinfo["bk_updater"] = oldgameinfo.get("bk_updater")
params["new_game_model"].info = json.dumps(newgameinfolist)
res += "Updated bkt<br>"
# Update num_pbs for old game, new game
res += "Previous num_pbs for old game, category = " + str(old_game_model.num_pbs) + "<br>"
res += "Previous num_pbs for new game, category = " + str(params["new_game_model"].num_pbs) + "<br>"
q = db.Query(runs.Runs, projection=["username"], distinct=True)
q.ancestor(runs.key())
q.filter("game =", params["old_game"])
q.filter("category =", params["old_category"])
for run in q.run(limit=1000):
old_game_model.num_pbs -= 1
q2 = db.Query(runs.Runs)
q2.ancestor(runs.key())
q2.filter("game =", params["new_game"])
q2.filter("category =", params["new_category"])
q2.filter("username ="******"new_game_model"].num_pbs += 1
else:
# Need to decrement runner's num_pbs
runner = self.get_runner(util.get_code(run.username))
runner.num_pbs -= 1
runner.put()
res += (
"Updated "
+ run.username
+ " num_pbs from "
+ str(runner.num_pbs + 1)
+ " to "
+ str(runner.num_pbs)
+ "<br>"
)
res += "Updated num_pbs for old game, category = " + str(old_game_model.num_pbs) + "<br>"
res += "Updated num_pbs for new game, category = " + str(params["new_game_model"].num_pbs) + "<br>"
# Update old, new game models in database
old_game_model.put()
if old_game_code != params["new_game_code"]:
params["new_game_model"].put()
# Change the runs
res += "<br>Changed runs:<br>"
q = db.Query(runs.Runs)
q.ancestor(runs.key())
q.filter("game =", params["old_game"])
q.filter("category =", params["old_category"])
for run in q.run(limit=10000):
# Update the run
run.game = params["new_game"]
run.category = params["new_category"]
run.put()
res += "Runner=" + run.username + " time=" + util.seconds_to_timestr(run.seconds) + "<br>"
if not memcache.flush_all():
res += "Failed to flush memcache<br>"
# All dun
return res
