def get_clientes_provincia() -> list:
"""
Genera una lista de provincias con el numero de clientes que hay por cada una
:return: lista de Clientes filtrados por provincia
:rtype: list
"""
provincias = []
conn = GenericDao.connect()
sql = "SELECT cliente_provincia, count(cliente_provincia) FROM clientes GROUP BY cliente_provincia"
cursor = conn.execute(sql)
for row in cursor:
fila = row[0] + " - Nº clientes: " + str(row[1])
provincias.append(fila)
conn.close()
return provincias
def remove_id(idd: int) -> bool:
"""
Elimina un cliente de la base de datos en por su id
:param idd: id del cliente a eliminar
:type idd: int
:return: True si fue eliminado
:rtype: bool
"""
conn = GenericDao.connect()
cursor = conn.execute("DELETE FROM clientes where cliente_id = ?",
(str(idd), ))
conn.commit()
conn.close()
if debug:
print('Cliente eliminado: ' + str(cursor.rowcount))
return cursor.rowcount > 0
def remove_id(idd: int) -> bool:
"""
Elimina una categoria de la base de datos por su id
:param idd: id de la categoria a eliminar
:type idd: int
:return: True si fue eliminada
:rtype: bool
"""
conn = GenericDao.connect()
cursor = conn.execute("DELETE FROM categorias where categoria_id = ?",
(str(idd), ))
conn.commit()
conn.close()
if debug:
print('Categoria eliminada: ' + str(cursor.rowcount))
return cursor.rowcount > 0
def get_all() -> list:
"""
Obtiene una lista con todos los productos existentes en la base de datos
:return: lista de Productos
:rtype: list
"""
productos = []
conn = GenericDao.connect()
cursor = conn.execute("SELECT * FROM productos")
for row in cursor:
producto = Producto(row[1], row[2], row[3], row[4], row[0])
productos.append(producto)
if debug:
print(str(producto))
conn.close()
return productos
def get_all() -> list:
"""
Obtiene una lista con todos las categorias existentes en la base de datos
:return: lista de categorias
:rtype: list
"""
categorias = []
conn = GenericDao.connect()
cursor = conn.execute("SELECT * FROM categorias")
for row in cursor:
categoria = Categoria(row[1], row[0])
categorias.append(categoria)
if debug:
print(str(categoria))
conn.close()
return categorias
def get_id(idd: int) -> Cliente:
"""
Busca 1 cliente en la base de datos proporcionando el id
:param idd: id del cliente
:type idd: int
:return: Cliente, si existe
:rtype: Cliente
"""
conn = GenericDao.connect()
cursor = conn.execute("SELECT * FROM clientes where cliente_id = ?",
(str(idd), ))
row = cursor.fetchone()
cliente = Cliente(row[1], row[2], row[3], row[4], row[5], row[6], row[0])
if debug:
print(str(cliente))
conn.close()
return cliente
def get_all() -> list:
"""
Obtiene una lista con todos los clientes existentes en la base de datos
:return: lista de Clientes
:rtype: list
"""
clientes = []
conn = GenericDao.connect()
cursor = conn.execute("SELECT * FROM clientes")
for row in cursor:
cliente = Cliente(row[1], row[2], row[3], row[4], row[5], row[6],
row[0])
clientes.append(cliente)
if debug:
print(str(cliente))
conn.close()
return clientes
def get_id(idd: int) -> Categoria:
"""
Busca 1 categoria en la base de datos proporcionando el id
:param idd: id de categoria
:type idd: int
:return: Categoria, si existe en la base de datos
:rtype: Categoria
"""
conn = GenericDao.connect()
cursor = conn.execute('SELECT * FROM categorias where categoria_id = ?',
(str(idd), ))
row = cursor.fetchone()
categoria = Categoria(row[1], row[0])
if debug:
print(str(categoria))
conn.close()
return categoria
def get_id(idd: int) -> Producto:
"""
Busca 1 producto en la base de datos proporcionando el id
:param idd: id del cliente
:type idd: int
:return: Producto, si existe
:rtype: Producto
"""
conn = GenericDao.connect()
cursor = conn.execute("SELECT * FROM productos where producto_id = ?",
(str(idd), ))
row = cursor.fetchone()
producto = Producto(row[1], row[2], row[3], row[4], row[0])
if debug:
print(str(producto))
conn.close()
return producto
def get_productos_stock(stock: int) -> list:
"""
Genera una lista con todos los poductos con stock inferior o igual a lo indicado
:param stock: stock
:type stock: int
:return: lista de Productos filtrados por stock
:rtype: list<Producto>
"""
productos = []
conn = GenericDao.connect()
sql = 'SELECT * FROM productos where producto_stock <=' + str(stock)
cursor = conn.execute(sql)
for row in cursor:
producto = Producto(row[1], row[2], row[3], row[4], row[0])
productos.append(producto)
if debug:
print(str(producto))
conn.close()
return productos
def get_id_nombre(categoria_nombre: str) -> str:
"""
Busca el id de 1 categoria en la base de datos proporcionando el nombre
:param categoria_nombre: nombre de categoria
:type categoria: str
:return: Categoria, si existe en la base de datos
:rtype: Categoria
"""
conn = GenericDao.connect()
cursor = conn.execute(
'SELECT categoria_id FROM categorias where categoria_nombre=?',
(categoria_nombre, ))
row = cursor.fetchone()
id_categoria = row[0]
if debug:
print(str(id_categoria))
conn.close()
return id_categoria
def update(categoria: Categoria) -> bool:
"""
Actualiza los datos de un objeto Categoria a la representación en base de datos
:param categoria: categoria a actualizar
:type categoria: Categoria
:return: True si hubo modificaciones
:rtype: bool
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'UPDATE categorias SET categoria_id=?, categoria_nombre=? WHERE categoria_id = ?'
values = (categoria.categoria_id, categoria.categoria_nombre,
categoria.idd)
cursor.execute(sql, values)
conn.commit()
conn.close()
if debug:
print("Categoria actualizada: " + str(categoria))
return cursor.rowcount > 0
def insert(categoria: Categoria) -> int:
"""
Inserta una nueva categoria en la base de datos
:param categoria: categoria a insertar
:type categoria: Categoria
:return: el id generado para la categoria insertada
:rtype: int
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'INSERT INTO categorias(categoria_id) VALUES (?)'
values = (int(categoria.categoria_id), categoria.categoria_nombre)
cursor.execute(sql, values)
conn.commit()
conn.close()
categoria.idd = cursor.lastrowid
if debug:
print("Categoria insertada: " + str(categoria))
return categoria.idd
def update(producto: Producto) -> bool:
"""
Actualiza los datos de un objeto Producto a la representación en base de datos
:param producto: producto a actualizar
:type producto: Producto
:return: True si hubo modificaciones
:rtype: bool
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'UPDATE productos SET producto_id=?, producto_nombre=?, producto_precio=?, producto_stock=?, categoria_id=? WHERE producto_id = ?'
values = (producto.producto_id, producto.producto_nombre,
producto.producto_precio, producto.producto_stock,
producto.producto_categoria, producto.idd)
cursor.execute(sql, values)
conn.commit()
conn.close()
if debug:
print("Producto actualizado: " + str(producto))
return cursor.rowcount > 0
def insert(producto: Producto) -> int:
"""
Inserta un nuevo producto en la base de datos
:param producto: el producto a insertar
:type producto: Producto
:return: el id generado para el producto insertado
:rtype: int
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'INSERT INTO productos(producto_id, producto_nombre, producto_precio, producto_stock, categoria_id) VALUES (?,?,?,?,?)'
values = (None, producto.producto_nombre, producto.producto_precio,
producto.producto_stock, producto.producto_categoria)
cursor.execute(sql, values)
conn.commit()
conn.close()
producto.idd = cursor.lastrowid
if debug:
print("Producto insertado: " + str(producto))
return producto.idd
def update(cliente: Cliente) -> bool:
"""
Actualiza los datos de un objeto Cliente a la representación en base de datos
:param cliente: cliente a actualizar
:type cliente: Cliente
:return: True si hubo modificaciones
:rtype: bool
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'UPDATE clientes SET cliente_id=?, cliente_nombre=?, cliente_apellido_1=?, cliente_apellido_2=?, cliente_documento=?, cliente_edad=?, cliente_provincia=? WHERE cliente_id = ?'
values = (cliente.cliente_id, cliente.cliente_nombre,
cliente.cliente_apellido_1, cliente.cliente_apellido_2,
cliente.cliente_documento, cliente.cliente_edad,
cliente.cliente_provincia, cliente.idd)
cursor.execute(sql, values)
conn.commit()
conn.close()
if debug:
print("Cliente actualizado: " + str(cliente))
return cursor.rowcount > 0
def insert(cliente: Cliente) -> int:
"""
Inserta un nuevo cliente en la base de datos
:param cliente: el cliente a insertar
:type cliente: Cliente
:return: el id generado para el cliente insertado
:rtype: int
"""
conn = GenericDao.connect()
cursor = conn.cursor()
sql = 'INSERT INTO clientes(cliente_id, cliente_nombre, cliente_apellido_1, cliente_apellido_2, cliente_documento, cliente_edad, cliente_provincia) VALUES (?,?,?,?,?,?,?)'
values = (None, cliente.cliente_nombre, cliente.cliente_apellido_1,
cliente.cliente_apellido_2, cliente.cliente_documento,
cliente.cliente_edad, cliente.cliente_provincia)
cursor.execute(sql, values)
conn.commit()
conn.close()
cliente.idd = cursor.lastrowid
if debug:
print("Cliente insertado: " + str(cliente))
return cliente.idd