def cell_func(column, cell, model, itr, numcol):
"""
Si la fila corresponde a un parte de producción no verificado,
lo colorea en rojo oscuro, si no, lo hace en verde oscuro.
"""
consumido = model[itr][1]
producido = model[itr][2]
try:
consumido = utils._float(consumido)
producido = utils._float(producido)
if consumido < producido:
if numcol == 1:
color = "red"
elif numcol == 2:
color = "blue"
else:
if numcol == 1:
color = "blue"
else:
color = "red"
except:
color = None
if consumido == 0 or producido == 0:
color = None
cell.set_property("cell-background", "red")
else:
cell.set_property("cell-background", None)
cell.set_property("foreground", color)
def importar_productos(nomarchivo, tarifas, tipos_de_material):
"""
Importa los productos de compra.
Devuelve un diccionario con los IDs del archivo y el objeto
ProductoCompra que le ha correspondido.
"""
f = open(nomarchivo)
#r = csv.reader(f)
r = csv.reader(f, delimiter = ";", lineterminator = "\n")
res = {}
fila_actual = 0
for producto in r:
if fila_actual == 0:
fila_actual += 1
continue
fila_actual += 1
for i in xrange(len(producto)):
c = producto[i]
c = c.strip()
#producto[i] = c.replace("\xd3", "Ó").replace("\xba", "º").replace("\xd1", "Ñ")
producto[i] = c.replace("?", "").replace("%", "")
#id, codigo, precio, descripcion, color, tamanno, cifproveedor, existencias, minimo, preciocosto, ganancia, tarifa1, tarifa2, tarifa3, ean13 = producto
id, codigo, precio, descripcion, color, tamanno, cifproveedor, existencias, minimo, preciocosto, ganancia, tarifa1, tarifa2, tarifa3, ean13 = producto
descripcion = " ".join((descripcion, color, tamanno))
try:
minimo = utils._float(minimo)
except ValueError, msg:
print "Excepción capturada: %s. Valor erróneo para mínimo: %s" % (msg, minimo)
minimo = 0.0
try:
existencias = utils._float(existencias)
except ValueError, msg:
print "Excepción capturada: %s. Valor erróneo para existencias: %s" % (msg, existencias)
existencias = 0.0
def parsear_fraccion(txt):
"""
Devuelve la cantidad de producto compra y unidad que hay que descontar
por cada cantidad de producto venta y unidad (que también se devuelven).
Es necesario que venga la cantidadpc aunque en el registro, en el campo
"unidad" no aparece.
"""
regexp_float = re.compile("-?\d+[\.,]?\d*")
regexp_unidad = re.compile("\w+")
cantidades = regexp_float.findall(txt)
if len(cantidades) == 1:
cantidadpc = cantidades[0]
cantidadpv = '1'
txt = txt.replace(cantidadpc, "")
elif len(cantidades) == 2:
cantidadpc, cantidadpv = cantidades[0:2]
txt = txt.replace(cantidadpc, "")
txt = txt.replace(cantidadpv, "")
else:
cantidadpc = '1'
cantidadpv = '1'
txt = txt.replace("/", "")
unidadpc, unidadpv = regexp_unidad.findall(txt)[0:2]
cantidadpc = utils._float(cantidadpc)
cantidadpv = utils._float(cantidadpv)
return cantidadpc, unidadpc, cantidadpv, unidadpv
def rellenar_tabla(self, facturas):
"""
Rellena el model con los facturas de la consulta.
"""
from formularios.ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
tot = facturas.count()
vpro.mostrar()
model = self.wids['tv_datos'].get_model()
model.clear()
total = 0.0
rows_proveedor = {}
total_facturado = 0.0
for fra in facturas:
vpro.set_valor(total / tot,
"Recuperando facturas... [%d/%d]" % (total, tot))
total += 1
proveedor = fra.proveedor
importe = fra.calcular_importe_total()
total_facturado += importe
vencimientos = sum([vto.importe for vto in fra.vencimientosPago])
pagado = sum([c.importe for c in fra.pagos])
pendiente = importe - pagado
try:
row_proveedor = rows_proveedor[proveedor.puid]
except KeyError:
rows_proveedor[proveedor.puid] = row_proveedor = model.append(
None, (proveedor.nombre,
"",
"",
"0",
"0",
"0",
"0",
proveedor.puid))
model.append(row_proveedor, ("",
fra.numfactura,
utils.str_fecha(fra.fecha),
utils.float2str(importe),
utils.float2str(vencimientos),
utils.float2str(pagado),
utils.float2str(pendiente),
fra.puid))
model[row_proveedor][3] = utils.float2str(
utils._float(model[row_proveedor][3]) + importe)
model[row_proveedor][4] = utils.float2str(
utils._float(model[row_proveedor][4]) + vencimientos)
model[row_proveedor][5] = utils.float2str(
utils._float(model[row_proveedor][5]) + pagado)
model[row_proveedor][6] = utils.float2str(
utils._float(model[row_proveedor][6]) + pendiente)
self.wids['e_facturas'].set_text(str(facturas.count()))
self.wids['e_total'].set_text(utils.float2str(total_facturado))
vpro.ocultar()
def importar_ventas(nomarchivo):
"""
Importa las ventas como tickets.
Devuelve un diccionario de ID de venta y la LDV relacionada.
"""
f = open(nomarchivo)
r = csv.reader(f)
res = {}
fila_actual = 0
for venta in r:
if fila_actual == 0:
fila_actual += 1
continue
fila_actual += 1
for i in xrange(len(venta)):
c = venta[i]
c = c.strip()
venta[i] = c.replace("\xd3", "Ó").replace("\xba", "º").replace("\xd1", "Ñ").replace("\xaa", "ª")
id, numventa, codigo, precioventa, preciocosto, cantidad, bazzura, fecha, impuesto, descripcion = venta
numventas = {}
numventa = int(numventa)
precio = utils._float(precioventa)
cantidad = utils._float(cantidad)
strfecha, strhora = fecha.split()
dia, mes, anno = map(int, strfecha.split("/")); horas, minutos, segundos = map(int, strhora.split(":"))
fecha = mx.DateTime.DateTimeFrom(day = dia, month = mes, year = anno, hour = horas, minute = minutos, second = segundos)
if numventa not in numventas:
numventas[numventa] = pclases.Ticket(fechahora = fecha, numticket = numventa)
PC = pclases.ProductoCompra
productos = PC.select(pclases.OR(pclases.AND(PC.q.codigo.contains(codigo),
PC.q.descripcion.contains(descripcion[:5])),
pclases.AND(PC.q.descripcion.contains(codigo),
PC.q.descripcion.contains(descripcion[:5]))))
if productos.count() == 0:
print "No se encontró el producto con código %s y descripción %s. Ticket %d. Me lo salto." % (codigo, descripcion, numventa)
elif productos.count() > 1:
print "Se econtró más de un producto con código %s y descripción %s. Ticket %d. Me lo salto." % (codigo, descripcion, numventa)
else:
producto = productos[0]
ldv = pclases.LineaDeVenta(productoCompra = producto,
ticket = numventas[numventa],
pedidoVenta = None,
facturaVenta = None,
productoVenta = None,
albaranSalida = None,
fechahora = fecha,
cantidad = cantidad,
precio = precio,
descuento = 0.0)
res[id] = ldv
return res
def cambiar_peso(self, cell, path, texto):
"""
Cambia el peso de la bala editada.
"""
try:
peso = utils._float(texto)
except ValueError:
utils.dialogo_info(titulo = "ERROR",
texto = "El valor tecleado %s no es correcto." % (peso),
padre = self.wids['ventana'])
else:
model = self.wids['tv_balas'].get_model()
try:
bala = pclases.BalaCable.get(model[path][-1])
except:
utils.dialogo_info(titulo = "ERROR",
texto = "No se pudo acceder a la bala.",
padre = self.wids['ventana'])
self.actualizar_tabla()
else:
difpeso = bala.peso - peso
bala.peso = peso
bala.syncUpdate()
model[path][2] = utils.float2str(bala.peso, 1)
try:
totpantalla = utils.parse_float(
self.wids['e_pantalla'].get_text())
except:
totpantalla = 0.0
totpantalla -= difpeso
self.rellenar_totales(totpantalla)
def cambiar_cantidad_envase(self, cell, path, text):
"""
Cambia la cantidad de tarrinas contenidas en la configuración de
envase.
"""
try:
cantidad = int(utils._float(text))
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un número." % text,
padre = self.wids['ventana'])
else:
model = self.wids['tv_empaquetado'].get_model()
id = model[path][-1]
try:
empaquetado = pclases.Empaquetado.get(id)
except:
utils.dialogo_info(titulo = "ERROR EMPAQUIETADO",
texto = "La configuración de empaquetado "
"no existe. Recargue la ventana.",
padre = self.wids['ventana'])
else:
empaquetado.cantidad = cantidad
empaquetado.syncUpdate()
model[path][1] = empaquetado.cantidad
model[path][2] = utils.float2str(
empaquetado.calcular_capacidad_total())
def comparar_float(self, col):
res = 0.0
try:
valor_ventana = self.wids[col].get_text()
except KeyError:
txt_error = "categorias_laborales.py: No se pudo obtener el valor de la ventana para %s." % col
print txt_error
self.logger.error(txt_error)
valor_ventana = 0.0
try:
valor_ventana = utils._float(valor_ventana)
except ValueError:
txt_error = "categorias_laborales.py: No se pudo convertir %s (%s) a float." % (col, valor_ventana)
print txt_error
self.logger.error(txt_error)
valor_ventana = 0.0
try:
valor_campo = self.objeto._SO_getValue(col)
if not isinstance(valor_campo, type(0.0)): # Porque es posible
# que el SOCol no contenga un float.
# El SOCol es la clase base. Se asume flotante por eliminación.
res = False
else:
res = valor_ventana == valor_campo
except KeyError:
txt_error = "categorias_laborales.py: No se pudo obtener el valor del objeto para %s." % col
print txt_error
self.logger.error(txt_error)
valor_campo = 0.0
return res
def cambiar_cantidad_ldv(self, cell, path, text):
try:
nueva = utils._float(text)
except:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un número." % text,
padre = self.wids['ventana'])
else:
model = self.wids['tv_ldvs'].get_model()
idldv = model[path][-1]
ldv = pclases.LineaDeVenta.get(idldv)
vieja = ldv.cantidad
diferencia = nueva - vieja
producto = ldv.productoCompra
producto.sync()
#bak = producto.existencias
#producto.existencias -= diferencia
if (producto.get_existencias(self.objeto.almacenOrigen)
- diferencia) < 0:
utils.dialogo_info(titulo = "ERROR EXISTENCIAS",
texto = "No hay existencias suficientes.",
padre = self.wids['ventana'])
#producto.existencias = bak
else:
producto.add_existencias(-diferencia,
self.objeto.almacenOrigen,
actualizar_global = True)
#producto.syncUpdate()
ldv.cantidad = nueva
ldv.syncUpdate()
model[path][2] = utils.float2str(ldv.cantidad)
def rellenar_tabla(self, cuentas):
"""
Rellena el model con los items de la consulta.
Elementos es un diccionario con objetos cuentaGastos y una lista
de gastos correspondientes a los meses de consulta.
"""
model = self.wids['tv_datos'].get_model()
model.clear()
total = 0
for cuenta in cuentas:
padre = model.append(None, (cuenta.descripcion,
"",
"",
"",
"",
utils.float2str(0.0),
cuenta.id))
for gasto in cuentas[cuenta]:
model.append(padre, (gasto.codigo,
gasto.concepto,
utils.str_fecha(gasto.fecha),
gasto.facturaCompra
and gasto.facturaCompra.numfactura
or "",
gasto.parcela
and gasto.parcela.parcela
or "",
utils.float2str(gasto.importe),
gasto.id))
model[padre][5] = utils.float2str(
utils._float(model[padre][5]) + gasto.importe)
total += gasto.importe
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
def cambiar_concentracion(self, cell, path, texto):
model = self.wids['tv_concentracion'].get_model()
try:
concentracion = utils._float(texto)
except (ValueError, TypeError):
utils.dialogo_info("ERROR EN FORMATO",
"Introduzca la concentración como fracción de 1."
"\n(P. ej. 20% = 0.2)",
padre = self.wids['ventana'])
else:
puid = model[path][-1]
cr = pclases.getObjetoPUID(puid)
#if (sum([c.concentracion
# for c in self.objeto.concentracionesRemesa if c != cr])
# + concentracion) > 1.0:
# utils.dialogo_info(titulo = "EXCESO CONCENTRACIÓN",
# texto = "La concentración total no puede superar el 100%."
# "\nSe corregirá.",
# padre = self.wids['ventana'])
# concentracion = 1.0 - sum([c.concentracion
# for c in self.objeto.concentracionesRemesa
# if c != cr])
cr.concentracion = concentracion
cr.syncUpdate()
model[path][1] = utils.float2str(cr.concentracion)
def parsear_porcentaje(txt):
"""
Devuelve la cantidad del porcentaje como fracción de 1.
"""
regexp_float = re.compile("^-?\d+[\.,]?\d*")
num = regexp_float.findall(txt)[0]
return utils._float(num) / 100
def guardar(self, widget):
"""
Guarda el contenido de los entry y demás widgets de entrada
de datos en el objeto y lo sincroniza con la BD.
"""
# Desactivo el notificador momentáneamente
self.objeto.notificador.desactivar()
# Actualizo los datos del objeto
adaptadores = self.adaptador.get_adaptadores()
for col in adaptadores:
if col.name == "comision":
try:
self.objeto.comision = utils._float(self.wids['e_comision'].get_text())
except ValueError:
self.objeto.comision = 0
self.wids['e_comision'].set_text('0')
continue
setattr(self.objeto, col.name, adaptadores[col]['leer']())
# Fuerzo la actualización de la BD y no espero a que SQLObject
# lo haga por mí:
self.objeto.syncUpdate()
self.objeto.sync()
# Vuelvo a activar el notificador
self.objeto.notificador.activar(self.aviso_actualizacion)
self.actualizar_ventana()
self.wids['b_guardar'].set_sensitive(False)
def crear_servicio(self):
# Datos a pedir: Concepto, descuento y precio... Bah, el descuento
# que lo cambie en el TreeView.
concepto = utils.dialogo_entrada(titulo = "CONCEPTO",
texto = 'Introduzca el concepto del servicio facturable:',
padre = self.wids['ventana'])
if concepto != None:
precio = utils.dialogo_entrada(titulo = "PRECIO",
texto = 'Introduzca el precio unitario sin IVA:',
padre = self.wids['ventana'])
if precio != None:
try:
precio = utils._float(precio)
servicio = pclases.Servicio(facturaVenta = self.objeto,
concepto = concepto,
precio = precio,
descuento = 0)
# Cantidad es 1 por defecto.
except Exception, e:
utils.dialogo_info(texto = """
Ocurrió un error al crear el servicio.
Asegúrese de haber introducido correctamente los datos,
especialmente el precio (que no debe incluir símbolos
monetarios), y vuelva a intentarlo.
DEBUG:
%s
""" %(e),
titulo = "ERROR",
padre = self.wids['ventana'])
return
self.rellenar_servicios()
self.rellenar_vencimientos()
def add(self, w):
if self.producto != None:
fecha = self.wids['e_fecha'].get_text()
if fecha == '':
utils.dialogo_info(titulo = 'SIN FECHA',
texto = 'Debe introducir la fecha del resultado de la prueba.')
return
resultado1 = self.wids['e_resultado1'].get_text()
if resultado1 == '':
utils.dialogo_info(titulo = 'SIN RESULTADO',
texto = 'Debe introducir el resultado de la prueba en resultado1.',
padre = self.wids['ventana'])
return
resultado2 = self.wids['e_resultado2'].get_text()
try:
mfi = utils._float(self.wids['e_mfi'].get_text())
except:
utils.dialogo_info(titulo = "MFI INCORRECTO",
texto = "No ha introducido un valor correcto para el MFI del proveedor.",
padre = self.wids['ventana'])
return
try:
resultado = float(resultado1)
prueba = pclases.PruebaGranza(fecha = utils.parse_fecha(fecha),
resultado = resultado,
productoCompra = self.producto,
fechaEntrada = mx.DateTime.localtime(),
silo = self.wids['e_silo'].get_text(),
lote = self.wids['e_lote'].get_text(),
mfi = mfi)
pclases.Auditoria.nuevo(prueba, self.usuario, __file__)
if resultado2:
try:
resultado = float(resultado2)
prueba = pclases.PruebaGranza(
fecha = utils.parse_fecha(fecha),
resultado = resultado,
productoCompra = self.producto,
fechaEntrada = mx.DateTime.localtime(),
silo = self.wids['e_silo'].get_text(),
lote = self.wids['e_lote'].get_text(),
mfi = mfi)
pclases.Auditoria.nuevo(prueba, self.usuario, __file__)
except Exception, msg:
utils.dialogo_info(titulo = 'ERROR',
texto = 'Verifique que ha introducido los datos correctamente.\n\n\nInformación de depuración: %s' % (msg),
padre = self.wids['ventana'])
except Exception, msg:
utils.dialogo_info(titulo = 'ERROR',
texto = 'Verifique que ha introducido los datos correctamente.\n\n\nInformación de depuración: %s' % (msg),
padre = self.wids['ventana'])
self.wids['e_fecha'].set_text(utils.str_fecha(time.localtime()))
self.wids['e_resultado1'].set_text('')
self.wids['e_resultado2'].set_text('')
self.wids['e_lote'].set_text('')
self.wids['e_silo'].set_text('')
self.wids['e_mfi'].set_text('0')
self.rellenar_pruebas()
def rellenar_tabla_por_provincia(self, vpro):
"""
Rellena el model de la lista de ofertas clasificada por comercial.
Recibe la ventana de progreso.
"""
model = self.wids['tv_provincia'].get_model()
model.clear()
tot = sum([len(self.por_producto[k])
for k in self.por_producto.keys()])
i = 0.0
try:
vpro.set_valor(i/tot, "Mostrando ofertas por provincia...")
except ZeroDivisionError:
return # No hay ofertas que mostrar
padres = {}
for provincia in self.por_provincia:
for presupuesto in self.por_provincia[provincia]:
vpro.set_valor(i/tot, "Mostrando ofertas por provincia... (%d)"
% presupuesto.id)
try:
padre = padres[provincia]
except KeyError:
padre = padres[provincia] = model.append(None,
(provincia,
"",
"",
"",
"0.0",
None))
importe = presupuesto.calcular_importe_total()
try:
comercial = presupuesto.comercial
nombre_comercial = comercial.get_nombre_completo()
except AttributeError:
nombre_comercial = "Sin comercial relacionado"
fila = ("Presupuesto %d" % presupuesto.id,
nombre_comercial,
presupuesto.cliente and presupuesto.cliente.nombre
or presupuesto.nombrecliente,
presupuesto.formaDePago
and presupuesto.formaDePago.toString(
presupuesto.cliente) or "",
utils.float2str(importe),
presupuesto.puid)
model.append(padre, fila)
# Actualizo totales fila padre.
model[padre][4] = utils.float2str(
utils._float(model[padre][4]) + importe)
if nombre_comercial not in model[padre][1]:
if not model[padre][1]:
model[padre][1] = nombre_comercial
else:
model[padre][1] += "; " + nombre_comercial
i += 1
# Y ahora la gráfica.
if self.wids['notebook1'].get_current_page() == 4:
self.graficar_por_provincia()
def cambiar_resultado(self, tv, path, texto, columna):
texto = texto.replace(" ", "")
if texto != "":
try:
resultado = utils._float(texto)
except:
utils.dialogo_info('RESULTADO INCORRECTO',
'El número tecleado (%s) no es correcto.' % (texto),
padre = self.wids['ventana'])
return
clase = self.get_clase(columna)
columnaid = columna-1 # Porque en los IDS empieza por 0
if clase != None:
model = self.wids['tv_pruebas'].get_model()
ids = map(int, model[path][-1].split(','))
ide = ids[columnaid]
if ide == 0:
if texto != "":
fecha = time.strptime(model[path][0], '%d/%m/%Y')
fecha = mx.DateTime.DateFrom(fecha.tm_year,
fecha.tm_mon,
fecha.tm_mday)
try:
prueba = clase(fecha = fecha,
resultado = resultado,
loteCem = self.loteCem,
lote = None)
except TypeError: # Es prueba de Humedad, no lleva relación con lote de fibra:
prueba = clase(fecha = fecha,
resultado = resultado,
loteCem = self.loteCem)
ids[columnaid] = prueba.id
model[path][-1] = ','.join(map(str, ids))
model[path][columna] = "%.2f" % resultado
else:
prueba = clase.get(int(ide))
if texto == "":
try:
prueba.destroy(ventana = __file__)
except:
utils.dialogo_info(titulo = "ERROR",
texto = "El resultado no se pudo eliminar.",
padre = self.wids['ventana'])
return
model[path][columna] = ""
ids[columnaid] = 0
model[path][-1] = ','.join(map(str, ids))
self.rellenar_pruebas() # Prefiero esto a comprobar si la fila se ha quedado vacía, etc...
else:
prueba.resultado = resultado
if columna != 6:
model[path][columna] = "%.2f" % resultado
else:
model[path][columna] = "%d" % resultado
self.calcular_caracteristicas()
def editar_float_tv(w, clase, campo, text, path, col):
try:
numero = utils._float(text)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un número." % text)
else:
model = w.get_model()
o = clase.get(model[path][-1])
setattr(o, campo, numero)
model[path][col] = utils.float2str(getattr(o, campo))
def graficar_por_producto(self):
datachart = []
model = self.wids['tv_producto'].get_model()
try:
maximo_producto = max([utils._float(f[1]) for f in model])
except ValueError: # empty sequence
maximo_producto = 0
for fila in model:
if utils._float(fila[1]) == maximo_producto:
color = 0
if (fila[-1] == None or isinstance(pclases.getObjetoPUID(fila[-1]),
pclases.Servicio)):
# Productos que no están dados de alta, no
# tengo el puid de producto o es servicio.
color = 7
else:
color = 3
nombre_corto = fila[0].replace("GEOTESAN", "") # OJO: HARCODED
datachart.append([nombre_corto, utils._float(fila[1]), color])
# Filtro y me quedo con el TOP5:
datachart.sort(lambda c1, c2: int(c2[1] - c1[1]))
_datachart = datachart[:5]
_datachart.append(("Resto", sum([c[1] for c in datachart[5:]]), 7))
datachart = _datachart
try:
oldchart = self.wids['eventbox_chart'].get_child()
if oldchart != None:
self.wids['eventbox_chart'].remove(oldchart)
#chart = oldchart
#else:
chart = charting.Chart(orient = "vertical",
values_on_bars = True)
self.wids['eventbox_chart'].add(chart)
chart.plot(datachart)
self.wids['eventbox_chart'].show_all()
except Exception, msg:
txt = "consulta_ofertas_estudio.py::graficar_por_producto -> "\
"Error al dibujar gráfica (charting): %s" % msg
print txt
self.logger.error(txt)
def rellenar_tabla_por_cliente(self, vpro):
"""
Rellena el model de la lista de ofertas clasificada por cliente.
Recibe la ventana de progreso.
"""
model = self.wids['tv_cliente'].get_model()
model.clear()
tot = sum([len(self.por_producto[k])
for k in self.por_producto.keys()])
i = 0.0
try:
vpro.set_valor(i/tot, "Mostrando ofertas por cliente...")
except ZeroDivisionError:
return # No hay ofertas que mostrar.
padres = {}
for cliente in self.por_cliente:
for presupuesto in self.por_cliente[cliente]:
vpro.set_valor(i/tot, "Mostrando ofertas por cliente... (%d)"
% presupuesto.id)
try:
padre = padres[cliente]
except KeyError:
try:
nombre_cliente = cliente.descripcion
cif = cliente.cif
puid = cliente.puid
except AttributeError:
nombre_cliente = presupuesto.nombrecliente
cif = presupuesto.cif
puid = None
padre = padres[cliente] = model.append(None,
(nombre_cliente,
cif,
"0.0",
"",
puid))
importe = presupuesto.calcular_importe_total()
fila = ("Presupuesto %d" % presupuesto.id,
utils.str_fecha(presupuesto.fecha),
utils.float2str(importe),
presupuesto.formaDePago
and presupuesto.formaDePago.toString(
presupuesto.cliente) or "",
presupuesto.puid)
model.append(padre, fila)
# Actualizo totales fila padre.
model[padre][2] = utils.float2str(
utils._float(model[padre][2]) + importe)
i += 1
# Y ahora la gráfica.
if self.wids['notebook1'].get_current_page() == 2:
self.graficar_por_cliente()
def get_float_tv(self, path, texto, col):
model = self.wids['tv_nominas'].get_model()
idnomina = model[path][-1]
nomina = pclases.Nomina.get(idnomina)
try:
valor = utils._float(texto)
model[path][col] = utils.float2str(valor, 3, autodec = True)
except ValueError:
utils.dialogo_info(titulo = "VALOR INCORRECTO",
texto = "El valor introducido no es correcto.",
padre = self.wids['ventana'])
valor = None
return nomina, valor
def add_concepto(self, b):
"""
Añade un detalle a un precio.
Si se han marcado varias filas, añade el mismo concepto a todos
los precios marcados.
"""
sel = self.wids['tv_productos'].get_selection()
model, paths = sel.get_selected_rows()
ids = []
tratados = []
while paths:
path = paths.pop()
tratados.append(path)
tipo, id = model[path][-1].split(":")
if tipo == "PV":
paths += [hijo.path for hijo in model[path].iterchildren()
if hijo.path not in tratados]
elif tipo == "C":
#pathpadre = model[path].parent.path
#if pathpadre not in tratados:
# paths.append(pathpadre)
id = pclases.Concepto.get(int(id)).precioID
if not id in ids:
ids.append(id)
elif tipo == "P":
id = int(id)
if id not in ids:
ids.append(id)
if ids:
concepto = utils.dialogo_entrada(titulo = "CONCEPTO",
texto = "Introduzca detalle:",
padre = self.wids['ventana'])
if concepto:
precio = utils.dialogo_entrada(titulo = "IMPORTE",
texto = "Importe del detalle:",
padre = self.wids['ventana'])
if precio:
try:
precio = utils._float(precio)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un número." % precio,
padre = self.wids['ventana'])
else:
for id in ids:
pre = pclases.Precio.get(id)
con = pclases.Concepto(importe = precio,
concepto = concepto,
precio = pre)
pre.tarifa.add_conceptoLdv_a_ldvs(con)
self.rellenar_tabla_precios()
def cambiar_importe_cobro(self, cell, path, texto):
model = self.wids['tv_cobros'].get_model()
id = model[path][-1]
cobro = pclases.Cobro.get(id)
try:
importe = utils._float(texto)
except:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un importe válido."%(
texto),
padre = self.wids['ventana'])
else:
cobro.importe = importe
self.rellenar_vencimientos()
def cambiar_precio_srv(self, cell, path, texto):
model = self.wids['tv_servicios'].get_model()
idsrv = model[path][-1]
srv = pclases.Servicio.get(idsrv)
try:
srv.precio = utils._float(texto)
# print srv.precio, utils._float(texto), texto
self.rellenar_servicios()
self.rellenar_vencimientos()
# Para que verifique si los totales coinciden
except:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = 'Formato numérico incorrecto',
padre = self.wids['ventana'])
def graficar_por_cliente(self):
datachart = []
model = self.wids['tv_cliente'].get_model()
try:
maximo_cliente = max([utils._float(f[2])
for f in model]) # if f[0]!="Sin cliente"])
except ValueError: # empty sequence
maximo_cliente = 0
for fila in model:
if fila[0] == None: # Cliente no dado de alta. No tiene PUID.
color = 7
elif utils._float(fila[2]) == maximo_cliente:
color = 0
else:
color = 3
datachart.append([fila[0], utils._float(fila[2]), color])
# Filtro y me quedo con el TOP5:
datachart.sort(lambda c1, c2: int(c2[1] - c1[1]))
_datachart = datachart[:5]
_datachart.append(("Resto", sum([c[1] for c in datachart[5:]]), 7))
datachart = _datachart
try:
oldchart = self.wids['eventbox_chart'].get_child()
if oldchart != None:
self.wids['eventbox_chart'].remove(oldchart)
#chart = oldchart
#else:
chart = charting.Chart(orient = "horizontal",
values_on_bars = True)
self.wids['eventbox_chart'].add(chart)
chart.plot(datachart)
self.wids['eventbox_chart'].show_all()
except Exception, msg:
txt = "consulta_ofertas_estudio.py::graficar_por_cliente -> "\
"Error al dibujar gráfica (charting): %s" % msg
print txt
self.logger.error(txt)
def pedir_cantidad(self):
"""
Pide una cantidad que debe ser un número float.
"""
res = utils.dialogo_entrada(titulo = "CANTIDAD",
texto = "Introduzca la cantidad a consumir del producto de compra (sin unidades):",
padre = self.wids['ventana'])
try:
res = utils._float(res)
except ValueError:
utils.dialogo_info(titulo = "CANTIDAD INCORRECTA",
texto = "El texto introducido %s no es correcto." % (res),
padre = self.wids['ventana'])
res = None
return res
def cambiar_precio_minimo(self, cell, path, texto):
if texto.strip() == "":
precio = None
else:
try:
precio = utils._float(texto)
except:
return
model = self.wids['tv_precio_minimo'].get_model()
ldp = pclases.getObjetoPUID(model[path][-1])
antes = ldp.precioMinimo
ldp.precioMinimo = precio
pclases.Auditoria.modificado(ldp, self.usuario, __file__,
"Precio mínimo de %s cambiado de %s a %s" % (
ldp.nombre, antes, ldp.precioMinimo))
self.rellenar_precio_minimo()
def cambiar_precio(self, cell, path, texto):
model = self.wids['tv_ldvs'].get_model()
idldv = model[path][-1]
ldv = pclases.LineaDeVenta.get(idldv)
try:
ldv.precio = utils._float(texto)
ldv.syncUpdate()
model[path][2] = ldv.precio
model[path][3] = ldv.calcular_importe(iva = False)
self.rellenar_totales()
self.rellenar_vencimientos()
# Para que verifique si los totales coinciden
except:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = 'Formato numérico incorrecto',
padre = self.wids['ventana'])
def cambiar_cantidad_srv(self, cell, path, texto):
model = self.wids['tv_servicios'].get_model()
idsrv = model[path][-1]
srv = pclases.Servicio.get(idsrv)
try:
srv.cantidad = utils._float(texto)
srv.syncUpdate()
# self.rellenar_servicios()
model[path][0] = srv.cantidad
model[path][4] = srv.precio * (1.0 - srv.descuento) * srv.cantidad
self.rellenar_totales()
self.rellenar_vencimientos()
# Para que verifique si los totales coinciden
except:
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = 'Formato numérico incorrecto',
padre = self.wids['ventana'])
def cambiar_cantidad(self, cell, path, texto):
"""
Cambia la cantidad del descuento adicional por producto.
"""
try:
cantidad = utils._float(texto)
except ValueError:
utils.dialogo_info(titulo = "FORMATO INCORRECTO",
texto = "El texto %s no es válido." % (texto),
padre = self.wids['ventana'])
return
model = self.wids['tv_consumos'].get_model()
if model[path].parent == None:
idconsumo = model[path][-1]
consumo = pclases.ConsumoAdicional.get(idconsumo)
consumo.cantidad = cantidad
self.rellenar_consumos_adicionales_por_producto()
