Exemplos de Direccion em Python

Exemplo n.º 1

Arquivo: pProveedor.py Projeto: alfa87/Sistema-de-gestion-con-PyQt5

    def changeSelectedTable(self, selected, deselected):
        proveedorList = selected.model().mylist
        proveedorSelected = proveedorList[selected.row()]
        self.proveedor = Proveedor()
        self.direccion = Direccion()
        self.proveedor.setIdProveedor(int(proveedorSelected[0]))
        self.proveedor.setDescripcion(str(proveedorSelected[1]))
        self.proveedor.setNombre(str(proveedorSelected[2]))
        self.proveedor.setEmail(str(proveedorSelected[3]))
        self.proveedor.setWeb(str(proveedorSelected[4]))

        self.direccion.setDireccion(str(proveedorSelected[5]))
        if proveedorSelected[6] != None:
            self.direccion.setNumero(int(proveedorSelected[6]))

        if proveedorSelected[7] != None:
            self.direccion.setPiso(int(proveedorSelected[7]))

        if proveedorSelected[8] != None:
            self.direccion.setDpto(proveedorSelected[8])

        self.direccion.setIdDireccion(int(proveedorSelected[10]))
        self.proveedor.setDireccion(self.direccion)

        self.proveedor.setIdPersona(proveedorSelected[9])

        self.winPrincipal.tvProveedores_prov.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvProveedores_prov.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setModel(None)
        self.cargarTablaTelefono()

Exemplo n.º 2

    def changeSelectedTable(self, selected, deselected):

        clienteList = selected.model().mylist
        clienteSelected = clienteList[selected.row()]
        self.cliente = Cliente()
        self.direccion = Direccion()
        self.cliente.setIdCliente(int(clienteSelected[0]))
        self.cliente.setApellido(clienteSelected[1])
        self.cliente.setNombre(clienteSelected[2])
        self.cliente.setEmail(clienteSelected[3])
        self.direccion = Direccion()
        self.direccion.setDireccion(clienteSelected[4])

        if clienteSelected[5] != None:
            self.direccion.setNumero(int(clienteSelected[5]))

        if clienteSelected[6] != None:
            self.direccion.setPiso(int(clienteSelected[6]))

        if clienteSelected[7] != None:
            self.direccion.setDpto(clienteSelected[7])

        self.direccion.setIdDireccion(int(clienteSelected[8]))
        self.cliente.setDireccion(self.direccion)

        self.cliente.setIdPersona(clienteSelected[9])

        self.winPrincipal.tvClientes_c.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvClientes_c.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_c.setEnabled(True)
        self.winPrincipal.btnBorrar_c.setEnabled(True)
        self.winPrincipal.tvTelefonos_c.setModel(None)
        self.cargarTablaTelefono()

Exemplo n.º 3

Arquivo: pProveedor.py Projeto: alfa87/Sistema-de-gestion-con-PyQt5

    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 4

Arquivo: pUsuario.py Projeto: robertoweller/estudos-python

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.usuario = Usuario()
        self.conexionUsuario = conexionUsuario()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 5

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.conexionCliente = conexionCliente()
        self.conexionTelefono = conexionTelefono()

        self.listTelefonosInit = []

        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 6

Arquivo: pProveedor.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

    def changeSelectedTable(self, selected, deselected):
        proveedorList = selected.model().mylist
        proveedorSelected = proveedorList[selected.row()]
        self.proveedor = Proveedor()
        self.direccion = Direccion()
        self.proveedor.setIdProveedor(int(proveedorSelected[0]))
        self.proveedor.setDescripcion(str(proveedorSelected[1]))
        self.proveedor.setNombre(str(proveedorSelected[2]))
        self.proveedor.setEmail(str(proveedorSelected[3]))
        self.proveedor.setWeb(str(proveedorSelected[4]))

        self.direccion.setDireccion(str(proveedorSelected[5]))
        if proveedorSelected[6] != None:
            self.direccion.setNumero(int(proveedorSelected[6]))

        if proveedorSelected[7] != None:
            self.direccion.setPiso(int(proveedorSelected[7]))

        if proveedorSelected[8] != None:
            self.direccion.setDpto(proveedorSelected[8])

        self.direccion.setIdDireccion(int(proveedorSelected[10]))
        self.proveedor.setDireccion(self.direccion)

        self.proveedor.setIdPersona(proveedorSelected[9])


        self.winPrincipal.tvProveedores_prov.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvProveedores_prov.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setModel(None)
        self.cargarTablaTelefono()

Exemplo n.º 7

Arquivo: pUsuario.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.usuario = Usuario()
        self.conexionUsuario = conexionUsuario()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 8

Arquivo: pProveedor.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 9

Arquivo: pCliente.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.conexionCliente = conexionCliente()
        self.conexionTelefono = conexionTelefono()

        self.listTelefonosInit = []

        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

Exemplo n.º 10

Arquivo: pCliente.py Projeto: Zeldex/PQt5-Stock-Venta-CuentaCorriente

    def changeSelectedTable(self, selected, deselected):

            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]
            self.cliente = Cliente()
            self.direccion = Direccion()
            self.cliente.setIdCliente(int(clienteSelected[0]))
            self.cliente.setApellido(clienteSelected[1])
            self.cliente.setNombre(clienteSelected[2])
            self.cliente.setEmail(clienteSelected[3])
            self.direccion = Direccion()
            self.direccion.setDireccion(clienteSelected[4])

            if clienteSelected[5] != None:
                self.direccion.setNumero(int(clienteSelected[5]))

            if clienteSelected[6] != None:
                self.direccion.setPiso(int(clienteSelected[6]))

            if clienteSelected[7] != None:
                self.direccion.setDpto(clienteSelected[7])

            self.direccion.setIdDireccion(int(clienteSelected[8]))
            self.cliente.setDireccion(self.direccion)

            self.cliente.setIdPersona(clienteSelected[9])

            self.winPrincipal.tvClientes_c.setRowHeight(deselected.row(), 28)
            self.winPrincipal.tvClientes_c.setRowHeight(selected.row(), 45)

            self.cliente.setEstado(int(clienteSelected[10]))

            self.setCampos()
            self.winPrincipal.btnModificar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.tvTelefonos_c.setModel(None)
            self.cargarTablaTelefono()

Exemplo n.º 11

Arquivo: pUsuario.py Projeto: robertoweller/estudos-python

    def changeSelectedTable(self, selected, deselected):
        usuarioList = selected.model().mylist
        usuarioSelected = usuarioList[selected.row()]
        self.usuario = Usuario()
        self.direccion = Direccion()
        self.usuario.setIdUsuario(int(usuarioSelected[0]))
        self.usuario.setNombre(str(usuarioSelected[1]))
        self.usuario.setApellido(str(usuarioSelected[2]))
        self.usuario.setUsuario(str(usuarioSelected[3]))

        self.usuario.setTipoUsuario(str(usuarioSelected[4]))

        self.usuario.setPasswd(str(usuarioSelected[5]))
        self.usuario.setEmail(str(usuarioSelected[6]))

        self.direccion.setDireccion(str(usuarioSelected[7]))
        if usuarioSelected[8] != None:
            self.direccion.setNumero(int(usuarioSelected[8]))

        if usuarioSelected[9] != None:
            self.direccion.setPiso(int(usuarioSelected[9]))

        if usuarioSelected[10] != None:
            self.direccion.setDpto(usuarioSelected[10])

        self.direccion.setIdDireccion(usuarioSelected[11])
        self.usuario.setDireccion(self.direccion)
        self.usuario.setIdPersona(usuarioSelected[12])
        self.winPrincipal.tvUsuarios_u.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvUsuarios_u.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnBorrar_u.setEnabled(True)
        self.winPrincipal.btnModificar_u.setEnabled(True)
        self.winPrincipal.tvTelefonos_u.setModel(None)
        self.cargarTablaTelefono()

Exemplo n.º 12

Arquivo: pUsuario.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

    def changeSelectedTable(self, selected, deselected):
        usuarioList = selected.model().mylist
        usuarioSelected = usuarioList[selected.row()]
        self.usuario = Usuario()
        self.direccion = Direccion()
        self.usuario.setIdUsuario(int(usuarioSelected[0]))
        self.usuario.setNombre(str(usuarioSelected[1]))
        self.usuario.setApellido(str(usuarioSelected[2]))
        self.usuario.setUsuario(str(usuarioSelected[3]))


        self.usuario.setTipoUsuario(str(usuarioSelected[4]))

        self.usuario.setPasswd(str(usuarioSelected[5]))
        self.usuario.setEmail(str(usuarioSelected[6]))

        self.direccion.setDireccion(str(usuarioSelected[7]))
        if usuarioSelected[8] != None:
            self.direccion.setNumero(int(usuarioSelected[8]))

        if usuarioSelected[9] != None:
            self.direccion.setPiso(int(usuarioSelected[9]))

        if usuarioSelected[10] != None:
            self.direccion.setDpto(usuarioSelected[10])

        self.direccion.setIdDireccion(usuarioSelected[11])
        self.usuario.setDireccion(self.direccion)
        self.usuario.setIdPersona(usuarioSelected[12])
        self.winPrincipal.tvUsuarios_u.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvUsuarios_u.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnBorrar_u.setEnabled(True)
        self.winPrincipal.btnModificar_u.setEnabled(True)
        self.winPrincipal.tvTelefonos_u.setModel(None)
        self.cargarTablaTelefono()

Exemplo n.º 13

 def __init__(self):
     self.__idPersona = 0
     self.__nombre = ""
     self.__email = ""
     self.__direccion = Direccion()

Exemplo n.º 14

Arquivo: pCliente.py Projeto: Wilo/Sistema-de-gestion-con-PyQt5

