def oauth_validate_token(self, entity_id=None, params={}):
next_url=params.get('next_url', settings.FACEBOOK_CONNECTOR_REDIRECT_URI)
decode = params.get('decode', False)
if decode:
next_url=urllib.unquote(next_url)
client=Oauth2WebFlow('graph.facebook.com',
settings.FACEBOOK_CONNECTOR_API_KEY,
settings.FACEBOOK_CONNECTOR_SECRET_KEY,
next_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('&'))
code = urllib.unquote(parsed_params.get('code'))
access_token = client.getAccessToken(code)
facebook_params=None
if access_token:
entity_type=self.object_name.split("_")[-1]
if entity_id is None:
facebook_params=self.graph(None, {}, access_token)
remote_id = "%s" % facebook_params['id']
entity_name="%s %s" % (facebook_params.get('first_name'), facebook_params.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": 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": 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": access_token})
else:
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))
def build_response(self):
if isinstance(self.response, dict):
response=""
if self.response.has_key('success') and \
self.response.has_key('msg') and \
self.response.has_key('data'):
if self.response['success']:
transaction.commit()
else:
transaction.rollback()
transaction.leave_transaction_management()
format='json'
fl_jindent=False
mimetype='text/plain'
_params=None
if self.method in ('POST', 'PUT'):
_params=self.raw_data
elif self.method in ('GET', 'DELETE'):
_params=self.params
if _params:
format=_params.get('format', 'json')
fl_jindent=bool(_params.get('jindent', False))
if format=='json':
fl_jindent=settings.DEBUG_JSON or fl_jindent
if not fl_jindent:
mimetype='application/json'
_result=json_encode(self.response, fl_jindent)
response=_result
elif format=='xml':
mimetype='text/xml'
response='<?xml version="1.0" encoding="UTF-8" ?><answer>Sorry, xml format not yet implemented</answer>'
elif format=='csv':
csv_text=""
if len(self.response)>0:
row_cells=list()
first_row=list()
if _params.has_key('row_format'):
row_format=_params.get('row_format')
for row_cell in _params.get('row_format').split(','):
if ':' in row_cell:
cell_path, cell_head=row_cell.split(':')
else:
cell_path=row_cell
cell_head=row_cell
cell_path=cell_path.strip()
cell_head=cell_head.strip()
first_row.append(smart_str(cell_head))
row_cells.append(cell_path.split('.'))
else:
if isinstance(self.response['data'], list) and isinstance(self.response['data'][0], dict):
for key in self.response['data'][0]:
if isinstance(self.response['data'][0][key], dict):
for inner_key in self.response['data'][0][key]:
row_cells.append([key, inner_key])
first_row.append("%s.%s" % (smart_str(key),
smart_str(inner_key)))
else:
row_cells.append([key])
first_row.append(smart_str(key))
row_cells.sort()
first_row.sort()
if len(row_cells)>0:
string_file=StringIO.StringIO()
writer=csv.writer(string_file,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL,
)
if bool(int(_params.get('first_row',1))):
writer.writerow(first_row)
for row in self.response['data']:
row_list=list()
for cell in row_cells:
nomad = get_item_value_by_key(row, cell)
if isinstance(nomad, (str, unicode)):
row_list.append(nomad.encode('utf-8'))
elif isinstance(nomad, (int, float)):
row_list.append(nomad)
else:
try:
row_list.append(json_encode(nomad).encode('utf-8'))
except Exception, err:
try:
row_list.append("%s" % (nomad))
except Exception, err:
row_list.append("%s-%s" % (Exception, err))
writer.writerow(row_list)
csv_text=string_file.getvalue()
if bool(int(_params.get('compress',0))):
mimetype='application/zip'
zip_file=StringIO.StringIO()
zipper=zipfile.ZipFile(zip_file, 'w')
zipper.writestr("%s.csv" % _params.get('file_name',microtime_slug()), csv_text )
zipper.close()
response=zip_file.getvalue()
Content_Disposition = 'attachment; filename=%s.zip' % microtime_slug()
else:
mimetype='text/csv'
response=csv_text
Content_Disposition = 'attachment; filename=%s.csv' % microtime_slug()
if csv_text=="":
response="No data to convert"
HttpResponseServerError(response)
else:
http_response=HttpResponse(response, mimetype=mimetype)
http_response['Content-Disposition'] = Content_Disposition
return http_response
else:
response="Answer format not supported: %s" % (format,)
HttpResponseServerError(response)
return HttpResponse(response, mimetype=mimetype)
def oauth_validate_token(self, entity_id=None, params={}):
pos=1
self.trace(pos)
try:
tokenized_url = params.get('tokenized_url')
decode = params.get('decode', False)
if decode:
tokenized_url=urllib.unquote(tokenized_url)
parsed=urlparse(tokenized_url)
self.trace(pos)
parsed_params=dict([item.split('=')[0], item.split('=')[1]] for item in parsed.query.split('&'))
oauth_token = urllib.unquote(parsed_params.get('oauth_token'))
oauth_verifier = urllib.unquote(parsed_params.get('oauth_verifier'))
self.trace(pos)
self.cursor.execute(QUERY_GET_OAUTH_RECORD % (DM_DATABASE_NAME, oauth_token, "twitterConnector"))
record=[dict(zip(['pickled'], row)) for row in self.cursor.fetchall()]
record = cjson.decode(record[0].get('pickled'))
self.trace(pos)
auth = self.get_auth()
auth.set_request_token(record['key'],record['secret'])
auth.get_access_token(oauth_verifier)
self.trace(pos)
self.key= auth.access_token.key
self.secret=auth.access_token.secret
auth.set_access_token(self.key, self.secret)
api = tweepy.API(auth)
self.trace(pos)
try:
query=QUERY_DELETE_OAUTH_RECORD % (DM_DATABASE_NAME,oauth_token, "twitterConnector")
self.do_query(query)
except Exception, err:
Logger().error("Error: %s (%s)" % (err, query))
#raise Exception, err
me =api.me()
my_id=getattr(me,'id')
my_name=getattr(me,'name')
if my_name is None or my_name =="":
my_name=getattr(me,'screen_name')
entity_type=self.object_name.split("_")[-1]
attributes={"token_key":self.key, "token_secret":self.secret}
self.trace(pos)
entity_type=self.object_name.split("_")[-1]
if entity_id is None:
remote_id = "%s" % getattr(me,'id')
entity_name=my_name
entity_slug=microtime_slug()
try:
my_entity=add_entity({"slug":entity_slug,
"name":entity_name,
"type":entity_type,
"remote_id":remote_id,
"attributes":attributes
})
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, attributes)
except Exception, err:
raise ApiError(None, 3923, "%s - %s" % (Exception, err))
