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()
예제 #2
0
    def __init__(self, winPrincipal):
        self.conexionPagos = ConexionPagos()
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.proveedor = Proveedor()
        self.state = 'COBRANZA'

        self.configInit()
예제 #3
0
 def __init__(self, winPrincipal):
     self.conexionTransacciones = ConexionTransacciones()
     self.winPrincipal = winPrincipal
     self.cliente = Cliente()
     self.proveedor = Proveedor()
     self.producto = Producto()
     self.tipoTransaccion = "VENTA"
     self.configInit()
    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()
예제 #5
0
    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.producto = Producto()
        self.proveedor = Proveedor()
        self.marca = Marca()
        self.rubro = Rubro()
        self.estado = ""
        self.conexionProducto = conexionProducto()

        self.configInit()
예제 #6
0
    def generarSaldos(self):
        validate = True
        if self.winPrincipal.chbTodos_saldos.isChecked() == False:
            if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                if self.proveedores is None:
                    validate = False
            else:
                if self.clientes is None:
                    validate = False

        if validate == True:
            if self.winPrincipal.chbTodos_saldos.isChecked() == True:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    listProveedores = self.conexionesGenerales.selectProveedor(
                        '')
                    contenido = ""
                    for proveedores in listProveedores:
                        self.proveedores = Proveedor()
                        self.proveedores.setIdProveedor(int(proveedores[0]))
                        self.proveedores.setDescripcion(str(proveedores[1]))
                        self.proveedores.setNombre(str(proveedores[2]))

                        contenido += self.generateTable(
                            'PROVEEDOR', self.proveedores)
                else:
                    listClientes = self.conexionesGenerales.selectCliente('')
                    contenido = ""
                    for clientes in listClientes:
                        self.clientes = Cliente()
                        self.clientes.setIdCliente(int(clientes[0]))
                        self.clientes.setApellido(str(clientes[1]))
                        self.clientes.setNombre(str(clientes[2]))

                        contenido += self.generateTable(
                            'CLIENTE', self.clientes)
            else:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    contenido = self.generateTable('PROVEEDOR',
                                                   self.proveedores)
                else:
                    contenido = self.generateTable('CLIENTE', self.clientes)

            self.generatePDF(contenido)
        else:
            alert = QDialog()
            confirm = QMessageBox.question(alert, "Mensaje",
                                           "Falta selecciona la/s persona/s.",
                                           QMessageBox.Ok)
    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 __init__(self, winPrincipal):
     self.conexionTransacciones = ConexionTransacciones()
     self.winPrincipal = winPrincipal
     self.cliente = Cliente()
     self.proveedor = Proveedor()
     self.producto = Producto()
     self.tipoTransaccion = "VENTA"
     self.configInit()
    def __init__(self, winPrincipal):
        self.proveedor = Proveedor()
        self.winPrincipal = winPrincipal
        self.conexionProveedor = conexionProveedor()
        self.conexionTelefono = conexionTelefono()
        self.estado = ""
        self.direccion = Direccion()

        self.configInit()
예제 #10
0
    def changeSelectedTable(self, selected, deselected):
        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            proveedorList = selected.model().mylist
            proveedorSelected = proveedorList[selected.row()]

            self.proveedores = Proveedor()

            self.proveedores.setIdProveedor(int(proveedorSelected[0]))
            self.proveedores.setDescripcion(str(proveedorSelected[1]))
            self.proveedores.setNombre(str(proveedorSelected[2]))
        else:
            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]

            self.clientes = Cliente()

            self.clientes = Cliente()
            self.clientes.setIdCliente(int(clienteSelected[0]))
            self.clientes.setApellido(str(clienteSelected[1]))
            self.clientes.setNombre(str(clienteSelected[2]))
예제 #11
0
    def changeSelectedTable(self, selected, deselected):
        listPersonas = selected.model().mylist

        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        if self.state == "COBRANZA":
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif self.state == "PAGO":
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))

        self.calcularTransaccion()
예제 #12
0
    def changeSelectedTable(self, selected, deselected):

        productoList = selected.model().mylist
        productoSelected = productoList[selected.row()]
        self.producto = Producto()
        self.rubro = Rubro()
        self.proveedor = Proveedor()
        self.marca = Marca()

        self.producto.setIdProducto(productoSelected[0])
        self.producto.setNombre(productoSelected[1])
        self.producto.setDescripcion(productoSelected[2])
        self.producto.setPrecioCompra(productoSelected[3])
        self.producto.setPrecioVenta(productoSelected[4])
        self.producto.setGenero(productoSelected[5])
        self.producto.setEstado(productoSelected[6])
        self.producto.setCantidad(productoSelected[7])
        self.producto.setCantidadMinima(productoSelected[8])

        self.marca.setIdMarca(productoSelected[9])
        self.marca.setMarca(productoSelected[10])
        self.producto.setMarca(self.marca)

        self.rubro.setIdRubro(productoSelected[11])
        self.rubro.setRubro(productoSelected[12])
        self.producto.setRubro(self.rubro)

        self.proveedor.setIdProveedor(productoSelected[13])
        self.proveedor.setDescripcion(productoSelected[14])
        self.producto.setProveedor(self.proveedor)


        self.winPrincipal.tvProductos_p.setRowHeight(deselected.row(),33)
        self.winPrincipal.tvProductos_p.setRowHeight(selected.row(),45)


        self.setCampos()
        self.winPrincipal.btnModificar_p.setEnabled(True)
        self.winPrincipal.btnBorrar_p.setEnabled(True)
예제 #13
0
    def changeSelectedTable(self, selected, deselected):

        listPersonas = selected.model().mylist
        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        self.personaSelectedRow = selected.row()

        if (self.tipoTransaccion == "VENTA"):
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif (self.tipoTransaccion == "COMPRA"):
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))

        self.activateButton()
