def gather_social_network_data():
arg = request.args.to_dict()
token = arg.get('token', None)
email = logged_users_by_token.get(token, None)
if not email:
response = {'success': False, 'message': 'You are not signed in.'}
else:
# We get all messages from and to this user
messages = database_helper.get_messages(email_from=email)
messages += database_helper.get_messages(email_to=email)
# We decide what are the users to show
nodes = set()
for msg in messages:
nodes.add(msg['email_from'])
nodes.add(msg['email_to'])
#nodes = list(nodes)
nodes = [{'id': id} for id in nodes]
# We collect all the messages between the users we want to show
for user_a in nodes:
if user_a['id'] == email: continue
for user_b in nodes:
if user_a['id'] >= user_b['id'] or user_b['id'] == email:
continue
messages += database_helper.get_messages(
email_from=user_a['id'], email_to=user_b['id'])
messages += database_helper.get_messages(
email_from=user_b['id'], email_to=user_a['id'])
# We create links between users weighted by the number of messages they have
links_dict = {}
max_weight = -1
for msg in messages:
who = (min(msg['email_from'],
msg['email_to']), max(msg['email_from'],
msg['email_to']))
links_dict[who] = links_dict.get(who, 0) + 1
max_weight = max(max_weight, links_dict[who])
# We finally create a list with all the links
links = [{
'source': who[0],
'target': who[1],
'value': weight / max_weight
} for who, weight in links_dict.iteritems()]
response = {'nodes': nodes, 'links': links}
return json.dumps(response)
def get_user_messages_by_email():
user_email = request.args.get("user_email")
email = request.args.get("email")
time_stamp = request.args.get("time")
blob = user_email + email
if check_hash(blob, email, request.args.get("hash"), time_stamp):
return json.dumps({
'success':
False,
'message':
'You are trying to hack a user. You should be ashamed of yourself!'
})
token = database_helper.get_token(email)
if token is None:
return json.dumps({
'success': False,
'message': 'User is not logged in'
})
else:
data = database_helper.get_messages(user_email)
retData = []
for d in data:
retData.append({"writer": d[1], "content": d[0]})
return json.dumps({
'success': True,
'message': 'Data retrieval successful',
"data": retData
})
def message_by_email(token, email):
if database_helper.find_inlogged(token) is not None:
if database_helper.find_user(email) is not None:
messages = database_helper.get_messages(email)
if messages is not None:
sum = ""
for message in messages:
#do we have to add the senders email?
sum += message[0] + "\n"
return json.dumps({
"success": True,
"message": "User messages retrieved",
"data": sum
})
return json.dumps({
"success": True,
"message": "No messages on this users profile",
"data": ""
})
else:
return json.dumps({"success": False, "message": "No such user"})
else:
return json.dumps({
"success": False,
"message": "You are not signed in"
})
def get_user_messages_by_token(token):
email = dh.email_from_token(token)
messages = dh.get_messages(email[0])
return json.dumps({
"message": "Messages to the user",
"data": messages
}), 200
def get_messages_by_email():
body = json.loads(request.data.decode("utf-8"))
token = body['token']
user = database_helper.email_from_token(token)
if user == None:
return _return_json_message(False, "User not signed in")
result = database_helper.get_messages(body['email'])
return _return_json_message(True, "Successfully found messages", result)
def get_user_messages_by_email(email, token):
token_email = dh.email_from_token(token)
if token_email[0] is None:
return json.dumps({"message": "User not logged in"}), 501
messages = dh.get_messages(email)
return json.dumps({
"message": "Messages to the user",
"data": messages
}), 200
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 getUserMessageByEmail():
token = request.form['token']
email = request.form['email']
if checkLogin(token):
user = database_helper.get_messages(email)
if not user:
return jsonify(success=True, message="No messages for user")
else:
return jsonify(success=True, message="User data retrieved.", data=user)
def get_user_messages_by_email(token, email):
signed_in = database_helper.user_signedin(token)
if email is None or signed_in is None:
return json.dumps({"success": False, "message": "You are not signed in."})
data = database_helper.get_messages(email)
if data is None:
return json.dumps({"success": False, "message": "No such user."})
return json.dumps({"success": True, "message": "User messages retrieved..", "data": data})
def get_user_messages_by_token():
token = request.values.get('token')
user = database_helper.get_user_by_token(token)
if len(user) > 0:
messages = database_helper.get_messages(user[0][0])
if len(messages) > 0:
return jsonify(success = True, data = messages, message = "Successfully got user data")
else:
return jsonify(success = False, message = "User has no messages")
else:
return jsonify(success = False, message = "You're not signed in")
def get_user_messages_by_token():
token = request.values.get("token")
user = database_helper.get_user_by_token(token)
if len(user) > 0:
messages = database_helper.get_messages(user[0][0])
if len(messages) > 0:
return json.dumps({"success": True, "data": messages, "message": "Successfully got user data"})
else:
return jsonify(success=False, message="User has no messages")
else:
return jsonify(success=False, message="You're not signed in")
def get_message_with_email(email):
response = {}
if database_helper.check_user(email,'','exist'):
messages = database_helper.get_messages(email)
response['success'] = True
response['message'] = 'User messages retrieved.'
response['data'] = messages
send_live_data()
else:
response['success'] = False
response['message'] = 'No such user.'
return response
def getUserMessageByToken():
token = request.form['token']
email = database_helper.get_email(token)
email = email[0]
if not email:
return jsonify(success=False, message="Error!")
else:
messages = database_helper.get_messages(email)
if not messages:
return jsonify(success=True, message="No messages for user")
else:
return jsonify(success=True, message="User messages retrieved.", data=messages)
def get_user_messages_by_email(token, email, hashvalue):
# Create empty dictionary for storing return data
data = {}
# Check if user with given email exists
dataset = database_helper.get_user(email)
if (dataset == None):
# Pass error data to dictionary
data['success'] = False
data['message'] = 'No user with email ' + email
# return the dataset as json data
return json.dumps(data)
# Create empty list for storing messages dictionaries
messages = []
# Check if user is logged in
if (is_logged_in(token) == True):
# Get user
logged_in_user = get_user_by_token(token)
privatekey = logged_in_user['privatekey']
# Compare hash values
if (hashvalue != hash_data(privatekey + token)):
data['success'] = False
data['message'] = 'Error in hash value'
return json.dumps(data)
# Get Messages for searched user and append them to messages dict
result = database_helper.get_messages(email)
count = 0
for element in result:
message = {}
message['sender_email'] = element[1]
message['receiver_email'] = element[2]
message['message'] = element[3]
message['messageid'] = "getusermessagesbyemail" + str(count)
messages.append(message)
count = count + 1
# Pass success data to dictionary
data['success'] = True
data['message'] = 'Successfully retrieved messages'
data['data'] = messages
else:
# Pass error data to dictionary
data['success'] = False
data['message'] = 'Not able to get messages'
# return the dataset as json data
return json.dumps(data)
def get_user_messages_by_email(token, email) :
if database_helper.get_active(token) == None :
return json.dumps({"success": False, "message" : "You are not signed in."})
if database_helper.get_user_by_email(email) == None :
return json.dumps({"success": False, "message" : "No such user."})
messages = database_helper.get_messages(email)
message_list = []
for (recipient, sender, time, message) in messages :
json_message = {"sender" : sender, "time" : time, "message" : message}
message_list.append(json_message)
return json.dumps({"success": True, "message" : "User messages retrieved", "data" : message_list})
def get_user_messages_helper(token, email):
if database_helper.get_active(token) == None :
return json.dumps({"success": False, "message" : "You are not signed in."})
if database_helper.get_user_by_email(email) == None :
return json.dumps({"success": False, "message" : "No such user."})
messages = database_helper.get_messages(email)
message_list = []
for (recipient, sender, time, message) in messages :
json_message = {"sender" : sender, "time" : time, "message" : message}
message_list.append(json_message)
return json.dumps({"success": True, "message" : "User messages retrieved", "data" : message_list})
def get_user_messages_by_email(token, email):
if (database_helper.logged_in_users(token)):
if (database_helper.check_user_by_email(email)):
match = database_helper.get_messages(email)
print match
#return {"success": "true", "message": "User messages retrieved.", "data": match}
return "User messages retrieved: " + database_helper.list_to_string(match)
else:
#return {"success": "false", "message": "No such user."}
return "No such user"
else:
#return {"success": "false", "message": "You are not signed in."}
return "You are not signed 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 get_user_messages_by_token():
try:
header = request.headers
print(header)
token = header["token"]
email = loggedInUsers[token]
except KeyError as e:
response = jsonify({"success": False, "message": "Missing data."})
return response
updateStats(email)
response = database_helper.get_messages(email)
return response
def get_user_messages_by_token():
arg = request.args.to_dict()
token = arg.get('token', None)
email = logged_users_by_token.get(token, None)
if email:
response = database_helper.get_messages(email_to=email)
response = {
'success': True,
'message': 'User messages retrieved.',
'data': response
}
else:
response = {'success': False, 'message': 'You are not signed in.'}
return json.dumps(response)
def getUserMessageByToken():
token = request.form['token']
print "TOKEN I getUserMessagebyToken: ", token
token = verify_token(token)
print "token efter verify: ", token
email = database_helper.get_email(token)
email = email[0]
print "EMAIL I GETUSERMESSSAGEBYTOKEN: ", email
if not email:
return jsonify(success=False, message="Error!")
else:
messages = database_helper.get_messages(email)
if not messages:
return jsonify(success=True, message="No messages for user")
else:
return jsonify(success=True, message="User messages retrieved.", data=messages)
def get_user_messages_by_email(email):
try:
header = request.headers
token = header["token"]
if token not in loggedInUsers.keys():
raise KeyError
except KeyError as e:
response = jsonify({"success": False, "message": "Missing data."})
return response
updateStats(email)
response = database_helper.get_messages(email)
return response
def get_my_messages():
hashedData = request.headers.get('hashedData')
myEmail = request.json['myEmail']
serverHash = server_hash(myEmail, myEmail)
if (hashedData == serverHash):
result = database_helper.get_messages(myEmail)
if (result != []):
return json.dumps({
"success": True,
"message": "Messages collected",
"data": result
})
else:
return json.dumps({"success": False, "message": "No Messages"})
else:
return json.dumps({
"success": False,
"message": "You have to be logged in to see messages"
})
def updateStats(email):
print("hej\n\n")
print(int(os.environ.get("PORT", 5000)))
print("hej\n\n")
try:
response = database_helper.get_messages(email)
response = response.get_json()
print(response)
response = response["messages"]
message_count = len(response)
loggedCount = len(loggedInUsers)
regCount = database_helper.get_user_count()
message = json.dumps({"message_count" : message_count,
"loggedInCount" : loggedCount,
"registredCount" : regCount})
user = loggedInConnections[email]
ws = user[2]
ws.send(message);
except KeyError:
print("I updateStats: Keyerror, förmodligen websocket som saknas")
def get_user_messages_by_token():
token = request.args.get("token")
time_stamp = request.args.get("time")
if check_hash("", database_helper.get_email(token),
request.args.get("hash"), time_stamp):
return json.dumps({
'success':
False,
'message':
'You are trying to hack a user. You should be ashamed of yourself!'
})
email = database_helper.get_email(token)
if email is None:
return json.dumps({
'success': False,
'message': 'User is not logged in'
})
else:
data = database_helper.get_messages(email)
return json.dumps({
'success': True,
'message': 'Data retrieval successful',
"data": data
})
