def __init__(self, frame_pai, controller):
super().__init__(frame_pai)
self.controller = controller
self.controller.requestRetrieveFriends()
# LEMBRAR DE CRIAR METODOS QUE CARREGAMOS OS CONTATOS!
self.currentChat = Models.LstMessages
self.currentContactChat = Models.user()
self.idUserSelected = self.currentContactChat.idd
self.userFriendsList = Models.LstUsers()
self.config_opcoes1(command=lambda: self.controller.loginActivity())
self.config_ajuda1(command=lambda: self.__raise_ajuda__())
self.config_ajuda2(command=lambda: self.__raise_sobre__())
self.botao_envia.config(command=lambda: self.__envia_msg__())
self.entr_msg.bind('<KeyRelease-Return>',
lambda event: self.__envia_msg__())
self.contatos_treeview.bind('<<TreeviewSelect>>',
lambda event: self.__retrieve_chat__())
#TODO MUDAR ESSA CHAMADA ABAIXO
self.frame_chat.config(text='Seja bem vindo(a) ' +
self.controller.session.currentUser.userName)
self.add_contato_button.config(command=lambda: self.__add_contato__())
self.solicitations_button.config(
command=lambda: self.FriendshipSolicitations())
self.entr_contatos.bind('<KeyRelease>',
lambda event: self.__search_contacts__())
def retrieveChat(self, friendship: Models.Friendship):
# PRIMEIRO É VERIFICADO SE O PEDIDO DE AMIZADE FOI ACEITO
tableFriends = 'friends_' + str(friendship.senderUser.idd)
sql = 'SELECT confirmation FROM ' + tableFriends + ' WHERE id_friend = ' + str(
friendship.recipUser.idd) + ';'
confirmation = self.__select_fetchone__(sql)
if int(confirmation[0]) == 1:
userId = friendship.senderUser.idd
friendId = friendship.recipUser.idd
# Método que busca a conversa de dois usuários dados
# Como a tabela foi criada pelo método newChat(), o nome dela respeita a lógica seguinte:
if int(userId) > int(friendId):
tableName = 'chat_' + str(userId) + '_' + str(friendId)
elif int(friendId) > int(userId):
tableName = 'chat_' + str(friendId) + '_' + str(userId)
user = UserMapper().retrieveUser(userId)
friend = UserMapper().retrieveUser(friendId)
sql = 'SELECT data_hora, conteudo, id_dest, id_remete FROM ' + tableName + ' ORDER BY data_hora;'
tupl_lst = self.__execute_fetchall__(sql)
if isinstance(tupl_lst, Exception):
return tupl_lst
elif tupl_lst is None:
return Exception('Chat not found')
lstMessage = Models.LstMessages()
# A ROTINA ABAIXO VERIFICA SE NA MENSAGEM EM QUESTÃO, O USUÁRIO REQUISITANTE DA LISTA DE MENSAGENS FOI O DESTINATÁRIO
# OU REMETENTE, PARA PREENCHER O NOME(STRING) DE FORMA CORRETA, JÁ QUE A RECUPERAÇÃO DO MESMO VIA INNER JOIN É INVIÁVEL
# POIS AMBOS RESIDEM NA MESMA TABELA
for elem_tupl in tupl_lst:
if userId == int(elem_tupl[3]):
message = Models.Message()
message.dateTime = elem_tupl[0]
message.content = elem_tupl[1]
message.recipUser = friend
message.senderUser = user # USUÁRIO REQUISITANTE DO MÉTODO FOI O REMETENTE
lstMessage.append(message)
if userId == int(elem_tupl[2]):
message = Models.Message()
message.dateTime = elem_tupl[0]
message.content = elem_tupl[1]
message.recipUser = user # USUÁRIO REQUISITANTE DO MÉTODO FOI O DESTINATÁRIO
message.senderUser = friend
lstMessage.append(message)
return lstMessage
else:
#CASO O PEDIDO DE AMIZADE AINDA NÃO TENHA SIDO ACEITO PELO DESTINATÁRIO:
lstMessage = Models.LstMessages()
#O MÉTODO RETORNA UMA LISTA VAZIA:
return lstMessage
def __init__(self):
self.clientHandler = ClientHandler.ClientRequestManager(self)
self.currentUser = Models.user()
self.viewController = ViewController.MainViewController(self)
self.viewController.loginActivity()
self.viewController.mainloop()
def requestFriendshipAcepted(self, user: Models.user):
# VERIFICAÇÃO FEITA:
friendship = Models.Friendship()
friendship.recipUser = self.currentUser
friendship.accepted = 1
friendship.blocked = 0
friendship.senderUser = user
self.clientHandler.requestFriendshipAcepted(friendship)
def __init__(self, friendship: Models.Friendship = Models.Friendship()):
"""
:param senderUser: Models.user()
:param recipUser: Models.user()
:rtype: ResponseUnblockUser
"""
super().__init__()
self.friendship = friendship
def __init__(self, controller):
super().__init__()
self.controller = controller
self.lstRequests = Models.LstUsers()
self.controller.requestFriendshipRequests()
self.blockButton.config(command=lambda: self.blockUser())
self.aceptButton.config(command=lambda: self.aceptUser())
self.contatos_treeview.bind('<<TreeviewSelect>>',
lambda event: self.bindTreeview())
def retrieveUser(self, id_user):
id_user = self.__strip_id__(id_user, tipo='str')
sql = 'SELECT userEmail, userName FROM users WHERE id = ' + id_user + ';'
tupl = self.__execute_fetchone__(sql)
if tupl != None:
user = Models.user()
user.userEmail = tupl[0]
user.userName = tupl[1]
user.idd = int(id_user)
return user
else:
return Exception('User not found')
def __comando_B1__(self):
user = Models.user()
user.userName = self.entr1.retorna_entr()
user.userEmail = self.entrMail.retorna_entr()
user.password = self.entr2.retorna_entr()
password2 = self.entr3.retorna_entr()
if user.password != password2:
self.messagebox_info('Cadastro', 'As senhas não conferem!')
self.entr2.limpa_entr()
self.entr3.limpa_entr()
else:
self.controller.requestNewUser(user)
def retrieveFriends(self, user: Models.user):
id_user = user.idd
tableName = 'friends_' + str(id_user)
sql = 'SELECT id_friend, userName, userEmail, showNotification, dateAdd FROM ' + tableName + ' INNER JOIN users ON (' + tableName + '.id_friend = users.id) WHERE confirmation = 1;'
lst_tupl = self.__execute_fetchall__(sql)
if isinstance(lst_tupl, Exception):
return lst_tupl
elif lst_tupl is None:
return Exception('Friends list not found')
else:
lstUser = Models.LstUsers()
for elem in lst_tupl:
friendUser = Models.user()
friendUser.idd = int(elem[0])
friendUser.userName = elem[1]
friendUser.userEmail = elem[2]
friendUser.showNotification = elem[3]
friendUser.dateAdd = elem[4]
lstUser.append(friendUser)
return lstUser
def namesLike(self, user: Models.user, nameLike: str):
tableName = 'friends_' + str(user.idd)
nameLike = nameLike + '%'
sql = 'SELECT ' \
'id_friend, ' \
'userName, u' \
'serEmail ' \
'FROM ' + tableName + \
' INNER JOIN users ON (' + tableName + '.id_friend = users.id)' \
' WHERE userName LIKE "' + nameLike + '" ;'
lst_tupl = self.__execute_fetchall__(sql)
lstUser = Models.LstUsers()
if lst_tupl != []:
for tupl in lst_tupl:
user = Models.user()
user.idd = int(tupl[0])
user.userName = tupl[1]
user.userEmail = tupl[2]
lstUser.append(user)
return lstUser
def searchUser(self, userEmail: str):
sql = 'SELECT id, userName FROM users WHERE userEmail = "' + userEmail + '" ;'
commitFeedback = self.__execute_fetchone__(sql)
if isinstance(commitFeedback, Exception):
return commitFeedback
elif commitFeedback != None:
user = Models.user()
user.userEmail = userEmail
user.userName = commitFeedback[1]
user.idd = int(commitFeedback[0])
return user
else:
return Exception('Usuário não encontrado!')
def addFriend(self, senderUser: Models.user,
friendEmail: str) -> Models.Friendship or Exception:
if self.searchUser(friendEmail) != None:
recipUser = self.searchUser(friendEmail)
if isinstance(recipUser, Exception):
return recipUser
elif recipUser is None:
return Exception('Usuário não encontrado!')
else:
senderId = senderUser.idd
recipId = recipUser.idd
tableBlocks = 'blocks_' + str(recipId)
sql = 'SELECT id_block FROM ' + tableBlocks + ' WHERE id_block = ' + str(
senderId) + ';'
id = self.__execute_fetchone__(sql)
# VERIFICA SE O REMETENTE DO PEDIDO DE AMIZADO ESTÁ BLOQUEADO PELO DESTINATÁRIO
if id == None or id == 0:
registerDate = datetime.datetime.now()
# O contato é adcionado na tabela de amigos do usuário:
tableSender = 'friends_' + str(senderId)
tableRecip = 'friends_' + str(recipId)
sql1 = 'INSERT INTO ' + tableSender + '(id_friend, confirmation, showNotification) VALUES (' + str(
recipId) + ', 1, 1);'
sql2 = 'INSERT INTO ' + tableRecip + '(id_friend, confirmation, showNotification) VALUES (' + str(
senderId) + ', 0, 1);'
if recipId > senderId:
tableName = 'chat_' + str(recipId) + '_' + str(
senderId)
elif senderId > recipId:
tableName = 'chat_' + str(senderId) + '_' + str(
recipId)
sql3 = 'CREATE TABLE IF NOT EXISTS ' + tableName + '(id INTEGER PRIMARY KEY AUTOINCREMENT, id_dest INTEGER, id_remete INTEGER, data_hora datetime, conteudo TEXT, statusRead INTEGER, statusReceived INTEGER, FOREIGN KEY(id_dest) REFERENCES users(id), FOREIGN KEY(id_remete) REFERENCES users(id));'
commitFeedback = self.__execute_transaction__(sql1 + sql2 +
sql3)
print('commitFeedback ' + str(commitFeedback))
if commitFeedback == 0:
friendship = Models.Friendship(senderUser, recipUser)
return friendship
elif isinstance(commitFeedback, Exception):
return commitFeedback
elif int(id) == senderId:
#CASO CONSTE NA LISTA DE BLOQUEIOS:
return Exception('Usuário não encontrado!')
else:
return Exception('Usuário não encontrado!')
def __init__(self, message: Models.Message = Models.Message()):
super().__init__()
self.message = message
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.lstUsers = Models.LstUsers().fromJson(dictObj['lstUsers'])
return self
def __init__(self, lstUsers: Models.LstUsers = Models.LstUsers()):
super().__init__()
self.lstUsers = lstUsers
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.lstMessages = Models.LstMessages().fromJson(
dictObj['lstMessages'])
return self
def __init__(self, lstMessages: Models.LstMessages = Models.LstMessages()):
super().__init__()
self.lstMessages = lstMessages
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.user = Models.user().fromJson(dictObj['user'])
return self
def __init__(self, friendship: Models.Friendship = Models.Friendship()):
super().__init__()
self.friendship = friendship
self.senderUser = friendship.senderUser
self.recipUser = friendship.recipUser
def fromJson(self, dictObj: dict or list):
super().fromJson(dictObj)
self.namesLike = dictObj['namesLike']
self.user = Models.user().fromJson(dictObj['user'])
return self
def blockUser(self):
friendship = Models.Friendship()
friendship.recipUser = self.currentContact
friendship.accepted = 0
friendship.blocked = 1
self.controller.requestBlockUser(friendship)
def fromJson(self, dictObj: dict or list):
super().fromJson(dictObj)
self.namesLike = Models.LstUsers().fromJson(dictObj['namesLike'])
return self
def __init__(self, friendship: Models.Friendship = Models.Friendship()):
super().__init__()
self.friendship = friendship
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.friendship = Models.Friendship().fromJson(dictObj['friendship'])
self.recipUser = Models.user().fromJson(dictObj['recipUser'])
self.senderUser = Models.user().fromJson(dictObj['senderUser'])
return self
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.message = Models.Message().fromJson(dictObj['message'])
return self
def __init__(self, user: Models.Login = Models.Login()):
super().__init__()
self.user = user
def __init__(self,
currentUser: Models.user = Models.user(),
nameLike: str = ''):
super().__init__()
self.namesLike = nameLike
self.user = currentUser
def __init__(self,
senderUser: Models.user = Models.user(),
recipUser: Models.user = Models.user()):
super().__init__()
self.senderUser = senderUser
self.recipUser = recipUser
def __init__(self, namesLike: Models.LstUsers = Models.LstUsers()):
super().__init__()
self.namesLike = namesLike
def fromJson(self, dictObj: dict):
super().fromJson(dictObj)
self.friendship = Models.Friendship().fromJson(dictObj['friendship'])
return self
