SocketCliente.py

import socket
import threading
import os
import time
import datetime
import math
import json
import sys

#registroUsuario = True

#import Cliente.LlenarBaseCliente
#import Cliente.Interfaz.Cliente

import ConfigBaseCliente
import ModeloCliente
import Interfaz.Login
import Interfaz.Chat


#global rcv, snd, sckt, chat, ventanaChat, ventanaLogin

class Chat(threading.Thread):
    def __init__(self, sckt, ventanaChat, deltaTime):
        super(Chat, self).__init__()

        self.rcv = Receive(sckt, ventanaChat, deltaTime)
        self.snd = Send(sckt)

    def stop_children(self):
        self.rcv.fin = True
        self.snd.fin = True

    def run(self):
        self.rcv.start()
        self.snd.start()
        self.rcv.join()
        self.snd.join()
        print('finalizo el chat')
        #exit_handler()

class Archivo():
    def __init__(self, ext, packages, name):
        self.packages = packages
        self.ext = ext
        self.file = None
        self.name = ''
        self.nbuffer = 0
        self.name = name
        self.iniciarBuffer()


    def iniciarBuffer(self, folder = r'./archivosCompartidos'):
        newpath = folder + '/' + self.name
        print(newpath)
        if not os.path.exists(newpath):
            os.makedirs(newpath)
        self.name = newpath + '/' + datetime.datetime.now().strftime("%Y%m%d%H%M%S")+'.'+self.ext
        self.file = open(self.name, 'wb')
        print('me he creado', newpath)

    def actualizarInfo(self, info):
        self.file.write(info)
        self.nbuffer += 1
        print('voy en : ', self.nbuffer)
        if self.nbuffer == int(self.packages):
            self.file.close()
            print('Ya tengo todos los paquetes, soy : ', self.name)
            print('\n\n##############################################################################\n\n')

class Receive(threading.Thread):
    def __init__(self, skt, ventanaChat, deltaTime):
        super(Receive, self).__init__()
        self.skt = skt
        self.archi = None
        self.fin = False
        self.message = ''
        self.ventanaChat = ventanaChat
        self.deltaTime = deltaTime
        self.hora = time.localtime(time.time())
        self.actualizarHora()

    def recibirArchivo(self, message):
        message = message.split('uwu'.encode())
        #byte:232323:png:3
        print('archi: ',self.archi.packages, self.archi.nbuffer)
        print('mes: ', message)

        if self.archi:
            if self.archi.packages == message[1].decode() and self.archi.ext == message[2].decode() and self.archi.nbuffer == int(message[3].decode()):
                self.archi.actualizarInfo(message[0])

    def actualizarHora(self):
        desfase = self.deltaTime.split(":")
        desfase = [int(i) for i in desfase]
        self.hora = time.localtime(time.time())
        self.hora = "["+str(self.hora[3]+desfase[0])+":"+str(self.hora[4]+desfase[1])+":"+str(self.hora[5]+desfase[2])+"]"

    def run(self):
        self.message = ''
        while not self.fin:
            self.message = self.skt.recv(1024)
            #serv:typeOfService:[info]
            if self.message:
                print('Ha llegado un mensaje: \t')
                #print('->> \t',self.message.decode())
                data = self.message.split(':'.encode(), 2)
                print('\t',data)
                owner = data[0]
                if owner.decode() == 'sv':
                    typeOfService = data[1].decode()
                    if typeOfService == 'rf':
                        self.recibirArchivo(data[2])
                    elif typeOfService == 'fileInfo':
                        self.message = data[2].decode().split(':')
                        self.archi = Archivo(message[0],message[1],message[2])
                        #print('instancia de archi')
                    elif typeOfService == 'fileReceived':
                        self.message = data[2].decode()
                        if ventanaChat:
                            #mostrar el link de descarga en la vista de chat
                            pass
                    elif typeOfService == 'exitAccepted':
                        self.fin = True

                    elif typeOfService == 'updateUsersEntry':
                        infoUser = data[2].decode()
                        print("######### oyeeee ya voy a tengo la info del usuario #########3")
                        infoUser = json.loads(infoUser)
                        print(type(infoUser))
                        print("######### oyeeee ya voy a emitir la info a la señal #########3")
                        self.ventanaChat.entro.emit(infoUser)
                        #self.ventanaChat.entrousuariosignal(infoUser)

                    elif typeOfService == 'updateUsersExit':
                        infoUser = data[2].decode()
                        print("######### oyeeee ya voy a tengo la info del usuario #########3")
                        infoUser = json.loads(infoUser)
                        print(type(infoUser))
                        print("######### oyeeee ya voy a emitir la info a la señal #########3")
                        self.ventanaChat.salio.emit(infoUser)

                else:
                    self.message =':'.encode().join(data).decode().split(":",1)
                    print(self.message)
                    mensaje = self.message[1]
                    user = self.message[0]
                    print("user ->> "+ user)
                    self.actualizarHora()
                    cosas = {}
                    cosas['hora'] = self.hora
                    cosas['usuario'] = user
                    cosas['mensaje'] = mensaje
                    self.ventanaChat.escribio.emit(cosas)
                    #print("Hilo: "+self.message, type(self.message))

        print('deje de recibir')

