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( "/" )
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 )
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})
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 )
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( "/" )
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')
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( "/" )
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( "/" )
