class ConexionGenerales(object):
    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()

    def selectProductoStock(self):

        query = """
                   SELECT idproductos, nombre, cantidad, cant_minima
                   FROM productos
                   WHERE cantidad = cant_minima or cantidad < cant_minima and estado = 1
               """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProductos
class ConexionGenerales(object):

    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()


    def selectProductoStock(self):

        query = """
                   SELECT idproductos, nombre, cantidad, cant_minima
                   FROM productos
                   WHERE cantidad = cant_minima or cantidad < cant_minima and estado = 1
               """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProductos
class conexionProducto(object):

    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()
        self.proveedor = Proveedor()
        self.rubro = Rubro()
        self.marca = Marca()

    def selectProducto(self, typeParameter, parameter, parameterState, parameterStock):
        query = """
                    SELECT p.idproductos, p.nombre, p.descripcion, CAST(TRUNCATE(p.pCompra, 2) AS CHAR), CAST(TRUNCATE(p.pVenta, 2) AS CHAR),
                            p.genero, p.estado, p.cantidad, p.cant_minima, m.idmarcas, m.descripcion, r.idrubros,
                            r.descripcion, prov.idproveedores, prov.descripcion
                    FROM productos p, marcas m , rubros r, proveedores prov
                    WHERE p.rubros_idrubros = r.idrubros and p.marcas_idmarcas = m.idmarcas and
                        p.proveedores_idproveedores = prov.idproveedores and """+ typeParameter + """ LIKE %s and
                        p.estado LIKE %s
                """
        param = parameter + '%'

        paramState = '1'
        if parameterState == 0:
            paramState = '%'

        if parameterStock == 1:
            query = query + " and p.cantidad > 0"

        values = (param, paramState)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProducto = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProducto

    def modificarProducto(self, producto):
        query = """
                    UPDATE productos
                    SET nombre= %s, cantidad= %s, descripcion= %s, rubros_idrubros= %s, proveedores_idproveedores=%s,
                        marcas_idmarcas= %s, pCompra= %s, pVenta= %s, estado= %s, cant_minima= %s, genero= %s
                    WHERE idproductos= %s
                """
        idRubro = self.getIdRubro(producto.getRubro().getRubro())
        idMarca = self.getIdMarca(producto.getMarca().getMarca())
        idProveedor = self.getIdProveedor(producto.getProveedor().getDescripcion())
        values = (producto.getNombre(), producto.getCantidad(), producto.getDescripcion(), idRubro, idProveedor,
                  idMarca, producto.getPrecioCompra(), producto.getPrecioVenta(), producto.getEstado(),
                  producto.getCantidadMinima(), producto.getGenero(), producto.getIdProducto()
                 )
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarProducto(self, producto):
        query = """
                    INSERT INTO productos (nombre, cantidad, descripcion, rubros_idrubros,
                        proveedores_idproveedores, marcas_idmarcas, pCompra, pVenta, estado,
                        cant_minima, genero)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                """
        idRubro = self.getIdRubro(producto.getRubro().getRubro())
        idMarca = self.getIdMarca(producto.getMarca().getMarca())
        idProveedor = self.getIdProveedor(producto.getProveedor().getDescripcion())
        values = (producto.getNombre(), producto.getCantidad(), producto.getDescripcion(), idRubro, idProveedor,
                  idMarca, producto.getPrecioCompra(), producto.getPrecioVenta(), producto.getEstado(),
                  producto.getCantidadMinima(), producto.getGenero()
                 )
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        print(self.conexion.cursor._check_executed())
        print(self.conexion.cursor.messages)

        self.conexion.cerrarConexion()

    def borrarProducto(self, producto):
        query = """
                    UPDATE productos
                    SET estado = 0
                    WHERE idproductos = %s
                """
        values = producto.getIdProducto()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.cerrarConexion()

    def listMarcas(self):
        query = "SELECT descripcion FROM marcas"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listMarcasaux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listMarcas = []
        listMarcas.append('')
        for marca in listMarcasaux:
            listMarcas.append(marca[0])

        return listMarcas

    def listRubro(self):
        query = "SELECT descripcion FROM rubros"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listRubrosaux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listRubros = []
        listRubros.append('')
        for rubro in listRubrosaux:
            listRubros.append(rubro[0])

        return listRubros

    def listProveedor(self):
        query = "SELECT descripcion FROM proveedores"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedoraux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listProveedores = []
        listProveedores.append('')
        for proveedor in listProveedoraux:
            listProveedores.append(proveedor[0])

        return listProveedores

    def getIdProveedor(self, proveedor):
        query = "SELECT idproveedores FROM proveedores WHERE descripcion = %s"
        values = proveedor
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idProveedor = int(result[0][0])

        return idProveedor

    def getIdMarca(self, marca):
        query = "SELECT idmarcas FROM marcas WHERE descripcion = %s"
        values = marca
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idMarca = int(result[0][0])

        return idMarca

    def getIdRubro(self, rubro):
        query = "SELECT idrubros FROM rubros WHERE descripcion = %s"
        values = rubro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idRubro = int(result[0][0])

        return idRubro
 def __init__(self):
     self.conexion = Conexion()
     self.producto = Producto()
     self.proveedor = Proveedor()
     self.rubro = Rubro()
     self.marca = Marca()
 def __init__(self):
     self.conexion = Conexion()
     self.__rubro = Rubro()
