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 buscar(self, boton):
"""
Dadas fecha de inicio y de fin, lista todos los albaranes
pendientes de facturar.
"""
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:
pedidos = pclases.PedidoVenta.select(pclases.AND(
pclases.PedidoVenta.q.fecha <= self.fin,
pclases.PedidoVenta.q.clienteID == cliente.id),
orderBy = 'fecha')
else:
pedidos = pclases.PedidoVenta.select(pclases.AND(
pclases.PedidoVenta.q.fecha >= self.inicio,
pclases.PedidoVenta.q.fecha <= self.fin,
pclases.PedidoVenta.q.clienteID == cliente.id),
orderBy='fecha')
self.resultado = pedidos
self.rellenar_tabla(self.resultado)
def buscar(self, boton):
"""
Dadas fecha de inicio y de fin, lista todos los albaranes
pendientes de facturar.
"""
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:
facturas = pclases.FacturaVenta.select(pclases.AND(
pclases.FacturaVenta.q.clienteID == cliente.id,
pclases.FacturaVenta.q.fecha <= self.fin),
orderBy = 'fecha')
else:
facturas = pclases.FacturaVenta.select(pclases.AND(
pclases.FacturaVenta.q.fecha >= self.inicio,
pclases.FacturaVenta.q.fecha <= self.fin,
pclases.FacturaVenta.q.clienteID == cliente.id),
orderBy='fecha')
productos = []
for f in facturas:
for ldv in f.lineasDeVenta:
producto = ldv.producto
if producto not in productos:
productos.append(producto)
self.rellenar_tabla(productos)
def buscar(self,boton):
if self.inicio == None:
vencimientos = pclases.VencimientoCobro.select(
pclases.VencimientoCobro.q.fecha <= self.fin,
orderBy = 'fecha')
else:
vencimientos = pclases.VencimientoCobro.select(pclases.AND(
pclases.VencimientoCobro.q.fecha >= self.inicio,
pclases.VencimientoCobro.q.fecha <= self.fin),
orderBy='fecha')
idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
if idcliente != None:
cliente = pclases.Cliente.get(
utils.combo_get_value(self.wids['cmbe_cliente']))
vencimientos = [v for v in vencimientos
if (v.facturaVenta
and v.facturaVenta.clienteID == cliente.id)
or
(v.prefactura
and v.prefactura.clienteID == cliente.id)]
self.resultado = []
for i in vencimientos:
if not self.esta_cobrado(i):
self.resultado.append([i.fecha,i,False])
# XXX Esto estaba comentado. ¿Por qué? Ya sé el porqué. Porque de
# LOGIC solo sacamos las obligaciones de pago, no las de cobro.
#if idcliente == None: # Porque en Logic los clientes no son los mismos que
# # aquí (no están exactamente igual escritos)
# vencimientos_logic = self.buscar_vencimientos_logic(self.inicio, self.fin)
# for i in vencimientos_logic:
# self.resultado.append([i['fecha'],i,True])
# XXX
self.resultado.sort(self.por_fecha)
self.rellenar_tabla(self.resultado)
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 buscar(self,boton):
"""
Dadas fecha de inicio y de fin, lista todos los albaranes
pendientes de facturar.
"""
if self.inicio == None:
facturas = pclases.FacturaCompra.select(pclases.FacturaCompra.q.fecha <= self.fin, orderBy = 'fecha')
else:
facturas = pclases.FacturaCompra.select(sqlobject.AND(pclases.FacturaCompra.q.fecha >= self.inicio,pclases.FacturaCompra.q.fecha <= self.fin), orderBy='fecha')
idproveedor = utils.combo_get_value(self.wids['cmbe_proveedor'])
if idproveedor != None:
proveedor = pclases.Proveedor.get(utils.combo_get_value(self.wids['cmbe_proveedor']))
facturas = [v for v in facturas if v.proveedorID == proveedor.id]
self.resultado = []
condusuario = self.usuario == None or self.usuario.firmaTotal or self.usuario.firmaUsuario
condtecnico = self.usuario == None or self.usuario.firmaTotal or self.usuario.firmaTecnico
condcomercial = self.usuario == None or self.usuario.firmaTotal or self.usuario.firmaComercial
conddirector = self.usuario == None or self.usuario.firmaTotal or self.usuario.firmaDirector
for i in facturas:
if boton.name == "b_pendientes":
if condusuario and not i.vistoBuenoUsuario and i not in self.resultado:
self.resultado.append(i)
if condtecnico and not i.vistoBuenoTecnico and i not in self.resultado:
self.resultado.append(i)
if condcomercial and not i.vistoBuenoComercial and i not in self.resultado:
self.resultado.append(i)
if conddirector and not i.vistoBuenoDirector and i not in self.resultado:
self.resultado.append(i)
elif boton.name == "b_todas":
self.resultado.append(i)
self.resultado.sort(utils.cmp_fecha_id)
self.rellenar_tabla(self.resultado)
def buscar(self,boton):
"""
Dadas fecha de inicio y de fin, lista todos los albaranes
pendientes de facturar.
"""
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'])
# return
# Selecciono los albaranes de todos los clientes.
if self.inicio == None:
albaranes = pclases.AlbaranSalida.select(pclases.AlbaranSalida.q.fecha <= self.fin,
orderBy = 'fecha')
else:
albaranes = pclases.AlbaranSalida.select(sqlobject.AND(pclases.AlbaranSalida.q.fecha >= self.inicio,
pclases.AlbaranSalida.q.fecha <= self.fin),
orderBy='fecha')
else:
self.cliente = pclases.Cliente.get(utils.combo_get_value(self.wids['cmbe_cliente']))
cliente = self.cliente
if self.inicio == None:
albaranes = pclases.AlbaranSalida.select(sqlobject.AND(pclases.AlbaranSalida.q.fecha <= self.fin,
pclases.AlbaranSalida.q.clienteID == cliente.id),
orderBy = 'fecha')
else:
albaranes = pclases.AlbaranSalida.select(sqlobject.AND(pclases.AlbaranSalida.q.fecha >= self.inicio,
pclases.AlbaranSalida.q.fecha <= self.fin,
pclases.AlbaranSalida.q.clienteID == cliente.id),
orderBy='fecha')
self.resultado = albaranes
self.rellenar_tabla(self.resultado)
def es_diferente(self):
"""
Devuelve True si la información en pantalla es distinta a la
del objeto en memoria.
"""
albaran = self.objeto
if albaran == None: return False # Si no hay albaran activo, devuelvo que no hay cambio respecto a la ventana
condicion = (str(albaran.numalbaran) == self.wids['e_numalbaran'].get_text())
condicion = condicion and (utils.str_fecha(albaran.fecha) == self.wids['e_fecha'].get_text())
condicion = condicion and (utils.combo_get_value(self.wids['cmbe_proveedor']) == albaran.proveedorID)
condicion = condicion and (utils.combo_get_value(self.wids['cbe_almacenID']) == albaran.almacenID)
return not condicion # "condicion" verifica que sea igual
def buscar(self,boton):
"""
Dadas fecha de inicio y de fin, devuelve todos los vencimientos
no pagados al completo.
"""
if self.inicio == None:
vencimientos = pclases.VencimientoPago.select(
pclases.VencimientoPago.q.fecha <= self.fin,
orderBy = 'fecha')
estimados = pclases.EstimacionPago.select(
pclases.EstimacionPago.q.fecha <= self.fin,
orderBy = 'fecha')
else:
vencimientos = pclases.VencimientoPago.select(pclases.AND(
pclases.VencimientoPago.q.fecha >= self.inicio,
pclases.VencimientoPago.q.fecha <= self.fin),
orderBy='fecha')
estimados = pclases.EstimacionPago.select(pclases.AND(
pclases.EstimacionPago.q.fecha >= self.inicio,
pclases.EstimacionPago.q.fecha <= self.fin),
orderBy='fecha')
idproveedor = utils.combo_get_value(self.wids['cmbe_proveedor'])
if idproveedor != None:
idproveedor = utils.combo_get_value(self.wids['cmbe_proveedor'])
proveedor = pclases.Proveedor.get(idproveedor)
vencimientos = [v for v in vencimientos
if v.facturaCompra.proveedorID == proveedor.id]
estimados = [e for e in estimados
if e.facturaCompra.proveedorID == proveedor.id]
mostrar_solo_pendientes = self.wids['ch_pendientes'].get_active()
self.resultado = []
for i in vencimientos:
if not self.esta_pagado(i):
if ((mostrar_solo_pendientes and self.pagare_y_no_emitido(i))
or not mostrar_solo_pendientes):
self.resultado.append([i.fecha, i, False])
if idproveedor == None:
# Porque en Logic los proveedores no son los mismos que
# aquí (no están exactamente igual escritos)
vencimientos_logic = self.buscar_vencimientos_logic(self.inicio,
self.fin)
for i in vencimientos_logic:
self.resultado.append([i['fecha'], i, True])
self.resultado = self.filtrar_por_forma_de_pago(self.resultado)
self.resultado.sort(self.por_fecha)
self.rellenar_tabla(self.resultado)
def cambiar_datos_cliente(self, cbe):
"""
Machaca la información de los entries de los datos del cliente
del presupuesto si están vacíos.
"""
idcliente = utils.combo_get_value(cbe)
if not idcliente:
return
cliente = pclases.Cliente.get(idcliente)
if not self.wids["e_persona_contacto"].get_text():
self.wids["e_persona_contacto"].set_text(cliente.contacto.strip())
if not self.wids["e_cliente"].get_text():
self.wids["e_cliente"].set_text(cliente.nombre)
if not self.wids["e_direccion"].get_text():
self.wids["e_direccion"].set_text(cliente.direccion)
if not self.wids["e_ciudad"].get_text():
self.wids["e_ciudad"].set_text(cliente.ciudad)
if not self.wids["e_provincia"].get_text():
self.wids["e_provincia"].set_text(cliente.provincia)
if not self.wids["e_cp"].get_text():
self.wids["e_cp"].set_text(cliente.cp)
if not self.wids["e_pais"].get_text():
self.wids["e_pais"].set_text(cliente.pais)
if not self.wids["e_telefono"].get_text():
self.wids["e_telefono"].set_text(cliente.telefono)
if not self.wids["e_fax"].get_text():
self.wids["e_fax"].set_text(cliente.fax)
def get_valor(self, w, nombrecampo, tipocampo):
res = None
if isinstance(tipocampo, sqlobject.SOStringCol): # Cadena: el widget es un entry
res = w.get_text()
elif isinstance(tipocampo, sqlobject.SOIntCol): # Entero: el widget es un entry
res = w.get_text()
try:
res = int(res)
except ValueError:
txt = "El valor %s no es correcto. Introduzca un número entero." % (res)
utils.dialogo_info(titulo = "ERROR DE FORMATO", texto = txt, padre = self.wids['ventana'])
res = 0
elif isinstance(tipocampo, sqlobject.SOBoolCol): # Boolean: el widget es un checkbox
res = w.get_active()
elif isinstance(tipocampo, sqlobject.SOForeignKey): # Entero-clave ajena: el widget es un comboboxentry
res = utils.combo_get_value(w)
elif isinstance(tipocampo, sqlobject.SOCol): # Clase base, casi seguro Float: el widget es un entry
res = w.get_text()
try:
res = float(res)
except ValueError:
txt = "El valor %s no es correcto. Introduzca un número." % (res)
utils.dialogo_info(titulo = "ERROR DE FORMATO", texto = txt, padre = self.wids['ventana'])
res = 0.0
else:
txt = "motivos_ausencia.py: No se pudo obtener el valor de %s para %s <%s>." \
% (w, nombrecampo, tipocampo)
print txt
self.logger.error(txt)
return res
def buscar(self, boton):
"""
Dadas fecha de inicio y de fin, busca todas las ventas
(facturadas) entre esas dos fechas.
"""
from ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
# print self.fin, self.inicio
vpro.set_valor(0.0, "Analizando prefacturas...")
idcliente = utils.combo_get_value(self.wids['cbe_cliente'])
self.resultado = []
fechafin = datetime.date(day = int(self.fin.split("/")[2]),
month = int(self.fin.split("/")[1]),
year = int(self.fin.split("/")[0]))
if self.inicio == None:
prefacturas = pclases.Prefactura.select(pclases.Prefactura.q.fecha <= fechafin, orderBy = 'fecha')
vpro.set_valor(0.5, "Analizando prefacturas...")
else:
fechainicio = datetime.date(day = int(self.inicio.split("/")[2]),
month = int(self.inicio.split("/")[1]),
year = int(self.inicio.split("/")[0]))
prefacturas = pclases.Prefactura.select(pclases.AND(pclases.Prefactura.q.fecha >= fechainicio,
pclases.Prefactura.q.fecha <= fechafin), orderBy='fecha')
vpro.set_valor(0.5, "Analizando prefacturas...")
self.resultado = list(prefacturas)
vpro.set_valor(0.8, "Analizando prefacturas...")
self.resultado.sort(self.por_fecha)
vpro.set_valor(0.9, "Analizando prefacturas...")
vpro.ocultar()
self.rellenar_tabla(self.resultado)
def es_diferente(self):
"""
Devuelve True si la información en pantalla es distinta a la
del objeto en memoria.
"""
# NOTA: No hay que preocuparse por el exceso de cómputo. Estas comparaciones
# son bastante rápidas al tener python -como los lenguajes de verdad y no
# los jueguetes tipo VB- las operaciones lógicas cortocircuitadas, de forma
# que si condición pasa a False no se evalúa lo que esté detrás del and en
# las instrucciones posteriores.
albaran = self.objeto
if albaran == None: return False # Si no hay albaran activo, devuelvo que no hay cambio respecto a la ventana
condicion = (str(albaran.numalbaran) == self.wids['e_numalbaran'].get_text())
condicion = condicion and (utils.str_fecha(albaran.fecha) == self.wids['e_fecha'].get_text())
condicion = condicion and (utils.combo_get_value(self.wids['cmbe_proveedor']) == albaran.proveedorID)
condicion = condicion and (utils.combo_get_value(self.wids['cbe_almacenID']) == albaran.almacenID)
return not condicion # "condicion" verifica que sea igual
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
proveedor_id = utils.combo_get_value(self.wids['cmbe_proveedor'])
try:
proveedor = pclases.Proveedor.get(proveedor_id)
except:
proveedor = None
error_proveedor = False
proveedores_de_pedidos = utils.unificar(
[p.proveedor for p in albaran.get_pedidos()])
if proveedores_de_pedidos and proveedor not in proveedores_de_pedidos:
# Si el proveedor es diferente al del pedido, no dejo guardarlo.
proveedor = albaran.proveedor
error_proveedor = True
albaran.proveedor = proveedor
albaran.almacen = utils.combo_get_value(self.wids['cbe_almacenID'])
try:
albaran.fecha = utils.parse_fecha(fecha)
except:
albaran.fecha = datetime.date.today()
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)
if error_proveedor:
utils.dialogo_info(titulo = "PROVEEDOR NO GUARDADO",
texto = "El proveedor no se guardó porque no coincide con\n"\
"el del pedido del que procede.",
padre = self.wids['ventana'])
def buscar(self,boton):
"""
"""
idproducto = utils.combo_get_value(self.wids['cmbe_producto'])
if idproducto == None:
utils.dialogo_info(titulo = 'ERROR',
texto = 'Seleccione un producto',
padre = self.wids['ventana'])
return
producto = pclases.ProductoVenta.get(idproducto)
and_fecha_inicio = "AND parte_de_produccion.fecha >= '%s'" % (self.get_unambiguous_fecha(self.inicio))
if producto.es_rollo():
parte_where_de_consulta = """
partida.id IN
(SELECT rollo.partida_id
FROM rollo
WHERE rollo.id IN
(SELECT articulo.rollo_id
FROM articulo
WHERE articulo.producto_venta_id = %d AND articulo.parte_de_produccion_id IN
(SELECT parte_de_produccion.id
FROM parte_de_produccion
WHERE parte_de_produccion.fecha <= '%s' %s
ORDER BY parte_de_produccion.fecha
)
)
) """ % (producto.id,
self.get_unambiguous_fecha(self.fin),
self.inicio and and_fecha_inicio or "")
else:
parte_where_de_consulta = """
partida.id IN
(SELECT bala.partida_carga_id
FROM bala
WHERE bala.id IN
(SELECT articulo.rollo_id
FROM articulo
WHERE articulo.producto_venta_id = %d AND articulo.parte_de_produccion_id IN
(SELECT parte_de_produccion.id
FROM parte_de_produccion
WHERE parte_de_produccion.fecha <= '%s' %s
ORDER BY parte_de_produccion.fecha
)
)
) """ % (producto.id,
self.get_unambiguous_fecha(self.fin),
self.inicio and and_fecha_inicio or "")
partidas = pclases.Partida.select(parte_where_de_consulta, distinct = True)
# Hasta aquí la consulta optimizada para obtener las partidas. Pasamos a recuperar los datos en sí:
vpro = VentanaActividad(padre = self.wids['ventana'])
vpro.mostrar()
self.resultado = []
for p in partidas:
vpro.mover()
self.resultado.append(p)
vpro.ocultar()
self.resultado = partidas
self.rellenar_tabla(self.resultado)
def imprimir(self,boton):
"""
Prepara la vista preliminar para la impresión del informe
"""
from treeview2pdf import treeview2pdf
from informes import abrir_pdf
strfecha = "%s - %s" % (self.wids['e_fechainicio'].get_text(), self.wids['e_fechafin'].get_text())
resp = utils.dialogo(titulo = "¿IMPRIMIR DESGLOSE?",
texto = "Puede imprimir únicamente los albaranes o toda la información de la ventana.\n¿Desea imprimir también el contenido de los albaranes?",
padre = self.wids['ventana'])
if resp:
tv = self.wids['tv_datos']
tv.expand_all()
while gtk.events_pending(): gtk.main_iteration(False)
itertotal = tv.get_model().append(None, ("",)*8 + ("TOTAL", self.wids['e_total'].get_text()) + ("", )*2 + (0, ))
else:
tv = self.wids['tv_datos']
tv.collapse_all()
while gtk.events_pending(): gtk.main_iteration(False)
tv = convertir_a_listview(tv)
# Me sobran algunas columnas
tv.remove_column(tv.get_columns()[2])
tv.remove_column(tv.get_columns()[3])
tv.remove_column(tv.get_columns()[3])
tv.remove_column(tv.get_columns()[3])
tv.remove_column(tv.get_columns()[3])
tv.remove_column(tv.get_columns()[3])
tv.remove_column(tv.get_columns()[-1])
tv.remove_column(tv.get_columns()[-1])
tv.get_column(2).set_title("Proveedor")
model = tv.get_model()
# Chapuza para mover los datos de la columna, pensaba que se eliminaban al quitar las columnas del TV.
for fila in model:
fila[2], fila[3] = fila[3],fila[9]
itertotal = model.append(("", "", "TOTAL", self.wids['e_total'].get_text()) + ("", )*8 + (0, ) )
idproveedor = utils.combo_get_value(self.wids['cbe_proveedor'])
if idproveedor > 1:
try:
nomproveedor = pclases.Proveedor.get(idproveedor).nombre
except:
nomproveedor = "?"
else:
nomproveedor = "proveedores"
abrir_pdf(treeview2pdf(tv, titulo = "Compras a %s" % (nomproveedor), fecha = strfecha))
tv.get_model().remove(itertotal)
if self.wids['notebook1'].get_current_page() == 0:
self.wids['notebook1'].next_page()
self.wids['notebook1'].realize()
while gtk.events_pending(): gtk.main_iteration(False)
self.wids['notebook1'].prev_page()
abrir_pdf(treeview2pdf(self.wids['tv_proveedor'],
titulo = "Compras por proveedor y producto",
fecha = strfecha))
def filtrar_por_forma_de_pago(self, r):
res = r[:]
if self.wids['ch_formapago'].get_active():
formapago = utils.combo_get_value(self.wids['cb_formapago'])
if formapago != None:
txtformapago = self.formaspago[formapago][1]
res = []
for v in r: # v es una tupla con fecha, vencimiento o estimación y un boolean para indicar si es de LOGIC.
# Las formas de pago en el combo están todas en minúsuclas y sin tildes:
if not v[2] and txtformapago in utils.filtrar_tildes(v[1].observaciones).lower():
res.append(v)
return res
def actualizar(self, *args, **kw):
"""
Wrapper para actualizar_ventana.
"""
id = utils.combo_get_value(self.wids['cb_empleadoID'])
if id > 0:
self.lista_empleados = [pclases.Empleado.get(id)]
elif id == 0:
self.lista_empleados = [e for e in pclases.Empleado.select()]
else:
self.lista_empleados = None
#self.actualizar_ventana()
self.rellenar_widgets()
def add_ventana_a_modulo(self, b):
model, iter = self.wids['tv_modulos'].get_selection().get_selected()
if iter == None or model[iter].parent != None:
utils.dialogo_info(titulo = 'SELECCIONE MÓDULO', texto = 'Debe seleccionar un módulo al que añadir la ventana.')
return
idventana = utils.combo_get_value(self.wids['cb_add_ventana'])
if idventana == None:
utils.dialogo_info(titulo = 'SELECCIONE VENTANA', texto = 'Debe seleccionar una ventana para añadir al módulo.')
idmodulo = model[iter][-1]
modulo = pclases.Modulo.get(idmodulo)
ventana = pclases.Ventana.get(idventana)
ventana.modulo = modulo
self.rellenar_tab_modulos()
def rellenar_widgets(self):
"""
Rellena la información de los widgets, que es básicamente el
TreeView de alumnos a través del evento "changed" del profesor.
"""
id = utils.combo_get_value(self.wids['cb_empleadoID'])
if id > 0:
self.lista_empleados = [pclases.Empleado.get(id)]
elif id == 0:
self.lista_empleados = [e for e in pclases.Empleado.select()]
else:
self.lista_empleados = []
fecha = self.get_fecha_mostrada()
dict_clases = self.rellenar_asistencias(fecha)
self.actualizar_grafica(dict_clases)
self.wids['tv_asistencias'].expand_all()
def imprimir(self, boton):
"""
Imprime la información en dos documentos: fibra y geotextiles.
"""
import informes
idcliente = utils.combo_get_value(self.wids['cbe_cliente'])
if idcliente > 0:
nombrecliente = pclases.Cliente.get(idcliente).nombre
else:
nombrecliente = ""
if self.gpped != None and self.gpped != []:
informes.abrir_pdf(geninformes.pendiente_servir("geotextiles", self.gpped, self.gppro, nombrecliente))
if self.fpped != None and self.fpped != []:
informes.abrir_pdf(geninformes.pendiente_servir("fibra", self.fpped, self.fppro, nombrecliente))
if self.opped != None and self.opped != []:
informes.abrir_pdf(geninformes.pendiente_servir("otros", self.opped, self.oppro, nombrecliente))
def add_cobro(self, b):
pagare = self.objeto
idcliente = utils.combo_get_value(self.wids['cbe_cliente'])
if idcliente > 0:
cliente = pclases.Cliente.get(idcliente)
else:
cliente = self.buscar_cliente()
if cliente == None:
return
facturas = self.buscar_factura(cliente)
if facturas == None:
return
for factura in facturas:
if factura.id in [c.facturaVentaID or c.prefacturaID for c in self.objeto.cobros] and len(factura.vencimientosCobro) < 2:
utils.dialogo_info(titulo = "FACTURA YA INCLUIDA",
texto = "La factura %s ya ha sido incluida en este pagaré." % (factura.numfactura),
padre = self.wids['ventana'])
continue
# TODO: No controlo que no se pueda pagar el mismo vencimiento de la misma factura en dos pagarés diferentes.
vencimiento = self.buscar_vencimiento(factura)
if vencimiento == None:
continue
antes = sum([c.importe for c in pagare.cobros])
if antes == pagare.cantidad:
actualizar_cantidad = True # Como el importe es la suma de los cobros, el nuevo que añado ahora tiene que actualizar la cantidad.
# Si no fuera así (el importe es distinto a la suma de los cobros) es que se ha introducido a mano
# y por tanto debo respetarlo.
else:
actualizar_cantidad = False
observaciones = "Pagaré %s con fecha %s y vencimiento %s" % (
self.objeto.codigo,
utils.str_fecha(self.objeto.fechaRecepcion),
utils.str_fecha(self.objeto.fechaCobro))
cobro = pclases.Cobro(facturaVenta = vencimiento.facturaVenta,
prefactura = vencimiento.prefactura,
pagareCobro = self.objeto,
fecha = vencimiento.fecha,
importe = vencimiento.importe,
#observaciones = 'Cubierto por el pagaré con fecha %s.' % utils.str_fecha(self.objeto.fechaRecepcion),
observaciones = observaciones)
if actualizar_cantidad:
if pagare.cobrado == pagare.cantidad:
pagare.cobrado = sum([c.importe for c in pagare.cobros])
pagare.cantidad = pagare.cobrado
else:
pagare.cantidad = sum([c.importe for c in pagare.cobros])
self.actualizar_ventana()
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...).
"""
tipo = utils.combo_get_value(self.wids['cbe_tipo'])
from ventana_progreso import VentanaProgreso
vpro = VentanaProgreso(padre = self.wids['ventana'])
vpro.mostrar()
txtvpro = "Recuperando existencias por almacén..."
i = 0.0
vpro.set_valor(i, txtvpro)
almacenes = pclases.Almacen.select(orderBy = "id")
itotal = pclases.ProductoCompra.select().count()
model = self.wids['tv_por_producto'].get_model()
model.clear()
for a in almacenes:
self.wids['tv_%d' % a.id].get_model().clear()
if tipo in (0, -2) or tipo > 0:
for pc in pclases.ProductoCompra.select():
if ((tipo > 0 and pc.tipoDeMaterialID == tipo)
or tipo in (0, -2)):
fila = [pc.codigo, pc.descripcion]
total = pc.existencias
for a in almacenes:
existencias_almacen = a.get_existencias(pc)
if existencias_almacen == None:
existencias_almacen = 0
fila.append(utils.float2str(existencias_almacen))
if existencias_almacen != 0:
self.wids['tv_%d' % a.id].get_model().append(
(pc.codigo, pc.descripcion,
utils.float2str(existencias_almacen),
pc.get_puid()))
fila.append(utils.float2str(total))
fila.append(pc.get_puid())
model.append(fila)
txtvpro = "Recuperando existencias por almacén... (%s)" % (
pc.get_puid())
i += 1
vpro.set_valor(i/itotal, txtvpro)
else:
i += pclases.ProductoCompra.select().count()
txtvpro = "Recuperando existencias por almacén..."
vpro.ocultar()
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 rellenar_vencimientos(self):
model = self.wids['tv_cobros'].get_model()
model.clear()
idcliente = utils.combo_get_value(self.wids['cbe_cliente'])
total = 0
vencido = 0
if idcliente > 0:
cliente = pclases.Cliente.get(idcliente)
for f in cliente.facturasVenta:
total, vencido = self.agregar_factura(f, model, total, vencido)
elif idcliente == 0:
for cliente in pclases.Cliente.select(orderBy = "nombre"):
for f in cliente.facturasVenta:
total, vencido = self.agregar_factura(f, model, total,
vencido)
self.wids['e_total'].set_text("%s €" % utils.float2str(total))
self.wids['e_vencido'].set_text("%s €" % utils.float2str(vencido))
def comparar_ajena(self, col):
res = None
try:
valor_ventana = utils.combo_get_value(self.wids[col])
except KeyError:
txt_error = "categorias_laborales.py: No se pudo obtener el valor de la ventana para %s." % col
print txt_error
self.logger.error(txt_error)
valor_ventana = None
try:
valor_campo = self.objeto._SO_getValue(col) # Es un ID -es decir, un entero-, no un objeto sqlobject.
except KeyError:
txt_error = "categorias_laborales.py: No se pudo obtener el valor del objeto para %s." % col
print txt_error
self.logger.error(txt_error)
valor_campo = None
res = valor_ventana == valor_campo
return res
def rellenar_tabla(self):
idcliente = utils.combo_get_value(self.wids['cbe_cliente'])
if idcliente >= 0:
if idcliente != 0:
# Filtrar el cliente.
self.fpped, self.fppro, self.gpped, self.gppro, self.opped, self.oppro = buscar_pendiente_servir(cliente = pclases.Cliente.get(idcliente), padre = self.wids['ventana'])
else:
# No filtrarlo
self.fpped, self.fppro, self.gpped, self.gppro, self.opped, self.oppro = buscar_pendiente_servir(cliente = None, padre = self.wids['ventana'])
tvs = []
if pclases.ProductoVenta.select().count() > 0:
tvs += [(self.fpped, 'tv_fibra_por_pedido'),
(self.fppro, 'tv_fibra_por_producto'),
(self.gpped, 'tv_gtx_por_pedido'),
(self.gppro, 'tv_gtx_por_producto')]
tvs += [(self.opped, 'tv_otros_por_pedido'),
(self.oppro, 'tv_otros_por_producto')]
for datos, tv in tvs:
self.rellenar_tv(datos, tv)
def actualizar_turno(self, cbe):
dia, idgrupo = map(int, cbe.get_name().split("_"))
mes = int(self.wids['sp_mes'].get_value())
anno = int(self.wids['sp_anno'].get_value())
grupo = pclases.Grupo.get(idgrupo)
idturno = utils.combo_get_value(cbe)
if idturno != None:
turno = pclases.Turno.get(idturno)
else:
turno = None
laborable = [l for l in self.objeto.laborables if l.fecha.day == dia and l.grupo == grupo]
if laborable == []:
nuevolaborable = pclases.Laborable(turno = turno,
grupo = grupo,
calendarioLaboral = self.objeto,
fecha = mx.DateTime.DateTimeFrom(day = dia, month = mes, year = anno))
else:
laborable = laborable[0]
laborable.turno = turno
cbe.child.modify_base(gtk.STATE_NORMAL, cbe.child.get_colormap().alloc_color(get_color_turno(idturno)))
def rellenar_tabla(self, items):
"""
Rellena el model con los items de la consulta
"""
model = self.wids['tv_datos'].get_model()
model.clear()
idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
if idcliente != None:
cliente = pclases.Cliente.get(idcliente)
tarifa = cliente.tarifa
for i in items:
if tarifa:
precio_tarifa = tarifa.obtener_precio(i,
sincronizar = True)
else:
precio_tarifa = i.precioDefecto
model.append((i.codigo,
i.descripcion,
utils.float2str(precio_tarifa),
i.get_puid()))
def crear_bala(self, boton = None, peso = None):
"""
Crea una bala del producto mostrado en pantalla e introduce
su información en el TreeView. El peso lo solicita en una
ventana de diálogo.
Si se recibe peso, debe ser un float.
"""
# TODO: Hacer que el peso lo tome del puerto serie y se le pase a
# esta función.
producto = utils.combo_get_value(self.wids['cbe_producto'])
if producto == None:
utils.dialogo_info(titulo = "SELECCIONE UN PRODUCTO",
texto = "Debe seleccionar un producto en el desplegable.",
padre = self.wids['ventana'])
else:
if peso == None:
peso = utils.dialogo_entrada(titulo = "PESO",
texto = "Introduzca peso:",
padre = self.wids['ventana'],
valor_por_defecto = "0")
try:
peso = utils._float(peso)
except ValueError:
utils.dialogo_info(titulo = "ERROR",
texto = "El valor tecleado %s no es correcto." % (peso),
padre = self.wids['ventana'])
peso = 0
nueva_bala = self.crear_objeto_bala(producto, peso)
if nueva_bala == None:
utils.dialogo_info(titulo = "ERROR",
texto = "La bala no se pudo crear. Inténtelo de nuevo.",
padre = self.wids['ventana'])
else:
self.add_nueva_bala_tv(nueva_bala)
try:
totpantalla = utils.parse_float(
self.wids['e_pantalla'].get_text())
except:
totpantalla = 0.0
totpantalla += peso
self.rellenar_totales(totpantalla)
