def updateUser(self, uid, args):
dao = usersDAO()
if not dao.getUserById(uid):
return jsonify(Error="User not found."), 404
else:
if len(args) != 5:
return jsonify(Error="Malformed update request"), 400
else:
ufirstname = args['ufirstname']
ulastname = args['ulastname']
uuemail = args['uemail']
uusername = args['uusername']
upassword = args['upassword']
if ufirstname and ulastname and uuemail and uusername and upassword:
dao.updateUser(uid, ufirstname, ulastname, uuemail,
uusername,
upassword) # NEEDS TO BE IMPLEMENTED
result = self.build_user_attributes(
uid, ufirstname, ulastname, uuemail, uusername,
upassword)
return jsonify(User=result), 200
else:
return jsonify(
Error="Unexpected attributes in update request"), 400
def searchUsers(self, args):
print("entro?")
print(args)
username = None
id = None
try:
username = args["uusername"]
except:
pass
try:
id = args["uid"]
except:
pass
dao = usersDAO()
users_list = []
if (len(args) == 1) and username:
users_list = dao.getUsersByUsername(username)
print(users_list)
elif (len(args) == 1) and id:
users_list = dao.getUserById2(id)
else:
return jsonify(Error="Malformed query string"), 400
result_list = self.build_user_dict(users_list)
return jsonify(Users=result_list)
def addContactToChatJson(self, cid, form):
print(cid)
dao = chatsDAO()
dao2 = usersDAO()
if not dao.getChatById(cid):
return jsonify(Error="Chat with id:" + str(cid) +
" not found."), 404
if len(form) != 3:
return jsonify(Error="Malformed add contact to chat request"), 400
ufirstname = form['ufirstname']
ulastname = form['ulastname']
uemail = form['uemail']
if ufirstname and ulastname and uemail:
row = dao2.getUserByEmail(uemail)
if not row:
return jsonify(Error="User with email: " + str(uemail) +
" not found."), 404
uid = row[0]
if dao.isMember(cid, uid):
return jsonify(Error="User with email: " + str(uemail) +
" is already a member of chat with id: " +
str(cid))
if dao.addMemberToChat(cid, uid) == 1:
result = self.build_contact_attributes(ufirstname, ulastname,
uemail)
return jsonify(AddedContactToChat=result), 200
else:
return jsonify(
Error="Unexpected attributes in add contact to chat request"
), 400
def register_user(self, form):
dao = usersDAO()
if len(form) != 5:
return jsonify(
REGISTER="Invalid registration. Not enough parameters"), 401
ufirstname = form['ufirstname']
ulastname = form['ulastname']
uemail = form['uemail']
uusername = form['uusername']
upassword = form['upassword']
if ufirstname and ulastname and uemail and uusername and upassword:
row = dao.insertUser(ufirstname, ulastname, uemail, uusername,
upassword)
if not row or dao.getUserByEmail(uemail) or dao.getUsersByUsername(
uusername):
return jsonify(REGISTER="UNSUCCESSFUL REGISTER"), 401
else:
lid = dao.insertToLogin(uusername, upassword)
dao.insertToValidates(lid, row)
return jsonify(REGISTER="USER " + uusername +
" REGISTERED"), 200
else:
return jsonify(
Error="Unexpected attributes in update request"), 400
def insertPost(self, form):
print("form: ", form)
if len(form) != 8:
return jsonify(Error="Malformed post request"), 400
else:
pid = form['pid']
p_user = form['p_user']
p_photo = form['p_photo']
p_message = form['p_ message']
p_likes = form['p_likes']
p_dislikes = form['p_dislikes']
p_date = form['p_date']
p_replies = form['p_replies']
if pid and p_user and p_photo and p_message and p_likes and p_dislikes and p_date and p_replies:
dao = usersDAO()
pid = dao.insert(pid, p_user, p_photo, p_message, p_likes,
p_dislikes, p_date, p_replies)
result = self.build_user_attributes(pid, p_user, p_photo,
p_message, p_likes,
p_dislikes, p_date,
p_replies)
return jsonify(User=result), 201
else:
return jsonify(
Error="Unexpected attributes in post request"), 400
def getUserById(self, uid):
dao = usersDAO()
row = dao.getUserById(uid)
if not row:
return jsonify(Error="User Not Found"), 404
else:
user = self.build_user_dict(row)
return jsonify(User=user)
def getAllPost(self):
dao = usersDAO()
posts_list = dao.getAllPosts()
result_list = []
for row in posts_list:
result = self.build_post_dict(row)
result_list.append(result)
return jsonify(Posts=result_list)
def getPostById(self, pid):
dao = usersDAO()
row = dao.getPostById(pid)
if not row:
return jsonify(Error="Post Not Found"), 404
else:
post = self.build_user_dict(row)
return jsonify(Post=post)
def getStatByChoice(self, form):
stat = form['stat']
dao = statsDAO()
if len(form) == 2:
uid = form['uid']
if stat == "postsperdaybyuser":
dao2 = usersDAO()
if not dao2.getUserById(uid):
return jsonify(Error="User " + str(uid) +
" not found"), 404
dates = dao.getDatesOfPostsPerDayByUser(uid)
if not dates:
return jsonify(Error="No Posts found for user: "******"Invalid statistic per user operation"), 404
if len(form) == 1:
if stat == "mostactivityofusers":
dates = dao.getPostDatesAvailable()
if not dates:
return jsonify(Error="No Posts found"), 400
return jsonify(MostActiveUsersPerDates=dao.
getMostActivityOfUsers(dates)), 200
elif stat == "repliesperdates":
dates = dao.getAvailableRepliesDates()
if not dates:
return jsonify(Error="No replies found"), 400
return jsonify(
RepliesPerDates=dao.getRepliesPerDates(dates)), 200
elif stat == "postsperdates":
dates = dao.getPostDatesAvailable()
if not dates:
return jsonify(Error="No Posts found"), 400
return jsonify(PostsPerDates=dao.getPostsPerDates(dates)), 200
elif stat == "likesperdates":
dates = dao.getReactionsDatesAvailable()
if not dates:
return jsonify(Error="No reactions found"), 400
return jsonify(LikesPerDates=dao.getLikesPerDate(dates)), 200
elif stat == "dislikesperdates":
dates = dao.getReactionsDatesAvailable()
if not dates:
return jsonify(Error="No reactions found"), 400
return jsonify(Dislikes=dao.getDisikesPerDate(dates)), 200
elif stat == "trending":
dates = dao.getAvailableTrendingDates()
if not dates:
return jsonify(Error="No hashtags found"), 400
return jsonify(
TrendingHashtags=dao.getTrendringHashtags(dates)), 200
return jsonify(Error="Invalid statistic operation"), 404
return jsonify(Error="Malformed stats request"), 400
def getAllUsers(self):
dao = usersDAO()
users_list = dao.getAllUsers()
result_list = []
for row in users_list:
print(row)
result = self.build_user_dict(row)
result_list.append(result)
print(result_list)
return jsonify(Users=result_list)
def __init__(self, cid, cname, cadmin):
dao = usersDAO()
self.cid = cid
self.cname = cname
self.cmembers = [cadmin]
self.postlist = []
self.cadmin = cadmin
def getIdByUsername(self, args):
dao = usersDAO()
username = args['username']
user = dao.getUsersByUsername(username)
if not user:
return jsonify(Error="No user exists with that username")
else:
return jsonify(ID=user[0])
def deleteUser(self, uid):
dao = usersDAO()
row = dao.getUserById(uid)
if not row:
return jsonify(Error="User " + str(uid) + " not found."), 404
else:
dao.deleteUserFromAllContacts(uid)
if dao.deleteUserFromValidates(uid) == 1 and dao.deleteUser(
uid) == 1 and dao.deleteUserFromLogin(row[4], row[5]) == 1:
return jsonify(DeletedUser=self.build_user_dict(row)), 200
else:
return jsonify(Error="Delete failed"), 404
def getContactsById(self, uid):
dao = usersDAO()
contact_list = dao.getContactListFromUserId(uid)
print("THIS IS CONTACT LIST")
print(contact_list)
result_list = []
if not contact_list:
return jsonify(Error="User Not Found"), 404
else:
for row in contact_list:
user = self.build_contact_dict(row)
result_list.append(user)
return jsonify(ContactList=result_list)
def insertUserJson(self, json):
uname = json['uname']
username = json['username']
password = json['password']
uemail = json['uemail']
if uname and username and password and uemail:
dao = usersDAO()
uid = dao.insert(uname, username, password, uemail)
result = self.build_user_attributes(uid, uname, username, password,
uemail)
return jsonify(User=result), 201
else:
return jsonify(Error="Unexpected attributes in post request"), 400
def getAllChatsOfUser(self, uid):
dao2 = usersDAO()
if not dao2.getUserById(uid):
return jsonify(Error="User " + str(uid) + " not found"), 404
dao = chatsDAO()
chat_list = dao.getAllChatsOfUser(uid)
if not chat_list:
return jsonify(NoChats="User " + str(uid) +
" is not a member of any chat."), 404
result_list = []
for row in chat_list:
print(row)
result = self.build_chats_dict(row)
result_list.append(result)
return jsonify(Chats=result_list)
def validate_login(self, form):
dao = usersDAO()
if len(form) != 2:
return jsonify(ERROR="Invalid login.")
else:
uusername = form['uusername']
upassword = form['upassword']
row = dao.validate_login(uusername, upassword)
if not row:
return jsonify(LOGIN="******"), 401
else:
return jsonify(LOGIN="******" + uusername +
" SUCCESSFULLY LOGGED IN."), 200
def deleteContact(self, uid, form): # by contact id OR by uusername
dao = usersDAO()
if not dao.getUserById(uid): # Checks if user is valid.
return jsonify(Error="User " + str(uid) + " not found"), 404
if len(form) != 1:
return jsonify(Error="Malformed delete contact request"), 400
else:
cid = None
uusername = None
try:
uusername = form['uusername']
except:
pass
try:
cid = form['cid']
except:
pass
if cid:
row = dao.getContactFromUserId(uid, cid)
if not row:
return jsonify(Error="User with id " + str(uid) +
" does NOT have contact with id " +
str(cid)), 404
if dao.deleteUserFromContactList(uid, cid) == 1:
result = self.build_contact_attributes(row)
return jsonify(DeleteContact=result), 200
else:
return jsonify(Error="Delete contact failed."), 400
elif uusername:
row = dao.getContactFromUsername(uid, uusername)
if not row:
return jsonify(Error="There is no user with username: "******"User with id " + str(uid) +
" does NOT have contact with username " +
str(uusername)), 404
if dao.deleteUserFromContactList(uid, cid) == 1:
result = self.build_contact_attributes(row)
return jsonify(DeletedContact=result), 200
else:
return jsonify(Error="Delete contact failed."), 400
else:
return jsonify(Error="Malformed delete request"), 400
def searchPosts(self, args):
p_chat = args.get("p_chat")
p_date = args.get("p_date")
dao = usersDAO()
post_list = []
if (len(args) == 2) and p_chat and p_date:
post_list = dao.getPostsByChatAndDate(p_chat, p_date)
elif (len(args) == 1) and p_chat:
post_list = dao.getPostsByChat(p_chat)
elif (len(args) == 1) and p_date:
post_list = dao.getPostsByDate(p_date)
else:
return jsonify(Error="Malformed query string"), 400
result_list = []
for row in post_list:
result = self.build_post_dict(row)
result_list.append(result)
return jsonify(Posts=result_list)
def getUsersForAdding(self, cid, uid):
dao = chatsDAO()
udao = usersDAO()
if not dao.getChatById(cid):
return jsonify(Error="Chat not found."), 404
elif not udao.getUserById(uid):
return jsonify(Error="User not found."), 404
else:
chat_members = dao.getAllUsersFromChat(cid)
if len(chat_members) == 1:
return jsonify(Error="Only user in chat is admin.")
contact_list = udao.getContactListFromUserId(uid)
print(chat_members)
print(contact_list)
contacts = []
for contact in contact_list:
if not contact in chat_members:
contacts.append(contact)
print(contacts)
if len(contacts) > 0:
result = []
for row in contacts:
result.append(self.build_users_from_chat_dict(row))
print(result)
return jsonify(Contacts=result), 200
else:
return jsonify(
Error="All users in contact list already in chat.")
def deleteUserFromChat(self, cid, admin_id, uid):
dao = chatsDAO()
dao2 = usersDAO()
if not dao.getChatById(cid):
return jsonify(Error="Chat with id: " + str(cid) +
" not found."), 404
if not dao2.getUserById(uid):
return jsonify(Error="User with id: " + str(uid) +
" not found."), 404
if not dao.isMember(cid, uid):
return jsonify(Error="User with id: " + str(uid) +
" is not a member of chat with id: " + str(cid))
if not dao.isAdmin(cid, admin_id):
return jsonify(Error="You are not admin")
if admin_id == uid:
return jsonify(Error="You cannot remove yourself from the chat.")
if dao.deleteUserFromChat(cid, uid) == 1:
return jsonify(DeletedChatMember="User: "******" from Chat " + str(cid) + " was deleted."), 200
else:
return jsonify(Error="Delete user: "******" from chat: " +
str(cid) + " was unsuccessful"), 400
def addContactToChat(self, form):
dao = chatsDAO()
dao2 = usersDAO()
cid = form["cid"]
contact_id = form["contact_id"]
if not dao.getChatById(cid):
return jsonify(Error="Chat with id: " + str(cid) +
" not found."), 404
if not dao2.getUserById(contact_id):
return jsonify(Error="User with contact id: " + str(contact_id) +
" not found."), 404
if dao.isMember(cid, contact_id):
return jsonify(Error="User with contact id: " + str(contact_id) +
" is already a member of chat with id: " + str(cid))
if dao.addMemberToChat(cid, contact_id) == 1:
return jsonify(AddedChatMember="User with contact id: " +
str(contact_id) + " was added to Chat: " +
str(cid)), 200
else:
return jsonify(Error="Adding contact with id: " + str(contact_id) +
" to chat: " + str(cid) + " was unsuccessful"), 400
def getUserByIdORUsername(self, form):
uusername = None
uid = None
dao = usersDAO()
try:
uusername = form["uusername"]
result = dao.getUsersByUsername(uusername)
if not result:
return jsonify(Error="User not found"), 404
result = self.build_user_dict(result)
return jsonify(User=result)
except:
pass
try:
uid = form["uid"]
result = dao.getUserById(uid)
if not result:
return jsonify(Error="User not found"), 404
result = self.build_user_dict(result)
return jsonify(User=result)
except:
return jsonify(Error="Malformed query string"), 400
def insertUser(self, form):
if len(form) != 5:
return jsonify(Error="Malformed insert user request"), 400
else:
ufirstname = form['ufirstname']
ulastname = form['ulastname']
uemail = form['uemail']
uusername = form['uusername']
upassword = form['upassword']
if ufirstname and ulastname and uemail and uusername and upassword:
dao = usersDAO()
if dao.getUserByEmail(uemail):
return jsonify(
Error=
"User with that email already exists. Please try a different one."
), 400
elif dao.getUsersByUsername(uusername):
return jsonify(
Error=
"User with that username already exists. Please try a different one."
), 400
uid = dao.insertUser(ufirstname, ulastname, uemail, uusername,
upassword)
login_id = dao.insertToLogin(uusername, upassword)
if dao.insertToValidates(login_id, uid) == 1:
result = self.build_user_attributes(
uid, ufirstname, ulastname, uemail, uusername,
upassword)
return jsonify(User=result), 201
else:
return jsonify(
Error="User insertion failed horribly."), 400
else:
return jsonify(
Error="Unexpected attributes in insert user request"), 400
def addToContactList(self, uid, form):
dao = usersDAO()
if not dao.getUserById(uid):
return jsonify(Error="User with id " + str(uid) +
" not found."), 404
else:
if len(form) == 1:
cusername = form['cusername']
if not cusername:
return jsonify(Error="Username left blank"), 405
cid = dao.getUsersByUsername(cusername)[0]
if cid:
if not dao.getUserById(cid):
return jsonify(Error="Contact User with id " +
str(cid) + " not found."), 404
if dao.getContactFromUserId(uid, cid):
return jsonify(Error="User with id " + str(uid) +
" already has contact with id " +
str(cid)), 404
if uid == cid:
return jsonify(
Error=
"You cannot add yourself to your own contact list."
)
result = self.build_contact_attributes(
dao.insertContact(uid, cid))
print(result)
return jsonify(Contact=result), 201
else:
return jsonify(
Error="Unexpected attributes in insert contact request"
), 400
elif len(form) == 5:
ufirstname = form['ufirstname']
ulastname = form['ulastname']
uemail = form['uemail']
uusername = form['uusername']
upassword = form['upassword']
if ufirstname and ulastname and uemail and uusername and upassword:
if dao.getUserByEmail(uemail):
return jsonify(
Error=
"User with that email already exists. Please try a different one."
), 400
elif dao.getUsersByUsername(uusername):
return jsonify(
Error=
"User with that username already exists. Please try a different one."
), 400
cid = dao.insertUser(ufirstname, ulastname, uemail,
uusername, upassword)
result = self.build_contact_attributes(
dao.insertContact(uid, cid))
print(result)
return jsonify(Contact=result), 201
else:
return jsonify(
Error="Unexpected attributes in insert contact request"
), 400
else:
return jsonify(Error="Malformed add to contacts request"), 400