class ConexionTransacciones(object):

    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()
        self.proveedor = Proveedor()


    def selectProveedores(self, typeParameter, parameter):
        query = """
                    SELECT prov.idproveedores , prov.descripcion, p.nombre, p.email
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas and prov.estado = 1 and """+ typeParameter +""" LIKE %s
                """
        param = parameter + '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedores = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProveedores

    def selectClientes(self, typeParameter, parameter):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, p.email
                    FROM clientes c, personas p
                    WHERE p.idpersonas = c.personas_idpersonas and c.estado = 1 and """+ typeParameter +""" LIKE %s
                """
        param = parameter + '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes

    def selectProductos(self, typeParameter, parameter, parameterTransaccion):
        query = """
                    SELECT p.idproductos, p.nombre, p.descripcion, p.cantidad, CAST(TRUNCATE(p.pCompra, 2) AS CHAR), CAST(TRUNCATE(p.pVenta, 2) AS CHAR), m.descripcion
                    FROM productos p, marcas m
                    WHERE p.marcas_idmarcas = m.idmarcas and """ +typeParameter+ """ LIKE %s
                """
        if parameterTransaccion == 'VNT':
            query += " and p.estado = 1 and p.cantidad > 0"

        param = parameter + '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, param)
        listProductos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listProductos

    def cargarTransaccionCompra(self, listMovimiento, proveedor, estado):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, proveedores_idproveedores)
                                VALUES ('compra', %s)
                              """
        valuesTipoMovimiento = proveedor.getIdProveedor()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento, estado)
                            VALUES ( %s , %s, %s)
                          """
        valuesMovimiento = (hoy, idTipoMovimiento, estado)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1], detalleMovimiento[5], detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento, valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount
            producto = Producto()
            producto.setIdProducto(int(detalleMovimiento[2]))
            producto.setCantidad(int(detalleMovimiento[1]))
            self.modificarStock('CMP', producto)

        self.conexion.cerrarConexion()
        return idMovimiento

    def cargarTransaccionVenta(self: object, listMovimiento, cliente, estado):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, clientes_idClientes)
                                VALUES ('venta', %s)
                              """
        valuesTipoMovimiento = cliente.getIdCliente()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento, estado)
                            VALUES ( %s , %s, %s);
                          """
        valuesMovimiento = (hoy, idTipoMovimiento, estado)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1], detalleMovimiento[5], detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento, valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount

            producto = Producto()
            producto.setIdProducto(int(detalleMovimiento[2]))
            producto.setCantidad(int(detalleMovimiento[1]))
            self.modificarStock(tipoT='VNT', producto=producto)

        self.conexion.cerrarConexion()

        return idMovimiento


    def modificarStock(self, tipoT, producto):
        query = """
                    SELECT cantidad
                    FROM productos
                    WHERE idproductos = %s
                """
        values = producto.getIdProducto()
        #self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        cant = 0
        cantInit = int(self.conexion.cursor.fetchall()[0][0])
        #self.conexion.cerrarConexion()
        if tipoT == 'VNT':
            cant = cantInit - producto.getCantidad()
        else:
            cant = cantInit + producto.getCantidad()

        queryUpdateProducto = """
                                UPDATE productos
                                SET cantidad = %s
                                WHERE idproductos = %s
                              """
        valuesUpdateProducto = (cant, producto.getIdProducto())
        #self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryUpdateProducto, valuesUpdateProducto)
        self.conexion.db.commit()
        #self.conexion.cerrarConexion()
 def __init__(self):
     self.conexion = Conexion()
     self.__marca = Marca()
Пример #8
0
 def __init__(self):
     self.conexion = Conexion()
     self.__marca = Marca()
Пример #9
0
 def __init__(self):
     self.conexion = Conexion()
     self.cliente = Cliente()
     self.proveedor = Proveedor()
class conexionCliente(object):

    def __init__(self):
       self.conexion = Conexion()
       self.cliente = Cliente()

    def selectCliente(self, typeParameter, parameter, parameterState):
        query = """
                    SELECT cli.idClientes, cli.apellido, p.nombre, p.email, d.direccion, d.numero, d.piso, d.dpto,
                         d.iddirecciones, p.idpersonas, cli.estado
                    FROM clientes cli, personas p, direcciones d
                    WHERE p.idpersonas = cli.personas_idpersonas and d.iddirecciones = p.direcciones_iddirecciones and
                    """ +typeParameter + """ LIKE %s and cli.estado LIKE %s
                """
        paramState = '1'
        if parameterState == 0:
            paramState = '%'

        param = parameter+ '%'
        values = (param, paramState)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente

    def selectTelefonoCliente(self, cliente):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, clientes c
                    WHERE p.idpersonas = c.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and c.idClientes = %s"""
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarCliente(self, cliente):

        query = """UPDATE personas p, clientes c, direcciones d
                    SET p.nombre = %s , p.email= %s , c.apellido = %s, d.direccion= %s, d.numero = %s, d.piso = %s, d.dpto = %s, c.estado = %s
                    WHERE p.idpersonas = c.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and c.idClientes = %s"""
        values = (cliente.getNombre(), cliente.getEmail(), cliente.getApellido(), cliente.getDireccion().getDireccion(),
                  cliente.getDireccion().getNumero(), cliente.getDireccion().getPiso(),
                  cliente.getDireccion().getDpto(), cliente.getEstado(), cliente.getIdCliente())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarCliente(self, cliente):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"

        valuesDireccion = (cliente.getDireccion().getDireccion(), cliente.getDireccion().getNumero(),
                            cliente.getDireccion().getPiso(), cliente.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (cliente.getNombre(), cliente.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryCliente = "INSERT INTO clientes (personas_idpersonas, apellido, estado) VALUES (LAST_INSERT_ID(), %s, %s)"
        valuesCliente = (cliente.getApellido(), cliente.getEstado())
        self.conexion.cursor.execute(queryCliente, valuesCliente)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarCliente(self, cliente):
        queryCliente = """
                            UPDATE clientes
                            SET estado = 0
                            WHERE idClientes = %s
                       """
        valuesCliente = cliente.getIdCliente()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryCliente, valuesCliente)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
class ConexionTransacciones(object):
    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()
        self.proveedor = Proveedor()

    def selectProveedores(self, tipoParametro, parametro):
        query = """
                    SELECT prov.idproveedores , prov.descripcion, p.nombre, p.email
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas
                """
        values = (tipoParametro, parametro)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedores = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProveedores

    def selectClientes(self, tipoParametro, parametro):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, p.email
                    FROM clientes c, personas p
                    WHERE p.idpersonas = c.personas_idpersonas
                """
        values = (tipoParametro, parametro)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes

    def selectProductos(self):
        query = """
                    SELECT p.idproductos, p.nombre, p.descripcion, p.cantidad, p.pCompra, p.pVenta, m.descripcion
                    FROM productos p, marcas m
                    WHERE p.marcas_idmarcas = m.idmarcas
                """
        values = ""
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listProductos

    def cargarTransaccionCompra(self, listMovimiento, proveedor):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, proveedores_idproveedores)
                                VALUES ('compra', %s)
                              """
        valuesTipoMovimiento = proveedor.getIdProveedor()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount

        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento)
                            VALUES ( %s , %s)
                          """
        valuesMovimiento = (hoy, idTipoMovimiento)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount

        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1],
                                       detalleMovimiento[5],
                                       detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento,
                                         valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount

        self.conexion.cerrarConexion()
        return idMovimiento

    def cargarTransaccionVenta(self, listMovimiento, cliente):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, clientes_idClientes)
                                VALUES ('venta', %s)
                              """
        valuesTipoMovimiento = cliente.getIdCliente()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount

        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento)
                            VALUES ( %s , %s);
                          """
        valuesMovimiento = (hoy, idTipoMovimiento)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount

        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1],
                                       detalleMovimiento[5],
                                       detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento,
                                         valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount

        self.conexion.cerrarConexion()

        return idMovimiento

    def modificarStock(self, tipoT, producto):
        pass
class conexionUsuario(object):

    def __init__(self):
        self.conexion = Conexion()
        self.usuario = Usuario()

    def selectUsuario(self):
        query = """
                    SELECT u.idusuarios, p.nombre, u.apellido, u.usuario, u.tipo, u.contraseña, p.email, d.direccion,
                            d.numero, d.piso, d.dpto, d.iddirecciones, p.idpersonas
                    FROM usuarios u , personas p, direcciones d
                    WHERE p.idpersonas = u.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listUsuario = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listUsuario

    def selectTelefonoUsuario(self, usuario):
        query = """
                    SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, usuarios u",
                    WHERE p.idpersonas = u.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and usuarios.idusuarios = %s
                """
        values = usuario.getIdUsuario()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarUsuario(self, usuario):
        query = """
                    UPDATE personas p, usuarios u, direcciones d
                    SET p.nombre = % , p.email= %s, u.apellido = %s, u.usuario = %s,
                        u.tipo = %s, u.contraseña = %s, d.direccion = %s, d.numero = %s, d.piso = %s, d.dpto = %s
                    WHERE p.idpersonas = u.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                        and u.idusuarios = %s
                """
        values = (usuario.getNombre(), usuario.getEmail(), usuario.getApellido(), usuario.getUsuario(),
                  usuario.getTipoUsuario(), usuario.getPasswd(), usuario.getDireccion().getDireccion(),
                  usuario.getDireccion().getNumero(), usuario.getDireccion().getPiso(),
                  usuario.getDireccion().getDpto(), usuario.getIdUsuario())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarUsuario(self, usuario):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"
        valuesDireccion = (usuario.getDireccion().getDireccion(), usuario.getDireccion().getNumero(),
                            usuario.getDireccion().getPiso(), usuario.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (usuario.getNombre(), usuario.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryUsuario = """INSERT INTO usuarios (tipo, personas_idpersonas, contraseña, usuario, apellido)
                        VALUES ( %s , LAST_INSERT_ID() , %s , %s , %s )"""
        valuesUsuario = (usuario.getTipoUsuario(), usuario.getPasswd(), usuario.getUsuario(), usuario.getApellido())
        self.conexion.cursor.execute(queryUsuario, valuesUsuario)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarUsuario(self, usuario):
        queryTelefono = """
                            DELETE telefonos
                            FROM telefonos
                            WHERE telefonos.personas_idpersonas = %s
                        """
        valuesTelefono = usuario.getIdPersona()

        queryUsuario = """
                            DELETE usuarios
                            FROM usuarios
                            WHERE usuarios.idusuarios = %s
                       """

        valuesUsuario = usuario.getIdUsuario()

        queryPersona = """
                            DELETE personas
                            FROM personas
                            WHERE personas.idpersonas = %s
                       """

        valuesPersona = usuario.getIdPersona()

        queryDireccion = """
                            DELETE direcciones
                            FROM direcciones
                            WHERE direcciones.iddirecciones = %s
                         """

        valuesDireccion = usuario.getDireccion().getIdDireccion()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryTelefono, valuesTelefono)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryUsuario, valuesUsuario)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryPersona, valuesPersona)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)
        self.conexion.db.commit()

        self.conexion.cerrarConexion()


    def validarUsuario(self, usuario):
        query = "SELECT usuario, tipo FROM usuarios WHERE usuario= %s and contraseña = %s"
        values = (usuario.getUsuario(), usuario.getPasswd())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        auxUsuario = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return auxUsuario
