Python utils.dialogo_info函数代码示例

 def buscar_cod_libre(self):
     """
     Devuelve un código de tres cifras como 
     cadena que no esté ya en la tabla de 
     productos como producto terminado.
     Siempre devolverá el primer código
     libre más cercano a 000.
     Si no quedan más mostrará un mensaje
     de error por pantalla y devolverá
     999.
     """
     prods = pclases.ProductoVenta.select(pclases.AND(
         pclases.OR(
             pclases.ProductoVenta.q.camposEspecificosBalaID !=None, 
             pclases.ProductoVenta.q.camposEspecificosRolloID !=None, 
             pclases.ProductoVenta.q.camposEspecificosEspecialID !=None), 
         pclases.ProductoVenta.q.codigo.startswith('843603219')))
     # Incluyo todo tipo de productos porque aunque la fibra esté limitada 
     # al rango 300~400, el resto no, y al crearlos ha podido pillar uno 
     # de esos números.
     codsproducto = [int(p.codigo[-4:-1]) for p in prods]
     codsproducto.sort()
     for i in xrange(300, 400):  # OJO: Códigos hardcoded. Para balas se 
                                 # han asignado los códigos 300 a 399.
         try:
             if not i in codsproducto:
                 return "%03d" % i
         except IndexError:  # No hay o me pasé de rango
             return "%03d" % i
     utils.dialogo_info('NO QUEDAN CÓDIGOS DISPONIBLES', 
                        'Todos los códigos EAN13 fueron asignados.', 
                        padre = self.wids['ventana'])
     return '999'

 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 drop_consumo_por_producto(self, boton):
     """
     Elimina el consumo o consumos seleccionados en el TreeView.
     """
     texto = """
     Si ha seleccionado un consumo se eliminará el consumo completo.             
     Si seleccionó uno o varios productos, se eliminarán del consumo al          
     que pertenece, por lo que ya no empleará el material relacionado            
     cuando se fabriquen artículos del mismo.                                    
                                                                                 
     ¿Está seguro de querer continuar?                                           
                                                                                 
     """
     model, paths = self.wids['tv_consumos'].get_selection().get_selected_rows()
     if paths and utils.dialogo(titulo = "¿ELIMINAR?", texto = texto, padre = self.wids['ventana']):
         for path in paths:
             if model[path].parent == None:
                 id_consumo = model[path][-1]
                 consumo_adicional_por_producto = pclases.ConsumoAdicional.get(id_consumo)
                 try:
                     for p in consumo_adicional_por_producto.productosVenta:
                         consumo_adicional_por_producto.removeProductoVenta(p)
                     consumo_adicional_por_producto.destroySelf()
                 except pclases.psycopg_ProgrammingError, msg:
                     utils.dialogo_info(titulo = "ERROR: INFORME A LOS DESARROLLADORES", 
                                        texto = "Ocurrió un error al eliminar el consumo.\nDEBUG: Traza de la excepción:\n%s" % (msg), 
                                        padre = self.wids['ventana'])
             else:
                 id_consumo = model[path].parent[-1]
                 idproductov = model[path][-1]
                 consumo_adicional_por_producto = pclases.ConsumoAdicional.get(id_consumo)
                 productov = pclases.ProductoVenta.get(idproductov)
                 consumo_adicional_por_producto.removeProductoVenta(productov)
         self.rellenar_consumos_adicionales_por_producto()

 def buscar_pedido(self, numero):
     """
     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.
     """
     if numero != None:
         resultados = pclases.PedidoVenta.select(pclases.PedidoVenta.q.numpedido.contains(numero))
         if resultados.count() > 1:
                 ## Refinar los resultados
                 idpedido = self.refinar_resultados_busqueda(resultados)
                 if idpedido == None:
                     return
                 resultados = [pclases.PedidoVenta.get(idpedido)]
                 # Se supone que la comprensión de listas es más rápida que hacer un nuevo get a SQLObject.
                 # Me quedo con una lista de resultados de un único objeto ocupando la primera posición.
                 # (Más abajo será cuando se cambie realmente el objeto actual por este resultado.)
         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
         ## Un único resultado
         return resultados[0]
     else:
         return None

 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), #@UndefinedVariable
                                                                      pclases.ProductoCompra.q.codigo.contains(codigo)), #@UndefinedVariable
                                                           pclases.ProductoCompra.q.controlExistencias == True)) #@UndefinedVariable
         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 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.Uduario.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 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)
             self.rellenar_widgets()

 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 salir(self, boton, event=None, mostrar_ventana=False):
     """
     Muestra una ventana de confirmación y 
     sale de la ventana cerrando el bucle
     local de gtk_main.
     Si mostrar_ventana es False, sale directamente
     sin preguntar al usuario.
     """
     try:
         b_guardar = self.wids['b_guardar']
     except KeyError:
         b_guardar = None
     if  b_guardar != None and b_guardar.get_property('sensitive'):
         # Hay cambios pendientes de guardar.
         if utils.dialogo('Hay cambios pendientes de guardar.\n¿Desea hace'
                          'rlo ahora?', 
                          '¿GUARDAR CAMBIOS?', 
                          padre = self.wids['ventana'], 
                          icono = gtk.STOCK_SAVE, 
                          #defecto = "Sí"):  # CWT: A veces en BlancoPe 
                             # abren la ventana de productos para buscar 
                             # un precio y le dan al botón antes de que se 
                             # carguen los datos, provocando que se detecte 
                             # como un falso cambio de datos de la ventana 
                             # (todo blanco) respecto a la caché (datos 
                             # reales de la BD). Al darle a ENTER, 
                             # responden Sí por defecto -hasta ahora- y 
                             # sobreescriben con blanco todos los datos del 
                             # registro en la base de datos.
                          defecto = "No"):
             try:
                 self.guardar(None)
             except:
                 utils.dialogo_info(titulo = 'NO SE PUDO GUARDAR', 
                                    texto = 'Los cambios no se pudieron gua'
                                            'rdar automáticamente.\nDebe ha'
                                            'cerlo de forma manual',
                                    padre = self.wids['ventana'])
                 return True # Si devuelvo False, None, etc... continúa la 
                             # cadena de eventos y destruye la ventana.
                             # Devuelvo True para cancelar el cierre de la 
                             # ventana. 
     if event == None:
         # Me ha invocado el botón
         if not mostrar_ventana or \
             utils.dialogo('¿Desea salir de la ventana actual?', 
                          'SALIR', 
                          padre = self.wids['ventana'], 
                          icono = gtk.STOCK_QUIT):
             self.wids['ventana'].destroy()
             return False
         else:
             return True
     else:
         if not mostrar_ventana or not \
                 utils.dialogo('¿Desea salir de la ventana actual?',
                 'SALIR', padre=self.wids['ventana'], icono=gtk.STOCK_QUIT):
             return False
         else:
             return True

 def pedir_transportista(self, widget):
     """
     Solicita un número de pedido, muestra una
     ventana de resultados coincidentes con la 
     búsqueda de ese número y devuelve un 
     objeto pedido seleccionado de entre
     los resultados o None si se cancela o 
     no se encuentra.
     """
     global transportista
     codigo = utils.dialogo_entrada(texto = 'Introduzca nombre del transportista', titulo = 'TRANSPORTISTA', padre = self.wids['ventana'])
     if codigo != None:
         trans = pclases.Transportista.select(pclases.Transportista.q.nombre.contains(codigo))
         trans = [p for p in trans]
         mens_error = 'No se encontró ningún transportista con ese nombre.'
         if len(trans) > 1:
             idtrans = refinar_busqueda_transportista(trans)
             if idtrans != None:
                 trans = [p for p in trans if p.id == idtrans]
             else:
                 return None
         elif len(trans) < 1:
             utils.dialogo_info('TRANSPORTISTA NO ENCONTRADO', mens_error, padre = self.wids['ventana'])
             return None
         transportista = trans[0]

 def cambiar_precio(self, cell, path, texto):
     try:
         precio = float(texto)
     except:
         utils.dialogo_info(titulo = "ERROR FORMATO", 
                            texto = "El texto %s no es un número." % texto, 
                            padre = self.wids['ventana'])
     else:
         model = self.wids['tv_ldvs'].get_model()
         ldc = pclases.LineaDeCompra.get(model[path][-1])
         ldc.precio = precio
         # CWT: Si el precio cambia al alza, respetar porcentaje. Si meto 
         # un precio inferior, entonces respetar el precio final de las 
         # tarifas y adaptar el porcentaje a ese precio de forma que nunca 
         # venda más barato al cambiar el precio del proveedor.
         pc = ldc.productoCompra
         pc.sync()
         if precio > pc.precioDefecto:
             # Si el precio sube, actualizo tarifas respetando porcentajes.
             for t in pclases.Tarifa.select(orderBy = "nombre"):
                 if t.vigente:
                     porcentaje = t.get_porcentaje(pc, fraccion = True)
                     nuevo_precio = precio * (1 + porcentaje)
                     t.asignarTarifa(pc, nuevo_precio)
         # Si el precio ha bajado o se mantiene, respeto precio final. La 
         # ventana ya calculará el porcentaje que sea.
         pc.precioDefecto = precio
         pc.syncUpdate()
         self.actualizar_ventana()

 def seleccionar_cantidad(self, producto):
     """
     Muestra un diálogo para introducir la cantidad.
     Si el producto es un rollo, se introducirá en 
     metros cuadrados.
     Si es una bala, se introducirá en kilos.
     En las LDV se mantendrán también estas unidades
     ya que el precio por unidad va en función de 
     kilos y rollos en el producto.
     Cuando se haga el albarán es cuando habrá que
     calcular cuantos rollos (y cuáles en concreto)
     y cuántas balas entran. Aunque en realidad es 
     el usuario el que las seleccionará y el programa
     irá informando si se satisface la LDV o no.
     """
     if isinstance(producto, pclases.ProductoCompra):
         txt = "Introduzca la cantidad en %s." % (producto.unidad)
     else:
         txterror = "presupuestos::seleccionar_cantidad -> ERROR: Producto %s no es producto de compra ni de venta." % (producto)
         self.logger.error(txterror)
     cantidad = utils.dialogo_entrada(titulo = 'CANTIDAD', texto = txt, padre = self.wids['ventana'])
     try:
         cantidad = utils._float(cantidad)
         return cantidad
     except:
         utils.dialogo_info(titulo = 'ERROR', texto = 'La cantidad introducida no es correcta.', padre = self.wids['ventana'])
         return None

 def borrar(self, widget):
     """
     Elimina la cuenta de la tabla pero NO
     intenta eliminar ninguna de sus relaciones,
     de forma que si se incumple alguna 
     restricción de la BD, cancelará la eliminación
     y avisará al usuario.
     """
     if not utils.dialogo('¿Eliminar %s?'%self.clase.sqlmeta.table.lower(), 
                          'BORRAR', 
                          padre = self.wids['ventana']):
         return
     self.objeto.notificador.desactivar()
     try:
         self.objeto.destroySelf()
     except Exception, e:
         self.logger.error("grupos_alumnos.py::borrar -> %s ID %d no se "
                           "pudo eliminar. Excepción: %s." % (
                             self.objeto.sqlmeta.table, self.objeto.id, e))
         utils.dialogo_info(
             titulo = "%s NO BORRADO" % self.clase.sqlmeta.table.upper(), 
             texto = "%s no se pudo eliminar.\n\nSe generó un informe de "
                     "error en el «log» de la aplicación." % (
                         self.clase.sqlmeta.table.title()),
             padre = self.wids['ventana'])
         self.actualizar_ventana()
         return

 def borrar_producto(self, widget):
     """
     Elimina el producto de la tabla pero NO
     intenta eliminar ninguna de sus relaciones,
     de forma que si se incumple alguna 
     restricción de la BD, cancelará la eliminación
     y avisará al usuario.
     """
     producto = self.objeto
     if not utils.dialogo('¿Eliminar el producto?', 'BORRAR'):
         return
     if producto.articulos != [] or producto.precios != []:
         utils.dialogo_info('PRODUCTO NO ELIMINADO', 'El producto está implicado en operaciones que impiden su borrado.', padre = self.wids['ventana'])
     else:
         producto.notificador.desactivar()
         campos = producto.camposEspecificosBala
         try:
             producto.destroySelf()
             campos.destroySelf()
         except:
             utils.dialogo_info(titulo = "NO SE PUEDE ELIMINAR",
                                texto = "El producto no se puede eliminar. Verifique que no\ntiene ventas o producción relacionada.", 
                                padre = self.wids['ventana'])
         else:
             self.objeto = None
             self.ir_a_primero()

 def cambiar_precio_ldp(self, cell, path, texto):
     """
     Cambia el precio de la LDP conforme al texto recibido.
     """
     try:
         precio = utils._float(texto)
     except:
         utils.dialogo_info(titulo = "ERROR", 
                            texto = 'El texto "%s" no es un número.' % (texto), 
                            padre = self.wids['ventana'])
     else:
         model = self.wids['tv_ldps'].get_model()
         ldp = pclases.LineaDePedido.get(model[path][-1])
         if ldp.precio != precio:
             ldp.precio = precio
             if ldp.get_lineas_de_venta() != [] \
                and utils.dialogo(titulo = "¿CAMBIAR PRECIO PRODUCTOS SERVIDOS?", 
                              texto = """
             Al cambiar el precio de una parte del presupuesto ofertado,             
             se cambian automáticamente los precios de los pedidos                   
             involucrados. También puede cambiar los albaranes y facturas            
             si el pedido ya ha sido servido.                                        
                                                                                     
             ¿Desea cambiar el precio de todos los artículos servidos                
             de este producto?                                                       
                                                                                     
             Si lo hace, se cambiará también en la factura en caso de                
             que se haya facturado el albarán o albaranes                            
             correspondientes.                                                       
             """, 
                             padre = self.wids['ventana']):
                 for ldv in ldp.get_lineas_de_venta():
                     ldv.precio = ldp.precio
         self.rellenar_tablas()