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
Ventana.__init__(self, 'consulta_ventas_por_producto.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 = (('Producto', 'gobject.TYPE_STRING', False, True, True, None),
('Cantidad', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Albarán', 'gobject.TYPE_STRING', False, True, False, None),
('ID', 'gobject.TYPE_STRING', False, False, False, None)) # Del producto, de la LDV o de la LDD.
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_producto_albaran_o_abono)
self.wids['tv_datos'].get_column(1).get_cell_renderers()[0].set_property('xalign', 1)
self.wids['tv_datos'].get_column(2).get_cell_renderers()[0].set_property('xalign', 1)
self.wids['tv_datos'].get_column(3).get_cell_renderers()[0].set_property('xalign', 0.5)
fin = mx.DateTime.localtime()
inicio = mx.DateTime.localtime() - mx.DateTime.oneWeek
self.wids['e_fechainicio'].set_text(utils.str_fecha(inicio))
self.wids['e_fechafin'].set_text(utils.str_fecha(fin))
gtk.main()
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
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 != []:
informes.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))
def __init__(self, objeto = None, usuario = None):
Ventana.__init__(self, 'up_consulta_facturas.glade', objeto)
self.usuario = usuario
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_ticket/clicked': self.imprimir_ticket,
'tv_datos/cursor-changed': self.mostrar_info_factura}
self.add_connections(connections)
cols = (('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Importe','gobject.TYPE_STRING', False, True, False, None),
('Fecha','gobject.TYPE_STRING', False, True, False, None),
('Pendiente de cobro','gobject.TYPE_STRING',
False, True, False, None),
('PUID','gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
for col in (self.wids['tv_datos'].get_column(1),
self.wids['tv_datos'].get_column(3)):
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
self.fin = datetime.date.today()
self.inicio = datetime.date(day = 1, month = self.fin.month,
year = self.fin.year)
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
gtk.main()
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 imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
for pago in self.resultado:
datos.append((pago.facturaCompra.numfactura,
utils.str_fecha(pago.fecha),
utils.float2str(pago.importe),
pago.observaciones,
pago.facturaCompra.proveedor.nombre))
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 != []:
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(),
"",
""))
informes.abrir_pdf(geninformes.vencimientosPago(datos,fechaInforme))
def rellenar_cobros(self):
model = self.wids['tv_cobros'].get_model()
model.clear()
if self.objeto.cobros != []:
utils.combo_set_from_db(self.wids['cbe_cliente'],
self.objeto.cobros[0].cliente.id)
for c in self.objeto.cobros:
if c.facturaVentaID != None:
importe_factura = c.facturaVenta.importeTotal
vencimientos = "(%d) " % len(c.facturaVenta.vencimientosCobro)
vencimientos += "; ".join(
["%s: %s €" % (utils.str_fecha(v.fecha),
utils.float2str(v.importe))
for v in c.facturaVenta.vencimientosCobro])
elif c.prefacturaID != None:
importe_factura = c.prefactura.importeTotal
vencimientos = "(%d) " % (len(c.prefactura.vencimientosCobro))
vencimientos += "; ".join(
["%s: %s €" % (utils.str_fecha(v.fecha),
utils.float2str(v.importe))
for v in c.prefactura.vencimientosCobro])
model.append((c.numfactura,
"%s €" % (utils.float2str(c.importe)),
utils.str_fecha(c.fecha),
"%s €" % (utils.float2str(importe_factura)),
vencimientos,
c.id))
def __init__(self, objeto=None, usuario=None):
self.usuario = usuario
Ventana.__init__(self, "consulta_ventas_ticket.glade", objeto)
connections = {
"b_salir/clicked": self.salir,
"b_buscar/clicked": self.buscar,
"b_imprimir/clicked": self.imprimir,
"b_exportar/clicked": self.exportar,
"b_fecha_inicio/clicked": self.set_inicio,
"b_fecha_fin/clicked": self.set_fin,
}
self.add_connections(connections)
cols = (
("Fecha", "gobject.TYPE_STRING", False, True, False, None),
("Ticket", "gobject.TYPE_STRING", False, True, True, None),
("Imp. total", "gobject.TYPE_STRING", False, True, False, None),
("Imp. (s/IVA)", "gobject.TYPE_STRING", False, True, False, None),
("Ben. sobre tarifa", "gobject.TYPE_STRING", False, True, 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()[2:]:
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(0.5)
self.wids["tv_datos"].connect("row-activated", self.abrir_producto)
self.fin = datetime.date.today()
self.inicio = self.fin
self.wids["e_fechafin"].set_text(utils.str_fecha(self.fin))
self.wids["e_fechainicio"].set_text(utils.str_fecha(self.inicio))
self.wids["hbox1"].set_property("visible", False)
self.wids["hbox6"].set_property("visible", False)
gtk.main()
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
model = self.wids['tv_datos'].get_model()
for i in model:
datos.append((i[0],
i[1],
i[2]))
if self.balas != 0:
datos.append(("", "", ""))
datos.append(("", "-" * 30 , "-" * 30))
datos.append(("", "", ""))
datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.kilos)), self.balas))
if self.rollos != 0:
datos.append(("", "", ""))
datos.append(("", "-" * 30 , "-" * 30))
datos.append(("", "", ""))
datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.metros)), self.rollos))
if (self.inicio) == None:
fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
if datos != []:
informes.abrir_pdf(geninformes.producido_produccion(datos, fechaInforme, self.grafico))
def __init__(self, objeto = None, usuario = None, fini = None, ffin = 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
Ventana.__init__(self, 'facturacion_por_cliente_y_fechas.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_imprimir/clicked': self.imprimir,
'cbe_cliente/changed': self.cambiar_cliente,
'b_fechaini/clicked': self.cambiar_fechaini,
'b_fechafin/clicked': self.cambiar_fechafin,
'b_export/clicked': self.exportar_a_csv, }
#'tv_facturas/row-expanded': self.expandir_subramas}
self.add_connections(connections)
self.wids['tv_facturas'].connect("row-expanded",
self.expandir_subramas)
self.inicializar_ventana()
if fini:
self.wids['e_fechaini'].set_text(utils.str_fecha(fini))
if ffin:
self.wids['e_fechafin'].set_text(utils.str_fecha(ffin))
if objeto != None:
utils.combo_set_from_db(self.wids['cbe_cliente'], objeto.id)
gtk.main()
def imprimir(self, boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
for i in self.resultado:
datos.append((i.cliente.nombre,
utils.str_fecha(i.fecha),
i.numpedido,
"%s €" % (utils.float2str(i.calcular_importe_total())),
i.bloqueado and "Sí" or "No",
i.cerrado and "Sí" or "No"))
datos.append(("", "", "", "---", "", ""))
datos.append(("%s pedidos listados." % (self.wids['e_total'].get_text()),
"",
"Importe total:",
self.wids['e_importe_total'].get_text(),
"",
""))
if (self.inicio) == None:
fechaInforme = 'Hasta ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio, "%Y/%m/%d")) + ' - ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
if datos != []:
informes.abrir_pdf(geninformes.pedidosCliente(datos, self.cliente and self.cliente.nombre or "?", fechaInforme))
def __init__(self, objeto = None, usuario = None):
Ventana.__init__(self, 'consulta_beneficio.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None),
('Nº Factura','gobject.TYPE_STRING', False, True, True, None),
('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Importe','gobject.TYPE_STRING', False, True, False, None),
('Base imponible','gobject.TYPE_STRING',
False, True, False, None),
('Beneficio sobre tarifa','gobject.TYPE_STRING',
False, True, False, None),
('Idfactura','gobject.TYPE_INT64', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for col in (self.wids['tv_datos'].get_columns()[0:2]
+ self.wids['tv_datos'].get_columns()[3:]):
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(0.5)
self.fin = datetime.date.today()
self.inicio = datetime.date(day = 1, month = self.fin.month, year = self.fin.year)
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
gtk.main()
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
lista = self.resultado
for elem in lista:
datos.append((elem.numpartida,
"%.2f" % elem.longitudinal,
"%.2f" % elem.transversal,
"%.2f" % elem.compresion,
"%.2f" % elem.perforacion,
"%.2f" % elem.permeabilidad,
"%.2f" % elem.poros,
"%.2f" % elem.piramidal,
"%.2f" % elem.espesor))
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 != []:
informes.abrir_pdf(geninformes.laboratorioPartidas(datos,
fechaInforme))
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).
"""
if utils.dialogo(titulo = "¿EXPORTAR A CSV?",
texto = "¿Quiere generar también un archivo CSV por "
"cada PDF que se cree a continuación?",
defecto = False,
tiempo = 15):
csv = True
ruta_csv = tempfile.NamedTemporaryFile(suffix = ".csv").name
else:
csv = False
ruta_csv = None
import informes
informes.abrir_pdf(geninformes.existencias_productos(
'rollos',
"%s, %s" % (utils.str_fecha(time.localtime()),
time.strftime("%H:%M")),
ruta_csv = ruta_csv))
if pclases.Almacen.select().count() > 1:
for a in pclases.Almacen.select():
if csv:
ruta_csv = tempfile.NamedTemporaryFile(
suffix = "_%s.csv" % a.nombre,
delete = False).name
informes.abrir_pdf(
geninformes.existencias_productos('rollos', "%s, %s" % (
utils.str_fecha(time.localtime()),
time.strftime("%H:%M")),
almacen = a,
ruta_csv = ruta_csv))
def refinar_resultados_busqueda(self, resultados):
"""
Muestra en una ventana de resultados todos los
registros de "resultados".
Devuelve el id (primera columna de la ventana
de resultados) de la fila seleccionada o None
si se canceló.
"""
filas_res = []
for r in resultados:
cliente = r.cliente
filas_res.append((r.id,
r.codigo,
cliente != None and cliente.nombre or "",
utils.str_fecha(r.fechaRecepcion),
"%s €" % (utils.float2str(r.cantidad)),
utils.str_fecha(r.fechaCobro),
r.pendiente and "Sí" or "No",
", ".join([c.numfactura for c in r.cobros])))
idpagare = utils.dialogo_resultado(filas_res,
titulo = 'Seleccione Pagaré',
cabeceras = ('ID', 'Número', 'Cliente', 'Fecha recepción',
'Importe', 'Vencimiento', 'Pendiente', 'Facturas'),
padre = self.wids['ventana'])
if idpagare < 0:
return None
else:
return idpagare
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
for i in self.resultado:
# if len(i.observaciones) > 35:
# observaciones = i.observaciones[:35]+'...'
# else:
# observaciones = i.observaciones # Ya administra bien el salto de línea. No hace falta cortar.
observaciones = i.observaciones # Ya administra bien el salto de línea. No hace falta cortar.
datos.append((i.tipoDeIncidencia.descripcion,
utils.str_hora_corta(i.horainicio),
utils.str_hora_corta(i.horafin),
utils.str_fecha(i.parteDeProduccion.fecha),
utils.str_hora_corta(i.parteDeProduccion.horainicio)+'-'+utils.str_hora_corta(i.parteDeProduccion.horafin),
observaciones))
if (self.inicio) == None:
fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
if datos != []:
informes.abrir_pdf(geninformes.incidencias(datos,fechaInforme))
def refinar_resultados_busqueda(self, resultados):
"""
Muestra en una ventana de resultados todos los
registros de "resultados".
Devuelve el id (primera columna de la ventana
de resultados) de la fila seleccionada o None
si se canceló.
"""
filas_res = []
for r in resultados:
filas_res.append((r.id,
r.numrecibo,
r.anno,
r.get_cliente() and r.get_cliente().nombre or "",
", ".join([f.numfactura for f
in r.get_facturas()]),
utils.float2str(r.calcular_importe()),
utils.str_fecha(r.fechaLibramiento),
utils.str_fecha(r.fechaVencimiento)
))
idrecibo = utils.dialogo_resultado(filas_res,
titulo = 'SELECCIONE RECIBO',
cabeceras = ('ID',
'Número',
'Año',
'Cliente',
'Facturas',
'Importe',
'Libramiento',
'Vencimiento'),
padre = self.wids['ventana'])
if idrecibo < 0:
return None
else:
return idrecibo
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import informes
datos = []
# for i in self.resultado:
# datos.append((i.cliente.nombre,
# utils.str_fecha(i.fecha),
# i.numalbaran,
# i.nombre))
model = self.wids['tv_datos'].get_model()
for i in model:
datos.append((i[0], i[1], i[2], i[3], i[5]))
if (self.inicio) == None:
fechaInforme = ('Hasta '
+ utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d")))
else:
fechaInforme = (
utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))
+ ' - '
+ utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d")))
if datos != []:
datos.append(("Total albaranes: ",
self.wids["e_total"].get_text(),
"", "", ""))
informes.abrir_pdf(
geninformes.albaranesCliente(datos,
self.cliente and self.cliente.nombre or "",
fechaInforme))
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).
"""
Ventana.__init__(self, "up_report_diario.glade", objeto)
self.objeto = objeto
self.usuario = usuario
self.inicializar_ventana()
connections = {
"b_salir/clicked": self.salir,
"b_imprimir/clicked": self.imprimir,
"b_refrescar/clicked": self.actualizar,
"b_send/clicked": self.enviar_por_correoe,
"b_fecha_ini/clicked": self.set_inicio,
"b_fecha_fin/clicked": self.set_fin,
}
self.add_connections(connections)
hoy = datetime.datetime.today()
self.wids["e_fecha_ini"].set_text(utils.str_fecha(hoy))
self.wids["e_fecha_fin"].set_text(utils.str_fecha(hoy))
self.dia_seleccionado, self.fechafin = self.get_fechas_mostradas()
self.fechaini = self.dia_seleccionado
self.actualizar()
gtk.main()
def __init__(self, objeto = None, usuario = None):
self.usuario = usuario
Ventana.__init__(self, 'consulta_ventas_ticket.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
cols = (('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('T./Alb./Fra.','gobject.TYPE_STRING',False,True,True,None),
('Imp. total', 'gobject.TYPE_STRING',False,True,False,None),
('Imp. (s/IVA)','gobject.TYPE_STRING',False,True,False,None),
('Ben. sobre tarifa', 'gobject.TYPE_STRING',
False, True, 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()[2:]:
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(0.5)
self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
self.fin = mx.DateTime.today()
#self.inicio = mx.DateTime.DateTimeFrom(day = 1, month = self.fin.month, year = self.fin.year)
self.inicio = self.fin
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
gtk.main()
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
Ventana.__init__(self, 'up_consulta_clientes_por_mes.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fechainicio/clicked': self.set_inicio,
'b_fechafin/clicked': self.set_fin,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Mes', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
('Clases a las que asistió',
'gobject.TYPE_STRING', False, True, False, None),
('PUDI_cliente', 'gobject.TYPE_STRING',
False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
col = self.wids['tv_datos'].get_column(2)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
hoy = datetime.date.today()
self.fechainicio = datetime.date(hoy.year, hoy.month, 1)
for i in range(28, 32):
try:
self.fechafin = datetime.date(hoy.year, hoy.month, i)
except ValueError:
pass
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.fechainicio))
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fechafin))
gtk.main()
def imprimir(self, boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
import sys, os
sys.path.append(os.path.join("..", "informes"))
from treeview2pdf import treeview2pdf
from informes import abrir_pdf
idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
if idcliente == None:
utils.dialogo_info(titulo = 'ERROR',
texto = 'Seleccione un cliente',
padre = self.wids['ventana'])
else:
idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
self.cliente = pclases.Cliente.get(idcliente)
cliente = self.cliente
if self.inicio == None:
fechaInforme = 'Hasta ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
else:
fechaInforme = utils.str_fecha(time.strptime(self.inicio, "%Y/%m/%d")) + ' - ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
strfecha = fechaInforme
informe = treeview2pdf(self.wids['tv_datos'],
titulo = "Productos comprados por " + cliente.nombre,
fecha = strfecha)
if informe:
abrir_pdf(informe)
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
global fin
Ventana.__init__(self, 'consulta_productividad.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Inicio del turno', 'gobject.TYPE_STRING',
False, True, False, None),
('Fin del turno', 'gobject.TYPE_STRING',
False, True, False, None),
('Producción', 'gobject.TYPE_STRING', False, True, False, None),
('Productividad', 'gobject.TYPE_STRING',
False, True, False, None),
('Idparte', 'gobject.TYPE_INT64', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_parte)
# XXX
import gobject
model = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_FLOAT,
gobject.TYPE_INT64)
self.wids['tv_datos'].set_model(model)
model.set_sort_func(0, utils.funcion_orden, 0)
cell = gtk.CellRendererProgress()
column = gtk.TreeViewColumn('', cell)
column.add_attribute(cell, 'value', 5)
column.set_sort_column_id(5)
self.wids['tv_datos'].insert_column(column, 5)
# XXX
self.wids['tv_datos'].add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.wids['tv_datos'].connect('button_press_event',
self.button_clicked)
# XXX
self.colorear(self.wids['tv_datos'])
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
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 = self.wids['e_fechainicio'].get_text().split('/')
self.inicio.reverse()
self.inicio = '/'.join(self.inicio)
gtk.main()
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
"""
model = self.wids['tv_datos'].get_model()
model.clear()
total = 0
vencido = 0
hoy = datetime.date.today()
por_fecha = {}
for i in items:
if not i[2]: # i[2] = False cuando es vencimiento normal de la BD
total += i[1].importe
importe = i[1].importe
anno = i[1].fecha.year
mes = i[1].fecha.month
if i[1].fecha < hoy:
vencido += i[1].importe
fra = i[1].facturaVenta or i[1].prefactura
model.append((fra.numfactura,
utils.str_fecha(i[1].fecha),
utils.float2str(importe),
i[1].observaciones,
fra.cliente.nombre,
"V:" + `i[1].id`))
else: # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
importe = i[1]['importe']
anno = i[1]['fecha'].year
mes = i[1]['fecha'].month
total += i[1]['importe']
if i[1]['fecha'] < hoy:
vencido += i[1]['importe']
model.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'],
"L:" + i[1]['id']))
if anno not in por_fecha:
por_fecha[anno] = {}
if mes not in por_fecha[anno]:
por_fecha[anno][mes] = 0.0
por_fecha[anno][mes] += importe
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
self.wids['e_vencido'].set_text("%s €" % utils.float2str(vencido))
# Relleno el model de totales.
annos = por_fecha.keys()
annos.sort()
model = self.wids['tv_totales'].get_model()
model.clear()
for anno in annos:
total_anno = sum([por_fecha[anno][mes] for mes in por_fecha[anno]])
anno_padre = model.append(None, (`anno`,
utils.float2str(total_anno),
""))
meses = por_fecha[anno].keys()
def get_txtfechavtopago(pago):
"""
Devuelve la fecha de vencimiento del propio pago.
"""
res = ""
if pago and pago.fecha:
res = utils.str_fecha(pago.fecha)
if pago.pagarePago:
res = utils.str_fecha(pago.pagarePago.fechaVencimiento)
return res
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
global fin
Ventana.__init__(self, "consulta_cobros.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 = (
("Fecha", "gobject.TYPE_STRING", False, True, True, None),
("Vencimientos", "gobject.TYPE_STRING", False, False, False, None),
("Factura(Cliente)", "gobject.TYPE_STRING", False, True, False, None),
("Cobros", "gobject.TYPE_STRING", False, False, False, None),
("Factura(Cliente)", "gobject.TYPE_STRING", False, True, False, None),
("id", "gobject.TYPE_STRING", False, False, False, None),
)
utils.preparar_treeview(self.wids["tv_datos"], cols)
col = self.wids["tv_datos"].get_column(1)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
col = self.wids["tv_datos"].get_column(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
cols2 = (
("Forma de pago", "gobject.TYPE_STRING", False, True, True, None),
("Factura", "gobject.TYPE_STRING", False, False, False, None),
("Cliente", "gobject.TYPE_STRING", False, True, False, None),
("Importe", "gobject.TYPE_STRING", False, False, False, None),
("PUID", "gobject.TYPE_STRING", False, False, False, None),
)
utils.preparar_treeview(self.wids["tv_datos_cobros_formapago"], cols2)
self.wids["tv_datos_cobros_formapago"].connect("row-activated", self.abrir_factura)
utils.preparar_treeview(self.wids["tv_datos_vtos_formapago"], cols2)
self.wids["tv_datos_vtos_formapago"].connect("row-activated", self.abrir_factura)
temp = time.localtime()
self.fin = str(temp[0]) + "/" + str(temp[1]) + "/" + str(temp[2])
self.wids["e_fechafin"].set_text(utils.str_fecha(temp))
tempinicio = datetime.date.today() - datetime.timedelta(days=1) * 30
tempinicio = utils.str_fecha(tempinicio)
self.inicio = tempinicio
self.wids["e_fechainicio"].set_text(tempinicio)
self.wids["e_estimados"].set_property("visible", False)
self.wids["label8"].set_property("visible", False)
gtk.main()
def get_txtfecha(pago, vto):
"""
Devuelve la fecha de vencimiento al que corresponde el pago. Si no hay
vencimiento, entonces la fecha del pago en sí. Y si no, cadena vacía.
"""
res = ""
if vto:
res = utils.str_fecha(vto.fecha)
elif pago and pago.fecha:
res = utils.str_fecha(pago.fecha)
return res
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
global fin
Ventana.__init__(self, 'consulta_pendientes_vto_bueno.glade', objeto,
usuario = self.usuario)
connections = {'b_salir/clicked': self.salir,
'b_pendientes/clicked': self.buscar,
'b_todas/clicked': self.buscar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre)
for c
in pclases.Proveedor.select(orderBy='nombre')])
cols = (('Factura', 'gobject.TYPE_STRING', False, True, True, None),
('Código vto. bueno', 'gobject.TYPE_STRING',
False, True, False, None),
('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, False, False, None),
('Fecha fra.', 'gobject.TYPE_STRING',
False, True, False, None),
('Fecha recepción', 'gobject.TYPE_STRING',
False, True, False, None),
('Automático', 'gobject.TYPE_BOOLEAN',
False, True, False, None),
('Usuario', 'gobject.TYPE_BOOLEAN', False, True, False, None),
('Técnico', 'gobject.TYPE_BOOLEAN', False, True, False, None),
('Comercial', 'gobject.TYPE_BOOLEAN',
False, True, False, None),
('D. General', 'gobject.TYPE_BOOLEAN',
False, True, False, None),
('id', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
self.colorear(self.wids['tv_datos'])
temp = time.localtime()
self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
self.inicio = self.fin - datetime.timedelta(days = 4 * 7)
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
sens = (self.usuario == None
or self.usuario.firmaUsuario
or self.usuario.firmaComercial
# or self.usuario.firmaTecnico
or self.usuario.firmaDirector
or self.usuario.firmaTotal)
self.wids['b_pendientes'].set_sensitive(sens)
self.wids['b_pendientes'].child.child.get_children()[1].set_text("Ver pendientes de mi firma (%s)" % (self.usuario and self.usuario.usuario or "cualquiera"))
gtk.main()
def rellenar_muestras(self):
"""
Rellena el TreeView de las muestras extraídas a la partida.
"""
model = self.wids['tv_muestras'].get_model()
model.clear()
if self.partida != None:
for m in self.partida.muestras:
model.append((m.codigo, m.observaciones, m.pendiente,
utils.str_fecha(m.envio),
utils.str_fecha(m.recepcion), m.id))
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)))