class Send(threading.Thread):
    def __init__(self, skt):
        super(Send, self).__init__()
        self.skt = skt
        self.masaje = ''
        self.fin = False

    def run(self):
        self.masaje = ''
        while not self.fin:
            if self.masaje != '':
                if self.masaje == 'okis':
                    # se añaden ':' para hacer split
                    self.masaje += ':**'
                else:
                    self.masaje += ':*'
                #masaje = '' # Provisional para que no ocurra ningun error

                print("---> : "+self.masaje)
                self.skt.send(self.masaje.encode('UTF-8'))
                #enviar la informacion del archivo adjunto
                if self.masaje == '#exit:*':
                    break
                self.masaje = ''
        print('deje de enviar')

class Cliente():
    def __init__(self):
        self.rcv = None
        self.snd = None
        self.sckt = None
        self.chat = None
        self.ventanaChat = None
        self.ventanaLogin = None
        self.deltatime = None
        self.InitializeSocket()
        self.Login()

    def InitializeSocket(self):
        self.sckt = socket.socket()
        self.sckt.connect(("192.168.0.102", 8092))
        print(self.sckt)
        hora = time.localtime(time.time())[3:6]
        mensaje = '*Updthur:'+str(hora[0])+":"+str(hora[1])+":"+str(hora[2])
        self.sckt.send(mensaje.encode())
        self.deltatime = self.sckt.recv(1024).decode()

    def llenarBase(self):
        estados = ConfigBaseCliente.sessioncliente.query(ModeloCliente.Estados).all()
        if len(estados) == 0:
            #print(estados)
            estado1 = ModeloCliente.Estados(Descripcion='Mensaje no llegó al servidor.')
            ConfigBaseCliente.sessioncliente.add(estado1)
            estado2 = ModeloCliente.Estados(Descripcion='Mensaje llegó al servidor.')
            ConfigBaseCliente.sessioncliente.add(estado2)
            estado3 = ModeloCliente.Estados(Descripcion='Mensaje no llegó al cliente.')
            ConfigBaseCliente.sessioncliente.add(estado3)
            estado4 = ModeloCliente.Estados(Descripcion='Mensaje llegó al cliente.')
            ConfigBaseCliente.sessioncliente.add(estado4)
            ConfigBaseCliente.sessioncliente.commit()

    def Login(self):
        Interfaz.Login.main(self)

    def verificarDatosVentanaOlvidoClave(self, ventana):

        usuario = ventana.olvidoVentana.lineEditUsuario.text()
        respuestaSecreta = ventana.olvidoVentana.lineEditRespuesta.text()
        mensaje = '*' + 'RC'+':'+usuario+':'+respuestaSecreta
        print("******** voy a enviar la info *************")
        self.sckt.send(mensaje.encode('UTF-8'))
        print("******** ya envié la info *************")
        error = self.sckt.recv(1024).decode('UTF-8')
        print("******** ya ya recibí una respuesta *************")
        if error[:5] != 'error':
            ventana.olvidoVentana.hide()
            ventana.olvidoVentana.deleteLater()
            ventana.ventana_clave_nueva(usuario)
        else:
            ventana.olvidoVentana.labelError.setText(error[5:])
            ventana.olvidoVentana.labelError.show()

    def editarDatosCuenta(self, ventana, campo, datos):
        if campo == 'Sexo':
            if ventana.ventanaEditarDatos.widget.widget.radioButtonMasculino.isChecked() == True:
                datos = 'Masculino'
            else:
                datos = 'Femenino'
        mensaje = '*ED:'+campo+':'+str(datos)
        print(mensaje)
        self.sckt.send(mensaje.encode())
        time.sleep(0.5)
        error = self.chat.rcv.message
        print(error)
        if error[:5] != 'error': #si no hay error es porque se guardó
            print('se ha actualizado el campo' + campo)
            if campo == 'Nombre':
                Interfaz.Chat.actualizarVistaEditarNombre(ventana, datos)
            elif campo == 'Sexo':
                Interfaz.Chat.actualizarVistaEditarSexo(ventana, datos)
            elif campo == 'Fecha':
                Interfaz.Chat.actualizarVistaEditarFecha(ventana, datos)
            elif campo == 'Clave':
                Interfaz.Chat.actualizarVistaEditarClave(ventana)
            elif campo == 'Respuesta':
                Interfaz.Chat.actualizarVistaEditarRespuesta(ventana)
        else:
            if campo == 'Clave':
                Interfaz.Chat.verificacion1(ventana.ventanaEditarDatos.widget.widget2, 'EditarClave Nofocus', None)
                ventana.ventanaEditarDatos.widget.widget2.labelClaveError.setText("Contraseña actual incorrecta.")
            else:
                print('ha ocurrido un error')

    def controladorInicioSesion(self, ventana):

        nickname = ventana.lineEditUsuario.text()
        password = ventana.lineEditPassword.text()

        mensaje = '*'+'DC'+':'+nickname+':'+password
        self.sckt.send(mensaje.encode('UTF-8'))
        error = self.sckt.recv(1024).decode('UTF-8')
        if error[:5] != 'error': #Si no hay error llegan los datos en el error
            datos = error.split('<>')
            print(datos)
            user = json.loads(datos[0])
            room = json.loads(datos[1])
            room['owner']='Sistema'
            usersRoom = json.loads(datos[2])
            ventana.hide()
            ventana.deleteLater()
            ConfigBaseCliente.main()
            self.llenarBase()
            self.sckt.send('*IS'.encode('UTF-8'))
            self.ventanaChat = Interfaz.Chat.Ventana_Principal(self)
            self.ventanaChat.constructor(user,room,usersRoom,None,None) #--Enviar Parámetros. (usuario-->dict, sala-->dict, usuariosSala-->list[dicts], usuariosMensajesPrivados-->list[dicts], mensajesPrivados-->list[dicts]):
            self.ventanaChat.setIndexTab(0)
            self.ventanaChat.show()
            #b.show()
            self.chat = Chat(self.sckt, self.ventanaChat, self.deltatime)
            self.chat.start()
        else:
            ventana.labelError.setText(error[5:])
            ventana.labelError.show()

    def controladorRegistro(self, ventana):

        nombreCompleto = ventana.ventanaRegistro.widget.widget.lineEditNombre.text()
        nickname = ventana.ventanaRegistro.widget.widget.lineEditNickname.text()
        password = ventana.ventanaRegistro.widget.widget2.lineEditClave.text()
        respuestaSecreta = ventana.ventanaRegistro.widget.widget2.lineEditRespuesta.text()
        fecha = ventana.ventanaRegistro.widget.widget.dateEditFechaNacimiento.date().toString('dd/MM/yyyy')
        sexo = None
        if ventana.ventanaRegistro.widget.widget.radioButtonMasculino.isChecked() == True:
            sexo ='Masculino'
        else:
            sexo='Femenino'
        mensaje = '*'+'DR'+':'+nombreCompleto+':'+nickname+':'+password+':'+respuestaSecreta+':'+sexo+':'+fecha
        self.sckt.send(mensaje.encode('UTF-8'))
        error = self.sckt.recv(1024).decode('UTF-8')
        if error[:5] != 'error':
            ventana.ventanaRegistro.hide()
            ventana.ventanaRegistro.deleteLater()
            ventana.alerta('Registro exitoso.')
        else:
            ventana.ventanaRegistro.widget.widget.labelErrorNickname.setText(error[5:])
            ventana.ventanaRegistro.widget.widget.labelErrorNickname.show()

    def controladorNuevaClave(self, ventana):

        clave = ventana.claveNuevaVentana.lineEditClave.text()
        mensaje = '*'+'NC'+':'+clave
        self.sckt.send(mensaje.encode('UTF-8'))
        ventana.claveNuevaVentana.hide()
        ventana.claveNuevaVentana.deleteLater()
        ventana.alerta('Contraseña modificada con éxito.')
        error = self.sckt.recv(1024).decode('UTF-8')

    def controladorEnviarArchivos(self, archivo):

        #enviar byte por byte con el tamaño total, el tipo de archivo, y que parte se envía
        #byte:232323:png:3
        nombreArchivo = archivo.split('/')[-1]
        tipo = nombreArchivo.split('.')[-1]
        print('\n\n##############################################################################\n\n')
        archi = open(archivo,'rb')
        info = archi.read()
        size = len(info)
        total = 6 + 5 + len(tipo) + len('uwu'*3) + 5 #solo se pueden enviar archivos de máximo 100mb
        step = 1024 - total
        nsends = math.ceil(size/step)
        #sckt.send('*PART:'.encode() + info)
        mensajeArchivo = '*EN:'+tipo+':'+str(nsends)
        #print(mensajeArchivo)
        print('Tengo el mensaje listo para enviar')
        self.sckt.send(mensajeArchivo.encode())
        print('Se ha enviado el mensaje de informacion')
        time.sleep(0.5)
        print('Hey :', nsends, step)
        for i in range(nsends):
            encd = '*PART:'.encode() + info[i*step:(i+1)*step] + 'uwu'.encode() + str(nsends).encode() + 'uwu'.encode() + tipo.encode() + 'uwu'.encode() + str(i).encode()
            #print(encd.split('uwu'.encode()))
            time.sleep(0)
            self.sckt.send(encd)
        print('Se han enviado todas las partes')
        print('\n\n##############################################################################\n\n')
        archi.close()
        print('se ha cerrado el archivo')

    def controladorRecibirArchivos(self, archivo):
        pass

    def consultarInformacionUsuario(self, ventana):
        mensaje = "*ReqInfo:"
        self.sckt.send(mensaje.encode())
        time.sleep(0.1)
        error = self.chat.rcv.message
        print("Respuesta del servidor: "+error+" : Fin del mensaje")
        error = json.loads(error)
        #print(type(error))
        ventana.informacionusuarioventana(error)

    def controladorComandos(self, comando):
        self.chat.snd.masaje = comando

    def controladorMensajesEnviar(self, ventana):
        self.chat.rcv.ventanaChat = ventana
        self.chat.snd.masaje = ventana.tabSala.lineEditChat.text()
        print(ventana.tabSala.lineEditChat.text())
        ventana.tabSala.lineEditChat.setText("")

    def cerrarSesionChat(self, ventana, crearventana = True):
        self.chat.stop_children()
        mensaje = '*RUSS:'
        self.sckt.send(mensaje.encode())
        if os.path.exists("cliente.db"):
            ConfigBaseCliente.sessioncliente.close()
            os.remove("cliente.db")
        else:
            print("No existe la base de datos")
        ventana.hide()
        ventana.deleteLater()
        #error = sckt.recv(1024).decode()
        #print(error)
        if crearventana:
            self.ventanaLogin = Interfaz.Login.Ventana_Login(self)
            self.ventanaLogin.show()

    def salirChat(self, ventana):
        self.cerrarSesionChat(ventana, False)
        self.salir(ventana)

    def salir(self, ventana):
        #matar el sckt
        mensaje = '#exit*'
        self.sckt.send(mensaje.encode('UTF-8'))
        time.sleep(1)
        self.sckt.shutdown(socket.SHUT_RDWR)
        self.sckt.close()
        print("Me cerré")
        ventana.hide()
        ventana.deleteLater()
        sys.exit()

if __name__ == "__main__":
    cliente = Cliente()