def socket():
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
while True:
try:
message = json.loads(ws.receive())
except:
break
if message is not None:
user_token = message["token"]
print(user_token)
user_email = database_helper.get_email_by_token(user_token)
print(user_email)
for logged_token in logged_user:
if user_email == database_helper.get_email_by_token(
logged_token):
prev_socket = logged_user[logged_token]
try:
prev_socket.send(
json.dumps({"message": "logged in elsewhere"}))
except:
pass
logged_user[user_token] = ws
return None
def get_user_data_by_token():
token = request.headers.get("Authorization")
if database_helper.get_email_by_token(token):
email = database_helper.get_email_by_token(token)
data = database_helper.get_user_data(email)
return jsonify(success=True, message="User data sent.", data=data)
else:
return jsonify(success=False, message="Token does not exist.")
def change_password():
data = request.get_json()
token = data['token']
old_password = data['old_password']
new_password = data['new_password']
if token != None:
email = database_helper.get_email_by_token(token)
email = email[0]
exists = database_helper.check_user_password(email, old_password)
if exists == False:
return jsonify({'success': False, 'message': "Wrong password"})
password_changed = database_helper.change_password(email, new_password)
if password_changed and exists:
return jsonify({
'success': True,
'message': "Password succesfully changed"
})
else:
return jsonify({
'success':
False,
'message':
"Something went wrong changing the password"
})
else:
return jsonify({'success': False, 'message': "You are not signed in."})
def ws_email(ws):
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
obj = ws.receive() # tokens
email = database_helper.get_email_by_token(obj)
if email is not None:
if email in logged_in_users: #logged in users is the dictionary
if not logged_in_users[email] == ws:
old_user = logged_in_users[email]
try:
print(old_user)
old_user.send("logout")
except:
print("test")
del logged_in_users[email]
logged_in_users[email] = ws
while True:
try:
ws.receive()
except:
return ""
return "asd"
def changePW():
data = request.get_json() #have to send in token as json string for now
oldPW = data['password']
newPW = data['newPW']
userToken = request.headers.get(
'token') # Got THROUGH request.header() instead
if (oldPW == newPW):
return jsonify(success=False, message="dont use same password")
if not validatePW(newPW):
return jsonify(success=False, message="use a longer password")
email = database_helper.get_email_by_token(userToken)
if email is None:
return jsonify(success=False, message="Cant find logged in user")
if database_helper.find_user(email, oldPW):
if database_helper.change_user_PW(email, newPW):
return jsonify(success=True, message="successfully changed pw")
else:
return jsonify(success=False, message="Couldnt change pw")
else:
return jsonify(success=False,
message="Password is wrong for that email")
def post_message():
token = request.form['token']
message = request.form['message']
toEmail = request.form['email']
fromEmail = database_helper.get_email_by_token(token)
toUser = database_helper.get_user_by_email(toEmail)
#check if fromEmail is signed in
if (fromEmail):
if (toUser is None):
return jsonify(success = False, message = "No such user.")
else:
try:
database_helper.post_message(fromEmail[0], toEmail, message);
# Update chart
if (toEmail == fromEmail[0]):
print "PM EQUALS............."
live_data(fromEmail[0], {"id": "update_chart", "online": -1, "sent": database_helper.get_num_messages_sent(fromEmail[0])[0], "received": database_helper.get_num_messages_received(toEmail)[0]})
else:
print "PM NO EQ............."
live_data(fromEmail[0], {"id": "update_chart", "online": -1, "sent": database_helper.get_num_messages_sent(fromEmail[0])[0], "received":-1})
live_data(toEmail, {"id": "update_chart", "online":-1, "sent": -1, "received": database_helper.get_num_messages_received(toEmail)[0]})
return jsonify(success = True, message = "Message posted.")
# Catching IntegrityError
except sqlite3.IntegrityError:
return jsonify(success = False, message = "This message is already posted.")
else:
return jsonify(success = False, message = "You are not logged in.")
def api():
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
token = ws.receive()
#print(token)
aux = database_helper.get_email_by_token(token)
email = aux[0]
#print(email)
if email in socketsTab:
oldSocket = socketsTab[email]
try:
oldSocket.send("sign_out")
except:
print("Failed sending sign_out")
del socketsTab[email]
socketsTab[email] = ws
print(socketsTab)
while True:
try:
token = ws.receive()
except:
return "Connection socket failed"
return "End if api"
def api():
if request.environ.get("wsgi.websocket"):
ws = request.environ["wsgi.websocket"]
token = ws.receive()
email = str(database_helper.get_email_by_token(token))
if email in active_sockets:
try:
active_sockets[email].send(json.dumps("logout"))
print("Active Websocket deleted: " + email)
except:
print("Active Websocket deleted (due to reload): " + email)
del active_sockets[email]
active_sockets[email] = ws
print("New Active Websocket added: " + email)
else:
active_sockets[email] = ws
print("New Active Websocket added: " + email)
try:
while True:
message = ws.receive()
if message == "close":
database_helper.remove_loggedIn(token)
break
except WebSocketError as e:
print("Client Disconnected Websocket")
return ""
def change_password():
data = request.get_json()
token = data['token']
old_password = data['old_password']
new_password = data['new_password']
if token != None and old_password != new_password and old_password != None and len(
new_password) >= 5:
email = database_helper.get_email_by_token(token)
email = email[0]
exists = database_helper.check_user_password(email, old_password)
password_changed = database_helper.change_password(email, new_password)
if password_changed and exists:
return jsonify({
'success': True,
'message': "Password succesfully changed"
})
else:
return jsonify({
'success':
False,
'message':
"Something went wrong changing the password"
})
else:
return jsonify({
'success':
False,
'message':
"Make sure that all fields are filled and new password has at least 5 letters"
})
def change_password():
token = request.json['token']
oldpassword = request.json['oldpassword']
newpassword = request.json['newpassword']
try:
email = database_helper.get_email_by_token(token)
except:
return json.dumps({
'success': False,
'message': "Token does not exist",
'data': ""
})
user = database_helper.get_user(email)
if user[0]['password'] == oldpassword:
result = database_helper.change_password(email, newpassword)
if result:
return json.dumps({
'success': result,
'message': "Password successfully changed",
'data': ""
})
else:
return json.dumps({
'success': result,
'message': "Password change failed",
'data': ""
})
else:
return json.dumps({
'success': False,
'message': "Old passwords do not match",
'data': ""
})
def get_email_token():
token = request.form['token']
email = database_helper.get_email_by_token(token)
if (email):
return jsonify(success = True, message = "There is your email.", data = email[0])
else:
return jsonify(success = False, message = "You are not logged in.")
def post_message():
token = request.headers.get('token')
receiverEmail = request.headers.get('email')
content = request.headers.get('content')
# Convert encoded message to unicode
def unescape(encodedText):
encodedText = urllib.unquote(encodedText)
encodedText = re.sub(r'%u([a-fA-F0-9]{4}|[a-fA-F0-9]{2})',
lambda m: unichr(int(m.group(1), 16)),
encodedText)
return encodedText
content = unescape(content)
if len(content) > 1000:
return json.dumps({
'success': False,
'message': "Form data missing or incorrect type."
})
authorEmail = db.get_email_by_token(token)
# Add message and notify users
new_message = db.add_user_message(receiverEmail, authorEmail, content)
print u"{}> {}: {}".format(new_message["owner"], new_message["author"],
new_message["content"])
sockets.notify_message(new_message)
return json.dumps({'success': True, 'message': "Message posted"})
def post_message():
token = request.json['token']
toemail = request.json['email']
message = request.json['message']
if toemail == "":
toemail = database_helper.get_email_by_token(token)
user = database_helper.get_user(toemail)
if len(user) == 0:
return json.dumps({
'success': False,
'message': "Recipient does not exist (postmessage)",
'data': ""
})
try:
fromemail = database_helper.get_email_by_token(token)
except:
return json.dumps({
'success': False,
'message': "Token does not exist",
'data': ""
})
result = database_helper.store_message(toemail, fromemail, message)
if result:
try:
ws_dic[toemail].send(
str(len(ws_dic.keys())) + ":" +
str(database_helper.number_of_messages(toemail)) + ":" +
str(database_helper.registered_users()))
except:
pass
return json.dumps({
'success': result,
'message': "You succesfully posted a message",
'data': message
})
else:
return json.dumps({
'success': result,
'message': "Your message was not posted",
'data': ""
})
def get_user_messages_by_token():
token = request.json['token']
try:
email = database_helper.get_email_by_token(token)
except:
return json.dumps({'success':False, 'message':"Token does not exist", 'data':""})
messages = database_helper.get_messages(email)
return json.dumps({'success':True, 'message':"", 'data':messages})
def wrap(*args, **kwargs):
token = request.headers.get('token')
if token and db.get_email_by_token(token):
return json.dumps({
'success': False,
'message': "You are already signed in."
})
else:
return f(*args, **kwargs)
def get_user_messages_by_email():
token = request.json['token']
email = database_helper.get_email_by_token(token)
response = {}
if email is None:
response['success'] = False
response['message'] = 'You are not signed in.'
else:
response = get_message_with_email(request.json['email'])
return json.dumps(response)
def get_user_data_by_token():
token = request.json['token']
response = {}
email = database_helper.get_email_by_token(token)
if email is None:
response['success'] = False
response['message'] = 'You are not signed in.'
else:
response = get_info_with_email(email, 'own')
return json.dumps(response)
def post_message():
email=request.args.get("email")
token=request.args.get("token")
mess =request.args.get("message")
if request.method == 'POST':
if dh.is_user_logged_in_token(token)==False:
return json.dumps([{'success': False, 'message': "Not signed in"}])
if dh.is_user(email)==False:
return json.dumps([{'success': False, 'message': "Illegal recipient"}])
return json.dumps([{'success': dh.post_msg(dh.get_email_by_token(token),email,mess),'message':"message sent"}])
def sign_out():
# Check if the user is siggned in
token = request.form['token']
email = database_helper.get_email_by_token(token)
# If it is:
if(email is not None):
database_helper.delete_logged_in_by_token(token)
return jsonify(success = True, message = "Successfully signed out.")
else:
return jsonify(success = False, message = "You are not logged in.")
def get_user_messages_by_token():
token = request.headers.get('token')
email = db.get_email_by_token(token)
messages = db.get_user_messages(email)
return json.dumps({
'success': True,
'message': "User messages retrieved.",
'data': messages
})
def change_password():
email=dh.get_email_by_token(request.args.get("token"))
old=request.args.get("old_password")
new=request.args.get("new_password")
if request.method == 'POST':
if dh.is_user_logged_in_email(email)==True:
if dh.get_password(email)==old:
dh.update_pass(email,new)
return json.dumps([{'success': True, 'message': "Password changed"}])
return json.dumps([{'success': False, 'message': "Wrong password"}])
return json.dumps([{'success': False, 'message': "User not signed in"}])
def echo_socket(ws):
token = ws.receive()
email = dh.get_email_by_token(token)
if email in opensockets:
opensockets[email].append(ws)
else:
opensockets[email] = [ws]
while not ws.closed:
ws.receive()
def get_user_messages_by_token():
token = request.headers.get("Authorization")
if database_helper.check_token(token):
email = database_helper.get_email_by_token(token)
if database_helper.get_user_messages(email):
messages = database_helper.get_user_messages(email)
return jsonify(success=True, message="Messages recieved!", data=messages)
else:
return jsonify(success=False, message="User has no messages yet.")
else:
return jsonify(success=False, message="Not logged in.")
def messagebytoken():
userToken = request.headers.get(
'token') # Got THROUGH request.header() instead
email = database_helper.get_email_by_token(userToken)
if email is None:
return jsonify(success=False,
message="Cant find email with that token")
else:
email = email[0]
result = database_helper.message_by_email(email)
return jsonify(result)
def get_user_messages_by_token():
input_data = request.get_json()
token = input_data['token']
email = database_helper.get_email_by_token(token)
if email is not None:
messages = database_helper.get_messages_by_email(email)
# if messages is not None:
return json.dumps({"success": True, "message": "User messages retrieved.", "data": messages})
# else:
# return json.dumps({"success": False, "message": "No message."})
else:
return json.dumps({"success": False, "message": "You are not signed in."})
def api():
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
while True:
msg = ws.receive()
if database_helper.check_token(msg):
email = database_helper.get_email_by_token(msg)
webSockets[email] = ws
else:
ws.close()
return "OK"
def sign_out():
# Check if the user is siggned in
token = request.form['token']
email = database_helper.get_email_by_token(token)
# If it is:
if(email is not None):
database_helper.delete_logged_in_by_token(token)
#Update chart
live_data(None, {"id": "update_chart", "online": database_helper.get_num_users_online()[0], "sent": -1, "received": -1});
return jsonify(success = True, message = "Successfully signed out.")
else:
return jsonify(success = False, message = "You are not logged in.")
def get_user_data_by_token():
input_data = request.get_json()
token = input_data['token']
email = database_helper.get_email_by_token(token)
if email:
user_data = database_helper.get_user_by_email(email)
if user_data:
return json.dumps({"success": True, "message": "User data retrieved.", "data": user_data})
else:
return json.dumps({"success": False, "message": "No such user."})
else:
return json.dumps({"success": False, "message": "You are not signed in."})
def echo_socket():
ws = request.environ['wsgi.websocket']
g.db = sqlite3.connect(DATABASE)
print "ws", ws
while True:
print "ws: ", ws
token = ws.receive()
print "token:", token
email = database_helper.get_email_by_token(token)
print "email:", email
socket_connections[email[0]] = ws
def get_user_messages_by_token():
token = request.form['token']
email = database_helper.get_email_by_token(token)
# Check if the user is loggedin
if (email is None):
return jsonify(success = False, message = "You are not logged in.")
else:
user = database_helper.get_user_by_email(email[0])
if (user is None):
return jsonify(success = False, message = "No such user.")
else:
messages = database_helper.get_messages_by_email(email[0])
return jsonify(success = True, message = "User messages retrieved.", data = messages)
def sign_out():
token = request.headers.get("Authorization")
email = database_helper.get_email_by_token(token)
if email in webSockets:
del webSockets[email]
if email and database_helper.remove_token_user(token):
return jsonify(success=True, message="Logged out!")
else:
return jsonify(success=False,
message="Token does not exist/Already signed out?")
def change_password():
input_data = request.get_json()
token = input_data['token']
email = database_helper.get_email_by_token(token)
if email:
# user logged in
user_data = database_helper.get_user_by_email(email)
if input_data['oldPassword'] == user_data['password']:
database_helper.change_password(email, input_data['newPassword'])
return json.dumps({"success": True, "message": "Password changed."})
else:
return json.dumps({"success": False, "message": "Wrong password."})
else:
return json.dumps({"success": False, "message": "You are not logged in."})
def get_user_messages_by_email():
token = request.json['token']
toemail = request.json['email']
try:
fromemail = database_helper.get_email_by_token(token)
except:
return json.dumps({'success':False, 'message':"Token does not exist", 'data':""})
user = database_helper.get_user(toemail)
if len(user) == 0:
return json.dumps({'success':False, 'message':"Recipient does not exist", 'data':""})
messages = database_helper.get_messages(toemail)
return json.dumps({'success':True, 'message':"", 'data':messages})
def api():
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
while True:
msg = ws.receive()
message = json.loads(msg)
if message["id"] == "token":
if database_helper.check_token(message["token"]):
email = database_helper.get_email_by_token(message["token"])
webSockets[email] = ws
else:
ws.close()
elif message["id"] == "chartUpdate":
if database_helper.check_token(message["token"]):
email = database_helper.get_email_by_token(message["token"])
chartsUpdate(email)
else:
ws.close()
else:
ws.close()
return "OK"
def get_user_data_by_token():
token = request.json['token']
try:
email = database_helper.get_email_by_token(token)
except:
return json.dumps({'success':False, 'message':"Token does not exist", 'data':""})
user = database_helper.get_user(email)
if len(user) != 0:
user = user[0]
del user['password']
return json.dumps({'success':True, 'message':"", 'data':user})
else:
return json.dumps({'success':False, 'message':"User does not exist", 'data':""})
def change_password():
token = request.headers.get('token')
old_password = request.headers.get('oldPassword')
new_password = request.headers.get('newPassword')
email = db.get_email_by_token(token)
user = db.get_user(email)
# Compare encrypted password
if not sha256_crypt.verify(str(old_password), user['password']):
return json.dumps({'success': False, 'message': "Wrong password."})
encrypted_password = sha256_crypt.encrypt(unicode(new_password))
db.set_password(email, encrypted_password)
return json.dumps({'success': True, 'message': "Password changed."})
def socket():
ws = request.environ.get('wsgi.websocket')
if not ws:
print "! WebSocket failed to initialize"
return "WebSocket failed to initialize"
token, email = None, None
try:
# Await client confirmation
data = ws.receive()
try:
message = json.loads(data)
token = message['token']
email = message['email']
except:
raise WebSocketError("WebSocket data missing or incorrect type")
if not db.get_email_by_token(token):
ws.send(
json.dumps({
'success': False,
'message': "You are not signed in."
}))
raise WebSocketError("User is not signed in")
# Save connection
sockets.add(token, email, ws)
print "+ Connected with:", email, '({})'.format(request.remote_addr)
sockets.success(token, "Connection established.")
sockets.update_online_status()
# Await client closing connection
while True:
data = ws.receive()
if data == None:
sockets.remove(token)
break
except WebSocketError as error:
print "! WebSocketError:", error
finally:
print "- Disconnected from:", email
ws.close()
sockets.update_online_status()
return ''
def sign_out():
token = request.json['token']
response = {}
email = database_helper.get_email_by_token(token)
if email is not None:
response['success'] = True
response['message'] = 'Successfully signed out.'
database_helper.delete_token(token)
if email in connected_users:
connected_users[email].close()
connected_users.pop(email, None)
send_live_data()
else:
response['success'] = False
response['message'] = 'You are not signed in.'
return json.dumps(response)
def change_password():
token = request.form['token']
old_password = request.form['oldpassword']
new_password = request.form['newpassword']
email = database_helper.get_email_by_token(token)
# Check if the user exists:
if (email is not None):
password = database_helper.get_password(email[0])
# Check if the passwords match
if (password[0] == old_password):
database_helper.set_password(email[0], new_password)
return jsonify(success = True, message = "Password changed.")
else:
return jsonify(success = False, message = "Wrong password.")
else:
return jsonify(success = False, message = "You are not logged in.")
def get_stats():
token = request.form['token']
# Get the data from db
email = database_helper.get_email_by_token(token)
if email:
print email;
# get user statistics
sent_ = database_helper.get_num_messages_sent(email[0])
received_ = database_helper.get_num_messages_received(email[0])
online_ = database_helper.get_num_users_online()
u={}
u["sent"] = sent_[0]
u["received"] = received_[0]
u["online"] = online_[0]
return jsonify(success = True, message = "This is the data for chart.", data = u)
else:
return jsonify(success = False, message = "You are not logged in.")
def post_message():
token = request.form['token']
message = request.form['message']
toEmail = request.form['email']
fromEmail = database_helper.get_email_by_token(token)
toUser = database_helper.get_user_by_email(toEmail)
#check if fromEmail is signed in
if (fromEmail):
if (toUser is None):
return jsonify(success = False, message = "No such user.")
else:
try:
database_helper.post_message(fromEmail[0], toEmail, message);
return jsonify(success = True, message = "Message posted.")
# Catching IntegrityError
except sqlite3.IntegrityError:
return jsonify(success = False, message = "This message is already posted.")
else:
return jsonify(success = False, message = "You are not logged in.")
def get_user_data_by_token():
token = request.form['token']
#Check if there is such a user
email = database_helper.get_email_by_token(token)
if (email is not None):
user = database_helper.get_user_by_email(email[0])
if (user is None):
return jsonify(success = False, message = "No such user.")
else:
u = {}
u['email'] = user[0]
u['firstname'] = user[1]
u['familyname'] = user[2]
u['gender'] = user[3]
u['city'] = user[4]
u['country'] = user[5]
return jsonify(success = True, message = "User data retrieved.", data = u)
else:
return jsonify(success = False, message = "You are not logged in.")
def change_password():
data = request.json
token = data['token']
old_password = data['old_password']
new_password = data['new_password']
email = database_helper.get_email_by_token(token)
response = {}
if email is None:
response['success'] = False
response['message'] = 'You are not signed in.'
else:
if database_helper.check_user(email, old_password):
salt = str(binascii.hexlify(os.urandom(16)))
hnew_password = str(binascii.hexlify(hashlib.pbkdf2_hmac('sha256', str(new_password), salt, 100000)))
database_helper.update_password(email, hnew_password, salt)
response['success'] = True
response['message'] = 'Password changed.'
else:
response['success'] = False
response['message'] = 'Wrong password.'
return json.dumps(response)
def post_message():
response = {}
data = request.json
email = database_helper.get_email_by_token(data['token'])
if email is None:
response['success'] = False
response['message'] = 'You are not signed in.'
else:
message = data['message']
target_email = data['email']
if target_email == 'own':
target_email = email
if database_helper.check_user(target_email,'','exist'):
database_helper.post_message(email, target_email,message)
response['success'] = True
response['message'] = 'Message posted'
send_live_data()
else:
response['success'] = False
response['message'] = 'No such user.'
return json.dumps(response)
def websocket():
print "INTO WEBSOCKET"
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
while True:
try:
msg = ws.receive()
message = json.loads(msg)
# To start ws
if message["id"] == "start":
print "WS Start"
# To kick the user from the previous session
if message["id"] == "email":
print "MESSAGE IS EMAIL"
if message["email"] in socket_list:
socket_list[message["email"]].send(json.dumps(dict(id = "sign_out")))
print ""+json.dumps(dict(id = "sign_out"))
socket_list[message["email"]] = ws
# To update the chart
elif message["id"] == "update_chart":
token = message["token"]
email = database_helper.get_email_by_token(token)
print email;
# get user statistics
sent_ = database_helper.get_num_messages_sent(email[0])
received_ = database_helper.get_num_messages_received(email[0])
online_ = database_helper.get_num_users_online()
ws.send(json.dumps(dict(id = "update_chart", sent = sent_[0], received = received_[0], online = online_[0])))
except WebSocketError as e:
print(str(e))
return
def get_user_messages_by_token():
token=request.args.get("token")
if request.method == 'GET':
if dh.is_user(dh.get_email_by_token(token))==False:
return json.dumps([{'success': False, 'message': "No such user"}])
return json.dumps([{'success': True, 'message': "Success",'data':dh.messages_by_token(token)}])
