Python Token.gql方法代码示例

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def fs_request_token_ready(request):
  """
  OAuth dance for Foursquare, callback URL
  """
  CONSUMER_KEY = FS_CONSUMER_KEY
  CONSUMER_SECRET = FS_CONSUMER_SECRET
  token = Token.gql( "WHERE user = :1", str(request.user) ).get()
  request_values = token.fs_request_token.split("&")
  env = os.environ['QUERY_STRING'].split("&")
  for e in env:
      request_values.append(e)
  values = {}
  for rv in request_values:
      (key, value) = rv.split("=")
      values[key] = value
  oauth_token = oauth.OAuthToken.from_string( token.fs_request_token )
  oauth_verifier = values['oauth_verifier']
  request_token_key = oauth_token
  request_token_secret = values['oauth_token_secret']
  credentials = foursquare.OAuthCredentials(CONSUMER_KEY, CONSUMER_SECRET)
  fs = foursquare.Foursquare(credentials)
  user_token = fs.access_token(token=request_token_key, oauth_verifier=oauth_verifier)
  credentials.set_access_token(user_token)
  fs_token = "oauth_token_secret=%s&oauth_token=%s" % (request_token_secret, str(user_token))
  token.fs_token = fs_token
  token.fs_user_token = str(user_token)
  token.put()
  return redirect( "/" )

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def fe_connect(request):
  """
  Do the OAuth dance for Fire Eagle!
  """
  CONSUMER_KEY = FE_CONSUMER_KEY
  CONSUMER_SECRET = FE_CONSUMER_SECRET
  CALLBACK_URL = FE_CALLBACK_URL
  fe = FireEagle( CONSUMER_KEY, CONSUMER_SECRET )
  request_token = fe.request_token( oauth_callback=CALLBACK_URL )
  if ( Token.gql( "WHERE user = :1", str(request.user) ).get() != None ):
      token = Token.gql( "WHERE user = :1", str(request.user) ).get()
  else:
    token = Token()
  token.user = str(request.user)
  token.fe_request_token = str(request_token)
  token.put()
  auth_url = fe.authorize( request_token, oauth_callback=CALLBACK_URL )
  return redirect( auth_url )

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def render_index(request, template):
    """
    Render the single landing page we have in FireCheckIn. Fill in information on the state
    of the connections to Fire Eagle and Foursquare and see if the user is logged in.
    """
    fireeagle_connected = False
    foursquare_connected = False
    if request.user.is_anonymous():
        return render_to_response(template,  { 'fireeagle_connected': fireeagle_connected,
                                                 'foursquare_connected': foursquare_connected})
    else:
        if ( Token.gql( "WHERE user = :1", str(request.user) ).get() != None ):
              token = Token.gql( "WHERE user = :1", str(request.user) ).get()
              if ( token.fe_token ):
                  fireeagle_connected = True
              if ( token.fs_token ):
                  foursquare_connected = True
        return render_to_response(template,  { 'fireeagle_connected': fireeagle_connected,
                                                 'foursquare_connected': foursquare_connected})

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def fs_connect(request):
  """
  OAUTh dance for Foursquare
  """
  CONSUMER_KEY = FS_CONSUMER_KEY
  CONSUMER_SECRET = FS_CONSUMER_SECRET
  CALLBACK_URL = FS_CALLBACK_URL
  credentials = foursquare.OAuthCredentials(CONSUMER_KEY, CONSUMER_SECRET)
  fs = foursquare.Foursquare(credentials)
  request_token = fs.request_token( oauth_callback=CALLBACK_URL )
  if ( Token.gql( "WHERE user = :1", str(request.user) ).get() != None ):
      token = Token.gql( "WHERE user = :1", str(request.user) ).get()
  else:
    token = Token()
  token.user = str(request.user)
  token.fs_request_token = str(request_token)
  token.put()
  auth_url = fs.authorize( request_token, oauth_callback=CALLBACK_URL )
  return redirect( auth_url )

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def deleteme(request):
    """
    Remove the currently logged in user from our database and log them out. 
    Privacy, you know? Don't request this casually :)
    """
    if (not (request.user.is_anonymous())):
        logout = users.create_logout_url( "/" )
        db.delete(Token.gql( "WHERE user = :1", str(request.user) ).get())
        return redirect( logout )
    else:
        return redirect( "/" )

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def syncworker(request):
    """
    Okay, this is the real stuff. It's the worker process for the task queue.
    Gets a user name as a parameter.
    Calls Foursquare, Fire Eagle. Compares times of last check-in. If the Foursquare check-in
    is more recent, updates Fire Eagle.
    We catch all kinds of exceptions, so users with messed up OAuth permissions won't stop
    the worker.
    """
    user = request.args.get('user')
    logging.warning('user is: %s' % str(user))
    t = Token.gql( "WHERE user = :1", str(user) ).get()
    lat = 0
    lon = 0
    try:
        token = oauth.OAuthToken.from_string( t.fe_token )
        fe = FireEagle( FE_CONSUMER_KEY, FE_CONSUMER_SECRET )
        user = fe.user( token )
        date_time = user[0]['location'][0]['located_at']
        """
        For some reasons that only Yahoo! knows, Fire Eagle logs its time and dates
        in local Californian time (including Daylight Saving Time), so we have to
        convert the thing to UTC. Crazy, huh? 
        Share my frustration at http://blog.johl.io/post/393494632/what-time-is-it
        """
        current_datetime = datetime.datetime.now(ustimezones.pacific()) # What time is it in Cali?
        fe_delta = str(current_datetime.replace(tzinfo=None) - date_time)
        credentials = foursquare.OAuthCredentials( FS_CONSUMER_KEY, FS_CONSUMER_SECRET )
        fs = foursquare.Foursquare( credentials )
        token = oauth.OAuthToken.from_string( t.fs_user_token )
        credentials.set_access_token(token)
        history = fs.history()
        date_time = history['checkins'][0]['created']
        lat = history['checkins'][0]['venue']['geolat']
        lon = history['checkins'][0]['venue']['geolong']
        current_datetime = datetime.datetime.now()
        date_time = datetime.datetime.fromtimestamp(time.mktime(rfc822.parsedate(date_time)))
        fs_delta = str(current_datetime.replace(tzinfo=None) - date_time)
    except:
        """
        So yeah, something went wrong. Let's assume we should update Fire Eagle.
        """
        logging.warning('Application error occurred with user %s', str(t.user))
        fs_delta = 0
        fe_delta = -1
    if (fs_delta < fe_delta):
      try:
        fe.update( lat=lat, lon=lon, token=oauth.OAuthToken.from_string( t.fe_token ) )
      except:
        """
        Can't update Fire Eagle. Whatever.
        """
        logging.warning('Application error occurred with user %s', str(t.user))
    return render_to_response('firecheckin/index.html')

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def sync(request):
  """
  It's the cron job that gets run every 2 minutes (or on request). Iterates over users and
  queues tasks to sync. Will only 'iterate' over the current user
  if called by a logged in user.
  """
  tokens = []
  if (request.user.is_anonymous()):
      tokens = Token.all().fetch(1000)
  else:
      tokens.append(Token.gql( "WHERE user = :1", str(request.user) ).get())
  for t in tokens:
      taskqueue.add(url='/syncworker/?user=%s' % str(t.user), method='GET')
  """
  We cannot return a redirect when called anonymously as a cron job.
  Google App Engine will complain about 'Too many continues.'
  """
  if (request.user.is_anonymous()):
      return render_to_response('firecheckin/index.html')
  else:
      return redirect( "/" )

# 需要导入模块: from models import Token [as 别名]
# 或者: from models.Token import gql [as 别名]
def fe_request_token_ready(request):
  """
  OAuth dance for Fire Eagle, callback URL
  """
  query = request.environ['QUERY_STRING']
  query_values = query.split("&")
  values = {}
  for qv in query_values:
      (key, value) = qv.split("=")
      values[key] = value
  oauth_verifier = values['oauth_verifier']
  oauth_token = values['oauth_token']
  CONSUMER_KEY = FE_CONSUMER_KEY
  CONSUMER_SECRET = FE_CONSUMER_SECRET
  fe = FireEagle( CONSUMER_KEY, CONSUMER_SECRET )
  token = Token.gql( "WHERE user = :1", str(request.user) ).get()
  oauth_token = oauth.OAuthToken.from_string( token.fe_request_token )
  fe = FireEagle( CONSUMER_KEY, CONSUMER_SECRET )
  access_token = fe.access_token( oauth_verifier=oauth_verifier, token=oauth_token )
  token.fe_token = str(access_token)
  token.put()
  return redirect( "/" )