def test_uso_property(self):
producto = Producto()
producto.descripcion = 'acer A515'
producto.precio = 500000
producto.tipo = 'computadoras'
self.assertDictEqual(producto.__dict__, {'_descripcion': 'acer A515',
'_precio': 500000,
'_tipo': 'computadoras'})
def seedearProductos():
session = BaseDeDatos.getInstance()
arroz = Producto('Arroz', 1.25, 1)
session.add(arroz)
print(arroz.id)
agua = Producto('Agua', 0.3, 2)
session.add(agua)
session.commit()
print(agua.id)
def buscar_producto_por_id(self,id):
#id = input('ingresa un id para buscar')
producto = self.file_handler.buscar_registro_por_id(id)
if producto:
product = Producto(*producto)
print("resultado de la busqueda \n :"+product.__str__())
print("\n")
return True
else:
print("no se encontro ningun producto asociado a ese id \n")
return False
def test_update_producto(self, descripcion, precio, tipo):
producto = Producto(descripcion, precio, tipo)
productkey = ProductoService().add_producto(producto)
producto_update = Producto(
descripcion + '_update',
precio,
tipo + '_update')
ProductoService().update_producto(
productkey, producto_update
)
self.assertDictEqual(
Repositorios.productosList[productkey], producto_update.__dict__
)
def agrega_producto(nombre, cantidad, precio, rutaimagen):
"""
Agrega un producto proporcionado por el usuario desde la línea de
comandos. Los atributos obligatorios son NOMBRE, CANTIDAD y PRECIO
y el atributo RUTAIMAGEN es opcional. Si RUTAIMAGE está presente se
hace una copia del archivo indicado a la carpeta DIR_IMAGENES con el
nombre producto-id.ext
"""
# Si ya hay un archivos de productos se lee para determinar el
# siguiente id, de lo contrario el id sería el 1.
if os.path.exists(NA_PRODUCTOS):
lista = obtiene_productos_csv(NA_PRODUCTOS)
id_producto = int(lista[-1].id) + 1
else:
id_producto = 1
# Se procesa la rutaimagen
if rutaimagen:
imagen = "producto-{}{}".format(id_producto,
os.path.splitext(rutaimagen)[1])
guarda_producto_imagen(rutaimagen, DIR_IMAGENES, imagen)
else:
imagen = ""
# Se agrega el producto
producto = Producto(id_producto, nombre, cantidad, precio, imagen)
guarda_producto_csv(producto, NA_PRODUCTOS)
def crear_Producto(self):
print("\n Agregando producto")
descripcion = input('Ingrese descripción: ')
precio = int(input('Ingrese un precio: '))
tipo = input('Ingrese el tipo de producto: ')
return Producto(descripcion, precio, tipo)
def agregar_producto():
nombre = input("Nombre: ")
nombre_categoria = input("Categoria: ")
categoria = buscar_categoria(nombre_categoria)
if categoria is None:
print("La categoria no existe")
return
cantidad = input("Cantidad: ")
nombre_seccion = input("Seccion: ")
# nombre_seccion tiene formato "bodega1-2"
# donde bodega1 es el nombre de la bodega
# y 2 es el numero de seccion
partes = nombre_seccion.split("-")
nombre_bodega = partes[0]
numero_seccion = partes[1]
bodega = buscar_bodega(nombre_bodega)
if bodega is None:
print("No se encontro la bodega")
return
seccion = buscar_seccion(numero_seccion, bodega)
if seccion is None:
print("No se encontro la seccion en la bodega")
return
# La seccion tiene que ser de la misma categoria
# que el producto que se esta agregando
if seccion.get_categoria() != categoria:
print("La categoria de la seccion no concuerda con la del producto.")
return
producto = Producto(nombre, categoria, cantidad, seccion)
lista_productos.append(producto)
def test_precio_valueerror(self, descripcion, precio, tipo, estado):
producto = Producto(descripcion, precio, tipo, estado)
try:
self.assertDictEqual(producto, producto.__dict__)
except Exception:
print('\n\n >>>>>>', producto.__dict__)
print('\n\nError, precio no valido <<<<<<')
def getInfo(codigo, xml):
"""Busca un producto en XML BD.
Busca un producto por su codigo y regresa un objeto de
tipo producto si encuentra el codigo en BD.
Parámetros;
codigo -- Código del producto que se deseá buscar.
xml -- ruta del archivo donde se buscará el producto.
"""
tree = ET.parse(xml) # se accesa al arbol XML
root = tree.getroot() # se obtiene la raíz
childs = root.getchildren() # se obtiene los nodo producto.
i = 0
if codigo != '0':
# Mientras existan productos en el anaquel
# se buscara el código del producto solicitado.
while i < len(childs):
if codigo == childs[i].find('codigoBarras').text:
producto = Producto(childs[i].find('nombre').text,
childs[i].find('precio').text,
childs[i].find('descripcion').text,
childs[i].find('marca').text,
childs[i].find('imagen').get('url'),
childs[i].find('codigoBarras').text)
return producto
i += 1
else:
print("Código no puede ser 0")
return None
return None
def main():
producto = Producto(2033, "Producto Genérico", "1 kg", 50)
alimento = Alimento(2035, "Botella de Aceite de Oliva", "250 ML", 50,
"Marca", "Distribuidor")
adorno = Adorno(2034, "Vaso adornado", "Vaso de porcelana", 34, "De Mesa")
libro = Libro(2036, "Cocina Mediterránea", "Recetas buenas", 75,
"0-123456-78-9", "Autor")
productos = [producto, alimento, adorno]
productos.append(libro)
print("Recorriendo lista de productos:")
for producto in productos:
print(producto.referencia, producto.nombre)
print("Condicional isInstance():")
for producto_r in productos:
if (isinstance(producto_r, Adorno)):
print(producto_r.referencia, producto_r.nombre, producto_r.estilo)
elif (isinstance(producto_r, Alimento)):
print(producto_r.referencia, producto_r.nombre,
producto_r.productor)
elif (isinstance(producto_r, Libro)):
print(producto_r.referencia, producto_r.nombre, producto_r.isbn)
print("Rebajar lista de productos:")
for producto_r in productos:
producto_r.rebajar_producto(10)
print(producto_r)
def cargarCatalogo(self,
nombre,
precio,
precios_cuidados=0,
primera_neceisadad=0):
catalogo = Producto(nombre, precio, precios_cuidados,
primera_neceisadad)
self.catalogo.append(catalogo)
def openFile(filename):
f = open(filename) # O(1)
productos = [] # O(1)
for line in f: # O(K)
productos.append(Producto(line)) # O(1)
f.close() # O(1)
return productos # O(1)
def test_constructor_con_valores_iniciales(self):
producto = Producto("Lenovo 450", 300000, 'computadoras')
self.assertDictEqual(
producto.__dict__, {
'_descripcion': 'Lenovo 450',
'_precio': 300000,
'_tipo': 'computadoras'
})
def producto():
formpro={}
formpro['nombrereal']=input('Nombre: ')
formpro['modelo']=input('Modelo: ')
formpro['descripcion']=input('Descripcion: ')
formpro['precio']=input('Precio: ')
formpro['categoria']=input('Categoria: ')
formpro['almacen']=input('Almacen: ')
formpro['marca']=input('Marca: ')
formpro['edit']="0"
if validator.validar_pro(formpro)=={}:
producto=Producto("",formpro['nombrereal'],formpro['modelo'],formpro['descripcion'],formpro['precio'],formpro['categoria'],formpro['almacen'],formpro['marca'])
producto.save()
print('Producto registrado exitosamente')
else:
print(validator.validar_pro(formpro))
def test_estado_inicial(self):
prod = Producto("Lenovo 450", 300000, 'computadoras')
self.assertDictEqual(
prod.__dict__, {
'_descripcion': 'Lenovo 450',
'_precio': 300000,
'_tipo': 'computadoras',
'_estado': 'disponible'
})
def main():
seleccion = [3, 1, 4]
producto1 = Producto(1, "Botella de Agua", 5, 1.00)
producto2 = Producto(2, "Coca Cola", 10, 1.50)
producto3 = Producto(3, "Papas Fritas", 7, 0.50)
producto4 = Producto(4, "Chifles", 11, 1.25)
producto5 = Producto(5, "Granola", 15, 2.50)
productos = [producto1, producto2, producto3, producto4, producto5]
vm1 = VendingMachine("Maquina Generica")
cargaProductos(vm1, productos)
verProductosDisponibles(vm1)
venta(vm1, seleccion, 20.00)
verProductosDisponibles(vm1)
def test_update_producto(self, productoKey):
# Creamos producto
productoVendido = Producto(
Repositorios.productosList[productoKey]['_descripcion'],
Repositorios.productosList[productoKey]['_precio'],
Repositorios.productosList[productoKey]['_tipo'], "vendido")
ProductoService().update_producto(productoKey)
self.assertDictEqual(Repositorios.productosList[productoKey],
productoVendido.__dict__)
def Edit_Producto():
formProducto={}
formProducto['nombrereal']=input("Ingrese Nombre del producto: ")
formProducto['modelo']=input("Ingrese Modelo: ")
if validator.edit_pro(formProducto)=={}:
user=Producto("",formProducto['nombrereal'],formProducto['modelo'],"","","","","",)
user.select()
a=user.select()
print("ID: "+str(a[0])+" - Producto: "+str(a[1])+" - Modelo: "+str(a[2])+" - Descripcion: "+str(a[3])+" - Precio: "+str(a[4])+" - Categoria: "+ str(a[5])+" - Almacen: "+str(a[6])+" - Marca: "+str(a[7]))
# print(user.select())
print("\n Producto encontrado")
formeditProducto={}
formeditProducto['id']=str(a[0])
formeditProducto['nombrereal']=input('Nombre del Producto: ')
formeditProducto['modelo']=input('Modelo del Producto: ')
formeditProducto['descripcion']=(input('Descripcion del Producto: ').capitalize())
formeditProducto['precio']=input('Precio del Producto: ')
print("-"*35)
validator.listar_categoria()
print("-"*35)
formeditProducto['categoria']=input('Categoria del Producto: ')
print("-"*35)
validator.listar_almacen()
print("-"*35)
formeditProducto['almacen']=input('Almacen del Producto: ')
print("-"*35)
validator.listar_marca()
print("-"*35)
formeditProducto['marca']=input('Marca del Producto: ')
formeditProducto['edit']="1"
if validator.validar_pro(formeditProducto)=={}:
user1=Producto(formeditProducto['id'],formeditProducto['nombrereal'],formeditProducto['modelo'],formeditProducto['descripcion'],formeditProducto['precio'],formeditProducto['categoria'],formeditProducto['almacen'],formeditProducto['marca'])
user1.update()
print('Producto Actualizado exitosamente')
else:
print(validator.validar_pro(formeditProducto))
else:
print(validator.edit_pro(formProducto))
#endregion
def cargar_productos(cls):
# Lectura del archivo
with open('BD/productos_bd.csv', 'r') as csv_example:
reader_csv = csv.reader(csv_example)
for row in reader_csv:
# hacemos la separacion del string
string_producto = ', '.join(row)
arreglo_producto = string_producto.split(';')
producto = Producto(arreglo_producto[0], arreglo_producto[1],
arreglo_producto[2], arreglo_producto[3])
cls.lista_productos.append(producto)
def crearProductosDeHojaExcelReaders(hojaExcel):
listaDeProductos = []
marca = "e-future"
sector = "Readers"
for rowEx in range(1, hojaExcel.nrows):
titulo = str(hojaExcel.cell(rowEx, 1).value)
isbn = str(hojaExcel.cell(rowEx, 0).value)
if (not isbn or not titulo): # Tenemos un espacio vacío o un campo en blanco
continue
area = str(hojaExcel.cell(rowEx, 2).value)
componente = str(hojaExcel.cell(rowEx, 3).value)
descripcion = titulo + " incluye " + componente \
if (componente != "-") else titulo
precio = '$' + str(hojaExcel.cell(rowEx, 5).value)
listaDeProductos.append(Producto(titulo, isbn, precio, marca, area, sector, descripcion))
return listaDeProductos
def crearProductosDeHojaExcelLiteratura(hojaExcel):
listaDeProductos = []
sector = "Literatura"
areaPrevia = ""
for rowEx in range(1, hojaExcel.nrows):
titulo = str(hojaExcel.cell(rowEx, 1).value)
isbn = str(hojaExcel.cell(rowEx, 0).value)
if (not isbn and not titulo): # Tenemos un espacio vacío o un campo en blanco
continue
if (titulo and not isbn):
areaPrevia = titulo
continue
marca = ""
area = areaPrevia
autor = str(hojaExcel.cell(rowEx, 2).value)
descripcion = "La obra de " + titulo + "por" + autor + "." + regresarDescripcionDeLiteratura(area)
precio = '$' + str(hojaExcel.cell(rowEx, 3).value)
listaDeProductos.append(Producto(titulo, isbn, precio, marca, area, sector, descripcion))
return listaDeProductos
def crearProductosDeHojaExcel(hojaExcel):
listaDeProductos = []
descripcionPrevia = ""
for rowEx in range(1, hojaExcel.nrows):
titulo = str(hojaExcel.cell(rowEx, 2).value)
isbn = str(hojaExcel.cell(rowEx, 0).value)
if (not isbn or not titulo): # Tenemos un espacio vacío o un campo en blanco
continue
marca = str(hojaExcel.cell(rowEx, 3).value)
area = str(hojaExcel.cell(rowEx, 4).value)
sector = str(hojaExcel.cell(rowEx, 1).value)
descripcion = str(hojaExcel.cell(rowEx, 5).value)
if not descripcion:
descripcion = descripcionPrevia
else:
descripcionPrevia = descripcion
precio = '$' + str(hojaExcel.cell(rowEx, 6).value)
listaDeProductos.append(Producto(titulo, isbn, precio, marca, area, sector, descripcion))
return listaDeProductos
def on_btAceptar_clicked(self):
descripcion = unicode(self.leDescripcion.text().toUtf8(),'utf-8')
cantidad = self.sbCantidad.value()
precio = self.dsbPrecio.value()
if (descripcion != '') and (precio != 0):
from producto import Producto
#unCodigo, unaDesc, unrecio_costo, unPrecio_venta, UI, unCantidad, unMinimo, unCategori
unProducto = Producto(
u'-',
descripcion,
0,
precio,
False,
0,
0,
None)
self.parent.agregarProductoAVenta(unProducto)
self.close()
def agregaProducto():
if request.method == 'POST':
# se crea un Objeto de tipo Producto
# para poder generar el xml correspondiente a
# un producto y validarlo.
producto = Producto(request.form['nombre'], request.form['precio'],
request.form['descripcion'], request.form['marca'],
request.form['imagen'], request.form['codigo'])
# se crea el archivo xml del producto.
mkXML(producto)
# se valida que el xml corresponda con lo que se
# espera recibir.
if validateXML(productoXML, productoSchema):
addAnaquel(productoXML, xml)
if validateXML(xml, xsd):
return redirect('/')
else:
return render_template(agrega, message='Erro en la petición')
else:
return render_template(agrega)
def importarDatos(self, ruta, actualizar_productos):
'''
Toma los datos leidos del .xls y los inserta en el programa.
'''
try:
datos = ImportXLS().getDataInRows(ruta, 0)[1:]
# PROCEDIMIENTO A SEGUIR EN LA IMPORTACION:
# SI el codigo del producto ya existe, se actualizan los datos con los nuevos
# SI la categoria del producto no existe, se crea y se asocia al producto
i = 0
cant = len(datos)
self.pbProgreso.setMinimum(1)
self.pbProgreso.setMaximum(cant)
for prod in datos:
#unCodigo, unaDesc, unprecio_costo, unPrecio_venta, UI, unCantidad, unMinimo, unCategoria
data_prod = self.parseDataRow(prod)
# si esto es True, para cada codigo de prod ya existente en el programa
# se actualizara con los datos nuevos importados
if self.codigoYaExiste(data_prod[0]):
if actualizar_productos:
self.actualizarDatosDeProducto(data_prod)
else:
unProducto = Producto(*data_prod)
self.almacen.add(unProducto)
i += 1
self.pbProgreso.setValue(i)
# se persisten los datos
self.almacen.flush()
self.almacen.commit()
print 'Importacion terminada con exito...'
self.parent.manager._aiGetAll()
self.parent.manager._aiGenerateIndex()
self.parent.recargarLista()
QtGui.QMessageBox.information(self, "Importar",
u"Importación terminada con éxito.")
except Exception, msg:
print 'Se ha producido un error al intentar importar', msg
QtGui.QMessageBox.information(
self, "Importar",
u"Se ha producido un error al intentar importar.")
def listar_productos(imprimir):
filename = os.path.join(dirname, 'db/productos.txt')
data_productos = open(filename, 'r')
lista_productos = {}
for dp in data_productos:
linea = [x.strip() for x in dp.split(';')]
if len(linea[0]) > 0:
producto = Producto(linea[0], linea[1], linea[2], linea[3])
lista_productos[linea[0]] = producto
data_productos.close()
if imprimir:
for pro in lista_productos.items():
print('Articulo: ' + pro[1].nombre + ' Cantidad: ' +
pro[1].cantidad + ' Valor: ' + pro[1].valor)
else:
return lista_productos
def updateProducto():
if request.method == 'POST':
# Aux como su nombre lo indica es una variable
# auxiliar en caso que el usuario modifique el
# código de barras, con esto se tiene un "registro"
# para posteriormente modificar el producto en el
# anaquel.
aux = productoXML
restAnaquel(aux, xml)
newProdcuto = Producto(request.form['nombre'], request.form['precio'],
request.form['descripcion'],
request.form['marca'], request.form['imagen'],
request.form['codigo'])
mkXML(newProdcuto)
if validateXML(aux, productoSchema):
addAnaquel(aux, xml)
else:
return render_template(indexAux,
message='Error al procesar la petición.')
return redirect('/')
else:
return render_template(indexAux,
message='Error al procesar la petición.')
from orden import Orden
from producto import Producto
p1 = Producto("Banana", 100)
p2 = Producto("melon", 150.50)
l_productos = [p1, p2]
o1 = Orden(l_productos)
print(o1)
p3 = Producto("Manzana", 75.25)
l_productos.append(p3)
print(o1) #Recordar que se trabaja con punteros y està referenciado
#Por lo tanto si modifico algo se modificara en tdos lados
new_pro = Producto("Tomate", 50)
o1.agregar_producto(new_pro)
print(o1)
p4 = Producto("Papa", 300)
p5 = Producto("Durazno", 170)
l2 = [p4, p5]
o2 = Orden(l2)
print(o2) #Vemos que el ID orden funciona OK
print(o2.calcular_total())
from producto import Producto
from orden import Orden
producto1 = Producto("Camisa", 100.00)
producto2 = Producto("Pantalon", 200.00)
producto3 = Producto("Calcetines", 50.00)
productos = [producto1, producto2]
# print(productos)
orden1 = Orden(productos)
print(orden1)
print("Total orden 1: ",orden1.calcular_total())
print("----------------------------")
# Agregamos un nuevo producto a la lista
# productos.append(producto3)
orden2 = Orden(productos)
orden2.agregar_producto(producto3)
# Imprimimos la orden 2
print(orden2)
# Imprimimos el total
print("Total orden 2: ",orden2.calcular_total())
def test_update_producto(self, key, descripcion, precio, tipo):
producto = Producto(descripcion, precio, tipo)
ProductoService().update_producto(key, producto)
self.assertDictEqual(Repositorios.productosList[key],
producto.__dict__)
def ingresarDatos(self):
Producto.ingresarDatos(self)
cant=raw_input("Cantidad en existencia:")
self.cant_existencia=int(cant)
marca=raw_input("Marca del enlatado:")
self.marca=str(marca)
def __init__(self):
Producto.__init__(self)
self.marca=str('')
def imprimirDatos(self):
Producto.imprimirDatos(self)
self.datos+='| Cantidad existente: %s | Marca: %s ' % (self.cant_existencia,self.marca)
print(self.datos)
def imprimirDatos(self):
Producto.imprimirDatos(self)
self.datos+="kilos: %s" % (self.cant_existencia)
print(self.datos)
def __init__(self): Producto.__init__(self)
def ingresarDatos(self):
Producto.ingresarDatos(self)
kilos=float(raw_input("Kilos:"))
self.cant_existencia=kilos
