def user_id_for_session_id(self, session_id=None):
"""
overloads from parent. looks for user_id in the database and returns it
:param session_id: session id
:return: user id.
"""
if session_id:
UserSession.load_from_file()
user_session_list = UserSession.search({'session_id': session_id})
if user_session_list:
session = user_session_list[0]
user_id = session.user_id
if hasattr(session, 'created_at'):
current = datetime.utcnow()
if user_id:
if self.session_duration <= 0 \
or not self.session_duration:
return user_id
if (session.created_at + timedelta(
seconds=self.session_duration)) < current:
return None
return user_id
return None
def destroy_session(self, request=None):
""" Destroy the session
"""
if request is None:
return False
session_id = self.session_cookie(request)
if session_id is None:
return False
user_id = self.user_id_for_session_id(session_id)
if not user_id:
return False
session_ids = UserSession.search({'session_id': session_id})
if not session_ids:
return False
try:
session_ids[0].remove()
UserSession.save_to_file()
except Exception:
return False
return True
def destroy_session(self, request=None):
"""Remove Session from Database"""
if request is None:
return False
session_id = self.session_cookie(request)
if session_id is None:
return False
user_id = self.user_id_for_session_id(session_id)
if not user_id:
return False
user_session = UserSession.search({'session_id': session_id})
if not user_session:
return False
user_session = user_session[0]
try:
user_session.remove()
UserSession.save_to_file()
except Exception:
return False
return True
def user_id_for_session_id(self, session_id=None):
"""
Make user id to session
Args:
session_id: String of the session
Return:
User ID if not is expired
"""
if session_id is None:
return None
UserSession.load_from_file()
user_sess = UserSession.search({'session_id': session_id})
if not user_sess:
return None
user = user_sess[0]
if user is None:
return None
expired_tm = user.created_at + \
timedelta(seconds=self.session_duration)
if expired_tm < datetime.now():
return None
return user.user_id
def create_session(self, user_id=None):
""" Generates a session ID
"""
session_id = super().create_session(user_id)
if user_id is None:
return None
user_session = UserSession(user_id=user_id, session_id=session_id)
user_session.save()
return session_id
def create_session(self, user_id=None):
"""
method that create a new session
"""
if user_id:
session_id = super().create_session(user_id)
user = UserSession(user_id=user_id, session_id=session_id)
user.save()
return session_id
return None
def create_session(self, user_id=None):
""" create a session and store session_id in storage """
if not user_id:
return None
session_id = super().create_session(user_id)
if not session_id:
return
user = UserSession(user_id=user_id, session_id=session_id)
user.save()
return session_id
def create_session(self, user_id=None):
"""create a session
"""
if user_id is None:
return None
session_id = super().create_session(user_id)
if session_id is None:
return None
session = UserSession(user_id, session_id)
session.save()
return session
def create_session(self, user_id=None):
"""
create_session.
"""
if user_id:
session_id = super().create_session(user_id)
if not session_id:
return
new_user = UserSession(user_id=user_id, session_id=session_id)
new_user.save()
return session_id
def create_session(self, user_id: str = None) -> str:
"""
create_session function
"""
if user_id is None:
return None
session_id = super().create_session(user_id)
if session_id is None:
return None
user_session = UserSession(user_id=user_id, session_id=session_id)
user_session.save()
return session_id
def create_session(self, user_id=None):
"""
overloads parents create_session. Creates a UserSession Object and
saves it in the database
:param user_id:
:return:
"""
session_id = super().create_session(user_id=user_id)
if session_id:
user_session = UserSession(user_id=user_id, session_id=session_id)
user_session.save()
return session_id
class SessionDBAuth(SessionExpAuth):
""" SessionDBAuth class
"""
def __init__(self):
super().__init__()
self.user_session = UserSession()
def create_session(self, user_id=None):
""" Overloads SessionExpAuth create_session
"""
if user_id is None:
return None
session_id = super().create_session(user_id)
self.user_session.session_id = session_id
self.user_session.user_id = user_id
self.user_session.save()
return session_id
def user_id_for_session_id(self, session_id=None):
""" Overloads method in SessionExpAuth
Returns User ID by requesting UserSession in DB using session_id
"""
if session_id is None:
return None
UserSession.load_from_file()
user_session = UserSession.search({'session_id': session_id})
if not user_session:
return None
session = user_session[0]
session_dictionary = self.user_id_by_session_id.get(session_id)
if not session_dictionary:
return None
created_at = session_dictionary.get('created_at')
expiration = created_at + timedelta(seconds=self.session_duration)
if expiration < datetime.now():
return None
return session.user_id
def destroy_session(self, request=None):
""" Overloads method in SessionExpAuth
Destroys UserSession based on the Session ID from user cookie
"""
if request is None:
return False
session_id = self.session_cookie(request)
if not session_id:
return False
session_list = UserSession.search({'session_id': session_id})
if len(session_list) < 1:
return False
current_session = session_list[0]
current_session.remove()
return True
def user_id_for_session_id(self, session_id=None):
"""Get user ID from session
"""
if not session_id:
return None
UserSession.load_from_file()
users = UserSession.search({'session_id': session_id})
for u in users:
delta = timedelta(seconds=self.session_duration)
if u.created_at + delta < datetime.now():
return None
return u.user_id
def create_session(self, user_id=None):
""" creates and stores new instance
of UserSession and returns the Session ID
"""
if not user_id:
return
session_id = super().create_session(user_id)
if not session_id:
return
session = UserSession(user_id=user_id, session_id=session_id)
session.save()
return session_id
def create_session(self, user_id=None):
""" Save an instance of the user session """
if user_id is None:
return None
session_id = super().create_session(user_id)
if session_id is None:
return None
session = UserSession(user_id=user_id, session_id=session_id)
session.save()
return session_id
def create_session(self, user_id=None):
"""[create sesion]
Args:
user_id ([type], optional): [id]. Defaults to None.
"""
if user_id:
session = super().create_session(user_id)
if session:
user = UserSession(user_id=user_id, session_id=session)
user.save()
return session
return None
def create_session(self, user_id=None):
''' Create and store session. '''
if user_id is None:
return None
# Get session ID from parent class method
session_id = super().create_session(user_id)
# Create and save instance of UserSession with user ID and session ID
user_session = UserSession(user_id=user_id, session_id=session_id)
user_session.save()
return session_id
def user_id_for_session_id(self, session_id=None):
""" that returns the User ID by requesting UserSession
in the database based on session_id
"""
if not session_id:
return None
UserSession.load_from_file()
users = UserSession.search({'session_id': session_id})
for user in users:
delta = timedelta(seconds=self.session_duration)
if user.created_at + delta < datetime.now():
return None
return user.user_id
def create_session(self, user_id=None):
""" overloaded create_session method """
sess_id = super().create_session(user_id)
if sess_id is None:
return None
try:
sess = UserSession()
sess.user_id = user_id
sess.session_id = sess_id
db_session.add(sess)
db_session.commit()
return sess.session_id
except:
return None
def create_session(self, user_id=None):
"""
creates and stores new instance of UserSession
and returns the Session ID
"""
if not user_id:
return None
session_id = super().create_session(user_id)
if not session_id:
return None
session_data = {"user_id": user_id, "session_id": session_id}
obj = UserSession(**session_data)
obj.save()
return session_id
def destroy_session(self, request=None):
"""Delete the user session / log out
"""
if request:
session_id = self.session_cookie(request)
if not session_id:
return False
if not self.user_id_for_session_id(session_id):
return False
users = UserSession.search({'session_id': session_id})
for u in users:
u.remove()
UserSession.save_to_file()
return True
return False
def create_session(self, user_id=None):
"""
Creates a session ID.
"""
if user_id is None:
return None
session_id = super().create_session(user_id)
if session_id is None:
return None
user_session_data = {'session_id': session_id, 'user_id': user_id}
user_session = UserSession(**user_session_data)
user_session.save()
return session_id
def destroy_session(self, request=None):
""" that destroys the UserSession based on the Session ID
from the request cookie
"""
if request:
session_id = self.session_cookie(request)
if not session_id:
return False
if not self.user_id_for_session_id(session_id):
return False
users = UserSession.search({'session_id': session_id})
for user in users:
user.remove()
UserSession.save_to_file()
return True
return False
def user_id_for_session_id(self, session_id=None):
""" returns the User ID by requesting UserSession in
the database based on session_id
"""
if type(session_id) is not str:
return None
try:
users_sessions = UserSession.search({'session_id': session_id})
except Exception:
return None
if len(users_sessions) == 0:
return None
user_session = users_sessions[0]
if self.session_duration <= 0:
return user_session.user_id
created_at_session = user_session.created_at
duration_session = created_at_session + timedelta(
seconds=self.session_duration
)
if duration_session < datetime.now():
return None
return user_session.user_id
def create_session(self, user_id=None):
""" create a new session for a user overloaded """
sess = super().create_session(user_id)
if sess is None:
return None
UserSession(user_id=user_id, session_id=sess).save()
return sess
def user_id_for_session_id(self, session_id=None):
"""
Returns a User ID based on a Session ID.
"""
if session_id is None:
return None
UserSession.load_from_file()
user = UserSession.search({'session_id': session_id})
if not user:
return None
user = user[0]
timing = timedelta(seconds=self.session_duration) + user.created_at
if timing < datetime.now():
return None
return user.user_id
def user_id_for_session_id(self, session_id=None):
""" Get the user id for session
"""
if session_id is None:
return None
UserSession.load_from_file()
session_ids = UserSession.search({'session_id': session_id})
if not session_ids:
return None
if datetime.utcnow() > session_ids[0].created_at + timedelta(
seconds=self.session_duration):
return None
return session_ids[0].user_id
def create_session(self, user_id=None):
""" Create Session
"""
if user_id is None:
return None
session_id = super().create_session(user_id)
if session_id is None:
return None
user_session = UserSession(**{
'user_id': user_id,
'session_id': session_id
})
user_session.save()
return session_id
def destroy_session(self, request=None):
""" destroy/logout of the session overloaded """
if super().destroy(request):
sess = self.session_cookie(request)
sessData = UserSession.search({"session_id": sess})
if sessData is not None:
[x.remove() for x in sessData]
return True
return False
def create_session(self, user_id=None):
""" This module is for session DB auth which stores sessions in db """
if not user_id:
return None
session_id = super().create_session(user_id)
if not session_id:
return
UserSession(user_id=user_id, session_id=session_id).save()
return session_id
def post(self):
""" User sends gold and route info to server.
Request
uid - user_id
cid - channel_id
data - message
"""
data = json.loads(self.request.body)
uid = data['uid']
print uid
cid = data['cid']
print cid
ucg = data['current_gold']
print "The user's current gold is " + ucg
r = data['route']
print "The route is: " + r
pointsList = r.split(";")
ndb.GeoPoint()
rid = uid + "-" + cid
route = Route(route_id=rid, list_of_points=[])
for i in range(len(pointsList)):
lng = pointsList[i].split()[0]
lat = pointsList[i].split()[1]
route.list_of_points.append(ndb.GeoPoint(lng, lat))
route.put()
usid = uid + "-" + cid
user_session = UserSession(user_session_id=usid, base_point="",
drop_off_point="", user_current_gold=ucg, route_id=rid)
user_session.put()
# session = Session.query(Session.channel_id == cid).get()
pubnub = Pubnub(publish_key=PUBLISH_KEY,
subscribe_key=SUBSCRIBE_KEY, ssl_on=False, uuid=str(uid))
pubnub.subscribe(cid, callback)
pubnub.publish(cid, uid + " has selected a route")
response = {'user-session-id': usid}
self.response.out.write(json.dumps(response))
