def mostrar_totales(self, devengado, soportado, base_devengado):
"""
Muestra los totales, la diferencia de ambos y colorea los Entries.
"""
# Base imponible de las facturas de venta. (Si trabajara con más IVAs debería haber una línea por cada tipo de IVA)
self.wids['e_base_devengado'].set_text("%s €" % (utils.float2str(base_devengado, 2)))
# Devengado
self.wids['e_devengado'].set_text("%s €" % utils.float2str(devengado, 2))
tips = gtk.Tooltips()
tips.set_tip(self.wids['e_devengado'], str(devengado))
tips.enable()
self.wids['e_devengado'].modify_text(gtk.STATE_NORMAL, self.wids['e_devengado'].get_colormap().alloc_color("red"))
# Soportado
self.wids['e_soportado'].set_text("%s €" % utils.float2str(soportado, 2))
tips = gtk.Tooltips()
tips.set_tip(self.wids['e_soportado'], str(soportado))
tips.enable()
self.wids['e_soportado'].modify_text(gtk.STATE_NORMAL, self.wids['e_soportado'].get_colormap().alloc_color("blue"))
# Diferencia
diferencia = devengado - soportado
self.wids['e_diferencia'].set_text("%s €" % utils.float2str(diferencia, 2))
tips = gtk.Tooltips()
tips.set_tip(self.wids['e_diferencia'], str(diferencia))
tips.enable()
if diferencia > 0:
self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, self.wids['e_diferencia'].get_colormap().alloc_color("red"))
else:
self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, self.wids['e_diferencia'].get_colormap().alloc_color("blue"))
def build_tabla_contenido(data):
"""
Construye la tabla del contenido del albaranSalida.
Los datos deben venir en listas. Cada línea de la tabla, una tupla o lista
con el código, descripción, cantidad, precio unitario (con dto. si lo
lleva e IVA) y número de pedido.
El precio y cantidad deben ser flotantes para poder calcular el subtotal.
"""
estilo_cabecera_tabla = ParagraphStyle("Cabecera tabla",
parent=estilos["Heading3"])
estilo_cabecera_tabla.fontName = "Times-Bold"
estilo_cabecera_tabla.alignment = enums.TA_CENTER
estilo_numeros_tabla = ParagraphStyle("Números tabla",
parent=estilos["Normal"])
estilo_numeros_tabla.alignment = enums.TA_RIGHT
datos = [(Paragraph(escribe("Código"), estilo_cabecera_tabla),
Paragraph(escribe("Descripción"), estilo_cabecera_tabla),
Paragraph("Cantidad", estilo_cabecera_tabla),
Paragraph("Precio/U", estilo_cabecera_tabla),
#Paragraph("Total c/IVA", estilo_cabecera_tabla),
# CWT: Prefiere la carta de portes sin IVA.
Paragraph("Total", estilo_cabecera_tabla),
Paragraph(escribe("Nº Pedido"), estilo_cabecera_tabla))
]
for d in data:
fila = (escribe(d[0]),
Paragraph(escribe(d[1]),estilos["Normal"]),
Paragraph(escribe(utils.float2str(d[2])),estilo_numeros_tabla),
Paragraph(escribe(utils.float2str(d[3])),estilo_numeros_tabla),
Paragraph(escribe(utils.float2str(d[2] * d[3])),
estilo_numeros_tabla),
escribe(d[4])
)
datos.append(fila)
tabla = Table(datos,
colWidths = (PAGE_WIDTH * 0.13,
PAGE_WIDTH * 0.35,
PAGE_WIDTH * 0.09,
PAGE_WIDTH * 0.09,
PAGE_WIDTH * 0.13,
PAGE_WIDTH * 0.11),
repeatRows = 1)
tabla.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), colors.lightgrey),
("LINEBEFORE", (0, 0), (-1, -1), 0.25, colors.black),
("LINEBELOW", (0, 0), (-1, 0), 1.0, colors.black),
("LINEBELOW", (0, "splitlast"), (-1, "splitlast"), 1.0, colors.black),
("BOX", (0, 0), (-1, -1), 1.0, colors.black),
("INNERGRID", (0, 0), (-1, -1), 0.25, colors.black),
("VALIGN", (0, 0), (-1, 0), "CENTER"),
("VALIGN", (0, 0), (0, -1), "TOP"),
("ALIGN", (0, 0), (-1, 0), "CENTER"),
("ALIGN", (-3, 1), (-1, -1), "RIGHT"),
#("ALIGN", (0, 1), (0, -1), "DECIMAL"), <- No puedo cambiar
# el pivotChar de "." a ",". No me vale.
("ALIGN", (-1, 1), (-1, -1), "CENTER"),
("ALIGN", (0, 1), (0, -1), "CENTER"),
#("RIGHTPADDING", (0, 1), (0, -1), 0.75 * cm),
]))
return tabla
def rellenar_tabla(self, tabla):
"""
Rellena el model con las ldc existentes
"""
albaran = self.objeto
if albaran != None:
lineas = albaran.lineasDeCompra
try:
lineas.sort(lambda l1, l2: l1.id - l2.id)
except:
pass
model = self.wids['tv_ldvs'].get_model()
model.clear()
for l in lineas:
model.append((l.productoCompra.codigo,
l.productoCompra.descripcion,
utils.float2str(l.cantidad, 2),
utils.float2str(l.precio, 4, autodec = True),
"%s %%" % (utils.float2str(l.iva * 100, 0)),
"%s %%" % (utils.float2str(l.descuento*100, 0)),
utils.float2str(l.get_subtotal(iva = True)),
l.silo and l.silo.nombre or "",
l.pedidoCompra
and l.pedidoCompra.numpedido or "",
l.pedidoCompra
and utils.str_fecha(l.pedidoCompra.fecha)
or "",
l.id))
def valorar_a_precio_valoracion(tv):
"""
Valora todos los productos de compra con existencias distintas a cero
(OJO: Incluye existencias negativas) según el precio de valoración
definido (precio por defecto, precio medio ponderado, etc.).
"""
pcs = pclases.ProductoCompra.select(pclases.AND(
pclases.ProductoCompra.q.controlExistencias == True,
pclases.ProductoCompra.q.obsoleto == False,
pclases.ProductoCompra.q.existencias != 0))
model = tv.get_model()
tv.freeze_child_notify()
tv.set_model(None)
model.clear()
suma = 0.0
for pc in pcs:
precio_valoracion = pc.get_precio_valoracion()
valoracion = precio_valoracion * pc.existencias
model.append((pc.codigo,
pc.descripcion,
utils.float2str(pc.existencias,precision=2,autodec=True),
utils.float2str(precio_valoracion, precision = 2),
utils.float2str(valoracion, precision = 2),
pc.id))
suma += valoracion
tv.set_model(model)
tv.thaw_child_notify()
return suma
def setter_textview(objeto, col, w):
"""
Muestra el valor del atributo "col" del objeto
"objeto" en el textview "w".
"""
valor = getattr(objeto, col.name)
if isinstance(col, sqlobject.col.SODateCol):
valor = str_fecha(valor)
elif isinstance(col, sqlobject.col.SODateTimeCol):
valor = str_fechahoralarga(valor)
elif isinstance(col, sqlobject.col.SOTimeCol):
valor = str_hora(valor)
elif isinstance(col, sqlobject.col.SOFloatCol):
# XXX
# HACK: Workaround. Los valores que son porcentaje (descuentos e IVA)
# se deben mostrar con el símbolo "%", pero la única manera de
# distinguir esas columnas es mirar el nombre.
if col.name in NOMBRES_COLUMNAS_PORCENTAJE:
valor = "%s %%" % float2str(valor * 100, precision=5, autodec=True)
# XXX
else:
valor = float2str(valor, autodec=False)
# Si autodec=True y es número redondo > 1000 escribe 1.000 y el
# getter lo interpreta como flotante.
if not isinstance(valor, str):
valor = str(valor)
buf = w.get_buffer()
buf.set_text(valor)
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
from formularios import reports
datos = []
total = 0
self.resultados.sort(self.por_fecha_ldc)
for ldc in self.resultados:
subtotal = ldc.cantidad * ldc.precio
datos.append((ldc.nombre_proveedor,
ldc.albaranEntrada.numalbaran,
utils.str_fecha(ldc.albaranEntrada.fecha),
ldc.descripcion_productoCompra,
utils.float2str(ldc.cantidad),
utils.float2str(ldc.precio),
utils.float2str(subtotal)
))
total += subtotal
if len(self.resultados) > 0:
datos.append(("", "", "", "", "", "", "-"*20))
datos.append(("", "", "", "", "", "", utils.float2str(total)))
if (self.inicio) == None:
fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
else:
fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
if datos != []:
reports.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))
def imprimir(self, boton):
"""
Imprime la tarifa en pantalla.
"""
from formularios import reports
datos = []
model = self.wids['tabla_productos'].get_model()
for itr in model:
datos.append((itr[0],
itr[1],
"%s €" % (utils.float2str(itr[2], 3)),
"%s €" % (utils.float2str(itr[3], 3))
))
def cmp_func(x, y):
"""
Para ordenar por nombre de producto.
"""
if x[1] < y[1]:
return -1
if x[1] > y[1]:
return 1
return 0
datos.sort(cmp_func)
if datos != []:
nombre_tarifa = self.wids['cb_nombre_tarifa'].child.get_text()
reports.abrir_pdf(geninformes.imprimir_tarifa(datos, nombre_tarifa, utils.str_fecha(mx.DateTime.localtime())))
def rellenar_pies(self,
total, pendiente, cobrado,
total_pagares, pendiente_pagares, cobrado_pagares,
total_otros, pendiente_otros, cobrado_otros,
total_vencimientos, cobrado_strict):
"""
Rellena los entries del pie del formulario con los totales recibidos.
CWT: Al pendiente de cobro hay que restarle lo negociado en pagaré,
aunque no hayan vencido o estén marcados como pendiente.
Por tanto, el
pendiente = total (facturado) - total_pagares - cobrado_otros
y (lo mismo pero jugando con las incóginitas) el
cobrado = total_pagares + cobrado_otros = total - pendiente
"""
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
# self.wids['e_pendiente'].set_text("%s €" % utils.float2str(pendiente))
self.wids['e_pendiente'].set_text("%s €" % utils.float2str(total_vencimientos - total_pagares - cobrado_otros))
self.wids['e_cobrado_strict'].set_text("%s €" % utils.float2str(cobrado_strict))
# self.wids['e_cobrado'].set_text("%s €" % utils.float2str(cobrado))
self.wids['e_cobrado'].set_text("%s €" % utils.float2str(total_pagares + cobrado_otros))
self.wids['e_total_pagares'].set_text("%s €" % utils.float2str(total_pagares))
self.wids['e_pendiente_pagares'].set_text("%s €" % utils.float2str(pendiente_pagares))
self.wids['e_cobrado_pagares'].set_text("%s €" % utils.float2str(cobrado_pagares))
self.wids['e_total_otros'].set_text("%s €" % utils.float2str(total_otros))
self.wids['e_pendiente_otros'].set_text("%s €" % utils.float2str(pendiente_otros))
self.wids['e_cobrado_otros'].set_text("%s €" % utils.float2str(cobrado_otros))
def rellenar_tabla(self, facturas):
"""
Rellena el model con los items de la consulta.
Elementos es un diccionario con objetos factura y una lista
de facturacion correspondientes a los meses de consulta.
"""
idserie = utils.combo_get_value(self.wids["cb_serie"])
if not idserie:
serie = None
else:
serie = pclases.SerieFacturasVenta.get(idserie)
model = self.wids["tv_datos"].get_model()
model.clear()
total = total_kg = 0
for factura in facturas:
if serie and factura.serieFacturasVenta != serie:
continue
importe = factura.calcular_importe_total(iva=True)
kilos = factura.calcular_kilos()
padre = model.append(
(
factura.numfactura,
utils.str_fecha(factura.fecha),
factura.cliente.nombre,
utils.float2str(importe),
utils.float2str(kilos),
factura.id,
)
)
total += importe
total_kg += kilos
self.wids["e_total_importes"].set_text("%s €" % utils.float2str(total))
self.wids["e_total_cantidades"].set_text("%s kg" % utils.float2str(total_kg))
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 rellenar_widgets(self, boton = None):
"""
Introduce la información de la cuenta actual
en los widgets.
No se chequea que sea != None, así que
hay que tener cuidado de no llamar a
esta función en ese caso.
"""
if self.empleado != None:
gtkimage = self.empleado.get_gtkimage(125)
self.wids['im_foto'].set_from_pixbuf(gtkimage.get_pixbuf())
self.wids['e_codigo'].set_text(str(self.empleado.id))
self.wids['e_nombre'].set_text(self.empleado.nombre)
anno, mes, dia = self.wids['cal_trabajo'].get_date()
fecha = mx.DateTime.DateTimeFrom(day = dia,
month = mes + 1,
year = anno)
prod = self.empleado.calcular_produccion_personal(fecha)
self.wids['e_prod_personal'].set_text(utils.float2str(prod))
mediaglobal = pclases.Jornal.calcular_media_global(fecha)
self.wids['e_media_global'].set_text(utils.float2str(mediaglobal))
ratio = self.empleado.calcular_ratio()
self.wids['e_ratio'].set_text(utils.float2str(ratio))
dibujar_grafico(self.wids['grafico'], self.empleado)
empleados = pclases.Empleado.select(orderBy = "nombre")
ids = [e.id for e in empleados]
idactual = self.empleado.id
self.wids['b_atras'].set_sensitive(ids[0] != idactual)
self.wids['b_adelante'].set_sensitive(ids[-1] != idactual)
else:
self.activar_widgets(False)
def es_diferente(self):
"""
Devuelve True si la información en pantalla es distinta a la
del objeto en memoria.
"""
producto = self.objeto
if producto == None: return False # Si no hay producto activo, devuelvo que no hay cambio respecto a la ventana
condicion = producto.codigo == self.wids['e_codigo'].get_text()
# print condicion
if producto.camposEspecificosEspecialID != None:
producto.camposEspecificosEspecial.sync()
producto.camposEspecificosEspecial.chequear_cambios()
condicion = condicion and (utils.float2str(producto.camposEspecificosEspecial.stock) == self.wids['e_stock'].get_text())
condicion = condicion and (producto.camposEspecificosEspecial.unidad == self.wids['e_unidad'].get_text())
condicion = condicion and (producto.camposEspecificosEspecial.observaciones == self.wids['e_observaciones'].get_text())
condicion = condicion and (str(producto.camposEspecificosEspecial.existencias) == self.wids['e_existencias'].get_text())
condicion = condicion and (producto.descripcion == self.wids['e_descripcion'].get_text())
condicion = condicion and (producto.nombre == self.wids['e_nombre'].get_text())
condicion = condicion and (str(producto.preciopordefecto) == self.wids['e_precio'].get_text())
condicion = condicion and (str(producto.minimo) == self.wids['e_minimo'].get_text())
condicion = condicion and (str(producto.arancel) == self.wids['e_arancel'].get_text())
condicion = condicion and (utils.float2str(producto.prodestandar) == self.wids['e_prodestandar'].get_text())
try:
condicion = (condicion and self.objeto.obsoleto
== self.wids['ch_obsoleto'].get_active())
except (KeyError, AttributeError):
pass # Versión antigua de la base de datos.
return not condicion # Concición verifica que sea igual
def rellenar_facturas(self):
"""
Rellena el model con las facturas no bloqueadas.
"""
model = self.wids['tv_facturas'].get_model()
model.clear()
self.wids['tv_facturas'].freeze_child_notify()
self.wids['tv_facturas'].set_model(None)
vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
i = 0.0
facturas = pclases.FacturaVenta.select(
pclases.FacturaVenta.q.bloqueada == False, orderBy = "id")
prefacturas = pclases.Prefactura.select(
pclases.Prefactura.q.bloqueada == False, orderBy = "id")
tot = facturas.count() + prefacturas.count()
for factura in facturas:
vpro.set_valor(i/tot,
'Recuperando factura %s...' % (factura.numfactura))
i += 1
if factura.vencimientosCobro == []:
motivo = "Sin vencimientos."
elif (factura.cliente.cif == None
or factura.cliente.cif.strip() == ""):
motivo = "Cliente sin CIF."
else:
motivo = "Factura no bloqueada."
model.append((factura.numfactura,
utils.str_fecha(factura.fecha),
factura.cliente and factura.cliente.nombre or "-",
"%s €" % (utils.float2str(factura.calcular_total())),
", ".join([a.numalbaran
for a in factura.get_albaranes()]),
factura.bloqueada,
motivo,
factura.id))
for factura in prefacturas:
vpro.set_valor(i/tot,
'Recuperando factura %s...' % (factura.numfactura))
i += 1
if factura.vencimientosCobro == []:
motivo = "Sin vencimientos."
elif (factura.cliente.cif == None
or factura.cliente.cif.strip() == ""):
motivo = "Cliente sin CIF."
else:
motivo = "Factura no bloqueada."
model.append(
(factura.numfactura,
utils.str_fecha(factura.fecha),
factura.cliente and factura.cliente.nombre or "-",
"%s €" % (utils.float2str(factura.calcular_total())),
", ".join([a.numalbaran for a in factura.get_albaranes()]),
factura.bloqueada,
motivo,
factura.id))
self.wids['tv_facturas'].set_model(model)
self.wids['tv_facturas'].thaw_child_notify()
vpro.ocultar()
def rellenar_widgets(self):
"""
Introduce la información del producto actual
en los widgets.
No se chequea que sea != None, así que
hay que tener cuidado de no llamar a
esta función en ese caso.
"""
producto = self.objeto
productos = pclases.ProductoVenta.select(
pclases.ProductoVenta.q.camposEspecificosEspecialID != None,
orderBy='id')
productos_count = productos.count()
yo_index = pclases.SQLlist(productos).index(producto) + 1
self.wids['ventana'].set_title(
"Productos de venta: ESPECIAL - %s (%d de %d)" % (
producto.descripcion,
yo_index,
productos_count))
self.wids['i_barcode'].set_from_file(EanBarCode().getImage(
producto.codigo))
self.wids['e_codigo'].set_text(producto.codigo)
self.wids['e_descripcion'].set_text(producto.descripcion)
self.wids['e_nombre'].set_text(producto.nombre)
self.wids['e_precio'].set_text(str(producto.preciopordefecto))
self.wids['e_minimo'].set_text(str(producto.minimo))
self.wids['e_arancel'].set_text(str(producto.arancel))
self.wids['e_prodestandar'].set_text(utils.float2str(producto.prodestandar))
campos = producto.camposEspecificosEspecial
self.wids['e_stock'].set_text(utils.float2str(campos.stock))
self.wids['e_existencias'].set_text(str(campos.existencias))
try:
pesobulto = utils.float2str(producto.calcular_razon_bultos())
except (ValueError, TypeError):
pesobulto = "N/A"
self.wids['e_razon'].set_text(pesobulto)
self.wids['e_unidad'].set_text(campos.unidad)
self.wids['e_observaciones'].set_text(campos.observaciones)
# Datos no modificables:
self.wids['e_idproducto'].set_text(`producto.id`)
try:
self.wids['ch_obsoleto'].set_active(self.objeto.obsoleto)
except (KeyError, AttributeError):
pass # Versión antigua de la base de datos.
self.mostrar_especificos()
self.rellenar_tabla_tarifas()
self.rellenar_existencias_almacen(producto)
self.objeto.make_swap()
self.objeto.camposEspecificosEspecial.make_swap()
# Sombreado de botones anterior-siguiente
anteriores = pclases.ProductoVenta.select(pclases.AND(
pclases.ProductoVenta.q.camposEspecificosEspecialID != None,
pclases.ProductoVenta.q.id < producto.id),orderBy='-id').count()
siguientes = pclases.ProductoVenta.select(pclases.AND(
pclases.ProductoVenta.q.camposEspecificosEspecialID != None,
pclases.ProductoVenta.q.id > producto.id),orderBy='id').count()
self.wids['b_anterior'].set_sensitive(anteriores)
self.wids['b_siguiente'].set_sensitive(siguientes)
def rellenar_tabla_XXX(self):
model = self.wids["XXXtv_treeview"].get_model()
model.clear()
total = 0.0
for p in self.objeto.XXXunoamuchos:
total += p.XXXcampoacumulable
model.append((p.XXXcampo1, utils.float2str(p.XXXcampoacumulable), p.id))
self.wids["XXXe_total_si_lo_hay"].set_text(utils.float2str(total))
def rellenar_tabla(self, items):
"""
Rellena el model con los items de la consulta
"""
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
vpro.set_valor(0.0, "Contando existencias...")
act = 0.0
tot = len(items) * len(self.tvs)
try:
fecha = utils.parse_fecha(self.wids['e_fecha'].get_text())
except (TypeError, ValueError, AttributeError):
fecha = mx.DateTime.today()
self.wids['e_fecha'].set_text(utils.str_fecha(fecha))
# XXX: Optimización (cosas de cómo están hechas las funciones de get_*
# por dentro en pclases):
if fecha >= mx.DateTime.today():
fecha = None
for tv, kg, bultos, a in self.tvs:
model = tv.get_model()
model.clear()
totalkgs = 0.0
totalbultos = 0
for pv in items:
vpro.set_valor(act/tot,
"Contando existencias...\t[%s]" % pv.get_puid())
stock = pv.get_stock(hasta = fecha, almacen = a)
totalkgs += stock
existencias = pv.get_existencias(hasta=fecha, almacen = a)
totalbultos += existencias
stock_A = pv.get_stock_A(hasta = fecha, almacen = a)
existencias_A = pv.get_existencias_A(hasta=fecha, almacen = a)
stock_B = pv.get_stock_B(hasta = fecha, almacen = a)
existencias_B = pv.get_existencias_B(hasta=fecha, almacen = a)
stock_C = pv.get_stock_C(hasta = fecha, almacen = a)
existencias_C = pv.get_existencias_C(hasta=fecha, almacen = a)
model.append((pv.codigo,
pv.descripcion,
utils.float2str(stock),
utils.float2str(existencias, autodec = True),
utils.float2str(stock_A!=None and stock_A or 0),
utils.float2str(existencias_A != None and
existencias_A or 0,
autodec = True),
utils.float2str(stock_B!=None and stock_B or 0),
utils.float2str(existencias_B != None and
existencias_B or 0,
autodec = True),
utils.float2str(stock_C!=None and stock_C or 0),
utils.float2str(existencias_C != None and
existencias_C or 0,
autodec = True),
pv.get_puid()))
act += 1
kg.set_text(utils.float2str(totalkgs))
bultos.set_text(utils.float2str(totalbultos, autodec = True))
vpro.ocultar()
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 rellenar_totales(self, totf, tots, totb):
"""
Introduce los totales en los "entries".
"""
self.wids['e_total'].set_text(utils.float2str(totf))
self.wids['e_siniva'].set_text(utils.float2str(tots))
try:
beneficio = totb * 100.0 / tots
except ZeroDivisionError:
beneficio = 0
self.wids['e_beneficio'].set_text("%s (%s %%)" % (utils.float2str(totb), utils.float2str(beneficio, 4, autodec = True)))
def rellenar_tabla_efectos(self):
model = self.wids['tv_efectos'].get_model()
model.clear()
total = 0.0
for p in self.objeto.efectos:
total += p.cantidad
model.append((self.objeto.aceptada, # False,
p.codigo,
p.cliente and p.cliente.nombre or "",
utils.float2str(p.cantidad),
p.puid))
self.wids['e_importe'].set_text(utils.float2str(total))
def rellenar_tabla_gastos(self):
model = self.wids['tv_gastos'].get_model()
model.clear()
total = 0.0
for p in self.objeto.gastos:
total += p.importe
model.append((p.codigo,
p.concepto,
utils.str_fecha(p.fecha),
utils.float2str(p.importe),
p.id))
self.wids['e_importe'].set_text(utils.float2str(total))
def insert_finca(self, finca, fila, columna):
"""
Inserta en self.wids['tabla'] -en (fila, columna)- la información de
la finca a través de un gtk.Image y un label dentro de un VBox que a
su vez está dentro de un HBox de dos columnas y con la información de
la finca como ToolTip.
"""
#MAX = 50 # Máximo ancho y alto de píxeles para el mapa de la finca.
MAX = 100 # Máximo ancho y alto de píxeles para el mapa de la finca.
vbox = gtk.VBox()
image = gtk.Image()
#image.set_from_file(finca.get_ruta_completa_plano())
finca.mostrar_imagen_en(image, MAX)
label = gtk.Label(' <span foreground="Gray"><big><i>'
+ finca.nombre
+ '</i></big></span> ')
label.set_use_markup(True)
label.set_angle(90)
idcampanna = utils.combo_get_value(self.wids['cb_campanna'])
campanna = pclases.Campanna.get(idcampanna)
prod = sum([parcela.calcular_produccion(campanna)
for parcela in finca.parcelas])
plantas = sum([p.numeroDePlantas for p in finca.parcelas])
if plantas != 0:
kgplanta = sum([parcela.calcular_produccion(campanna)
for parcela in finca.parcelas]) / plantas
else:
kgplanta = 0.0
apertura = sum([parcela.get_total_gastos_apertura(campanna)
for parcela in finca.parcelas])
varios = sum([parcela.get_total_gastos_varios(campanna)
for parcela in finca.parcelas])
cierre = sum([parcela.get_total_gastos_cierre(campanna)
for parcela in finca.parcelas])
texto_tip = "<big><big>%s</big>\nProducción: <b>%s kg</b>\n<b>%s kg/planta</b>\nGastos apertura: %s €\nGastos varios: %s €\nGastos de cierre: %s €</big>" % (
finca.nombre,
utils.float2str(prod),
utils.float2str(kgplanta),
utils.float2str(apertura),
utils.float2str(varios),
utils.float2str(cierre))
#image.set_tooltip_text(texto_tip)
try:
image.set_tooltip_markup(texto_tip)
except:
pass # No tiene este método en GTK/PyGTK 2.10 de WXP
vbox.pack_start(image)
vbox.pack_start(label)
hbox = gtk.HBox()
hbox.pack_start(vbox)
widparcelas = self.insert_parcelas(finca)
hbox.pack_start(widparcelas)
self.wids['tabla'].attach(hbox, columna, columna+1, fila, fila+1)
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 rellenar_tabla_ldvs(self):
model = self.wids['tv_ldvs'].get_model()
model.clear()
total = 0.0
for ldv in self.objeto.lineasDeVenta:
importe = ldv.calcular_importe(iva = False)
total += importe
model.append((ldv.productoVenta.nombre,
utils.float2str(ldv.cantidad),
utils.float2str(ldv.precio),
utils.float2str(importe),
ldv.id))
return total
def rellenar_totales(self, tot, tipo):
"""
Rellena los totales de fibra, geotextiles y cemento.
"""
for dim in tot.keys():
total = 0.0
for qlty in tot[dim].keys():
cantidad = tot[dim][qlty]
total += cantidad
nomentry = "e_%s_%s_%s" % (tipo, dim, qlty)
w = self.wids[nomentry]
w.set_text(utils.float2str(cantidad, autodec=True))
e_total = "e_%s_%s_total" % (tipo, dim)
self.wids[e_total].set_text(utils.float2str(total, autodec=True))
def rellenar_tabla_transferencias(self):
model = self.wids['tv_transferencias'].get_model()
model.clear()
total = 0.0
for p in self.objeto.pagos:
total += p.importe
model.append((p.proveedor and p.proveedor.nombre,
p.cuentaOrigen and p.cuentaOrigen.nombre,
utils.float2str(p.importe),
utils.str_fecha(p.fecha),
p.observaciones,
p.concepto,
p.id))
self.wids['e_total'].set_text(utils.float2str(total))
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
from formularios import reports
datos = []
for i in self.resultado:
if not i[2]: # i[2] = False cuando es vencimiento normal de la BD
if isinstance(i[1], pclases.FacturaDeAbono):
importe = i[1].calcular_importe_total()
datos.append((i[1].numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(importe),
"",
i[1].cliente and i[1].cliente.nombre or ""))
else:
fra = i[1].facturaVenta or i[1].prefactura
datos.append((fra.numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(i[1].importe),
i[1].observaciones,
fra.cliente.nombre))
else: # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
datos.append(("LOGIC", # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
utils.str_fecha(i[1]['fecha']),
utils.float2str(i[1]['importe']),
i[1]['comentario'],
i[1]['cuenta']))
if (self.inicio) == None:
fechaInforme = 'Hasta %s' % (utils.str_fecha(self.fin))
else:
fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
if datos != []:
model = self.wids['tv_totales'].get_model()
datos.append(("---", )*5)
datos.append(("TOTALES POR MES Y AÑO", ">->", ">->", ">->", ">->"))
for fila in model:
datos.append((fila[0], "", fila[1], "", ""))
iter_filames = model.iter_children(fila.iter)
while iter_filames:
filames = model[iter_filames]
datos.append(("", filames[0], filames[1], "", ""))
iter_filames = model.iter_next(iter_filames)
datos.append(("---", )*5)
datos.append(("",
"Total",
self.wids['e_total'].get_text(),
"Vencido a la fecha",
self.wids['e_vencido'].get_text()))
reports.abrir_pdf(geninformes.vencimientosCobro(datos,fechaInforme))
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 rellenar_tabla(self,lista = []):
"""
Rellena el model con los resultados de la búsqueda almacenados
en una lista de lotes.
"""
model = self.wids['tv_resultado'].get_model()
model.clear()
for elem in lista:
model.append((elem.numlote,
elem.codigo,
"%s (%s)" % (str(elem.tenacidad), utils.float2str(elem.calcular_tenacidad_media())),
"%s (%s)" % (str(elem.elongacion), utils.float2str(elem.calcular_elongacion_media())),
"%s (%s)" % (elem.rizo, utils.float2str(elem.calcular_rizo_medio())),
"%s (%s)" % (elem.encogimiento, utils.float2str(elem.calcular_encogimiento_medio())),
elem.id))
def rellenar_tabla(self, fras):
"""
Introduce las facturas recibidas en el TreeView y
calcula el total de IVA para las facturas de compra
y de venta por separado.
"""
tv = self.wids['tv_datos']
model = tv.get_model()
tv.freeze_child_notify()
tv.set_model(None)
model.clear()
devengado = 0.0
soportado = 0.0
base_devengado = 0.0
for fra in fras:
if isinstance(fra, pclases.FacturaVenta):
iva = fra.calcular_total_iva()
base_devengado += fra.calcular_base_imponible()
devengado += iva
fila = [utils.str_fecha(fra.fecha),
"%s (%s)" % (fra.numfactura,
fra.cliente and fra.cliente.nombre or ""),
"%s €" % utils.float2str(fra.calcular_importe_total()),
"%s €" % utils.float2str(iva),
"",
"",
"",
"FV:%d" % fra.id
]
elif isinstance(fra, pclases.FacturaCompra):
iva = fra.calcular_importe_iva()
soportado += iva
fila = [utils.str_fecha(fra.fecha),
"",
"",
"",
"%s (%s)" % (fra.numfactura, fra.proveedor and fra.proveedor.nombre or ""),
"%s €" % utils.float2str(fra.calcular_importe_total()),
"%s €" % utils.float2str(iva),
"FC:%d" % fra.id
]
else:
self.logger.error("iva::rellenar_tabla -> Factura %s no es FacturaVenta ni FacturaCompra." % fra)
continue
model.append(fila)
tv.set_model(model)
tv.thaw_child_notify()
self.mostrar_totales(devengado, soportado, base_devengado)
def rellenar_cesce(self, cobros, pagares, confirmings, vpro):
"""
Rellena la tabla específica para la empresa de crédito, donde no
se permite agrupación y las columnas deben seguir un orden determinado.
"""
self.wids['notebook1'].set_current_page(1)
model = self.wids['tv_cesce'].get_model()
model.clear()
vpro.mover()
cobros_pagares = []
for p in pagares:
for c in p.cobros:
cobros_pagares.append(c)
cobros_confirmings = []
for p in confirmings:
for c in p.cobros:
cobros_confirmings.append(c)
cobros_efect_o_transf = [c for c in cobros]
for c in cobros_efect_o_transf + cobros_pagares + cobros_confirmings:
vpro.mover()
numfactura = c.get_numfactura()
if not numfactura:
try:
numfactura = c.get_factura_o_prefactura().numfactura
except AttributeError:
numfactura = ""
if c.cliente and c.cliente.riesgoAsegurado != -1:
model.append((c.cliente and c.cliente.nombre or "",
"", # Suplemento. Vacío (al menos de momento)
c.cliente and c.cliente.cif or "",
"", # Código CESCE. Vacío
utils.float2str(c.importe),
utils.str_fecha(c.fecha),
numfactura,
c.puid))