class PestaniaCliente():

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.conexionCliente = conexionCliente()
        self.conexionTelefono = conexionTelefono()

        self.listTelefonosInit = []

        self.estado = ""
        self.direccion = Direccion()

        self.configInit()



    def configInit(self):

        #Configurando botones Generales
        self.winPrincipal.btnAgregar_c.clicked.connect(self.onClickAgregar_c)
        self.winPrincipal.btnGuardar_c.clicked.connect(self.onClickGuardar_c)
        self.winPrincipal.btnBorrar_c.clicked.connect(self.onClickBorrar_c)
        self.winPrincipal.btnModificar_c.clicked.connect(self.onClickModificar_c)

        #Configurando botones ABM telefono
        self.winPrincipal.btnSumarTelefono_c.clicked.connect(self.onClickSumarTelefono)
        self.winPrincipal.btnRestarTelefono_c.clicked.connect(self.onClickRestarTelefono)
        self.winPrincipal.btnCancelarTelefono_c.clicked.connect(self.onClickCancelarTelefono)
        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)

        #configurando botones tipo telefono
        self.winPrincipal.btnTelefono_c.clicked.connect(self.onClickTelefono)
        self.winPrincipal.btnCelular_c.clicked.connect(self.onClickCelular)
        self.winPrincipal.btnFax_c.clicked.connect(self.onClickFax)


        #Seteando model y propiedades a la tabla
        self.cargarTabla()
        self.winPrincipal.tvClientes_c.setSortingEnabled(True)
        self.winPrincipal.tvClientes_c.setMouseTracking(True)
        self.winPrincipal.tvClientes_c.setSelectionBehavior(QAbstractItemView.SelectRows)


        #Seteando proiedades de la tabla telefono
        self.winPrincipal.tvTelefonos_c.setSortingEnabled(True)
        self.winPrincipal.tvTelefonos_c.setMouseTracking(True)
        self.winPrincipal.tvTelefonos_c.setSelectionBehavior(QAbstractItemView.SelectRows)



    def onClickAgregar_c(self):
        self.estado = 'AGREGAR'
        self.validarBotones(button='AGREGAR')


    def onClickGuardar_c(self):
        validar = self.validar()

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", validar)
        else:
            self.cliente.setApellido(self.winPrincipal.txtApellido_c.text())
            self.cliente.setNombre(self.winPrincipal.txtNombre_c.text())
            self.direccion.setDireccion(self.winPrincipal.txtDireccion_c.text())
            self.cliente.setEmail(self.winPrincipal.txtEmail_c.text())

            if self.winPrincipal.txtDDpto_c.text() != "":
                self.direccion.setDpto(str(self.winPrincipal.txtDDpto_c.text()))
            else:
                self.direccion.setDpto("")
            if self.winPrincipal.txtDNumero_c.text() != "":
                self.direccion.setNumero(int(self.winPrincipal.txtDNumero_c.text()))
            else:
                self.direccion.setNumero(0)
            if self.winPrincipal.txtDPiso_c.text() != "":
                self.direccion.setPiso(int(self.winPrincipal.txtDPiso_c.text()))
            else:
                self.direccion.setPiso(0)
            self.cliente.setDireccion(self.direccion)


            if self.estado == 'AGREGAR':
                self.insertCliente()
                self.insertTelefono()
            elif self.estado == 'MODIFICAR':
                self.modificarCliente()
                self.updateTelefono()

            self.validarBotones(button='GUARDAR')


    def onClickModificar_c(self):
        self.estado = 'MODIFICAR'
        self.validarBotones(button='MODIFICAR')


    def onClickBorrar_c(self):
        if self.winPrincipal.btnGuardar_c.isEnabled() != True:
            self.conexionCliente.borrarCliente(self.cliente)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')


    def cargarTabla(self):
        #listaClientes = []
        listaClientes = self.conexionCliente.selectCliente()
        header = ['ID','Apellido','Nombre','Email','Direccion', 'N°', 'Piso', 'Dpto', 'iddir', 'idper']
        self.tablaModel = MyTableModel(self.winPrincipal.tvClientes_c, listaClientes, header)
        self.winPrincipal.tvClientes_c.setModel(self.tablaModel)
        self.winPrincipal.tvClientes_c.selectionModel().currentChanged.connect(self.changeSelectedTable)


        self.winPrincipal.tvClientes_c.setColumnHidden(0, True)
        self.winPrincipal.tvClientes_c.setColumnWidth(1, 208)
        self.winPrincipal.tvClientes_c.setColumnWidth(2, 220)
        self.winPrincipal.tvClientes_c.setColumnWidth(3, 280)
        self.winPrincipal.tvClientes_c.setColumnWidth(4, 364)
        self.winPrincipal.tvClientes_c.setColumnWidth(5, 50)
        self.winPrincipal.tvClientes_c.setColumnHidden(6, True)
        self.winPrincipal.tvClientes_c.setColumnHidden(7, True)
        self.winPrincipal.tvClientes_c.setColumnHidden(8, True)
        self.winPrincipal.tvClientes_c.setColumnHidden(9, True)

    def changeSelectedTable(self, selected, deselected):

            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]
            self.cliente = Cliente()
            self.direccion = Direccion()
            self.cliente.setIdCliente(int(clienteSelected[0]))
            self.cliente.setApellido(clienteSelected[1])
            self.cliente.setNombre(clienteSelected[2])
            self.cliente.setEmail(clienteSelected[3])
            self.direccion = Direccion()
            self.direccion.setDireccion(clienteSelected[4])

            if clienteSelected[5] != None:
                self.direccion.setNumero(int(clienteSelected[5]))

            if clienteSelected[6] != None:
                self.direccion.setPiso(int(clienteSelected[6]))

            if clienteSelected[7] != None:
                self.direccion.setDpto(clienteSelected[7])

            self.direccion.setIdDireccion(int(clienteSelected[8]))
            self.cliente.setDireccion(self.direccion)

            self.cliente.setIdPersona(clienteSelected[9])

            self.winPrincipal.tvClientes_c.setRowHeight(deselected.row(), 28)
            self.winPrincipal.tvClientes_c.setRowHeight(selected.row(), 45)


            self.setCampos()
            self.winPrincipal.btnModificar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.tvTelefonos_c.setModel(None)
            self.cargarTablaTelefono()

    def validarBotones(self, button):
        if button == 'AGREGAR' :
            self.winPrincipal.wDatosCliente.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setText('CANCELAR')
            self.winPrincipal.btnGuardar_c.setEnabled(True)
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(False)
            self.limpiarCampos()

        elif button=='GUARDAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(True)
            self.winPrincipal.btnGuardar_c.setEnabled(False)
            self.winPrincipal.btnBorrar_c.setText('BORRAR')
            self.winPrincipal.btnBorrar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(True)
            self.winPrincipal.wDatosCliente.setEnabled(False)
            self.limpiarCampos()

        elif button == 'MODIFICAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(False)
            self.winPrincipal.btnGuardar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setText('Cancelar')
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.tvClientes_c.setEnabled(False)
            self.winPrincipal.wDatosCliente.setEnabled(True)

        elif button=='BORRAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(True)
            self.winPrincipal.btnGuardar_c.setEnabled(False)
            self.winPrincipal.btnBorrar_c.setText('BORRAR')
            self.winPrincipal.btnBorrar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(True)
            self.winPrincipal.wDatosCliente.setEnabled(False)
            self.limpiarCampos()


    def insertCliente(self):
        if self.cliente.getApellido() != '':
            self.conexionCliente.insertarCliente(cliente=self.cliente)
            self.cargarTabla()

    def modificarCliente(self):
            self.conexionCliente.modificarCliente(self.cliente)
            self.cargarTabla()

    def limpiarCampos(self):
        self.winPrincipal.txtApellido_c.setText('')
        self.winPrincipal.txtNombre_c.setText('')
        self.winPrincipal.txtDireccion_c.setText('')
        self.winPrincipal.txtDNumero_c.setText('')
        self.winPrincipal.txtDPiso_c.setText('')
        self.winPrincipal.txtDDpto_c.setText('')
        self.winPrincipal.txtEmail_c.setText('')
        self.winPrincipal.tvTelefonos_c.setModel(None)

    def setCampos(self):
        self.winPrincipal.txtApellido_c.setText(self.cliente.getApellido())
        self.winPrincipal.txtNombre_c.setText(self.cliente.getNombre())
        self.winPrincipal.txtEmail_c.setText(self.cliente.getEmail())

        self.winPrincipal.txtDireccion_c.setText(self.cliente.getDireccion().getDireccion())
        
        if self.cliente.getDireccion().getNumero() != None:
            self.winPrincipal.txtDNumero_c.setText(str(self.cliente.getDireccion().getNumero()))
        else:
            self.winPrincipal.txtDNumero_c.setText('')            
        
        if self.cliente.getDireccion().getPiso() != None:
            self.winPrincipal.txtDPiso_c.setText(str(self.cliente.getDireccion().getPiso()))
        else:
            self.winPrincipal.txtDPiso_c.setText('')

        if self.cliente.getDireccion().getDpto() != None:
            self.winPrincipal.txtDDpto_c.setText(self.cliente.getDireccion().getDpto())
        else:
            self.winPrincipal.txtDDpto_c.setText('')

        

    def validar(self):
        mensaje = ''
        if self.winPrincipal.txtNombre_c.text() == '':
            mensaje = "Falta ingresar un Nombre"
        elif self.winPrincipal.txtApellido_c.text() == '':
            mensaje = "Falta ingresar Apellido"
        elif self.winPrincipal.txtDireccion_c.text() == '':
            mensaje = "Falta ingresar una Direccion"
        elif self.winPrincipal.txtDNumero_c.text() == '':
            mensaje = "Falta ingresar un N° de Direccion"

        return mensaje


    def cargarTablaTelefono(self):
        self.listTelefonosInit = self.conexionTelefono.selectTelefono(self.cliente)
        if len(self.listTelefonosInit) >0:
            header = ['ID', 'Numero', 'TIPO']
            tableModel = MyTableModel(self.winPrincipal, self.listTelefonosInit, header)
            self.winPrincipal.tvTelefonos_c.setModel(tableModel)
            self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

            self.winPrincipal.tvTelefonos_c.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(2, 175)

            for r in range(0, len(self.listTelefonosInit)):
                self.winPrincipal.tvTelefonos_c.setRowHidden(r, False)



    def changeSelectedTableTel(self, selected, deselected):
        listTelefonos = selected.model().mylist
        self.telefonoSelected = ()
        self.telefonoSelected = listTelefonos[selected.row()]

        self.telefonoSelectedRow = selected.row()
        self.winPrincipal.txtTelefono_c.setText(str(self.telefonoSelected[2]))

        self.setTipoTelefono(str(self.telefonoSelected[1]))
        self.winPrincipal.btnCancelarTelefono_c.setVisible(True)
        self.winPrincipal.btnRestarTelefono_c.setEnabled(True)
        self.winPrincipal.tvTelefonos_c.setEnabled(False)

        self.winPrincipal.btnGuardar_c.setEnabled(False)

    def updateTelefono(self):

        listTelefono = []
        listTelefono = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

        estado = ''
        telNew = Telefono()
        if len(listTelefono) > 0:
            if len(self.listTelefonosInit) > 0:

                listTelInit = list(self.listTelefonosInit)
                parche = (listTelefono[0][0], listTelefono[0][1], str(listTelefono[0][2]))
                listTelefono[0] = parche
                #Recorre la lista de telefono inicial
                for telInit in listTelInit:
                    #recorre la lista de telefonos nueva
                    for tel in listTelefono:
                        telNew.setIdPersona(self.cliente.getIdPersona())
                        telNew.setIdTelefono(tel[0])
                        telNew.setTipo(tel[1])
                        if tel[2] == "":
                            estado = 'DEL'
                            break
                        else:
                            telNew.setTelefono(tel[2])

                        if tel[0] == 0:
                            estado = 'INS'
                            break

                        if telInit[0] == tel[0]:
                            if telInit[1] != tel[1] or telInit[2] != tel[2]:
                                estado = 'UPD'
                                break

                    if estado == 'UPD':
                        self.conexionTelefono.modificarTelefono(telNew)
                    elif estado == "INS":
                        self.conexionTelefono.insertarTelefono(telNew)
                    elif estado == 'DEL':
                        self.conexionTelefono.borrarTelefono(telNew)
            #Si la lista de telefono inicial es cero
            else:
                #recorre la lista de telefonos nueva para agregarlos a todos
                for telN in listTelefono:
                    if telN[2] != '':
                        telNew = Telefono()
                        telNew.setIdPersona(self.cliente.getIdPersona())
                        telNew.setIdTelefono(telN[0])
                        telNew.setTipo(telN[1])
                        telNew.setTelefono(telN[2])
                        self.conexionTelefono.insertarTelefono(telNew)



    def insertTelefono(self):

        listTelefonosNew = []
        tel = self.winPrincipal.tvTelefonos_c.model()

        listTelefonosNew = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

        if len(listTelefonosNew) > 0:
            self.conexionTelefono.insertTelefonoInit(listTelefonosNew)


    def onClickCancelarTelefono(self):
        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.txtTelefono_c.setText('')

        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
        self.winPrincipal.tvTelefonos_c.clearSelection()
        self.winPrincipal.tvTelefonos_c.setEnabled(True)

        self.winPrincipal.btnGuardar_c.setEnabled(True)

    def onClickSumarTelefono(self):
        numTelefono = self.winPrincipal.txtTelefono_c.text()

        if numTelefono.isdigit() == True:
            if self.winPrincipal.btnCancelarTelefono_c.isVisible() is True:
                self.updateTelefonoTabla()
            else:
                self.insertTelefonoTabla()

            self.winPrincipal.tvTelefonos_c.clearSelection()
            self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
            self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
            self.winPrincipal.txtTelefono_c.setText('')
            self.winPrincipal.tvTelefonos_c.setEnabled(True)

            self.winPrincipal.btnGuardar_c.setEnabled(True)
        else:
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", "El numero de telefono no es valido.")


    def onClickRestarTelefono(self):
        listTabTel = []
        #listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []

        listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

        header = ['Id', 'Tipo', 'Numero']
        telDel = [self.telefonoSelected[0], self.telefonoSelected[1], '']
        listTabTel[self.telefonoSelectedRow] = telDel
        tableTelModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_c.setModel(tableTelModel)
        self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        self.winPrincipal.tvTelefonos_c.setRowHidden(self.telefonoSelectedRow, True)

        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.txtTelefono_c.setText('')
        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
        self.winPrincipal.tvTelefonos_c.setEnabled(True)

        self.winPrincipal.btnGuardar_c.setEnabled(True)

    def onClickTelefono(self):
        self.changeTipoTelefono(button='TEL')

    def onClickCelular(self):
        self.changeTipoTelefono(button='CEL')

    def onClickFax(self):
        self.changeTipoTelefono(button='FAX')

    def changeTipoTelefono(self, button):

        if button == 'TEL':
            self.winPrincipal.btnTelefono_c.setEnabled(False)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif button == 'CEL':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(False)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif button == 'FAX':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(False)


    def setTipoTelefono(self, tipoTelefono):

        if tipoTelefono == 'TEL':
            self.winPrincipal.btnTelefono_c.setEnabled(False)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif tipoTelefono == 'CEL':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(False)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif tipoTelefono == 'FAX':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(False)

    def getTipoTelefono(self):

        if self.winPrincipal.btnTelefono_c.isEnabled() != True:
            return 'TEL'
        elif self.winPrincipal.btnCelular_c.isEnabled() != True:
            return 'CEL'
        elif self.winPrincipal.btnFax_c.isEnabled() != True:
            return 'FAX'


    def insertTelefonoTabla(self):
        numTel = self.winPrincipal.txtTelefono_c.text()
        tipoTel = str(self.getTipoTelefono())

        modelListTelefono = self.winPrincipal.tvTelefonos_c.model()
        header = ['ID', 'Tipo', 'Numero']

        if modelListTelefono is not None:
            listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist)

            if len(listTabTel) > 0 or listTabTel is not None:
                tuplaTel = ('0', tipoTel, numTel )
                listTabTel.append(tuplaTel)
                tupleTable = tuple(listTabTel)

                tableModel = MyTableModel(self.winPrincipal, tupleTable , header)
                self.winPrincipal.tvTelefonos_c.setModel(tableModel)
                self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        else:
            lista = []
            tuplaTel = ('0', tipoTel, numTel )
            lista.append(tuplaTel)

            tableModel = MyTableModel(self.winPrincipal, lista , header)
            self.winPrincipal.tvTelefonos_c.setModel(tableModel)
            self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvTelefonos_c.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(2, 175)


    def updateTelefonoTabla(self):
        listTabTel = []
        #listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []
        prob = self.winPrincipal.tvTelefonos_c.selectionModel()
        prob1 = self.winPrincipal.tvTelefonos_c.model()
        listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        """
        for lt in listTabTel:
            if lt[0] == self.telefonoSelected[0]:
                lt = (self.telefonoSelected[0], tipoTel, self.winPrincipal.txtTelefono_c.text())

            listTelefonosNew.append(lt)
        """
        telUpd = (self.telefonoSelected[0], tipoTel, int(self.winPrincipal.txtTelefono_c.text()))
        listTabTel[self.telefonoSelectedRow] = telUpd
        header = ['ID', 'Tipo', 'Numero']
        tableModel = MyTableModel(self.winPrincipal, listTabTel , header)
        self.winPrincipal.tvTelefonos_c.setModel(tableModel)
        self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

Exemplo n.º 15

Arquivo: pProveedor.py Projeto: Zeldex/PQt5-Stock-Venta-CuentaCorriente