Пример #13
0
class conexionCliente(object):
    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()

    def selectCliente(self):
        query = """SELECT cli.idClientes, cli.apellido, p.nombre, p.email, d.direccion, d.numero, d.piso, d.dpto,
                         d.iddirecciones, p.idpersonas
                    FROM clientes cli, personas p, direcciones d
                    WHERE p.idpersonas = cli.personas_idpersonas and d.iddirecciones = p.direcciones_iddirecciones"""
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente

    def selectTelefonoCliente(self, cliente):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, clientes c
                    WHERE p.idpersonas = c.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and c.idClientes = %s"""
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarCliente(self, cliente):

        query = """UPDATE personas p, clientes c, direcciones d
                    SET p.nombre = %s , p.email= %s , c.apellido = %s, d.direccion= %s, d.numero = %s, d.piso = %s, d.dpto = %s
                    WHERE p.idpersonas = c.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and c.idClientes = %s"""
        values = (cliente.getNombre(), cliente.getEmail(),
                  cliente.getApellido(), cliente.getDireccion().getDireccion(),
                  cliente.getDireccion().getNumero(),
                  cliente.getDireccion().getPiso(),
                  cliente.getDireccion().getDpto(), cliente.getIdCliente())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarCliente(self, cliente):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"

        valuesDireccion = (cliente.getDireccion().getDireccion(),
                           cliente.getDireccion().getNumero(),
                           cliente.getDireccion().getPiso(),
                           cliente.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (cliente.getNombre(), cliente.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryCliente = "INSERT INTO clientes (personas_idpersonas, apellido) VALUES (LAST_INSERT_ID(), %s)"
        valuesCliente = cliente.getApellido()
        self.conexion.cursor.execute(queryCliente, valuesCliente)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarCliente(self, cliente):
        queryTelefono = """
                            DELETE telefonos
                            FROM telefonos
                            WHERE telefonos.personas_idpersonas = %s
                        """
        valuesTelefono = cliente.getIdPersona()

        queryCliente = """
                            DELETE clientes
                            FROM clientes
                            WHERE idClientes = %s
                       """
        valuesCliente = cliente.getIdCliente()

        queryPersona = """
                            DELETE personas
                            FROM personas
                            WHERE personas.idpersonas = %s
                       """
        valuesPersona = cliente.getIdPersona()

        queryDireccion = """
                            DELETE direcciones
                            FROM direcciones
                            WHERE direcciones.iddirecciones = %s
                         """
        valuesDireccion = cliente.getDireccion().getIdDireccion()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryTelefono, valuesTelefono)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryCliente, valuesCliente)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryPersona, valuesPersona)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)
        self.conexion.db.commit()

        self.conexion.cerrarConexion()
class ConexionTransacciones(object):

    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()
        self.proveedor = Proveedor()


    def selectProveedores(self, tipoParametro, parametro):
        query = """
                    SELECT prov.idproveedores , prov.descripcion, p.nombre, p.email
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas
                """
        values = (tipoParametro, parametro)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedores = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProveedores

    def selectClientes(self, tipoParametro, parametro):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, p.email
                    FROM clientes c, personas p
                    WHERE p.idpersonas = c.personas_idpersonas
                """
        values = (tipoParametro, parametro)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes

    def selectProductos(self):
        query = """
                    SELECT p.idproductos, p.nombre, p.descripcion, p.cantidad, p.pCompra, p.pVenta, m.descripcion
                    FROM productos p, marcas m
                    WHERE p.marcas_idmarcas = m.idmarcas
                """
        values = ""
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listProductos

    def cargarTransaccionCompra(self, listMovimiento, proveedor):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, proveedores_idproveedores)
                                VALUES ('compra', %s)
                              """
        valuesTipoMovimiento = proveedor.getIdProveedor()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento)
                            VALUES ( %s , %s)
                          """
        valuesMovimiento = (hoy, idTipoMovimiento)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1], detalleMovimiento[5], detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento, valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount

        self.conexion.cerrarConexion()
        return idMovimiento

    def cargarTransaccionVenta(self, listMovimiento, cliente):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, clientes_idClientes)
                                VALUES ('venta', %s)
                              """
        valuesTipoMovimiento = cliente.getIdCliente()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryMovimiento = """
                            INSERT INTO movimiento (fecha, tipo_movimiento_idtipo_movimiento)
                            VALUES ( %s , %s);
                          """
        valuesMovimiento = (hoy, idTipoMovimiento)

        self.conexion.cursor.execute(queryMovimiento, valuesMovimiento)
        self.conexion.db.commit()
        idMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryDetalleMovimiento = """
                            INSERT INTO detalle_movimiento (cantidad, precio_unitario, productos_idproductos,
                                movimiento_idMovimiento)
                            VALUES (%s, %s , %s, %s)
                           """
        for detalleMovimiento in listMovimiento:
            valuesDetalleMovimiento = (detalleMovimiento[1], detalleMovimiento[5], detalleMovimiento[2], idMovimiento)
            self.conexion.cursor.execute(queryDetalleMovimiento, valuesDetalleMovimiento)
            self.conexion.db.commit()
            lastId = self.conexion.cursor.lastrowid
            cantRowAffect = self.conexion.cursor.rowcount

        self.conexion.cerrarConexion()

        return idMovimiento


    def modificarStock(self, tipoT, producto):
        pass
class ConexionGenerales(object):

    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()
        proveedor = Proveedor()
        cliente = Cliente()


    def selectProductoStock(self):

        query = """
                   SELECT idproductos, nombre, cantidad, cant_minima
                   FROM productos
                   WHERE estado = 1 and cantidad BETWEEN 0 and cant_minima
               """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProductos

    def changeStateProduct(self, producto):
        query ="""
                    UPDATE productos
                    SET estado = '0'
                    WHERE idproductos = %s
               """
        values = producto.getIdProducto()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def selectVentasMensuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY month(m.fecha)
                """
        self.conexion.abrirConexion()

        self.conexion.cursor.execute(query)
        listVentasMes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentasMes




    def selectComprasMensuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY month(m.fecha)
                """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listComprasMes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listComprasMes


    def selectVentasAnuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY year(m.fecha)
                """
        self.conexion.abrirConexion()

        self.conexion.cursor.execute(query)

        listVentasAnuales = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentasAnuales

    def selectComprasAnuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY year(m.fecha)
                """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listComprasAnuales = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listComprasAnuales


    def selectVentas(self, intervalo, desde, hasta):
        query = """
                    SELECT CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR)) AS fecha,
                           CAST(SUM(dm.cantidad) AS CHAR) as cantidad
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                          m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
						  m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)


        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listVentas = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentas

    def selectCompras(self, intervalo, desde, hasta):
        query = """
                    SELECT CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR)) AS fecha,
                           CAST(SUM(dm.cantidad) AS CHAR) as cantidad
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                          m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
						  m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCompras = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listCompras

    def selectProveedor(self, parameter):
        query ="""
                    SELECT prov.idproveedores, prov.descripcion, p.nombre
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas and
                    prov.descripcion LIKE %s
               """
        param = parameter+ '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedor = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProveedor

    def selectCliente(self, parameter):
        query = """
                    SELECT cli.idClientes, cli.apellido, p.nombre
                    FROM clientes cli, personas p
                    WHERE p.idpersonas = cli.personas_idpersonas and
                            cli.apellido LIKE %s
                """
        param = parameter+ '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente


    def selectListPagosProveedor(self, proveedor, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(p.fecha) AS CHAR))"""
        query = """
                    SELECT """+ selectFecha +""" AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        prov.idproveedores = %s and
	                    p.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(p.fecha)
					ORDER BY p.fecha
                """
        values = (proveedor.getIdProveedor(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionProveedor(self, proveedor, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR))"""
        query = """
                    SELECT """+ selectFecha +""" AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        prov.idproveedores = % s and
	                    m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (proveedor.getIdProveedor(), desde, hasta)

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectListPagosCliente(self, cliente, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(p.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha, SUM(p.monto), tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        c.idclientes = %s and
	                    p.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(p.fecha)
					ORDER BY p.fecha
                """
        values = (cliente.getIdCliente(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionCliente(self, cliente, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        c.idclientes = %s and
	                    m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (cliente.getIdCliente(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectEntradasTransacciones(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 1 and
	                    m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listEntradaTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listEntradaTransacciones


    def selectSalidaTransacciones(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(m.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 1 and
	                    m.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listSalidaTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listSalidaTransacciones


    def selectEntradaPagos(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(p.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
	                    p.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(p.fecha)
					ORDER BY p.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listEntradaPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listEntradaPagos

    def selectSalidaPagos(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST("""+intervalo+"""(p.fecha) AS CHAR))"""

        query = """
                    SELECT """+ selectFecha +""" AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
	                    p.fecha between %s and %s
                    GROUP BY """+ intervalo +"""(p.fecha)
					ORDER BY p.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listSalidaPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listSalidaPagos
class conexionProveedor(object):
    def __init__(self):
        self.conexion = Conexion()
        self.proveedor = Proveedor()

    def selectProveedor(self, typeParameter, parameter, parameterState):
        query = """
                    SELECT prov.idproveedores, prov.descripcion, p.nombre, p.email, prov.web, d.direccion, d.numero,
                        d.piso, d.dpto, p.idpersonas, d.iddirecciones, prov.estado
                    FROM proveedores prov, personas p, direcciones d
                    WHERE p.direcciones_iddirecciones = d.iddirecciones and p.idpersonas = prov.personas_idpersonas and
                    """ + typeParameter + """ LIKE %s and prov.estado LIKE %s
               """
        param = parameter + '%'

        paramState = '1'
        if parameterState == 0:
            paramState = '%'

        values = (param, paramState)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedor = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProveedor

    def selectTelefonoProveedor(self, proveedor):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, proveedores prov
                    WHERE p.idpersonas = prov.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and prov.idproveedores = %s"""
        value = proveedor.getIdProveedor()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarProveedor(self, proveedor):
        query = """
                    UPDATE personas p, proveedores prov, direcciones d
                    SET p.nombre = %s , p.email= %s , prov.descripcion = %s, prov.web = %s, d.direccion= %s,
                            d.numero = %s, d.piso = %s, d.dpto = %s, prov.estado = %s
                    WHERE p.idpersonas = prov.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and prov.idproveedores = %s
                """
        values = (proveedor.getNombre(), proveedor.getEmail(),
                  proveedor.getDescripcion(), proveedor.getWeb(),
                  proveedor.getDireccion().getDireccion(),
                  proveedor.getDireccion().getNumero(),
                  proveedor.getDireccion().getPiso(),
                  proveedor.getDireccion().getDpto(), proveedor.getEstado(),
                  proveedor.getIdProveedor())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarProveedor(self, proveedor):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"
        valuesDireccion = (proveedor.getDireccion().getDireccion(),
                           proveedor.getDireccion().getNumero(),
                           proveedor.getDireccion().getPiso(),
                           proveedor.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (proveedor.getNombre(), proveedor.getEmail())

        self.conexion.cursor.execute(queryPersona, valuesPersona)
        query1 = "INSERT INTO proveedores (personas_idpersonas, descripcion, web, estado) VALUES (LAST_INSERT_ID(), %s, %s, %s)"
        values1 = (proveedor.getDescripcion(), proveedor.getWeb(),
                   proveedor.getEstado())
        self.conexion.cursor.execute(query1, values1)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarProveedor(self, proveedor):
        queryProveedores = """
                            UPDATE proveedores
                            SET estado = 0
                            WHERE proveedores.idproveedores = %s
                           """
        valuesProveedor = proveedor.getIdProveedor()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryProveedores, valuesProveedor)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
class ConexionPagos(object):

    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()
        self.proveedor = Proveedor()


    def selectProveedores(self, tipoParametro, parametro):
        query = """
                    SELECT prov.idproveedores , prov.descripcion, p.nombre, p.email
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas and prov.estado = 1 and
                    """ + tipoParametro + """ LIKE %s
                """
        parametro = parametro + '%'
        values = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedores = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProveedores


    def selectClientes(self, tipoParametro, parametro):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, p.email
                    FROM clientes c, personas p
                    WHERE p.idpersonas = c.personas_idpersonas and c.estado = 1 and
                    """+ tipoParametro + """ LIKE %s
                """
        parametro = parametro + '%'
        values = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes


    def selectListPagosProveedor(self, proveedor):
        query = """
                    SELECT p.fecha, p.monto, tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        prov.idproveedores = %s
                """
        values = proveedor.getIdProveedor()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionProveedor(self, proveedor):
        query = """
                    SELECT m.fecha, SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        prov.idproveedores = %s
                    GROUP BY m.fecha
                """
        values = proveedor.getIdProveedor()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectListPagosCliente(self, cliente):
        query = """
                    SELECT p.fecha, p.monto, tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        c.idclientes = %s
                """
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionCliente(self, cliente):
        query = """
                    SELECT m.fecha, SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        c.idclientes = %s
                    GROUP BY m.fecha
                """
        values = cliente.getIdCliente()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def cargarCobranza(self, cliente, monto):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, clientes_idclientes)
                                VALUES ('pago', %s)
                              """
        valuesTipoMovimiento = cliente.getIdCliente()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount
        self.conexion.cerrarConexion()

        queryPagos = """
                            INSERT INTO pagos (fecha, monto, tipo_movimiento_idtipo_movimiento)
                            VALUES (%s, %s, %s);

                          """
        valuesPagos = (hoy, monto, idTipoMovimiento)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryPagos, valuesPagos)
        self.conexion.db.commit()
        idRecibo = self.conexion.cursor.lastrowid
        self.conexion.cerrarConexion()

        return idRecibo

    def cargarPago(self, proveedor, monto):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, proveedores_idproveedores)
                                VALUES ('pago', %s)
                              """
        valuesTipoMovimiento = proveedor.getIdProveedor()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount


        queryPagos = """
                            INSERT INTO pagos (fecha, monto, tipo_movimiento_idtipo_movimiento)
                            VALUES (%s, %s, %s);

                          """
        valuesPagos = (hoy, monto, idTipoMovimiento)

        self.conexion.cursor.execute(queryPagos, valuesPagos)
        self.conexion.db.commit()
        idRecibo = self.conexion.cursor.lastrowid
        self.conexion.cerrarConexion()

        return idRecibo
class conexionCliente(object):
    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()

    def selectCliente(self):
        query = """SELECT cli.idClientes, cli.apellido, p.nombre, p.email, d.direccion, d.numero, d.piso, d.dpto,
                         d.iddirecciones, p.idpersonas
                    FROM clientes cli, personas p, direcciones d
                    WHERE p.idpersonas = cli.personas_idpersonas and d.iddirecciones = p.direcciones_iddirecciones"""
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente

    def selectTelefonoCliente(self, cliente):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, clientes c
                    WHERE p.idpersonas = c.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and c.idClientes = %s"""
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarCliente(self, cliente):

        query = """UPDATE personas p, clientes c, direcciones d
                    SET p.nombre = %s , p.email= %s , c.apellido = %s, d.direccion= %s, d.numero = %s, d.piso = %s, d.dpto = %s
                    WHERE p.idpersonas = c.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and c.idClientes = %s"""
        values = (
            cliente.getNombre(),
            cliente.getEmail(),
            cliente.getApellido(),
            cliente.getDireccion().getDireccion(),
            cliente.getDireccion().getNumero(),
            cliente.getDireccion().getPiso(),
            cliente.getDireccion().getDpto(),
            cliente.getIdCliente(),
        )
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarCliente(self, cliente):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"

        valuesDireccion = (
            cliente.getDireccion().getDireccion(),
            cliente.getDireccion().getNumero(),
            cliente.getDireccion().getPiso(),
            cliente.getDireccion().getDpto(),
        )
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = (
            "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        )
        valuesPersona = (cliente.getNombre(), cliente.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryCliente = "INSERT INTO clientes (personas_idpersonas, apellido) VALUES (LAST_INSERT_ID(), %s)"
        valuesCliente = cliente.getApellido()
        self.conexion.cursor.execute(queryCliente, valuesCliente)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarCliente(self, cliente):
        queryTelefono = """
                            DELETE telefonos
                            FROM telefonos
                            WHERE telefonos.personas_idpersonas = %s
                        """
        valuesTelefono = cliente.getIdPersona()

        queryCliente = """
                            DELETE clientes
                            FROM clientes
                            WHERE idClientes = %s
                       """
        valuesCliente = cliente.getIdCliente()

        queryPersona = """
                            DELETE personas
                            FROM personas
                            WHERE personas.idpersonas = %s
                       """
        valuesPersona = cliente.getIdPersona()

        queryDireccion = """
                            DELETE direcciones
                            FROM direcciones
                            WHERE direcciones.iddirecciones = %s
                         """
        valuesDireccion = cliente.getDireccion().getIdDireccion()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryTelefono, valuesTelefono)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryCliente, valuesCliente)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryPersona, valuesPersona)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)
        self.conexion.db.commit()

        self.conexion.cerrarConexion()
 def __init__(self):
     self.conexion = Conexion()
     self.producto = Producto()
