Beispiel #1
0
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
Beispiel #2
0
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
Beispiel #3
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
Beispiel #4
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
Beispiel #5
0
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
Beispiel #6
0
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
Beispiel #7
0
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
Beispiel #8
0
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
Beispiel #9
0
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
Beispiel #10
0
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
Beispiel #11
0
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
Beispiel #12
0
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
Beispiel #13
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
Beispiel #14
0
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
Beispiel #15
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
Beispiel #16
0
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
Beispiel #17
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