def fromJSONFields(self,fromJSON,auxData=None):
super(LinkedInConnectEvent, self).fromJSONFields(fromJSON,auxData)
# query for the connection's profile image and bio
connection = self.raw_json['updateContent']['person']['connections']['values'][0]
if connection['id'] != 'private':
url = 'http://api.linkedin.com/v1/people/id=%s:(headline,summary,picture-url)' % connection['id']
try:
# request the user's updates
contentJSON = make_request(auxData,url,{'x-li-format':'json'})
contentObj = json.loads(contentJSON)
self.headline = contentObj.get('headline')
self.summary = contentObj.get('summary')
self.photo = contentObj.get('pictureUrl')
except urllib2.URLError:
self.log.error('***ERROR*** parse error')
self.log.error(contentJSON)
pass
return self
def get_author_profile(self,afm,db_session,oauth_config):
# Create our OAuth consumer instance
consumer = oauth.Consumer(oauth_config['key'], oauth_config['secret'])
token = oauth.Token(key=afm.access_token,secret=afm.access_token_secret)
client = oauth.Client(consumer, token)
# request the user's profile
content = make_request(client,'https://api.twitter.com/1/account/verify_credentials.json')
str_content = content.decode('utf-8')
respJSON = json.loads(str_content)
# print json.dumps(respJSON, sort_keys=True, indent=2)
profileJSON = {}
if respJSON.has_key('name'):
profileJSON['name'] = respJSON['name']
if respJSON.has_key('location'):
profileJSON['location'] = respJSON['location']
if respJSON.has_key('profile_image_url'):
profileJSON['picture_url'] = respJSON['profile_image_url']
if respJSON.has_key('description'):
profileJSON['headline'] = respJSON['description']
profileJSON['public_profile_url'] = 'https://twitter.com/#!/%s' % respJSON['screen_name']
return profileJSON
def linkedin_callback(request):
# the oauth_token is request as a query arg; the auth_token_secret is in session store
oauth_token = request.params['oauth_token']
oauth_token_secret = request.session['oauth_token_secret']
oauth_verifier = request.params['oauth_verifier']
# Step 3: Once the consumer has redirected the user back to the oauth_callback
# URL you can request the access token the user has approved. You use the
# request token to sign this request. After this is done you throw away the
# request token and use the access token returned. You should store this
# access token somewhere safe, like a database, for future use.
consumer = oauth.Consumer(oAuthConfig[FEATURE]['key'], oAuthConfig[FEATURE]['secret'])
token = oauth.Token(oauth_token,oauth_token_secret)
token.set_verifier(oauth_verifier)
client = oauth.Client(consumer, token)
resp, content = client.request(oAuthConfig[FEATURE]['access_token_url'], "POST")
access_token = dict(urlparse.parse_qsl(content))
# these are the real deal and need to be stored securely in the DB
accessToken = access_token['oauth_token']
accessTokenSecret = access_token['oauth_token_secret']
# Create our OAuth consumer instance
token = oauth.Token(key=accessToken,secret=accessTokenSecret)
client = oauth.Client(consumer, token)
response = make_request(client,'http://api.linkedin.com/v1/people/~:(id)',{'x-li-format':'json'})
respJSON = json.loads(response)
linkedinId = respJSON['id']
json_payload = json.dumps({'access_token':accessToken,'access_token_secret':accessTokenSecret,'auxillary_data':{'id':linkedinId}})
headers = {'Content-Type':'application/json; charset=utf-8'}
req = RequestWithMethod('%s/v1/authors/%s/features/%s' %
(request.registry.settings['mi.api.endpoint'],authenticated_userid(request),FEATURE),
'PUT',
json_payload,
headers)
res = urllib2.urlopen(req)
resJSON = json.loads(res.read())
try:
request.session['linkedin_access_token'] = accessToken
request.session['linkedin_access_token_secret'] = accessTokenSecret
except Exception, e:
print e
def twitter_callback(request):
# the oauth_token is request as a query arg; the auth_token_secret is in session store
oauth_token = request.params['oauth_token']
oauth_token_secret = request.session['oauth_token_secret']
oauth_verifier = request.params['oauth_verifier']
# Step 3: Once the consumer has redirected the user back to the oauth_callback
# URL you can request the access token the user has approved. You use the
# request token to sign this request. After this is done you throw away the
# request token and use the access token returned. You should store this
# access token somewhere safe, like a database, for future use.
consumer_key = oAuthConfig[FEATURE]['key']
consumer_secret = oAuthConfig[FEATURE]['secret']
consumer = oauth.Consumer(consumer_key, consumer_secret)
token = oauth.Token(oauth_token,oauth_token_secret)
client = oauth.Client(consumer, token)
token.set_verifier(oauth_verifier)
resp, content = client.request(oAuthConfig[FEATURE]['access_token_url'], "POST")
access_token = dict(urlparse.parse_qsl(content))
# these are the real deal and need to be stored securely in the DB
oauth_token = access_token['oauth_token']
oauth_token_secret = access_token['oauth_token_secret']
token = oauth.Token(oauth_token,oauth_token_secret)
client = oauth.Client(consumer, token)
userInfoJSON = json.loads(make_request(client,'https://api.twitter.com/1/account/verify_credentials.json').decode('utf-8'))
json_payload = json.dumps({'access_token':oauth_token,'access_token_secret':oauth_token_secret,'auxillary_data':{'id':userInfoJSON['id']}})
headers = {'Content-Type':'application/json; charset=utf-8'}
req = RequestWithMethod('%s/v1/authors/%s/features/%s' %
(request.registry.settings['mi.api.endpoint'],authenticated_userid(request),FEATURE),
'PUT',
json_payload,
headers)
res = urllib2.urlopen(req)
resJSON = json.loads(res.read())
try:
request.session['twitter_access_token'] = oauth_token
request.session['twitter_access_token_secret'] = oauth_token_secret
except Exception, e:
print e
def build_one(self,afm,dbSession,oauthConfig,incremental):
super(LinkedInFullCollector, self).build_one(afm,dbSession,oauthConfig,incremental)
# get the name of the author
authorName = dbSession.query(Author.author_name).filter_by(id=afm.author_id).one()
auxData = json.loads(afm.auxillary_data)
userId = auxData['id']
# setup what we need for oauth
consumer = oauth.Consumer(oauthConfig['key'], oauthConfig['secret'])
token = oauth.Token(key=afm.access_token,secret=afm.access_token_secret)
client = oauth.Client(consumer, token)
try:
# request the user's profile
response = make_request(client,'http://api.linkedin.com/v1/people/~:(picture-url)',{'x-li-format':'json'})
respJSON = json.loads(response)
profileImageURL = respJSON['pictureUrl'] if respJSON.has_key('pictureUrl') else None
traversal = self.beginTraversal(dbSession,afm,profileImageURL)
# optimization to request only those since we've last updated
args = {'scope':'self',
'type':['APPS','CMPY','CONN','JOBS','JGRP','PICT','PRFX','RECU','PRFU','QSTN','SHAR','VIRL'],
'count':PAGE_SIZE}
# incremental
if traversal.baselineLastUpdateTime:
# since a little before the last update time
args['after'] = '%s000' % int(mktime(traversal.baselineLastUpdateTime.timetuple()))
# full
else:
# limit to only one year of data
args['after'] = '%s000' % int(mktime((traversal.now - FULL_LOOKBACK_WINDOW).timetuple()))
offset = 0;
# args['start'] = offset
url = '%s?%s' % ('http://api.linkedin.com/v1/people/~/network/updates',urllib.urlencode(args, True))
while url and traversal.totalAccepted < 200:
# request the user's updates
content = make_request(client,url,{'x-li-format':'json'})
try:
rawJSON = json.loads(content)
except:
self.log.error('***ERROR*** parse error')
self.log.error(content)
continue
# print json.dumps(rawJSON, sort_keys=True, indent=2)
if rawJSON.get('_total',0) == 0:
url = None
continue
LinkedInEvent.eventsFromJSON(self,rawJSON,traversal,afm.author_id,userId,client)
# setup for the next page (if any)
if rawJSON['_total'] < PAGE_SIZE:
url = None
else:
offset = offset + PAGE_SIZE
# args['start'] = offset
url = '%s?%s' % ('http://api.linkedin.com/v1/people/~/network/updates',urllib.urlencode(args, True))
self.endTraversal(traversal,authorName)
except Exception, e:
self.log.error('****ERROR****')
self.log.error(e)
dbSession.rollback()
raise #continue
def build_one(self,afm,dbSession,oauthConfig,incremental):
super(TwitterFullCollector, self).build_one(afm,dbSession,oauthConfig,incremental)
# get the name of the author
authorName = dbSession.query(Author.author_name).filter_by(id=afm.author_id).one()
consumer = oauth.Consumer(oauthConfig['key'], oauthConfig['secret'])
token = oauth.Token(afm.access_token, afm.access_token_secret)
client = oauth.Client(consumer, token)
auxData = json.loads(afm.auxillary_data)
userId = int(auxData['id'])
try:
# API endpoing for querying user info
url = '%s%s' % (oauthConfig['endpoint'],USER_INFO)
userInfoJSON = json.loads(make_request(client,url))
twitterUserId = userInfoJSON['id']
if twitterUserId != userId:
raise Exception("Bad state - mis-matched twitter user ids")
profileImageUrl = userInfoJSON['profile_image_url'] if userInfoJSON.has_key('profile_image_url') else None
traversal = self.beginTraversal(dbSession,afm,profileImageUrl)
page = 1
# API endpoint for getting user timeline
url = '%s%s?%s' % (oauthConfig['endpoint'],USER_TIMELINE,urllib.urlencode({'include_rts':'1','include_entities':'1','count':'200','page':page}))
while url and traversal.totalAccepted < 200:
content = make_request(client,url)
try:
rawJSON = json.loads(content)
except:
self.log.error('***ERROR*** parse error')
self.log.error(content)
continue
if len(rawJSON) == 0:
url = None
continue
for post in rawJSON:
# process the item
#print json.dumps(post, sort_keys=True, indent=2)
event = Event.TwitterEvent(afm.author_id).fromJSON(post)
self.writeEvent(event,traversal)
# setup for the next page (if any)
page = page + 1
url = '%s%s?%s' % (oauthConfig['endpoint'],USER_TIMELINE,urllib.urlencode({'include_rts':'1','include_entities':'1','count':'200','page':page}))
self.endTraversal(traversal,authorName)
except Exception, e:
self.log.error('****ERROR****')
self.log.error(e)
dbSession.rollback()
raise #continue
def linkedin_confirmation(request):
# check if the linkedin access token is already in the session store. If not we'll need to retrieve
# from the API
access_token = request.session.get('linkedin_access_token')
if not access_token:
req = urllib2.Request('http://%s/v1/authors/%s/features/%s' %
(request.registry.settings['mi.api.endpoint'],authenticated_userid(request),FEATURE))
res = urllib2.urlopen(req)
resJSON = json.loads(res.read())
# ??? TODO - enhance the error handling
access_token = resJSON['access_token']
if not access_token:
raise UnexpectedAPIResponse('missing access_token for Instagram for author %s' % authenticated_userid(request))
access_token_secret = resJSON['access_token_secret']
if not access_token_secret:
raise UnexpectedAPIResponse('missing access_token_secret for Instagram for author %s' % authenticated_userid(request))
request.session['linkedin_access_token'] = access_token
request.session['linkedin_access_token_secret'] = access_token_secret
accessToken = request.session['linkedin_access_token']
accessTokenSecret = request.session['linkedin_access_token_secret']
# Create our OAuth consumer instance
consumer = oauth.Consumer(oAuthConfig[FEATURE]['key'], oAuthConfig[FEATURE]['secret'])
token = oauth.Token(key=accessToken,secret=accessTokenSecret)
client = oauth.Client(consumer, token)
# request the user's profile
response = make_request(client,'http://api.linkedin.com/v1/people/~:(id,first-name,last-name,headline,public-profile-url)',{'x-li-format':'json'})
respJSON = json.loads(response)
firstname = respJSON['firstName']
lastname = respJSON['lastName']
headline = respJSON['headline']
profileURL = respJSON['publicProfileUrl']
print json.dumps(respJSON, sort_keys=True, indent=2)
# request the user's network status
response = make_request(client,'http://api.linkedin.com/v1/people/~/network/network-stats',{'x-li-format':'json'})
respJSON = json.loads(response)
firstdegree = respJSON['values'][0]
seconddegree = respJSON['values'][1]
# print json.dumps(respJSON, sort_keys=True, indent=2)
# request the user's connections
response = make_request(client,'http://api.linkedin.com/v1/people/~/connections',{'x-li-format':'json'})
respJSON = json.loads(response)
connections = []
for connection in respJSON['values']:
if connection['id'] == 'private':
continue
image = '<img src="%s"/>' % connection['pictureUrl'] if 'pictureUrl' in connection else ''
connections.append('<li>%s %s %s</li>' % (connection['firstName'], connection['lastName'], image))
# print json.dumps(respJSON, sort_keys=True, indent=2)
# query the api for some feature events to display to the user
req = urllib2.Request('http://%s/v1/authors/%s/features/%s/featureEvents' %
(request.registry.settings['mi.api.endpoint'],authenticated_userid(request),FEATURE))
res = urllib2.urlopen(req)
resJSON = json.loads(res.read())
updates = []
for event in resJSON['events']:
title = event['content']['label'] if event['content']['label'] else ''
timestamp = datetime.utcfromtimestamp(event['create_time'])
updates.append('<p>%s (Created: %s)</p>' % (title,timestamp.isoformat()))
message = ''
messages = request.session.pop_flash()
if len(messages) > 0:
message = messages[0]
return{'message':message, 'title':'LinkedIn feature',
'firstname':firstname,'lastname':lastname,'headline':headline,'profileURL':profileURL,
'firstdegree':firstdegree,'seconddegree':seconddegree,
'updates': ''.join(updates),
'connections': ''.join(connections)}
