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