Пример #20
0
class conexionRubro(object):
    def __init__(self):
        self.conexion = Conexion()
        self.__rubro = Rubro()

    def selectRubro(self, filterText):
        query = "SELECT idrubros, descripcion FROM rubros WHERE descripcion LIKE %s"
        parametro = filterText + '%'
        value = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, value)
        listRubro = self.conexion.cursor.fetchall()

        return listRubro
        self.conexion.cerrarConexion()

    def borrarRubro(self, rubro):
        query = "DELETE FROM rubros WHERE idrubros = %s"
        values = rubro.getIdRubro()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def modificarRubro(self, rubro):
        query = "UPDATE rubros SET descripcion = %s WHERE idrubros = %s"
        values = (rubro.getRubro(), rubro.getIdRubro())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarRubro(self, rubro):
        query = "INSERT INTO rubros (descripcion) VALUES (%s)"
        values = rubro.getRubro()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
class conexionCliente(object):
    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()

    def selectCliente(self, typeParameter, parameter, parameterState):
        query = """
                    SELECT cli.idClientes, cli.apellido, p.nombre, p.email, d.direccion, d.numero, d.piso, d.dpto,
                         d.iddirecciones, p.idpersonas, cli.estado
                    FROM clientes cli, personas p, direcciones d
                    WHERE p.idpersonas = cli.personas_idpersonas and d.iddirecciones = p.direcciones_iddirecciones and
                    """ + typeParameter + """ LIKE %s and cli.estado LIKE %s
                """
        paramState = '1'
        if parameterState == 0:
            paramState = '%'

        param = parameter + '%'
        values = (param, paramState)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente

    def selectTelefonoCliente(self, cliente):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, clientes c
                    WHERE p.idpersonas = c.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and c.idClientes = %s"""
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarCliente(self, cliente):

        query = """UPDATE personas p, clientes c, direcciones d
                    SET p.nombre = %s , p.email= %s , c.apellido = %s, d.direccion= %s, d.numero = %s, d.piso = %s, d.dpto = %s, c.estado = %s
                    WHERE p.idpersonas = c.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and c.idClientes = %s"""
        values = (cliente.getNombre(), cliente.getEmail(),
                  cliente.getApellido(), cliente.getDireccion().getDireccion(),
                  cliente.getDireccion().getNumero(),
                  cliente.getDireccion().getPiso(),
                  cliente.getDireccion().getDpto(), cliente.getEstado(),
                  cliente.getIdCliente())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarCliente(self, cliente):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"

        valuesDireccion = (cliente.getDireccion().getDireccion(),
                           cliente.getDireccion().getNumero(),
                           cliente.getDireccion().getPiso(),
                           cliente.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (cliente.getNombre(), cliente.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryCliente = "INSERT INTO clientes (personas_idpersonas, apellido, estado) VALUES (LAST_INSERT_ID(), %s, %s)"
        valuesCliente = (cliente.getApellido(), cliente.getEstado())
        self.conexion.cursor.execute(queryCliente, valuesCliente)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarCliente(self, cliente):
        queryCliente = """
                            UPDATE clientes
                            SET estado = 0
                            WHERE idClientes = %s
                       """
        valuesCliente = cliente.getIdCliente()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryCliente, valuesCliente)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
 def __init__(self):
     self.conexion = Conexion()
     self.producto = Producto()
 def __init__(self):
     self.conexion = Conexion()
     self.cliente = Cliente()
Пример #24
0
class conexionMarca(object):


    def __init__(self):
        self.conexion = Conexion()
        self.__marca = Marca()
        
        
    def selectMarca(self):
        query = "SELECT idmarcas, descripcion FROM marcas"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listMarca = self.conexion.cursor.fetchall()

        return listMarca
        self.conexion.cerrarConexion()

    
    def borrarMarca(self, marca):
        query = "DELETE FROM marcas WHERE idmarcas= %s "
        values = marca.getIdMarca()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def modificarMarca(self, marca):
        query = "UPDATE marcas SET descripcion= %s WHERE idmarcas= %s"
        values = (marca.getMarca(),marca.getIdMarca())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
        
    def insertMarca(self, marca):
        query = "INSERT INTO marcas (descripcion) VALUES (%s)"
        values = marca.getMarca()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrar_conexion()
Пример #25
0
class ConexionGenerales(object):
    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()
        proveedor = Proveedor()
        cliente = Cliente()

    def selectProductoStock(self):

        query = """
                   SELECT idproductos, nombre, cantidad, cant_minima
                   FROM productos
                   WHERE estado = 1 and cantidad BETWEEN 0 and cant_minima
               """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProductos = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProductos

    def changeStateProduct(self, producto):
        query = """
                    UPDATE productos
                    SET estado = '0'
                    WHERE idproductos = %s
               """
        values = producto.getIdProducto()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def selectVentasMensuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY month(m.fecha)
                """
        self.conexion.abrirConexion()

        self.conexion.cursor.execute(query)
        listVentasMes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentasMes

    def selectComprasMensuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY month(m.fecha)
                """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listComprasMes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listComprasMes

    def selectVentasAnuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY year(m.fecha)
                """
        self.conexion.abrirConexion()

        self.conexion.cursor.execute(query)

        listVentasAnuales = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentasAnuales

    def selectComprasAnuales(self):
        query = """
                    SELECT m.fecha , CAST(SUM(dm.cantidad) AS CHAR)
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento
                    GROUP BY year(m.fecha)
                """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listComprasAnuales = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listComprasAnuales

    def selectVentas(self, intervalo, desde, hasta):
        query = """
                    SELECT CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR)) AS fecha,
                           CAST(SUM(dm.cantidad) AS CHAR) as cantidad
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                          m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
						  m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listVentas = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listVentas

    def selectCompras(self, intervalo, desde, hasta):
        query = """
                    SELECT CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR)) AS fecha,
                           CAST(SUM(dm.cantidad) AS CHAR) as cantidad
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                          m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
                          m.idmovimiento = dm.movimiento_idmovimiento and
						  m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCompras = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listCompras

    def selectProveedor(self, parameter):
        query = """
                    SELECT prov.idproveedores, prov.descripcion, p.nombre
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas and
                    prov.descripcion LIKE %s
               """
        param = parameter + '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedor = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProveedor

    def selectCliente(self, parameter):
        query = """
                    SELECT cli.idClientes, cli.apellido, p.nombre
                    FROM clientes cli, personas p
                    WHERE p.idpersonas = cli.personas_idpersonas and
                            cli.apellido LIKE %s
                """
        param = parameter + '%'
        values = param
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listCliente = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listCliente

    def selectListPagosProveedor(self, proveedor, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(p.fecha) AS CHAR))"""
        query = """
                    SELECT """ + selectFecha + """ AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        prov.idproveedores = %s and
	                    p.fecha between %s and %s
                    GROUP BY """ + intervalo + """(p.fecha)
					ORDER BY p.fecha
                """
        values = (proveedor.getIdProveedor(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionProveedor(self, proveedor, intervalo, desde,
                                       hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR))"""
        query = """
                    SELECT """ + selectFecha + """ AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        prov.idproveedores = % s and
	                    m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (proveedor.getIdProveedor(), desde, hasta)

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectListPagosCliente(self, cliente, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(p.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha, SUM(p.monto), tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        c.idclientes = %s and
	                    p.fecha between %s and %s
                    GROUP BY """ + intervalo + """(p.fecha)
					ORDER BY p.fecha
                """
        values = (cliente.getIdCliente(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionCliente(self, cliente, intervalo, desde, hasta):

        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        c.idclientes = %s and
	                    m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (cliente.getIdCliente(), desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectEntradasTransacciones(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 1 and
	                    m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listEntradaTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listEntradaTransacciones

    def selectSalidaTransacciones(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "m.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(m.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(m.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha,
                    SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 1 and
	                    m.fecha between %s and %s
                    GROUP BY """ + intervalo + """(m.fecha)
					ORDER BY m.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listSalidaTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listSalidaTransacciones

    def selectEntradaPagos(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(p.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
	                    p.fecha between %s and %s
                    GROUP BY """ + intervalo + """(p.fecha)
					ORDER BY p.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listEntradaPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listEntradaPagos

    def selectSalidaPagos(self, intervalo, desde, hasta):
        selectFecha = ''
        if intervalo == 'day':
            selectFecha = "p.fecha"
        else:
            selectFecha = """CONCAT(CAST(year(p.fecha) AS CHAR) ,"-", CAST(""" + intervalo + """(p.fecha) AS CHAR))"""

        query = """
                    SELECT """ + selectFecha + """ AS fecha , SUM(p.monto), tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
	                    p.fecha between %s and %s
                    GROUP BY """ + intervalo + """(p.fecha)
					ORDER BY p.fecha
                """
        values = (desde, hasta)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listSalidaPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listSalidaPagos
class conexionRubro(object):

    def __init__(self):
        self.conexion = Conexion()
        self.__rubro = Rubro()

    def selectRubro(self, filterText):
        query = "SELECT idrubros, descripcion FROM rubros WHERE descripcion LIKE %s"
        parametro = filterText + '%'
        value = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, value)
        listRubro = self.conexion.cursor.fetchall()

        return listRubro
        self.conexion.cerrarConexion()


    def borrarRubro(self, rubro):
        query = "DELETE FROM rubros WHERE idrubros = %s"
        values = rubro.getIdRubro()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()


    def modificarRubro(self, rubro):
        query = "UPDATE rubros SET descripcion = %s WHERE idrubros = %s"
        values = (rubro.getRubro(), rubro.getIdRubro())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()


    def insertarRubro(self, rubro):
        query = "INSERT INTO rubros (descripcion) VALUES (%s)"
        values = rubro.getRubro()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
Пример #27
0
class conexionUsuario(object):
    def __init__(self):
        self.conexion = Conexion()
        self.usuario = Usuario()

    def selectUsuario(self):
        query = """
                    SELECT u.idusuarios, p.nombre, u.apellido, u.usuario, u.tipo, u.contraseña, p.email, d.direccion,
                            d.numero, d.piso, d.dpto, d.iddirecciones, p.idpersonas
                    FROM usuarios u , personas p, direcciones d
                    WHERE p.idpersonas = u.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listUsuario = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listUsuario

    def selectTelefonoUsuario(self, usuario):
        query = """
                    SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, usuarios u",
                    WHERE p.idpersonas = u.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and usuarios.idusuarios = %s
                """
        values = usuario.getIdUsuario()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarUsuario(self, usuario):
        query = """
                    UPDATE personas p, usuarios u, direcciones d
                    SET p.nombre = % , p.email= %s, u.apellido = %s, u.usuario = %s,
                        u.tipo = %s, u.contraseña = %s, d.direccion = %s, d.numero = %s, d.piso = %s, d.dpto = %s
                    WHERE p.idpersonas = u.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                        and u.idusuarios = %s
                """
        values = (usuario.getNombre(),
                  usuario.getEmail(), usuario.getApellido(),
                  usuario.getUsuario(), usuario.getTipoUsuario(),
                  usuario.getPasswd(), usuario.getDireccion().getDireccion(),
                  usuario.getDireccion().getNumero(),
                  usuario.getDireccion().getPiso(),
                  usuario.getDireccion().getDpto(), usuario.getIdUsuario())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarUsuario(self, usuario):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"
        valuesDireccion = (usuario.getDireccion().getDireccion(),
                           usuario.getDireccion().getNumero(),
                           usuario.getDireccion().getPiso(),
                           usuario.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (usuario.getNombre(), usuario.getEmail())
        self.conexion.cursor.execute(queryPersona, valuesPersona)

        queryUsuario = """INSERT INTO usuarios (tipo, personas_idpersonas, contraseña, usuario, apellido)
                        VALUES ( %s , LAST_INSERT_ID() , %s , %s , %s )"""
        valuesUsuario = (usuario.getTipoUsuario(), usuario.getPasswd(),
                         usuario.getUsuario(), usuario.getApellido())
        self.conexion.cursor.execute(queryUsuario, valuesUsuario)

        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarUsuario(self, usuario):
        queryTelefono = """
                            DELETE telefonos
                            FROM telefonos
                            WHERE telefonos.personas_idpersonas = %s
                        """
        valuesTelefono = usuario.getIdPersona()

        queryUsuario = """
                            DELETE usuarios
                            FROM usuarios
                            WHERE usuarios.idusuarios = %s
                       """

        valuesUsuario = usuario.getIdUsuario()

        queryPersona = """
                            DELETE personas
                            FROM personas
                            WHERE personas.idpersonas = %s
                       """

        valuesPersona = usuario.getIdPersona()

        queryDireccion = """
                            DELETE direcciones
                            FROM direcciones
                            WHERE direcciones.iddirecciones = %s
                         """

        valuesDireccion = usuario.getDireccion().getIdDireccion()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryTelefono, valuesTelefono)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryUsuario, valuesUsuario)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryPersona, valuesPersona)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)
        self.conexion.db.commit()

        self.conexion.cerrarConexion()

    def validarUsuario(self, usuario):
        query = "SELECT usuario, tipo FROM usuarios WHERE usuario= %s and contraseña = %s"
        values = (usuario.getUsuario(), usuario.getPasswd())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        auxUsuario = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return auxUsuario
class conexionProveedor(object):
    def __init__(self):
        self.conexion = Conexion()
        self.proveedor = Proveedor()

    def selectProveedor(self):
        query = """SELECT prov.idproveedores, prov.descripcion, p.nombre, p.email, prov.web, d.direccion, d.numero,
                        d.piso, d.dpto, p.idpersonas, d.iddirecciones
                    FROM proveedores prov, personas p, direcciones d
                    WHERE p.direcciones_iddirecciones = d.iddirecciones and p.idpersonas = prov.personas_idpersonas"""
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedor = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProveedor

    def selectTelefonoProveedor(self, proveedor):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, proveedores prov
                    WHERE p.idpersonas = prov.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and prov.idproveedores = %s"""
        value = proveedor.getIdProveedor()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarProveedor(self, proveedor):
        query = """
                    UPDATE personas p, proveedores prov, direcciones d
                    SET p.nombre = %s , p.email= %s , prov.descripcion = %s, prov.web = %s, d.direccion= %s,
                            d.numero = %s, d.piso = %s, d.dpto = %s
                    WHERE p.idpersonas = prov.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and prov.idproveedores = %s
                """
        values = (proveedor.getNombre(), proveedor.getEmail(),
                  proveedor.getDescripcion(), proveedor.getWeb(),
                  proveedor.getDireccion().getDireccion(),
                  proveedor.getDireccion().getNumero(),
                  proveedor.getDireccion().getPiso(),
                  proveedor.getDireccion().getDpto(),
                  proveedor.getIdProveedor())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarProveedor(self, proveedor):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"
        valuesDireccion = (proveedor.getDireccion().getDireccion(),
                           proveedor.getDireccion().getNumero(),
                           proveedor.getDireccion().getPiso(),
                           proveedor.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (proveedor.getNombre(), proveedor.getEmail())

        self.conexion.cursor.execute(queryPersona, valuesPersona)
        query1 = "INSERT INTO proveedores (personas_idpersonas, descripcion, web) VALUES (LAST_INSERT_ID(), %s, %s)"
        values1 = (proveedor.getDescripcion(), proveedor.getWeb())
        self.conexion.cursor.execute(query1, values1)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def borrarProveedor(self, proveedor):
        queryTelefono = """
                            DELETE telefonos
                            FROM telefonos, personas, proveedores
                            WHERE proveedores.personas_idpersonas = personas.idpersonas and
                                personas.idpersonas = telefonos.personas_idpersonas and idproveedores= %s
                        """
        valuesTelefono = proveedor.getIdProveedor()

        queryProveedores = """
                            DELETE FROM proveedores
                            WHERE proveedores.idproveedores = %s
                           """
        valuesProveedor = proveedor.getIdProveedor()

        queryPersona = """
                            DELETE personas
                            FROM personas
                            WHERE personas.idpersonas = %s
                       """
        valuesPersona = proveedor.getIdPersona()

        queryDireccion = """
                            DELETE direcciones
                            FROM direcciones
                            WHERE direcciones.iddirecciones = %s
                         """
        valuesDireccion = proveedor.getDireccion().getIdDireccion()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryTelefono, valuesTelefono)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryProveedores, valuesProveedor)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryPersona, valuesPersona)
        self.conexion.db.commit()
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)
        self.conexion.db.commit()

        self.conexion.cerrarConexion()
Пример #29
0
 def __init__(self):
     self.conexion = Conexion()
     self.usuario = Usuario()
 def __init__(self):
     self.conexion = Conexion()
     self.cliente = Cliente()
     self.proveedor = Proveedor()
class conexionProveedor(object):


    def __init__(self):
        self.conexion = Conexion()
        self.proveedor = Proveedor()

    def selectProveedor(self, typeParameter, parameter, parameterState):
        query ="""
                    SELECT prov.idproveedores, prov.descripcion, p.nombre, p.email, prov.web, d.direccion, d.numero,
                        d.piso, d.dpto, p.idpersonas, d.iddirecciones, prov.estado
                    FROM proveedores prov, personas p, direcciones d
                    WHERE p.direcciones_iddirecciones = d.iddirecciones and p.idpersonas = prov.personas_idpersonas and
                    """ + typeParameter + """ LIKE %s and prov.estado LIKE %s
               """
        param = parameter + '%'

        paramState = '1'
        if parameterState == 0:
            paramState = '%'

        values = (param, paramState)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedor = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProveedor

    def selectTelefonoProveedor(self, proveedor):
        query = """SELECT t.idtelefono, t.numero, t.tipo
                    FROM telefonos t, personas p, proveedores prov
                    WHERE p.idpersonas = prov.personas_idpersonas and p.idpersonas = t.personas_idpersonas
                    and prov.idproveedores = %s"""
        value = proveedor.getIdProveedor()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarProveedor(self, proveedor):
        query = """
                    UPDATE personas p, proveedores prov, direcciones d
                    SET p.nombre = %s , p.email= %s , prov.descripcion = %s, prov.web = %s, d.direccion= %s,
                            d.numero = %s, d.piso = %s, d.dpto = %s, prov.estado = %s
                    WHERE p.idpersonas = prov.personas_idpersonas and p.direcciones_iddirecciones = d.iddirecciones
                            and prov.idproveedores = %s
                """
        values = (proveedor.getNombre(), proveedor.getEmail(), proveedor.getDescripcion(),
                    proveedor.getWeb(), proveedor.getDireccion().getDireccion(), proveedor.getDireccion().getNumero(),
                    proveedor.getDireccion().getPiso(), proveedor.getDireccion().getDpto(), proveedor.getEstado(),
                    proveedor.getIdProveedor()
        )
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarProveedor(self, proveedor):
        self.conexion.abrirConexion()

        queryDireccion = "INSERT INTO direcciones (direccion, numero, piso, dpto) VALUES (%s, %s, %s, %s)"
        valuesDireccion = (proveedor.getDireccion().getDireccion(), proveedor.getDireccion().getNumero(),
                            proveedor.getDireccion().getPiso(), proveedor.getDireccion().getDpto())
        self.conexion.cursor.execute(queryDireccion, valuesDireccion)

        queryPersona = "INSERT INTO personas (nombre, email, direcciones_iddirecciones) VALUES (%s, %s, LAST_INSERT_ID())"
        valuesPersona = (proveedor.getNombre(), proveedor.getEmail())

        self.conexion.cursor.execute(queryPersona, valuesPersona)
        query1 = "INSERT INTO proveedores (personas_idpersonas, descripcion, web, estado) VALUES (LAST_INSERT_ID(), %s, %s, %s)"
        values1 = (proveedor.getDescripcion(), proveedor.getWeb(), proveedor.getEstado())
        self.conexion.cursor.execute(query1, values1)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()


    def borrarProveedor(self, proveedor):
        queryProveedores = """
                            UPDATE proveedores
                            SET estado = 0
                            WHERE proveedores.idproveedores = %s
                           """
        valuesProveedor = proveedor.getIdProveedor()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryProveedores, valuesProveedor)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
 def __init__(self):
     self.conexion = Conexion()
     self.producto = Producto()
     self.proveedor = Proveedor()
     self.rubro = Rubro()
     self.marca = Marca()
Пример #33
0
class ConexionList():

    def __init__(self):
        self.conexion = Conexion()



    def selectClientesTransacciones(self):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, SUM(dm.precio_unitario * dm.cantidad ) as monto
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm, personas p
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and
                        m.estado = 0 and
                        p.idpersonas = c.personas_idpersonas
                    GROUP BY tm.clientes_idclientes
                    ORDER BY monto desc
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes


    def selectClientesPagos(self):
        query = """
                    SELECT c.idclientes, SUM(p.monto)
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento
                    GROUP BY c.idclientes
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes


    def selectProveedoresTransacciones(self):
        query = """
                    SELECT prov.idproveedores, prov.descripcion, p.nombre, SUM(dm.precio_unitario * dm.cantidad ) as monto
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm, personas p
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and
                        m.estado = 0 and
                        p.idpersonas = prov.personas_idpersonas
                    GROUP BY tm.proveedores_idproveedores
                    ORDER BY monto desc
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedores = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listProveedores

    def selectProveedoresPagos(self):
        query = """
                    SELECT prov.idproveedores, SUM(p.monto)
                    FROM  proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento
                    GROUP BY prov.idproveedores
                """

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedores = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listProveedores
class conexionProducto(object):
    def __init__(self):
        self.conexion = Conexion()
        self.producto = Producto()
        self.proveedor = Proveedor()
        self.rubro = Rubro()
        self.marca = Marca()

    def selectProducto(self):
        query = """
                    SELECT p.idproductos, p.nombre, p.descripcion, p.pCompra, p.pVenta, p.genero, p.estado, p.cantidad,
                            p.cant_minima, m.idmarcas, m.descripcion, r.idrubros, r.descripcion,
                            prov.idproveedores, prov.descripcion
                    FROM productos p, marcas m , rubros r, proveedores prov
                    WHERE p.rubros_idrubros = r.idrubros and p.marcas_idmarcas = m.idmarcas and
                        p.proveedores_idproveedores = prov.idproveedores
                """
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProducto = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listProducto

    def modificarProducto(self, producto):
        query = """
                    UPDATE productos
                    SET nombre= %s, cantidad= %s, descripcion= %s, rubros_idrubros= %s, proveedores_idproveedores=%s,
                        marcas_idmarcas= %s, pCompra= %s, pVenta= %s, estado= %s, cant_minima= %s, genero= %s
                    WHERE idproductos= %s
                """
        idRubro = self.getIdRubro(producto.getRubro().getRubro())
        idMarca = self.getIdMarca(producto.getMarca().getMarca())
        idProveedor = self.getIdProveedor(
            producto.getProveedor().getDescripcion())
        values = (producto.getNombre(), producto.getCantidad(),
                  producto.getDescripcion(), idRubro, idProveedor, idMarca,
                  producto.getPrecioCompra(), producto.getPrecioVenta(),
                  producto.getEstado(), producto.getCantidadMinima(),
                  producto.getGenero(), producto.getIdProducto())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarProducto(self, producto):
        query = """
                    INSERT INTO productos (nombre, cantidad, descripcion, rubros_idrubros,
                        proveedores_idproveedores, marcas_idmarcas, pCompra, pVenta, estado,
                        cant_minima, genero)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
                """
        idRubro = self.getIdRubro(producto.getRubro().getRubro())
        idMarca = self.getIdMarca(producto.getMarca().getMarca())
        idProveedor = self.getIdProveedor(
            producto.getProveedor().getDescripcion())
        values = (producto.getNombre(), producto.getCantidad(),
                  producto.getDescripcion(), idRubro, idProveedor, idMarca,
                  producto.getPrecioCompra(), producto.getPrecioVenta(),
                  producto.getEstado(), producto.getCantidadMinima(),
                  producto.getGenero())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        print(self.conexion.cursor._check_executed())
        print(self.conexion.cursor.messages)

        self.conexion.cerrarConexion()

    def borrarProducto(self, producto):
        query = """
                    UPDATE productos
                    SET estado = 0
                    WHERE idproductos = %s
                """
        values = producto.getIdProducto()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.cerrarConexion()

    def listMarcas(self):
        query = "SELECT descripcion FROM marcas"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listMarcasaux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listMarcas = []
        listMarcas.append('')
        for marca in listMarcasaux:
            listMarcas.append(marca[0])

        return listMarcas

    def listRubro(self):
        query = "SELECT descripcion FROM rubros"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listRubrosaux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listRubros = []
        listRubros.append('')
        for rubro in listRubrosaux:
            listRubros.append(rubro[0])

        return listRubros

    def listProveedor(self):
        query = "SELECT descripcion FROM proveedores"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listProveedoraux = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        listProveedores = []
        listProveedores.append('')
        for proveedor in listProveedoraux:
            listProveedores.append(proveedor[0])

        return listProveedores

    def getIdProveedor(self, proveedor):
        query = "SELECT idproveedores FROM proveedores WHERE descripcion = %s"
        values = proveedor
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idProveedor = int(result[0][0])

        return idProveedor

    def getIdMarca(self, marca):
        query = "SELECT idmarcas FROM marcas WHERE descripcion = %s"
        values = marca
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idMarca = int(result[0][0])

        return idMarca

    def getIdRubro(self, rubro):
        query = "SELECT idrubros FROM rubros WHERE descripcion = %s"
        values = rubro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)

        result = self.conexion.cursor.fetchall()

        idRubro = int(result[0][0])

        return idRubro
Пример #35
0
 def __init__(self):
     self.conexion = Conexion()
 def __init__(self):
     self.conexion = Conexion()
     self.usuario = Usuario()
class conexionTelefono(object):


    def __init__(self):
        self.conexion = Conexion()
        self.telefono = Telefono()

    def selectTelefono(self, telefono):
        query ="""
                    SELECT t.idTelefono, t.tipo, t.numero
                    FROM telefonos t, personas p
                    WHERE t.personas_idpersonas = p.idpersonas and p.idpersonas = %s
                """
        values = telefono.getIdPersona()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarTelefono(self, telefono):
        query = """
                    UPDATE telefonos
                    SET numero = %s , tipo = %s
                    WHERE idtelefono= %s;
                """
        values = (telefono.getTelefono(), telefono.getTipo(), telefono.getIdTelefono())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarTelefono(self, telefono):
        query = "INSERT INTO telefonos (numero, tipo, personas_idpersonas) VALUES (%s , %s, %s)"
        values = (telefono.getTelefono(), telefono.getTipo(), telefono.getIdPersona())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()


    def insertTelefonoInit(self, telefonos):
        self.conexion.abrirConexion()

        queryIdPersona = "select MAX(idpersonas) from personas"
        self.conexion.cursor.execute(queryIdPersona)
        result = self.conexion.cursor.fetchall()

        idPersona = int(result[0][0])

        for telefono in telefonos:
            if telefono[2] != '':
                query = "INSERT INTO telefonos (numero, tipo, personas_idpersonas) VALUES (%s , %s, %s)"
                values = (telefono[2], telefono[1], idPersona)
                self.conexion.cursor.execute(query, values)
                self.conexion.db.commit()

        self.conexion.cerrarConexion()


    def borrarTelefono(self, telefono):
        query = """
                    DELETE FROM telefonos
                    WHERE idtelefono= %s
                """
        values =telefono.getIdTelefono()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
Пример #38
0
class ConexionPagos(object):
    def __init__(self):
        self.conexion = Conexion()
        self.cliente = Cliente()
        self.proveedor = Proveedor()

    def selectProveedores(self, tipoParametro, parametro):
        query = """
                    SELECT prov.idproveedores , prov.descripcion, p.nombre, p.email
                    FROM proveedores prov, personas p
                    WHERE p.idpersonas = prov.personas_idpersonas and prov.estado = 1 and
                    """ + tipoParametro + """ LIKE %s
                """
        parametro = parametro + '%'
        values = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listProveedores = self.conexion.cursor.fetchall()

        self.conexion.cerrarConexion()

        return listProveedores

    def selectClientes(self, tipoParametro, parametro):
        query = """
                    SELECT c.idclientes, c.apellido, p.nombre, p.email
                    FROM clientes c, personas p
                    WHERE p.idpersonas = c.personas_idpersonas and c.estado = 1 and
                    """ + tipoParametro + """ LIKE %s
                """
        parametro = parametro + '%'
        values = parametro
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listClientes = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listClientes

    def selectListPagosProveedor(self, proveedor):
        query = """
                    SELECT p.fecha, p.monto, tm.tipo_movimiento
                    FROM proveedores prov, pagos p, tipo_movimiento tm
                    WHERE tm.proveedores_idproveedores = prov.idproveedores and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        prov.idproveedores = %s
                """
        values = proveedor.getIdProveedor()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionProveedor(self, proveedor):
        query = """
                    SELECT m.fecha, SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM proveedores prov, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE prov.idproveedores = tm.proveedores_idproveedores and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        prov.idproveedores = %s
                    GROUP BY m.fecha
                """
        values = proveedor.getIdProveedor()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def selectListPagosCliente(self, cliente):
        query = """
                    SELECT p.fecha, p.monto, tm.tipo_movimiento
                    FROM clientes c, pagos p, tipo_movimiento tm
                    WHERE tm.clientes_idclientes = c.idclientes and
                        p.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        c.idclientes = %s
                """
        values = cliente.getIdCliente()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listPagos = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listPagos

    def selectListTransaccionCliente(self, cliente):
        query = """
                    SELECT m.fecha, SUM(dm.precio_unitario * dm.cantidad) as monto, tm.tipo_movimiento
                    FROM clientes c, movimiento m, tipo_movimiento tm, detalle_movimiento dm
                    WHERE c.idclientes = tm.clientes_idclientes and
                        m.tipo_movimiento_idtipo_movimiento = tm.idtipo_movimiento and
                        m.idmovimiento = dm.movimiento_idmovimiento and m.estado = 0 and
                        c.idclientes = %s
                    GROUP BY m.fecha
                """
        values = cliente.getIdCliente()

        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTransacciones = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()

        return listTransacciones

    def cargarCobranza(self, cliente, monto):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, clientes_idclientes)
                                VALUES ('pago', %s)
                              """
        valuesTipoMovimiento = cliente.getIdCliente()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount
        self.conexion.cerrarConexion()

        queryPagos = """
                            INSERT INTO pagos (fecha, monto, tipo_movimiento_idtipo_movimiento)
                            VALUES (%s, %s, %s);

                          """
        valuesPagos = (hoy, monto, idTipoMovimiento)
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(queryPagos, valuesPagos)
        self.conexion.db.commit()
        idRecibo = self.conexion.cursor.lastrowid
        self.conexion.cerrarConexion()

        return idRecibo

    def cargarPago(self, proveedor, monto):
        hoy = datetime.datetime.now().date()

        self.conexion.abrirConexion()

        queryTipoMovimiento = """
                                INSERT INTO tipo_movimiento (tipo_movimiento, proveedores_idproveedores)
                                VALUES ('pago', %s)
                              """
        valuesTipoMovimiento = proveedor.getIdProveedor()

        self.conexion.cursor.execute(queryTipoMovimiento, valuesTipoMovimiento)
        self.conexion.db.commit()
        idTipoMovimiento = self.conexion.cursor.lastrowid
        cantRowAffect = self.conexion.cursor.rowcount

        queryPagos = """
                            INSERT INTO pagos (fecha, monto, tipo_movimiento_idtipo_movimiento)
                            VALUES (%s, %s, %s);

                          """
        valuesPagos = (hoy, monto, idTipoMovimiento)

        self.conexion.cursor.execute(queryPagos, valuesPagos)
        self.conexion.db.commit()
        idRecibo = self.conexion.cursor.lastrowid
        self.conexion.cerrarConexion()

        return idRecibo
 def __init__(self):
     self.conexion = Conexion()
     self.telefono = Telefono()
Пример #40
0
 def __init__(self):
     self.connection = Conexion()
     self.connectionCliente = conexionCliente(self.connection)
class conexionTelefono(object):
    def __init__(self):
        self.conexion = Conexion()
        self.telefono = Telefono()

    def selectTelefono(self, telefono):
        query = """
                    SELECT t.idTelefono, t.tipo, t.numero
                    FROM telefonos t, personas p
                    WHERE t.personas_idpersonas = p.idpersonas and p.idpersonas = %s
                """
        values = telefono.getIdPersona()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        listTelefono = self.conexion.cursor.fetchall()
        self.conexion.cerrarConexion()
        return listTelefono

    def modificarTelefono(self, telefono):
        query = """
                    UPDATE telefonos
                    SET numero = %s , tipo = %s
                    WHERE idtelefono= %s;
                """
        values = (telefono.getTelefono(), telefono.getTipo(),
                  telefono.getIdTelefono())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertarTelefono(self, telefono):
        query = "INSERT INTO telefonos (numero, tipo, personas_idpersonas) VALUES (%s , %s, %s)"
        values = (telefono.getTelefono(), telefono.getTipo(),
                  telefono.getIdPersona())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertTelefonoInit(self, telefonos):
        self.conexion.abrirConexion()

        queryIdPersona = "select MAX(idpersonas) from personas"
        self.conexion.cursor.execute(queryIdPersona)
        result = self.conexion.cursor.fetchall()

        idPersona = int(result[0][0])

        for telefono in telefonos:
            if telefono[2] != '':
                query = "INSERT INTO telefonos (numero, tipo, personas_idpersonas) VALUES (%s , %s, %s)"
                values = (telefono[2], telefono[1], idPersona)
                self.conexion.cursor.execute(query, values)
                self.conexion.db.commit()

        self.conexion.cerrarConexion()

    def borrarTelefono(self, telefono):
        query = """
                    DELETE FROM telefonos
                    WHERE idtelefono= %s
                """
        values = telefono.getIdTelefono()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()
Пример #42
0
 def __init__(self):
     self.conexion = Conexion()
     self.__rubro = Rubro()
 def __init__(self):
     self.conexion = Conexion()
     self.telefono = Telefono()
 def __init__(self):
    self.conexion = Conexion()
    self.cliente = Cliente()
class conexionMarca(object):
    def __init__(self):
        self.conexion = Conexion()
        self.__marca = Marca()

    def selectMarca(self):
        query = "SELECT idmarcas, descripcion FROM marcas"
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query)
        listMarca = self.conexion.cursor.fetchall()

        return listMarca
        self.conexion.cerrarConexion()

    def borrarMarca(self, marca):
        query = "DELETE FROM marcas WHERE idmarcas= %s "
        values = marca.getIdMarca()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def modificarMarca(self, marca):
        query = "UPDATE marcas SET descripcion= %s WHERE idmarcas= %s"
        values = (marca.getMarca(), marca.getIdMarca())
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrarConexion()

    def insertMarca(self, marca):
        query = "INSERT INTO marcas (descripcion) VALUES (%s)"
        values = marca.getMarca()
        self.conexion.abrirConexion()
        self.conexion.cursor.execute(query, values)
        self.conexion.db.commit()
        self.conexion.cerrar_conexion()