def nuevo(self, widget):
"""
Función callback del botón b_nuevo.
Pide los datos básicos para crear un nuevo objeto.
Una vez insertado en la BD hay que hacerlo activo
en la ventana para que puedan ser editados el resto
de campos que no se hayan pedido aquí.
"""
silo = self.objeto
nombre = utils.dialogo_entrada('Introduzca el nombre del silo:', 'NOMBRE', padre = self.wids['ventana'])
if nombre != None:
capacidad = utils.dialogo_entrada(titulo = "CAPACIDAD",
texto = "Introduzca la capacidad del silo:",
padre = self.wids['ventana'])
try:
capacidad = float(capacidad)
except:
utils.dialogo_info(titulo = "VALOR INCORRECTO",
texto = "El valor %s no es correcto. Inténtelo de nuevo.\nAsegúrese de no introducir unidades.",
padre = self.wids['ventana'])
return
observaciones = utils.dialogo_entrada(titulo = "OBSERVACIONES",
texto = "Introduzca observaciones si lo desea:",
padre = self.wids['ventana'])
if observaciones != None:
silo = pclases.Silo(nombre = nombre,
capacidad = capacidad,
observaciones = observaciones)
pclases.Auditoria.nuevo(silo, self.usuario, __file__)
self.rellenar_widgets()
def crear_servicio(self):
# Datos a pedir: Concepto, descuento y precio... Bah, el descuento
# que lo cambie en el TreeView.
concepto = utils.dialogo_entrada(titulo = "CONCEPTO",
texto = 'Introduzca el concepto del servicio facturable:',
padre = self.wids['ventana'])
if concepto != None:
precio = utils.dialogo_entrada(titulo = "PRECIO",
texto = 'Introduzca el precio unitario sin IVA:',
padre = self.wids['ventana'])
if precio != None:
try:
precio = utils._float(precio)
servicio = pclases.Servicio(facturaVenta = self.objeto,
concepto = concepto,
precio = precio,
descuento = 0)
# Cantidad es 1 por defecto.
except Exception, e:
utils.dialogo_info(texto = """
Ocurrió un error al crear el servicio.
Asegúrese de haber introducido correctamente los datos,
especialmente el precio (que no debe incluir símbolos
monetarios), y vuelva a intentarlo.
DEBUG:
%s
""" %(e),
titulo = "ERROR",
padre = self.wids['ventana'])
return
self.rellenar_servicios()
self.rellenar_vencimientos()
def nuevo(self, widget):
"""
Función callback del botón b_nuevo.
Pide los datos básicos para crear un nuevo objeto.
Una vez insertado en la BD hay que hacerlo activo
en la ventana para que puedan ser editados el resto
de campos que no se hayan pedido aquí.
"""
tipos = [(i.id, i.descripcion)
for i in pclases.PresupuestoAnual.select()]
tipos.insert(0, (0, "Añadir concepto de primer nivel"))
tipo = utils.dialogo_combo(titulo = "NUEVO CONCEPTO",
texto = "Seleccione tipo:",
ops = tipos,
padre = self.wids['ventana'])
if tipo >= 0:
if tipo > 0:
pa = pclases.PresupuestoAnual.get(tipo)
if "proveedores granza" in pa.descripcion.lower():
# Si es del tipo de proveedores, entonces tengo que
# añadir un proveedor de granza.
nombre = utils.dialogo_entrada(
titulo = "NOMBRE PROVEEDOR",
texto = "Introduzca el nombre del proveedor:",
padre = self.wids['ventana'])
if nombre != None:
proveedor = buscar_proveedor(nombre,
self.wids['ventana'])
if proveedor:
# TODO: Check que el proveedor no esté ya en
# el presupuesto.
c = pclases.ConceptoPresupuestoAnual(
presupuestoAnual = pa,
descripcion = proveedor.nombre,
proveedor = proveedor)
pclases.Auditoria.nuevo(c, self.usuario,
__file__)
else:
descripcion = utils.dialogo_entrada(
titulo = "NUEVO CONCEPTO",
texto = "Introduzca descripción:",
padre = self.wids['ventana'])
if descripcion:
c = pclases.ConceptoPresupuestoAnual(
presupuestoAnual = pa,
descripcion = descripcion)
pclases.Auditoria.nuevo(c, self.usuario, __file__)
else: # Concepto de primer nivel
descripcion = utils.dialogo_entrada(
titulo = "NUEVO CONCEPTO",
texto = "Introduzca descripción:",
padre = self.wids['ventana'])
if descripcion:
pa = pclases.PresupuestoAnual(descripcion = descripcion)
pclases.Auditoria.nuevo(pa, self.usuario, __file__)
self.actualizar_ventana()
def elegir_o_crear_obra(self):
"""
Crea una nueva obra relacionada con la factura de venta de la ventana.
"""
obras = pclases.Obra.select(orderBy = "nombre")
obras = [o for o in obras
if self.objeto.cliente in o.clientes]
idobra = utils.dialogo_combo(titulo = "SELECCIONE OBRA",
texto = "Es necesario relacionar una obra con la factura."\
"\nSeleccione una del desplegable inferior o cree una "\
"nueva",
padre = self.wids['ventana'],
ops = [(0, "Crear una obra nueva")] + [(o.id, o.nombre)
for o in obras])
if idobra == 0:
nombre = utils.dialogo_entrada(titulo = "NOMBRE DE OBRA",
texto = "Introduzca el nombre de la obra:",
padre = self.wids['ventana'])
if not nombre:
return None
direccion = utils.dialogo_entrada(titulo = "DIRECCIÓN",
texto = "Introduzca la dirección de la obra:",
padre = self.wids['ventana'])
if direccion == None:
return None
ciudad = utils.dialogo_entrada(titulo = "CIUDAD",
texto = "Introduzca la ciudad:",
padre = self.wids['ventana'])
if ciudad == None:
return None
cp = utils.dialogo_entrada(titulo = "CÓDIGO POSTAL",
texto = "Introduzca el código postal",
padre = self.wids['ventana'])
if cp == None:
return None
provincia = utils.dialogo_entrada(titulo = "PROVINCIA",
texto = "Introduzca la provincia:",
padre = self.wids['ventana'])
if provincia == None:
return None
# De fecha de inicio, fecha de fin de obra y observacione pasamos a
# este nivel. Eso se afina en la ventana de obras.
obra = pclases.Obra(nombre = nombre, direccion = direccion,
cp = cp, ciudad = ciudad, provincia = provincia,
fechainicio = None, fechafin = None,
observaciones = "Creada desde módulo CRM: detalles de "\
"factura.",
generica = False)
pclases.Auditoria.nuevo(obra, self.usuario, __file__)
obra.addCliente(self.objeto.cliente)
elif idobra:
obra = pclases.Obra.get(idobra)
else:
obra = None
return obra
def add_campoesp(self, w):
campo = utils.dialogo_entrada('Introduzca nombre del campo:', 'NOMBRE', padre = self.wids['ventana'])
if campo:
valor = utils.dialogo_entrada('Introduzca valor del campo:', 'VALOR', padre = self.wids['ventana'])
if valor:
producto = self.objeto
ce = pclases.CamposEspecificos(productoVenta = producto,
nombre = campo,
valor = valor)
pclases.Auditoria.nuevo(ce, self.usuario, __file__)
self.mostrar_especificos()
def add_concepto(self, b):
"""
Añade un detalle a un precio.
Si se han marcado varias filas, añade el mismo concepto a todos
los precios marcados.
"""
sel = self.wids['tv_productos'].get_selection()
model, paths = sel.get_selected_rows()
ids = []
tratados = []
while paths:
path = paths.pop()
tratados.append(path)
tipo, id = model[path][-1].split(":")
if tipo == "PV":
paths += [hijo.path for hijo in model[path].iterchildren()
if hijo.path not in tratados]
elif tipo == "C":
#pathpadre = model[path].parent.path
#if pathpadre not in tratados:
# paths.append(pathpadre)
id = pclases.Concepto.get(int(id)).precioID
if not id in ids:
ids.append(id)
elif tipo == "P":
id = int(id)
if id not in ids:
ids.append(id)
if ids:
concepto = utils.dialogo_entrada(titulo = "CONCEPTO",
texto = "Introduzca detalle:",
padre = self.wids['ventana'])
if concepto:
precio = utils.dialogo_entrada(titulo = "IMPORTE",
texto = "Importe del detalle:",
padre = self.wids['ventana'])
if precio:
try:
precio = utils._float(precio)
except (ValueError, TypeError):
utils.dialogo_info(titulo = "ERROR DE FORMATO",
texto = "El texto %s no es un número." % precio,
padre = self.wids['ventana'])
else:
for id in ids:
pre = pclases.Precio.get(id)
con = pclases.Concepto(importe = precio,
concepto = concepto,
precio = pre)
pre.tarifa.add_conceptoLdv_a_ldvs(con)
self.rellenar_tabla_precios()
def crear_nuevo_tipodematerialBala(self, widget):
"""
Función callback del botón b_nuevo.
Pide los datos básicos para crear un nuevo objeto.
Una vez insertado en la BD hay que hacerlo activo
en la ventana para que puedan ser editados el resto
de campos que no se hayan pedido aquí.
"""
nuevotipo = utils.dialogo_entrada('Introduzca el nuevo tipo de material')
nuevocodigo = utils.dialogo_entrada('Introduzca el código asociado al material')
if nuevotipo != None and nuevocodigo !=None :
tipodematerialBala = pclases.TipoMaterialBala(descripcion = nuevotipo, codigo = nuevocodigo)
pclases.Auditoria.nuevo(tipodematerialBala, self.usuario, __file__)
self.rellenar_tabla()
def ir_a_fecha(self, boton, fecha = None, comercial = None):
"""
Desplaza el calendario y contenido de la ventana a la fecha para el
comercial indicado. Si no se reciben, usa el comercial de la ventana
y pregunta la fecha en un diálogo modal.
"""
# 0.- Comprobar fecha recibida o pedir.
if not fecha:
fechastr = utils.dialogo_entrada(titulo = "INTRODUZCA FECHA",
texto = "Introduzca fecha a la que desplazarse:",
padre = self.wids['ventana'])
if fechastr:
try:
fecha = utils.parse_fecha(fechastr)
except ValueError, TypeError:
utils.dialogo_info(titulo = "ERROR EN FECHA",
texto = "Introdujo una fecha no valida: %s"
% fechastr,
padre = self.wids['ventana'])
return # Error del usuario al meter fecha
else:
dia = fecha.day
mes = fecha.month
anno = fecha.year
else:
return # Canceló
def buscar_usuario(self, widget):
"""
Muestra una ventana de búsqueda y a continuación los
resultados. El objeto seleccionado se hará activo
en la ventana a no ser que se pulse en Cancelar en
la ventana de resultados.
"""
usuario = self.objeto
a_buscar = utils.dialogo_entrada("Introduzca nombre de usuario o nombre real:")
if a_buscar != None:
resultados = pclases.Usuario.select(sqlobject.OR(pclases.Usuario.q.usuario.contains(a_buscar),
pclases.Usuario.q.nombre.contains(a_buscar)))
if resultados.count() > 1:
## Refinar los resultados
idusuario = self.refinar_resultados_busqueda(resultados)
if idusuario == None:
return
resultados = [pclases.Usuario.get(idusuario)]
elif resultados.count() < 1:
## Sin resultados de búsqueda
utils.dialogo_info('SIN RESULTADOS', 'La búsqueda no produjo resultados.\nPruebe a cambiar el texto buscado o déjelo en blanco para ver una lista completa.\n(Atención: Ver la lista completa puede resultar lento si el número de elementos es muy alto)')
return
## Un único resultado
# Primero anulo la función de actualización
if usuario != None:
usuario.notificador.desactivar()
# Pongo el objeto como actual
usuario = resultados[0]
# Y activo la función de notificación:
usuario.notificador.activar(self.aviso_actualizacion)
self.objeto = usuario
self.actualizar_ventana()
def buscar_motivo(self, widget):
"""
Muestra una ventana de búsqueda y a continuación los
resultados. El objeto seleccionado se hará activo
en la ventana a no ser que se pulse en Cancelar en
la ventana de resultados.
"""
motivo = self.objeto
objetobak = self.objeto
a_buscar = utils.dialogo_entrada("Introduzca descripción del motivo.")
if a_buscar != None:
criterio = pclases.Motivo.q.descripcion.contains(a_buscar)
resultados = pclases.Motivo.select(criterio)
if resultados.count() > 1:
## Refinar los resultados
idmotivo = self.refinar_resultados_busqueda(resultados)
if idmotivo == None:
return
resultados = [pclases.Motivo.get(idmotivo)]
elif resultados.count() < 1:
## Sin resultados de búsqueda
utils.dialogo_info('SIN RESULTADOS',
'\n\nLa búsqueda no produjo resultados.\nPruebe a cambiar el texto buscado o déjelo en blanco para ver una lista completa.\n(Atención: Ver la lista completa puede resultar lento si el número de elementos es muy alto)\n\n')
return
## Un único resultado
# Primero anulo la función de actualización
if motivo != None:
motivo.notificador.set_func(lambda : None)
# Pongo el objeto como actual
motivo = resultados[0]
# Y activo la función de notificación:
self.objeto = motivo
self.actualizar_ventana(objetobak)
motivo.notificador.set_func(self.aviso_actualizacion)
def pedir_unidad(self, productoCompra):
"""
Pide la unidad del descuento y comprueba que sea correcta.
Recibe el producto de compra para mostrar el valor por defecto.
"""
txt = """
Introduzca las unidades para el descuento de materiales.
Por ejemplo:
% (porcentaje en las unidades del material
por peso de producto terminado).
ud / 5 ud (unidad del material por cada 5 unidades
de producto terminado).
m / kg (metro de material por kilo de producto).
kg / 5.5 m (kg de material por cada 5.5 metros de producto).
NOTA: La unidad del materal que se descuenta debe ser la misma
que consta en catálogo, pedidos de compra, etc.
"""
defecto = "%s / ud" % (productoCompra.unidad)
res = utils.dialogo_entrada(titulo = "INTRODUZCA UNIDAD",
texto = txt,
padre = self.wids['ventana'],
valor_por_defecto = defecto)
if not comprobar_unidad(res):
utils.dialogo(titulo = "FORMATO INCORRECTO",
texto = "El texto introducido %s no tiene el formato correcto." % (res),
padre = self.wids['ventana'])
res = None
return res
def crear_nuevo_contador(self, widget):
"""
Función callback del botón b_nuevo.
Pide los datos básicos para crear un nuevo objeto.
Una vez insertado en la BD hay que hacerlo activo
en la ventana para que puedan ser editados el resto
de campos que no se hayan pedido aquí.
"""
prefijo = utils.dialogo_entrada('Introduzca el prefijo del nuevo contador')
if prefijo != None:
sufijo = utils.dialogo_entrada('Introduzca el sufijo del nuevo contador')
if sufijo != None:
contador = pclases.Contador(prefijo = prefijo, sufijo = sufijo,
contador = 1)
pclases.Auditoria.nuevo(contador, self.usuario, __file__)
self.rellenar_tabla()
def pedir_rango_balas(self):
"""
Pide un rango de números de balas.
Devuelve un generador de números
de bala que comienza en el primero
del rango (o único, si solo se teclea uno)
y acaba en el último del rango.
"""
rango = utils.dialogo_entrada(titulo='INTRODUZCA RANGO',
texto='Rango de números de bala o el código individual.\n'
'Escriba el rango de códigos de la forma "xxxx-yyyy"'
', ambos inclusive.\nO bien una lista de números'
' separada por comas o espacios (xxxx, yyyy zzzz).',
padre=self.wids['ventana'])
if not rango:
return rango
try:
if '-' in rango:
ini, fin = rango.split('-')
ini = int(ini)
fin = int(fin)
if fin < ini:
ini, fin = fin, ini
else:
ini = int(rango)
fin = ini
except (ValueError, TypeError):
utils.dialogo_info(titulo='CÓDIGO INCORRECTO',
texto='Los códigos deben ser numéricos.\n\nVerifique que los '
'ha escrito correctamente y que ha separado el rango '
'con un guión.',
padre=self.wids['ventana'])
return []
return xrange(ini, fin+1)
def buscar(self, boton):
a_buscar = utils.dialogo_entrada(titulo = "BUSCAR EMPLEADO",
texto = "Introduzca nombre, código o DNI:",
padre = self.wids['ventana'])
if a_buscar != None:
if a_buscar.isdigit():
subcriterios = [pclases.Empleado.q.id == int(a_buscar)]
else:
subcriterios = []
if a_buscar:
subnombre = pclases.AND(*[pclases.Empleado.q.nombre.contains(
subtext) for subtext in a_buscar.split()])
subcriterios.append(subnombre)
subdni = pclases.AND(*[pclases.Empleado.q.dni.contains(subtext)
for subtext in a_buscar.split()])
subcriterios.append(subdni)
resultados = pclases.Empleado.select(pclases.OR(*subcriterios),
orderBy = "nombre")
else:
resultados = pclases.Empleado.select(orderBy = "nombre")
resultados = [(r.id, r.nombre, r.dni) for r in resultados]
idempleado = utils.dialogo_resultado(resultados,
"SELECCIONE EMPLEADO",
padre = self.wids['ventana'],
cabeceras=("ID", "Nombre", "DNI"))
if idempleado and idempleado > 0:
self.empleado = pclases.Empleado.get(idempleado)
self.rellenar_widgets()
def pedir_producto(self):
"""
Solicita una descripción de producto, muestra una
ventana de resultados coincidentes con la
búsqueda de ese código y devuelve un
objeto producto seleccionado de entre
los resultados o None si se cancela o
no se encuentra.
"""
producto = None
codigo = utils.dialogo_entrada(titulo = 'PRODUCTO',
texto = 'Introduzca descripción del producto.',
padre = self.wids['ventana'])
if codigo == None: # Ha cancelado
producto = self.producto
if codigo != None:
prods = pclases.ProductoCompra.select(pclases.AND(
pclases.ProductoCompra.q.descripcion.contains(codigo),
pclases.ProductoCompra.q.obsoleto == False))
prods = [p for p in prods]
mens_error = 'No se encontró ningún producto con esa descripción.'
if len(prods) > 1:
idproducto = self.refinar_busqueda_productos(prods)
if idproducto != None:
prods = [p for p in prods if p.id == idproducto]
else:
return None
elif len(prods) < 1:
utils.dialogo_info('CÓDIGO NO ENCONTRADO', mens_error)
return None
producto = prods[0]
return producto
def imprimir(self, boton):
"""
Imprime un fax con la información de la transferencia.
Solicita un firmante al usuario. El resto de los datos
se obtienen de la BD.
"""
from informes.geninformes import fax_transferencia
from formularios.reports import abrir_pdf
firmantes = {1: "Otro (texto libre)",
2: "D. Enrique Román Corzo",
3: "D. Enrique Figueroa Yáñez",
4: "D. Enrique Mozo del Río",
5: "D. Fernando Guijarro Lozano"} # TODO: HARCODED
claves = firmantes.keys()
claves.sort()
firmado = utils.dialogo_combo(titulo = "FIRMANTE",
texto = 'Seleccione un firmante o elija "otro" y pulse\n«Aceptar» para escribir uno distinto:',
ops = ([(k, firmantes[k]) for k in claves]),
padre = self.wids['ventana'])
if firmado == 1:
firmado = utils.dialogo_entrada(titulo = "FIRMANTE",
texto = "Introduzca el nombre que aparecerá en la firma:",
padre = self.wids['ventana'])
elif firmado != None:
firmado = firmantes[firmado]
if firmado != None:
try:
e = pclases.DatosDeLaEmpresa.select()[0]
t = self.objeto
o = t.cuentaOrigen
d = t.cuentaDestino
p = t.proveedor
empresa = o.banco
contacto = o.contacto
fax = o.fax
telefono = o.telefono
de = e.nombreContacto
asunto = "Transferencia"
fecha = utils.str_fecha(t.fecha)
beneficiario = p.nombre
banco = d.banco
#if p.es_extranjero():
# cuenta = "%s %s" % (d.iban, d.swif)
#else:
# cuenta = d.cuenta
cuenta = d.cuenta
porcuenta = e.nombre
ccc = o.ccc
concepto = t.concepto
importe = "%s €" % (utils.float2str(t.importe))
swift = d.swif
iban = d.iban
observaciones = d.observaciones
conceptoLibre = t.conceptoLibre
except AttributeError, msg:
utils.dialogo_info(titulo = "ERROR AL GENERAR FAX", texto = "No se encontraron algunos datos.\n\nVerifique la información y vuelva a intentarlo.", padre = self.wids['ventana'])
self.logger.error("transferencias.py::imprimir -> AttributeError: %s" % msg)
except IndexError, msg:
utils.dialogo_info(titulo = "ERROR AL RECUPERAR DATOS DE LA EMPRESA", texto = "No se encontraron los datos de la empresa.\n\nCompruebe que existe una empresa en la tabla «datos_de_la_empresa».\n\n\n(Contacte con el administrador en caso de duda.)", padre = self.wids['ventana'])
self.logger.error("transferencias.py::imprimir -> IndexError: %s" % msg)
def buscar_cliente(self):
"""
Busca un cliente y devuelve su ID o None.
"""
idcliente = None
a_buscar = utils.dialogo_entrada(titulo = "BUSCAR CLIENTE", texto = "Introduzca nombre o CIF del cliente:", padre = self.wids['ventana'])
if a_buscar != None:
criterio = pclases.OR(pclases.Cliente.q.nombre.contains(a_buscar),
pclases.Cliente.q.cif.contains(a_buscar))
resultados = pclases.Cliente.select(criterio)
if resultados.count() > 1:
## Refinar los resultados
idcliente = self.refinar_resultados_busqueda_cliente(resultados)
if idcliente == None:
return None
resultados = [pclases.Cliente.get(idcliente)]
elif resultados.count() < 1:
## Sin resultados de búsqueda
utils.dialogo_info('SIN RESULTADOS',
'La búsqueda no produjo resultados.\nPruebe a cambiar el texto buscado o déjelo en blanco para ver una lista completa.\n(Atención: Ver la lista completa puede resultar lento si el número de elementos es muy alto)',
padre = self.wids['ventana'])
return None
## Un único resultado
idcliente = resultados[0].id
return idcliente
def pedir_producto_compra(self):
"""
Devuelve UN producto de compra obtenido a partir
de una búsqueda, etc.
"""
producto = None
a_buscar = utils.dialogo_entrada(titulo = "BUSCAR MATERIAL",
texto = "Introduzca texto a buscar en productos de compra:",
padre = self.wids['ventana'])
if a_buscar != None:
resultados = utils.buscar_productos_compra(a_buscar)
if resultados.count() > 1:
## Refinar los resultados:
filas_res = []
for r in resultados:
filas_res.append((r.id, r.codigo, r.descripcion))
idproducto = utils.dialogo_resultado(filas_res,
titulo = 'Seleccione producto',
cabeceras = ('ID Interno', 'Código', 'Descripción'),
padre = self.wids['ventana'])
if idproducto < 0:
return
producto = pclases.ProductoCompra.get(idproducto)
# id es clave primaria, esta comprensión debería devolver un único producto
elif resultados.count() < 1:
## La búsqueda no produjo resultados.
utils.dialogo_info('SIN RESULTADOS',
'La búsqueda no produjo ningún resultado.\nIntente una '
'búsqueda menos restrictiva usando un texto más corto.',
padre = self.wids['ventana'])
return None
else:
producto = resultados[0]
return producto
def pedir_nombre(self):
"""
Pide un texto y lo devuelve. Sin más.
"""
return utils.dialogo_entrada(titulo = "NOMBRE CONSUMO",
texto = "Introduzca un nombre identificativo si lo desea:",
padre = self.wids['ventana'])
def pedir_producto(self):
"""
Solicita un código de producto, muestra una
ventana de resultados coincidentes con la
búsqueda de ese código y devuelve un
objeto producto seleccionado de entre
los resultados o None si se cancela o
no se encuentra.
"""
producto = None
codigo = utils.dialogo_entrada(texto = 'Introduzca código o descripción del producto.',
titulo = 'PRODUCTO',
padre = self.wids['ventana'])
if codigo != None:
prods = pclases.ProductoCompra.select(pclases.AND(pclases.OR(pclases.ProductoCompra.q.descripcion.contains(codigo),
pclases.ProductoCompra.q.codigo.contains(codigo)),
pclases.ProductoCompra.q.controlExistencias == True))
prods = tuple(prods)
mens_error = 'No se encontró ningún producto con ese código o descripción.'
if len(prods) > 1:
idproducto = self.refinar_busqueda_productos(prods)
if idproducto != None:
prods = [pclases.ProductoCompra.get(idproducto)]
else:
return None
elif len(prods) < 1:
utils.dialogo_info(titulo = 'CÓDIGO NO ENCONTRADO',
texto = mens_error,
padre = self.wids['ventana'])
return None
producto = prods[0]
return producto
def agregar_a_pedido(self, widget):
"""
Asigna la linea sin pedido a un pedido ya creado
"""
model, itr = self.wids['tv_tipos'].get_selection().get_selected()
if itr != None:
idtipo = model[itr][-1]
linea_sin_pedido = pclases.LineaDeVenta.get(idtipo)
else:
utils.dialogo_info('ERROR','Seleccione una línea para asignarla al pedido')
return
numpedido = utils.dialogo_entrada(titulo = 'NÚMERO DE PEDIDO', texto = 'Introduzca el número del pedido al que desea añadir la línea seleccionada')
pedido = self.buscar_pedido(numpedido)
if pedido == None:
utils.dialogo_info(texto = 'No se encontró ningún pedido con ese número', titulo = 'ERROR')
return
linea_sin_pedido.pedidoVenta = pedido
ldc = pclases.LineaDePedido(presupuesto = None,
pedidoVenta = pedido,
productoVenta = linea_sin_pedido.productoVenta,
productoCompra = linea_sin_pedido.productoCompra,
fechahora = mx.DateTime.localtime(),
cantidad = linea_sin_pedido.cantidad,
precio = linea_sin_pedido.precio,
descuento = linea_sin_pedido.descuento,
fechaEntrega = None,
textoEntrega='')
pclases.Auditoria.nuevo(ldc, self.usuario, __file__)
self.rellenar_tabla()
from formularios import pedidos_de_venta
pedidos_de_venta.PedidosDeVenta(objeto = pedido, usuario = self.usuario)
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 set_lote(self, w):
numlote = utils.dialogo_entrada(titulo = 'Nº LOTE',
texto = 'Introduzca número de lote:')
if numlote != None:
lotes = pclases.Lote.select(pclases.Lote.q.numlote.contains(numlote))
if lotes.count() == 0:
utils.dialogo_info(titulo = 'LOTE NO ENCONTRADO',
texto = 'No se encontró ningún lote %s.' % numlote)
return
elif lotes.count() > 1:
filas = [(l.id, l.numlote, l.codigo, l.tenacidad, l.elongacion, l.rizo, l.encogimiento) for l in lotes]
idlote = utils.dialogo_resultado(filas,
titulo = 'SELECCIONE LOTE',
cabeceras = ('ID', 'Número', 'Código', 'Tenacidad', 'Elongación', 'Rizo', 'Encogimiento'))
if idlote < 0:
return
lote = pclases.Lote.get(idlote)
else:
lote = lotes[0]
if len(lote.balas) == 0:
utils.dialogo_info(titulo = 'LOTE VACÍO',
texto = 'El lote no contiene balas, no puede\nrealizar pruebas sobre un lote vacío.')
self.lote = None
return
self.lote = lote
self.actualizar_ventana()
def set_partida(self, w):
numpartida = utils.dialogo_entrada(titulo = 'Nº PARTIDA',
texto = 'Introduzca número de partida:')
if numpartida != None:
partidas = pclases.Partida.select(pclases.Partida.q.numpartida.contains(numpartida))
if partidas.count() == 0:
utils.dialogo_info(titulo = 'PARTIDA NO ENCONTRADA',
texto = 'No se encontró ninguna partida %s.' % numpartida)
return
elif partidas.count() > 1:
filas = [(l.id, l.numpartida, l.codigo, l.longitudinal, l.transversal, l.compresion, l.perforacion, l.permeabilidad, l.poros, l.espesor) for l in partidas]
idpartida = utils.dialogo_resultado(filas,
titulo = 'SELECCIONE PARTIDA',
cabeceras = ('ID', 'Número', 'Código', 'Longitudinal', 'Transversal', 'CBR', 'Perforación', 'Permeabilidad', 'Poros', 'Espesor'))
if idpartida < 0:
return
partida = pclases.Partida.get(idpartida)
else:
partida = partidas[0]
if len(partida.rollos) == 0:
utils.dialogo_info(titulo = 'PARTIDA VACÍA',
texto = 'La partida no contiene rollos, no puede\nrealizar pruebas sobre una partida vacía.')
self.partida = None
return
self.partida = partida
self.actualizar_ventana()
def clon_srv(self, boton):
"""
Busca un servicio existente en la BD (previamente facturado,
por tanto) y crea un nuevo servicio idéntico pero asociado a
la factura actual.
"""
a_buscar = utils.dialogo_entrada(titulo = 'BUSCAR SERVICIO FACTURADO',
texto = 'Introduzca un concepto (o parte) ya facturado:',
padre = self.wids['ventana'])
servicios = pclases.Servicio.select(pclases.Servicio.q.concepto.contains(a_buscar), orderBy = "concepto")
filas = [(s.id,
s.concepto,
s.precio,
(s.facturaVenta and s.facturaVenta.numfactura) or (s.prefactura and s.prefactura.numfactura) or '',
(s.facturaVenta and s.facturaVenta.cliente and s.facturaVenta.cliente.nombre) or
(s.prefactura and s.prefactura.cliente and s.prefactura.cliente.nombre) or '')
for s in servicios]
res = utils.dialogo_resultado(filas,
"SELECCIONE SERVICIO",
cabeceras = ('ID', 'Concepto', 'Precio', 'Facturado en', 'Cliente'),
multi = True,
padre = self.wids['ventana'])
if res[0] > 0:
for idservicio in res:
servicio = pclases.Servicio.get(idservicio)
nuevo_servicio = pclases.Servicio(facturaVenta = self.objeto,
concepto = servicio.concepto,
precio = servicio.precio,
descuento = servicio.descuento)
self.rellenar_servicios()
self.rellenar_vencimientos() # Para que verifique si los totales coinciden
def add_documento(self, num_factura):
""" Muestra una ventana donde añadir un documento de pago"""
importe = utils.dialogo_entrada(titulo="Importe para la factura %s" %
(num_factura),
texto="Ponga el fichero de pago en el scanner y acepte. ",
padre=self.wids['ventana'])
if not importe:
return 0.0
return float(importe)
def add_cuadrilla(self, widget):
nombre = utils.dialogo_entrada(
titulo="Nueva cuadrilla",
texto="Introduzca el nombre de la cuadrilla: ",
padre=self.wids['ventana'])
# comprobar que no exista
if nombre is not None:
pclases.Cuadrilla(nombre=nombre)
self.rellenar_empleados()
def modificar_contador(self, widget):
model, itr = self.wids['tv_tipos'].get_selection().get_selected()
if itr != None:
idtipo = model[itr][-1]
contador = pclases.Contador.get(idtipo)
else:
utils.dialogo_info('ERROR','Seleccione contador a modificar')
return
prefijo = utils.dialogo_entrada('Introduzca el nuevo prefijo.')
if prefijo != None:
sufijo = utils.dialogo_entrada('Introduzca el nuevo sufijo.')
try:
if prefijo != None and sufijo != None:
contador.prefijo = prefijo
contador.sufijo = sufijo
except:
utils.dialogo_info('ERROR','No se ha podido modificar el contador.')
self.rellenar_tabla()
def buscar_rollos(self,wid):
"""
Pide el código de un producto y busca todos las unidades de ese producto
"""
self.cache_albaranes = {} # Reinicio la caché en cada búsqueda.
a_buscar = utils.dialogo_entrada(titulo = 'INTRODUZCA DATOS',
texto = 'Introduzca el código o descripción\n'
'del producto que desea listar:',
padre = self.wids['ventana'])
if a_buscar != None:
criterio = pclases.OR(pclases.ProductoVenta.q.codigo.contains(a_buscar),
pclases.ProductoVenta.q.descripcion.contains(a_buscar))
criterio = pclases.AND(criterio, pclases.ProductoVenta.q.camposEspecificosRolloID != None)
resultados = pclases.ProductoVenta.select(criterio)
if resultados.count() > 1:
## Refinar los resultados
idproducto = self.refinar_resultados_busqueda(resultados)
if idproducto == None:
return
resultados = [pclases.ProductoVenta.get(idproducto)]
elif resultados.count() < 1:
## Sin resultados de búsqueda
utils.dialogo_info(titulo = 'ERROR', texto = 'No hay ningún producto con ese código')
return
## Un único resultado
# Pongo el objeto como actual
producto = resultados[0]
self.wids['e_descripcion'].set_text(producto.descripcion)
# articulos_rollo = [i for i in producto.articulos if i.rolloID!=None]
and_fecha_inicio = "AND fechahora >= '%s'" % (self.get_unambiguous_fecha(self.inicio))
articulos_rollo = pclases.Articulo.select("""rollo_id IS NOT NULL AND producto_venta_id = %d
AND rollo_id IN (SELECT id FROM rollo WHERE fechahora <= '%s' %s ) """ \
% (producto.id,
self.get_unambiguous_fecha(
self.fin + mx.DateTime.oneDay),
self.inicio and and_fecha_inicio or ""))
articulos_defectuosos = pclases.Articulo.select("""rollo_defectuoso_id IS NOT NULL AND producto_venta_id = %d
AND rollo_defectuoso_id IN (SELECT id FROM rollo_defectuoso WHERE fechahora <= '%s' %s ) """ \
% (producto.id,
self.get_unambiguous_fecha(
self.fin + mx.DateTime.oneDay),
self.inicio and and_fecha_inicio or ""))
gtxcs = pclases.Articulo.select("""
rollo_c_id IS NOT NULL AND producto_venta_id = %d
AND rollo_c_id IN (
SELECT id
FROM rollo_c
WHERE fechahora <= '%s' %s )
""" % (producto.id,
self.get_unambiguous_fecha(self.fin + mx.DateTime.oneDay),
self.inicio and and_fecha_inicio or ""))
self.rellenar_tabla(articulos_rollo,
articulos_defectuosos,
gtxcs,
producto)
def buscar(self, widget):
"""
Muestra una ventana de búsqueda y a continuación los
resultados. El objeto seleccionado se hará activo
en la ventana a no ser que se pulse en Cancelar en
la ventana de resultados.
"""
transferencia = self.objeto
a_buscar = utils.dialogo_entrada(titulo = "BUSCAR TRANSFERENCIA",
texto = "Introduzca identificador, importe o pulse «Aceptar» para verlas todas:",
padre = self.wids['ventana'])
if a_buscar != None:
try:
ida_buscar = int(a_buscar)
except ValueError:
ida_buscar = -1
try:
a_buscar = float(a_buscar)
except ValueError:
if ida_buscar != -1:
criterio = pclases.Pago.q.id == ida_buscar
else:
criterio = None
else:
criterio = pclases.OR(pclases.Pago.q.importe == a_buscar,
pclases.Pago.q.id == ida_buscar)
resultados = pclases.Pago.select(criterio)
resultados = [r for r in resultados if r.es_transferencia()]
if len(resultados) > 1:
## Refinar los resultados
idtransferencia = self.refinar_resultados_busqueda(resultados)
if idtransferencia == None:
return
resultados = [pclases.Pago.get(idtransferencia)]
elif len(resultados) < 1:
## Sin resultados de búsqueda
utils.dialogo_info('SIN RESULTADOS', 'La búsqueda no produjo resultados.\nPruebe a cambiar el texto buscado o déjelo en blanco para ver una lista completa.\n(Atención: Ver la lista completa puede resultar lento si el número de elementos es muy alto)',
padre = self.wids['ventana'])
return
## Un único resultado
# Primero anulo la función de actualización
if transferencia != None:
transferencia.notificador.desactivar()
# Pongo el objeto como actual
try:
transferencia = resultados[0]
except IndexError:
utils.dialogo_info(titulo = "ERROR",
texto = "Se produjo un error al recuperar la información.\nCierre y vuelva a abrir la ventana antes de volver a intentarlo.",
padre = self.wids['texto'])
return
# Y activo la función de notificación:
transferencia.notificador.activar(self.aviso_actualizacion)
self.activar_widgets(True)
self.objeto = transferencia
self.actualizar_ventana()
