Python utils.combo_get_value函数代码示例

 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 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))