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 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