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()
def __init__(self):
self.conexion = Conexion()
self.__marca = Marca()
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
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()
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()
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()
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()
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()
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()
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
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()
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()
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()
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()