예제 #14
0
    def __init__(self):

        self.__idProducto = ""
        self.__nombre = ""
        self.__cantidad = 0
        self.__cantidadMinima = 0
        self.__descripcion = ""
        self.__genero = ""
        self.__rubro = Rubro()
        self.__proveedor = Proveedor()
        self.__marca = Marca()
        self.__estado = 0
        self.__pCompra = 0, 00
        self.__pVenta = 0, 00
    def generarSaldos(self):
        validate = True
        if self.winPrincipal.chbTodos_saldos.isChecked() == False:
            if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                if self.proveedores is None:
                    validate = False
            else:
                if self.clientes is None:
                    validate = False

        if validate == True:
            if self.winPrincipal.chbTodos_saldos.isChecked() == True:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    listProveedores = self.conexionesGenerales.selectProveedor('')
                    contenido = ""
                    for proveedores in listProveedores:
                        self.proveedores = Proveedor()
                        self.proveedores.setIdProveedor(int(proveedores[0]))
                        self.proveedores.setDescripcion(str(proveedores[1]))
                        self.proveedores.setNombre(str(proveedores[2]))

                        contenido += self.generateTable('PROVEEDOR', self.proveedores)
                else:
                    listClientes = self.conexionesGenerales.selectCliente('')
                    contenido = ""
                    for clientes in listClientes:
                        self.clientes = Cliente()
                        self.clientes.setIdCliente(int(clientes[0]))
                        self.clientes.setApellido(str(clientes[1]))
                        self.clientes.setNombre(str(clientes[2]))

                        contenido += self.generateTable('CLIENTE', self.clientes)
            else:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    contenido = self.generateTable('PROVEEDOR', self.proveedores)
                else:
                    contenido = self.generateTable('CLIENTE', self.clientes)


            self.generatePDF(contenido)
        else:
            alert = QDialog()
            confirm = QMessageBox.question(alert, "Mensaje", "Falta selecciona la/s persona/s.", QMessageBox.Ok)
    def changeSelectedTable(self, selected, deselected):
        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            proveedorList = selected.model().mylist
            proveedorSelected = proveedorList[selected.row()]

            self.proveedores = Proveedor()

            self.proveedores.setIdProveedor(int(proveedorSelected[0]))
            self.proveedores.setDescripcion(str(proveedorSelected[1]))
            self.proveedores.setNombre(str(proveedorSelected[2]))
        else:
            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]

            self.clientes = Cliente()

            self.clientes = Cliente()
            self.clientes.setIdCliente(int(clienteSelected[0]))
            self.clientes.setApellido(str(clienteSelected[1]))
            self.clientes.setNombre(str(clienteSelected[2]))
    def changeSelectedTable(self, selected, deselected):

        listPersonas = selected.model().mylist
        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        self.personaSelectedRow = selected.row()

        if(self.tipoTransaccion == "VENTA"):
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif(self.tipoTransaccion == "COMPRA"):
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))
예제 #18
0
class PestaniaEstadisticas():
    def __init__(self, winPrincipal):
        self.conexionesGenerales = ConexionGenerales()
        self.winPrincipal = winPrincipal

        hoy = datetime.datetime.now().date()
        self.winPrincipal.deHasta_stock.setDate(hoy)
        self.winPrincipal.deHasta_dinero.setDate(hoy)
        self.winPrincipal.deHasta_saldos.setDate(hoy)

        self.winPrincipal.btnGenerarPdf_dinero.clicked.connect(
            self.generarDinero)
        self.winPrincipal.btnGenerarPdf_stock.clicked.connect(
            self.generarStock)
        self.winPrincipal.btnGenerarPdf_saldos.clicked.connect(
            self.generarSaldos)
        self.winPrincipal.txtFilterPersona_saldos.returnPressed.connect(
            self.buscarPersonas)
        self.winPrincipal.rbClientes_saldos.clicked.connect(self.changePersona)
        self.winPrincipal.rbProveedores_saldos.clicked.connect(
            self.changePersona)

        self.winPrincipal.chbTodos_saldos.clicked.connect(self.clickTodos)

        self.winPrincipal.chbHoy_stock.clicked.connect(self.clickHoy_stock)
        self.winPrincipal.chbHoy_saldos.clicked.connect(self.clickHoy_saldos)
        self.winPrincipal.chbHoy_dinero.clicked.connect(self.clickHoy_dinero)

        self.winPrincipal.tvPersonas_saldos.setSortingEnabled(True)
        self.winPrincipal.tvPersonas_saldos.setMouseTracking(True)
        self.winPrincipal.tvPersonas_saldos.setSelectionBehavior(
            QAbstractItemView.SelectRows)

    def generarDinero(self):
        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_dinero.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_dinero.currentText() == 'Año':
            intervalo = 'year'
        elif self.winPrincipal.cbIntervalo_dinero.currentText() == 'Dia':
            intervalo = 'day'

        auxDesde = self.winPrincipal.deDesde_dinero.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_dinero.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listaEntradaTransacciones = self.conexionesGenerales.selectEntradasTransacciones(
            intervalo, desde, hasta)
        listaEntradaPagos = self.conexionesGenerales.selectEntradaPagos(
            intervalo, desde, hasta)

        listaSalidaTransacciones = self.conexionesGenerales.selectSalidaTransacciones(
            intervalo, desde, hasta)
        listaSalidaPagos = self.conexionesGenerales.selectSalidaPagos(
            intervalo, desde, hasta)

        listaGeneral = []

        if len(listaEntradaPagos
               ) < 1 and len(listaEntradaTransacciones) < 1 and len(
                   listaSalidaPagos) < 1 and len(listaSalidaTransacciones) < 1:
            pass

        else:
            dineroEntrada = 0
            dineroSalida = 0
            for entradaP in listaEntradaPagos:
                dineroEntrada += float(entradaP[1])
                monto = '$ + ' + str("{0:.2f}".format(entradaP[1]))
                entrada = []
                entrada.append(entradaP[0])
                entrada.append(monto)
                entrada.append(entradaP[2])
                #entrada = (entradaP[0] + monto + entradaP[2] )
                listaGeneral.append(entrada)

            for entradaT in listaEntradaTransacciones:
                dineroEntrada += float(entradaT[1])
                monto = '$ + ' + str("{0:.2f}".format(entradaT[1]))
                entrada = []
                entrada.append(entradaT[0])
                entrada.append(monto)
                entrada.append(entradaT[2])
                #entrada = (entradaT[0], monto, entradaT[2])
                listaGeneral.append(entrada)

            for salidaP in listaSalidaPagos:
                dineroSalida += float(salidaP[1])
                monto = '$ - ' + str("{0:.2f}".format(salidaP[1]))
                salida = []
                salida.append(salidaP[0])
                salida.append(monto)
                salida.append(salidaP[2])
                #salida = (salidaP[0], monto, salidaP[2])
                listaGeneral.append(salida)

            for salidaT in listaSalidaTransacciones:
                dineroSalida += float(salidaT[1])
                monto = '$ - ' + str("{0:.2f}".format(salidaT[1]))
                salida = []
                salida.append(salidaT[0])
                salida.append(monto)
                salida.append(salidaT[2])
                #salida = (salidaT[0], monto, salidaT[2])
                listaGeneral.append(salida)

            listTable = ""
            listaGeneral.sort()
            for lista in listaGeneral:
                listTable += """
                                <tr height="80">
                                    <td width="60%" align="left" >
                                    <br>""" + str(lista[0]) + """<br>
                                    </td>
                                    <td width="20%" align="right">
                                        <br> &nbsp;&nbsp;""" + str(
                    lista[1]) + """<br>
                                    </td>
                                    <td width="20%" align="center">
                                       <br>&nbsp;&nbsp; """ + str(
                        lista[2]) + """<br>
                                    </td>
                                </tr>
                           """

            contenido = """
                             <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                              <tr  style=" background-color: gray; border-style: inset;">
                                <td width="60%"  align="center" valign="middle">
                                    <b>
                                    FECHA
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle">
                                    <b>
                                        DINERO
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle">
                                    <b>
                                        TIPO MOVIMIENTO
                                    </b>
                                </td>
                              </tr>
                          </table>
                          <br>
                          <table width="600" >
                            """ + listTable + """

                          </table>

                          <p>
                            <br>
                            Dinero entrante = $ + """ + str(
                "{0:.2f}".format(dineroEntrada)) + """
                            <br>
                            Dinero salida = $ - """ + str(
                    "{0:.2f}".format(dineroSalida)) + """
                            <br>
                            <br>
                            Total .... : $ """ + str(
                        "{0:.2f}".format(dineroEntrada - dineroSalida)) + """
                          </p>
                        """
            self.generatePDF(contenido)

    def generarStock(self):
        self.listFinal = []
        self.title = "intervalo"

        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_stock.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_stock.currentText() == 'Año':
            intervalo = 'year'

        auxDesde = self.winPrincipal.deDesde_stock.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_stock.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listVentas = self.conexionesGenerales.selectVentas(
            intervalo, desde, hasta)
        listCompras = self.conexionesGenerales.selectCompras(
            intervalo, desde, hasta)

        if len(listCompras) < 1 and len(listVentas) < 1:
            alert = QDialog()
            confirm = QMessageBox.question(
                alert, "Mensaje",
                "Verifique los valores, la consulta no tiene ningun dato.",
                QMessageBox.Ok)

        else:
            i = 0
            for ventas in listVentas:
                itemList = (str(ventas[0]), listCompras[i][1], ventas[1])
                self.listFinal.append(itemList)
                i += 1

            listTable = ""
            cantMax = 0
            tupleFecha = []
            tupleCompra = []
            tupleVenta = []
            listFechas = []
            for lista in self.listFinal:
                i = 0
                listTable += """
                                            <tr height="80">
                                                <td width="60%" align="left" >
                                                <br>""" + str(
                    lista[0]) + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                    <br> &nbsp;&nbsp;""" + str(
                        lista[1]) + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                   <br>&nbsp;&nbsp; """ + str(
                            lista[2]) + """<br>
                                                </td>
                                            </tr>
                                       """
                if int(lista[1]) > int(lista[2]):
                    if int(lista[1]) > cantMax:
                        cantMax = int(lista[1])
                else:
                    if int(lista[2]) > cantMax:
                        cantMax = int(lista[2])

                listFechas.append(str(lista[0]))

                tupleFecha.append(str(lista[0]))  #+= str(lista[0])
                tupleCompra.append(int(lista[1]))
                tupleVenta.append(int(lista[2]))
                i = i + 1

            generateGraphic = []
            tdFecha = ""
            trCantFechas = ""

            betweenCant = int(cantMax / 12)
            listRange = []
            for i in range(0, cantMax, betweenCant):
                listRange.append(i)
                tdFecha = ""
                for lista in self.listFinal:

                    if i < int(lista[1]):
                        tdCantCompra = """
                                            <td width="50" style=" background-color: red;">
                                            </td>
                                       """
                    else:
                        tdCantCompra = """
                                            <td width="50">
                                            </td>
                                       """

                    if i < int(lista[2]):
                        tdCantVenta = """
                                            <td width="50" style=" background-color: blue;">
                                            </td>
                                      """
                    else:
                        tdCantVenta = """
                                            <td width="50">
                                            </td>
                                      """

                    tdFecha += tdCantCompra + tdCantVenta

                tr = """
                        <tr>
                            <td width="60">
                                """ + str(i) + """
                            </td>
                            """ + str(tdFecha) + """
                        </tr>
                     """

                generateGraphic.append(tr)

            n_groups = len(tupleFecha)

            fig, ax = pyplot.subplots()

            index = np.arange(n_groups)
            bar_width = 0.20

            opacity = 0.4
            error_config = {'ecolor': '0.3'}

            rects1 = pyplot.bar(index,
                                tupleVenta,
                                bar_width,
                                alpha=opacity,
                                color='b',
                                error_kw=error_config,
                                label='Venta')

            rects2 = pyplot.bar(index + bar_width,
                                tupleCompra,
                                bar_width,
                                alpha=opacity,
                                color='r',
                                error_kw=error_config,
                                label='Compra')

            pyplot.xlabel('Fecha')
            pyplot.ylabel('Cantidad')
            pyplot.title('Cantidad por fechas')
            pyplot.xticks(index + bar_width, tupleFecha)
            pyplot.legend()

            pyplot.tight_layout()
            pyplot.savefig('../archivos/picture1.png')

            trFechas = """<tr> <td width="60">CANT/FECHAS</td>"""
            for fecha in listFechas:
                tdFecha = """<td width="50" align="right" font-size="8"> """ + str(
                    fecha) + """</td> <td width="50"> </td> """
                trFechas += tdFecha

            trFechas += "</tr>"

            generateGraphic.reverse()

            generateGraphic.append(trFechas)

            finalGraphic = ""

            for graphic in generateGraphic:
                finalGraphic += graphic

            contenido = """
                         <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                              <tr  style=" background-color: gray; border-style: inset;">
                                <td width="60%"  align="center" valign="middle">
                                    <b>
                                    FECHA
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle" style=" background-color: red;">
                                    <b>
                                        PRODUCTOS COMPRADOS
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle" style="background-color: blue;">
                                    <b>
                                        PRODUCTOS VENDIDOS
                                    </b>
                                </td>
                              </tr>
                          </table>

                          <br>
                          <br>
                          <br>

                          <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                                """ + listTable + """
                          </table>
                            <br>
                            <br>

                            <br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>



                          <br><br><br><br><br><br><br>
                          <IMG SRC="../archivos/picture1.png" width="600" height="600">
                          <br><br><br><br><br><br><br><br><br><br>
                            <br>

                            <hr>
                            <br>
                            <table width="600">
                                <tr>
                                    <td align="right" width="100%">
                                    FECHA/HORA : """ + fecha + """
                                    </td>
                                </tr>
                            </table>
                           <hr>
                        """

            self.generatePDF(contenido)

    def clickHoy_stock(self):
        if self.winPrincipal.chbHoy_stock.isChecked() == True:
            self.winPrincipal.deHasta_stock.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_stock.setDate(hoy)
        else:
            self.winPrincipal.deHasta_stock.setEnabled(True)

    def clickHoy_saldos(self):
        if self.winPrincipal.chbHoy_saldos.isChecked() == True:
            self.winPrincipal.deHasta_saldos.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_saldos.setDate(hoy)
        else:
            self.winPrincipal.deHasta_saldos.setEnabled(True)

    def clickHoy_dinero(self):
        if self.winPrincipal.chbHoy_dinero.isChecked() == True:
            self.winPrincipal.deHasta_dinero.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_dinero.setDate(hoy)
        else:
            self.winPrincipal.deHasta_dinero.setEnabled(True)

    def generarSaldos(self):
        validate = True
        if self.winPrincipal.chbTodos_saldos.isChecked() == False:
            if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                if self.proveedores is None:
                    validate = False
            else:
                if self.clientes is None:
                    validate = False

        if validate == True:
            if self.winPrincipal.chbTodos_saldos.isChecked() == True:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    listProveedores = self.conexionesGenerales.selectProveedor(
                        '')
                    contenido = ""
                    for proveedores in listProveedores:
                        self.proveedores = Proveedor()
                        self.proveedores.setIdProveedor(int(proveedores[0]))
                        self.proveedores.setDescripcion(str(proveedores[1]))
                        self.proveedores.setNombre(str(proveedores[2]))

                        contenido += self.generateTable(
                            'PROVEEDOR', self.proveedores)
                else:
                    listClientes = self.conexionesGenerales.selectCliente('')
                    contenido = ""
                    for clientes in listClientes:
                        self.clientes = Cliente()
                        self.clientes.setIdCliente(int(clientes[0]))
                        self.clientes.setApellido(str(clientes[1]))
                        self.clientes.setNombre(str(clientes[2]))

                        contenido += self.generateTable(
                            'CLIENTE', self.clientes)
            else:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    contenido = self.generateTable('PROVEEDOR',
                                                   self.proveedores)
                else:
                    contenido = self.generateTable('CLIENTE', self.clientes)

            self.generatePDF(contenido)
        else:
            alert = QDialog()
            confirm = QMessageBox.question(alert, "Mensaje",
                                           "Falta selecciona la/s persona/s.",
                                           QMessageBox.Ok)

    def generateTable(self, type, persona):

        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_saldos.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_saldos.currentText() == 'Año':
            intervalo = 'year'
        elif self.winPrincipal.cbIntervalo_saldos.currentText() == 'Dia':
            intervalo = 'day'

        auxDesde = self.winPrincipal.deDesde_saldos.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_saldos.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listTransacciones = []
        listPagos = []
        #Total de los pagos
        pagosTotal = 0
        #Total de las transacciones en estado 0
        transaccionesTotal = 0
        total = 0
        #Lista completa (transacciones + pagos)
        listDetalle = []
        apellido = ''
        if type == "CLIENTE":
            listPagos = self.conexionesGenerales.selectListPagosCliente(
                persona, intervalo, desde, hasta)
            listTransacciones = self.conexionesGenerales.selectListTransaccionCliente(
                persona, intervalo, desde, hasta)

            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(
                        transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto,
                                      str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0

            total = pagosTotal - transaccionesTotal
            apellido = persona.getApellido()
        elif type == "PROVEEDOR":
            listPagos = self.conexionesGenerales.selectListPagosProveedor(
                persona, intervalo, desde, hasta)
            listTransacciones = self.conexionesGenerales.selectListTransaccionProveedor(
                persona, intervalo, desde, hasta)

            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(
                        transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto,
                                      str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0

            total = pagosTotal - transaccionesTotal
            apellido = persona.getDescripcion()

        listDetalle.sort()
        listTable = ""
        for lista in listDetalle:
            listTable += """
                                            <tr height="80">
                                                <td width="60%" align="left" >
                                                <br>""" + str(
                lista[0]) + """<br>
                                                </td>
                                                <td width="20%" align="right">
                                                    <br> &nbsp;&nbsp;""" + str(
                    lista[1]) + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                   <br>&nbsp;&nbsp; """ + str(
                        lista[2]) + """<br>
                                                </td>
                                            </tr>
                                       """

        contenido = """
                            <br>
                            <br>
                          <table width="600" height="100">
                            <tr>
                                <br> Nombre : """ + persona.getNombre(
        ) + """ <br>
                                Apellido : """ + apellido + """<br>
                            </tr>
                          </table>
                          <table width="600"  >
                                <tr height="80" style=" background-color: gray; border-style: inset;">
                                    <td width="60%" align="center" >
                                        <br>FECHA<br>
                                        </td>
                                        <td width="20%" align="center">
                                            <br> MONTO <br>
                                        </td>
                                        <td width="20%" align="center">
                                           <br>ACCION<br>
                                        </td>
                                </tr>
                                """ + listTable + """
                          </table>

                          <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                            <tr>
                                <td width="70%"><br>SALDO..............<br></td>
                                <td><br> $ """ + str(
            "{0:.2f}".format(total)) + """ <br></td>
                            </tr>
                          </table>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                            <br>
                    """

        return contenido

    def buscarPersonas(self):
        if self.winPrincipal.txtFilterPersona_saldos.hasFocus() is True:
            self.cargarTablaSaldos()

    def cargarTablaSaldos(self):

        parameter = self.winPrincipal.txtFilterPersona_saldos.text()

        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            listaProveedores = self.conexionesGenerales.selectProveedor(
                parameter)

            if len(listaProveedores) > 0:
                header = ['ID', 'Apellido', 'Nombre']
                self.tablaModel = MyTableModel(
                    self.winPrincipal.tvPersonas_saldos, listaProveedores,
                    header)
                self.winPrincipal.tvPersonas_saldos.setModel(self.tablaModel)
                self.winPrincipal.tvPersonas_saldos.selectionModel(
                ).currentChanged.connect(self.changeSelectedTable)

                self.winPrincipal.tvPersonas_saldos.setColumnHidden(0, True)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(1, 120)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(2, 120)
        else:
            listaClientes = self.conexionesGenerales.selectCliente(parameter)

            if len(listaClientes) > 0:
                header = ['ID', 'Apellido', 'Nombre']
                self.tablaModel = MyTableModel(
                    self.winPrincipal.tvPersonas_saldos, listaClientes, header)
                self.winPrincipal.tvPersonas_saldos.setModel(self.tablaModel)
                self.winPrincipal.tvPersonas_saldos.selectionModel(
                ).currentChanged.connect(self.changeSelectedTable)

                self.winPrincipal.tvPersonas_saldos.setColumnHidden(0, True)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(1, 120)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(2, 120)

    def changeSelectedTable(self, selected, deselected):
        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            proveedorList = selected.model().mylist
            proveedorSelected = proveedorList[selected.row()]

            self.proveedores = Proveedor()

            self.proveedores.setIdProveedor(int(proveedorSelected[0]))
            self.proveedores.setDescripcion(str(proveedorSelected[1]))
            self.proveedores.setNombre(str(proveedorSelected[2]))
        else:
            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]

            self.clientes = Cliente()

            self.clientes = Cliente()
            self.clientes.setIdCliente(int(clienteSelected[0]))
            self.clientes.setApellido(str(clienteSelected[1]))
            self.clientes.setNombre(str(clienteSelected[2]))

    def changePersona(self):
        self.clientes = None
        self.proveedores = None

        self.winPrincipal.txtFilterPersona_saldos.setText('')
        self.winPrincipal.tvPersonas_saldos.setModel(None)

    def clickTodos(self):
        if self.winPrincipal.chbTodos_saldos.isChecked() == True:
            self.winPrincipal.txtFilterPersona_saldos.setEnabled(False)
            self.winPrincipal.tvPersonas_saldos.setModel(None)
        else:
            self.winPrincipal.txtFilterPersona_saldos.setEnabled(True)

    def generatePDF(self, contenido):
        hoy = str(datetime.datetime.now().year) + str(
            datetime.datetime.now().month) + str(
                datetime.datetime.now().day) + str(
                    datetime.datetime.now().hour) + str(
                        datetime.datetime.now().minute) + str(
                            datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + 'LIST') + '.pdf'

        fecha = str(datetime.datetime.now())

        html = """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">

                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>

                   <hr>
                    <br>
                    <p>
                        SALDOS
                    </p>
                    <br>

                  """ + contenido

        doc = QTextDocument()
        doc.setHtml(html)

        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)
예제 #19
0
class PestaniaProducto():
    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.producto = Producto()
        self.proveedor = Proveedor()
        self.marca = Marca()
        self.rubro = Rubro()
        self.estado = ""
        self.conexionProducto = conexionProducto()

        self.completerRubro = QCompleter()
        self.completerMarca = QCompleter()
        self.completerProveedor = QCompleter()
        self.configInit()

    def configInit(self):
        #Configurando botones
        self.winPrincipal.btnAgregar_p.clicked.connect(self.onClickAgregar_p)
        self.winPrincipal.btnGuardar_p.clicked.connect(self.onClickGuardar_p)
        self.winPrincipal.btnBorrar_p.clicked.connect(self.onClickBorrar_p)
        self.winPrincipal.btnModificar_p.clicked.connect(
            self.onClickModificar_p)

        self.winPrincipal.btnRubro_p.clicked.connect(windowRubro)
        self.winPrincipal.btnMarca_p.clicked.connect(windowMarca)

        #windowMarca.connect(windowMarca, Qt.SIGNAL('destroyed()'), self.onQuitMarca)
        self.winPrincipal.txtFilterProductos_p.returnPressed.connect(
            self.search)

        #self.cargarTabla()
        self.winPrincipal.tvProductos_p.setMouseTracking(True)
        self.winPrincipal.tvProductos_p.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.setCompleterMarca()
        self.setCompleterRubro()
        self.setCompleterProveedor()

        self.winPrincipal.txtFilterProductos_p.setFocus(True)

    def finish(self):
        self.winPrincipal.btnAgregar_p.disconnect()
        self.winPrincipal.btnGuardar_p.disconnect()
        self.winPrincipal.btnModificar_p.disconnect()
        self.winPrincipal.btnBorrar_p.disconnect()
        self.winPrincipal.btnRubro_p.disconnect()
        self.winPrincipal.btnMarca_p.disconnect()
        self.winPrincipal.tvProductos_p.disconnect()

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

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

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

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert, "ERROR", validar)
        else:
            self.producto.setDescripcion(
                str(self.winPrincipal.txtDescripcion_p.toPlainText()))
            self.producto.setCantidad(
                int(self.winPrincipal.sbCantidad_p.value()))
            self.producto.setCantidadMinima(
                int(self.winPrincipal.sbCantidadMin_p.value()))
            if self.winPrincipal.cbEstado_p.currentText() == "ACTIVO":
                self.producto.setEstado(1)
            else:
                self.producto.setEstado(0)

            if self.winPrincipal.rbFemenino_p.isChecked() is True:
                self.producto.setGenero("F")
            elif self.winPrincipal.rbMasculino_p.isChecked() is True:
                self.producto.setGenero("M")
            else:
                self.producto.setGenero("I")

            self.producto.setNombre(str(self.winPrincipal.txtNombre_p.text()))
            self.producto.setPrecioCompra(
                float(self.winPrincipal.txtPrecioCompra_p.text()))
            self.producto.setPrecioVenta(
                float(self.winPrincipal.txtPrecioVenta_p.text()))

            self.rubro.setRubro(str(self.completerRubro.currentCompletion()))
            self.producto.setRubro(self.rubro)

            self.proveedor.setDescripcion(
                str(self.completerProveedor.currentCompletion()))
            self.producto.setProveedor(self.proveedor)

            self.marca.setMarca(str(self.completerMarca.currentCompletion()))
            self.producto.setMarca(self.marca)

            if self.estado == 'AGREGAR':
                self.insertarProducto()
            elif self.estado == 'MODIFICAR':
                self.modificarProducto()

            self.validarBotones('GUARDAR')

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

    def onClickBorrar_p(self):
        if self.winPrincipal.btnGuardar_p.isEnabled() != True:
            self.conexionProducto.borrarProducto(self.producto)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')

    def cargarTabla(self):

        parameter = self.winPrincipal.txtFilterProductos_p.text()
        typeParameter = ''
        if self.winPrincipal.cbFilterProducto_p.currentText() == 'Nombre':
            typeParameter = 'p.nombre'
        elif self.winPrincipal.cbFilterProducto_p.currentText() == 'Marca':
            typeParameter = 'm.descripcion'
        else:
            typeParameter = 'r.descripcion'

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

        parameterStock = 1
        if self.winPrincipal.cbSinStock_p.isChecked() is True:
            parameterStock = 0

        listaProductos = self.conexionProducto.selectProducto(
            typeParameter, parameter, parameterState, parameterStock)

        if len(listaProductos) > 0:

            header = [
                'idPro', 'Nombre', 'Descripcion', 'PC', 'PV', 'G', 'Estado',
                'Cant', 'Cantidad Min', 'idMar', 'Marca', 'idRubro', 'Rubro',
                'idProv', 'Proveedor'
            ]
            self.tablaModel = MyTableModel(self.winPrincipal.tvProductos_p,
                                           listaProductos, header)
            self.winPrincipal.tvProductos_p.setModel(self.tablaModel)
            self.winPrincipal.tvProductos_p.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvProductos_p.setColumnHidden(0, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(1, 200)
            self.winPrincipal.tvProductos_p.setColumnWidth(2, 320)
            self.winPrincipal.tvProductos_p.setColumnWidth(3, 60)
            self.winPrincipal.tvProductos_p.setColumnWidth(4, 60)
            self.winPrincipal.tvProductos_p.setColumnWidth(5, 60)
            self.winPrincipal.tvProductos_p.setColumnHidden(6, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(7, 40)
            self.winPrincipal.tvProductos_p.setColumnHidden(8, True)
            self.winPrincipal.tvProductos_p.setColumnHidden(9, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(10, 130)
            self.winPrincipal.tvProductos_p.setColumnHidden(11, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(12, 130)
            self.winPrincipal.tvProductos_p.setColumnHidden(13, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(14, 130)
        else:
            self.winPrincipal.tvProductos_p.setModel(None)

    def changeSelectedTable(self, selected, deselected):

        productoList = selected.model().mylist
        productoSelected = productoList[selected.row()]
        self.producto = Producto()
        self.rubro = Rubro()
        self.proveedor = Proveedor()
        self.marca = Marca()

        self.producto.setIdProducto(productoSelected[0])
        self.producto.setNombre(productoSelected[1])
        self.producto.setDescripcion(productoSelected[2])
        self.producto.setPrecioCompra(productoSelected[3])
        self.producto.setPrecioVenta(productoSelected[4])
        self.producto.setGenero(productoSelected[5])
        self.producto.setEstado(productoSelected[6])
        self.producto.setCantidad(productoSelected[7])
        self.producto.setCantidadMinima(productoSelected[8])

        self.marca.setIdMarca(productoSelected[9])
        self.marca.setMarca(productoSelected[10])
        self.producto.setMarca(self.marca)

        self.rubro.setIdRubro(productoSelected[11])
        self.rubro.setRubro(productoSelected[12])
        self.producto.setRubro(self.rubro)

        self.proveedor.setIdProveedor(productoSelected[13])
        self.proveedor.setDescripcion(productoSelected[14])
        self.producto.setProveedor(self.proveedor)

        self.winPrincipal.tvProductos_p.setRowHeight(deselected.row(), 33)
        self.winPrincipal.tvProductos_p.setRowHeight(selected.row(), 45)

        self.setCampos()
        self.winPrincipal.btnModificar_p.setEnabled(True)
        self.winPrincipal.btnBorrar_p.setEnabled(True)

    def validarBotones(self, button):
        if button == 'AGREGAR':
            self.winPrincipal.wDatosProducto.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setText('CANCELAR')
            self.winPrincipal.btnGuardar_p.setEnabled(True)
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(False)
            self.limpiarCampos()

        elif button == 'GUARDAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(True)
            self.winPrincipal.btnGuardar_p.setEnabled(False)
            self.winPrincipal.btnBorrar_p.setText('BORRAR')
            self.winPrincipal.btnBorrar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(True)
            self.winPrincipal.wDatosProducto.setEnabled(False)
            self.limpiarCampos()

        elif button == 'MODIFICAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(False)
            self.winPrincipal.btnGuardar_p.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setText('CANCELAR')
            self.winPrincipal.btnBorrar_p.setEnabled(True)
            self.winPrincipal.tvProductos_p.setEnabled(False)
            self.winPrincipal.wDatosProducto.setEnabled(True)

        elif button == 'BORRAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(True)
            self.winPrincipal.btnGuardar_p.setEnabled(False)
            self.winPrincipal.btnBorrar_p.setText('BORRAR')
            self.winPrincipal.btnBorrar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(True)
            self.winPrincipal.wDatosProducto.setEnabled(False)
            self.limpiarCampos()

    def insertarProducto(self):
        self.conexionProducto.insertarProducto(producto=self.producto)
        self.cargarTabla()

    def modificarProducto(self):
        self.conexionProducto.modificarProducto(self.producto)
        self.cargarTabla()

    def limpiarCampos(self):
        self.winPrincipal.txtNombre_p.setText('')
        self.winPrincipal.txtPrecioCompra_p.setText('')
        self.winPrincipal.txtPrecioVenta_p.setText('')
        self.winPrincipal.sbCantidad_p.setValue(0)
        self.winPrincipal.sbCantidadMin_p.setValue(0)
        self.winPrincipal.txtProveedor_p.setText('')
        self.winPrincipal.txtDescripcion_p.setText('')
        self.winPrincipal.txtRubro_p.setText('')
        self.winPrincipal.txtMarca_p.setText('')
        self.completerProveedor.setCurrentRow(0)
        self.completerRubro.setCurrentRow(0)
        self.completerMarca.setCurrentRow(0)
        self.winPrincipal.txtFilterProductos_p.setText('')
        self.winPrincipal.tvProductos_p.setModel(None)

        self.winPrincipal.txtFilterProductos_p.setFocus(True)

    def setCampos(self):
        self.winPrincipal.txtNombre_p.setText(self.producto.getNombre())
        self.winPrincipal.txtDescripcion_p.setText(
            str(self.producto.getDescripcion()))
        self.winPrincipal.txtPrecioCompra_p.setText(
            str(self.producto.getPrecioCompra()))
        self.winPrincipal.txtPrecioVenta_p.setText(
            str(self.producto.getPrecioVenta()))
        self.winPrincipal.txtProveedor_p.setText(
            str(self.producto.getProveedor().getDescripcion()))

        self.winPrincipal.sbCantidad_p.setValue(
            int(self.producto.getCantidad()))
        self.winPrincipal.sbCantidadMin_p.setValue(
            int(self.producto.getCantidadMinima()))

        self.winPrincipal.txtRubro_p.setText(
            str(self.producto.getRubro().getRubro()))
        self.winPrincipal.txtMarca_p.setText(
            str(self.producto.getMarca().getMarca()))

        if self.producto.getEstado() == 1:
            self.winPrincipal.cbEstado_p.setCurrentIndex(0)
        else:
            self.winPrincipal.cbEstado_p.setCurrentIndex(1)

        if self.producto.getGenero() == 'F':
            self.winPrincipal.rbFemenino_p.setChecked(True)
        elif self.producto.getGenero() == 'M':
            self.winPrincipal.rbMasculino_p.setChecked(True)
        else:
            self.winPrincipal.rbIndiferente_p.setChecked(True)

    def validar(self):
        mensaje = ''
        if self.winPrincipal.txtNombre_p.text() == '':
            mensaje = "Falta ingresar Nombre"
        elif self.winPrincipal.txtPrecioCompra_p.text() == '':
            mensaje = "Falta ingresar Precio de Compra"
        elif self.winPrincipal.txtPrecioVenta_p.text() == '':
            mensaje = "Falta ingresar Precio de Venta"
        elif self.completerProveedor.currentCompletion() == '':
            mensaje = "Falta ingresar un Proveedor"
        elif self.completerMarca.currentCompletion() == '':
            mensaje = "Falta seleccionar la marca"
        elif self.completerRubro.currentCompletion() == '':
            mensaje = 'Falta seleccionar el rubro'
        """elif self.completerProveedor.currentCompletion() =='' or self.completerProveedor.currentRow() == 0:
            mensaje= "Falta ingresar un Proveedor"
        elif self.completerMarca.currentCompletion() == '' or self.completerMarca.currentRow() == 0:
            mensaje = "Falta seleccionar la marca"
        elif self.completerRubro.currentCompletion() == '' or self.completerRubro.currentRow() == 0:
            mensaje = 'Falta seleccionar el rubro'
        """
        return mensaje

    def setCompleterMarca(self):
        listMarcas = self.conexionProducto.listMarcas()
        self.completerMarca = QCompleter(listMarcas)

        self.completerMarca.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.winPrincipal.txtMarca_p.setCompleter(self.completerMarca)

    def setCompleterRubro(self):
        listRubros = self.conexionProducto.listRubro()
        self.completerRubro = QCompleter(listRubros)
        #self.completerRubro.dynamicPropertyNames()
        self.completerRubro.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.winPrincipal.txtRubro_p.setCompleter(self.completerRubro)

    def setCompleterProveedor(self):
        listProveedores = self.conexionProducto.listProveedor()
        self.completerProveedor = QCompleter(listProveedores)

        self.completerProveedor.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.winPrincipal.txtProveedor_p.setCompleter(self.completerProveedor)
class PestaniaTransacciones():


    def __init__(self, winPrincipal):
        self.conexionTransacciones = ConexionTransacciones()
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.proveedor = Proveedor()
        self.producto = Producto()
        self.tipoTransaccion = "VENTA"
        self.configInit()
        self.total = 0


    def configInit(self):
        self.winPrincipal.rbVenta_t.clicked.connect(self.onClickVenta)
        self.winPrincipal.rbCompra_t.clicked.connect(self.onClickCompra)

        self.winPrincipal.btnSumarProducto_t.clicked.connect(self.agregarTransaccion)

        self.winPrincipal.btnAceptar_t.clicked.connect(self.onClickAceptar)
        self.winPrincipal.btnCancelar_t.clicked.connect(self.onClickCancelar)

        self.cargarTablaProductos()

        self.winPrincipal.tvClientes_t.setSortingEnabled(True)
        self.winPrincipal.tvClientes_t.setMouseTracking(True)
        self.winPrincipal.tvClientes_t.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.tvProductos_t.setSortingEnabled(True)
        self.winPrincipal.tvProductos_t.setMouseTracking(True)
        self.winPrincipal.tvProductos_t.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.tvDetalleTransaccion_t.setSortingEnabled(True)
        self.winPrincipal.tvDetalleTransaccion_t.setMouseTracking(True)
        self.winPrincipal.tvDetalleTransaccion_t.setSelectionBehavior(QAbstractItemView.SelectRows)


    def onClickAceptar(self):

        listTransaccion = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()
        subNom = ""
        numRecibo = 0
        if(self.tipoTransaccion == "VENTA"):
            numRecibo = self.conexionTransacciones.cargarTransaccionVenta(listTransaccion, self.cliente)
            subNom = 'VNT'
        elif(self.tipoTransaccion == "COMPRA"):
            numRecibo = self.conexionTransacciones.cargarTransaccionCompra(listTransaccion, self.proveedor)
            subNom = 'CMP'

        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea generar factura ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.createFactura(listTransaccion, subNom, numRecibo)


        self.limpiarCampos()

    def createFactura(self, listTransaccion, subNom, idRecibo):
        hoy = str(datetime.datetime.now().year) + str(datetime.datetime.now().month) + str(datetime.datetime.now().day) + str(datetime.datetime.now().hour) + str(datetime.datetime.now().minute) + str(datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + subNom) + '.pdf'
        listTransaccionTable = ""
        for transaccion in listTransaccion:
            listTransaccionTable += """
                                        <tr height="80">
                                            <td width="10%" align="center" >
                                            <br>""" + str(transaccion[1])  + """<br>
                                            </td>
                                            <td width="20%" >
                                                <br> &nbsp;&nbsp;""" + str(transaccion[3])  + """<br>
                                            </td>
                                            <td width="50%" >
                                               <br>&nbsp;&nbsp; """ + str(transaccion[4])  + """<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str(transaccion[5])  + """&nbsp;&nbsp;<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str( int(transaccion[1]) * float(transaccion[5]))  + """&nbsp;&nbsp;<br>
                                            </td>
                                        </tr>
                                   """
        nombre = ""
        apellido = ""

        if(self.tipoTransaccion == "VENTA"):
            nombre = self.cliente.getNombre()
            apellido = self.cliente.getApellido()
        elif(self.tipoTransaccion == "COMPRA"):
            nombre = self.proveedor.getNombre()
            apellido = self.proveedor.getDescripcion()


        total = self.winPrincipal.lblTotal.text()
        fecha = str(datetime.datetime.now())
        html =  """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">
                               Perfumeria La que vende perfumes <br>
                               LABOULAYE, CORDOBA, ARGENTINA <br>
                               TEL: 0351-111111  <br>
                               MAIL: [email protected]  <br>
                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>
                _______________________________________________________________________________________________________
                    <p>
                        DATOS DEL CLIENTE:
                    </p>
                    <br>
                    <table>

                        <tr>
                            <td>
                                NOMBRE:   """+ nombre +"""  <br>
                                APELLIDO: """ + apellido + """ <br>

                            </td>
                            <td>
                            </td>
                        </tr>
                    </table>

                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <p>
                        DETALLES DE LA COMPRA:
                    </p>
                    <br>
                    <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                      <tr  style=" background-color: gray; border-style: inset;">
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            CANT
                            </b>
                        </td>
                        <td width="20%"  align="center" valign="middle">
                            <b>
                                PRODUCTO
                            </b>
                        </td>
                        <td width="50%"  align="center" valign="middle">
                            <b>
                            DESCRIPCION
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>UNIT
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>TOT
                            </b>
                        </td>
                      </tr>
                  </table>

                  <br>
                  <br>
                  <br>
                  <br>

                  <table  height="350" width="600" style="border-color: gray; border-width: .4px; border-collapse: collapse;">
                      """ + listTransaccionTable + """
                  </table>
                    <br>
                    <br>
                    <table width="600" border="0.5" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                        <tr >
                            <td width="90%" align="right">
                                <br>
                                TOTAL..................................................................................................................
                                <br>
                            </td>
                            <td width="10%" align="center">
                              <br> $ """ + total + """<br>
                            </td>
                        </tr>
                    </table>

                    <br>
                    <br>
                    <br>
                    <p width="600" align="center" style=" font-size: 10; " >
                    Por cualquier consulta, sobre este recibo, dirigirse al local que se encuentra ubicado en la calle
                    independencia 450. <br> O Comunicarse a los telefonos 03382-123123123 / 4231231
                    </p>
                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <table width="600">
                        <tr>
                            <td align="right" width="80%">
                            FECHA/HORA : """+ fecha + """
                            </td>
                            <td align="right">
                            N° : """+ str(idRecibo) +"""
                            </td>
                        </tr>
                    </table>
                    _______________________________________________________________________________________________________
                """

        doc = QTextDocument()
        doc.setHtml(html)
        #doc.setDefaultStyleSheet(style)
        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)

        """
        printPdf = QPrinter()
        printPdf.setOutputFormat(QPrinter.NativeFormat)

        questionPrint = QPrintDialog(printPdf, self.winPrincipal)

        if questionPrint.exec() == QPrintDialog.accept(printPdf):
            doc.print(printPdf)


        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea generar factura ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:

            #openPdf = QPrintDialog(printPdf, self.winPrincipal)
            #openPdf.setWindowTitle("Recibo")
        """


    def limpiarCampos(self):
        self.winPrincipal.tvClientes_t.setModel(None)
        self.winPrincipal.tvDetalleTransaccion_t.setModel(None)
        self.winPrincipal.tvProductos_t.setModel(None)
        self.winPrincipal.lblTotal.setText('')
        self.winPrincipal.sbCantidadProducto_t.setValue(0)



    def onClickCancelar(self):
        self.limpiarCampos()

    def cargarTablaClientes(self):
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Email':
            tipoParametro = 'p.email'

        parametro = self.winPrincipal.txtFilterCliente_t.text()

        listaClientes = self.conexionTransacciones.selectClientes(tipoParametro, parametro)

        header = ['ID','Apellido','Nombre','Email']
        tablaModel = MyTableModel(self.winPrincipal.tvClientes_t, listaClientes, header)
        self.winPrincipal.tvClientes_t.setModel(tablaModel)
        self.winPrincipal.tvClientes_t.selectionModel().currentChanged.connect(self.changeSelectedTable)


        self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
        self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
        self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
        self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)


    def cargarTablaProveedores(self):
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Email':
            tipoParametro = 'p.email'

        parametro = self.winPrincipal.txtFilterCliente_t.text()

        listProveedores = self.conexionTransacciones.selectProveedores(tipoParametro, parametro)

        header = ['ID', 'Descripcion', 'Nombre', 'Email']
        tableModel = MyTableModel(self.winPrincipal.tvClientes_t, listProveedores, header)
        self.winPrincipal.tvClientes_t.setModel(tableModel)
        self.winPrincipal.tvClientes_t.selectionModel().currentChanged.connect(self.changeSelectedTable)

        self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
        self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
        self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
        self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)



    def changeSelectedTable(self, selected, deselected):

        listPersonas = selected.model().mylist
        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        self.personaSelectedRow = selected.row()

        if(self.tipoTransaccion == "VENTA"):
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif(self.tipoTransaccion == "COMPRA"):
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))



    def cargarTablaProductos(self):
        listProducto = self.conexionTransacciones.selectProductos()

        header = ['ID', 'Nombre', 'Descripcion', 'Cant', 'P.Compra', 'P.Venta', 'Marca']

        tableModel = MyTableModel(self.winPrincipal.tvProductos_t, listProducto, header)
        self.winPrincipal.tvProductos_t.setModel(tableModel)
        self.winPrincipal.tvProductos_t.selectionModel().currentChanged.connect(self.changeSelectedTableProducto)



        self.winPrincipal.tvProductos_t.setColumnHidden(0, True)
        self.winPrincipal.tvProductos_t.setColumnWidth(1, 150)
        self.winPrincipal.tvProductos_t.setColumnWidth(2, 200)
        self.winPrincipal.tvProductos_t.setColumnWidth(3, 50)
        self.winPrincipal.tvProductos_t.setColumnWidth(4, 80)
        self.winPrincipal.tvProductos_t.setColumnWidth(5, 80)
        self.winPrincipal.tvProductos_t.setColumnWidth(6, 100)

        #tvProductos_t

    def changeSelectedTableProducto(self, selected, deselected):
        listProductos = selected.model().mylist
        productoSelected = ()
        productoSelected = tuple(listProductos[selected.row()])

        self.productoSelected = selected.row()

        self.producto = Producto()
        self.producto.setIdProducto(int(productoSelected[0]))
        self.producto.setNombre(str(productoSelected[1]))
        self.producto.setDescripcion(str(productoSelected[2]))
        self.producto.setCantidad(int(productoSelected[3]))
        self.producto.setPrecioCompra(float(productoSelected[4]))
        self.producto.setPrecioVenta(float(productoSelected[5]))




    def agregarTransaccion(self):
        #tvDetalleTransaccion_t
        #btnSumarProducto_t
        cantProducto = int(self.winPrincipal.sbCantidadProducto_t.value())

        modelListTransaccion = self.winPrincipal.tvDetalleTransaccion_t.model()
        header = ['ID', 'Cantidad','idProducto' ,'Producto', 'Descripcion', 'precio_unitario' ]

        precio_unitario = 0
        if(self.tipoTransaccion == "VENTA"):
            precio_unitario = float(self.producto.getPrecioVenta())

        elif(self.tipoTransaccion == "COMPRA"):
            precio_unitario = float(self.producto.getPrecioCompra())

        if modelListTransaccion is not None:
            listTabPro = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist)

            if len(listTabPro) > 0 or listTabPro is not None:
                tuplaProd = ('0', str(cantProducto), str(self.producto.getIdProducto()), str(self.producto.getNombre()),
                            str(self.producto.getDescripcion()), str(precio_unitario)
                            )

                listTabPro.append(tuplaProd)
                tupleTable = tuple(listTabPro)

                tableModel = MyTableModel(self.winPrincipal, tupleTable , header)
                self.winPrincipal.tvDetalleTransaccion_t.setModel(tableModel)
                #self.winPrincipal.tvDetalleTransaccion_t.selectionModel().currentChanged.connect(self.changeSelectedTableTransaccion)
        else:
            lista = []
            tuplaProd = ('0', str(cantProducto), str(self.producto.getIdProducto()), str(self.producto.getNombre()),
                           str(self.producto.getDescripcion()), str(precio_unitario)
                            )
            lista.append(tuplaProd)

            tableModel = MyTableModel(self.winPrincipal, lista , header)
            self.winPrincipal.tvDetalleTransaccion_t.setModel(tableModel)
            #self.winPrincipal.tvDetalleTransaccion_t.selectionModel().currentChanged.connect(self.changeSelectedTableTel)
            self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(0, True)
            self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(1, 80)
            self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(2, True)
            self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(3, 200)
            self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(4, 300)


        self.total = (cantProducto * self.producto.getPrecioVenta()) + self.total

        self.winPrincipal.lblTotal.setText(str(self.total))

        self.winPrincipal.tvClientes_t.setEnabled(False)

    def changeSelectedTableTransaccion(self, selected, deselected):
        pass

    def onClickVenta(self):
        self.winPrincipal.label2_t.setText('Cliente')
        self.cargarTablaClientes()
        self.tipoTransaccion = "VENTA"

    def onClickCompra(self):
        self.winPrincipal.label2_t.setText('Proovedor')
        self.cargarTablaProveedores()
        self.tipoTransaccion = "COMPRA"


    def selecClientes(self):
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Email':
            tipoParametro = 'p.email'

        parametro = self.winPrincipal.txtFilterCliente_t.text()

        self.conexionTransacciones.selectClientes(tipoParametro, parametro)
예제 #21
0
 def __init__(self):
     self.conexion = Conexion()
     self.cliente = Cliente()
     self.proveedor = Proveedor()
예제 #22
0
class PestaniaTransacciones():
    def __init__(self, winPrincipal):
        self.conexionTransacciones = ConexionTransacciones()
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.proveedor = Proveedor()
        self.producto = Producto()
        self.tipoTransaccion = "VENTA"
        self.configInit()

    def configInit(self):

        self.winPrincipal.rbVenta_t.clicked.connect(self.onClickVenta)
        self.winPrincipal.rbCompra_t.clicked.connect(self.onClickCompra)

        self.winPrincipal.btnSumarProducto_t.clicked.connect(
            self.agregarTransaccion)
        self.winPrincipal.btnRestarProducto_t.clicked.connect(
            self.restarTransaccion)

        self.winPrincipal.btnAceptar_t.clicked.connect(self.onClickAceptar)
        self.winPrincipal.btnCancelar_t.clicked.connect(self.onClickCancelar)

        self.winPrincipal.tvClientes_t.setSortingEnabled(True)
        self.winPrincipal.tvClientes_t.setMouseTracking(True)
        self.winPrincipal.tvClientes_t.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.winPrincipal.tvProductos_t.setSortingEnabled(True)
        self.winPrincipal.tvProductos_t.setMouseTracking(True)
        self.winPrincipal.tvProductos_t.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.winPrincipal.tvDetalleTransaccion_t.setSortingEnabled(True)
        self.winPrincipal.tvDetalleTransaccion_t.setMouseTracking(True)
        self.winPrincipal.tvDetalleTransaccion_t.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.winPrincipal.btnSumarProducto_t.setEnabled(False)
        self.winPrincipal.btnRestarProducto_t.setEnabled(False)
        self.winPrincipal.btnCancelar_t.setEnabled(False)
        self.winPrincipal.btnAceptar_t.setEnabled(False)

        self.winPrincipal.txtFilterCliente_t.setFocus(True)

        self.winPrincipal.txtFilterCliente_t.returnPressed.connect(
            self.searchPeople)
        self.winPrincipal.txtFilterProducto_t.returnPressed.connect(
            self.searchProduct)

    def finish(self):
        self.winPrincipal.btnAceptar_t.disconnect()
        self.winPrincipal.btnCancelar_t.disconnect()
        self.winPrincipal.btnRestarProducto_t.disconnect()
        self.winPrincipal.btnSumarProducto_t.disconnect()
        self.winPrincipal.rbVenta_t.disconnect()
        self.winPrincipal.rbCompra_t.disconnect()

    def searchProduct(self):

        if self.winPrincipal.txtFilterProducto_t.hasFocus() is True:
            self.cargarTablaProductos()

    def searchPeople(self):
        if self.winPrincipal.txtFilterCliente_t.hasFocus() is True:
            if self.winPrincipal.rbCompra_t.isChecked() is True:
                self.cargarTablaProveedores()
            else:
                self.cargarTablaClientes()

    def onClickAceptar(self):

        listTransaccion = list(
            self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()
        subNom = ""
        estado = 0
        if self.winPrincipal.cbEstado_t.isChecked() is True:
            estado = 1
        numRecibo = 0

        if self.tipoTransaccion == "VENTA":
            numRecibo = self.conexionTransacciones.cargarTransaccionVenta(
                listTransaccion, self.cliente, estado)
            subNom = 'VNT'
        elif self.tipoTransaccion == "COMPRA":
            numRecibo = self.conexionTransacciones.cargarTransaccionCompra(
                listTransaccion, self.proveedor, estado)
            subNom = 'CMP'

        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje",
                                       "¿ Desea generar Recibo ?",
                                       QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.createFactura(listTransaccion, subNom, numRecibo)

        self.limpiarCampos()

    def createFactura(self, listTransaccion, subNom, idRecibo):
        hoy = str(datetime.datetime.now().year) + str(
            datetime.datetime.now().month) + str(
                datetime.datetime.now().day) + str(
                    datetime.datetime.now().hour) + str(
                        datetime.datetime.now().minute) + str(
                            datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + subNom) + '.pdf'
        listTransaccionTable = ""
        for transaccion in listTransaccion:
            listTransaccionTable += """
                                        <tr height="80">
                                            <td width="10%" align="center" >
                                            <br>""" + str(
                transaccion[1]) + """<br>
                                            </td>
                                            <td width="20%" >
                                                <br> &nbsp;&nbsp;""" + str(
                    transaccion[3]) + """<br>
                                            </td>
                                            <td width="50%" >
                                               <br>&nbsp;&nbsp; """ + str(
                        transaccion[4]) + """<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str(
                            transaccion[5]) + """&nbsp;&nbsp;<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str(
                                int(transaccion[1]) *
                                float(transaccion[5])) + """&nbsp;&nbsp;<br>
                                            </td>
                                        </tr>
                                   """
        nombre = ""
        apellido = ""

        if (self.tipoTransaccion == "VENTA"):
            nombre = self.cliente.getNombre()
            apellido = self.cliente.getApellido()
        elif (self.tipoTransaccion == "COMPRA"):
            nombre = self.proveedor.getNombre()
            apellido = self.proveedor.getDescripcion()

        total = self.winPrincipal.lblTotal.text()
        fecha = str(datetime.datetime.now())
        html = """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">
                               Perfumeria La que vende perfumes <br>
                               LABOULAYE, CORDOBA, ARGENTINA <br>
                               TEL: 0351-111111  <br>
                               MAIL: [email protected]  <br>
                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>
                _______________________________________________________________________________________________________
                    <p>
                        DATOS DEL CLIENTE:
                    </p>
                    <br>
                    <table>

                        <tr>
                            <td>
                                NOMBRE:   """ + nombre + """  <br>
                                APELLIDO: """ + apellido + """ <br>

                            </td>
                            <td>
                            </td>
                        </tr>
                    </table>

                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <p>
                        DETALLES DE LA COMPRA:
                    </p>
                    <br>
                    <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                      <tr  style=" background-color: gray; border-style: inset;">
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            CANT
                            </b>
                        </td>
                        <td width="20%"  align="center" valign="middle">
                            <b>
                                PRODUCTO
                            </b>
                        </td>
                        <td width="50%"  align="center" valign="middle">
                            <b>
                            DESCRIPCION
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>UNIT
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>TOT
                            </b>
                        </td>
                      </tr>
                  </table>

                  <br>
                  <br>
                  <br>
                  <br>

                  <table  height="350" width="600" style="border-color: gray; border-width: .4px; border-collapse: collapse;">
                      """ + listTransaccionTable + """
                  </table>
                    <br>
                    <br>
                    <table width="600" border="0.5" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                        <tr >
                            <td width="90%" align="right">
                                <br>
                                TOTAL..................................................................................................................
                                <br>
                            </td>
                            <td width="10%" align="center">
                              <br> $ """ + total + """<br>
                            </td>
                        </tr>
                    </table>

                    <br>
                    <br>
                    <br>
                    <p width="600" align="center" style=" font-size: 10; " >
                    Por cualquier consulta, sobre este recibo, dirigirse al local que se encuentra ubicado en la calle
                    independencia 450. <br> O Comunicarse a los telefonos 03382-123123123 / 4231231
                    </p>
                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <table width="600">
                        <tr>
                            <td align="right" width="80%">
                            FECHA/HORA : """ + fecha + """
                            </td>
                            <td align="right">
                            N° : """ + str(idRecibo) + """
                            </td>
                        </tr>
                    </table>
                    _______________________________________________________________________________________________________
                """

        doc = QTextDocument()
        doc.setHtml(html)
        #doc.setDefaultStyleSheet(style)
        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)
        """
        printPdf = QPrinter()
        printPdf.setOutputFormat(QPrinter.NativeFormat)

        questionPrint = QPrintDialog(printPdf, self.winPrincipal)

        if questionPrint.exec() == QPrintDialog.accept(printPdf):
            doc.print(printPdf)


        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea generar factura ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:

            #openPdf = QPrintDialog(printPdf, self.winPrincipal)
            #openPdf.setWindowTitle("Recibo")
        """

    def limpiarCampos(self):
        self.winPrincipal.tvClientes_t.setModel(None)
        self.winPrincipal.tvDetalleTransaccion_t.setModel(None)
        self.winPrincipal.tvProductos_t.setModel(None)
        self.winPrincipal.lblTotal.setText('0.00')
        self.winPrincipal.sbCantidadProducto_t.setValue(0)
        self.winPrincipal.rbCompra_t.setEnabled(True)
        self.winPrincipal.rbVenta_t.setEnabled(True)

        self.winPrincipal.txtFilterCliente_t.setText('')
        self.winPrincipal.txtFilterProducto_t.setText('')

        self.winPrincipal.btnAceptar_t.setEnabled(False)
        self.winPrincipal.btnCancelar_t.setEnabled(False)

        self.winPrincipal.txtFilterCliente_t.setFocus(True)

    def onClickCancelar(self):
        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje",
                                       "¿ Desea cancelar la transaccion ?",
                                       QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.limpiarCampos()

    def cargarTablaClientes(self):
        parameter = self.winPrincipal.txtFilterCliente_t.text()

        typeParameter = ''
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            typeParameter = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'

        listaClientes = self.conexionTransacciones.selectClientes(
            typeParameter, parameter)
        if len(listaClientes) > 0:
            header = ['ID', 'Apellido', 'Nombre', 'Email']
            tablaModel = MyTableModel(self.winPrincipal.tvClientes_t,
                                      listaClientes, header)
            #tablaModel.setHeaderData(3, QtCore.Qt.Horizontal , 'Email', QtCore.Qt.AlignRight)
            #index = QModelIndex()
            #index.data(2)
            #index.column()
            #tablaModel.setData(index, QtCore.QVariant(QtCore.Qt.AlignHCenter), QtCore.Qt.TextAlignmentRole)
            self.winPrincipal.tvClientes_t.setModel(tablaModel)
            self.winPrincipal.tvClientes_t.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)
            #self.winPrincipal.tvClientes_t.model().headerData(2, QtCore.Qt.Horizontal, QtCore.Qt.AlignRight)
            self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
            self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)

        else:
            self.winPrincipal.tvClientes_t.setModel(None)

    def cargarTablaProveedores(self):

        parameter = self.winPrincipal.txtFilterCliente_t.text()

        typeParameter = ''
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            typeParameter = 'prov.descripcion'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'

        listProveedores = self.conexionTransacciones.selectProveedores(
            typeParameter, parameter)
        if len(listProveedores) > 0:
            header = ['ID', 'Descripcion', 'Nombre', 'Email']
            tableModel = MyTableModel(self.winPrincipal.tvClientes_t,
                                      listProveedores, header)
            self.winPrincipal.tvClientes_t.setModel(tableModel)
            self.winPrincipal.tvClientes_t.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
            self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)
        else:
            self.winPrincipal.tvClientes_t.setModel(None)

    def changeSelectedTable(self, selected, deselected):

        listPersonas = selected.model().mylist
        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        self.personaSelectedRow = selected.row()

        if (self.tipoTransaccion == "VENTA"):
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif (self.tipoTransaccion == "COMPRA"):
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))

        self.activateButton()

    def cargarTablaProductos(self):

        parameter = self.winPrincipal.txtFilterProducto_t.text()
        typeParameter = ''
        if self.winPrincipal.cbFilterProducto_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'
        elif self.winPrincipal.cbFilterProducto_t.currentText() == 'Marca':
            typeParameter = 'm.descripcion'
        elif self.winPrincipal.cbFilterProducto_t.currentText(
        ) == 'Precio de Venta':
            typeParameter = 'p.pVenta'
        else:
            typeParameter = 'p.pCompra'

        parameterTransaccion = 'CMP'
        if self.tipoTransaccion == "VENTA":
            parameterTransaccion = 'VNT'

        listProducto = self.conexionTransacciones.selectProductos(
            typeParameter, parameter, parameterTransaccion)

        if len(listProducto) > 0:
            header = [
                'ID', 'Nombre', 'Descripcion', 'Cant', 'P.Compra', 'P.Venta',
                'Marca'
            ]

            tableModel = MyTableModel(self.winPrincipal.tvProductos_t,
                                      listProducto, header)
            self.winPrincipal.tvProductos_t.setModel(tableModel)
            self.winPrincipal.tvProductos_t.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableProducto)

            self.winPrincipal.tvProductos_t.setColumnHidden(0, True)
            self.winPrincipal.tvProductos_t.setColumnWidth(1, 150)
            self.winPrincipal.tvProductos_t.setColumnWidth(2, 200)
            self.winPrincipal.tvProductos_t.setColumnWidth(3, 50)
            self.winPrincipal.tvProductos_t.setColumnWidth(4, 80)
            self.winPrincipal.tvProductos_t.setColumnWidth(5, 80)
            self.winPrincipal.tvProductos_t.setColumnWidth(6, 100)

        else:
            self.winPrincipal.tvProductos_t.setModel(None)

    def changeSelectedTableProducto(self, selected, deselected):
        listProductos = selected.model().mylist
        productoSelected = ()
        productoSelected = tuple(listProductos[selected.row()])

        self.productoSelected = selected.row()

        self.producto = Producto()
        self.producto.setIdProducto(int(productoSelected[0]))
        self.producto.setNombre(str(productoSelected[1]))
        self.producto.setDescripcion(str(productoSelected[2]))
        self.producto.setCantidad(int(productoSelected[3]))
        self.producto.setPrecioCompra(float(productoSelected[4]))
        self.producto.setPrecioVenta(float(productoSelected[5]))

        self.winPrincipal.btnSumarProducto_t.setEnabled(True)

    def agregarTransaccion(self):
        cantProducto = int(self.winPrincipal.sbCantidadProducto_t.value())

        stateProduct = True

        if self.tipoTransaccion == "VENTA" and cantProducto > self.producto.getCantidad(
        ):
            stateProduct = False

        if cantProducto == 0:
            stateProduct = False

        if stateProduct is True:  #and self.validateProduct() is True:
            modelListTransaccion = self.winPrincipal.tvDetalleTransaccion_t.model(
            )
            header = [
                'ID', 'Cantidad', 'idProducto', 'Producto', 'Descripcion',
                'Precio Unit', 'Precio Tot'
            ]

            precio_unitario = 0
            if (self.tipoTransaccion == "VENTA"):
                precio_unitario = float(self.producto.getPrecioVenta())

            elif (self.tipoTransaccion == "COMPRA"):
                precio_unitario = float(self.producto.getPrecioCompra())

            if modelListTransaccion is not None:
                listTabPro = list(
                    self.winPrincipal.tvDetalleTransaccion_t.model().mylist)

                if len(listTabPro) > 0 or listTabPro is not None:
                    tuplaProd = ('0', str(cantProducto),
                                 str(self.producto.getIdProducto()),
                                 str(self.producto.getNombre()),
                                 str(self.producto.getDescripcion()),
                                 str(precio_unitario),
                                 str(cantProducto * precio_unitario))

                    listTabPro.append(tuplaProd)
                    tupleTable = tuple(listTabPro)

                    tableModel = MyTableModel(self.winPrincipal, tupleTable,
                                              header)
                    self.winPrincipal.tvDetalleTransaccion_t.setModel(
                        tableModel)
            else:
                lista = []
                tuplaProd = ('0', str(cantProducto),
                             str(self.producto.getIdProducto()),
                             str(self.producto.getNombre()),
                             str(self.producto.getDescripcion()),
                             str(precio_unitario),
                             str(cantProducto * precio_unitario))
                lista.append(tuplaProd)

                tableModel = MyTableModel(self.winPrincipal, lista, header)
                self.winPrincipal.tvDetalleTransaccion_t.setModel(tableModel)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(
                    0, True)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(1, 80)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(
                    2, True)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(3, 200)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(4, 653)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(5, 80)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(6, 80)

                self.winPrincipal.rbCompra_t.setEnabled(False)
                self.winPrincipal.rbVenta_t.setEnabled(False)

            #self.total = (cantProducto * self.producto.getPrecioVenta()) + self.total

            #self.winPrincipal.lblTotal.setText(str(self.total))

            self.winPrincipal.btnCancelar_t.setEnabled(True)
            self.winPrincipal.btnSumarProducto_t.setEnabled(False)

            self.winPrincipal.sbCantidadProducto_t.setValue(0)

            self.winPrincipal.tvDetalleTransaccion_t.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTransaccion)

            total = float(self.winPrincipal.lblTotal.text())
            total += +(cantProducto * precio_unitario)
            self.winPrincipal.lblTotal.setText("{0:.2f}".format(total))
            self.activateButton()
            #self.calcularTotal()
        else:
            alert = QDialog()
            QMessageBox.information(alert, "ERROR",
                                    "La cantidad especificada es invalida")

    def activateButton(self):
        hasP = False
        if self.proveedor.getIdProveedor() != 0 or self.cliente.getIdCliente(
        ) != 0:
            hasP = True
        if self.winPrincipal.tvDetalleTransaccion_t.model(
        ) is not None and hasP is True:
            self.winPrincipal.btnAceptar_t.setEnabled(True)

    def validateProduct(self):
        validate = True

        if self.winPrincipal.tvDetalleTransaccion_t.model() is not None:
            listTransacciones = list(self.winPrincipal.tvDetalleTransaccion_t.
                                     model().mylist).copy()
            header = ('ID', 'Cantidad', 'idProducto', 'Producto',
                      'Descripcion', 'Precio Unit', 'Precio Tot')
            listTransacciones.append(header)

            #cant = int(len(list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()))
            tuple = ("", listTransacciones[0][1], listTransacciones[0][2],
                     listTransacciones[0][3], listTransacciones[0][4],
                     listTransacciones[0][5], listTransacciones[0][6])
            listTransacciones[0] = tuple
            for transaccion in listTransacciones:
                if str(transaccion[2]) == str(self.producto.getIdProducto()):
                    validate = False
            """
            for i in range(cant):

                if listTransacciones[i][2] == str(self.producto.getIdProducto()):
                    validate = False
"""

        return validate

    def restarTransaccion(self):

        listTransacciones = list(
            self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()

        header = [
            'ID', 'Cantidad', 'idProducto', 'Producto', 'Descripcion',
            'Precio Unit', 'Precio Tot'
        ]

        listTransacciones.remove(self.transaccionSelected)

        if len(listTransacciones) < 1:
            self.winPrincipal.btnAceptar_t.setEnabled(False)
            self.winPrincipal.btnCancelar_t.setEnabled(False)
            self.winPrincipal.tvDetalleTransaccion_t.setModel(None)
        else:
            tableTelModel = MyTableModel(self.winPrincipal, listTransacciones,
                                         header)
            self.winPrincipal.tvDetalleTransaccion_t.setModel(tableTelModel)
            self.winPrincipal.tvDetalleTransaccion_t.selectionModel(
            ).currentChanged.connect(self.changeSelectedTableTransaccion)

        total = float(self.winPrincipal.lblTotal.text())
        total -= float(self.transaccionSelected[6])
        self.winPrincipal.lblTotal.setText("{0:.2f}".format(total))

        self.winPrincipal.btnRestarProducto_t.setEnabled(False)
        #self.calcularTotal()

    def changeSelectedTableTransaccion(self, selected, deselected):
        listTransacciones = selected.model().mylist
        self.transaccionSelected = ()
        self.transaccionSelected = listTransacciones[selected.row()]

        self.telefonoSelectedRow = selected.row()

        self.winPrincipal.btnRestarProducto_t.setEnabled(True)

    def onClickVenta(self):
        self.winPrincipal.label2_t.setText('Cliente')
        self.tipoTransaccion = "VENTA"
        self.limpiarCampos()

    def onClickCompra(self):
        self.winPrincipal.label2_t.setText('Proovedor')
        self.tipoTransaccion = "COMPRA"
        self.limpiarCampos()

    def selecClientes(self):
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Email':
            tipoParametro = 'p.email'

        parametro = self.winPrincipal.txtFilterCliente_t.text()

        self.conexionTransacciones.selectClientes(tipoParametro, parametro)

    def calcularTotal(self):
        listTransacciones = []
        listTransacciones = list(
            self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()

        tupleParche = listTransacciones[0]
        tupleParche = ('1', tupleParche[1], tupleParche[2], tupleParche[3],
                       tupleParche[4], tupleParche[5], tupleParche[6])
        listTransacciones[0] = tupleParche
        if len(listTransacciones) > 0:
            total = 0

            for transaccion in listTransacciones:

                total = total + float(transaccion[6])

            self.winPrincipal.lblTotal.setText(str(total))
        else:
            self.winPrincipal.lblTotal.setText('0,00')
 def __init__(self):
     self.conexion = Conexion()
     self.producto = Producto()
     self.proveedor = Proveedor()
     self.rubro = Rubro()
     self.marca = Marca()
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)
예제 #25
0
class PestaniaPagos():
    def __init__(self, winPrincipal):
        self.conexionPagos = ConexionPagos()
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.proveedor = Proveedor()
        self.state = 'COBRANZA'

        self.configInit()

    def configInit(self):
        self.winPrincipal.tvCuentaCorriente_pag.setSortingEnabled(True)
        self.winPrincipal.tvCuentaCorriente_pag.setMouseTracking(True)
        self.winPrincipal.tvCuentaCorriente_pag.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        self.winPrincipal.btnAceptar_pag.clicked.connect(self.OnClickAceptar)
        self.winPrincipal.btnCancelar_pag.clicked.connect(self.OnClickCancelar)

        #self.winPrincipal.txtFilterPagos_pag.textChanged.connect(self.cargarTablaCliente)
        self.winPrincipal.txtFilterPagos_pag.returnPressed.connect(self.search)

        self.winPrincipal.txtMonto_pag.textChanged.connect(self.activateField)

        self.winPrincipal.rbCobranza_pag.clicked.connect(self.OnClickCobranza)
        self.winPrincipal.rbPago_pag.clicked.connect(self.OnClickPago)

    def cargarTablaCliente(self):
        tipoParametro = ''
        if self.winPrincipal.cbFilterCliente_pag.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_pag.currentText() == 'Nombre':
            tipoParametro = 'p.nombre'

        parametro = self.winPrincipal.txtFilterPagos_pag.text()

        listaClientes = self.conexionPagos.selectClientes(
            tipoParametro, parametro)
        if len(listaClientes) > 0:
            header = ['ID', 'Apellido', 'Nombre', 'Email']
            tablaModel = MyTableModel(self.winPrincipal.tvCuentaCorriente_pag,
                                      listaClientes, header)
            self.winPrincipal.tvCuentaCorriente_pag.setModel(tablaModel)
            self.winPrincipal.tvCuentaCorriente_pag.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvCuentaCorriente_pag.setColumnHidden(0, True)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(1, 140)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(2, 140)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(3, 207)
        else:
            self.winPrincipal.tvCuentaCorriente_pag.setModel(None)

    def changeSelectedTable(self, selected, deselected):
        listPersonas = selected.model().mylist

        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        if self.state == "COBRANZA":
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif self.state == "PAGO":
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))

        self.calcularTransaccion()

    def calcularTransaccion(self):
        listTransacciones = []

        listPagos = []
        #Total de los pagos
        pagosTotal = 0
        #Total de las transacciones en estado 0
        transaccionesTotal = 0

        #Lista completa (transacciones + pagos)
        listDetalle = []
        if self.state == "COBRANZA":
            listPagos = self.conexionPagos.selectListPagosCliente(self.cliente)
            listTransacciones = self.conexionPagos.selectListTransaccionCliente(
                self.cliente)

            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(
                        transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto,
                                      str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0

            total = pagosTotal - transaccionesTotal

        elif self.state == "PAGO":
            listPagos = self.conexionPagos.selectListPagosProveedor(
                self.proveedor)
            listTransacciones = self.conexionPagos.selectListTransaccionProveedor(
                self.proveedor)

            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(
                        transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto,
                                      str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0

            total = pagosTotal - transaccionesTotal

        self.winPrincipal.lblTotalDeuda_pag.setText(str(total))

        if len(listDetalle) > 0:
            header = ['Fecha', 'Monto', 'Tipo de movimiento']
            tablaModel = MyTableModel(
                self.winPrincipal.tvDetalleTransaccion_pag, listDetalle,
                header)
            self.winPrincipal.tvDetalleTransaccion_pag.setModel(tablaModel)

            self.winPrincipal.tvDetalleTransaccion_pag.setColumnWidth(0, 190)
            self.winPrincipal.tvDetalleTransaccion_pag.setColumnWidth(1, 190)
            self.winPrincipal.tvDetalleTransaccion_pag.setColumnWidth(2, 190)

    def cargarTablaProveedor(self):

        tipoParametro = ''

        if self.winPrincipal.cbFilterCliente_pag.currentText() == 'Apellido':
            tipoParametro = 'prov.descripcion'
        elif self.winPrincipal.cbFilterCliente_pag.currentText() == 'Nombre':
            tipoParametro = 'p.nombre'

        parametro = self.winPrincipal.txtFilterPagos_pag.text()

        listaClientes = self.conexionPagos.selectProveedores(
            tipoParametro, parametro)
        if len(listaClientes) > 0:
            header = ['ID', 'Descripcion', 'Nombre', 'Email']
            tablaModel = MyTableModel(self.winPrincipal.tvCuentaCorriente_pag,
                                      listaClientes, header)
            self.winPrincipal.tvCuentaCorriente_pag.setModel(tablaModel)
            self.winPrincipal.tvCuentaCorriente_pag.selectionModel(
            ).currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvCuentaCorriente_pag.setColumnHidden(0, True)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(1, 140)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(2, 140)
            self.winPrincipal.tvCuentaCorriente_pag.setColumnWidth(3, 207)
        else:
            self.winPrincipal.tvCuentaCorriente_pag.setModel(None)

    def OnClickAceptar(self):
        total = float(self.winPrincipal.txtMonto_pag.text())
        subNom = ''
        idRecibo = 0
        if self.state == 'COBRANZA':
            idRecibo = self.conexionPagos.cargarCobranza(self.cliente, total)
            subNom = 'COBRANZA'
        elif self.state == 'PAGO':
            idRecibo = self.conexionPagos.cargarPago(self.proveedor, total)
            subNom = 'PAGO'

        totalDeuda = float(self.winPrincipal.lblTotalDeuda_pag.text())

        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje",
                                       "¿ Desea generar Recibo ?",
                                       QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.createRecibo(subNom=subNom,
                              idRecibo=idRecibo,
                              total=total,
                              totDeuda=totalDeuda,
                              totPago=total)
        self.limpiarCampos()
        self.winPrincipal.txtFilterPagos_pag.setFocus(True)

    def OnClickCancelar(self):
        self.limpiarCampos()

    def OnClickCobranza(self):
        self.state = 'COBRANZA'

    def OnClickPago(self):
        self.state = 'PAGO'

    def limpiarCampos(self):
        self.winPrincipal.txtMonto_pag.setText('')
        self.winPrincipal.txtFilterPagos_pag.setText('')
        self.winPrincipal.txtFilterPagos_pag.setEnabled(True)
        self.winPrincipal.tvCuentaCorriente_pag.setEnabled(True)
        self.winPrincipal.tvCuentaCorriente_pag.setModel(None)
        self.winPrincipal.btnAceptar_pag.setEnabled(False)
        self.winPrincipal.btnCancelar_pag.setEnabled(False)
        self.winPrincipal.lblTotalDeuda_pag.setText('0.00')

        self.winPrincipal.tvDetalleTransaccion_pag.setModel(None)

    def finish(self):
        #self.winPrincipal.txtFilterPagos_pag.disconnect()
        #self.winPrincipal.txtMonto_pag.disconnect()
        self.winPrincipal.btnAceptar_pag.disconnect()
        self.winPrincipal.btnCancelar_pag.disconnect()
        self.winPrincipal.rbPago_pag.disconnect()
        self.winPrincipal.rbCobranza_pag.disconnect()

    def activateField(self):
        if self.winPrincipal.btnAceptar_pag.isEnabled() is False:
            self.winPrincipal.txtFilterPagos_pag.setEnabled(False)
            self.winPrincipal.tvCuentaCorriente_pag.setEnabled(False)
            self.winPrincipal.btnAceptar_pag.setEnabled(True)
            self.winPrincipal.btnCancelar_pag.setEnabled(True)

    def search(self):
        if self.winPrincipal.txtFilterPagos_pag.hasFocus() is True:
            if self.state == "COBRANZA":
                #if self.winPrincipal.rbCobranza_pag.isChecked() is True:
                self.cargarTablaCliente()
            else:
                self.cargarTablaProveedor()

    def createRecibo(self, subNom, idRecibo, total, totDeuda, totPago):
        hoy = str(datetime.datetime.now().year) + str(
            datetime.datetime.now().month) + str(
                datetime.datetime.now().day) + str(
                    datetime.datetime.now().hour) + str(
                        datetime.datetime.now().minute) + str(
                            datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + subNom) + '.pdf'
        listTransaccionTable = ""

        nombre = ""
        apellido = ""

        if (self.state == "COBRANZA"):
            nombre = self.cliente.getNombre()
            apellido = self.cliente.getApellido()
        elif (self.state == "PAGO"):
            nombre = self.proveedor.getNombre()
            apellido = self.proveedor.getDescripcion()

        totalDeuda = float(totDeuda)
        deudaString = "$  " + "{0:.2f}".format(totalDeuda)
        totalPago = float(totPago)
        pagoString = "$  +" + "{0:.2f}".format(totalPago)

        total = float(totalDeuda + totalPago)
        totalString = "{0:.2f}".format(total)
        fecha = str(datetime.datetime.now())
        html = """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">
                               Perfumeria La que vende perfumes <br>
                               LABOULAYE, CORDOBA, ARGENTINA <br>
                               TEL: 0351-111111  <br>
                               MAIL: [email protected]  <br>
                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>
                _______________________________________________________________________________________________________
                    <p>
                        DATOS DEL CLIENTE:
                    </p>
                    <br>
                    <table>

                        <tr>
                            <td>
                                NOMBRE:   """ + nombre + """  <br>
                                APELLIDO: """ + apellido + """ <br>

                            </td>
                            <td>
                            </td>
                        </tr>
                    </table>

                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <p>
                        DETALLES DEL RECIBO:
                    </p>
                    <br>
                    <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                      <tr  style=" background-color: gray; border-style: inset;">
                        <td width="80%"  align="center" valign="middle">
                            <b>
                            DESCRIPCION
                            </b>
                        </td>
                        <td width="20%"  align="center" valign="middle">
                            <b>
                                MONTO
                            </b>
                        </td>

                      </tr>
                  </table>

                  <br>
                  <br>
                  <br>
                  <br>

                  <table  height="350" width="600" style="border-color: gray; border-width: .4px; border-collapse: collapse;">
                      <tr height="80">
                            <td width="80%" align="left" >
                            <br>DEUDA <br>
                            </td>
                            <td width="20%" >
                                <br> &nbsp;&nbsp; """ + str(
            deudaString) + """<br>
                            </td>

                        </tr>
                        <tr height="80">
                            <td width="80%" align="left" >
                            <br> PAGO<br>
                            </td>
                            <td width="20%" >
                                <br> &nbsp;&nbsp;""" + str(
                pagoString) + """<br>
                            </td>

                        </tr>
                  </table>
                    <br>
                    <br>
                    <table width="600" border="0.5" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                        <tr >
                            <td width="90%" align="right">
                                <br>
                                TOTAL..................................................................................................................
                                <br>
                            </td>
                            <td width="10%" align="center">
                              <br> $ """ + str(totalString) + """<br>
                            </td>
                        </tr>
                    </table>

                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    <p width="600" align="center" style=" font-size: 10; " >
                    Por cualquier consulta, sobre este recibo, dirigirse al local que se encuentra ubicado en la calle
                    independencia 450. <br> O Comunicarse a los telefonos 03382-123123123 / 4231231
                    </p>
                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <table width="600">
                        <tr>
                            <td align="right" width="80%">
                            FECHA/HORA : """ + fecha + """
                            </td>
                            <td align="right">
                            N° : """ + str(idRecibo) + """
                            </td>
                        </tr>
                    </table>
                    _______________________________________________________________________________________________________
                """

        doc = QTextDocument()
        doc.setHtml(html)
        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)
예제 #26
0
class PestaniaProducto():

    def __init__(self, winPrincipal):
        self.winPrincipal = winPrincipal
        self.producto = Producto()
        self.proveedor = Proveedor()
        self.marca = Marca()
        self.rubro = Rubro()
        self.estado = ""
        self.conexionProducto = conexionProducto()

        self.configInit()



    def configInit(self):
        #Configurando botones
        self.winPrincipal.btnAgregar_p.clicked.connect(self.onClickAgregar_p)
        self.winPrincipal.btnGuardar_p.clicked.connect(self.onClickGuardar_p)
        self.winPrincipal.btnBorrar_p.clicked.connect(self.onClickBorrar_p)
        self.winPrincipal.btnModificar_p.clicked.connect(self.onClickModificar_p)

        self.winPrincipal.btnRubro_p.clicked.connect(windowRubro)
        self.winPrincipal.btnMarca_p.clicked.connect(windowMarca)

        self.cargarTabla()
        self.winPrincipal.tvProductos_p.setMouseTracking(True)
        self.winPrincipal.tvProductos_p.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.setCompleterMarca()
        self.setCompleterRubro()
        self.setCompleterProveedor()




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

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

        if validar != "":
            print(validar)
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", validar)
        else:
            self.producto.setDescripcion(str(self.winPrincipal.txtDescripcion_p.toPlainText()))
            self.producto.setCantidad(int(self.winPrincipal.sbCantidad_p.value()))
            self.producto.setCantidadMinima(int(self.winPrincipal.sbCantidadMin_p.value()))
            if self.winPrincipal.cbEstado_p.currentText() == "ACTIVO":
                self.producto.setEstado(1)
            else:
                self.producto.setEstado(0)

            if self.winPrincipal.rbFemenino_p.isChecked() is True:
                self.producto.setGenero("F")
            else:
                self.producto.setGenero("M")

            self.producto.setNombre(str(self.winPrincipal.txtNombre_p.text()))
            self.producto.setPrecioCompra(float(self.winPrincipal.txtPrecioCompra_p.text()))
            self.producto.setPrecioVenta(float(self.winPrincipal.txtPrecioVenta_p.text()))

            self.rubro.setRubro(str(self.completerRubro.currentCompletion()))
            self.producto.setRubro(self.rubro)

            self.proveedor.setDescripcion(str(self.completerProveedor.currentCompletion()))
            self.producto.setProveedor(self.proveedor)

            self.marca.setMarca(str(self.completerMarca.currentCompletion()))
            self.producto.setMarca(self.marca)

            if self.estado == 'AGREGAR':
                self.insertarProducto()
            elif self.estado == 'MODIFICAR':
                self.modificarProducto()

            self.validarBotones('GUARDAR')


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

    def onClickBorrar_p(self):
        if self.winPrincipal.btnGuardar_p.isEnabled() != True:
            self.conexionProducto.borrarProducto(self.producto)
            self.cargarTabla()

        self.validarBotones(button='BORRAR')

    def cargarTabla(self):
        listaProductos = self.conexionProducto.selectProducto()

        if len(listaProductos) > 0:

            header = ['idPro','Nombre', 'Descripcion', 'PC', 'PV', 'G', 'Estado', 'Cant', 'Cantidad Min',
                      'idMar', 'Marca', 'idRubro', 'Rubro', 'idProv', 'Proveedor']
            self.tablaModel = MyTableModel(self.winPrincipal.tvProductos_p, listaProductos, header)
            self.winPrincipal.tvProductos_p.setModel(self.tablaModel)
            self.winPrincipal.tvProductos_p.selectionModel().currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvProductos_p.setColumnHidden(0, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(1, 200)
            self.winPrincipal.tvProductos_p.setColumnWidth(2, 320)
            self.winPrincipal.tvProductos_p.setColumnWidth(3, 60)
            self.winPrincipal.tvProductos_p.setColumnWidth(4, 60)
            self.winPrincipal.tvProductos_p.setColumnWidth(5, 60)
            self.winPrincipal.tvProductos_p.setColumnHidden(6, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(7, 40)
            self.winPrincipal.tvProductos_p.setColumnHidden(8, True)
            self.winPrincipal.tvProductos_p.setColumnHidden(9, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(10, 130)
            self.winPrincipal.tvProductos_p.setColumnHidden(11, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(12, 130)
            self.winPrincipal.tvProductos_p.setColumnHidden(13, True)
            self.winPrincipal.tvProductos_p.setColumnWidth(14, 130)



    def changeSelectedTable(self, selected, deselected):

        productoList = selected.model().mylist
        productoSelected = productoList[selected.row()]
        self.producto = Producto()
        self.rubro = Rubro()
        self.proveedor = Proveedor()
        self.marca = Marca()

        self.producto.setIdProducto(productoSelected[0])
        self.producto.setNombre(productoSelected[1])
        self.producto.setDescripcion(productoSelected[2])
        self.producto.setPrecioCompra(productoSelected[3])
        self.producto.setPrecioVenta(productoSelected[4])
        self.producto.setGenero(productoSelected[5])
        self.producto.setEstado(productoSelected[6])
        self.producto.setCantidad(productoSelected[7])
        self.producto.setCantidadMinima(productoSelected[8])

        self.marca.setIdMarca(productoSelected[9])
        self.marca.setMarca(productoSelected[10])
        self.producto.setMarca(self.marca)

        self.rubro.setIdRubro(productoSelected[11])
        self.rubro.setRubro(productoSelected[12])
        self.producto.setRubro(self.rubro)

        self.proveedor.setIdProveedor(productoSelected[13])
        self.proveedor.setDescripcion(productoSelected[14])
        self.producto.setProveedor(self.proveedor)


        self.winPrincipal.tvProductos_p.setRowHeight(deselected.row(),33)
        self.winPrincipal.tvProductos_p.setRowHeight(selected.row(),45)


        self.setCampos()
        self.winPrincipal.btnModificar_p.setEnabled(True)
        self.winPrincipal.btnBorrar_p.setEnabled(True)

    def validarBotones(self, button):
        if button == 'AGREGAR' :
            self.winPrincipal.wDatosProducto.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setText('CANCELAR')
            self.winPrincipal.btnGuardar_p.setEnabled(True)
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(False)
            self.limpiarCampos()

        elif button=='GUARDAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(True)
            self.winPrincipal.btnGuardar_p.setEnabled(False)
            self.winPrincipal.btnBorrar_p.setText('BORRAR')
            self.winPrincipal.btnBorrar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(True)
            self.winPrincipal.wDatosProducto.setEnabled(False)
            self.limpiarCampos()

        elif button == 'MODIFICAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(False)
            self.winPrincipal.btnGuardar_p.setEnabled(True)
            self.winPrincipal.btnBorrar_p.setText('CANCELAR')
            self.winPrincipal.btnBorrar_p.setEnabled(True)
            self.winPrincipal.tvProductos_p.setEnabled(False)
            self.winPrincipal.wDatosProducto.setEnabled(True)

        elif button=='BORRAR':
            self.winPrincipal.btnModificar_p.setEnabled(False)
            self.winPrincipal.btnAgregar_p.setEnabled(True)
            self.winPrincipal.btnGuardar_p.setEnabled(False)
            self.winPrincipal.btnBorrar_p.setText('BORRAR')
            self.winPrincipal.btnBorrar_p.setEnabled(False)
            self.winPrincipal.tvProductos_p.setEnabled(True)
            self.winPrincipal.wDatosProducto.setEnabled(False)
            self.limpiarCampos()


    def insertarProducto(self):
        self.conexionProducto.insertarProducto(producto=self.producto)
        self.cargarTabla()

    def modificarProducto(self):
        self.conexionProducto.modificarProducto(self.producto)
        self.cargarTabla()

    def limpiarCampos(self):
        self.winPrincipal.txtNombre_p.setText('')
        self.winPrincipal.txtPrecioCompra_p.setText('')
        self.winPrincipal.txtPrecioVenta_p.setText('')
        self.winPrincipal.sbCantidad_p.setValue(0)
        self.winPrincipal.sbCantidadMin_p.setValue(0)
        self.winPrincipal.txtProveedor_p.setText('')
        self.winPrincipal.txtDescripcion_p.setText('')
        self.winPrincipal.txtRubro_p.setText('')
        self.winPrincipal.txtMarca_p.setText('')


    def setCampos(self):
        self.winPrincipal.txtNombre_p.setText(self.producto.getNombre())
        self.winPrincipal.txtDescripcion_p.setText(str(self.producto.getDescripcion()))
        self.winPrincipal.txtPrecioCompra_p.setText(str(self.producto.getPrecioCompra()))
        self.winPrincipal.txtPrecioVenta_p.setText(str(self.producto.getPrecioVenta()))
        self.winPrincipal.txtProveedor_p.setText(str(self.producto.getProveedor().getDescripcion()))

        self.winPrincipal.sbCantidad_p.setValue(int(self.producto.getCantidad()))
        self.winPrincipal.sbCantidadMin_p.setValue(int(self.producto.getCantidadMinima()))

        self.winPrincipal.txtRubro_p.setText(str(self.producto.getRubro().getRubro()))
        self.winPrincipal.txtMarca_p.setText(str(self.producto.getMarca().getMarca()))

        if self.producto.getEstado() == 1:
            self.winPrincipal.cbEstado_p.setCurrentIndex(0)
        else:
            self.winPrincipal.cbEstado_p.setCurrentIndex(1)

        if self.producto.getGenero() == 'F':
            self.winPrincipal.rbFemenino_p.setChecked(True)
        else:
            self.winPrincipal.rbMasculino_p.setChecked(True)




    def validar(self):
        mensaje=''
        if self.winPrincipal.txtNombre_p.text() == '':
            mensaje= "Falta ingresar Nombre"
        elif self.winPrincipal.txtPrecioCompra_p.text() =='':
            mensaje= "Falta ingresar Precio de Compra"
        elif self.winPrincipal.txtPrecioVenta_p.text() =='':
            mensaje= "Falta ingresar Precio de Venta"
        elif self.completerProveedor.currentCompletion() =='' or self.completerProveedor.currentRow() == 0:
            mensaje= "Falta ingresar un Proveedor"
        elif self.completerMarca.currentCompletion() == '' or self.completerMarca.currentRow() == 0:
            mensaje = "Falta seleccionar la marca"
        elif self.completerRubro.currentCompletion() == '' or self.completerRubro.currentRow() == 0:
            mensaje = 'Falta seleccionar el rubro'

        return mensaje

    def setCompleterMarca(self):
        listMarcas = self.conexionProducto.listMarcas()
        self.completerMarca = QCompleter(listMarcas)

        self.completerMarca.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.winPrincipal.txtMarca_p.setCompleter(self.completerMarca)


    def setCompleterRubro(self):
        listRubros = self.conexionProducto.listRubro()

        self.completerRubro = QCompleter(listRubros)

        self.completerRubro.setCaseSensitivity(QtCore.Qt.CaseInsensitive)

        self.winPrincipal.txtRubro_p.setCompleter(self.completerRubro)


    def setCompleterProveedor(self):
        listProveedores = self.conexionProducto.listProveedor()
        self.completerProveedor = QCompleter(listProveedores)
        pass
        self.completerProveedor.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.winPrincipal.txtProveedor_p.setCompleter(self.completerProveedor)
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)
class PestaniaEstadisticas():

    def __init__(self, winPrincipal):
        self.conexionesGenerales = ConexionGenerales()
        self.winPrincipal = winPrincipal


        hoy = datetime.datetime.now().date()
        self.winPrincipal.deHasta_stock.setDate(hoy)
        self.winPrincipal.deHasta_dinero.setDate(hoy)
        self.winPrincipal.deHasta_saldos.setDate(hoy)

        self.winPrincipal.btnGenerarPdf_dinero.clicked.connect(self.generarDinero)
        self.winPrincipal.btnGenerarPdf_stock.clicked.connect(self.generarStock)
        self.winPrincipal.btnGenerarPdf_saldos.clicked.connect(self.generarSaldos)
        self.winPrincipal.txtFilterPersona_saldos.returnPressed.connect(self.buscarPersonas)
        self.winPrincipal.rbClientes_saldos.clicked.connect(self.changePersona)
        self.winPrincipal.rbProveedores_saldos.clicked.connect(self.changePersona)

        self.winPrincipal.chbTodos_saldos.clicked.connect(self.clickTodos)

        self.winPrincipal.chbHoy_stock.clicked.connect(self.clickHoy_stock)
        self.winPrincipal.chbHoy_saldos.clicked.connect(self.clickHoy_saldos)
        self.winPrincipal.chbHoy_dinero.clicked.connect(self.clickHoy_dinero)


        self.winPrincipal.tvPersonas_saldos.setSortingEnabled(True)
        self.winPrincipal.tvPersonas_saldos.setMouseTracking(True)
        self.winPrincipal.tvPersonas_saldos.setSelectionBehavior(QAbstractItemView.SelectRows)


    def generarDinero(self):
        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_dinero.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_dinero.currentText() == 'Año':
            intervalo = 'year'
        elif self.winPrincipal.cbIntervalo_dinero.currentText() == 'Dia':
            intervalo = 'day'

        auxDesde = self.winPrincipal.deDesde_dinero.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_dinero.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listaEntradaTransacciones = self.conexionesGenerales.selectEntradasTransacciones(intervalo, desde, hasta)
        listaEntradaPagos = self.conexionesGenerales.selectEntradaPagos(intervalo, desde, hasta)

        listaSalidaTransacciones = self.conexionesGenerales.selectSalidaTransacciones(intervalo, desde, hasta)
        listaSalidaPagos = self.conexionesGenerales.selectSalidaPagos(intervalo, desde, hasta)

        listaGeneral =[]

        if len(listaEntradaPagos) < 1 and len(listaEntradaTransacciones) < 1 and len(listaSalidaPagos) < 1 and len(listaSalidaTransacciones) < 1:
            pass

        else:
            dineroEntrada = 0
            dineroSalida = 0
            for entradaP in listaEntradaPagos:
                dineroEntrada += float(entradaP[1])
                monto = '$ + ' + str("{0:.2f}".format(entradaP[1]))
                entrada = []
                entrada.append(entradaP[0])
                entrada.append(monto)
                entrada.append(entradaP[2])
                #entrada = (entradaP[0] + monto + entradaP[2] )
                listaGeneral.append(entrada)

            for entradaT in listaEntradaTransacciones:
                dineroEntrada += float(entradaT[1])
                monto = '$ + ' + str("{0:.2f}".format(entradaT[1]))
                entrada = []
                entrada.append(entradaT[0])
                entrada.append(monto)
                entrada.append(entradaT[2])
                #entrada = (entradaT[0], monto, entradaT[2])
                listaGeneral.append(entrada)

            for salidaP in listaSalidaPagos:
                dineroSalida += float(salidaP[1])
                monto = '$ - ' + str("{0:.2f}".format(salidaP[1]))
                salida = []
                salida.append(salidaP[0])
                salida.append(monto)
                salida.append(salidaP[2])
                #salida = (salidaP[0], monto, salidaP[2])
                listaGeneral.append(salida)

            for salidaT in listaSalidaTransacciones:
                dineroSalida += float(salidaT[1])
                monto = '$ - ' + str("{0:.2f}".format(salidaT[1]))
                salida = []
                salida.append(salidaT[0])
                salida.append(monto)
                salida.append(salidaT[2])
                #salida = (salidaT[0], monto, salidaT[2])
                listaGeneral.append(salida)

            listTable = ""
            listaGeneral.sort()
            for lista in listaGeneral:
                listTable += """
                                <tr height="80">
                                    <td width="60%" align="left" >
                                    <br>""" + str(lista[0])  + """<br>
                                    </td>
                                    <td width="20%" align="right">
                                        <br> &nbsp;&nbsp;""" + str(lista[1])  + """<br>
                                    </td>
                                    <td width="20%" align="center">
                                       <br>&nbsp;&nbsp; """ + str(lista[2])  + """<br>
                                    </td>
                                </tr>
                           """

            contenido = """
                             <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                              <tr  style=" background-color: gray; border-style: inset;">
                                <td width="60%"  align="center" valign="middle">
                                    <b>
                                    FECHA
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle">
                                    <b>
                                        DINERO
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle">
                                    <b>
                                        TIPO MOVIMIENTO
                                    </b>
                                </td>
                              </tr>
                          </table>
                          <br>
                          <table width="600" >
                            """+listTable +"""

                          </table>

                          <p>
                            <br>
                            Dinero entrante = $ + """ +str("{0:.2f}".format(dineroEntrada)) + """
                            <br>
                            Dinero salida = $ - """+ str("{0:.2f}".format(dineroSalida)) + """
                            <br>
                            <br>
                            Total .... : $ """+ str("{0:.2f}".format(dineroEntrada - dineroSalida)) +"""
                          </p>
                        """
            self.generatePDF(contenido)


    def generarStock(self):
        self.listFinal = []
        self.title = "intervalo"

        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_stock.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_stock.currentText() == 'Año':
            intervalo = 'year'


        auxDesde = self.winPrincipal.deDesde_stock.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_stock.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listVentas = self.conexionesGenerales.selectVentas(intervalo, desde, hasta)
        listCompras = self.conexionesGenerales.selectCompras(intervalo, desde, hasta)

        if len(listCompras) < 1 and len(listVentas) < 1:
            alert = QDialog()
            confirm = QMessageBox.question(alert, "Mensaje", "Verifique los valores, la consulta no tiene ningun dato.", QMessageBox.Ok)

        else:
            i= 0
            for ventas in listVentas:
                itemList = (str(ventas[0]), listCompras[i][1], ventas[1])
                self.listFinal.append(itemList)
                i += 1


            listTable = ""
            cantMax = 0
            tupleFecha = []
            tupleCompra = []
            tupleVenta = []
            listFechas = []
            for lista in self.listFinal:
                i = 0
                listTable += """
                                            <tr height="80">
                                                <td width="60%" align="left" >
                                                <br>""" + str(lista[0])  + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                    <br> &nbsp;&nbsp;""" + str(lista[1])  + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                   <br>&nbsp;&nbsp; """ + str(lista[2])  + """<br>
                                                </td>
                                            </tr>
                                       """
                if int(lista[1]) > int(lista[2]):
                    if int(lista[1]) > cantMax:
                        cantMax = int(lista[1])
                else:
                    if int(lista[2]) > cantMax:
                        cantMax = int(lista[2])

                listFechas.append(str(lista[0]))

                tupleFecha.append(str(lista[0])) #+= str(lista[0])
                tupleCompra.append(int(lista[1]))
                tupleVenta.append(int(lista[2]))
                i = i + 1

            generateGraphic = []
            tdFecha = ""
            trCantFechas = ""

            betweenCant = int(cantMax/12)
            listRange = []
            for i in range(0, cantMax, betweenCant):
                listRange.append(i)
                tdFecha = ""
                for lista in self.listFinal:

                    if i < int(lista[1]):
                        tdCantCompra = """
                                            <td width="50" style=" background-color: red;">
                                            </td>
                                       """
                    else:
                        tdCantCompra = """
                                            <td width="50">
                                            </td>
                                       """

                    if i < int(lista[2]):
                        tdCantVenta = """
                                            <td width="50" style=" background-color: blue;">
                                            </td>
                                      """
                    else:
                       tdCantVenta = """
                                            <td width="50">
                                            </td>
                                      """

                    tdFecha += tdCantCompra + tdCantVenta

                tr = """
                        <tr>
                            <td width="60">
                                """+ str(i) +"""
                            </td>
                            """+ str(tdFecha) +"""
                        </tr>
                     """

                generateGraphic.append(tr)


            n_groups = len(tupleFecha)

            fig, ax = pyplot.subplots()

            index = np.arange(n_groups)
            bar_width = 0.20

            opacity = 0.4
            error_config = {'ecolor': '0.3'}

            rects1 = pyplot.bar(index, tupleVenta, bar_width,
                             alpha=opacity,
                             color='b',
                             error_kw=error_config,
                             label='Venta')

            rects2 = pyplot.bar(index + bar_width, tupleCompra, bar_width,
                             alpha=opacity,
                             color='r',
                             error_kw=error_config,
                             label='Compra')

            pyplot.xlabel('Fecha')
            pyplot.ylabel('Cantidad')
            pyplot.title('Cantidad por fechas')
            pyplot.xticks(index + bar_width, tupleFecha)
            pyplot.legend()

            pyplot.tight_layout()
            pyplot.savefig('../archivos/picture1.png')

            trFechas = """<tr> <td width="60">CANT/FECHAS</td>"""
            for fecha in listFechas:
                tdFecha = """<td width="50" align="right" font-size="8"> """+ str(fecha) +"""</td> <td width="50"> </td> """
                trFechas += tdFecha

            trFechas += "</tr>"

            generateGraphic.reverse()

            generateGraphic.append(trFechas)

            finalGraphic = ""

            for graphic in generateGraphic:
                finalGraphic += graphic


            contenido = """
                         <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                              <tr  style=" background-color: gray; border-style: inset;">
                                <td width="60%"  align="center" valign="middle">
                                    <b>
                                    FECHA
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle" style=" background-color: red;">
                                    <b>
                                        PRODUCTOS COMPRADOS
                                    </b>
                                </td>
                                <td width="20%"  align="center" valign="middle" style="background-color: blue;">
                                    <b>
                                        PRODUCTOS VENDIDOS
                                    </b>
                                </td>
                              </tr>
                          </table>

                          <br>
                          <br>
                          <br>

                          <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                                """ + listTable + """
                          </table>
                            <br>
                            <br>

                            <br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>



                          <br><br><br><br><br><br><br>
                          <IMG SRC="../archivos/picture1.png" width="600" height="600">
                          <br><br><br><br><br><br><br><br><br><br>
                            <br>

                            <hr>
                            <br>
                            <table width="600">
                                <tr>
                                    <td align="right" width="100%">
                                    FECHA/HORA : """+ fecha + """
                                    </td>
                                </tr>
                            </table>
                           <hr>
                        """

            self.generatePDF(contenido)


    def clickHoy_stock(self):
        if self.winPrincipal.chbHoy_stock.isChecked() == True:
            self.winPrincipal.deHasta_stock.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_stock.setDate(hoy)
        else:
            self.winPrincipal.deHasta_stock.setEnabled(True)

    def clickHoy_saldos(self):
        if self.winPrincipal.chbHoy_saldos.isChecked() == True:
            self.winPrincipal.deHasta_saldos.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_saldos.setDate(hoy)
        else:
            self.winPrincipal.deHasta_saldos.setEnabled(True)

    def clickHoy_dinero(self):
        if self.winPrincipal.chbHoy_dinero.isChecked() == True:
            self.winPrincipal.deHasta_dinero.setEnabled(False)
            hoy = datetime.datetime.now().date()
            self.winPrincipal.deHasta_dinero.setDate(hoy)
        else:
            self.winPrincipal.deHasta_dinero.setEnabled(True)

    def generarSaldos(self):
        validate = True
        if self.winPrincipal.chbTodos_saldos.isChecked() == False:
            if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                if self.proveedores is None:
                    validate = False
            else:
                if self.clientes is None:
                    validate = False

        if validate == True:
            if self.winPrincipal.chbTodos_saldos.isChecked() == True:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    listProveedores = self.conexionesGenerales.selectProveedor('')
                    contenido = ""
                    for proveedores in listProveedores:
                        self.proveedores = Proveedor()
                        self.proveedores.setIdProveedor(int(proveedores[0]))
                        self.proveedores.setDescripcion(str(proveedores[1]))
                        self.proveedores.setNombre(str(proveedores[2]))

                        contenido += self.generateTable('PROVEEDOR', self.proveedores)
                else:
                    listClientes = self.conexionesGenerales.selectCliente('')
                    contenido = ""
                    for clientes in listClientes:
                        self.clientes = Cliente()
                        self.clientes.setIdCliente(int(clientes[0]))
                        self.clientes.setApellido(str(clientes[1]))
                        self.clientes.setNombre(str(clientes[2]))

                        contenido += self.generateTable('CLIENTE', self.clientes)
            else:
                if self.winPrincipal.rbProveedores_saldos.isChecked() == True:
                    contenido = self.generateTable('PROVEEDOR', self.proveedores)
                else:
                    contenido = self.generateTable('CLIENTE', self.clientes)


            self.generatePDF(contenido)
        else:
            alert = QDialog()
            confirm = QMessageBox.question(alert, "Mensaje", "Falta selecciona la/s persona/s.", QMessageBox.Ok)




    def generateTable(self, type, persona):

        intervalo = 'month'
        if self.winPrincipal.cbIntervalo_saldos.currentText() == 'Semana':
            intervalo = 'week'
        elif self.winPrincipal.cbIntervalo_saldos.currentText() == 'Año':
            intervalo = 'year'
        elif self.winPrincipal.cbIntervalo_saldos.currentText() == 'Dia':
            intervalo = 'day'


        auxDesde = self.winPrincipal.deDesde_saldos.text()

        desde = auxDesde[6:10] + '-' + auxDesde[3:5] + '-' + auxDesde[0:2]

        auxHasta = self.winPrincipal.deHasta_saldos.text()
        hasta = auxHasta[6:10] + '-' + auxHasta[3:5] + '-' + auxHasta[0:2]

        listTransacciones = []
        listPagos = []
        #Total de los pagos
        pagosTotal = 0
        #Total de las transacciones en estado 0
        transaccionesTotal = 0
        total = 0
        #Lista completa (transacciones + pagos)
        listDetalle = []
        apellido = ''
        if type == "CLIENTE":
            listPagos = self.conexionesGenerales.selectListPagosCliente(persona, intervalo, desde, hasta)
            listTransacciones = self.conexionesGenerales.selectListTransaccionCliente(persona, intervalo, desde, hasta)


            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto, str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0

            total = pagosTotal  - transaccionesTotal
            apellido = persona.getApellido()
        elif type == "PROVEEDOR":
            listPagos = self.conexionesGenerales.selectListPagosProveedor(persona, intervalo, desde, hasta)
            listTransacciones = self.conexionesGenerales.selectListTransaccionProveedor(persona, intervalo, desde, hasta)

            if len(listPagos) > 0:
                for pagos in listPagos:
                    pagosTotal += float(pagos[1])
                    auxMonto = "$  + " + str("{0:.2f}".format(pagos[1]))
                    auxPagos = (str(pagos[0]), auxMonto, str(pagos[2]))
                    listDetalle.append(auxPagos)
            else:
                pagosTotal = 0

            if len(listTransacciones):
                for transacciones in listTransacciones:
                    transaccionesTotal += transacciones[1]
                    auxMonto = "$  - " + str("{0:.2f}".format(transacciones[1]))
                    auxTransaccion = (str(transacciones[0]), auxMonto, str(transacciones[2]))
                    listDetalle.append(auxTransaccion)
            else:
                transaccionesTotal = 0


            total = pagosTotal - transaccionesTotal
            apellido = persona.getDescripcion()


        listDetalle.sort()
        listTable = ""
        for lista in listDetalle:
                listTable += """
                                            <tr height="80">
                                                <td width="60%" align="left" >
                                                <br>""" + str(lista[0])  + """<br>
                                                </td>
                                                <td width="20%" align="right">
                                                    <br> &nbsp;&nbsp;""" + str(lista[1])  + """<br>
                                                </td>
                                                <td width="20%" align="center">
                                                   <br>&nbsp;&nbsp; """ + str(lista[2])  + """<br>
                                                </td>
                                            </tr>
                                       """

        contenido = """
                            <br>
                            <br>
                          <table width="600" height="100">
                            <tr>
                                <br> Nombre : """+ persona.getNombre() +""" <br>
                                Apellido : """ + apellido + """<br>
                            </tr>
                          </table>
                          <table width="600"  >
                                <tr height="80" style=" background-color: gray; border-style: inset;">
                                    <td width="60%" align="center" >
                                        <br>FECHA<br>
                                        </td>
                                        <td width="20%" align="center">
                                            <br> MONTO <br>
                                        </td>
                                        <td width="20%" align="center">
                                           <br>ACCION<br>
                                        </td>
                                </tr>
                                """ + listTable + """
                          </table>

                          <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                            <tr>
                                <td width="70%"><br>SALDO..............<br></td>
                                <td><br> $ """ + str("{0:.2f}".format(total))+ """ <br></td>
                            </tr>
                          </table>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                          <br>
                            <br>
                    """

        return contenido



    def buscarPersonas(self):
         if self.winPrincipal.txtFilterPersona_saldos.hasFocus() is True:
            self.cargarTablaSaldos()



    def cargarTablaSaldos(self):

        parameter = self.winPrincipal.txtFilterPersona_saldos.text()

        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            listaProveedores = self.conexionesGenerales.selectProveedor(parameter)

            if len(listaProveedores) > 0:
                header = ['ID','Apellido','Nombre']
                self.tablaModel = MyTableModel(self.winPrincipal.tvPersonas_saldos, listaProveedores, header)
                self.winPrincipal.tvPersonas_saldos.setModel(self.tablaModel)
                self.winPrincipal.tvPersonas_saldos.selectionModel().currentChanged.connect(self.changeSelectedTable)


                self.winPrincipal.tvPersonas_saldos.setColumnHidden(0, True)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(1, 120)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(2, 120)
        else:
            listaClientes = self.conexionesGenerales.selectCliente(parameter)

            if len(listaClientes) > 0:
                header = ['ID','Apellido','Nombre']
                self.tablaModel = MyTableModel(self.winPrincipal.tvPersonas_saldos, listaClientes, header)
                self.winPrincipal.tvPersonas_saldos.setModel(self.tablaModel)
                self.winPrincipal.tvPersonas_saldos.selectionModel().currentChanged.connect(self.changeSelectedTable)


                self.winPrincipal.tvPersonas_saldos.setColumnHidden(0, True)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(1, 120)
                self.winPrincipal.tvPersonas_saldos.setColumnWidth(2, 120)



    def changeSelectedTable(self, selected, deselected):
        if self.winPrincipal.rbProveedores_saldos.isChecked() is True:
            proveedorList = selected.model().mylist
            proveedorSelected = proveedorList[selected.row()]

            self.proveedores = Proveedor()

            self.proveedores.setIdProveedor(int(proveedorSelected[0]))
            self.proveedores.setDescripcion(str(proveedorSelected[1]))
            self.proveedores.setNombre(str(proveedorSelected[2]))
        else:
            clienteList = selected.model().mylist
            clienteSelected = clienteList[selected.row()]

            self.clientes = Cliente()

            self.clientes = Cliente()
            self.clientes.setIdCliente(int(clienteSelected[0]))
            self.clientes.setApellido(str(clienteSelected[1]))
            self.clientes.setNombre(str(clienteSelected[2]))

    def changePersona(self):
        self.clientes = None
        self.proveedores = None

        self.winPrincipal.txtFilterPersona_saldos.setText('')
        self.winPrincipal.tvPersonas_saldos.setModel(None)

    def clickTodos(self):
        if self.winPrincipal.chbTodos_saldos.isChecked() == True:
            self.winPrincipal.txtFilterPersona_saldos.setEnabled(False)
            self.winPrincipal.tvPersonas_saldos.setModel(None)
        else:
            self.winPrincipal.txtFilterPersona_saldos.setEnabled(True)


    def generatePDF(self, contenido):
        hoy = str(datetime.datetime.now().year) + str(datetime.datetime.now().month) + str(datetime.datetime.now().day) + str(datetime.datetime.now().hour) + str(datetime.datetime.now().minute) + str(datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + 'LIST') + '.pdf'

        fecha = str(datetime.datetime.now())

        html =  """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">

                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>

                   <hr>
                    <br>
                    <p>
                        SALDOS
                    </p>
                    <br>

                  """+ contenido

        doc = QTextDocument()
        doc.setHtml(html)

        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)
class PestaniaTransacciones():


    def __init__(self, winPrincipal):
        self.conexionTransacciones = ConexionTransacciones()
        self.winPrincipal = winPrincipal
        self.cliente = Cliente()
        self.proveedor = Proveedor()
        self.producto = Producto()
        self.tipoTransaccion = "VENTA"
        self.configInit()





    def configInit(self):

        self.winPrincipal.rbVenta_t.clicked.connect(self.onClickVenta)
        self.winPrincipal.rbCompra_t.clicked.connect(self.onClickCompra)

        self.winPrincipal.btnSumarProducto_t.clicked.connect(self.agregarTransaccion)
        self.winPrincipal.btnRestarProducto_t.clicked.connect(self.restarTransaccion)

        self.winPrincipal.btnAceptar_t.clicked.connect(self.onClickAceptar)
        self.winPrincipal.btnCancelar_t.clicked.connect(self.onClickCancelar)


        self.winPrincipal.tvClientes_t.setSortingEnabled(True)
        self.winPrincipal.tvClientes_t.setMouseTracking(True)
        self.winPrincipal.tvClientes_t.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.tvProductos_t.setSortingEnabled(True)
        self.winPrincipal.tvProductos_t.setMouseTracking(True)
        self.winPrincipal.tvProductos_t.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.tvDetalleTransaccion_t.setSortingEnabled(True)
        self.winPrincipal.tvDetalleTransaccion_t.setMouseTracking(True)
        self.winPrincipal.tvDetalleTransaccion_t.setSelectionBehavior(QAbstractItemView.SelectRows)

        self.winPrincipal.btnSumarProducto_t.setEnabled(False)
        self.winPrincipal.btnRestarProducto_t.setEnabled(False)
        self.winPrincipal.btnCancelar_t.setEnabled(False)
        self.winPrincipal.btnAceptar_t.setEnabled(False)

        self.winPrincipal.txtFilterCliente_t.setFocus(True)

        self.winPrincipal.txtFilterCliente_t.returnPressed.connect(self.searchPeople)
        self.winPrincipal.txtFilterProducto_t.returnPressed.connect(self.searchProduct)


    def finish(self):
        self.winPrincipal.btnAceptar_t.disconnect()
        self.winPrincipal.btnCancelar_t.disconnect()
        self.winPrincipal.btnRestarProducto_t.disconnect()
        self.winPrincipal.btnSumarProducto_t.disconnect()
        self.winPrincipal.rbVenta_t.disconnect()
        self.winPrincipal.rbCompra_t.disconnect()

    def searchProduct(self):

        if self.winPrincipal.txtFilterProducto_t.hasFocus() is True:
            self.cargarTablaProductos()


    def searchPeople(self):
        if self.winPrincipal.txtFilterCliente_t.hasFocus() is True:
            if self.winPrincipal.rbCompra_t.isChecked() is True:
                self.cargarTablaProveedores()
            else:
                self.cargarTablaClientes()

    def onClickAceptar(self):

        listTransaccion = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()
        subNom = ""
        estado = 0
        if self.winPrincipal.cbEstado_t.isChecked() is True:
            estado = 1
        numRecibo = 0


        if self.tipoTransaccion == "VENTA":
            numRecibo = self.conexionTransacciones.cargarTransaccionVenta(listTransaccion, self.cliente, estado)
            subNom = 'VNT'
        elif self.tipoTransaccion == "COMPRA":
            numRecibo = self.conexionTransacciones.cargarTransaccionCompra(listTransaccion, self.proveedor, estado)
            subNom = 'CMP'

        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea generar Recibo ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.createFactura(listTransaccion, subNom, numRecibo)


        self.limpiarCampos()


    def createFactura(self, listTransaccion, subNom, idRecibo):
        hoy = str(datetime.datetime.now().year) + str(datetime.datetime.now().month) + str(datetime.datetime.now().day) + str(datetime.datetime.now().hour) + str(datetime.datetime.now().minute) + str(datetime.datetime.now().second)

        nombrePdf = '../archivos/' + str(hoy + subNom) + '.pdf'
        listTransaccionTable = ""
        for transaccion in listTransaccion:
            listTransaccionTable += """
                                        <tr height="80">
                                            <td width="10%" align="center" >
                                            <br>""" + str(transaccion[1])  + """<br>
                                            </td>
                                            <td width="20%" >
                                                <br> &nbsp;&nbsp;""" + str(transaccion[3])  + """<br>
                                            </td>
                                            <td width="50%" >
                                               <br>&nbsp;&nbsp; """ + str(transaccion[4])  + """<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str(transaccion[5])  + """&nbsp;&nbsp;<br>
                                            </td>
                                            <td width="10%" align="right" >
                                              <br>  $ """ + str( int(transaccion[1]) * float(transaccion[5]))  + """&nbsp;&nbsp;<br>
                                            </td>
                                        </tr>
                                   """
        nombre = ""
        apellido = ""

        if(self.tipoTransaccion == "VENTA"):
            nombre = self.cliente.getNombre()
            apellido = self.cliente.getApellido()
        elif(self.tipoTransaccion == "COMPRA"):
            nombre = self.proveedor.getNombre()
            apellido = self.proveedor.getDescripcion()


        total = self.winPrincipal.lblTotal.text()
        fecha = str(datetime.datetime.now())
        html =  """
                     <table width="600">
                        <tr width="600" color="#000000">
                            <td width="80%">
                               Perfumeria La que vende perfumes <br>
                               LABOULAYE, CORDOBA, ARGENTINA <br>
                               TEL: 0351-111111  <br>
                               MAIL: [email protected]  <br>
                            </td>
                            <td width="20%" align="right">
                                <IMG SRC="kde1.png">
                            </td>
                        </tr>

                    </table>
                _______________________________________________________________________________________________________
                    <p>
                        DATOS DEL CLIENTE:
                    </p>
                    <br>
                    <table>

                        <tr>
                            <td>
                                NOMBRE:   """+ nombre +"""  <br>
                                APELLIDO: """ + apellido + """ <br>

                            </td>
                            <td>
                            </td>
                        </tr>
                    </table>

                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <p>
                        DETALLES DE LA COMPRA:
                    </p>
                    <br>
                    <table width="600" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                      <tr  style=" background-color: gray; border-style: inset;">
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            CANT
                            </b>
                        </td>
                        <td width="20%"  align="center" valign="middle">
                            <b>
                                PRODUCTO
                            </b>
                        </td>
                        <td width="50%"  align="center" valign="middle">
                            <b>
                            DESCRIPCION
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>UNIT
                            </b>
                        </td>
                        <td width="10%"  align="center" valign="middle">
                            <b>
                            PREC <br>TOT
                            </b>
                        </td>
                      </tr>
                  </table>

                  <br>
                  <br>
                  <br>
                  <br>

                  <table  height="350" width="600" style="border-color: gray; border-width: .4px; border-collapse: collapse;">
                      """ + listTransaccionTable + """
                  </table>
                    <br>
                    <br>
                    <table width="600" border="0.5" height="0" style="border-color: black; border-width: 0.5px; border-spacing: 0;">
                        <tr >
                            <td width="90%" align="right">
                                <br>
                                TOTAL..................................................................................................................
                                <br>
                            </td>
                            <td width="10%" align="center">
                              <br> $ """ + total + """<br>
                            </td>
                        </tr>
                    </table>

                    <br>
                    <br>
                    <br>
                    <p width="600" align="center" style=" font-size: 10; " >
                    Por cualquier consulta, sobre este recibo, dirigirse al local que se encuentra ubicado en la calle
                    independencia 450. <br> O Comunicarse a los telefonos 03382-123123123 / 4231231
                    </p>
                    <br>
                    <br>
                    <br>
                    <br>
                    <br>
                    _______________________________________________________________________________________________________
                    <br>
                    <table width="600">
                        <tr>
                            <td align="right" width="80%">
                            FECHA/HORA : """+ fecha + """
                            </td>
                            <td align="right">
                            N° : """+ str(idRecibo) +"""
                            </td>
                        </tr>
                    </table>
                    _______________________________________________________________________________________________________
                """

        doc = QTextDocument()
        doc.setHtml(html)
        #doc.setDefaultStyleSheet(style)
        printer = QPrinter()
        printer.setOutputFileName(nombrePdf)

        printer.setOutputFormat(QPrinter.PdfFormat)
        doc.print(printer)
        printer.newPage()
        url = QUrl
        url = QUrl(nombrePdf)
        QDesktopServices.openUrl(url)

        """
        printPdf = QPrinter()
        printPdf.setOutputFormat(QPrinter.NativeFormat)

        questionPrint = QPrintDialog(printPdf, self.winPrincipal)

        if questionPrint.exec() == QPrintDialog.accept(printPdf):
            doc.print(printPdf)


        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea generar factura ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:

            #openPdf = QPrintDialog(printPdf, self.winPrincipal)
            #openPdf.setWindowTitle("Recibo")
        """


    def limpiarCampos(self):
        self.winPrincipal.tvClientes_t.setModel(None)
        self.winPrincipal.tvDetalleTransaccion_t.setModel(None)
        self.winPrincipal.tvProductos_t.setModel(None)
        self.winPrincipal.lblTotal.setText('0.00')
        self.winPrincipal.sbCantidadProducto_t.setValue(0)
        self.winPrincipal.rbCompra_t.setEnabled(True)
        self.winPrincipal.rbVenta_t.setEnabled(True)

        self.winPrincipal.txtFilterCliente_t.setText('')
        self.winPrincipal.txtFilterProducto_t.setText('')

        self.winPrincipal.btnAceptar_t.setEnabled(False)
        self.winPrincipal.btnCancelar_t.setEnabled(False)

        self.winPrincipal.txtFilterCliente_t.setFocus(True)


    def onClickCancelar(self):
        alert = QDialog()
        confirm = QMessageBox.question(alert, "Mensaje", "¿ Desea cancelar la transaccion ?", QMessageBox.Yes, QMessageBox.No)
        if confirm == QMessageBox.Yes:
            self.limpiarCampos()


    def cargarTablaClientes(self):
        parameter = self.winPrincipal.txtFilterCliente_t.text()

        typeParameter = ''
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            typeParameter = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'


        listaClientes = self.conexionTransacciones.selectClientes(typeParameter, parameter)
        if len(listaClientes) > 0:
            header = ['ID','Apellido','Nombre','Email']
            tablaModel = MyTableModel(self.winPrincipal.tvClientes_t, listaClientes, header)
            #tablaModel.setHeaderData(3, QtCore.Qt.Horizontal , 'Email', QtCore.Qt.AlignRight)
            #index = QModelIndex()
            #index.data(2)
            #index.column()
            #tablaModel.setData(index, QtCore.QVariant(QtCore.Qt.AlignHCenter), QtCore.Qt.TextAlignmentRole)
            self.winPrincipal.tvClientes_t.setModel(tablaModel)
            self.winPrincipal.tvClientes_t.selectionModel().currentChanged.connect(self.changeSelectedTable)
            #self.winPrincipal.tvClientes_t.model().headerData(2, QtCore.Qt.Horizontal, QtCore.Qt.AlignRight)
            self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
            self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)

        else:
            self.winPrincipal.tvClientes_t.setModel(None)


    def cargarTablaProveedores(self):

        parameter = self.winPrincipal.txtFilterCliente_t.text()

        typeParameter = ''
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            typeParameter = 'prov.descripcion'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'

        listProveedores = self.conexionTransacciones.selectProveedores(typeParameter, parameter)
        if len(listProveedores) > 0:
            header = ['ID', 'Descripcion', 'Nombre', 'Email']
            tableModel = MyTableModel(self.winPrincipal.tvClientes_t, listProveedores, header)
            self.winPrincipal.tvClientes_t.setModel(tableModel)
            self.winPrincipal.tvClientes_t.selectionModel().currentChanged.connect(self.changeSelectedTable)

            self.winPrincipal.tvClientes_t.setColumnHidden(0, True)
            self.winPrincipal.tvClientes_t.setColumnWidth(1, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(2, 130)
            self.winPrincipal.tvClientes_t.setColumnWidth(3, 150)
        else:
            self.winPrincipal.tvClientes_t.setModel(None)


    def changeSelectedTable(self, selected, deselected):

        listPersonas = selected.model().mylist
        personaSelected = ()
        personaSelected = tuple(listPersonas[selected.row()])

        self.personaSelectedRow = selected.row()

        if(self.tipoTransaccion == "VENTA"):
            self.cliente = Cliente()
            self.cliente.setIdCliente(int(personaSelected[0]))
            self.cliente.setApellido(str(personaSelected[1]))
            self.cliente.setNombre(str(personaSelected[2]))
            self.cliente.setEmail(str(personaSelected[3]))

        elif(self.tipoTransaccion == "COMPRA"):
            self.proveedor = Proveedor()
            self.proveedor.setIdProveedor(int(personaSelected[0]))
            self.proveedor.setDescripcion(str(personaSelected[1]))
            self.proveedor.setNombre(str(personaSelected[2]))
            self.proveedor.setEmail(str(personaSelected[3]))

        self.activateButton()

    def cargarTablaProductos(self):

        parameter = self.winPrincipal.txtFilterProducto_t.text()
        typeParameter = ''
        if self.winPrincipal.cbFilterProducto_t.currentText() == 'Nombre':
            typeParameter = 'p.nombre'
        elif self.winPrincipal.cbFilterProducto_t.currentText() == 'Marca':
            typeParameter = 'm.descripcion'
        elif self.winPrincipal.cbFilterProducto_t.currentText() == 'Precio de Venta':
            typeParameter = 'p.pVenta'
        else:
            typeParameter = 'p.pCompra'

        parameterTransaccion = 'CMP'
        if self.tipoTransaccion == "VENTA":
            parameterTransaccion = 'VNT'

        listProducto = self.conexionTransacciones.selectProductos(typeParameter, parameter, parameterTransaccion)

        if len(listProducto) > 0:
            header = ['ID', 'Nombre', 'Descripcion', 'Cant', 'P.Compra', 'P.Venta', 'Marca']

            tableModel = MyTableModel(self.winPrincipal.tvProductos_t, listProducto, header)
            self.winPrincipal.tvProductos_t.setModel(tableModel)
            self.winPrincipal.tvProductos_t.selectionModel().currentChanged.connect(self.changeSelectedTableProducto)

            self.winPrincipal.tvProductos_t.setColumnHidden(0, True)
            self.winPrincipal.tvProductos_t.setColumnWidth(1, 150)
            self.winPrincipal.tvProductos_t.setColumnWidth(2, 200)
            self.winPrincipal.tvProductos_t.setColumnWidth(3, 50)
            self.winPrincipal.tvProductos_t.setColumnWidth(4, 80)
            self.winPrincipal.tvProductos_t.setColumnWidth(5, 80)
            self.winPrincipal.tvProductos_t.setColumnWidth(6, 100)

        else:
            self.winPrincipal.tvProductos_t.setModel(None)


    def changeSelectedTableProducto(self, selected, deselected):
        listProductos = selected.model().mylist
        productoSelected = ()
        productoSelected = tuple(listProductos[selected.row()])

        self.productoSelected = selected.row()

        self.producto = Producto()
        self.producto.setIdProducto(int(productoSelected[0]))
        self.producto.setNombre(str(productoSelected[1]))
        self.producto.setDescripcion(str(productoSelected[2]))
        self.producto.setCantidad(int(productoSelected[3]))
        self.producto.setPrecioCompra(float(productoSelected[4]))
        self.producto.setPrecioVenta(float(productoSelected[5]))

        self.winPrincipal.btnSumarProducto_t.setEnabled(True)



    def agregarTransaccion(self):
        cantProducto = int(self.winPrincipal.sbCantidadProducto_t.value())


        stateProduct = True

        if self.tipoTransaccion == "VENTA" and cantProducto > self.producto.getCantidad():
            stateProduct = False

        if cantProducto == 0:
            stateProduct = False

        if stateProduct is True: #and self.validateProduct() is True:
            modelListTransaccion = self.winPrincipal.tvDetalleTransaccion_t.model()
            header = ['ID', 'Cantidad','idProducto' ,'Producto', 'Descripcion', 'Precio Unit', 'Precio Tot' ]

            precio_unitario = 0
            if(self.tipoTransaccion == "VENTA"):
                precio_unitario = float(self.producto.getPrecioVenta())

            elif(self.tipoTransaccion == "COMPRA"):
                precio_unitario = float(self.producto.getPrecioCompra())

            if modelListTransaccion is not None:
                listTabPro = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist)

                if len(listTabPro) > 0 or listTabPro is not None:
                    tuplaProd = ('0', str(cantProducto), str(self.producto.getIdProducto()), str(self.producto.getNombre()),
                                str(self.producto.getDescripcion()), str(precio_unitario), str(cantProducto * precio_unitario)
                                )

                    listTabPro.append(tuplaProd)
                    tupleTable = tuple(listTabPro)

                    tableModel = MyTableModel(self.winPrincipal, tupleTable , header)
                    self.winPrincipal.tvDetalleTransaccion_t.setModel(tableModel)
            else:
                lista = []
                tuplaProd = ('0', str(cantProducto), str(self.producto.getIdProducto()), str(self.producto.getNombre()),
                               str(self.producto.getDescripcion()), str(precio_unitario), str(cantProducto * precio_unitario)
                                )
                lista.append(tuplaProd)

                tableModel = MyTableModel(self.winPrincipal, lista , header)
                self.winPrincipal.tvDetalleTransaccion_t.setModel(tableModel)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(0, True)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(1, 80)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnHidden(2, True)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(3, 200)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(4, 653)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(5, 80)
                self.winPrincipal.tvDetalleTransaccion_t.setColumnWidth(6, 80)

                self.winPrincipal.rbCompra_t.setEnabled(False)
                self.winPrincipal.rbVenta_t.setEnabled(False)

            #self.total = (cantProducto * self.producto.getPrecioVenta()) + self.total

            #self.winPrincipal.lblTotal.setText(str(self.total))

            self.winPrincipal.btnCancelar_t.setEnabled(True)
            self.winPrincipal.btnSumarProducto_t.setEnabled(False)

            self.winPrincipal.sbCantidadProducto_t.setValue(0)

            self.winPrincipal.tvDetalleTransaccion_t.selectionModel().currentChanged.connect(self.changeSelectedTableTransaccion)

            total = float(self.winPrincipal.lblTotal.text())
            total +=+ (cantProducto * precio_unitario)
            self.winPrincipal.lblTotal.setText("{0:.2f}".format(total))
            self.activateButton()
            #self.calcularTotal()
        else:
            alert = QDialog()
            QMessageBox.information(alert,"ERROR", "La cantidad especificada es invalida")


    def activateButton(self):
        hasP = False
        if self.proveedor.getIdProveedor() != 0 or self.cliente.getIdCliente() != 0:
            hasP = True
        if self.winPrincipal.tvDetalleTransaccion_t.model() is not None and hasP is True:
            self.winPrincipal.btnAceptar_t.setEnabled(True)


    def validateProduct(self):
        validate = True


        if self.winPrincipal.tvDetalleTransaccion_t.model() is not None:
            listTransacciones = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()
            header = ('ID', 'Cantidad','idProducto' ,'Producto', 'Descripcion', 'Precio Unit', 'Precio Tot')
            listTransacciones.append(header)

            #cant = int(len(list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()))
            tuple = ("", listTransacciones[0][1], listTransacciones[0][2], listTransacciones[0][3], listTransacciones[0][4], listTransacciones[0][5], listTransacciones[0][6])
            listTransacciones[0] = tuple
            for transaccion in listTransacciones:
                if str(transaccion[2]) == str(self.producto.getIdProducto()):
                    validate = False
            """
            for i in range(cant):

                if listTransacciones[i][2] == str(self.producto.getIdProducto()):
                    validate = False
"""


        return validate


    def restarTransaccion(self):

        listTransacciones = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()

        header = ['ID', 'Cantidad','idProducto' ,'Producto', 'Descripcion', 'Precio Unit', 'Precio Tot' ]

        listTransacciones.remove(self.transaccionSelected)

        if len(listTransacciones) < 1:
            self.winPrincipal.btnAceptar_t.setEnabled(False)
            self.winPrincipal.btnCancelar_t.setEnabled(False)
            self.winPrincipal.tvDetalleTransaccion_t.setModel(None)
        else:
            tableTelModel = MyTableModel(self.winPrincipal, listTransacciones, header)
            self.winPrincipal.tvDetalleTransaccion_t.setModel(tableTelModel)
            self.winPrincipal.tvDetalleTransaccion_t.selectionModel().currentChanged.connect(self.changeSelectedTableTransaccion)


        total = float(self.winPrincipal.lblTotal.text())
        total -= float(self.transaccionSelected[6])
        self.winPrincipal.lblTotal.setText("{0:.2f}".format(total))

        self.winPrincipal.btnRestarProducto_t.setEnabled(False)
        #self.calcularTotal()


    def changeSelectedTableTransaccion(self, selected, deselected):
        listTransacciones = selected.model().mylist
        self.transaccionSelected = ()
        self.transaccionSelected = listTransacciones[selected.row()]

        self.telefonoSelectedRow = selected.row()

        self.winPrincipal.btnRestarProducto_t.setEnabled(True)


    def onClickVenta(self):
        self.winPrincipal.label2_t.setText('Cliente')
        self.tipoTransaccion = "VENTA"
        self.limpiarCampos()



    def onClickCompra(self):
        self.winPrincipal.label2_t.setText('Proovedor')
        self.tipoTransaccion = "COMPRA"
        self.limpiarCampos()



    def selecClientes(self):
        if self.winPrincipal.cbFilterCliente_t.currentText() == 'Apellido':
            tipoParametro = 'c.apellido'
        elif self.winPrincipal.cbFilterCliente_t.currentText() == 'Email':
            tipoParametro = 'p.email'

        parametro = self.winPrincipal.txtFilterCliente_t.text()

        self.conexionTransacciones.selectClientes(tipoParametro, parametro)


    def calcularTotal(self):
        listTransacciones = []
        listTransacciones = list(self.winPrincipal.tvDetalleTransaccion_t.model().mylist).copy()

        tupleParche = listTransacciones[0]
        tupleParche = ('1', tupleParche[1], tupleParche[2], tupleParche[3], tupleParche[4], tupleParche[5], tupleParche[6])
        listTransacciones[0] = tupleParche
        if len(listTransacciones) > 0:
            total = 0

            for transaccion in listTransacciones:

                total = total + float(transaccion[6])


            self.winPrincipal.lblTotal.setText(str(total))
        else:
            self.winPrincipal.lblTotal.setText('0,00')