def get_api(self, entity_obj=None, entity_id=None, access_token = None, access_token_secret=None):
if self.api is None:
_api = LinkedIn(settings.LINKEDIN_OAUTH_CONSUMER_KEY,
settings.LINKEDIN_OAUTH_CONSUMER_SECRET,
settings.LINKEDIN_OAUTH_RETURN_URL)
if access_token is None or access_token_secret is None:
_token=super(CustomConnector, self).get_record(entity_id, ["access_token_secret",
"access_token"])
_api.access_token=_token['access_token']
_api.access_token_secret=_token['access_token_secret']
else:
_api.access_token=access_token
_api.access_token_secret=access_token_secret
self.api = _api
return self.api
def get_oauth_url(self, entity_id=None, params={}):
next_url=params.get('next_url', settings.LINKEDIN_OAUTH_RETURN_URL)
decode = params.get('decode', False)
if decode:
next_url=urllib.unquote(next_url)
api = LinkedIn(settings.LINKEDIN_OAUTH_CONSUMER_KEY,
settings.LINKEDIN_OAUTH_CONSUMER_SECRET,
next_url)
result = api.requestToken() # result can be True or False
# if True, you can open your browser and copy the authorization url of LinkedIn.
if result:
try:
query=None
pickled = base64.encodestring(pickle.dumps(api))
token = api.request_token
self.transaction_start()
try:
query=QUERY_CREATE_OAUTH_TABLE % (DM_DATABASE_NAME)
self.do_query(query)
except Exception, err:
if not ("already exists" in ("%s" % err)):
Logger().error("Error: %s (%s) - %s" % (err, query, Exception))
raise Exception, err
try:
query=QUERY_DELETE_OAUTH_RECORD % (DM_DATABASE_NAME,token, "linkedinConnector")
self.do_query(query)
except Exception, err:
Logger().error("Error: %s (%s)" % (err, query))
raise Exception, err
query=QUERY_ADD_OAUTH_RECORD % (DM_DATABASE_NAME,
token,
pickled,
str(datetime.datetime.now()),
"linkedinConnector")
self.do_query(query)
self.transaction_commit()
def oauth_validate_token(self, entity_id=None, params={}):
api = LinkedIn(settings.LINKEDIN_OAUTH_CONSUMER_KEY,
settings.LINKEDIN_OAUTH_CONSUMER_SECRET,
params.get('next_url', settings.LINKEDIN_OAUTH_RETURN_URL))
try:
tokenized_url = params.get('tokenized_url')
if tokenized_url and tokenized_url!="":
decode = params.get('decode', False)
if decode:
tokenized_url=urllib.unquote(tokenized_url)
parsed=urlparse(tokenized_url)
parsed_params=dict([item.split('=')[0], item.split('=')[1]] for item in parsed.query.split('&'))
oauth_token = urllib.unquote(parsed_params.get('oauth_token'))
self.cursor.execute(QUERY_GET_OAUTH_RECORD % (DM_DATABASE_NAME, oauth_token, "linkedinConnector"))
record=[dict(zip(['pickled'], row)) for row in self.cursor.fetchall()]
api = pickle.loads(base64.decodestring(record[0].get('pickled')))
oauth_verifier = str(parsed_params.get('oauth_verifier'))
# After you get the verifier, you call the accessToken() method to get the access token.
result = api.accessToken(verifier=oauth_verifier) # result can be True or False
if result:
entity_type=self.object_name.split("_")[-1]
if entity_id is None:
profile_fields=["id",
"first-name",
"last-name",
]
profile = api.GetProfile(None, None, profile_fields)
attributes=profile.to_dict()
remote_id = "%s" % attributes['id']
entity_name="%s %s" % (attributes.get('first-name'), attributes.get('last-name'))
entity_slug=microtime_slug()
try:
my_entity=add_entity({"slug":entity_slug,
"name":entity_name,
"type":entity_type,
"remote_id":remote_id,
"attributes":{
"access_token_secret":api.access_token_secret,
"access_token": api.access_token
}
})
entity_id=my_entity.id
except Exception, err:
try:
my_entity=get_entity({"remote_id":remote_id, "type":entity_type})[0]
entity_id=my_entity.id
super(CustomConnector, self).update_record(entity_id, {
"access_token_secret":api.access_token_secret,
"access_token": api.access_token
})
except Exception, err:
raise ApiError(None, 3923, "%s - %s" % (Exception, err))
else:
my_entity=get_entity({"id":str(entity_id), "type":entity_type})[0]
super(CustomConnector, self).update_record(entity_id,
{"access_token_secret":api.access_token_secret,
"access_token": api.access_token})
try:
query=QUERY_DELETE_OAUTH_RECORD % (DM_DATABASE_NAME,oauth_token, "linkedinConnector")
self.do_query(query)
except Exception, err:
Logger().error("Error: %s (%s)" % (err, query))
