def actualizar_asistencia(self, cell, path):
"""
Crea o elimina un registro pclases.Asistencia en función de si se
marca o se desmarca la casilla del TreeView.
"""
model = self.wids['tv_asistencias'].get_model()
model[path][1] = not model[path][1]
if model[path].parent:
clientes = [pclases.getObjetoPUID(model[path][-1])]
actividad = pclases.getObjetoPUID(model[path].parent[-1])
# Es un alumno, actualizo el padre si todos asisten.
z = model[path][1] and 1 or -1
model[path].parent[1] = (
len(actividad.asistencias) + z == len(actividad.clientes))
else:
actividad = pclases.getObjetoPUID(model[path][-1])
clientes = actividad.clientes
# Es todo el grupo. Actualizo sus hijos.
for iterhijo in model[path].iterchildren():
iterhijo[1] = model[path][1]
if model[path][1]:
for cliente in clientes:
if cliente not in [a.cliente for a in actividad.asistencias]:
pclases.Asistencia(cliente = cliente,
actividad = actividad,
fechahora = datetime.datetime.today(),
observaciones = "")
else:
asistencias = [a for a in actividad.asistencias
if a.cliente in clientes]
for asistencia in asistencias:
asistencia.destroySelf()
def facturar_seleccionado(self, boton):
"""
Factura las actividades seleccionadas.
"""
sel = self.wids['tv_datos'].get_selection()
model, iters = sel.get_selected_rows()
a_facturar = {}
for iter in iters:
puid = model[iter][-1]
try:
objeto = pclases.getObjetoPUID(puid)
except ValueError:
continue # Es una clase sin producto relacionado.
if isinstance(objeto, pclases.Cliente):
# Facturar todas las actividades del cliente.
for iterproducto in model[iter].iterchildren():
iterproducto = iterproducto.iter
for iteractividad in model[iterproducto].iterchildren():
try:
actividad=pclases.getObjetoPUID(iteractividad[-1])
except ValueError:
continue # Es una clase sin producto relacionado.
try:
a_facturar[objeto].append(actividad)
except KeyError:
a_facturar[objeto] = [actividad]
elif isinstance(objeto, pclases.ProductoCompra):
producto = objeto
puidcliente = model[iter].parent[-1]
cliente = pclases.getObjetoPUID(puidcliente)
for iterhijo in model[iter].iterchildren():
try:
actividad = pclases.getObjetoPUID(iterhijo[-1])
except ValueError:
continue # Es una clase sin producto relacionado.
try:
a_facturar[cliente].append(actividad)
except KeyError:
a_facturar[cliente] = [actividad]
elif isinstance(objeto, pclases.Actividad):
actividad = objeto
puid = model[iter].parent.parent[-1]
cliente = pclases.getObjetoPUID(puid)
try:
a_facturar[cliente].append(actividad)
except KeyError:
a_facturar[cliente] = [actividad]
# Como solo muestro una actividad por producto, para no
# multiplicar por el número de clases el importe del producto
# completo, ahora tengo que mandar a facturar todas las
# actividades del mismo producto que no han entrado en el model
# pero que están en self.resultado.
try:
producto = actividad.get_or_guess_productoCompra()
except UnboundLocalError: # No hay actividad a facturar. El
pass # cliente no tenía hijos o vete tú
else: # a saber.
a_facturar[cliente] += self.resultado[cliente][producto]
self.crear_facturas(a_facturar)
def cambiar_descripcion_actividad(self, cell, path, text):
model = self.wids['tv_actividades'].get_model()
puid = model[path][-1]
p = pclases.getObjetoPUID(puid)
p.descripcion = text
p.syncUpdate()
model[path][0] = p.descripcion
def abrir_factura(self, tv, path, view_column):
model = tv.get_model()
puid = model[path][-1]
if puid:
objeto = pclases.getObjetoPUID(puid)
if isinstance(objeto, pclases.FacturaVenta):
fra = objeto
try:
import facturas_venta
except ImportError:
from os.path import join as pathjoin
from sys import path
path.insert(0, pathjoin("..", "formularios"))
import facturas_venta
ventana = facturas_venta.FacturasVenta(fra, self.usuario)
elif isinstance(objeto, pclases.Cliente):
cliente = objeto
try:
import clientes
except ImportError:
from os.path import join as pathjoin
from sys import path
path.insert(0, pathjoin("..", "formularios"))
import clientes
ventana_clientes = clientes.Clientes(cliente, self.usuario)
def imprimir_ticket(self, boton):
"""
Genera un ticket en texto plano y lo lanza a la impresora de tickets.
"""
tv = self.wids['tv_datos']
model, iter = tv.get_selection().get_selected()
path = model.get_path(iter)
puid = model[path][-1]
if puid:
try:
objeto = pclases.getObjetoPUID(puid)
except:
return
if isinstance(objeto, pclases.FacturaVenta):
fra = objeto
if utils.dialogo(titulo = "¿IMPRIMIR TICKET?",
texto = "¿Desea imprimir el ticket?\n\n\n"
"Necesitará una impresora de tickets \n"
"encendida y conectada al puerto paralelo.\n"
"En otro caso se provocará un error.",
padre = self.wids['ventana'],
defecto = True,
tiempo = 20):
imprimir_ticket_from_factura(fra)
self.preguntar_si_cobrado(fra)
def drop_actividad(self, boton):
sel = self.wids['tv_actividades'].get_selection()
model, iters = sel.get_selected_rows()
for iter in iters:
puid = model[iter][-1]
actividad = pclases.getObjetoPUID(puid)
actividad.destroySelf()
self.rellenar_tabla_actividades()
def abrir_cliente(self, tv, path, cv):
model = tv.get_model()
puid = model[path][-1]
print puid
if puid:
objeto = pclases.getObjetoPUID(puid)
import clientes
v = clientes.Clientes(usuario = self.usuario,
objeto = objeto)
def drop_docpago(self, boton):
"""
Elimina el documento de pago seleccionado.
"""
sel = self.wids["tv_documentos_pago"].get_selection()
model, iter = sel.get_selected()
if iter:
objeto = pclases.getObjetoPUID(model[iter][-1])
objeto.destroy_en_cascada()
model.remove(iter)
def abrir_factura(self, tv, path, view_column):
"""
Abre la factura a la que pertenece el vencimiento sobre el que se ha
hecho doble clic.
"""
model = tv.get_model()
puid = model[path][-1]
fra = pclases.getObjetoPUID(puid)
if isinstance(fra, pclases.FacturaVenta):
import facturas_venta
v = facturas_venta.FacturasVenta(fra, usuario = self.usuario)
def abrir_cliente(self, tv, path, cv):
"""
Abre el cliente seleccionado en una nueva ventana.
"""
model = tv.get_model()
while model[path].parent:
path = model[path].parent.path
puid = model[path][-1]
objeto = pclases.getObjetoPUID(puid)
import clientes
v = clientes.Clientes(objeto, usuario = self.usuario)
def abrir_grupo(self, tv, path, cv, dia):
"""
Abre el grupo al que se le ha hecho doble clic. Recibe el día, pero
no se llega a usar.
"""
model = tv.get_model()
puid = model[path][-1]
objeto = pclases.getObjetoPUID(puid)
if isinstance(objeto, pclases.Actividad):
actividad = objeto
grupo = actividad.grupoAlumnos
elif isinstance(objeto, pclases.Asistencia):
grupo = objeto.actividad.grupo
elif isinstance(objeto, pclases.Cliente):
puidgrupo = model[path].parent[-1]
grupo = pclases.getObjetoPUID(puidgrupo)
else:
grupo = objeto
if grupo: # Es posible que no esté asignado, aunque en ese caso no
# aparecería en el TreeView, pero por si las moscas.
import grupos_alumnos
v = grupos_alumnos.GruposAlumnos(grupo, usuario = self.usuario)
def cambiar_fin_actividad(self, cell, path, text):
model = self.wids['tv_actividades'].get_model()
puid = model[path][-1]
p = pclases.getObjetoPUID(puid)
try:
p.fechahoraFin = utils.parse_fechahora(text)
p.syncUpdate()
except (TypeError, ValueError):
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "La fecha %s no es correcta." % text,
padre = self.wids['ventana'])
else:
model[path][3] = utils.str_fechahora(p.fechahoraFin)
def drop_cliente(self, boton):
for tvname in ("tv_clientes", "tv_espera"):
sel = self.wids[tvname].get_selection()
model, iters = sel.get_selected_rows()
for iter in iters:
puid = model[iter][-1]
cliente = pclases.getObjetoPUID(puid)
# Lo elimino de las clases no dadas:
if not self.objeto.en_lista_de_espera(cliente):
acts = self.objeto.get_actividades_pendientes()
for a in acts:
a.removeCliente(cliente)
cliente.removeGrupoAlumnos(self.objeto)
self.rellenar_tabla_clientes()
def abrir_producto(self, tv, path, column):
"""
Abre el producto al que se le ha hecho doble clic en una ventana nueva.
"""
model = tv.get_model()
puid = model[path][-1]
producto = pclases.getObjetoPUID(puid)
if producto.es_rollo():
import productos_de_venta_rollos
V = productos_de_venta_rollos.ProductosDeVentaRollos
ventana_producto = V(producto, usuario = self.usuario)
elif producto.es_bala() or producto.es_bigbag() or producto.es_bolsa():
import productos_de_venta_balas
V = productos_de_venta_balas.ProductosDeVentaBalas
ventana_producto = V(producto, usuario = self.usuario)
def abrir_factura(self, tv, path, cv):
"""
Abre la factura relacionada con el cobro o el vencimiento.
"""
model = tv.get_model()
puid = model[path][-1]
if puid:
objeto = pclases.getObjetoPUID(puid)
factura = objeto.get_factura_o_prefactura()
if isinstance(factura, pclases.FacturaVenta):
import facturas_venta
v = facturas_venta.FacturasVenta(factura, usuario=self.usuario)
elif isinstance(factura, pclases.Prefactura):
import prefacturas
v = prefacturas.Prefacturas(factura, usuario=self.usuario)
def abrir_calendario(self, tv, path, cv):
"""
Abre el calendario con el día del evento seleccionado.
"""
model = tv.get_model()
puid = model[path][-1]
if puid:
objeto = pclases.getObjetoPUID(puid)
if hasattr(objeto, "fechahoraInicio"):
import up_calendario
v = up_calendario.Calendario(usuario=self.usuario, objeto=objeto)
elif isinstance(objeto, pclases.Cobro):
fra = objeto.facturaVenta
import facturas_venta
v = facturas_venta.FacturasVenta(usuario=self.usuario, objeto=fra)
def mostrar_info_factura(self, tv):
"""
Rellena la información de la factura en los "entries": importe y forma
de pago.
"""
model, iter = tv.get_selection().get_selected()
if iter:
path = model.get_path(iter)
puid = model[path][-1]
if puid:
try:
objeto = pclases.getObjetoPUID(puid)
except:
return
if isinstance(objeto, pclases.FacturaVenta):
fra = objeto
importe = fra.calcular_total()
formapago = fra.get_forma_de_pago()
self.wids['e_importe'].set_text(utils.float2str(importe))
self.wids['e_formapago'].set_text(formapago)
def imprimir(self, boton):
# OJO: Como no hay catálogo de pruebas en la base de datos, las
# unidades, métodos y descripciones de las pruebas sobre geotextiles
# están HARCODED aquí.
# PLAN: Meter todo esto en el tablas.sql, como debe de ser.
data_prueba = {
"Resistencia longitudinal":
{"descripción": "Resistencia a la tracción DM",
"método": "EN ISO 10319",
"unidad": "kN/m"},
"Resistencia transversal":
{"descripción": "Resistencia a la tracción DT",
"método": "EN ISO 10319",
"unidad": "kN/m"},
"Alargamiento longitudinal":
{"descripción": "Alargamiento DM",
"método": "EN ISO 10319",
"unidad": "%"},
"Alargamiento transversal":
{"descripción": "Alargamiento DT",
"método": "EN ISO 10319",
"unidad": "%"},
"Perforación":
{"descripción":
"Resistencia a la perforación dinámica (Caída de cono)",
"método": "EN ISO 13433",
"unidad": "mm"},
"Resistencia a la compresión":
{"descripción":
"Resistencia al punzonado estático (CBR a perforación)",
"método": "EN ISO 12236",
"unidad": "kN"},
"Apertura de poros":
{"descripción": "Medida de apertura (Porometría 090)",
"método": "EN ISO 12956",
"unidad": "mm"},
"Punzonado piramidal":
{"descripción": "Resistencia al punzonado piramidal",
"método": "NF G38-019",
"unidad": "kN"},
"Permeabilidad":
{"descripción": "Permeabilidad perpendicular al agua",
"método": "EN ISO 11058",
"unidad": "l/m²/s"},
"Gramaje":
{"descripción": "Gramaje",
"método": "EN ISO 9864",
"unidad": "g/m²"},
"Espesor":
{"descripción": "Espesor bajo 2 kPa",
"método": "EN ISO 9863-1",
"unidad": "mm"}
}
if not self.objeto:
return
#tv = self.wids['tv_datos']
#from treeview2pdf import treeview2pdf
from informes import abrir_pdf
#strfecha = "%s - %s" % (utils.str_fecha(mx.DateTime.localtime()),
# utils.str_hora(mx.DateTime.localtime()))
#abrir_pdf(treeview2pdf(tv,
# titulo = "Certificado de calidad de albarán %s" % (
# self.objeto.numalbaran),
# fecha = strfecha,
# apaisado = False))
path_informes = os.path.join("..", "informes")
if path_informes not in sys.path:
sys.path.append(path_informes)
import informe_certificado_calidad
from geninformes import give_me_the_name_baby
from time import sleep
dic_productos = {}
model = self.wids['tv_datos'].get_model()
for fila in model:
producto = pclases.getObjetoPUID(fila[-1])
dic_productos[producto] = {}
for hijo in fila.iterchildren():
caracteristica = hijo[0]
valor = hijo[-2]
dic_productos[producto][caracteristica] = {
"descripción": data_prueba[caracteristica]["descripción"],
"método": data_prueba[caracteristica]["método"],
"unidad": data_prueba[caracteristica]["unidad"],
"valor": valor}
for producto in dic_productos:
dic_valores = dic_productos[producto]
if producto.es_rollo():
orden = ("Resistencia longitudinal",
"Resistencia transversal",
"Alargamiento longitudinal",
"Alargamiento transversal",
"Perforación",
"Resistencia a la compresión",
"Apertura de poros",
"Permeabilidad",
"Gramaje",
"Espesor",
"Punzonado piramidal")
nomfich = informe_certificado_calidad.go(
"certcalidad_%s.pdf" % give_me_the_name_baby(),
producto,
dic_valores,
pclases.DatosDeLaEmpresa.select()[0],
self.objeto,
orden = orden)
sleep(1)
abrir_pdf(nomfich)
def abrir_trazabilidad(tv, path, view_col, usuario):
puid = tv.get_model()[path][-1]
objeto = pclases.getObjetoPUID(puid)
import trazabilidad_articulos
v = trazabilidad_articulos.TrazabilidadArticulos(usuario = usuario,
objeto = objeto)
def cambiar_observaciones_pagare(self, cell, path, texto):
model = self.wids['tv_documentos_pago'].get_model()
puid = model[path][-1]
objeto = pclases.getObjetoPUID(puid)
objeto.observaciones = texto
model[path][4] = objeto.observaciones
def abrir_objeto(self, tv, path, view_col):
puid = tv.get_model()[path][-1]
o = pclases.getObjetoPUID(puid)
if isinstance(o, pclases.FacturaCompra):
from facturas_compra import FacturasDeEntrada as NewW
elif isinstance(o, pclases.Proveedor):
from proveedores import Proveedores as NewW
elif isinstance(o, pclases.AlbaranEntrada):
from albaranes_de_entrada import AlbaranesDeEntrada as NewW
elif isinstance(o, pclases.LineaDeCompra):
if o.facturaCompra:
from facturas_compra import FacturasDeEntrada as NewW
o = o.facturaCompra
elif o.albaranEntrada:
from albaranes_de_entrada import AlbaranesDeEntrada as NewW
o = o.albaranEntrada
else:
o = None
elif isinstance(o, pclases.TransporteACuenta):
if o.proveedor:
from proveedores import Proveedor as NewW
o = o.proveedor
else:
from albaranes_de_salida import AlbaranesDeSalida as NewW
o = o.albaranSalida
elif isinstance(o, pclases.ServicioTomado):
if o.facturaCompra:
from facturas_compra import FacturasDeEntrada as NewW
o = o.facturaCompra
elif o.comision:
if o.comision.facturaVenta:
from facturas_venta import FacturasVenta as NewW
o = o.comision.facturaVenta
elif o.comision.albaranSalida:
from albaranes_de_salida import AlbaranesDeSalida as NewW
o = o.comision.albaranSalida
else:
o = None
else:
o = None
elif isinstance(o, pclases.AlbaranSalida):
from albaranes_de_salida import AlbaranesDeSalida as NewW
else:
o = None
if o:
self.wids['ventana'].window.set_cursor(
gtk.gdk.Cursor(gtk.gdk.WATCH))
while gtk.events_pending(): gtk.main_iteration(False)
if not self.usuario:
self.wids['ventana'].window.set_cursor(None)
v = NewW(objeto = o, usuario = self.usuario)
else:
try:
ventana = pclases.Ventana.selectBy(
fichero = NewW.__module__)[0]
except IndexError:#¿Ventana no está dada de alta en el sistema?
self.wids['ventana'].window.set_cursor(None)
v = NewW(objeto = o, usuario = self.usuario)
else:
if self.usuario.get_permiso(ventana):
self.wids['ventana'].window.set_cursor(None)
v = NewW(objeto = o, usuario = self.usuario)
else:
utils.dialogo_info(titulo = "USUARIO SIN PERMISO",
texto = "Carece de permiso para abrir el elemento"
"en una ventana nueva.",
padre = self.wids['ventana'])
