def buscar(self):
"""
Buscar las facturas de compra y de venta comprendidas entre
las fechas de la ventana, las ordena por fecha y devuelve
una lista de las mismas.
"""
try:
txt_fini = self.wids['e_fecha_inicio'].get_text()
fini = utils.parse_fecha(txt_fini)
except:
utils.dialogo_info(titulo = "ERROR FORMATO",
texto = "El texto %s no es una fecha correcta." % txt_fini,
padre = self.wids['ventana'])
return []
try:
txt_ffin = self.wids['e_fecha_fin'].get_text()
ffin = utils.parse_fecha(txt_ffin)
except:
utils.dialogo_info(titulo = "ERROR FORMATO",
texto = "El texto %s no es una fecha correcta." % txt_ffin,
padre = self.wids['ventana'])
return []
fraventas = pclases.FacturaVenta.select(pclases.AND(pclases.FacturaVenta.q.fecha >= fini,
pclases.FacturaVenta.q.fecha <= ffin))
fracompras = pclases.FacturaCompra.select(pclases.AND(pclases.FacturaCompra.q.fecha >= fini,
pclases.FacturaCompra.q.fecha <= ffin))
#facturas = list(fraventas) + list(fracompras)
# Me quito las facturas con IVA 0 (usualmente generadas para controlar ingresos a Hacienda y SS) y las de
# Portugal (21% de IVA) que irían en adquisiciones intracomunitarias en caso de que la empresa esté dada de
# alta como operador intracomunitario y sería autorrepercutido, etc.
facturas = list(fraventas) + [f for f in fracompras if not f.iva_homogeneo() or (f.iva != 0.0 and f.iva < 0.21)]
facturas.sort(lambda f1, f2: utils.orden_por_campo_o_id(f1, f2, "fecha"))
return facturas
def buscar(self, boton):
"""
A partir de las fechas de inicio y fin de la ventana busca las LDVs y LDDs de
albaranes de salida y albaranes de entrada de abonos entre ellas.
Rellena el TreeView con el resultado de la búsqueda.
"""
from ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
fini = utils.parse_fecha(self.wids['e_fechainicio'].get_text())
ffin = utils.parse_fecha(self.wids['e_fechafin'].get_text())
vpro.set_valor(0.3, "Buscando albaranes de salida...")
albs = pclases.AlbaranSalida.select(pclases.AND(pclases.AlbaranSalida.q.fecha >= fini,
pclases.AlbaranSalida.q.fecha <= ffin),
orderBy = "fecha")
ldvs = []
for a in albs:
for ldv in a.lineasDeVenta: # Lo hago así para cargar aquí todo el peso de traer las LDVs, y así aligero el rellenar_tabla.
ldvs.append(ldv)
vpro.set_valor(0.6, "Analizando facturas y abonos...")
adedas = pclases.AlbaranDeEntradaDeAbono.select(pclases.AND(pclases.AlbaranDeEntradaDeAbono.q.fecha >= fini,
pclases.AlbaranDeEntradaDeAbono.q.fecha <= ffin),
orderBy = "fecha")
ldds = []
for a in adedas:
for ldd in a.lineasDeDevolucion:
ldds.append(ldd)
vpro.set_valor(0.9, "Actualizando ventana...")
self.rellenar_tabla(ldvs, ldds)
vpro.ocultar()
def get_fechas_mostradas(self):
"""
Devuelve la fecha inicial y final de los datos mostrados.
"""
fini = self.wids["e_fecha_ini"].get_text()
fini = utils.parse_fecha(fini)
ffin = self.wids["e_fecha_fin"].get_text()
ffin = utils.parse_fecha(ffin)
return fini, ffin
def buscar(self, boton):
"""
Busca todos los productos e introduce en los TreeViews las existencias
de los mismos. En total y por almacén.
El total no lo calcula, se obtiene del total global (que debería
coincidir con el sumatorio de...).
"""
fechaini = self.wids['e_fechaini'].get_text().strip()
if fechaini:
try:
fechaini = utils.parse_fecha(fechaini)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR EN FECHA INICIAL",
texto = "El texto «%s» no es una fecha correcta." % fechaini,
padre = self.wids['ventana'])
fechaini = None
fechafin = self.wids['e_fechafin'].get_text().strip()
if fechafin:
try:
fechafin = utils.parse_fecha(fechafin)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR EN FECHA FINAL",
texto = "El texto «%s» no es una fecha correcta." % fechafin,
padre = self.wids['ventana'])
fechafin = None
if fechafin:
FV = pclases.FacturaVenta
if fechaini:
facturas = FV.select(pclases.AND(
FV.q.fecha >= fechaini,
FV.q.fecha <= fechafin))
else:
facturas = FV.select(FV.q.fecha <= fechafin)
from ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
txtvpro = "Buscando facturas..."
total = 0.0
i = 0.0
vpro.set_valor(i, txtvpro)
model = self.wids['tv_datos'].get_model()
model.clear()
for f in facturas:
i += 1
vpro.set_valor(i/facturas.count(),
txtvpro)
model.append((f.numfactura,
utils.str_fecha(f.fecha),
f.cliente and f.cliente.cif or "¡Sin cliente!",
f.cliente and f.cliente.nombre or "¡Sin cliente!",
utils.float2str(f.calcular_base_imponible()),
utils.float2str(f.calcular_total_iva()),
utils.float2str(f.calcular_importe_total()),
f.get_puid()))
total += f.calcular_importe_total()
vpro.ocultar()
self.wids['e_total'].set_text(utils.float2str(total))
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)
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)
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 buscar(self,boton):
"""
Dadas fecha de inicio y de fin, lista todos los albaranes
pendientes de facturar.
"""
self.resultado = []
self.comisiones = []
self.transportes = []
selfinicio = self.inicio and utils.parse_fecha("/".join(self.inicio.split("/")[::-1])) or None
selffin = utils.parse_fecha("/".join(self.fin.split("/")[::-1]))
if selfinicio == None:
albaranesentrada = pclases.AlbaranEntrada.select(pclases.AlbaranEntrada.q.fecha <= selffin, orderBy = 'fecha')
else:
albaranesentrada = pclases.AlbaranEntrada.select(sqlobject.AND(pclases.AlbaranEntrada.q.fecha >= selfinicio,
pclases.AlbaranEntrada.q.fecha <= selffin),
orderBy='fecha')
for proveedor in pclases.Proveedor.select():
if selfinicio == None:
self.comisiones += [c for c in proveedor.get_comisiones_pendientes_de_facturar()
if c.fecha <= selffin and c not in self.comisiones]
self.transportes += [t for t in proveedor.get_transportes_pendientes_de_facturar()
if t.fecha <= selffin and t not in self.transportes]
else:
for c in proveedor.get_comisiones_pendientes_de_facturar():
if selfinicio <= c.fecha <= selffin and c not in self.comisiones:
self.comisiones.append(c)
for t in proveedor.get_transportes_pendientes_de_facturar():
if selfinicio <= t.fecha <= selffin and t not in self.transportes:
self.transportes.append(t)
if selfinicio == None:
albaranessalida = pclases.AlbaranSalida.select(pclases.AND(pclases.AlbaranSalida.q.fecha <= selffin,
pclases.AlbaranSalida.q.facturable == True),
orderBy = 'fecha')
else:
albaranessalida = pclases.AlbaranSalida.select(sqlobject.AND(pclases.AlbaranSalida.q.fecha >= selfinicio,
pclases.AlbaranSalida.q.fecha <= selffin,
pclases.AlbaranSalida.q.facturable == True),
orderBy='fecha')
for a in albaranessalida:
total_lineas = len(a.lineasDeVenta)
if a.contar_lineas_facturadas() < total_lineas:
self.resultado.append(a)
for a in albaranesentrada:
total_lineas = len(a.lineasDeCompra)
if a.contar_lineas_facturadas() < total_lineas:
self.resultado.append(a)
self.resultado.sort(self.por_fecha)
self.comisiones.sort(self.por_fecha)
self.transportes.sort(self.por_fecha)
self.rellenar_tabla(self.resultado, self.comisiones, self.transportes)
self.wids['tv_producto'].get_columns()[0].set_expand(True)
def set_inicio(self, boton):
temp = utils.mostrar_calendario(
fecha_defecto = utils.parse_fecha(
self.wids['e_fechainicio'].get_text()),
padre = self.wids['ventana'])
self.inicio = mx.DateTime.DateTimeFrom(*temp[::-1])
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
def set_fecha_fin(self, b):
try:
fecha_defecto = utils.parse_fecha(self.wids['e_fecha_fin'].get_text())
except:
fecha_defecto = mx.DateTime.localtime()
else:
self.wids['e_fecha_fin'].set_text(utils.str_fecha(utils.mostrar_calendario(fecha_defecto = fecha_defecto, padre = self.wids['ventana'])))
def cambiar_fecha_fin_baja(self, cell, path, texto):
try:
fecha = utils.parse_fecha(texto)
except (ValueError, TypeError):
utils.dialogo_info(
titulo="FECHA INCORRECTA", texto="La fecha introducida no es válida", padre=self.wids["ventana"]
)
return
model = self.wids["tv_bajas"].get_model()
baja = pclases.Baja.get(model[path][-1])
for bajaexistente in self.objeto.bajas:
if bajaexistente == baja:
continue
iniciorango = baja.fechaInicio
finrango = fecha
if iniciorango > finrango:
iniciorango, finrango = finrango, iniciorango
fechaintermedia = iniciorango
while fechaintermedia < finrango:
if bajaexistente.esta_vigente(fechaintermedia):
utils.dialogo_info(
titulo="BAJA SOLAPADA",
texto="Las bajas médicas no pueden solaparse entre sí, elija otra fecha.",
padre=self.wids["ventana"],
)
return
fechaintermedia += mx.DateTime.oneDay
baja.fechaFin = fecha
if baja.fechaInicio > baja.fechaFin:
baja.fechaInicio, baja.fechaFin = baja.fechaFin, baja.fechaInicio
baja.sync()
model[path][0] = utils.str_fecha(baja.fechaInicio)
model[path][1] = utils.str_fecha(baja.fechaFin)
def set_fin(self, boton):
temp = utils.mostrar_calendario(
fecha_defecto = utils.parse_fecha(
self.wids["e_fechafin"].get_text()),
padre = self.wids['ventana'])
self.fin = mx.DateTime.DateTimeFrom(*temp[::-1])
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
def set_fecha(self, b):
try:
fecha_defecto = utils.parse_fecha(self.wids['e_fecha'].get_text())
except:
fecha_defecto = mx.DateTime.localtime()
else:
self.wids['e_fecha'].set_text("/".join(["%02d" % i for i in utils.mostrar_calendario(fecha_defecto = fecha_defecto, padre = self.wids['ventana'])]))
def get_fecha_mostrada(self):
"""
Devuelve la fecha mostrada en el calendario, que es la que se usa
para rescatar y presentar registros en la ventana.
"""
dia_seleccionado = utils.parse_fecha(self.wids['e_fecha'].get_text())
return dia_seleccionado
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.
"""
albaran = self.objeto
# Campos del objeto que hay que guardar:
numalbaran = self.wids['e_numalbaran'].get_text()
fecha = self.wids['e_fecha'].get_text()
# Desactivo el notificador momentáneamente
albaran.notificador.set_func(lambda: None)
# Actualizo los datos del objeto
albaran.numalbaran = numalbaran
albaran.proveedor = utils.combo_get_value(self.wids['cmbe_proveedor'])
albaran.almacen = utils.combo_get_value(self.wids['cbe_almacenID'])
try:
albaran.fecha = utils.parse_fecha(fecha)
except:
albaran.fecha = time.localtime()
utils.dialogo_info(titulo = "ERROR GUARDANDO FECHA",
texto = "La fecha %s no es correcta." % (fecha),
padre = self.wids['ventana'])
# Fuerzo la actualización de la BD y no espero a que SQLObject lo haga por mí:
albaran.syncUpdate()
# Vuelvo a activar el notificador
albaran.notificador.set_func(self.aviso_actualizacion)
self.actualizar_ventana()
self.wids['b_guardar'].set_sensitive(False)
def set_fin(self,boton):
try:
temp = utils.mostrar_calendario(utils.parse_fecha(self.wids['e_fechafin'].get_text()), padre = self.wids['ventana'])
except:
temp = utils.mostrar_calendario(padre = self.wids['ventana'])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.fin = mx.DateTime.DateTimeFrom(day = temp[0], month = temp[1], year = temp[2])
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
fechastr = self.wids['e_fecha'].get_text()
fecha = utils.parse_fecha(fechastr)
fechastr = utils.str_fecha(fecha)
fechas = pclases.HistorialExistenciasA.get_fechas_cacheadas()
if fecha not in fechas:
res = utils.dialogo(
titulo = "EXISTENCIAS NO CACHEADAS. ¿CONTINUAR?",
texto = "La fecha seleccionada no se encuentra precalculada.\n"
"Esto implica que el recuento de existencias puede\n"
"demorarse incluso horas. Durante este tiempo es \n"
"posible que la aplicación no responda.\n\n"
"¿Está seguro de que desea continuar?",
padre = self.wids['ventana'])
else:
res = utils.dialogo(titulo = "¿CONTINUAR?",
texto = "La operación puede demorarse durante algún tiempo\n"
"y dar la impresión de que la aplicación no responde.\n"
"¿Desea continuar?",
padre = self.wids['ventana'])
if not res:
return
vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
self.wids['ventana'].window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
vpro.mostrar()
act = 0.0
tot = 2 + pclases.Almacen.select().count()
msgtexto = 'Calculando existencias a %s.' % fechastr
vpro.set_valor(act/tot, msgtexto)
vpro._ventana.realize()
vpro._ventana.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
while gtk.events_pending(): gtk.main_iteration(False)
import informes
try:
vpro.set_valor(act/tot, msgtexto)
informes.abrir_pdf(geninformes.existencias_productos('rollos',
fechastr, hasta = fecha))
act += 1
vpro.set_valor(act/tot, msgtexto)
informes.abrir_pdf(geninformes.existencias_productos('balas',
fechastr, hasta = fecha))
act += 1
vpro.set_valor(act/tot, msgtexto)
for a in pclases.Almacen.select(orderBy = "id"):
informes.abrir_pdf(geninformes.existencias_productos('rollos',
fechastr, hasta = fecha, almacen = a))
act += 1
vpro.set_valor(act/tot, msgtexto)
informes.abrir_pdf(geninformes.existencias_productos('balas',
fechastr, hasta = fecha, almacen = a))
act += 1
vpro.set_valor(act/tot, msgtexto)
finally:
vpro.ocultar()
vpro._ventana.window.set_cursor(None)
self.wids['ventana'].window.set_cursor(None)
def guardar(self, widget = None):
"""
Guarda el contenido de los entry y demás widgets de entrada
de datos en el objeto y lo sincroniza con la BD.
"""
pagare = self.objeto
codigo = self.wids['e_codigo'].get_text()
try:
fechar = utils.parse_fecha(self.wids['e_fechar'].get_text())
except:
utils.dialogo_info(titulo = "ERROR EN FORMATO DE FECHA",
texto="El texto %s no es correcto o no representa una fecha" %
self.wids['e_fechar'].get_text(),
padre = self.wids['ventana'])
fechar = self.objeto.fechaRecepcion
try:
fechac = utils.parse_fecha(self.wids['e_fechac'].get_text())
except:
utils.dialogo_info(titulo = "ERROR EN FORMATO DE FECHA",
texto="El texto %s no es correcto o no representa una fecha" %
self.wids['e_fechar'].get_text(),
padre = self.wids['ventana'])
fechac = self.objeto.fechaCobro
buffer = self.wids['txt_observaciones'].get_buffer()
observaciones = buffer.get_text(buffer.get_start_iter(),
buffer.get_end_iter())
try:
cantidad=float(self.wids['e_cantidad'].get_text().replace("€", ""))
except:
utils.dialogo_info(titulo = "ERROR EN FORMATO NUMÉRICO",
texto="El texto %s no es correcto o no representa un número" %
self.wids['e_cantidad'].get_text(),
padre = self.wids['ventana'])
cantidad = self.objeto.cantidad
self.objeto.fechaRecepcion = fechar
self.objeto.fechaCobro = fechac
self.objeto.observaciones = observaciones
self.objeto.cantidad = cantidad
self.objeto.codigo = codigo
# Fuerzo la actualización de la BD y no espero a que SQLObject lo haga por mí:
pagare.syncUpdate()
# Vuelvo a activar el notificador
pagare.notificador.set_func(self.aviso_actualizacion)
self.actualizar_ventana()
self.wids['b_guardar'].set_sensitive(False)
def buscar(self, boton):
idproducto = utils.combo_get_value(self.wids['cbe_producto'])
fechaini = utils.parse_fecha(self.wids['e_fechaini'].get_text())
fechafin = utils.parse_fecha(self.wids['e_fechafin'].get_text())
if idproducto > 1:
try:
producto = pclases.ProductoVenta.get(idproducto)
except:
utils.dialogo_info(titulo = "ERROR",
texto = "El producto seleccionado no se encontró.\n"
"Probablemente fue eliminado.\nCierre y vuelva "
"a abrir esta ventana antes de volver a "
"intentarlo.",
padre = self.wids['ventana'])
else:
partidas = producto.get_partidas(fechaini = fechaini,
fechafin = fechafin)
if pclases.DEBUG:
print "consulta_marcado_ce.py::len(partidas", len(partidas)
if self.wids['ch_gramaje'].get_active():
gramaje = producto.camposEspecificosRollo.gramos
cers = pclases.CamposEspecificosRollo.select(
pclases.CamposEspecificosRollo.q.gramos == gramaje)
for cer in cers:
try:
cerproducto = cer.productosVenta[0]
except IndexError, msg:
txt = "%sconsulta_marcado_ce::buscar -> "\
"El registro CER ID %d no tiene producto "\
"asociado. Mensaje de la excepción: %s" % (
self.usuario
and self.usuario.usuario + ": " or "",
cer.id, msg)
print txt
self.logger.error(txt)
continue
if cerproducto != producto: # Porque ya lo he
# contado antes
for partida in cerproducto.get_partidas():
if (partida not in partidas
and fechaini
<= partida.get_fecha_fabricacion()
<= fechafin):
partidas.append(partida)
self.rellenar_tabla(partidas)
def show_fecha(self, entry, event):
"""
Muestra la fecha en modo texto después de parsearla.
"""
if entry.get_text():
try:
entry.set_text(utils.str_fecha(utils.parse_fecha(entry.get_text())))
except (ValueError, TypeError):
entry.set_text(utils.str_fecha(mx.DateTime.localtime()))
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 imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
fechastr = self.wids['e_fecha'].get_text()
fecha = utils.parse_fecha(fechastr)
informes.abrir_pdf(
geninformes.existencias(hasta = fecha,
ventana_padre = self.wids['ventana']))
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
fechastr = self.wids['e_fecha'].get_text()
fecha = utils.parse_fecha(fechastr)
# informes.abrir_pdf(geninformes.existencias_productos('rollos', fechastr, hasta = fecha))
# informes.abrir_pdf(geninformes.existencias_productos('balas', fechastr, hasta = fecha))
informes.abrir_pdf(geninformes.existencias(hasta = fecha))
def buscar(self, widget):
"""
Muestra una ventana de búsqueda y a continuación los
resultados. El objeto seleccionado se hará activo
en la ventana a no ser que se pulse en Cancelar en
la ventana de resultados.
"""
pagare = self.objeto
a_buscar = utils.dialogo_entrada(titulo = "BUSCAR PAGARÉ",
texto = "Introduzca número, fecha del pagaré o número de factura:",
padre = self.wids['ventana'])
if a_buscar != None:
if a_buscar.count('/') == 2:
fecha = utils.parse_fecha(a_buscar)
resultados = pclases.PagareCobro.select(pclases.OR(
pclases.PagareCobro.q.fechaRecepcion == fecha,
pclases.PagareCobro.q.fechaCobro == fecha))
lon = resultados.count()
else:
resultados = pclases.PagareCobro.select(pclases.PagareCobro.q.codigo.contains(a_buscar))
resultados = list(resultados)
facturas = pclases.FacturaVenta.select(pclases.FacturaVenta.q.numfactura.contains(a_buscar))
prefacturas = pclases.Prefactura.select(pclases.Prefactura.q.numfactura.contains(a_buscar))
if facturas.count() + prefacturas.count() > 0:
for f in facturas:
for c in f.cobros:
if c.pagareCobro != None and c.pagareCobro not in resultados:
resultados.append(c.pagareCobro)
for f in prefacturas:
for c in f.cobros:
if c.pagareCobro != None and c.pagareCobro not in resultados:
resultados.append(c.pagareCobro)
lon = len(resultados)
if lon > 1:
## Refinar los resultados
idpagare = self.refinar_resultados_busqueda(resultados)
if idpagare == None:
return
resultados = [pclases.PagareCobro.get(idpagare)]
elif lon < 1:
## Sin resultados de búsqueda
utils.dialogo_info('SIN RESULTADOS',
'La búsqueda no produjo resultados.\nPruebe a cambiar el texto buscado o déjelo en blanco para ver una lista completa.\n(Atención: Ver la lista completa puede resultar lento si el número de elementos es muy alto)',
padre = self.wids['ventana'])
return
## Un único resultado
# Primero anulo la función de actualización
if pagare != None:
pagare.notificador.set_func(lambda : None)
# Pongo el objeto como actual
pagare = resultados[0]
# Y activo la función de notificación:
pagare.notificador.set_func(self.aviso_actualizacion)
self.objeto = pagare
self.actualizar_ventana()
def guardar(self, button):
"""
Actualiza la información del objeto respecto a la
mostrada en pantalla. Guarda todos los datos de
la ventana en el objeto persistente (y por tanto
en la base de datos).
"""
## NOTAS: A ver, vamos por orden. Campos que tiene una tarifa:
## - Nombre -> Se guarda automáticamente con el botón "Cambiar nombre"
## - Descripción -> Hay que guardarlo en esta función.
## - Identificador -> Es automático y ni lo muestro. No se puede
## cambiar.
## - Productos asociados -> Se añaden y eliminan con sus botones correspondientes.
tarifa = self.objeto
# Desactivo notificador:
tarifa.notificador.set_func(lambda : None)
# Guardo cambios:
## Por tanto, sólo hay que guardar los cambios en la descripción:
buffer = self.wids['tv_descripcion_tarifa'].get_buffer()
texto=buffer.get_text(buffer.get_bounds()[0], buffer.get_bounds()[1])
tarifa.observaciones=texto
try:
periodoValidezIni = utils.parse_fecha(self.wids['e_periodo_validez_ini'].get_text())
except:
periodoValidezIni = None
tarifa.periodoValidezIni = periodoValidezIni
try:
periodoValidezFin = utils.parse_fecha(self.wids['e_periodo_validez_fin'].get_text())
except:
periodoValidezFin = None
tarifa.periodoValidezFin = periodoValidezFin
if tarifa.periodoValidezIni != None and tarifa.periodoValidezFin != None and tarifa.periodoValidezIni > tarifa.periodoValidezFin:
tarifa.periodoValidezIni, tarifa.periodoValidezFin = tarifa.periodoValidezFin, tarifa.periodoValidezIni
tarifa.syncUpdate() # Por probare.
self.actualizar(None)
# Y vuelvo a activar el notificador:
tarifa.notificador.set_func(self.act)
# Y por último deshabilito el botón hasta que el usuario lo vuelva a necesitar
self.wids['b_guardar'].set_sensitive(False)
def set_inicio(self,boton):
try:
datinw = utils.parse_fecha(self.wids['e_fechainicio'].get_text())
temp = utils.mostrar_calendario(datinw,
padre = self.wids['ventana'])
except:
temp = utils.mostrar_calendario(padre = self.wids['ventana'])
self.wids['e_fechainicio'].set_text(utils.str_fecha(temp))
self.inicio = mx.DateTime.DateTimeFrom(day = temp[0],
month = temp[1],
year = temp[2])
def buscar_fecha(self, boton):
"""
Muestra el diálogo calendario y establece la fecha de la partida.
"""
partida = self.get_partida()
if partida != None:
fecha = utils.mostrar_calendario(fecha_defecto = partida.fecha, padre = self.wids['ventana'])
fecha = utils.parse_fecha(utils.str_fecha(fecha))
partida.fecha = mx.DateTime.DateTimeFrom(day = fecha.day, month = fecha.month, year = fecha.year,
hour = partida.fecha.hour, minute = partida.fecha.minute, second = partida.fecha.second)
self.wids['e_fecha'].set_text(utils.str_fechahora(partida.fecha))
def act_fecha(entry, event):
"""
Cambia los mnemotécnicos de fecha por la fecha debidamente formateada
o la cadena vacía para indicar que no hay límite de fecha.
"""
txtfecha = entry.get_text()
try:
txtfecha = utils.str_fecha(utils.parse_fecha(txtfecha))
except (ValueError, TypeError):
txtfecha = ""
entry.set_text(txtfecha)
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.partidas_carga = {}
global fin
Ventana.__init__(self, 'consumo_fibra_por_partida_gtx.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Partida', 'gobject.TYPE_STRING', False, True, False, None),
('kg consumidos', 'gobject.TYPE_STRING', False, False, False, None),
('kg prod. (real)', 'gobject.TYPE_STRING', False, False, False, None),
('kg prod. (teórico)', 'gobject.TYPE_STRING', False,False,False,None),
('balas cons.', 'gobject.TYPE_STRING', False, False, False, None),
('rollos prod.', 'gobject.TYPE_STRING', False, False, False, None),
('m² producidos', 'gobject.TYPE_STRING', False, False, False, None),
('ID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for col in self.wids['tv_datos'].get_columns()[1:]:
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(1.0)
self.colorear(self.wids['tv_datos'])
temp = time.localtime()
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.wids['e_fechainicio'].set_text(utils.str_fecha(mx.DateTime.localtime() - (7 * mx.DateTime.oneDay)))
self.inicio = utils.parse_fecha(self.wids['e_fechainicio'].get_text())
self.fin = utils.parse_fecha(self.wids['e_fechafin'].get_text())
self.wids['rb_pesoreal'].child.set_property("use-markup", True)
self.wids['rb_teorico'].child.set_property("use-markup", True)
self.wids['rb_pesosin'].child.set_property("use-markup", True)
self.wids['rb_pesosin'].set_active(True)
gtk.main()
def leer_fechas(self):
"""
Devuelve las fechas escritas en los widgets o None si se
produce algún error.
"""
fechaini = fechafin = None
try:
fechaini = utils.parse_fecha(self.wids['e_fechaini'].get_text())
except ValueError, excepcion:
utils.dialogo_info(titulo = "ERROR FECHA INICIO",
texto = "Compruebe la fecha inicial\n\n\nDEBUG: %s" % (excepcion),
padre = self.wids['ventana'])
def set_fecha(self, boton):
"""
Cambia la fecha de los filtros.
"""
w = self.wids[boton.name.replace("b_", "e_")]
try:
fechaentry = utils.parse_fecha(w.get_text())
except (TypeError, ValueError):
fechaentry = mx.DateTime.today()
w.set_text(utils.str_fecha(utils.mostrar_calendario(
fecha_defecto = fechaentry,
padre = self.wids['ventana'])))
def cambiar_fecha(entry, padre = None):
"""
Cambia el texto del entry por la fecha seleccionada en un diálogo
centrado en la ventana "padre".
"""
try:
entry.set_text(utils.str_fecha(utils.mostrar_calendario(
fecha_defecto = utils.parse_fecha(entry.get_text()),
padre = padre)))
except: # Probablemente fecha mal formada,
# pero me curo en salud y capturo todas.
entry.set_text(utils.str_fecha(utils.mostrar_calendario(padre=padre)))