def AddMessage(self, ClientId, SecondId, Message):
TimeStamp = datetime.now().strftime("%d-%b-%Y|%H:%M:%S")
#IdMensaje = IDEMISOR-IDRECEPTOR-TIMESTAMP
IdMessage = str(ClientId)+"_"+str(SecondId)+"_"+str(TimeStamp)
try:
log = open(FILE,"a")
except IOError:
print("[ERROR] Algo salio mal, al intentar registrar el mensaje: "+ str(Message)+" entre los clientes :"+str(ClientId)+" -- "+str(SecondId))
return
Data = "#".join([str(IdMessage), str(Message), "\n"])
if ClientId in self.Clients.keys():
if SecondId in self.Clients.keys():
self.Clients[SecondId].append(Data)
log.write(Data)
print("[EXITO] El mensaje: "+ str(Message)+" entre los clientes :"+str(ClientId)+" -- "+str(SecondId)+ " Se registro correctame")
return Chat_pb2.Confirmacion(Tipo = 1, IdPropietario=ClientId, IdMensaje = IdMessage, Error = "" )
else:
print("El receptor {0} no se ecnuentra registrado".format(SecondId))
return Chat_pb2.Confirmacion(Tipo = 0, IdPropietario=ClientId, IdMensaje = IdMessage, Error = "El receptor {0} no se ecnuentra registrado".format(SecondId) )
else:
print("El emisor {0} no se encuentra registrado".format(ClientId))
return Chat_pb2.Confirmacion(Tipo = 0, IdPropietario=ClientId, IdMensaje = IdMessage, Error = "El emisor {0} no se encuentra registrado".format(ClientId))
log.close()
def Saludo(self, request, context):
NewId = "Cliente-"+str(self.ClientNumber+1)
if (request.Tipo == 0):
if (self.Directorio.AddClient(NewId)):
self.ClientNumber = self.ClientNumber +1
print("Se ha agregado a {0} a la lista de clientes".format(NewId))
return Chat_pb2.Saludos(Tipo = 1, IdCliente = NewId, IdServidor = str(self.ServerId), Error = "")
else:
return Chat_pb2.Saludos(Tipo = 1, IdCliente = "", IdServidor = "", Error = "Error al ser agregado al servidor, El cliente ya existe")
elif (request.Tipo == 1):
print("USTED NO DEBERIA ESTAR AQUI! ¬¬")
def __init__(self, nombre):
self.nombre = nombre
self.channel = grpc.insecure_channel(f'{SERVER}:{PORT}')
self.stub = Chat_pb2_grpc.ChatStub(self.channel)
self.id = self.stub.Connection(Chat_pb2.Nombre(
nombre=nombre)).id # se le pide al server que nos de un id
print(f'Id cliente: {self.id}, Nombre Cliente: {self.nombre}')
print(
'==================================BEGIN======================================='
)
self.my_user = Chat_pb2.User(id=self.id, nombre=self.nombre)
#se crea thread para que escuche los mensajes entrantes
threading.Thread(target=self.ReciveMessage, daemon=True).start()
def SendMessage(self, contenido, destino):
try:
response = self.stub.SendMessage(
Chat_pb2.Message(
emisor=self.my_user,
contenido=contenido,
timestamp=time.strftime("%c"),
receptor=Chat_pb2.User(id=int(destino.split('#')[1]),
nombre=destino.split('#')[0]),
id=self.stub.New_message(Chat_pb2.Id(id=self.id)).id))
if not response.flag:
print(
"NO existe el usuario a quien se le quiere enviar el mensaje "
)
except grpc.RpcError as err:
print(err)
def test_enviarMensajes(self):
stub = str_grpc.ChatStub(self.channel)
msg = structure.Mensaje(sender='testsender',
content="this is a test",
receiver='testreceiver')
self.assertEqual("success", stub.enviarMensaje(msg))
def Messages(self, id, context):
r = Chat_pb2.MessageList()
try:
f = open("log/log.txt", "r")
for i in f:
l = i.split("@")
if (int(l[1][1:-1].split("#")[1]) == id.id):
men = l[5][1:-1].split(";")
r.msn.append(
Chat_pb2.Message(id=int(men[0]),
contenido=men[1],
timestamp=men[2]))
f.close()
except:
r.msn.append(Chat_pb2.Empty())
return r
def ListaDeUsuarios(self):
m = self.stub.ListaDeUsuarios(Chat_pb2.Id(id=self.id))
print(
"\n================================ LISTA DE USUARIOS ==================================== "
)
for i in m.user:
print(f'-> {i.nombre}#{i.id}')
print("")
def EsperaMensajes(self):
#print("Servicio de espera de mensajes iniciado")
for element in self.stub.DespachoMensajes(
Chat_pb2.Consulta(IdCliente=self.Id, Tipo=str("r"))):
#print("Mensaje recibido :\n"+element.Mensaje)
Mensaje = " ".join(
[element.TimeStamp, element.IdPropietario, element.Mensaje])
self.Mensajes.append(Mensaje)
def EsperaHistorial(self):
temp = []
#print("Servicio de espera de mensajes iniciado")
for element in self.stub.DespachoMensajes(
Chat_pb2.Consulta(IdCliente=self.Id, Tipo=str("e"))):
#print("Mensaje recibido :\n"+element.Mensaje)
Mensaje = " ".join(
[element.TimeStamp, element.IdDestinatario, element.Mensaje])
temp.append(Mensaje)
return temp
def SendMessage(self, message, context):
flag = False
respuesta = Chat_pb2.Estado(
estado=flag,
detalle=f'El mensaje a {message.receptor} no pudo se entregado')
if message.receptor.id > self.user_id and message.receptor.nombre not in self.nombre.values(
): #el usuario que iba a ser el enviado el mensaje no existe
return Chat_pb2.Flag(flag=False)
self.recibidos[message.receptor.id].append(message)
self.enviados[message.emisor.id].append(message)
# Se procede a escribir log .txt
f = open("log/log.txt", "a")
f.write(
f'Sender@[{message.emisor.nombre}#{message.emisor.id}]@Receiver@[{message.receptor.nombre}#{message.receptor.id}]@Message@[{message.id};{message.contenido};{message.timestamp}]\n'
)
f.close()
print(
f'El usuario {message.emisor.nombre} envia mensaje a {message.receptor.nombre}'
)
return Chat_pb2.Flag(flag=True)
def recibirMensajes(self, request, context):
cont = 0
#while True:
while cont < len(self.messages):
message = structure.Mensaje(id=self.messages[cont][0],
sender=self.messages[cont][1],
receiver=self.messages[cont][2],
content=self.messages[cont][3])
if request.username == message.receiver or request.username == message.sender:
yield message
print(cont)
cont = cont + 1
def Connection(self, request, context):
print(f'Responde el thread{threading.get_ident()}')
new_id = self.user_id
self.nombre[
new_id] = request.nombre # se obtiene el nombre de la persona que hizo la request, supongo que despue slo ssamos ?
self.enviados[new_id] = [
] # se crea llave = id , valor = lista de mensajes enviados
self.recibidos[new_id] = [] #se crea lista para mensaje recibidos
self.user_id += 1
return Chat_pb2.Id(id=new_id)
def EnvioSolicitud(self):
Dest = input("ingrese el Id del destinatario: ")
Message = input("Ingrese un mensaje: ")
if Message != "":
self.stub.EnvioSolicitud(
Chat_pb2.MensajeCliente(IdPropietario=self.Id,
IdDestinatario=Dest,
IdMensaje="",
TimeStamp="",
Mensaje=Message,
Error=""))
else:
print("Ingrese un mensaje valido")
def ReciveMessage(self):
try:
for mensaje in self.stub.ReciveMessage(Chat_pb2.Id(id=self.id)):
emisor = mensaje.emisor
print(
'\n========================= NUEVO MENSAJE RECIBIDO ==============================='
)
print(
f'[{emisor.nombre}#{emisor.id}-{mensaje.timestamp}]{mensaje.contenido}'
)
print('>> Ingrese accion:')
except grpc.RpcError as err:
print(err)
def GetMessages(self,ClientId):
temp = []
try:
for mensaje in self.Clients[ClientId]:
temp.append(mensaje)
print("se obtubieron los mensajes del usuario {0}".format(ClientId))
except Exception as error:
print(error)
print("Error al acceder al buffer de mensajes del cliente {0}".format(ClientId))
self.Clients[ClientId].clear()
for m in temp:
IdMensaje, Mensaje = m.split(sep="#", maxsplit=1)
IdEmisor,IdReceptor, TimeStamp = IdMensaje.split(sep="_", maxsplit = 2)
mensaje = Chat_pb2.MensajeCliente(IdPropietario = IdEmisor, IdDestinatario = IdReceptor, IdMensaje = IdMensaje,
TimeStamp = TimeStamp, Mensaje = Mensaje, Error = "" )
yield mensaje
def enviarMensaje(self, request, context):
cur = cnx.cursor()
sender = request.sender
receiver = request.receiver
contenido = request.content
date = datetime.datetime.now()
query = "INSERT INTO photogram.mensaje (sender, receiver, content, date) values (%s,%s,%s,%s)"
values = (sender, receiver, contenido, date)
cur.execute(query, values)
cnx.commit()
#insertarlo en la bd
self.messages.clear()
cur.execute("SELECT * FROM photogram.mensaje")
for msj in cur.fetchall():
print(msj)
self.messages.append(msj)
return structure.Empty(response="success")
def GetRecord(self, ClientId):
temp = []
try:
log = open(FILE,"r")
except IOError:
print("[ERROR] Algo salio mal, al intentar abrir el archivo log.txt")
return
for linea in log:
IdMensaje, Mensaje = linea.split(sep="#", maxsplit=1)
IdEmisor,IdReceptor, TimeStamp = IdMensaje.split(sep="_", maxsplit = 2)
if IdEmisor == ClientId:
temp.append((IdEmisor,IdReceptor,IdMensaje, TimeStamp, Mensaje))
log.close()
for tupla in temp:
IdEmisor,IdReceptor,IdMensaje, TimeStamp, Mensaje = tupla
mensaje = Chat_pb2.MensajeCliente(IdPropietario = IdEmisor, IdDestinatario = IdReceptor, IdMensaje = IdMensaje,
TimeStamp = TimeStamp, Mensaje = Mensaje, Error = "" )
yield mensaje
def __init__(self):
#Variables de clase
self.Id = "null"
self.IdServer = "null"
self.Mensajes = []
#Crear grpc Channel y stub
channel = grpc.insecure_channel(IP + ":" + PORT)
self.stub = Chat_pb2_grpc.ChatStub(channel)
response = self.stub.Saludo(
Chat_pb2.Saludos(Tipo=0, IdCliente="", IdServidor="", Error=""))
if response.Tipo == 1:
if len(response.IdCliente) > 0:
self.Id = response.IdCliente
self.IdServer = response.IdServidor
print("Has ingresado al servidor {0} con el Id {1}".format(
self.IdServer, self.Id))
elif len(response.Error) > 0:
print(response.Error)
else:
print("Algo salio mal al iniciar comunicacion con el servidor")
threading.Thread(target=self.EsperaMensajes(), daemon=True).start()
def EsperaClientes(self):
temp = []
for element in self.stub.DespachoMensajes(
Chat_pb2.Consulta(IdCliente=self.Id, Tipo=str("c"))):
temp.append(element.Mensaje)
return temp
def ListaDeUsuarios(self, id, context):
r = Chat_pb2.UserList()
for i in self.nombre:
r.user.append(Chat_pb2.User(id=i, nombre=self.nombre[i]))
return r
def New_message(self, n, context):
self.message_id += 1
return Chat_pb2.NewMessageID(id=self.message_id)
def getMessages():
print("RECIBIENDO")
for x in stub.recibirMensajes(structure.Usuario(username=sender)):
print(x)
def GetClients(self, ClientId):
for client in self.Clients.keys():
if client != ClientId:
mensaje = Chat_pb2.MensajeCliente(IdPropietario = "", IdDestinatario = "", IdMensaje = "", TimeStamp = "", Mensaje = client, Error = "" )
yield mensaje
def test_recibirMensajes(self):
with grpc.insecure_channel("localhost:" + self.port) as channel:
stub = str_grpc.ChatStub(channel)
response = stub.recibirMensajes(
structure.Usuario(username="******"))
self.assertEqual(response)
def Messages(self):
m = self.stub.Messages(Chat_pb2.Id(id=self.id))
for i in m.msn:
print(f'-> {i.contenido}')
if len(m.msn) == 0:
print('-> NO mensajes enviados')