class PestaniaProveedor():

    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()


        self.configInit()


    def configInit(self):
        """
        Configuracion inicial de la pestaña probeedor, setea todas las señales de los botones y carga la tabla
        @return: void
        """
         #Configurando botones Generales
        self.winPrincipal.btnGuardar_prov.clicked.connect(self.onClickGuardar)
        self.winPrincipal.btnAgregar_prov.clicked.connect(self.onClickAgregar)
        self.winPrincipal.btnModificar_prov.clicked.connect(self.onClickModificar)
        self.winPrincipal.btnBorrar_prov.clicked.connect(self.onClickBorrar)

        #Configurando botones ABM telefono
        self.winPrincipal.btnSumarTelefono_prov.clicked.connect(self.onClickSumarTelefono)
        self.winPrincipal.btnRestarTelefono_prov.clicked.connect(self.onClickRestarTelefono)
        self.winPrincipal.btnCancelarTelefono_prov.clicked.connect(self.onClickCancelarTelefono)
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)

        #configurando botones tipo telefono
        self.winPrincipal.btnTelefono_prov.clicked.connect(self.onClickTelefono)
        self.winPrincipal.btnCelular_prov.clicked.connect(self.onClickCelular)
        self.winPrincipal.btnFax_prov.clicked.connect(self.onClickFax)

        self.winPrincipal.txtFilterProveedores_prov.returnPressed.connect(self.search)

        #Seteando model y propieades de la tabla
        self.winPrincipal.tvProveedores_prov.setSortingEnabled(True)
        self.winPrincipal.tvProveedores_prov.setMouseTracking(True)
        self.winPrincipal.tvProveedores_prov.setSelectionBehavior(QAbstractItemView.SelectRows)

        #Seteando proiedades de la tabla telefono
        self.winPrincipal.tvTelefonos_prov.setSortingEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setMouseTracking(True)
        self.winPrincipal.tvTelefonos_prov.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.txtFilterProveedores_prov.setFocus(True)


    def finish(self):
        self.winPrincipal.btnAgregar_prov.disconnect()
        self.winPrincipal.btnBorrar_prov.disconnect()
        self.winPrincipal.btnModificar_prov.disconnect()
        self.winPrincipal.btnGuardar_prov.disconnect()

        self.winPrincipal.btnCancelarTelefono_prov.disconnect()
        self.winPrincipal.btnSumarTelefono_prov.disconnect()
        self.winPrincipal.btnRestarTelefono_prov.disconnect()

        self.winPrincipal.btnCelular_prov.disconnect()
        self.winPrincipal.btnFax_prov.disconnect()
        self.winPrincipal.btnTelefono_prov.disconnect()

        self.winPrincipal.tvTelefonos_prov.disconnect()
        self.winPrincipal.tvProveedores_prov.disconnect()

    def search(self):
        if self.winPrincipal.txtFilterProveedores_prov.hasFocus() is True:
            self.cargarTabla()

    def onClickAgregar(self):
        self.estado = 'AGREGAR'
        self.validarBotones(button='AGREGAR')


    def onClickGuardar(self):
        validar = self.validar()

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", validar)
        else:
            self.proveedor.setDescripcion(str(self.winPrincipal.txtDescripcion_prov.text()))
            self.proveedor.setWeb(str(self.winPrincipal.txtWeb_prov.text()))
            self.proveedor.setEmail(str(self.winPrincipal.txtEmail_prov.text()))
            self.proveedor.setNombre(str(self.winPrincipal.txtNombre_prov.text()))
            self.direccion.setDireccion(str(self.winPrincipal.txtDireccion_prov.text()))
            if self.winPrincipal.txtDDpto_prov.text() != "":
                self.direccion.setDpto(str(self.winPrincipal.txtDDpto_prov.text()))
            else:
                self.direccion.setDpto("")
            if self.winPrincipal.txtDNumero_prov.text() != "":
                self.direccion.setNumero(int(self.winPrincipal.txtDNumero_prov.text()))
            else:
                self.direccion.setNumero(0)
            if self.winPrincipal.txtDPiso_prov.text() != "":
                self.direccion.setPiso(int(self.winPrincipal.txtDPiso_prov.text()))
            else:
                self.direccion.setPiso(0)

            self.proveedor.setDireccion(self.direccion)

            if self.winPrincipal.cbEstado_prov.currentText() == 'ACTIVO':
                self.proveedor.setEstado(1)
            else:
                self.proveedor.setEstado(0)

            self.validarBotones(button='GUARDAR')

            if self.estado == 'AGREGAR':
                self.insertProveedor()
                self.insertTelefono()
            elif self.estado == 'MODIFICAR':
                self.modificarProveedor()
                self.updateTelefono()


    def onClickModificar(self):
        self.estado = 'MODIFICAR'
        self.validarBotones(button='MODIFICAR')


    def onClickBorrar(self):

        if self.winPrincipal.btnGuardar_prov.isEnabled() != True:
            self.conexionProveedor.borrarProveedor(self.proveedor)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')


    def cargarTabla(self):
        parameter = self.winPrincipal.txtFilterProveedores_prov.text()
        typeParameter = ''

        if self.winPrincipal.cbFilterProveedores_prov.currentText() == 'Descripcion':
            typeParameter = 'prov.descripcion'
        else:
            typeParameter = 'p.nombre'

        parameterState = 1
        if self.winPrincipal.cbInactivo_prov.isChecked() is True:
            parameterState = 0

        listProveedores = self.conexionProveedor.selectProveedor(typeParameter, parameter, parameterState)

        if len(listProveedores) > 0:
            header = ['ID', 'Descripcion', 'Nombre', 'Email', 'Web', 'Direccion', 'N°', 'P', 'D', 'idper', 'iddir', 'Estado' ]
            tableModel = MyTableModel(self.winPrincipal.tvProveedores_prov, listProveedores, header)
            self.winPrincipal.tvProveedores_prov.setModel(tableModel)
            self.winPrincipal.tvProveedores_prov.selectionModel().currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvProveedores_prov.setColumnHidden(0, True)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(1, 190)

            self.winPrincipal.tvProveedores_prov.setColumnWidth(2, 190)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(3, 263)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(4, 240)


            self.winPrincipal.tvProveedores_prov.setColumnWidth(5, 200)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(6, 50)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(7, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(8, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(9, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(10, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(11, True)
        else:
            self.winPrincipal.tvProveedores_prov.setModel(None)


    def changeSelectedTable(self, selected, deselected):
        proveedorList = selected.model().mylist
        proveedorSelected = proveedorList[selected.row()]
        self.proveedor = Proveedor()
        self.direccion = Direccion()
        self.proveedor.setIdProveedor(int(proveedorSelected[0]))
        self.proveedor.setDescripcion(str(proveedorSelected[1]))
        self.proveedor.setNombre(str(proveedorSelected[2]))
        self.proveedor.setEmail(str(proveedorSelected[3]))
        self.proveedor.setWeb(str(proveedorSelected[4]))

        self.direccion.setDireccion(str(proveedorSelected[5]))
        if proveedorSelected[6] != None:
            self.direccion.setNumero(int(proveedorSelected[6]))

        if proveedorSelected[7] != None:
            self.direccion.setPiso(int(proveedorSelected[7]))

        if proveedorSelected[8] != None:
            self.direccion.setDpto(proveedorSelected[8])

        self.direccion.setIdDireccion(int(proveedorSelected[10]))
        self.proveedor.setDireccion(self.direccion)

        self.proveedor.setIdPersona(int(proveedorSelected[9]))

        self.proveedor.setEstado(int(proveedorSelected[11]))

        self.winPrincipal.tvProveedores_prov.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvProveedores_prov.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setModel(None)
        self.cargarTablaTelefono()


    def validarBotones(self, button):

        if button == 'AGREGAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(False)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setEnabled(True)
            self.winPrincipal.tvProveedores_prov.setEnabled(False)
            self.winPrincipal.wDatosProveedor.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setText('CANCELAR')
            self.limpiarCampos()
        elif button == 'GUARDAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(True)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setEnabled(False)
            self.winPrincipal.tvProveedores_prov.setEnabled(True)
            self.winPrincipal.wDatosProveedor.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setText('BORRAR')
            self.limpiarCampos()
        elif button == 'MODIFICAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(False)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setEnabled(True)
            self.winPrincipal.tvProveedores_prov.setEnabled(False)
            self.winPrincipal.wDatosProveedor.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setText('CANCELAR')
        elif button == 'BORRAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(True)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setEnabled(False)
            self.winPrincipal.tvProveedores_prov.setEnabled(True)
            self.winPrincipal.wDatosProveedor.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setText('BORRAR')
            self.limpiarCampos()


    def insertProveedor(self):
        self.conexionProveedor.insertarProveedor(proveedor=self.proveedor)
        self.cargarTabla()


    def modificarProveedor(self):
        self.conexionProveedor.modificarProveedor(proveedor=self.proveedor)
        self.cargarTabla()


    def limpiarCampos(self):
        self.winPrincipal.txtNombre_prov.setText('')
        self.winPrincipal.txtDescripcion_prov.setText('')
        self.winPrincipal.txtEmail_prov.setText('')
        self.winPrincipal.txtDireccion_prov.setText('')
        self.winPrincipal.txtDNumero_prov.setText('')
        self.winPrincipal.txtDPiso_prov.setText('')
        self.winPrincipal.txtDDpto_prov.setText('')
        self.winPrincipal.txtWeb_prov.setText('')
        self.winPrincipal.tvTelefonos_prov.setModel(None)
        self.winPrincipal.cbEstado_prov.setCurrentIndex(0)
        self.winPrincipal.txtFilterProveedores_prov.setText('')
        self.winPrincipal.tvProveedores_prov.setModel(None)

        self.winPrincipal.txtFilterProveedores_prov.setFocus(True)


    def setCampos(self):
        self.winPrincipal.txtDescripcion_prov.setText(str(self.proveedor.getDescripcion()))
        self.winPrincipal.txtEmail_prov.setText(str(self.proveedor.getEmail()))
        self.winPrincipal.txtNombre_prov.setText(str(self.proveedor.getNombre()))
        self.winPrincipal.txtWeb_prov.setText(str(self.proveedor.getWeb()))

        self.winPrincipal.txtDireccion_prov.setText(str(self.proveedor.getDireccion().getDireccion()))

        if self.proveedor.getDireccion().getNumero() is not None:
            self.winPrincipal.txtDNumero_prov.setText(str(self.proveedor.getDireccion().getNumero()))
        else:
            self.winPrincipal.txtDNumero_prov.setText('')

        if self.proveedor.getDireccion().getPiso() is not None:
            self.winPrincipal.txtDPiso_prov.setText(str(self.proveedor.getDireccion().getPiso()))
        else:
            self.winPrincipal.txtDPiso_prov.setText('')

        if self.proveedor.getDireccion().getDpto() is not None:
            self.winPrincipal.txtDDpto_prov.setText(self.proveedor.getDireccion().getDpto())
        else:
            self.winPrincipal.txtDDpto_prov.setText('')

        if self.proveedor.getEstado() == 1:
            self.winPrincipal.cbEstado_prov.setCurrentIndex(0)
        else:
            self.winPrincipal.cbEstado_prov.setCurrentIndex(1)


    def validar(self):
        mensaje = ''
        if self.winPrincipal.txtNombre_prov.text() == '':
            mensaje = "Falta ingresar un Nombre"
        elif self.winPrincipal.txtDescripcion_prov.text() == '':
            mensaje = "Falta ingresa la descripcion"
        elif self.winPrincipal.txtDireccion_prov.text() == '':
            mensaje = "Falta ingresar una Direccion"
        elif self.winPrincipal.txtDNumero_prov.text() == '':
            mensaje = "Falta ingresar un N° de Direccion"

        return mensaje


    def cargarTablaTelefono(self):
        self.listTelefonosInit = self.conexionTelefono.selectTelefono(self.proveedor)
        if len(self.listTelefonosInit) >0:
            header = ['ID', 'Numero', 'TIPO']
            tableModel = MyTableModel(self.winPrincipal, self.listTelefonosInit, header)
            self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
            self.winPrincipal.tvTelefonos_prov.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

            self.winPrincipal.tvTelefonos_prov.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(2, 175)

            for r in range(0, len(self.listTelefonosInit)):
                self.winPrincipal.tvTelefonos_prov.setRowHidden(r, False)


    def changeSelectedTableTel(self, selected, deselected):
        listTelefonos = selected.model().mylist
        self.telefonoSelected = ()
        self.telefonoSelected = listTelefonos[selected.row()]

        self.telefonoSelectedRow = selected.row()
        self.winPrincipal.txtTelefono_prov.setText(str(self.telefonoSelected[2]))

        self.setTipoTelefono(str(self.telefonoSelected[1]))
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(True)
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setEnabled(False)

        self.winPrincipal.btnGuardar_prov.setEnabled(False)
        self.winPrincipal.btnBorrar_prov.setEnabled(False)


    def updateTelefono(self):

        listTelefono = []
        if self.winPrincipal.tvTelefonos_prov.model() != None and \
                        len(self.winPrincipal.tvTelefonos_prov.model().mylist) > 0:
            listTelefono = list(self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

            estado = ''
            telNew = Telefono()
            if len(listTelefono) > 0:
                if len(self.listTelefonosInit) > 0:

                    listTelInit = list(self.listTelefonosInit)
                    parche = (listTelefono[0][0], listTelefono[0][1], str(listTelefono[0][2]))
                    listTelefono[0] = parche
                    #Recorre la lista de telefono inicial
                    for telInit in listTelInit:
                        #recorre la lista de telefonos nueva
                        for tel in listTelefono:
                            telNew.setIdPersona(self.proveedor.getIdPersona())
                            telNew.setIdTelefono(tel[0])
                            telNew.setTipo(tel[1])
                            if tel[2] == "":
                                estado = 'DEL'
                                break
                            else:
                                telNew.setTelefono(tel[2])

                            if tel[0] == 0:
                                estado = 'INS'
                                break

                            if telInit[0] == tel[0]:
                                if telInit[1] != tel[1] or telInit[2] != tel[2]:
                                    estado = 'UPD'
                                    break

                        if estado == 'UPD':
                            self.conexionTelefono.modificarTelefono(telNew)
                        elif estado == "INS":
                            self.conexionTelefono.insertarTelefono(telNew)
                        elif estado == 'DEL':
                            self.conexionTelefono.borrarTelefono(telNew)
                #Si la lista de telefono inicial es cero
                else:
                    #recorre la lista de telefonos nueva para agregarlos a todos
                    for telN in listTelefono:
                        if telN[2] != '':
                            telNew = Telefono()
                            telNew.setIdPersona(self.proveedor.getIdPersona())
                            telNew.setIdTelefono(telN[0])
                            telNew.setTipo(telN[1])
                            telNew.setTelefono(telN[2])
                            self.conexionTelefono.insertarTelefono(telNew)


    def insertTelefono(self):

        listTelefonosNew = []
        tel = self.winPrincipal.tvTelefonos_prov.model()

        listTelefonosNew = list(self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        if len(listTelefonosNew) > 0:
            self.conexionTelefono.insertTelefonoInit(listTelefonosNew)


    def onClickCancelarTelefono(self):
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.txtTelefono_prov.setText('')

        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
        self.winPrincipal.tvTelefonos_prov.clearSelection()
        self.winPrincipal.tvTelefonos_prov.setEnabled(True)

        self.winPrincipal.btnGuardar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)


    def onClickSumarTelefono(self):
        numTelefono = self.winPrincipal.txtTelefono_prov.text()

        if numTelefono.isdigit() == True:
            if self.winPrincipal.btnCancelarTelefono_prov.isVisible() is True:
                self.updateTelefonoTabla()
            else:
                self.insertTelefonoTabla()

            self.winPrincipal.tvTelefonos_prov.clearSelection()
            self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
            self.winPrincipal.txtTelefono_prov.setText('')
            self.winPrincipal.tvTelefonos_prov.setEnabled(True)

            self.winPrincipal.btnGuardar_prov.setEnabled(True)
        else:
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", "El numero de telefono no es valido.")


    def onClickRestarTelefono(self):
        listTabTel = []

        #tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []

        listTabTel = list(self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        header = ['Id', 'Tipo', 'Numero']
        telDel = [self.telefonoSelected[0], self.telefonoSelected[1], '']
        listTabTel[self.telefonoSelectedRow] = telDel
        tableTelModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_prov.setModel(tableTelModel)
        self.winPrincipal.tvTelefonos_prov.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        self.winPrincipal.tvTelefonos_prov.setRowHidden(self.telefonoSelectedRow, True)

        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.txtTelefono_prov.setText('')
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
        self.winPrincipal.tvTelefonos_prov.setEnabled(True)

        self.winPrincipal.btnGuardar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)


    def onClickTelefono(self):
        self.changeTipoTelefono(button='TEL')


    def onClickCelular(self):
        self.changeTipoTelefono(button='CEL')


    def onClickFax(self):
        self.changeTipoTelefono(button='FAX')


    def changeTipoTelefono(self, button):

        if button == 'TEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif button == 'CEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(False)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif button == 'FAX':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(False)


    def setTipoTelefono(self, tipoTelefono):

        if tipoTelefono == 'TEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif tipoTelefono == 'CEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(False)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif tipoTelefono == 'FAX':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(False)


    def getTipoTelefono(self):

        if self.winPrincipal.btnTelefono_prov.isEnabled() != True:
            return 'TEL'
        elif self.winPrincipal.btnCelular_prov.isEnabled() != True:
            return 'CEL'
        elif self.winPrincipal.btnFax_prov.isEnabled() != True:
            return 'FAX'


    def insertTelefonoTabla(self):
        numTel = self.winPrincipal.txtTelefono_prov.text()
        tipoTel = str(self.getTipoTelefono())

        modelListTelefono = self.winPrincipal.tvTelefonos_prov.model()
        header = ['ID', 'Tipo', 'Numero']

        if modelListTelefono is not None:
            listTabTel = list(self.winPrincipal.tvTelefonos_prov.model().mylist)

            if len(listTabTel) > 0 or listTabTel is not None:
                tuplaTel = ('0', tipoTel, numTel )
                listTabTel.append(tuplaTel)
                tupleTable = tuple(listTabTel)

                tableModel = MyTableModel(self.winPrincipal, tupleTable , header)
                self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
                self.winPrincipal.tvTelefonos_prov.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        else:
            lista = []
            tuplaTel = ('0', tipoTel, numTel )
            lista.append(tuplaTel)

            tableModel = MyTableModel(self.winPrincipal, lista , header)
            self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
            self.winPrincipal.tvTelefonos_prov.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvTelefonos_prov.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(2, 175)


    def updateTelefonoTabla(self):
        listTabTel = []

        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []
        prob = self.winPrincipal.tvTelefonos_prov.selectionModel()
        prob1 = self.winPrincipal.tvTelefonos_prov.model()
        listTabTel = list(self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        telUpd = (self.telefonoSelected[0], tipoTel, int(self.winPrincipal.txtTelefono_prov.text()))
        listTabTel[self.telefonoSelectedRow] = telUpd
        header = ['ID', 'Tipo', 'Numero']
        tableModel = MyTableModel(self.winPrincipal, listTabTel , header)
        self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
        self.winPrincipal.tvTelefonos_prov.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

Exemplo n.º 16

Arquivo: pProveedor.py Projeto: alfa87/Sistema-de-gestion-con-PyQt5

class PestaniaProveedor():
    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

    def configInit(self):
        """
        Configuracion inicial de la pestaña probeedor, setea todas las señales de los botones y carga la tabla
        @return: void
        """
        #Configurando botones Generales
        self.winPrincipal.btnGuardar_prov.clicked.connect(self.onClickGuardar)
        self.winPrincipal.btnAgregar_prov.clicked.connect(self.onClickAgregar)
        self.winPrincipal.btnModificar_prov.clicked.connect(
            self.onClickModificar)
        self.winPrincipal.btnBorrar_prov.clicked.connect(self.onClickBorrar)

        #Configurando botones ABM telefono
        self.winPrincipal.btnSumarTelefono_prov.clicked.connect(
            self.onClickSumarTelefono)
        self.winPrincipal.btnRestarTelefono_prov.clicked.connect(
            self.onClickRestarTelefono)
        self.winPrincipal.btnCancelarTelefono_prov.clicked.connect(
            self.onClickCancelarTelefono)
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)

        #configurando botones tipo telefono
        self.winPrincipal.btnTelefono_prov.clicked.connect(
            self.onClickTelefono)
        self.winPrincipal.btnCelular_prov.clicked.connect(self.onClickCelular)
        self.winPrincipal.btnFax_prov.clicked.connect(self.onClickFax)

        #Seteando model y propieades de la tabla
        self.cargarTabla()
        self.winPrincipal.tvProveedores_prov.setSortingEnabled(True)
        self.winPrincipal.tvProveedores_prov.setMouseTracking(True)
        self.winPrincipal.tvProveedores_prov.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        #Seteando proiedades de la tabla telefono
        self.winPrincipal.tvTelefonos_prov.setSortingEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setMouseTracking(True)
        self.winPrincipal.tvTelefonos_prov.setSelectionBehavior(
            QAbstractItemView.SelectRows)

    def onClickAgregar(self):
        self.estado = 'AGREGAR'
        self.validarBotones(button='AGREGAR')

    def onClickGuardar(self):
        validar = self.validar()

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert, "ERROR", validar)
        else:
            self.proveedor.setDescripcion(
                str(self.winPrincipal.txtDescripcion_prov.text()))
            self.proveedor.setWeb(str(self.winPrincipal.txtWeb_prov.text()))
            self.proveedor.setEmail(str(
                self.winPrincipal.txtEmail_prov.text()))
            self.proveedor.setNombre(
                str(self.winPrincipal.txtNombre_prov.text()))
            self.direccion.setDireccion(
                str(self.winPrincipal.txtDireccion_prov.text()))
            if self.winPrincipal.txtDDpto_prov.text() != "":
                self.direccion.setDpto(
                    str(self.winPrincipal.txtDDpto_prov.text()))
            else:
                self.direccion.setDpto("")
            if self.winPrincipal.txtDNumero_prov.text() != "":
                self.direccion.setNumero(
                    int(self.winPrincipal.txtDNumero_prov.text()))
            else:
                self.direccion.setNumero(0)
            if self.winPrincipal.txtDPiso_prov.text() != "":
                self.direccion.setPiso(
                    int(self.winPrincipal.txtDPiso_prov.text()))
            else:
                self.direccion.setPiso(0)

            self.proveedor.setDireccion(self.direccion)

            self.validarBotones(button='GUARDAR')

            if self.estado == 'AGREGAR':
                self.insertProveedor()
                self.insertTelefono()
            elif self.estado == 'MODIFICAR':
                self.modificarProveedor()
                self.updateTelefono()

    def onClickModificar(self):
        self.estado = 'MODIFICAR'
        self.validarBotones(button='MODIFICAR')

    def onClickBorrar(self):
        if self.winPrincipal.btnGuardar_prov.isEnabled() != True:
            self.conexionProveedor.borrarProveedor(self.proveedor)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')

    def cargarTabla(self):
        listProveedores = self.conexionProveedor.selectProveedor()

        if len(listProveedores) > 0:
            header = [
                'ID', 'Descripcion', 'Nombre', 'Email', 'Web', 'Direccion',
                'N°', 'P', 'D', 'idper', 'iddir'
            ]
            tableModel = MyTableModel(self.winPrincipal.tvProveedores_prov,
                                      listProveedores, header)
            self.winPrincipal.tvProveedores_prov.setModel(tableModel)
            self.winPrincipal.tvProveedores_prov.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvProveedores_prov.setColumnHidden(0, True)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(1, 190)
            if len(listProveedores) > 4:
                self.winPrincipal.tvProveedores_prov.setColumnWidth(2, 177)
            else:
                self.winPrincipal.tvProveedores_prov.setColumnWidth(2, 190)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(3, 263)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(4, 240)

            self.winPrincipal.tvProveedores_prov.setColumnWidth(5, 200)
            self.winPrincipal.tvProveedores_prov.setColumnWidth(6, 50)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(7, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(8, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(9, True)
            self.winPrincipal.tvProveedores_prov.setColumnHidden(10, True)

    def changeSelectedTable(self, selected, deselected):
        proveedorList = selected.model().mylist
        proveedorSelected = proveedorList[selected.row()]
        self.proveedor = Proveedor()
        self.direccion = Direccion()
        self.proveedor.setIdProveedor(int(proveedorSelected[0]))
        self.proveedor.setDescripcion(str(proveedorSelected[1]))
        self.proveedor.setNombre(str(proveedorSelected[2]))
        self.proveedor.setEmail(str(proveedorSelected[3]))
        self.proveedor.setWeb(str(proveedorSelected[4]))

        self.direccion.setDireccion(str(proveedorSelected[5]))
        if proveedorSelected[6] != None:
            self.direccion.setNumero(int(proveedorSelected[6]))

        if proveedorSelected[7] != None:
            self.direccion.setPiso(int(proveedorSelected[7]))

        if proveedorSelected[8] != None:
            self.direccion.setDpto(proveedorSelected[8])

        self.direccion.setIdDireccion(int(proveedorSelected[10]))
        self.proveedor.setDireccion(self.direccion)

        self.proveedor.setIdPersona(proveedorSelected[9])

        self.winPrincipal.tvProveedores_prov.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvProveedores_prov.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_prov.setEnabled(True)
        self.winPrincipal.btnBorrar_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setModel(None)
        self.cargarTablaTelefono()

    def validarBotones(self, button):
        if button == 'AGREGAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(False)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setEnabled(True)
            self.winPrincipal.tvProveedores_prov.setEnabled(False)
            self.winPrincipal.wDatosProveedor.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setText('CANCELAR')
            self.limpiarCampos()
        elif button == 'GUARDAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(True)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setEnabled(False)
            self.winPrincipal.tvProveedores_prov.setEnabled(True)
            self.winPrincipal.wDatosProveedor.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setText('BORRAR')
            self.limpiarCampos()
        elif button == 'MODIFICAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(False)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setEnabled(True)
            self.winPrincipal.tvProveedores_prov.setEnabled(False)
            self.winPrincipal.wDatosProveedor.setEnabled(True)
            self.winPrincipal.btnBorrar_prov.setText('CANCELAR')
        elif button == 'BORRAR':
            self.winPrincipal.btnAgregar_prov.setEnabled(True)
            self.winPrincipal.btnModificar_prov.setEnabled(False)
            self.winPrincipal.btnGuardar_prov.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setEnabled(False)
            self.winPrincipal.tvProveedores_prov.setEnabled(True)
            self.winPrincipal.wDatosProveedor.setEnabled(False)
            self.winPrincipal.btnBorrar_prov.setText('BORRAR')
            self.limpiarCampos()

    def insertProveedor(self):
        self.conexionProveedor.insertarProveedor(proveedor=self.proveedor)
        self.cargarTabla()

    def modificarProveedor(self):
        self.conexionProveedor.modificarProveedor(proveedor=self.proveedor)
        self.cargarTabla()

    def limpiarCampos(self):
        self.winPrincipal.txtNombre_prov.setText('')
        self.winPrincipal.txtDescripcion_prov.setText('')
        self.winPrincipal.txtEmail_prov.setText('')
        self.winPrincipal.txtDireccion_prov.setText('')
        self.winPrincipal.txtDNumero_prov.setText('')
        self.winPrincipal.txtDPiso_prov.setText('')
        self.winPrincipal.txtDDpto_prov.setText('')
        self.winPrincipal.txtWeb_prov.setText('')
        self.winPrincipal.tvTelefonos_prov.setModel(None)

    def setCampos(self):
        self.winPrincipal.txtDescripcion_prov.setText(
            str(self.proveedor.getDescripcion()))
        self.winPrincipal.txtEmail_prov.setText(str(self.proveedor.getEmail()))
        self.winPrincipal.txtNombre_prov.setText(
            str(self.proveedor.getNombre()))
        self.winPrincipal.txtWeb_prov.setText(str(self.proveedor.getWeb()))

        self.winPrincipal.txtDireccion_prov.setText(
            str(self.proveedor.getDireccion().getDireccion()))

        if self.proveedor.getDireccion().getNumero() is not None:
            self.winPrincipal.txtDNumero_prov.setText(
                str(self.proveedor.getDireccion().getNumero()))
        else:
            self.winPrincipal.txtDNumero_prov.setText('')

        if self.proveedor.getDireccion().getPiso() is not None:
            self.winPrincipal.txtDPiso_prov.setText(
                str(self.proveedor.getDireccion().getPiso()))
        else:
            self.winPrincipal.txtDPiso_prov.setText('')

        if self.proveedor.getDireccion().getDpto() is not None:
            self.winPrincipal.txtDDpto_prov.setText(
                self.proveedor.getDireccion().getDpto())
        else:
            self.winPrincipal.txtDDpto_prov.setText('')

    def validar(self):
        mensaje = ''
        if self.winPrincipal.txtNombre_prov.text() == '':
            mensaje = "Falta ingresar un Nombre"
        elif self.winPrincipal.txtDescripcion_prov.text() == '':
            mensaje = "Falta ingresa la descripcion"
        elif self.winPrincipal.txtDireccion_prov.text() == '':
            mensaje = "Falta ingresar una Direccion"
        elif self.winPrincipal.txtDNumero_prov.text() == '':
            mensaje = "Falta ingresar un N° de Direccion"

        return mensaje

    def cargarTablaTelefono(self):
        self.listTelefonosInit = self.conexionTelefono.selectTelefono(
            self.proveedor)
        if len(self.listTelefonosInit) > 0:
            header = ['ID', 'Numero', 'TIPO']
            tableModel = MyTableModel(self.winPrincipal,
                                      self.listTelefonosInit, header)
            self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
            self.winPrincipal.tvTelefonos_prov.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTel)

            self.winPrincipal.tvTelefonos_prov.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(2, 175)

            for r in range(0, len(self.listTelefonosInit)):
                self.winPrincipal.tvTelefonos_prov.setRowHidden(r, False)

    def changeSelectedTableTel(self, selected, deselected):
        listTelefonos = selected.model().mylist
        self.telefonoSelected = ()
        self.telefonoSelected = listTelefonos[selected.row()]

        self.telefonoSelectedRow = selected.row()
        self.winPrincipal.txtTelefono_prov.setText(
            str(self.telefonoSelected[2]))

        self.setTipoTelefono(str(self.telefonoSelected[1]))
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(True)
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(True)
        self.winPrincipal.tvTelefonos_prov.setEnabled(False)

        self.winPrincipal.btnGuardar_prov.setEnabled(False)

    def updateTelefono(self):

        listTelefono = []
        listTelefono = list(
            self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        estado = ''
        telNew = Telefono()
        if len(listTelefono) > 0:
            if len(self.listTelefonosInit) > 0:

                listTelInit = list(self.listTelefonosInit)
                parche = (listTelefono[0][0], listTelefono[0][1],
                          str(listTelefono[0][2]))
                listTelefono[0] = parche
                #Recorre la lista de telefono inicial
                for telInit in listTelInit:
                    #recorre la lista de telefonos nueva
                    for tel in listTelefono:
                        telNew.setIdPersona(self.proveedor.getIdPersona())
                        telNew.setIdTelefono(tel[0])
                        telNew.setTipo(tel[1])
                        if tel[2] == "":
                            estado = 'DEL'
                            break
                        else:
                            telNew.setTelefono(tel[2])

                        if tel[0] == 0:
                            estado = 'INS'
                            break

                        if telInit[0] == tel[0]:
                            if telInit[1] != tel[1] or telInit[2] != tel[2]:
                                estado = 'UPD'
                                break

                    if estado == 'UPD':
                        self.conexionTelefono.modificarTelefono(telNew)
                    elif estado == "INS":
                        self.conexionTelefono.insertarTelefono(telNew)
                    elif estado == 'DEL':
                        self.conexionTelefono.borrarTelefono(telNew)
            #Si la lista de telefono inicial es cero
            else:
                #recorre la lista de telefonos nueva para agregarlos a todos
                for telN in listTelefono:
                    if telN[2] != '':
                        telNew = Telefono()
                        telNew.setIdPersona(self.proveedor.getIdPersona())
                        telNew.setIdTelefono(telN[0])
                        telNew.setTipo(telN[1])
                        telNew.setTelefono(telN[2])
                        self.conexionTelefono.insertarTelefono(telNew)

    def insertTelefono(self):

        listTelefonosNew = []
        tel = self.winPrincipal.tvTelefonos_prov.model()

        listTelefonosNew = list(
            self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        if len(listTelefonosNew) > 0:
            self.conexionTelefono.insertTelefonoInit(listTelefonosNew)

    def onClickCancelarTelefono(self):
        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.txtTelefono_prov.setText('')

        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
        self.winPrincipal.tvTelefonos_prov.clearSelection()
        self.winPrincipal.tvTelefonos_prov.setEnabled(True)

        self.winPrincipal.btnGuardar_prov.setEnabled(True)

    def onClickSumarTelefono(self):
        numTelefono = self.winPrincipal.txtTelefono_prov.text()

        if numTelefono.isdigit() == True:
            if self.winPrincipal.btnCancelarTelefono_prov.isVisible() is True:
                self.updateTelefonoTabla()
            else:
                self.insertTelefonoTabla()

            self.winPrincipal.tvTelefonos_prov.clearSelection()
            self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
            self.winPrincipal.txtTelefono_prov.setText('')
            self.winPrincipal.tvTelefonos_prov.setEnabled(True)

            self.winPrincipal.btnGuardar_prov.setEnabled(True)
        else:
            alert = QDialog()
            QMessageBox.information(alert, "ERROR",
                                    "El numero de telefono no es valido.")

    def onClickRestarTelefono(self):
        listTabTel = []

        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []

        listTabTel = list(
            self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        header = ['Id', 'Tipo', 'Numero']
        telDel = [self.telefonoSelected[0], self.telefonoSelected[1], '']
        listTabTel[self.telefonoSelectedRow] = telDel
        tableTelModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_prov.setModel(tableTelModel)
        self.winPrincipal.tvTelefonos_prov.selectionModel(
        ).currentChanged.connect(self.changeSelectedTableTel)
        self.winPrincipal.tvTelefonos_prov.setRowHidden(
            self.telefonoSelectedRow, True)

        self.winPrincipal.btnCancelarTelefono_prov.setVisible(False)
        self.winPrincipal.txtTelefono_prov.setText('')
        self.winPrincipal.btnRestarTelefono_prov.setEnabled(False)
        self.winPrincipal.tvTelefonos_prov.setEnabled(True)

        self.winPrincipal.btnGuardar_prov.setEnabled(True)

    def onClickTelefono(self):
        self.changeTipoTelefono(button='TEL')

    def onClickCelular(self):
        self.changeTipoTelefono(button='CEL')

    def onClickFax(self):
        self.changeTipoTelefono(button='FAX')

    def changeTipoTelefono(self, button):

        if button == 'TEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif button == 'CEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(False)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif button == 'FAX':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(False)

    def setTipoTelefono(self, tipoTelefono):

        if tipoTelefono == 'TEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(False)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif tipoTelefono == 'CEL':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(False)
            self.winPrincipal.btnFax_prov.setEnabled(True)
        elif tipoTelefono == 'FAX':
            self.winPrincipal.btnTelefono_prov.setEnabled(True)
            self.winPrincipal.btnCelular_prov.setEnabled(True)
            self.winPrincipal.btnFax_prov.setEnabled(False)

    def getTipoTelefono(self):

        if self.winPrincipal.btnTelefono_prov.isEnabled() != True:
            return 'TEL'
        elif self.winPrincipal.btnCelular_prov.isEnabled() != True:
            return 'CEL'
        elif self.winPrincipal.btnFax_prov.isEnabled() != True:
            return 'FAX'

    def insertTelefonoTabla(self):
        numTel = self.winPrincipal.txtTelefono_prov.text()
        tipoTel = str(self.getTipoTelefono())

        modelListTelefono = self.winPrincipal.tvTelefonos_prov.model()
        header = ['ID', 'Tipo', 'Numero']

        if modelListTelefono is not None:
            listTabTel = list(
                self.winPrincipal.tvTelefonos_prov.model().mylist)

            if len(listTabTel) > 0 or listTabTel is not None:
                tuplaTel = ('0', tipoTel, numTel)
                listTabTel.append(tuplaTel)
                tupleTable = tuple(listTabTel)

                tableModel = MyTableModel(self.winPrincipal, tupleTable,
                                          header)
                self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
                self.winPrincipal.tvTelefonos_prov.selectionModel(
                ).currentChanged.connect(self.changeSelectedTableTel)
        else:
            lista = []
            tuplaTel = ('0', tipoTel, numTel)
            lista.append(tuplaTel)

            tableModel = MyTableModel(self.winPrincipal, lista, header)
            self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
            self.winPrincipal.tvTelefonos_prov.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvTelefonos_prov.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_prov.setColumnWidth(2, 175)

    def updateTelefonoTabla(self):
        listTabTel = []

        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []
        prob = self.winPrincipal.tvTelefonos_prov.selectionModel()
        prob1 = self.winPrincipal.tvTelefonos_prov.model()
        listTabTel = list(
            self.winPrincipal.tvTelefonos_prov.model().mylist).copy()

        telUpd = (self.telefonoSelected[0], tipoTel,
                  int(self.winPrincipal.txtTelefono_prov.text()))
        listTabTel[self.telefonoSelectedRow] = telUpd
        header = ['ID', 'Tipo', 'Numero']
        tableModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_prov.setModel(tableModel)
        self.winPrincipal.tvTelefonos_prov.selectionModel(
        ).currentChanged.connect(self.changeSelectedTableTel)

Exemplo n.º 17

Arquivo: pCliente.py Projeto: robertoweller/estudos-python

class PestaniaCliente():

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.conexionCliente = conexionCliente()
        self.conexionTelefono = conexionTelefono()

        self.listTelefonosInit = []

        self.estado = ""
        self.direccion = Direccion()

        self.configInit()


    def configInit(self):
        #Configurando botones Generales
        self.winPrincipal.btnAgregar_c.clicked.connect(self.onClickAgregar_c)
        self.winPrincipal.btnGuardar_c.clicked.connect(self.onClickGuardar_c)
        self.winPrincipal.btnBorrar_c.clicked.connect(self.onClickBorrar_c)
        self.winPrincipal.btnModificar_c.clicked.connect(self.onClickModificar_c)

        #Configurando botones ABM telefono
        self.winPrincipal.btnSumarTelefono_c.clicked.connect(self.onClickSumarTelefono)
        self.winPrincipal.btnRestarTelefono_c.clicked.connect(self.onClickRestarTelefono)
        self.winPrincipal.btnCancelarTelefono_c.clicked.connect(self.onClickCancelarTelefono)
        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)

        #configurando botones tipo telefono
        self.winPrincipal.btnTelefono_c.clicked.connect(self.onClickTelefono)
        self.winPrincipal.btnCelular_c.clicked.connect(self.onClickCelular)
        self.winPrincipal.btnFax_c.clicked.connect(self.onClickFax)


        self.winPrincipal.txtFilterClientes_c.returnPressed.connect(self.search)

        #Seteando model y propiedades a la tabla
        self.winPrincipal.tvClientes_c.setSortingEnabled(True)
        self.winPrincipal.tvClientes_c.setMouseTracking(True)
        self.winPrincipal.tvClientes_c.setSelectionBehavior(QAbstractItemView.SelectRows)


        #Seteando proiedades de la tabla telefono
        self.winPrincipal.tvTelefonos_c.setSortingEnabled(True)
        self.winPrincipal.tvTelefonos_c.setMouseTracking(True)
        self.winPrincipal.tvTelefonos_c.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.txtFilterClientes_c.setFocus(True)

    def finish(self):
        self.winPrincipal.btnAgregar_c.disconnect()
        self.winPrincipal.btnBorrar_c.disconnect()
        self.winPrincipal.btnModificar_c.disconnect()
        self.winPrincipal.btnGuardar_c.disconnect()

        self.winPrincipal.btnCancelarTelefono_c.disconnect()
        self.winPrincipal.btnSumarTelefono_c.disconnect()
        self.winPrincipal.btnRestarTelefono_c.disconnect()

        self.winPrincipal.btnCelular_c.disconnect()
        self.winPrincipal.btnFax_c.disconnect()
        self.winPrincipal.btnTelefono_c.disconnect()

        self.winPrincipal.tvTelefonos_c.disconnect()
        self.winPrincipal.tvClientes_c.disconnect()


    def search(self):
        if self.winPrincipal.txtFilterClientes_c.hasFocus() is True:
            self.cargarTabla()


    def onClickAgregar_c(self):
        self.estado = 'AGREGAR'
        self.validarBotones(button='AGREGAR')


    def onClickGuardar_c(self):
        validar = self.validar()

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", validar)
        else:
            self.cliente.setApellido(self.winPrincipal.txtApellido_c.text())
            self.cliente.setNombre(self.winPrincipal.txtNombre_c.text())
            self.direccion.setDireccion(self.winPrincipal.txtDireccion_c.text())
            self.cliente.setEmail(self.winPrincipal.txtEmail_c.text())

            if self.winPrincipal.txtDDpto_c.text() != "":
                self.direccion.setDpto(str(self.winPrincipal.txtDDpto_c.text()))
            else:
                self.direccion.setDpto("")
            if self.winPrincipal.txtDNumero_c.text() != "":
                self.direccion.setNumero(int(self.winPrincipal.txtDNumero_c.text()))
            else:
                self.direccion.setNumero(0)
            if self.winPrincipal.txtDPiso_c.text() != "":
                self.direccion.setPiso(int(self.winPrincipal.txtDPiso_c.text()))
            else:
                self.direccion.setPiso(0)
            self.cliente.setDireccion(self.direccion)

            if self.winPrincipal.cbEstado_c.currentText() == 'ACTIVO':
                self.cliente.setEstado(1)
            else:
                self.cliente.setEstado(0)

            if self.estado == 'AGREGAR':
                self.insertCliente()
                self.insertTelefono()
            elif self.estado == 'MODIFICAR':
                self.modificarCliente()
                self.updateTelefono()

            self.validarBotones(button='GUARDAR')


    def onClickModificar_c(self):
        self.estado = 'MODIFICAR'
        self.validarBotones(button='MODIFICAR')


    def onClickBorrar_c(self):
        if self.winPrincipal.btnGuardar_c.isEnabled() != True:
            self.conexionCliente.borrarCliente(self.cliente)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')


    def cargarTabla(self):
        parameter = self.winPrincipal.txtFilterClientes_c.text()
        typeParameter = ''

        if self.winPrincipal.cbFilterClientes_c.currentText() == 'Apellido':
            typeParameter = 'cli.apellido'
        else:
            typeParameter = 'p.nombre'

        parameterState = 1
        if self.winPrincipal.cbInactivo_c.isChecked() is True:
            parameterState = 0

        listaClientes = self.conexionCliente.selectCliente(typeParameter, parameter, parameterState)

        if len(listaClientes) > 0:
            header = ['ID','Apellido','Nombre','Email','Direccion', 'N°', 'Piso', 'Dpto', 'iddir', 'idper', 'Estado']
            self.tablaModel = MyTableModel(self.winPrincipal.tvClientes_c, listaClientes, header)
            self.winPrincipal.tvClientes_c.setModel(self.tablaModel)
            self.winPrincipal.tvClientes_c.selectionModel().currentChanged.connect(self.changeSelectedTable)


            self.winPrincipal.tvClientes_c.setColumnHidden(0, True)
            self.winPrincipal.tvClientes_c.setColumnWidth(1, 208)
            self.winPrincipal.tvClientes_c.setColumnWidth(2, 220)
            self.winPrincipal.tvClientes_c.setColumnWidth(3, 280)
            self.winPrincipal.tvClientes_c.setColumnWidth(4, 364)
            self.winPrincipal.tvClientes_c.setColumnWidth(5, 50)
            self.winPrincipal.tvClientes_c.setColumnHidden(6, True)
            self.winPrincipal.tvClientes_c.setColumnHidden(7, True)
            self.winPrincipal.tvClientes_c.setColumnHidden(8, True)
            self.winPrincipal.tvClientes_c.setColumnHidden(9, True)
            self.winPrincipal.tvClientes_c.setColumnHidden(10, True)
        else:
            self.winPrincipal.tvClientes_c.setModel(None)


    def changeSelectedTable(self, selected, deselected):

            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]
            self.cliente = Cliente()
            self.direccion = Direccion()
            self.cliente.setIdCliente(int(clienteSelected[0]))
            self.cliente.setApellido(clienteSelected[1])
            self.cliente.setNombre(clienteSelected[2])
            self.cliente.setEmail(clienteSelected[3])
            self.direccion = Direccion()
            self.direccion.setDireccion(clienteSelected[4])

            if clienteSelected[5] != None:
                self.direccion.setNumero(int(clienteSelected[5]))

            if clienteSelected[6] != None:
                self.direccion.setPiso(int(clienteSelected[6]))

            if clienteSelected[7] != None:
                self.direccion.setDpto(clienteSelected[7])

            self.direccion.setIdDireccion(int(clienteSelected[8]))
            self.cliente.setDireccion(self.direccion)

            self.cliente.setIdPersona(clienteSelected[9])

            self.winPrincipal.tvClientes_c.setRowHeight(deselected.row(), 28)
            self.winPrincipal.tvClientes_c.setRowHeight(selected.row(), 45)

            self.cliente.setEstado(int(clienteSelected[10]))

            self.setCampos()
            self.winPrincipal.btnModificar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.tvTelefonos_c.setModel(None)
            self.cargarTablaTelefono()


    def validarBotones(self, button):
        if button == 'AGREGAR' :
            self.winPrincipal.wDatosCliente.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setText('CANCELAR')
            self.winPrincipal.btnGuardar_c.setEnabled(True)
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(False)
            self.limpiarCampos()

        elif button=='GUARDAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(True)
            self.winPrincipal.btnGuardar_c.setEnabled(False)
            self.winPrincipal.btnBorrar_c.setText('BORRAR')
            self.winPrincipal.btnBorrar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(True)
            self.winPrincipal.wDatosCliente.setEnabled(False)
            self.limpiarCampos()

        elif button == 'MODIFICAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(False)
            self.winPrincipal.btnGuardar_c.setEnabled(True)
            self.winPrincipal.btnBorrar_c.setText('Cancelar')
            self.winPrincipal.btnBorrar_c.setEnabled(True)
            self.winPrincipal.tvClientes_c.setEnabled(False)
            self.winPrincipal.wDatosCliente.setEnabled(True)

        elif button=='BORRAR':
            self.winPrincipal.btnModificar_c.setEnabled(False)
            self.winPrincipal.btnAgregar_c.setEnabled(True)
            self.winPrincipal.btnGuardar_c.setEnabled(False)
            self.winPrincipal.btnBorrar_c.setText('BORRAR')
            self.winPrincipal.btnBorrar_c.setEnabled(False)
            self.winPrincipal.tvClientes_c.setEnabled(True)
            self.winPrincipal.wDatosCliente.setEnabled(False)
            self.limpiarCampos()


    def insertCliente(self):
        if self.cliente.getApellido() != '':
            self.conexionCliente.insertarCliente(cliente=self.cliente)
            self.cargarTabla()


    def modificarCliente(self):
            self.conexionCliente.modificarCliente(self.cliente)
            self.cargarTabla()


    def limpiarCampos(self):
        self.winPrincipal.txtApellido_c.setText('')
        self.winPrincipal.txtNombre_c.setText('')
        self.winPrincipal.txtDireccion_c.setText('')
        self.winPrincipal.txtDNumero_c.setText('')
        self.winPrincipal.txtDPiso_c.setText('')
        self.winPrincipal.txtDDpto_c.setText('')
        self.winPrincipal.txtEmail_c.setText('')
        self.winPrincipal.tvTelefonos_c.setModel(None)
        self.winPrincipal.cbEstado_c.setCurrentIndex(0)
        self.winPrincipal.txtFilterClientes_c.setText('')
        self.winPrincipal.tvClientes_c.setModel(None)

        self.winPrincipal.txtFilterClientes_c.setFocus(True)


    def setCampos(self):
        self.winPrincipal.txtApellido_c.setText(self.cliente.getApellido())
        self.winPrincipal.txtNombre_c.setText(self.cliente.getNombre())
        self.winPrincipal.txtEmail_c.setText(self.cliente.getEmail())

        self.winPrincipal.txtDireccion_c.setText(self.cliente.getDireccion().getDireccion())
        
        if self.cliente.getDireccion().getNumero() != None:
            self.winPrincipal.txtDNumero_c.setText(str(self.cliente.getDireccion().getNumero()))
        else:
            self.winPrincipal.txtDNumero_c.setText('')            
        
        if self.cliente.getDireccion().getPiso() != None:
            self.winPrincipal.txtDPiso_c.setText(str(self.cliente.getDireccion().getPiso()))
        else:
            self.winPrincipal.txtDPiso_c.setText('')

        if self.cliente.getDireccion().getDpto() != None:
            self.winPrincipal.txtDDpto_c.setText(self.cliente.getDireccion().getDpto())
        else:
            self.winPrincipal.txtDDpto_c.setText('')

        if self.cliente.getEstado() == 1:
            self.winPrincipal.cbEstado_c.setCurrentIndex(0)
        else:
            self.winPrincipal.cbEstado_c.setCurrentIndex(1)

    def validar(self):
        mensaje = ''
        if self.winPrincipal.txtNombre_c.text() == '':
            mensaje = "Falta ingresar un Nombre"
        elif self.winPrincipal.txtApellido_c.text() == '':
            mensaje = "Falta ingresar Apellido"
        elif self.winPrincipal.txtDireccion_c.text() == '':
            mensaje = "Falta ingresar una Direccion"
        elif self.winPrincipal.txtDNumero_c.text() == '':
            mensaje = "Falta ingresar un N° de Direccion"

        return mensaje


    def cargarTablaTelefono(self):
        self.listTelefonosInit = self.conexionTelefono.selectTelefono(self.cliente)
        if len(self.listTelefonosInit) >0:
            header = ['ID', 'Numero', 'TIPO']
            tableModel = MyTableModel(self.winPrincipal, self.listTelefonosInit, header)
            self.winPrincipal.tvTelefonos_c.setModel(tableModel)
            self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

            self.winPrincipal.tvTelefonos_c.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(2, 175)

            for r in range(0, len(self.listTelefonosInit)):
                self.winPrincipal.tvTelefonos_c.setRowHidden(r, False)


    def changeSelectedTableTel(self, selected, deselected):
        listTelefonos = selected.model().mylist
        self.telefonoSelected = ()
        self.telefonoSelected = listTelefonos[selected.row()]

        self.telefonoSelectedRow = selected.row()
        self.winPrincipal.txtTelefono_c.setText(str(self.telefonoSelected[2]))

        self.setTipoTelefono(str(self.telefonoSelected[1]))
        self.winPrincipal.btnCancelarTelefono_c.setVisible(True)
        self.winPrincipal.btnRestarTelefono_c.setEnabled(True)
        self.winPrincipal.tvTelefonos_c.setEnabled(False)

        self.winPrincipal.btnGuardar_c.setEnabled(False)
        self.winPrincipal.btnBorrar_c.setEnabled(False)


    def updateTelefono(self):

        listTelefono = []
        if self.winPrincipal.tvTelefonos_c.model() != None and \
                        len(self.winPrincipal.tvTelefonos_c.model().mylist) > 0:
            listTelefono = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

            estado = ''
            telNew = Telefono()
            if len(listTelefono) > 0:
                if len(self.listTelefonosInit) > 0:

                    listTelInit = list(self.listTelefonosInit)
                    parche = (listTelefono[0][0], listTelefono[0][1], str(listTelefono[0][2]))
                    listTelefono[0] = parche
                    #Recorre la lista de telefono inicial
                    for telInit in listTelInit:
                        #recorre la lista de telefonos nueva
                        for tel in listTelefono:
                            telNew.setIdPersona(self.cliente.getIdPersona())
                            telNew.setIdTelefono(tel[0])
                            telNew.setTipo(tel[1])
                            if tel[2] == "":
                                estado = 'DEL'
                                break
                            else:
                                telNew.setTelefono(tel[2])

                            if tel[0] == 0:
                                estado = 'INS'
                                break

                            if telInit[0] == tel[0]:
                                if telInit[1] != tel[1] or telInit[2] != tel[2]:
                                    estado = 'UPD'
                                    break

                        if estado == 'UPD':
                            self.conexionTelefono.modificarTelefono(telNew)
                        elif estado == "INS":
                            self.conexionTelefono.insertarTelefono(telNew)
                        elif estado == 'DEL':
                            self.conexionTelefono.borrarTelefono(telNew)
                #Si la lista de telefono inicial es cero
                else:
                    #recorre la lista de telefonos nueva para agregarlos a todos
                    for telN in listTelefono:
                        if telN[2] != '':
                            telNew = Telefono()
                            telNew.setIdPersona(self.cliente.getIdPersona())
                            telNew.setIdTelefono(telN[0])
                            telNew.setTipo(telN[1])
                            telNew.setTelefono(telN[2])
                            self.conexionTelefono.insertarTelefono(telNew)


    def insertTelefono(self):

        listTelefonosNew = []
        tel = self.winPrincipal.tvTelefonos_c.model()

        listTelefonosNew = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

        if len(listTelefonosNew) > 0:
            self.conexionTelefono.insertTelefonoInit(listTelefonosNew)


    def onClickCancelarTelefono(self):
        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.txtTelefono_c.setText('')

        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
        self.winPrincipal.tvTelefonos_c.clearSelection()
        self.winPrincipal.tvTelefonos_c.setEnabled(True)

        self.winPrincipal.btnGuardar_c.setEnabled(True)
        self.winPrincipal.btnBorrar_c.setEnabled(True)


    def onClickSumarTelefono(self):
        numTelefono = self.winPrincipal.txtTelefono_c.text()

        if numTelefono.isdigit() == True:
            if self.winPrincipal.btnCancelarTelefono_c.isVisible() is True:
                self.updateTelefonoTabla()
            else:
                self.insertTelefonoTabla()

            self.winPrincipal.tvTelefonos_c.clearSelection()
            self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
            self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
            self.winPrincipal.txtTelefono_c.setText('')
            self.winPrincipal.tvTelefonos_c.setEnabled(True)

            self.winPrincipal.btnGuardar_c.setEnabled(True)
        else:
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", "El numero de telefono no es valido.")


    def onClickRestarTelefono(self):
        listTabTel = []
        #listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        #tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []

        listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()

        header = ['Id', 'Tipo', 'Numero']
        telDel = [self.telefonoSelected[0], self.telefonoSelected[1], '']
        listTabTel[self.telefonoSelectedRow] = telDel
        tableTelModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_c.setModel(tableTelModel)
        self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        self.winPrincipal.tvTelefonos_c.setRowHidden(self.telefonoSelectedRow, True)

        self.winPrincipal.btnCancelarTelefono_c.setVisible(False)
        self.winPrincipal.txtTelefono_c.setText('')
        self.winPrincipal.btnRestarTelefono_c.setEnabled(False)
        self.winPrincipal.tvTelefonos_c.setEnabled(True)

        self.winPrincipal.btnGuardar_c.setEnabled(True)
        self.winPrincipal.btnBorrar_c.setEnabled(True)


    def onClickTelefono(self):
        self.changeTipoTelefono(button='TEL')


    def onClickCelular(self):
        self.changeTipoTelefono(button='CEL')


    def onClickFax(self):
        self.changeTipoTelefono(button='FAX')


    def changeTipoTelefono(self, button):

        if button == 'TEL':
            self.winPrincipal.btnTelefono_c.setEnabled(False)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif button == 'CEL':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(False)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif button == 'FAX':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(False)


    def setTipoTelefono(self, tipoTelefono):

        if tipoTelefono == 'TEL':
            self.winPrincipal.btnTelefono_c.setEnabled(False)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif tipoTelefono == 'CEL':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(False)
            self.winPrincipal.btnFax_c.setEnabled(True)
        elif tipoTelefono == 'FAX':
            self.winPrincipal.btnTelefono_c.setEnabled(True)
            self.winPrincipal.btnCelular_c.setEnabled(True)
            self.winPrincipal.btnFax_c.setEnabled(False)


    def getTipoTelefono(self):

        if self.winPrincipal.btnTelefono_c.isEnabled() != True:
            return 'TEL'
        elif self.winPrincipal.btnCelular_c.isEnabled() != True:
            return 'CEL'
        elif self.winPrincipal.btnFax_c.isEnabled() != True:
            return 'FAX'


    def insertTelefonoTabla(self):
        numTel = self.winPrincipal.txtTelefono_c.text()
        tipoTel = str(self.getTipoTelefono())

        modelListTelefono = self.winPrincipal.tvTelefonos_c.model()
        header = ['ID', 'Tipo', 'Numero']

        if modelListTelefono is not None:
            listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist)

            if len(listTabTel) > 0 or listTabTel is not None:
                tuplaTel = ('0', tipoTel, numTel )
                listTabTel.append(tuplaTel)
                tupleTable = tuple(listTabTel)

                tableModel = MyTableModel(self.winPrincipal, tupleTable , header)
                self.winPrincipal.tvTelefonos_c.setModel(tableModel)
                self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
        else:
            lista = []
            tuplaTel = ('0', tipoTel, numTel )
            lista.append(tuplaTel)

            tableModel = MyTableModel(self.winPrincipal, lista , header)
            self.winPrincipal.tvTelefonos_c.setModel(tableModel)
            self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvTelefonos_c.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_c.setColumnWidth(2, 175)


    def updateTelefonoTabla(self):
        listTabTel = []
        #listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []
        #prob = self.winPrincipal.tvTelefonos_c.selectionModel()
        #prob1 = self.winPrincipal.tvTelefonos_c.model()
        listTabTel = list(self.winPrincipal.tvTelefonos_c.model().mylist).copy()
        """
        for lt in listTabTel:
            if lt[0] == self.telefonoSelected[0]:
                lt = (self.telefonoSelected[0], tipoTel, self.winPrincipal.txtTelefono_c.text())

            listTelefonosNew.append(lt)
        """
        telUpd = (self.telefonoSelected[0], tipoTel, int(self.winPrincipal.txtTelefono_c.text()))
        listTabTel[self.telefonoSelectedRow] = telUpd
        header = ['ID', 'Tipo', 'Numero']
        tableModel = MyTableModel(self.winPrincipal, listTabTel , header)
        self.winPrincipal.tvTelefonos_c.setModel(tableModel)
        self.winPrincipal.tvTelefonos_c.selectionModel().currentChanged.connect(self.changeSelectedTableTel)

Exemplo n.º 18

Arquivo: pUsuario.py Projeto: robertoweller/estudos-python

class PestaniaUsuario():
    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.usuario = Usuario()
        self.conexionUsuario = conexionUsuario()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()

    def configInit(self):
        self.limpiarCampos()
        #Configurando botones Generales
        self.winPrincipal.btnAgregar_u.clicked.connect(self.onClickAgregar_u)
        self.winPrincipal.btnGuardar_u.clicked.connect(self.onClickGuardar_u)
        self.winPrincipal.btnBorrar_u.clicked.connect(self.onClickBorrar_u)
        self.winPrincipal.btnModificar_u.clicked.connect(
            self.onClickModificar_u)

        #Configurando botones ABM telefono
        self.winPrincipal.btnSumarTelefono_u.clicked.connect(
            self.onClickSumarTelefono)
        self.winPrincipal.btnRestarTelefono_u.clicked.connect(
            self.onClickRestarTelefono)
        self.winPrincipal.btnCancelarTelefono_u.clicked.connect(
            self.onClickCancelarTelefono)
        self.winPrincipal.btnCancelarTelefono_u.setVisible(False)
        self.winPrincipal.btnRestarTelefono_u.setEnabled(False)

        #configurando botones tipo telefono
        self.winPrincipal.btnTelefono_u.clicked.connect(self.onClickTelefono)
        self.winPrincipal.btnCelular_u.clicked.connect(self.onClickCelular)
        self.winPrincipal.btnFax_u.clicked.connect(self.onClickFax)

        self.winPrincipal.txtFilterUsuarios_u.returnPressed.connect(
            self.search)

        #Seteando model y propieades de la tabla
        self.winPrincipal.tvUsuarios_u.setSortingEnabled(True)
        self.winPrincipal.tvUsuarios_u.setMouseTracking(True)
        self.winPrincipal.tvUsuarios_u.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        #Seteando proiedades de la tabla telefono
        self.winPrincipal.tvTelefonos_u.setSortingEnabled(True)
        self.winPrincipal.tvTelefonos_u.setMouseTracking(True)
        self.winPrincipal.tvTelefonos_u.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.winPrincipal.txtFilterUsuarios_u.setFocus(True)

    def finish(self):
        self.winPrincipal.btnAgregar_u.disconnect()
        self.winPrincipal.btnBorrar_u.disconnect()
        self.winPrincipal.btnModificar_u.disconnect()
        self.winPrincipal.btnGuardar_u.disconnect()

        self.winPrincipal.btnCancelarTelefono_u.disconnect()
        self.winPrincipal.btnSumarTelefono_u.disconnect()
        self.winPrincipal.btnRestarTelefono_u.disconnect()

        self.winPrincipal.btnCelular_u.disconnect()
        self.winPrincipal.btnFax_u.disconnect()
        self.winPrincipal.btnTelefono_u.disconnect()

        self.winPrincipal.tvTelefonos_u.disconnect()
        self.winPrincipal.tvUsuarios_u.disconnect()

    def search(self):
        if self.winPrincipal.txtFilterUsuarios_u.hasFocus() is True:
            self.cargarTabla()

    def onClickAgregar_u(self):
        self.estado = 'AGREGAR'
        self.validarBotones(button='AGREGAR')

    def onClickGuardar_u(self):
        validar = self.validar()

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert, "ERROR", validar)
        else:
            self.usuario.setNombre(str(self.winPrincipal.txtNombre_u.text()))
            self.usuario.setApellido(
                str(self.winPrincipal.txtApellido_u.text()))
            self.usuario.setEmail(str(self.winPrincipal.txtEmail_u.text()))
            self.usuario.setPasswd(
                str(self.winPrincipal.txtContrasena_u.text()))
            self.usuario.setUsuario(str(self.winPrincipal.txtUsuario_u.text()))

            if self.winPrincipal.cbTipoUsuario_u.currentText() == 'user':
                self.usuario.setTipoUsuario("USR")
            else:
                self.usuario.setTipoUsuario("ADM")

            self.direccion.setDireccion(
                str(self.winPrincipal.txtDireccion_u.text()))
            if self.winPrincipal.txtDDpto_u.text() != "":
                self.direccion.setDpto(str(
                    self.winPrincipal.txtDDpto_u.text()))
            else:
                self.direccion.setDpto("")
            if self.winPrincipal.txtDNumero_u.text() != "":
                self.direccion.setNumero(
                    int(self.winPrincipal.txtDNumero_u.text()))
            else:
                self.direccion.setNumero(0)
            if self.winPrincipal.txtDPiso_u.text() != "":
                self.direccion.setPiso(int(
                    self.winPrincipal.txtDPiso_u.text()))
            else:
                self.direccion.setPiso(0)

            self.usuario.setDireccion(self.direccion)

            self.validarBotones(button='GUARDAR')

            if self.estado == 'AGREGAR':
                self.insertUsuario()
                self.insertTelefono()
            elif self.estado == 'MODIFICAR':
                self.modificarUsuario()
                self.updateTelefono()

    def onClickModificar_u(self):
        self.estado = 'MODIFICAR'
        self.validarBotones(button='MODIFICAR')

    def onClickBorrar_u(self):
        if self.winPrincipal.btnGuardar_u.isEnabled() != True:
            self.conexionUsuario.borrarUsuario(self.usuario)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')

    def cargarTabla(self):
        parameter = self.winPrincipal.txtFilterUsuarios_u.text()
        typeParameter = ''

        if self.winPrincipal.cbFilterUsuario_u.currentText() == 'Apellido':
            typeParameter = 'u.apellido'
        if self.winPrincipal.cbFilterUsuario_u.currentText() == 'Usuario':
            typeParameter = 'u.usuario'
        else:
            typeParameter = 'u.tipo'

        listaUsuarios = self.conexionUsuario.selectUsuario(
            typeParameter, parameter)
        if len(listaUsuarios) > 0:

            header = [
                'ID', 'Nombre', 'Apellido', 'Usuario', 'Tipo', 'Contraseña',
                'Email', 'Direccion', 'N°', 'P', 'D', 'iddire', 'idpers'
            ]
            tableModel = MyTableModel(self.winPrincipal.tvUsuarios_u,
                                      listaUsuarios, header)
            self.winPrincipal.tvUsuarios_u.setModel(tableModel)
            self.winPrincipal.tvUsuarios_u.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvUsuarios_u.setColumnHidden(0, True)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(1, 200)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(2, 200)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(3, True)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(4, 80)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(5, True)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(6, 270)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(7, 333)
            self.winPrincipal.tvUsuarios_u.setColumnWidth(8, 50)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(9, True)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(10, True)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(11, True)
            self.winPrincipal.tvUsuarios_u.setColumnHidden(12, True)
        else:
            self.winPrincipal.tvUsuarios_u.setModel(None)

    def changeSelectedTable(self, selected, deselected):
        usuarioList = selected.model().mylist
        usuarioSelected = usuarioList[selected.row()]
        self.usuario = Usuario()
        self.direccion = Direccion()
        self.usuario.setIdUsuario(int(usuarioSelected[0]))
        self.usuario.setNombre(str(usuarioSelected[1]))
        self.usuario.setApellido(str(usuarioSelected[2]))
        self.usuario.setUsuario(str(usuarioSelected[3]))

        self.usuario.setTipoUsuario(str(usuarioSelected[4]))

        self.usuario.setPasswd(str(usuarioSelected[5]))
        self.usuario.setEmail(str(usuarioSelected[6]))

        self.direccion.setDireccion(str(usuarioSelected[7]))
        if usuarioSelected[8] != None:
            self.direccion.setNumero(int(usuarioSelected[8]))

        if usuarioSelected[9] != None:
            self.direccion.setPiso(int(usuarioSelected[9]))

        if usuarioSelected[10] != None:
            self.direccion.setDpto(usuarioSelected[10])

        self.direccion.setIdDireccion(usuarioSelected[11])
        self.usuario.setDireccion(self.direccion)
        self.usuario.setIdPersona(usuarioSelected[12])
        self.winPrincipal.tvUsuarios_u.setRowHeight(deselected.row(), 28)
        self.winPrincipal.tvUsuarios_u.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnBorrar_u.setEnabled(True)
        self.winPrincipal.btnModificar_u.setEnabled(True)
        self.winPrincipal.tvTelefonos_u.setModel(None)
        self.cargarTablaTelefono()

    def validarBotones(self, button):
        if button == 'AGREGAR':
            self.winPrincipal.wDatosUsuario.setEnabled(True)
            self.winPrincipal.btnBorrar_u.setEnabled(True)
            self.winPrincipal.btnBorrar_u.setText('CANCELAR')
            self.winPrincipal.btnGuardar_u.setEnabled(True)
            self.winPrincipal.btnModificar_u.setEnabled(False)
            self.winPrincipal.btnAgregar_u.setEnabled(False)
            self.winPrincipal.tvUsuarios_u.setEnabled(False)
            self.limpiarCampos()

        elif button == 'GUARDAR':
            self.winPrincipal.btnModificar_u.setEnabled(False)
            self.winPrincipal.btnAgregar_u.setEnabled(True)
            self.winPrincipal.btnGuardar_u.setEnabled(False)
            self.winPrincipal.btnBorrar_u.setText('BORRAR')
            self.winPrincipal.btnBorrar_u.setEnabled(False)
            self.winPrincipal.tvUsuarios_u.setEnabled(True)
            self.winPrincipal.wDatosUsuario.setEnabled(False)
            self.limpiarCampos()

        elif button == 'MODIFICAR':
            self.winPrincipal.btnModificar_u.setEnabled(False)
            self.winPrincipal.btnAgregar_u.setEnabled(False)
            self.winPrincipal.btnGuardar_u.setEnabled(True)
            self.winPrincipal.btnBorrar_u.setText('CANCELAR')
            self.winPrincipal.btnBorrar_u.setEnabled(True)
            self.winPrincipal.tvUsuarios_u.setEnabled(False)
            self.winPrincipal.wDatosUsuario.setEnabled(True)

        elif button == 'BORRAR':
            self.winPrincipal.btnModificar_u.setEnabled(False)
            self.winPrincipal.btnAgregar_u.setEnabled(True)
            self.winPrincipal.btnGuardar_u.setEnabled(False)
            self.winPrincipal.btnBorrar_u.setText('BORRAR')
            self.winPrincipal.btnBorrar_u.setEnabled(False)
            self.winPrincipal.tvUsuarios_u.setEnabled(True)
            self.winPrincipal.wDatosUsuario.setEnabled(False)
            self.limpiarCampos()

    def insertUsuario(self):
        self.conexionUsuario.insertarUsuario(self.usuario)
        self.cargarTabla()

    def modificarUsuario(self):
        self.conexionUsuario.modificarUsuario(self.usuario)
        self.cargarTabla()

    def limpiarCampos(self):
        self.winPrincipal.txtApellido_u.setText('')
        self.winPrincipal.txtContrasena_u.setText('')
        self.winPrincipal.txtDireccion_u.setText('')
        self.winPrincipal.txtEmail_u.setText('')
        self.winPrincipal.txtNombre_u.setText('')
        self.winPrincipal.txtUsuario_u.setText('')
        self.winPrincipal.cbTipoUsuario_u.setCurrentIndex(0)
        self.winPrincipal.txtDNumero_u.setText('')
        self.winPrincipal.txtDPiso_u.setText('')
        self.winPrincipal.txtDDpto_u.setText('')
        self.winPrincipal.tvTelefonos_u.setModel(None)
        self.winPrincipal.txtFilterUsuarios_u.setText('')
        self.winPrincipal.tvUsuarios_u.setModel(None)

        self.winPrincipal.txtFilterUsuarios_u.setFocus(True)

    def setCampos(self):
        self.winPrincipal.txtApellido_u.setText(str(
            self.usuario.getApellido()))
        self.winPrincipal.txtContrasena_u.setText(str(
            self.usuario.getPasswd()))
        self.winPrincipal.txtEmail_u.setText(str(self.usuario.getEmail()))
        self.winPrincipal.txtNombre_u.setText(str(self.usuario.getNombre()))

        self.winPrincipal.txtUsuario_u.setText(str(self.usuario.getUsuario()))
        if self.usuario.getTipoUsuario() == 'ADM':
            self.winPrincipal.cbTipoUsuario_u.setCurrentIndex(1)
        elif self.usuario.getTipoUsuario() == 'USR':
            self.winPrincipal.cbTipoUsuario_u.setCurrentIndex(0)

        self.winPrincipal.txtDireccion_u.setText(
            str(self.usuario.getDireccion().getDireccion()))

        if self.usuario.getDireccion().getNumero() != None:
            self.winPrincipal.txtDNumero_u.setText(
                str(self.usuario.getDireccion().getNumero()))
        else:
            self.winPrincipal.txtDNumero_u.setText('')

        if self.usuario.getDireccion().getPiso() != None:
            self.winPrincipal.txtDPiso_u.setText(
                str(self.usuario.getDireccion().getPiso()))
        else:
            self.winPrincipal.txtDPiso_u.setText('')

        if self.usuario.getDireccion().getDpto() != None:
            self.winPrincipal.txtDDpto_u.setText(
                self.usuario.getDireccion().getDpto())
        else:
            self.winPrincipal.txtDDpto_u.setText('')

    def validar(self):
        mensaje = ""

        if self.winPrincipal.txtApellido_u.text() == '':
            mensaje = "Falta ingresar un apellido."
        elif self.winPrincipal.txtNombre_u.text() == '':
            mensaje = "Falta ingresar un nombre."
        elif self.winPrincipal.txtDireccion_u.text() == '':
            mensaje = "Falta ingresar la Direccion"
        elif self.winPrincipal.txtUsuario_u.text() == '':
            mensaje = "Falta ingresar el nombre de usuario"
        elif self.winPrincipal.txtContrasena_u.text() == '':
            mensaje = "Falta ingresa la contraseña."

        return mensaje

    def cargarTablaTelefono(self):
        self.listTelefonosInit = self.conexionTelefono.selectTelefono(
            self.usuario)
        if len(self.listTelefonosInit) > 0:
            header = ['ID', 'Numero', 'TIPO']
            tableModel = MyTableModel(self.winPrincipal,
                                      self.listTelefonosInit, header)
            self.winPrincipal.tvTelefonos_u.setModel(tableModel)
            self.winPrincipal.tvTelefonos_u.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTel)

            self.winPrincipal.tvTelefonos_u.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_u.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_u.setColumnWidth(2, 175)

            for r in range(0, len(self.listTelefonosInit)):
                self.winPrincipal.tvTelefonos_u.setRowHidden(r, False)

    def changeSelectedTableTel(self, selected, deselected):
        listTelefonos = selected.model().mylist
        self.telefonoSelected = ()
        self.telefonoSelected = listTelefonos[selected.row()]

        self.telefonoSelectedRow = selected.row()
        self.winPrincipal.txtTelefono_u.setText(str(self.telefonoSelected[2]))

        self.setTipoTelefono(str(self.telefonoSelected[1]))
        self.winPrincipal.btnCancelarTelefono_u.setVisible(True)
        self.winPrincipal.btnRestarTelefono_u.setEnabled(True)
        self.winPrincipal.tvTelefonos_u.setEnabled(False)

        self.winPrincipal.btnGuardar_u.setEnabled(False)
        self.winPrincipal.btnBorrar_u.setEnabled(False)

    def updateTelefono(self):

        listTelefono = []
        listTelefono = list(
            self.winPrincipal.tvTelefonos_u.model().mylist).copy()

        estado = ''
        telNew = Telefono()
        if len(listTelefono) > 0:
            if len(self.listTelefonosInit) > 0:

                listTelInit = list(self.listTelefonosInit)
                parche = (listTelefono[0][0], listTelefono[0][1],
                          str(listTelefono[0][2]))
                listTelefono[0] = parche
                #Recorre la lista de telefono inicial
                for telInit in listTelInit:
                    #recorre la lista de telefonos nueva
                    for tel in listTelefono:
                        telNew.setIdPersona(self.usuario.getIdPersona())
                        telNew.setIdTelefono(tel[0])
                        telNew.setTipo(tel[1])
                        if tel[2] == "":
                            estado = 'DEL'
                            break
                        else:
                            telNew.setTelefono(tel[2])

                        if tel[0] == 0:
                            estado = 'INS'
                            break

                        if telInit[0] == tel[0]:
                            if telInit[1] != tel[1] or telInit[2] != tel[2]:
                                estado = 'UPD'
                                break

                    if estado == 'UPD':
                        self.conexionTelefono.modificarTelefono(telNew)
                    elif estado == "INS":
                        self.conexionTelefono.insertarTelefono(telNew)
                    elif estado == 'DEL':
                        self.conexionTelefono.borrarTelefono(telNew)
            #Si la lista de telefono inicial es cero
            else:
                #recorre la lista de telefonos nueva para agregarlos a todos
                for telN in listTelefono:
                    if telN[2] != '':
                        telNew = Telefono()
                        telNew.setIdPersona(self.usuario.getIdPersona())
                        telNew.setIdTelefono(telN[0])
                        telNew.setTipo(telN[1])
                        telNew.setTelefono(telN[2])
                        self.conexionTelefono.insertarTelefono(telNew)

    def insertTelefono(self):

        listTelefonosNew = []
        tel = self.winPrincipal.tvTelefonos_u.model()

        listTelefonosNew = list(
            self.winPrincipal.tvTelefonos_u.model().mylist).copy()

        if len(listTelefonosNew) > 0:
            self.conexionTelefono.insertTelefonoInit(listTelefonosNew)

    def onClickCancelarTelefono(self):
        self.winPrincipal.btnCancelarTelefono_u.setVisible(False)
        self.winPrincipal.txtTelefono_u.setText('')

        self.winPrincipal.btnRestarTelefono_u.setEnabled(False)
        self.winPrincipal.tvTelefonos_u.clearSelection()
        self.winPrincipal.tvTelefonos_u.setEnabled(True)

        self.winPrincipal.btnGuardar_u.setEnabled(True)
        self.winPrincipal.btnBorrar_u.setEnabled(True)

    def onClickSumarTelefono(self):
        numTelefono = self.winPrincipal.txtTelefono_u.text()

        if numTelefono.isdigit() == True:
            if self.winPrincipal.btnCancelarTelefono_u.isVisible() is True:
                self.updateTelefonoTabla()
            else:
                self.insertTelefonoTabla()

            self.winPrincipal.tvTelefonos_u.clearSelection()
            self.winPrincipal.btnRestarTelefono_u.setEnabled(False)
            self.winPrincipal.btnCancelarTelefono_u.setVisible(False)
            self.winPrincipal.txtTelefono_u.setText('')
            self.winPrincipal.tvTelefonos_u.setEnabled(True)

            self.winPrincipal.btnGuardar_u.setEnabled(True)
        else:
            alert = QDialog()
            QMessageBox.information(alert, "ERROR",
                                    "El numero de telefono no es valido.")

    def onClickRestarTelefono(self):
        listTabTel = []
        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []

        listTabTel = list(
            self.winPrincipal.tvTelefonos_u.model().mylist).copy()

        header = ['Id', 'Tipo', 'Numero']
        telDel = [self.telefonoSelected[0], self.telefonoSelected[1], '']
        listTabTel[self.telefonoSelectedRow] = telDel
        tableTelModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_u.setModel(tableTelModel)
        self.winPrincipal.tvTelefonos_u.selectionModel(
        ).currentChanged.connect(self.changeSelectedTableTel)
        self.winPrincipal.tvTelefonos_u.setRowHidden(self.telefonoSelectedRow,
                                                     True)

        self.winPrincipal.btnCancelarTelefono_u.setVisible(False)
        self.winPrincipal.txtTelefono_u.setText('')
        self.winPrincipal.btnRestarTelefono_u.setEnabled(False)
        self.winPrincipal.tvTelefonos_u.setEnabled(True)

        self.winPrincipal.btnGuardar_u.setEnabled(True)
        self.winPrincipal.btnBorrar_u.setEnabled(True)

    def onClickTelefono(self):
        self.changeTipoTelefono(button='TEL')

    def onClickCelular(self):
        self.changeTipoTelefono(button='CEL')

    def onClickFax(self):
        self.changeTipoTelefono(button='FAX')

    def changeTipoTelefono(self, button):

        if button == 'TEL':
            self.winPrincipal.btnTelefono_u.setEnabled(False)
            self.winPrincipal.btnCelular_u.setEnabled(True)
            self.winPrincipal.btnFax_u.setEnabled(True)
        elif button == 'CEL':
            self.winPrincipal.btnTelefono_u.setEnabled(True)
            self.winPrincipal.btnCelular_u.setEnabled(False)
            self.winPrincipal.btnFax_u.setEnabled(True)
        elif button == 'FAX':
            self.winPrincipal.btnTelefono_u.setEnabled(True)
            self.winPrincipal.btnCelular_u.setEnabled(True)
            self.winPrincipal.btnFax_u.setEnabled(False)

    def setTipoTelefono(self, tipoTelefono):

        if tipoTelefono == 'TEL':
            self.winPrincipal.btnTelefono_u.setEnabled(False)
            self.winPrincipal.btnCelular_u.setEnabled(True)
            self.winPrincipal.btnFax_u.setEnabled(True)
        elif tipoTelefono == 'CEL':
            self.winPrincipal.btnTelefono_u.setEnabled(True)
            self.winPrincipal.btnCelular_u.setEnabled(False)
            self.winPrincipal.btnFax_u.setEnabled(True)
        elif tipoTelefono == 'FAX':
            self.winPrincipal.btnTelefono_u.setEnabled(True)
            self.winPrincipal.btnCelular_u.setEnabled(True)
            self.winPrincipal.btnFax_u.setEnabled(False)

    def getTipoTelefono(self):

        if self.winPrincipal.btnTelefono_u.isEnabled() != True:
            return 'TEL'
        elif self.winPrincipal.btnCelular_u.isEnabled() != True:
            return 'CEL'
        elif self.winPrincipal.btnFax_u.isEnabled() != True:
            return 'FAX'

    def insertTelefonoTabla(self):
        numTel = self.winPrincipal.txtTelefono_u.text()
        tipoTel = str(self.getTipoTelefono())

        modelListTelefono = self.winPrincipal.tvTelefonos_u.model()
        header = ['ID', 'Tipo', 'Numero']

        if modelListTelefono is not None:
            listTabTel = list(self.winPrincipal.tvTelefonos_u.model().mylist)

            if len(listTabTel) > 0 or listTabTel is not None:
                tuplaTel = ('0', tipoTel, numTel)
                listTabTel.append(tuplaTel)
                tupleTable = tuple(listTabTel)

                tableModel = MyTableModel(self.winPrincipal, tupleTable,
                                          header)
                self.winPrincipal.tvTelefonos_u.setModel(tableModel)
                self.winPrincipal.tvTelefonos_u.selectionModel(
                ).currentChanged.connect(self.changeSelectedTableTel)
        else:
            lista = []
            tuplaTel = ('0', tipoTel, numTel)
            lista.append(tuplaTel)

            tableModel = MyTableModel(self.winPrincipal, lista, header)
            self.winPrincipal.tvTelefonos_u.setModel(tableModel)
            self.winPrincipal.tvTelefonos_u.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvTelefonos_u.setColumnHidden(0, True)
            self.winPrincipal.tvTelefonos_u.setColumnWidth(1, 36)
            self.winPrincipal.tvTelefonos_u.setColumnWidth(2, 175)

    def updateTelefonoTabla(self):
        listTabTel = []
        tipoTel = str(self.getTipoTelefono())
        listTelefonosNew = []
        prob = self.winPrincipal.tvTelefonos_u.selectionModel()
        prob1 = self.winPrincipal.tvTelefonos_u.model()
        listTabTel = list(
            self.winPrincipal.tvTelefonos_u.model().mylist).copy()

        telUpd = (self.telefonoSelected[0], tipoTel,
                  int(self.winPrincipal.txtTelefono_u.text()))
        listTabTel[self.telefonoSelectedRow] = telUpd
        header = ['ID', 'Tipo', 'Numero']
        tableModel = MyTableModel(self.winPrincipal, listTabTel, header)
        self.winPrincipal.tvTelefonos_u.setModel(tableModel)
        self.winPrincipal.tvTelefonos_u.selectionModel(
        ).currentChanged.connect(self.changeSelectedTableTel)