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)