def post(self):
# Get POST data
email = self.request.get("email")
password = self.request.get("psw")
# Check if user exists
user = User.query(User.email == email).fetch()
if not user:
return self.write("Email or password is wrong")
# Compare hashed password with value in database
salt = "d9be95247"
password = sha256(salt + password + salt).hexdigest()
if password != user[0].password:
return self.write("Email or password is wrong")
# Create session token
token = sha256(str(time.time()) + user[0].email).hexdigest()
# Write new session in database
new_session = Session(token=token, user_email=user[0].email)
new_session.put()
# Write token to cookie
self.response.set_cookie("token", token)
return self.redirect("/")
class SessionStore(SessionBase):
"""
A google appengine datastore based session store.
"""
def __init__(self, session_key=None):
self._datastore_session = None
if session_key:
query = db.Query(Session)
query = query.filter("session_key =", session_key)
self._datastore_session = query.get()
super(SessionStore, self).__init__(session_key)
def load(self):
session_data = {}
if self._datastore_session:
if self._datastore_session.expire_date > datetime.now():
if self._datastore_session.session_data:
session_data = self.decode(self._datastore_session.session_data)
else:
session_data = None
else:
self.delete()
return session_data or {}
def save(self):
time_till_expire = timedelta(seconds=60*60*24*7*2)
expire_date = datetime.now() + time_till_expire
if self._datastore_session:
self._datastore_session.session_data = self.encode(self._session)
else:
self._datastore_session = Session(session_key=self.session_key, session_data=self.encode(self._session), expire_date=expire_date)
self._datastore_session.put()
def exists(self, session_key):
query = db.Query(Session)
query = query.filter("session_key =", session_key)
session = query.get()
if session:
exists = True
else:
exists = False
return exists
def delete(self, session_key):
query = db.Query(Session)
query = query.filter("session_key =", session_key)
session = query.get()
if session:
session.delete()
def post(self):
# Get the POST data
email = cgi.escape(self.request.get("email")).strip()
psw = self.request.get("psw").strip()
psw_check = self.request.get("psw_check").strip()
# Check that no fields were submitted empty
if email == "" or psw == "" or psw_check == "":
return self.write(
"You need to fill out all the fields! Please try again!")
# Check that passwords match
if psw != psw_check:
return self.write("Passwords do not match. Please try again.")
# Check if user already exists
if User.query(User.email == email).fetch():
return self.write(
"That user already exists. Please use a different email.")
# Check if email is valid
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
return self.write("Please enter a valid email")
# Validate recaptcha
payload = {
'secret': os.environ.get("RECAPTCHA_KEY"),
'response': self.request.get("g-recaptcha-response"),
}
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
result = urlfetch.fetch(
url="https://www.google.com/recaptcha/api/siteverify",
headers=headers,
payload=urlencode(payload),
method=urlfetch.POST)
recaptcha_response = json.loads(result.content)
if not recaptcha_response['success']:
return self.write("Please verify you are not a robot")
# Hash the password
salt = "d9be95247"
password = sha256(salt + psw + salt).hexdigest()
# Create new user and write to database
new_user = User(email=email, password=password)
new_user.put()
# Send validation email
user_validation_token = str(uuid.uuid4())
memcache.add(user_validation_token, email, 86400)
params = {
"email":
email,
"subject":
"Please validate your email address",
"body":
"Visit this link - http://ninja-tech.appspot.com/validate/%s to validate your email and activate your user account."
% str(user_validation_token)
}
taskqueue.add(url="/task/send-validation-email", params=params)
#
# Log the user in
#
# Create session token
token = sha256(str(time.time()) + new_user.email).hexdigest()
# Write new session in database
new_session = Session(token=token, user_email=new_user.email)
new_session.put()
# Write token to cookie
self.response.set_cookie("token", token)
return self.redirect("/")
def post(self):
""" Start game by both users.
Request
uid - user_id
lid - the game lobby both users are playing in
Response
"""
data = json.loads(self.request.body)
response = {}
try:
uid = data['uid']
except KeyError:
self.error(400)
response['status'] = 'error'
response['msg'] = 'Missing uid (User id)'
return self.response.out.write(json.dumps(response))
try:
lobby_id = data['lid']
except KeyError:
self.error(400)
response['status'] = 'error'
response['msg'] = 'Missing lid (Lobby id)'
return self.response.out.write(json.dumps(response))
lobby = Lobby.query(Lobby.lobby_id == lobby_id).get()
if lobby is None:
logging.error(
"User (" + str(uid) + ") attempted to join non-existent Lobby (" + str(lobby_id) + ").")
else:
ready = lobby.ready
# This is a new user who is ready
if uid not in ready:
lobby.ready.append(uid)
lobby.put()
response = {}
# The game is ready to be started
if len(lobby.ready) == REQ_USERS:
# TODO: Add logic for creating a Session here
session = Session(channel_id=lobby_id, target_gold_amount="100",
user_ids=[])
for i in range(len(lobby.ready)):
session.user_ids.append(lobby.ready[i])
session.put()
response['type'] = "info"
response['data'] = {"ready": "true"}
pubnub.subscribe(lobby_id, callback)
pubnub.publish(lobby_id, response)
pubnub.unsubscribe(lobby_id)
self.response.out.write(json.dumps(response))
else:
response['type'] = "info"
response['data'] = {"ready": "false"}
pubnub.subscribe(lobby_id, callback)
pubnub.publish(lobby_id, callback)
pubnub.unsubscribe(lobby_id)
self.response.out.write(json.dumps(response))
def post(self):
""" Start game by both users.
Request
uid - user_id
lid - the game lobby both users are playing in
Response
"""
data = json.loads(self.request.body)
response = {}
try:
uid = data['uid']
except KeyError:
self.error(400)
response['status'] = 'error'
response['msg'] = 'Missing uid (User id)'
return self.response.out.write(json.dumps(response))
try:
lobby_id = data['lid']
except KeyError:
self.error(400)
response['status'] = 'error'
response['msg'] = 'Missing lid (Lobby id)'
return self.response.out.write(json.dumps(response))
lobby = Lobby.query(Lobby.lobby_id == lobby_id).get()
if lobby is None:
logging.error("User (" + str(uid) +
") attempted to join non-existent Lobby (" +
str(lobby_id) + ").")
else:
ready = lobby.ready
# This is a new user who is ready
if uid not in ready:
lobby.ready.append(uid)
lobby.put()
response = {}
# The game is ready to be started
if len(lobby.ready) == REQ_USERS:
# TODO: Add logic for creating a Session here
session = Session(channel_id=lobby_id,
target_gold_amount="100",
user_ids=[])
for i in range(len(lobby.ready)):
session.user_ids.append(lobby.ready[i])
session.put()
response['type'] = "info"
response['data'] = {"ready": "true"}
pubnub.subscribe(lobby_id, callback)
pubnub.publish(lobby_id, response)
pubnub.unsubscribe(lobby_id)
self.response.out.write(json.dumps(response))
else:
response['type'] = "info"
response['data'] = {"ready": "false"}
pubnub.subscribe(lobby_id, callback)
pubnub.publish(lobby_id, callback)
pubnub.unsubscribe(lobby_id)
self.response.out.write(json.dumps(response))
