def has_entry(self, action_id, unique_key): session = named_scoped_session('haifu.storage') if session.query(VerificationEntry).filter( and_(VerificationEntry.action_id==action_id, VerificationEntry.unique_key==unique_key) ).first(): return True return False
def removeAssociation(self, server_url, handle): session = named_scoped_session('haifu.storage') query = session.query(OpenIDAssociation).filter( OpenIDAssociation.server_url==server_url).filter( OpenIDAssociation.handle==handle) for i in query: session.delete(i)
def get_key_for(self, unique_key): session = named_scoped_session('haifu.storage') entry = session.query(VerificationEntry).filter( VerificationEntry.unique_key==unique_key ).first() if entry: return entry.key return None
def lookup_nonce(self, oauth_consumer, oauth_token, nonce): session = named_scoped_session('haifu.storage') query = session.query(OAuthNonce).filter( OAuthNonce.consumer_key==oauth_consumer.key).filter( OAuthNonce.nonce_key==nonce) if oauth_token: query = query.filter(OAuthNonce.token_key==oauth_token.key) n = query.first() return n.nonce_key if n else None
def storeAssociation(self, server_url, association): session = named_scoped_session('haifu.storage') assoc = OpenIDAssociation(server_url=server_url, handle=association.handle, secret=base64.b64encode(association.secret), issued=association.issued, lifetime=association.lifetime, assoc_type=association.assoc_type) session.add(assoc)
def getAssociation(self, server_url, handle=None): session = named_scoped_session('haifu.storage') query = session.query(OpenIDAssociation).filter( OpenIDAssociation.server_url==server_url) if handle: query = query.filter(OpenIDAssociation.handle==handle) query = query.order_by(OpenIDAssociation.issued.desc()) assoc = query.first() return IOpenIDAssociation(assoc) if assoc else None
def authorize_request_token(self, oauth_token, user): session = named_scoped_session('haifu.storage') token = session.query(OAuthToken).filter( OAuthToken.key==oauth_token.key, OAuthToken.token_type=='request').first() if token: token.verifier = random_key() token.user = user return IOAuthToken(token) if token else None
def fetch_request_token(self, oauth_consumer, oauth_callback): session = named_scoped_session('haifu.storage') token = OAuthToken( consumer_key=oauth_consumer.key, callback=oauth_callback, key=random_key(), secret=random_key(), token_type='request' ) session.add(token) return IOAuthToken(token)
def get_activities(self, person_id, limit=None, offset=None): session = named_scoped_session('haifu.storage') query = session.query(Activity).filter( Activity.person_id==person_id ).order_by(Activity.timestamp.desc()) if limit is None or limit==0 or limit > HARD_LIMIT: limit = HARD_LIMIT query.limit(limit) if offset is not None or offset != 0: query.offset(offset) return [IActivity(i) for i in query]
def add_activity(self, person_id, data, timestamp=None): if timestamp is None: timestamp = datetime.utcnow() session = named_scoped_session('haifu.storage') jsondata = simplejson.dumps(data) activity = Activity( person_id = person_id, data = jsondata, timestamp = timestamp ) session.add(activity)
def add_person(self, login, password, firstname, lastname, email): session = named_scoped_session('haifu.storage') hashed_pw = hashlib.sha1(password).hexdigest() p = Person( login=login, password=hashed_pw, firstname=firstname, lastname=lastname, email=email ) session.add(p) session.flush() return IPerson(p)
def add_entry(self, key, action_id, data, unique_key, timestamp=None): if timestamp is None: timestamp = datetime.utcnow() session = named_scoped_session('haifu.storage') # delete old entries with the same unique key entries = session.query(VerificationEntry).filter( and_(VerificationEntry.action_id==action_id, VerificationEntry.unique_key==unique_key)) for entry in entries: session.delete(entry) # add new entry jsondata = simplejson.dumps(data) entry = VerificationEntry( key=key, action_id=action_id, data=jsondata, unique_key=unique_key, timestamp=timestamp ) session.add(entry)
def fetch_access_token(self, oauth_consumer, oauth_token, oauth_verifier): session = named_scoped_session('haifu.storage') request_token = session.query(OAuthToken).filter( OAuthToken.consumer_key==oauth_consumer.key).filter( OAuthToken.key==oauth_token.key).filter( OAuthToken.token_type=='request').filter( OAuthToken.verifier==oauth_verifier).first() if not request_token: return None token = OAuthToken( consumer_key=oauth_consumer.key, key=random_key(), secret=random_key(), user=request_token.user, token_type='access' ) session.add(token) return IOAuthToken(token)
def delete_entry(self, key): session = named_scoped_session('haifu.storage') entries = session.query(VerificationEntry).filter( VerificationEntry.key==key) for entry in entries: session.delete(entry)
def get_entry(self, key): session = named_scoped_session('haifu.storage') entry = session.query(VerificationEntry).filter( VerificationEntry.key==key).first() return IVerificationEntry(entry) if entry else None
def lookup_consumer(self, key): session = named_scoped_session('haifu.storage') consumer = session.query(OAuthConsumer).filter( OAuthConsumer.consumer_key==key ).first() return IOAuthConsumer(consumer) if consumer else None
def get_person_by_email(self, email): session = named_scoped_session('haifu.storage') p = session.query(Person).filter(Person.email==email).first() return IPerson(p) if p else None
def get_person(self, login): session = named_scoped_session('haifu.storage') p = session.query(Person).filter(Person.login==login).first() return IPerson(p) if p else None
def handler(event): session = named_scoped_session('haifu.storage') metadata.create_all(session.bind)
def lookup_token(self, token_type, token): session = named_scoped_session('haifu.storage') token = session.query(OAuthToken).filter( OAuthToken.key==token ).filter(OAuthToken.token_type==token_type).first() return IOAuthToken(token) if token else None