Пример #1
0
 def get_user(self):
     cookie_val = self.request.cookies.get('user_id')
     if cookie_val:
         username_code = util.check_secure_val(cookie_val)
         if username_code:
             return runners.Runners.get_by_key_name(username_code,
                                                    parent=runners.key())
Пример #2
0
    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" )
Пример #3
0
 def get_user( self ):
     cookie_val = self.request.cookies.get( 'user_id' )
     if cookie_val:
         username_code = util.check_secure_val( cookie_val )
         if username_code:
             return runners.Runners.get_by_key_name( username_code, 
                                                     parent=runners.key() )
Пример #4
0
    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")
Пример #5
0
 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
Пример #6
0
 def is_valid_login( self, username, password ):
     username_code = util.get_code( username )
     
     # Find the user in the database
     try:
         user = runners.Runners.get_by_key_name( username_code, 
                                                 parent=runners.key() )
     except apiproxy_errors.OverQuotaError, msg:
         logging.error( msg )
         return False, dict( user_error="Over quota error" )
Пример #7
0
    def is_valid_login(self, username, password):
        username_code = util.get_code(username)

        # Find the user in the database
        try:
            user = runners.Runners.get_by_key_name(username_code,
                                                   parent=runners.key())
        except apiproxy_errors.OverQuotaError, msg:
            logging.error(msg)
            return False, dict(user_error="Over quota error")
Пример #8
0
    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" )
Пример #9
0
 def get_user( self ):
     cookie_val = self.request.cookies.get( 'user_id' )
     if cookie_val:
         username_code = util.check_secure_val( cookie_val )
         if username_code:
             try:
                 user = runners.Runners.get_by_key_name( 
                     username_code, parent=runners.key() )
             except apiproxy_errors.OverQuotaError, msg:
                 logging.error( msg )
                 return self.OVER_QUOTA_ERROR
             return user
Пример #10
0
 def get_user(self):
     cookie_val = self.request.cookies.get('user_id')
     if cookie_val:
         username_code = util.check_secure_val(cookie_val)
         if username_code:
             try:
                 user = runners.Runners.get_by_key_name(
                     username_code, parent=runners.key())
             except apiproxy_errors.OverQuotaError, msg:
                 logging.error(msg)
                 return self.OVER_QUOTA_ERROR
             return user
Пример #11
0
    def is_valid_login(self, username, password):
        username_code = util.get_code(username)

        # Find the user in the database
        user = runners.Runners.get_by_key_name(username_code, parent=runners.key())
        if not user:
            return False, dict(user_error="Username not found")

        # Check for valid password
        if util.valid_pw(username_code, password, user.password):
            return True, dict()
        else:
            return False, dict(pass_error="Invalid password")
Пример #12
0
    def is_valid_login(self, username, password):
        username_code = util.get_code(username)

        # Find the user in the database
        user = runners.Runners.get_by_key_name(username_code,
                                               parent=runners.key())
        if not user:
            return False, dict(user_error="Username not found")

        # Check for valid password
        if util.valid_pw(username_code, password, user.password):
            return True, dict()
        else:
            return False, dict(pass_error="Invalid password")
Пример #13
0
    def get_runner(self, username_code):
        if not username_code:
            return None

        key = self.get_runner_memkey(username_code)
        runner = memcache.get(key)
        if runner is None:
            # Not in memcache, so check the database
            runner = runners.Runners.get_by_key_name(username_code, parent=runners.key())
            if memcache.set(key, runner):
                logging.debug("Set " + key + " in memcache")
            else:
                logging.warning("Failed to set " + key + " in memcache")
        else:
            logging.debug("Got " + key + " from memcache")
        return runner
Пример #14
0
    def get_runner(self, username_code):
        if not username_code:
            return None

        key = self.get_runner_memkey(username_code)
        runner = memcache.get(key)
        if runner is None:
            # Not in memcache, so check the database
            runner = runners.Runners.get_by_key_name(username_code,
                                                     parent=runners.key())
            if memcache.set(key, runner):
                logging.debug("Set " + key + " in memcache")
            else:
                logging.warning("Failed to set " + key + " in memcache")
        else:
            logging.debug("Got " + key + " from memcache")
        return runner
Пример #15
0
    def get_runner( self, username_code ):
        if not username_code:
            return None

        key = self.get_runner_memkey( username_code )
        runner = memcache.get( key )
        if runner is None:
            # Not in memcache, so check the database
            try:
                runner = runners.Runners.get_by_key_name( username_code,
                                                          parent=runners.key() )
            except apiproxy_errors.OverQuotaError, msg:
                logging.error( msg )
                return self.OVER_QUOTA_ERROR
            if memcache.set( key, runner ):
                logging.debug( "Set " + key + " in memcache" )
            else:
                logging.warning( "Failed to set " + key + " in memcache" )
Пример #16
0
    def get_runner(self, username_code):
        if not username_code:
            return None

        key = self.get_runner_memkey(username_code)
        runner = memcache.get(key)
        if runner is None:
            # Not in memcache, so check the database
            try:
                runner = runners.Runners.get_by_key_name(username_code,
                                                         parent=runners.key())
            except apiproxy_errors.OverQuotaError, msg:
                logging.error(msg)
                return self.OVER_QUOTA_ERROR
            if memcache.set(key, runner):
                logging.debug("Set " + key + " in memcache")
            else:
                logging.warning("Failed to set " + key + " in memcache")
Пример #17
0
    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 )
Пример #18
0
    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)