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
if isinstance(fechaintermedia, datetime.date):
fechaintermedia += datetime.timedelta(1)
else:
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
"""
from formularios import reports
from informes.treeview2pdf import treeview2pdf
tv = self.wids['tv_datos']
titulo = "Ofertas"
totales = [6]
extra_data = []
if self.inicio:
titulo += " desde %s" % utils.str_fecha(self.inicio)
if self.fin:
titulo += " hasta %s" % utils.str_fecha(self.fin)
#import tempfile
#ruta_grafico = tempfile.NamedTemporaryFile(suffix = ".png").name
#win = self.wids['eventbox_chart'].window
#ancho, alto = win.get_size()
#pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, ancho, alto)
#captura = pb.get_from_drawable(win, win.get_colormap(), 0, 0, 0, 0,
# ancho, alto)
# Por algún motivo, que tendrá que ver con los dpi, ppp o cualquiera
# sabe qué complejo cálculo gráfico, la imagen sale muy grande en el
# PDF. La reduzco cutremente:
#escalado = captura.scale_simple(int(ancho * 0.75), int(alto * 0.75),
# gtk.gdk.INTERP_TILES)
#escalado.save(ruta_grafico, "png")
reports.abrir_pdf(treeview2pdf(tv,
titulo = titulo,
numcols_a_totalizar = totales,
#graficos = [ruta_grafico],
extra_data = extra_data))
def rellenar_tabla(self, filtro=None):
" Rellena el model con los items de la consulta. """
facturas = pclases.FacturaVenta.select(orderBy='fecha')
model = self.wids['tv_datos'].get_model()
model.clear()
for factura in facturas:
if filtro == factura.estado():
continue
if factura.estado() == "No enviado":
pdf = "factura_" + factura.numfactura.__str__()
pdf.replace("/", "_")
if (factura.cliente.email and enviar_correo("Factura",
factura.cliente.email, "Texto de prueba", [pdf])):
factura.observaciones = "Correo enviado"
importe = factura.calcular_importe_total(iva=True)
model.append((factura.id,
factura.numfactura,
factura.cliente.nombre,
utils.str_fecha(factura.fecha),
#utils.float2str(importe),
str(importe),
factura.estado(),#TODO "Pagado o no pagado
utils.str_fecha(factura.fecha_vencimiento()),
utils.str_fecha(factura.fecha_pago()),
factura.id))
self.colorear(self.wids['tv_datos'])
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):
"""
Prepara la vista preliminar para la impresión del informe
"""
from formularios import reports
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 != []:
reports.abrir_pdf(geninformes.laboratorioPartidas(datos, fechaInforme))
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, usuario = usuario)
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 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 inicializar_ventana(self):
"""
Inicializa los controles de la ventana, estableciendo sus
valores por defecto, deshabilitando los innecesarios,
rellenando los combos, formateando el TreeView -si lo hay-...
"""
# Inicialmente no se muestra NADA. Sólo se le deja al
# usuario la opción de buscar o crear nuevo.
self.activar_widgets(False)
# Inicialización del resto de widgets:
camps = [(c.id, "%s - %s" % (utils.str_fecha(c.fechaInicio),
utils.str_fecha(c.fechaFin)))
for c in pclases.Campanna.select(orderBy = "fechaInicio")]
utils.rellenar_lista(self.wids['cb_campanna'], camps)
self.wids['b_guardar'] = gtk.Button("N/A")
self.wids['b_guardar'].set_property("visible", False)
self.wids['b_guardar'].set_sensitive(False)
i = -1
anno_actual = mx.DateTime.localtime().year
model = self.wids['cb_campanna'].get_model()
for i in range(len(model)):
if str(anno_actual) in model[i][1]:
break
# Y si el año no está, se queda en la última campaña.
self.wids['cb_campanna'].set_active(i)
def __init__(self, objeto = None, usuario = None):
Ventana.__init__(self, 'consulta_beneficio.glade', objeto, 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}
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 = mx.DateTime.localtime()
self.inicio = mx.DateTime.DateTimeFrom(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):
"""
Crea un PDF con el contenido del TreeView.
"""
datos = []
model = self.wids['tv_rollos'].get_model()
for i in model:
pas = pclases.AlbaranSalida
if i[4] == "-" or pas.str_tipos[pas.MOVIMIENTO] in i[4]:
en_almacen = i[6]
else:
en_almacen = ""
if ( (self.wids['ch_filtrar'].get_active()
and i[4] == "-"
or pas.str_tipos[pas.MOVIMIENTO] in i[4])
or
(not self.wids['ch_filtrar'].get_active())):
datos.append((i[0], i[1], i[3], i[4], en_almacen, i[5]))
datos.append(("---", ) * 6)
datos.append(("Total almacén (no defectuosos):", self.wids['e_total_almacen'].get_text(), "Total fabricado (incluye defectuosos):", self.wids['e_total_fabricado'].get_text(), ""))
if not self.inicio:
fechaInforme = 'Hasta: %s' % (utils.str_fecha(self.fin))
else:
fechaInforme = utils.str_fecha(self.inicio) + ' - ' + utils.str_fecha(self.fin)
if datos != []:
desc_producto = self.wids['e_descripcion'].get_text()
listado_pdf = geninformes.listado_rollos(datos, desc_producto,
fechaInforme)
from formularios import reports
reports.abrir_pdf(listado_pdf)
def __init__(self, objeto = None, usuario = None):
self.usuario = usuario
Ventana.__init__(self, 'consulta_ventas_ticket.glade', objeto, 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}
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 = 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))
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
"""
from informes.treeview2pdf import treeview2pdf
from formularios.reports 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 not self.inicio:
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 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 __init__(self, objeto=None, usuario=None):
self.usuario = usuario
Ventana.__init__(self, "consulta_ventas_por_producto.glade", objeto, usuario=usuario)
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,
"e_fechainicio/focus-out-event": act_fecha,
"e_fechafin/focus-out-event": act_fecha,
"b_map/clicked": self.exportar_a_html,
}
self.add_connections(connections)
# TreeViews de fibra y cemento
cols = [
("Producto", "gobject.TYPE_STRING", False, True, True, None),
("kg A", "gobject.TYPE_STRING", False, True, False, None),
("# A", "gobject.TYPE_STRING", False, True, False, None),
("kg B", "gobject.TYPE_STRING", False, True, False, None),
("# B", "gobject.TYPE_STRING", False, True, False, None),
("kg C", "gobject.TYPE_STRING", False, True, False, None),
("# C", "gobject.TYPE_STRING", False, True, False, None),
("Total kg", "gobject.TYPE_STRING", False, True, False, None),
("Total #", "gobject.TYPE_STRING", False, True, False, None),
("PUID", "gobject.TYPE_STRING", False, False, False, None),
]
for tv in (self.wids["tv_fibra"], self.wids["tv_cem"]):
utils.preparar_treeview(tv, cols)
tv.connect("row-activated", self.abrir_producto_albaran_o_abono)
for n in range(1, 9):
tv.get_column(n).get_cell_renderers()[0].set_property("xalign", 1)
# TreeView de geotextiles
cols.insert(1, ("m² A", "gobject.TYPE_STRING", False, True, False, None))
cols.insert(4, ("m² B", "gobject.TYPE_STRING", False, True, False, None))
cols.insert(7, ("m² C", "gobject.TYPE_STRING", False, True, False, None))
cols.insert(10, ("Total m²", "gobject.TYPE_STRING", False, True, False, None))
utils.preparar_treeview(self.wids["tv_gtx"], cols)
self.wids["tv_gtx"].connect("row-activated", self.abrir_producto_albaran_o_abono)
tv = self.wids["tv_gtx"]
for n in range(1, 13):
tv.get_column(n).get_cell_renderers()[0].set_property("xalign", 1)
# TreeView de otros
cols = [
("Producto", "gobject.TYPE_STRING", False, True, True, None),
("Cantidad", "gobject.TYPE_STRING", False, True, False, None),
("PUID", "gobject.TYPE_STRING", False, False, False, None),
]
utils.preparar_treeview(self.wids["tv_otros"], cols)
self.wids["tv_otros"].connect("row-activated", self.abrir_producto_albaran_o_abono)
tv = self.wids["tv_otros"]
tv.get_column(1).get_cell_renderers()[0].set_property("xalign", 1)
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 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 enviar_correo_visitas_confirmadas(self, confirmadas = []):
"""
Igual que en ofertas, se envía un correo a quien corresponde con el
resumen del día, destacando las recién confirmadas.
"""
dests = select_correo_validador(self.usuario,
copia_a_dircomercial = True)
if not isinstance(dests, (list, tuple)):
dests = [dests]
servidor = self.usuario.smtpserver
smtpuser = self.usuario.smtpuser
smtppass = self.usuario.smtppassword
rte = self.usuario.email
year, month, day = self.wids['calendario'].get_date()
fecha = datetime.date(year = year, month = month, day = day)
texto = "Resumen de visitas de %s para el día %s:\n\n" % (
self.objeto.get_nombre_completo(),
utils.str_fecha(fecha))
# TODO: Empepinar el correo usando una tabla HTML. No es tan difícil.
for row in self.wids['tv_visitas'].get_model():
visita = pclases.getObjetoPUID(row[-1])
if not visita.enviada:
continue
texto += "%s%s\t%s%s\t%s\t%s\t%s%s\n" % (
visita in confirmadas and "*" or "",
utils.str_hora_corta(visita.fechahora),
visita.nombrecliente,
visita.cliente and "" or " (+)",
visita.lugar and visita.lugar or "",
visita.motivoVisita and visita.motivoVisita.motivo or "",
visita.observaciones,
visita in confirmadas and "*" or ""
)
ok = utils.enviar_correoe(rte,
dests,
"Parte de visitas confirmado (%s)"
% utils.str_fecha(fecha),
texto,
servidor = servidor,
usuario = smtpuser,
password = smtppass)
if ok:
self.to_log(
"Usuario %s envió correo de confirmación de visitas "
"para el día %s."
% (self.usuario and self.usuario.usuario or "¡NADIE!",
utils.str_fecha(fecha)),
nivel = 3) # info
else:
self.to_log(
"Falló envío de correo de solicitud de validación de la "
"oferta %s del usuario %s."
% (utils.str_fecha(fecha),
self.usuario and self.usuario.usuario or "¡NADIE!"),
nivel = 1) # error
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 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, mx.DateTime.RangeError,
# pero me curo en salud y capturo todas.
entry.set_text(utils.str_fecha(utils.mostrar_calendario(padre=padre)))
def rellenar_cultivos(self):
model = self.wids['tv_cultivos'].get_model()
model.clear()
for p in self.objeto.cultivos:
model.append((p.cultivo,
p.variedad,
utils.str_fecha(p.siembra),
utils.str_fecha(p.recoleccionInicio),
utils.str_fecha(p.recoleccionFin),
p.hidroponico,
p.tradicional,
p.id))
def rellenar_partes(self):
"""
Rellena el model con los partes no bloqueados.
"""
model = self.wids['tv_partes'].get_model()
# Primero verifico los que ya estaban (si es que había alguno):
for fila in model:
idparte = fila[-1]
try:
pdp = pclases.ParteDeProduccion.get(idparte)
except pclases.SQLObjectNotFound:
continue # El parte se ha borrado entre actualización y
# actualización de la ventana.
pdp.sync() # ¿Hay algún cambio pendiente de rescatar en local?
if pdp.se_solapa():
self.logger.warning("%spartes_no_bloqueados::rellenar_partes"
" -> El parte ID %d se solapa con otros de la misma línea."
"Si estaba verificado, lo desbloqueo para que se vuelva a"
" revisar." % (self.usuario
and self.usuario.usuario + ": " or "", pdp.id))
pdp.bloqueado = False
# Y ahora meto los de la consulta real:
model.clear()
self.wids['tv_partes'].freeze_child_notify()
self.wids['tv_partes'].set_model(None)
vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
i = 0.0
partes = pclases.ParteDeProduccion.select(
pclases.ParteDeProduccion.q.bloqueado == False, orderBy = "id")
tot = partes.count()
for parte in partes:
vpro.set_valor(i/tot, 'Recuperando parte %s'
% utils.str_fecha(parte.fecha))
parte.sync() # ¿Algún cambio en la BD no rescatado en local?
i += 1
lotepartida = "CLIC PARA VER"
if (self.wids['rb_todos'].get_active() or
(self.wids['rb_balas'].get_active() and parte.es_de_balas()) or
(self.wids['rb_rollos'].get_active() and parte.es_de_rollos())
or self.wids['rb_bolsas'].get_active() and parte.es_de_bolsas()
):
model.append(("CLIC PARA VER",
utils.str_fecha(parte.fecha),
parte.horainicio.strftime('%H:%M'),
parte.horafin.strftime('%H:%M'),
parte.bloqueado,
lotepartida,
parte.id))
self.wids['tv_partes'].set_model(model)
self.wids['tv_partes'].thaw_child_notify()
vpro.ocultar()
def __init__(self, objeto = None, usuario = None, gui = True):
"""
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).
Si `gui` es True, tira de Gtk para preguntar, exportar y abrir los
PDF. En otro caso devuelve los nombres de fichero por salida estándar.
"""
if gui:
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
else:
csv = False
ruta_csv = None
ruta_pdf = geninformes.existencias_productos(
'rollos',
"%s, %s" % (utils.str_fecha(time.localtime()),
time.strftime("%H:%M")),
ruta_csv = ruta_csv)
self.fich_generados = [ruta_pdf]
if gui:
from formularios import reports
reports.abrir_pdf(ruta_pdf)
if pclases.Almacen.select(pclases.Almacen.q.activo==True).count() > 1:
for a in pclases.Almacen.select(pclases.Almacen.q.activo == True):
if csv:
ruta_csv = tempfile.NamedTemporaryFile(
suffix = "_%s.csv" % a.nombre,
delete = False).name
ruta_pdf = geninformes.existencias_productos('rollos',
"%s, %s" % (
utils.str_fecha(time.localtime()),
time.strftime("%H:%M")),
almacen = a,
ruta_csv = ruta_csv)
self.fich_generados.append(ruta_pdf)
if gui:
reports.abrir_pdf(ruta_pdf)
if not gui:
try:
sys.stdout.write("\n".join(self.fich_generados))
sys.stdout.write("\n")
except IOError:
pass # No tengo salida estándar.
def agregar_factura_de_abono(self, f, model, total, vencido):
vtos = []
vtos_emparejados = f.emparejar_vencimientos()
for vto in vtos_emparejados['vtos']:
try:
cobro = vtos_emparejados[vto][0]
except IndexError:
cobro = None
vtos.append([vto, None, cobro])
# OJO: A diferencia que con el emparejar_vencimientos de pclases.FacturaCompra, no debería haber más de un
# cobro por vencimiento en los abonos ni haber cobros sin vencimientos (clave None del diccionario), ya
# que los vencimientos son ficticios, no se corresponden con ningún registro de la BD (es una clase "closured")
# y se crean sobre la marcha en la función. Como tampoco se permite asociar una misma factura de abono a más
# de un cobro (bien en factura o bien en pagaré), nunca habrá más de un "vencimiento" por abono.
# XXX: Hasta aquí lo que hace el preparar_vencimientos con las facturasVenta. Ahora a agregarlo al TreeView.
vtos = [v for v in vtos if (v[2]==None or (v[2].pagareCobro != None and v[2].pagareCobro.pendiente)) and v[0] != None]
# Todos los que no tienen pagaré o si lo tienen, que esté pendiente
# y los que sean realmente vencimientos (hay entradas en vtos que pueden tener v[0] a None).
for v in vtos:
if v[2]!=None and v[2].pagareCobro!=None:
pagare = v[2].pagareCobro
else:
pagare = None
fechavto = pagare and pagare.fechaCobro or v[0].fecha # Fecha del vencimiento final: la del vencimiento de la factura
# si no tiene pagaré o la del vencimiento del pagaré que cubre
# el vencimiento de la factura.
mes = utils.corregir_nombres_fecha(fechavto.strftime("%B '%y"))
primero_mes = mx.DateTime.DateTimeFrom(day = 1, month = fechavto.month, year = fechavto.year)
try:
rowpadre = [r for r in model if r[2] == mes][0]
padre = rowpadre.iter
except IndexError:
padre = model.append(None, ("", utils.str_fecha(primero_mes), mes, 0.0, "", "", 0))
factura = v[0].get_factura_o_prefactura()
model.append(padre, ("%s (%s)" % (factura.numfactura, factura.cliente and factura.cliente.nombre or "Sin cliente"),
utils.str_fecha(factura.fecha),
utils.str_fecha(v[0].fecha),
v[0].importe,
pagare and "%s (%s)" % (pagare.codigo, utils.str_fecha(pagare.fechaRecepcion)) or '',
pagare and utils.str_fecha(pagare.fechaCobro) or '',
pagare and pagare.id or v[0].id)
)
total += v[0].importe
model[padre][3] += v[0].importe
if pagare:
if pagare.fechaCobro <= mx.DateTime.localtime():
vencido += v[0].importe
else:
if v[0].fecha <= mx.DateTime.localtime():
vencido += v[0].importe
# NOTA: Si la fecha del vencimiento ha vencido pero la del pagaré no, no la cuento como pendiente.
return total, vencido
def set_fecha(self, boton):
"""
Muestra el diálogo de selección de fecha en calendario.
"""
if "inicio" in boton.name:
e = self.wids['e_fecha_inicio']
elif "fin" in boton.name:
e = self.wids['e_fecha_fin']
else:
return
try:
e.set_text(utils.str_fecha(utils.mostrar_calendario(e.get_text(), self.wids['ventana'])))
except:
e.set_text(utils.str_fecha(utils.mostrar_calendario(padre = self.wids['ventana'])))
def add_efecto(self, boton):
"""
Añade un pagaré o un confirming a la remesa, creando si hace falta
el efecto "intermedio".
"""
efectos = []
# TODO: Aquí falta una barra de progreso y/o pedir un criterio de
# búsqueda. O bien abrir la ventana de consulta pero con un
# botón añadir a una remesa existente en lugar de "Generar".
for p in pclases.PagareCobro.select():
if not p.remesado and p.esta_pendiente():
if not p.efecto:
pclases.Efecto(pagareCobro = p,
confirming = None,
cuentaBancariaCliente = None)
efecto = p.efecto
efectos.append(efecto)
# Los confirming no se envían en remesas. Solo pagarés.
#for c in pclases.Confirming.select():
# if not c.remesado and c.esta_pendiente():
# if not c.efecto:
# pclases.Efecto(pagareCobro = None,
# confirming = c,
# cuentaBancariaCliente = None)
# efecto = c.efecto
# efectos.append(efecto)
efectos = [(e.id,
e. codigo,
e.cliente and e.cliente.nombre or "",
utils.float2str(e.cantidad),
utils.str_fecha(e.fechaVencimiento),
utils.str_fecha(e.fechaRecepcion),
e.get_str_tipo())
for e in efectos]
idefectos = utils.dialogo_resultado(efectos,
titulo = "SELECCIONE EFECTOS DE COBRO",
texto = "Seleccione uno o varios efectos a incluir en la remesa.",
padre = self.wids['ventana'],
cabeceras = ["ID", "Código", "Cliente", "Importe",
"Fecha de vencimiento", "Fecha de recepción", "Tipo"],
multi = True)
# FIXME: Ojo. No se hacen las comprobaciones de límite de
# concentraciones, disponible, etc. Ni siquiera se indican
# visualmente en la ventana los valores para ver si la remesa
# excede los límites aceptados por el banco.
for idefecto in idefectos:
efecto = pclases.Efecto.get(idefecto)
self.objeto.addEfecto(efecto)
if idefectos:
self.actualizar_ventana()
def imprimir(self, boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
from informes.treeview2pdf import treeview2pdf
from formularios.reports import abrir_pdf
if not self.inicio:
fecha_informe = 'Hasta ' + utils.str_fecha(self.fin)
else:
fecha_informe = (utils.str_fecha(self.inicio)
+ ' - '
+ utils.str_fecha(self.fin))
abrir_pdf(treeview2pdf(self.wids['tv_datos'],
titulo = "Consulta visitas realizadas",
fecha = fecha_informe))
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 imprimir(self, boton):
"""
Crea un impreso del albarán
"""
self.guardar(None) # Si se ha olvidado guardar, guardo yo.
from formularios import reports
albaran = self.objeto
if albaran.proveedor != None:
proveedor = albaran.proveedor.nombre
else:
proveedor = ''
pedidos = []
lineas = []
for l in albaran.lineasDeCompra:
if l.pedidoCompra != None:
numpedido = l.pedidoCompra.numpedido
else:
numpedido = '-'
lineas.append({'codigo': l.productoCompra.codigo, 'descripcion': l.productoCompra.descripcion, 'cantidad': l.cantidad, 'numped': numpedido })
if l.pedidoCompra != None and l.pedidoCompra.numpedido not in pedidos:
pedidos.append(l.pedidoCompra.numpedido)
cadenaPedidos = ','.join(pedidos)
general = {'albnum':albaran.numalbaran,
'fecha':utils.str_fecha(albaran.fecha),
'proveedor':proveedor,
'pednum':cadenaPedidos}
observaciones = utils.dialogo_entrada(titulo = 'OBSERVACIONES',
texto = '¿Desea incluir alguna observación en el albarán?',
padre = self.wids['ventana'])
if observaciones == None:
return
reports.abrir_pdf(geninformes.albaranEntrada(general, lineas, observaciones))
def rellenar_widgets(self):
"""
Introduce la información del albaran 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.
"""
albaran = self.objeto
self.wids['e_numalbaran'].set_text(albaran.numalbaran)
self.wids['e_fecha'].set_text(utils.str_fecha(albaran.fecha))
self.rellenar_tabla(self.wids['tv_ldvs'])
if albaran.proveedorID == None:
self.wids['cmbe_proveedor'].set_active(-1)
self.wids['cmbe_proveedor'].child.set_text("")
else:
utils.combo_set_from_db(self.wids['cmbe_proveedor'], albaran.proveedorID)
self.wids['e_facturas'].set_text(", ".join([f.numfactura for f in albaran.facturasCompra]))
self.wids['e_pedidos'].set_text(", ".join([p.numpedido for p in albaran.pedidosCompra]))
self.suspender(self.wids['cbe_almacen'])
utils.combo_set_from_db(self.wids['cbe_almacen'],
self.objeto.almacenID,
forced_value = self.objeto.almacen
and self.objeto.almacen.nombre or None)
self.revivir(self.wids['cbe_almacen'])
self.objeto.make_swap()
def add(self, w):
if self.loteCem != None:
model = self.wids['tv_pruebas'].get_model()
model.append((utils.str_fecha(time.localtime()),
"", "", "", "", "", "", "0,0,0,0,0,0"))
else:
print "WARNING: Se ha intentano añadir una prueba con loteCem = None"
