class CookieClientIdentification(ext.Adapter):
ext.context(ext.IRequest)
ext.implements(IClientIdentification)
def __init__(self, request):
self.request = request
def identification(self):
""" cookie expiration will do on server. BE SURE A OLD COOKIE
WILL BE OVERIDE AFTER HIS LIVE TIME!
"""
return self.request.cookies.get(COOKIE_SESSION_KEY)
def apply(self, secure=False):
""" the secure flag means that this
cookie can be set on http and https.
"""
cookie = self.genereate_id()
self.request.cookies[COOKIE_SESSION_KEY] = cookie
self.request.response.set_cookie(key=COOKIE_SESSION_KEY,
value=cookie,
secure=secure)
return cookie
def genereate_id(self):
letters = string.ascii_letters + string.digits
return ''.join(
random.choice(letters) for i in range(COOKIE_SESSION_LENGHT))
class DefaultHTTPExceptionHandler(ext.Adapter):
""" This is a default adapter that do
nothing else as return the same error.
"""
ext.context(HTTPError)
def __call__(self):
transaction.abort()
return self.context
class DefaultHTTPExceptionHandler(DefaultExceptionHandler):
""" This is a default adapter for HTTP errors. The client receive
as json object with the a http error code.
"""
ext.context(HTTPError)
def __call__(self, request):
self.request = request
transaction.abort()
self.errorresponse(str(self.context), self.context.code)
class DefaultExceptionHandler(ext.Adapter):
""" This adapter is for all exceptions types.
It recreate the exceptions and send it as
InternalServerError.
IN FUTURE WE SHOULD REMOVE THE ERROR MESSAGE FOR THE WEBUSER !!
"""
ext.context(Exception)
def __call__(self):
transaction.abort()
print(traceback.format_exc())
return HTTPInternalServerError(str(self.context))
class DefaultExceptionHandler(ext.Adapter):
""" This adapter is for all exceptions types.
The handler wrap the error message to a json
response object and send it back to client.
IN FUTURE WE SHOULD REMOVE THE ERROR MESSAGE FOR THE WEBUSER !!
"""
ext.context(Exception)
def __call__(self, request):
self.request = request
transaction.abort()
print(traceback.format_exc())
self.errorresponse(str(self.context), 500)
def errorresponse(self, message, code):
self.request.response.status_code = code
self.request.response.write(
json.dumps(dict(success=False,
message=message,
total=0,
data=list()),
indent=' ' * 4))
class RamSession(ext.Adapter):
""" simple session thats store data unencrypted in ram. After shutdown
the server all data will lost.
For a persistent session class you properly should
inherit from this class.
"""
ext.implements(ISession)
ext.context(ext.IRequest)
user_session_data_cls = UserSessionData
def __init__(self, request):
self.request = request
def __setitem__(self, key, value):
client = IClientIdentification(self.request)
identification = client.identification()
if identification is None or identification not in self.store():
identification = client.apply()
data = self.store().setdefault(identification,
self.user_session_data_cls())
data[key] = self.encrypt(value)
data.reset_lastchanged()
def __getitem__(self, key):
self.refresh()
identification = IClientIdentification(self.request).identification()
if identification is None or identification not in self.store():
raise KeyError('user has no identification or data')
return self.decrypt(self.store()[identification][key])
def __delitem__(self, key):
identification = IClientIdentification(self.request).identification()
if identification is None or identification not in self.store():
raise KeyError('user has no identification or data')
del self.store()[identification]
def __contains__(self, key):
identification = IClientIdentification(self.request).identification()
if identification is None:
return False
if identification not in self.store():
return False
return key in self.store()[identification]
def set_expiration_time(self, time):
self.store().expiration = time
def get_expiration_time(self):
return self.store().expiration
def store(self):
""" return a store in form of a dict
"""
return ram
def decrypt(self, value):
""" this function do nothing but
can easily overridden in a subclass
"""
return value
def encrypt(self, value):
""" this function do nothing but
can easily overridden in a subclass
"""
return value
def refresh(self):
removes = list()
for key, data in self.store().items():
if data.lastchanged + self.get_expiration_time() < time():
removes.append(key)
for key in removes:
del self.store()[key]