def get_activity(params):
objects = Activity.objects.all()
if params.has_key('id') and params.get('id'):
objects = objects.filter(id=params.get('id'))
if params.has_key('activity_id') and params.get('activity_id'):
objects = objects.filter(activity_id=params.get('activity_id'))
objects=build_text_search(objects, "subject_uri", params)
objects=build_text_search(objects, "verb_uri", params)
objects=build_text_search(objects, "object_uri", params)
objects=build_text_search(objects, "url", params)
if params.get('entity_rel', '')!='':
param_chunks=params.get('entity_rel', '').split(">")
entity_from_type=param_chunks[0]
rel=param_chunks[1]
entity_to=param_chunks[2]
funct_params={'type':entity_from_type, 'rel':"%s>%s" % (rel, entity_to), 'count':'1'}
entities_count=get_entity(funct_params)
if entities_count>0:
funct_params['count']='0'
funct_params['limit']=entities_count
entity_objs=get_entity(funct_params)
slugs_list=[("%s:%s" % (entity_from_type, obj.slug)) for obj in entity_objs]
objects = objects.filter(subject_uri__in=slugs_list)
else:
objects = objects.filter(subject_uri__in=list())
if params.has_key('published_interval') and params.get('published_interval'):
objects = objects.filter(published__range=params.get('published_interval'))
if params.get('distinct', '')!='':
return list ( objects.values(params.get('distinct')).distinct());
else:
objects = objects.order_by('-published')
#Insert here additional filtering
list_offset=max(int(params.get('offset', 0)),0)
list_limit=max(int(params.get('limit', 20)),1)
#raise Exception, ("%s" % (params.get('subject_description')))
if int(params.get('count', 0))==1:
return objects.count()
objectlist = list(objects[list_offset: list_offset+list_limit])
if params.has_key('htmlformat') and params.get('htmlformat'):
htmlobjectString = ""
for object in objectlist:
# htmlobject = object.to_dict()
htmlobjectString = "%s%s%s%s" %(htmlobjectString,'<li>',object.content,'</li>')
return htmlobjectString
return list(objects[list_offset: list_offset+list_limit])
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 oauth_validate_token(self, entity_id=None, params={}):
pos=0
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, "googleConnector"))
record=[dict(zip(['pickled'], row)) for row in self.cursor.fetchall()]
_pickled = pickle.loads(base64.decodestring(record[0].get('pickled')))
next_url=_pickled['next_url']
service = _pickled['service']
consumer_key = _pickled['consumer_key']
consumer_secret = _pickled['consumer_secret']
source = _pickled['source']
scopes = _pickled['scopes']
saved_request_token = _pickled['token']
self.logger.error(_pickled)
self.request_token = gdata.gauth.AuthorizeRequestToken(saved_request_token, tokenized_url)
client = gdata.docs.client.DocsClient(source=source)
self.access_token = client.GetAccessToken(self.request_token)
credentials_attributes={"token_key":self.access_token.token,
"token_secret":self.access_token.token_secret,
"consumer_key":consumer_key,
'consumer_secret':consumer_secret,
'service':service
}
services=list()
for service_key, service_val in services_data.items():
intersect=list(set(service_val["scopes"]).intersection(set(scopes)))
intersect.sort()
service_scopes=service_val["scopes"]
service_scopes.sort()
if intersect == service_scopes:
services.append(service_key)
for service in services:
if service in ('docs', 'youtube'):
attributes = super(CustomConnector, self).get_record(entity_id, ["services"])
credentials=attributes.get("services", "{}")
if credentials is None or credentials=="":
credentials={}
else:
credentials=json_decode(credentials)
if not credentials.has_key(service):
credentials[service]={}
credentials[service]['oauth']=credentials_attributes
super(CustomConnector, self).update_record(entity_id, {"services":cjson.encode(credentials)})
else:
raise ApiError(None, 3941)
entity_type=self.object_name.split("_")[-1]
my_entity=get_entity({"slug":str(entity_id), "type":entity_type})
return my_entity
else:
raise ApiError(None, 3942)
except Exception, err:
err="%s - %s" % (pos, err)
raise ApiError(None, 3100, err)
def get(self):
return em.get_entity(self.params, self)
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))
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))
else:
my_entity=get_entity({"id":str(entity_id), "type":entity_type})[0]
super(CustomConnector, self).update_record(entity_id, attributes)
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))
return my_entity
except Exception, err:
self.logger.error("%s" % err)
raise ApiError(None, 3100, err)
