Esempio n. 1
0
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     Ventana.__init__(self, 'busca_lote.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_ayuda/clicked': self.ayuda}
     self.add_connections(connections)
     cols = (('Num. Lote','gobject.TYPE_INT64',False,True,False,None),
             ('Código','gobject.TYPE_STRING',False,True,False,None),
             ('Tenacidad','gobject.TYPE_STRING',False,True,False,None),
             ('Elongación','gobject.TYPE_STRING',False,True,False,None),
             ('Rizo','gobject.TYPE_STRING',False,True,False,None),
             ('Encogimiento','gobject.TYPE_STRING',False,True,False,None),
             ('Idlote','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_listview(self.wids['tv_resultado'], cols)
     utils.rellenar_lista(self.wids['cmbe_producto'], [(p.id, p.nombre) for p in pclases.ProductoVenta.select(pclases.ProductoVenta.q.camposEspecificosBalaID != None, orderBy = 'nombre')])
     self.rellenar_tabla()
     # Valores por defecto:
     self.wids['e_tenacidad'].set_text('A')
     self.wids['e_elongacion'].set_text('A')
     self.wids['e_rizo'].set_text('6-7')
     self.wids['e_encogimiento'].set_text('A')
     self.wids['chk_tenacidad'].set_active(True)
     self.wids['chk_elongacion'].set_active(True)
     self.wids['chk_rizo'].set_active(True)
     self.wids['chk_encogimiento'].set_active(True)
     self.wids['chk_producto'].set_active(True)
     
     gtk.main()
Esempio n. 2
0
 def inicializar_ventana(self):
     """
     Inicialización de controles de la ventana.
     """
     self.wids['frame_observaciones'].set_property("visible", False)
     try:
         dde = pclases.DatosDeLaEmpresa.select()[0]
         if "Bogado" in dde.nombre:
             self.wids['frame_observaciones'].set_property("visible", True)
     except:
         pass
     self.activar_widgets(False)
     utils.rellenar_lista(self.wids['cbe_cuenta_origen'], 
                          [(c.id, "%s%s" % (c.ccc, c.nombre and " (%s)" % c.nombre or "")) for c in pclases.CuentaOrigen.select(orderBy = "nombre")])
     utils.rellenar_lista(self.wids['cbe_cuenta_bancaria_cliente'], 
                             [(c.id, "%s%s%s%s (%s)" % (
                                 c.cuenta, 
                                 c.iban and " | IBAN: " + c.iban or "", 
                                 c.swif and " | SWIF: " + c.swif or "", 
                                 c.banco and " (%s)" % c.banco or "", 
                                 c.cliente and c.cliente.nombre 
                                     or "SIN CLIENTE")) 
                              for c in pclases.CuentaBancariaCliente.select(orderBy = "id")])
     self.wids['b_actualizar'].set_sensitive(False)
     self.wids['b_guardar'].set_sensitive(False)
     self.wids['b_nuevo'].set_sensitive(True)
     self.wids['b_buscar'].set_sensitive(True)
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     global fin
     Ventana.__init__(self, 'consulta_lotes_por_producto.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    "b_exportar/clicked": self.exportar}
     self.add_connections(connections)
     cols = (('Num. Lote','gobject.TYPE_INT64',False,True,False,None),
             ('Código','gobject.TYPE_STRING',False,True,False,None),
             ('Tenacidad','gobject.TYPE_STRING',False,True,False,None),
             ('Elongación','gobject.TYPE_STRING',False,True,False,None),
             ('Rizo','gobject.TYPE_STRING',False,True,False,None),
             ('Encogimiento','gobject.TYPE_STRING',False,True,False,None),
             ('Grasa','gobject.TYPE_STRING',False,True,False,None),
             ('Idlote','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_parte_tv)
     utils.rellenar_lista(self.wids['cmbe_producto'], [(p.id, p.nombre) for p in pclases.ProductoVenta.select(pclases.ProductoVenta.q.camposEspecificosBalaID != None, orderBy = 'nombre')])
     temp = time.localtime()
     self.fin = mx.DateTime.localtime()
     self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
     gtk.main()
Esempio n. 4
0
 def __init__(self, mes = None, anno = None, ldp = None, solo_lectura = False, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases  de la 
     línea de producción con la que comenzar la ventana.
     """
     self.escritura = not solo_lectura
     Ventana.__init__(self, 'calendario_laboral.glade', None)
     connections = {'b_salir/clicked': self.salir
                    }
     self.add_connections(connections)
     self.cal = []    # Los Gtk.Table no tienen método para acceder a los hijos por fila y columna (flipa!).
                      # Así que los iré guardando aquí para poderlos crear y destruir sobre la marcha.
     utils.rellenar_lista(self.wids['cbe_linea'], 
                          [(l.id, l.nombre) for l in pclases.LineaDeProduccion.select(orderBy='nombre')])
     if mes == None:
         mes = mx.DateTime.localtime().month
     if anno == None:
         anno = mx.DateTime.localtime().year
     self.wids['sp_mes'].set_value(mes)
     self.wids['sp_anno'].set_value(anno)
     self.wids['cbe_linea'].connect('changed', self.rellenar_widgets)
     self.wids['sp_mes'].connect('value-changed', self.rellenar_widgets)
     self.wids['sp_anno'].connect('value-changed', self.rellenar_widgets)
     if ldp == None:
         utils.combo_set_from_db(self.wids['cbe_linea'], pclases.LineaDeProduccion.select(orderBy='nombre')[0].id)
     else:
         utils.combo_set_from_db(self.wids['cbe_linea'], ldp.id)
     gtk.main()
Esempio n. 5
0
 def mostrar_info_cliente(self):
     """
     Introduce el código del cliente y la información relativa en los widgets.
     Si el nombre y domicilio del librado están en blanco, escribe también 
     ahí los datos del cliente.
     """
     if self.cliente == None:
         self.wids['e_codcliente'].set_text("")
         utils.rellenar_lista(self.wids['cbe_cuenta_bancaria_cliente'], 
             [(c.id, "%s%s%s%s" % (c.cuenta, 
                                   c.iban and " | IBAN: " + c.iban or "", 
                                   c.swif and " | SWIF: " + c.swif or "", 
                                   c.banco and " (%s)" % c.banco or "")) 
              for c in pclases.CuentaBancariaCliente.select(orderBy = "id")])
     else:
         self.wids['e_codcliente'].set_text(`self.cliente.id`)
         utils.rellenar_lista(self.wids['cbe_cuenta_bancaria_cliente'], 
             [(c.id, "%s%s%s%s" % (c.cuenta, 
                                   c.iban and " | IBAN: " + c.iban or "", 
                                   c.swif and " | SWIF: " + c.swif or "", 
                                   c.banco and " (%s)" % c.banco or "")) 
              for c in pclases.CuentaBancariaCliente.select(
                 pclases.CuentaBancariaCliente.q.clienteID==self.cliente.id, 
                 orderBy = "id")])
         if self.objeto.nombreLibrado == "":
             self.objeto.nombreLibrado = self.cliente.nombre
         if self.objeto.direccionLibrado == "":
             self.objeto.direccionLibrado = ", ".join(
                                                 (self.cliente.direccion, 
                                                  self.cliente.cp, 
                                                  self.cliente.ciudad))
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     global fin
     Ventana.__init__(self, 'consulta_albaranes_clientes.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     utils.rellenar_lista(self.wids['cmbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy='nombre')])
     cols = (('Cliente','gobject.TYPE_STRING',False,True,False,None),
             ('Fecha','gobject.TYPE_STRING',False,True,False,None),
             ('Albarán','gobject.TYPE_STRING',False,True,False,None),
             ('Destinatario','gobject.TYPE_STRING',False,True,False,None),
             ('Facturado', 'gobject.TYPE_BOOLEAN', False, True, False, None),
             ('Facturas', 'gobject.TYPE_STRING', False, True, False, None),
             ('Idalbaran','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_albaran)
     temp = time.localtime()
     self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
     self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
     gtk.main()
Esempio n. 7
0
    def __init__(self, objeto = None, usuario = None):
        """
        Constructor. objeto puede ser un objeto de pclases con el que
        comenzar la ventana (en lugar del primero de la tabla, que es
        el que se muestra por defecto).
        """
        global fin
        Ventana.__init__(self, 'consulta_entradas_almacen.glade', objeto)
        connections = {'b_salir/clicked': self.salir,
                       'b_buscar/clicked': self.buscar,
                       'b_imprimir/clicked': self.imprimir,
                       'b_fecha_inicio/clicked': self.set_inicio,
                       'b_producto/clicked': self.buscar_producto,
                       'b_fecha_fin/clicked': self.set_fin}
        self.add_connections(connections)
        utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) for c in pclases.Proveedor.select(orderBy='nombre')])

        cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
                ('Albarán', 'gobject.TYPE_STRING', False, True, True, None),
                ('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
                ('Producto', 'gobject.TYPE_STRING', False, True, True, None),
                ('Cantidad', 'gobject.TYPE_FLOAT', False, True, False, None),
                ('Precio', 'gobject.TYPE_FLOAT', False, True, False, None),
                ('Subtotal', 'gobject.TYPE_FLOAT', False, True, False, None),
                ('idldc','gobject.TYPE_STRING',False,False,False,None))
        utils.preparar_listview(self.wids['tv_datos'], cols)
        for ncol in (4, 5, 6):
            col = self.wids['tv_datos'].get_column(ncol)
            for cell in col.get_cell_renderers():
                cell.set_property("xalign", 1)
        temp = time.localtime()
        self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
        self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
        self.producto = None
        gtk.main()
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.grafico = None
     Ventana.__init__(self, 'historico_existencias.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_fecha/clicked': self.set_fecha,
                    'b_imprimir/clicked': self.imprimir,
                    'b_actualizar/clicked': self.cambiar_grafico, 
                   }
     self.add_connections(connections)
     self.wids['ventana'].set_title("Histórico de existencias de productos de compra")
     fechactual = datetime.date.today()
     fechactual = datetime.datetime(day = 1, 
                                    month = fechactual.month, 
                                    year = fechactual.year)
     primero_de_mes_corriente = utils.str_fecha(fechactual)
     self.wids['e_fecha'].set_text(primero_de_mes_corriente)
     opciones = [(p.id, p.descripcion) for p in pclases.ProductoCompra.select(orderBy = "descripcion") if p.controlExistencias]
     opciones.insert(0, (-1, "Todos (escala logarítmica)"))
     utils.rellenar_lista(self.wids['cbe_grafico'], opciones)
     gtk.main()
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     global fin
     Ventana.__init__(self, 'consulta_pedidos_clientes.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin,
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     utils.rellenar_lista(self.wids['cmbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy='nombre')])
     cols = (('Código', 'gobject.TYPE_STRING', False, True, False, None),
             ('Descripción', 'gobject.TYPE_STRING', False,True,False,None),
             ('Precio s/IVA', 'gobject.TYPE_STRING', False,True,False,None),
             ('ID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     col = self.wids['tv_datos'].get_column(2)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
     temp = time.localtime()
     self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
     self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
     if objeto != None:
         utils.combo_set_from_db(self.wids["cmbe_cliente"], objeto.id)
         self.wids["b_buscar"].clicked()
     self.wids['hbox4'].set_property("visible", False)
     self.wids['ventana'].set_title("Productos facturados al cliente")
     gtk.main()
Esempio n. 10
0
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     global fin
     Ventana.__init__(self, 'consulta_ventas.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin}
     self.add_connections(connections)
     cols = (('Cliente','gobject.TYPE_STRING',False,True,False,None),
             ('Factura','gobject.TYPE_STRING',False,True,True,None),
             ('Fecha','gobject.TYPE_STRING',False,True,False,None),
             ('Total','gobject.TYPE_STRING',False,True,False,None),
             ('Beneficio','gobject.TYPE_STRING',False,True,False,None),
             ('Pendiente','gobject.TYPE_STRING',False,True,False,None),
             ('Id','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_prefactura)
     self.wids['tv_datos'].get_column(3).get_cell_renderers()[0].set_property('xalign', 1) 
     self.wids['tv_datos'].get_column(4).get_cell_renderers()[0].set_property('xalign', 1) 
     self.wids['tv_datos'].get_column(5).get_cell_renderers()[0].set_property('xalign', 1) 
     temp = time.localtime()
     self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
     self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
     self.metros_totales = 0.0
     self.kilos_totales = 0.0
     opciones = [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy = "nombre")]
     opciones.insert(0, (-1, "Todos"))
     utils.rellenar_lista(self.wids['cbe_cliente'], opciones)
     utils.combo_set_from_db(self.wids['cbe_cliente'], -1)
     self.wids['label7'].set_text("Total beneficio estimado: ")
     #self.wids['label7'].set_property("visible", False)
     #self.wids['e_total_kilos'].set_property("visible", False)
     self.wids['label8'].set_property("visible", False)
     self.wids['e_total_metros'].set_property("visible", False)
     self.wids['label9'].set_property("visible", False)
     self.wids['cbe_cliente'].set_property("visible", False)
     self.wids['ventana'].set_title("Listado de prefacturas")
     self.wids['notebook1'].remove_page(1)
     self.wids['label1'].set_text("Por cliente")
     labpdte = gtk.Label("Total pendiente:")
     labpdte.show()
     self.wids['hbox4'] = gtk.HBox()
     self.wids['hbox4'].add(labpdte)
     self.wids['e_totpdte'] = gtk.Entry()
     self.wids['e_totpdte'].set_property("editable", False)
     self.wids['e_totpdte'].set_property("has-frame", False)
     self.wids['hbox4'].add(self.wids['e_totpdte'])
     self.wids['hbox4'].show_all()
     self.wids['vbox2'].add(self.wids['hbox4'])
     self.wids['vbox2'].reorder_child(self.wids['hbox4'], 2)
     self.wids['e_totpdte'].show()
     gtk.main()
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     global fin
     Ventana.__init__(self, 'consulta_pendientes_vto_bueno.glade', objeto, 
                      usuario = self.usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_pendientes/clicked': self.buscar,
                    'b_todas/clicked': self.buscar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin}
     self.add_connections(connections)
     utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) 
                          for c 
                          in pclases.Proveedor.select(orderBy='nombre')])
     cols = (('Factura', 'gobject.TYPE_STRING', False, True, True, None),
             ('Código vto. bueno', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
             ('Importe', 'gobject.TYPE_STRING', False, False, False, None),
             ('Fecha fra.', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Fecha recepción', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Automático', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('Usuario', 'gobject.TYPE_BOOLEAN', False, True, False, None),
             ('Técnico', 'gobject.TYPE_BOOLEAN', False, True, False, None),
             ('Comercial', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('D. General', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('id', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
     self.colorear(self.wids['tv_datos'])
     temp = time.localtime()
     self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
     self.inicio = self.fin - datetime.timedelta(days = 4 * 7)
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     sens = (self.usuario == None 
             or self.usuario.firmaUsuario 
             or self.usuario.firmaComercial 
             # or self.usuario.firmaTecnico 
             or self.usuario.firmaDirector 
             or self.usuario.firmaTotal)
     self.wids['b_pendientes'].set_sensitive(sens)
     self.wids['b_pendientes'].child.child.get_children()[1].set_text("Ver pendientes de mi firma (%s)" % (self.usuario and self.usuario.usuario or "cualquiera"))
     gtk.main()
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     self.wids['ventana'].resize(800, 600)
     self.ffped = self.fppro = self.gpped = self.gppro = None
     cols = (('Pedido', 'gobject.TYPE_STRING', False, True, True, None), 
             ('Fecha', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Cliente', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Producto', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Pendiente', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Existencias totales', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Fecha entrega', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Texto entrega', 'gobject.TYPE_STRING', False, True, False, None), 
             ('IDPedido', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_fibra_por_pedido'], cols)
     utils.preparar_listview(self.wids['tv_gtx_por_pedido'], cols)
     utils.preparar_listview(self.wids['tv_otros_por_pedido'], cols)
     self.wids['tv_fibra_por_pedido'].connect("row-activated", self.abrir_pedido)
     self.wids['tv_gtx_por_pedido'].connect("row-activated", self.abrir_pedido)
     self.wids['tv_otros_por_pedido'].connect("row-activated", self.abrir_pedido)
     cols = (('Producto', 'gobject.TYPE_STRING', False, True, True, None), 
             ('Pendiente', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Existencias totales', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Bultos totales', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Existencias clase A', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Bultos clase A', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Existencias clase B', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Bultos clase B', 'gobject.TYPE_STRING', False, True, False, None), 
             ('IDPedido', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_fibra_por_producto'], cols)
     utils.preparar_listview(self.wids['tv_gtx_por_producto'], cols)
     utils.preparar_listview(self.wids['tv_otros_por_producto'], cols)
     self.colorear(self.wids['tv_fibra_por_producto'])
     self.colorear(self.wids['tv_gtx_por_producto'])
     self.colorear(self.wids['tv_otros_por_producto'])
     self.colorear(self.wids['tv_fibra_por_pedido'])
     self.colorear(self.wids['tv_gtx_por_pedido'])
     self.colorear(self.wids['tv_otros_por_pedido'])
     utils.rellenar_lista(self.wids['cbe_cliente'], [(0, "Todos los clientes")] + [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy="nombre")])
     def iter_cliente_seleccionado(completion, model, iter):
         idcliente = model[iter][0]
         utils.combo_set_from_db(self.wids['cbe_cliente'], idcliente)
     self.wids['cbe_cliente'].child.get_completion().connect('match-selected', iter_cliente_seleccionado)
     self.wids['cbe_cliente'].grab_focus()
     if pclases.ProductoVenta.select().count() > 0:
         self.wids['notebook1'].set_current_page(1)
     else:
         self.wids['notebook1'].remove_page(1)
         self.wids['notebook1'].remove_page(0)
         self.wids['notebook1'].set_current_page(-1)
Esempio n. 13
0
def build_widget_valor(col):
    """
    Recibe un objeto de la familia SOCol y devuelve el 
    widget adecuado para mostrar su valor.
    Si es un texto, entero o float: entry.
    Si es un boolean: checkbutton.
    Si es una fecha: entry con un botón para mostrar el calendario.
    Si es un ForeignKey, usar un ComboBoxEntry con utils.rellenar... con las
    tuplas de la tabla referenciada.
    """
    box = None  # Posible contenedor externo.
    if isinstance(col, pclases.SOStringCol): 
        w = gtk.Entry()
        w.set_name(col.name)
    elif isinstance(col, pclases.SOIntCol):
        w = gtk.Entry()
        w.set_name(col.name)
    elif isinstance(col, pclases.SOFloatCol):
        w = gtk.Entry()
        w.set_name(col.name)
    elif isinstance(col, pclases.SOBoolCol):
        w = gtk.CheckButton()
        w.set_name(col.name)
    elif isinstance(col, pclases.SODateCol):
        box = gtk.HBox()
        w = gtk.Entry()
        w.set_name(col.name)
        button = gtk.Button(label = "Buscar _fecha")
        button.connect("clicked", lambda boton: w.set_text(utils.str_fecha(utils.mostrar_calendario())))
        button.set_name("b_%s" % (col.name))
        box.add(w)
        box.add(button)
    elif isinstance(col, pclases.SOForeignKey):
        w = gtk.ComboBoxEntry()
        w.set_name(col.name)
        tablajena = col.foreignKey
        clase_tablajena = getattr(pclases, tablajena)
        func_select = getattr(clase_tablajena, "select")
        datos = []
        for reg in func_select():
            campos = []
            for columna in clase_tablajena._SO_columnDict:
                valor = getattr(reg, columna)
                campos.append(`valor`)
            info = ", ".join(campos)
            # info = reg.get_info()
            datos.append((reg.id, info))
        utils.rellenar_lista(w, datos)
    else:
        w = gtk.Entry()
        w.set_name(col.name)
    return w, box
Esempio n. 14
0
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_compras.glade', objeto, usuario = usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_fecha,
                    'b_fecha_fin/clicked': self.set_fecha, 
                    'cbe_proveedor/changed': lambda *args, **kw: self.wids['tv_datos'].get_model().clear(), 
                    "b_exportar/clicked": self.exportar}
     self.add_connections(connections)
     cols = (('Fecha','gobject.TYPE_STRING',False,True,False,None),
             ('Albarán','gobject.TYPE_STRING',False,True,False,None),
             ('Código', 'gobject.TYPE_STRING', False, True, False, None),
             ('Descripción', 'gobject.TYPE_STRING', False, True, False, None),
             ('Cantidad', 'gobject.TYPE_STRING', False, True, False, None),
             ('Precio', 'gobject.TYPE_STRING', False, True, False, None),
             ('IVA', 'gobject.TYPE_STRING', False, True, False, None),
             ('Descuento', 'gobject.TYPE_STRING', False, True, False, None),
             ('Subtotal s/IVA', 'gobject.TYPE_STRING', False, True, False, None),
             ('Subtotal c/IVA', 'gobject.TYPE_STRING', False, True, False, None),
             ('Pedido', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Factura', 'gobject.TYPE_STRING', False, True, False, None), 
             ('IDLDC','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].get_column(4).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(5).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(6).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(7).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(8).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(9).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_datos'].get_column(10).get_cell_renderers()[0].set_property('xalign', 0.5)
     self.wids['tv_datos'].get_column(11).get_cell_renderers()[0].set_property('xalign', 0.5)
     cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, True, False), 
             ('Cantidad', 'gobject.TYPE_STRING', False, True, False, None), 
             ('Total sin IVA','gobject.TYPE_STRING',False,True,False,False),
             ('ID', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_proveedor'], cols)
     self.wids['tv_proveedor'].get_column(1).get_cell_renderers()[0].set_property('xalign', 1.0)
     self.wids['tv_proveedor'].get_column(2).get_cell_renderers()[0].set_property('xalign', 1.0)
     utils.rellenar_lista(self.wids['cbe_proveedor'], [(-1, "Todos los proveedores")] + [(p.id, p.nombre) 
         for p in pclases.Proveedor.select(pclases.Proveedor.q.inhabilitado == False, orderBy = "nombre")])
     self.fin = datetime.date.today()
     self.inicio = datetime.date(day = 1, month = self.fin.month, year = self.fin.year)
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     gtk.main()
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_totales_geotextiles.glade', objeto, usuario = usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar
                   }
     self.add_connections(connections)
     cols = (('Mes', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Producción: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Producción: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Producción: kg', 'gobject.TYPE_STRING', False, False, False, None),
             ('Existencias: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Existencias: m²', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Existencias: kg', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: total: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: total: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: total: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Salidas: C. nac.: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: C. nac.: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: C. nac.: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Salidas: C. int.: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: C. int.: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: C. int.: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Salidas: G.: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: G.: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: G.: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Salidas: Otros: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: Otros: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Salidas: Otros: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('Peds. pendientes: rollos', 'gobject.TYPE_STRING', False, False, False, None),
             ('Peds. pendientes: m²', 'gobject.TYPE_STRING', False, False, False, None),
             ('Peds. pendientes: kg', 'gobject.TYPE_STRING', False, False, False, None), 
             ('mes', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     for numcol in xrange(1, 25):
         col = self.wids['tv_datos'].get_column(numcol)
         for cell in col.get_cell_renderers():
             cell.set_property('xalign', 1.0)
     anno_ini, anno_fin = buscar_annos_ini_fin()
     opciones = [(anno, anno) for anno in xrange(anno_ini, anno_fin + 1)]
     utils.rellenar_lista(self.wids['cbe_year'], opciones)
     utils.combo_set_from_db(self.wids['cbe_year'], -1)
     gtk.main()
Esempio n. 16
0
 def _construir_model_a(self, widget, col):
     """
     Averigua la fuente del widget según el nombre de la columna 
     recibida y asocia un model sencillo al widget, que debe ser 
     un ComboBox[Entry].
     """
     import pclases
     nomclase = col.name.replace("ID", "")
     nomclase = nomclase[0].upper() + nomclase[1:]
     clase = getattr(pclases, nomclase)
     primera_col = clase.sqlmeta.columnList[0].name
     filas = [(r.id, getattr(r, primera_col))
              for r in clase.select(orderBy = primera_col)]
     rellenar_lista(widget, filas)
Esempio n. 17
0
 def inicializar_ventana(self, objeto = None):
     """
     Inicializa los widgets de la ventana.
     """
     pixbuf_logo = gtk.gdk.pixbuf_new_from_file(
         pathjoin("..", "imagenes", "logo_up.gif"))
     pixbuf_logo = escalar_a(200, 100, pixbuf_logo)
     self.wids['logo'].set_from_pixbuf(pixbuf_logo)
     cols = (('Grupo', 'gobject.TYPE_STRING', False, True, True, None),
             ('Asistencia','gobject.TYPE_BOOLEAN', True, False, True, 
                 self.actualizar_asistencia),
             ('id', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_asistencias'], cols)
     self.wids['tv_asistencias'].set_headers_visible(False)
     self.wids['tv_asistencias'].connect("row-activated", self.abrir_grupo)
     cats = pclases.CategoriaLaboral.selectBy(daClases = True)
     empleados = []
     for c in cats:
         for e in c.empleados:
             if e not in empleados: empleados.append(e)
     empleados.sort(key = lambda e: e.apellidos)
     opciones = ([(0, "Todos")] + 
                 [(e.id, e.get_nombre_completo()) for e in empleados])
     utils.rellenar_lista(self.wids['cb_empleadoID'], opciones)
     self.grafica = charting.add_grafica_rangos(self.wids['vbox2'], [], [])
     if self.lista_empleados and self.lista_empleados[0] != None:
         if len(self.lista_empleados) == 1:
             utils.combo_set_from_db(self.wids['cb_empleadoID'], 
                                     self.lista_empleados[0].id)
         else:
             utils.combo_set_from_db(self.wids['cb_empleadoID'], 0)
     else:
         utils.combo_set_from_db(self.wids['cb_empleadoID'], None)
     if not self.fecha:
         hoy = datetime.datetime.today()
         mes = hoy.month - 1 # gtk.Calendar empieza por 0
         anno = hoy.year
         dia = hoy.day
         self.wids['calendario'].select_month(mes, anno)
         self.wids['calendario'].select_day(dia)
     else:
         self.wids['calendario'].select_month(self.fecha.month - 1, 
                                              self.fecha.year)
         self.wids['calendario'].select_day(self.fecha.day)
     self.wids['ventana'].resize(
         int(self.wids['ventana'].get_size()[0]*2), 
         self.wids['ventana'].get_size()[1]*2)
Esempio n. 18
0
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     # Inicialmente no se muestra NADA. Sólo se le deja al
     # usuario la opción de buscar o crear nuevo.
     self.activar_widgets(False)
     self.wids['b_actualizar'].set_sensitive(False)
     self.wids['b_guardar'].set_sensitive(False)
     self.wids['b_nuevo'].set_sensitive(True)
     self.wids['b_buscar'].set_sensitive(True)
     cols = (('Factura', 'gobject.TYPE_STRING', False, True, True, None),
             ('Importe', 'gobject.TYPE_STRING', True, True, False, self.cambiar_importe_cobro),
             ('Fecha vencimiento', 'gobject.TYPE_STRING', False, True, False, None),
             ('Importe total de la factura', 'gobject.TYPE_STRING', False, True, False, None),
             ('Vencimientos', 'gobject.TYPE_STRING', False, True, False, None), 
             ('ID', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_cobros'], cols)
     self.colorear_cobros(self.wids['tv_cobros'])
     self.wids['tv_cobros'].connect("row-activated", self.abrir_factura)
     utils.rellenar_lista(self.wids['cbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy="nombre")])
     utils.combo_set_from_db(self.wids['cbe_cliente'], -1)   # Esto quitará el elemento activo del combo.
     self.wids['cbe_cliente'].child.set_text("")
     def iter_cliente_seleccionado(completion, model, iter = None):
         if iter == None:    # Si me ha llamado el changed, el iter habrá cambiado JUSTO AHORA.
             try:
                 iter = completion.get_active_iter()
             except AttributeError:
                 iter = None
         if iter != None:
             idcliente = model[iter][0]
             utils.combo_set_from_db(self.wids['cbe_cliente'], idcliente)
             for p in [p for p in self.objeto.cobros if p.cliente == None]:
                 p.clienteID = idcliente
         self.wids['cbe_cliente'].set_sensitive(
             len([c for c in self.objeto.cobros if c.cliente != None])==0)
     self.wids['cbe_cliente'].child.get_completion().connect(
         'match-selected', iter_cliente_seleccionado)
     self.wids['cbe_cliente'].connect('changed', 
                             iter_cliente_seleccionado, 
                             self.wids['cbe_cliente'].get_model(), 
                             self.wids['cbe_cliente'].get_active_iter())
     self.wids['b_add_abono'].set_property("visible", False)
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     global fin
     Ventana.__init__(self, 'consulta_vencimientos_cobro.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     utils.rellenar_lista(self.wids['cmbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy='nombre')])
     cols = (('Factura','gobject.TYPE_STRING',False,True, False,None),
             ('Fecha vto.','gobject.TYPE_STRING',False,True,False,None),
             ('Importe','gobject.TYPE_STRING',False,False,False,None),
             ('Observaciones/Forma de cobro','gobject.TYPE_STRING',False,True, False,None),
             ('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
             ('id','gobject.TYPE_STRING',False,False,False,None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
     self.colorear(self.wids['tv_datos'])
     col = self.wids['tv_datos'].get_column(2)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     self.wids['tv_datos'].connect('button_press_event', self.button_clicked)
     self.wids['tv_datos'].set_hover_selection(True)
     cols = (('Año y mes','gobject.TYPE_STRING', False,True, True, None),
             ('Total','gobject.TYPE_STRING', False, True, False, None),
             ('nada','gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_totales'], cols)
     col = self.wids['tv_totales'].get_column(1)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     temp = time.localtime()
     self.fin = mx.DateTime.DateTimeFrom(day = temp[2], month = temp[1], year = temp[0])
     self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
     self.inicio = mx.DateTime.DateTimeFrom(day = 1, month = mx.DateTime.localtime().month, year = mx.DateTime.localtime().year)
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     gtk.main()
Esempio n. 20
0
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     # Inicialmente no se muestra NADA. Sólo se le deja al
     # usuario la opción de buscar o crear nuevo.
     self.activar_widgets(False)
     self.wids['b_actualizar'].set_sensitive(False)
     self.wids['b_guardar'].set_sensitive(False)
     self.wids['b_nuevo'].set_sensitive(True)
     self.wids['b_buscar'].set_sensitive(True)
     # Inicialización del resto de widgets:
     utils.rellenar_lista(self.wids['cb_material'],[(t.id, t.descripcion) for t in pclases.TipoMaterialBala.select()])
     cols = (('Tarifa', 'gobject.TYPE_STRING', False, True, True, None),
             ('Precio', 'gobject.TYPE_FLOAT', False, True, False, None),
             ('ID', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_tarifas'], cols)
Esempio n. 21
0
 def inicializar_ventana(self, objeto = None):
     """
     Inicializa los widgets de la ventana.
     """
     cols = (('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
             ('Importe','gobject.TYPE_STRING', False, False, True, None), 
             ('PUID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_datos'], cols, multi = True)
     self.wids['tv_datos'].connect("row-activated", self.abrir_cliente)
     clientes = pclases.Cliente.select(
         pclases.Cliente.q.inhabilitado == False, 
         orderBy = "nombre")
     opciones = [(c.id, c.nombre) for c in clientes]
     utils.rellenar_lista(self.wids['cbe_cliente'], opciones)
     col = self.wids['tv_datos'].get_column(1)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     self.wids['b_imprimir'].set_property("visible", False)
     self.wids['b_exportar'].set_property("visible", False)
Esempio n. 22
0
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     # Inicialmente no se muestra NADA. Sólo se le deja al
     # usuario la opción de buscar o crear nuevo.
     self.activar_widgets(False)
     self.wids['b_actualizar'].set_sensitive(False)
     self.wids['b_guardar'].set_sensitive(False)
     self.wids['b_nuevo'].set_sensitive(True)
     self.wids['b_buscar'].set_sensitive(True)
     self.wids['ventana'].set_title(self.clase.sqlmeta.table.upper())
     # Inicialización del resto de widgets:
     cols = (('Nombre', 'gobject.TYPE_STRING', False, True, True, None),
             ('PUID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_clientes'], cols, multi = True)
     cols = (('Nombre', 'gobject.TYPE_STRING', False, True, True, None),
             ('PUID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_espera'], cols, multi = True)
     self.wids['tv_espera'].connect("cursor-changed", 
         self.quitar_seleccion, 'tv_clientes')
     self.wids['tv_espera'].connect("row-activated", self.abrir_cliente)
     self.wids['tv_clientes'].connect("cursor-changed", 
         self.quitar_seleccion, 'tv_espera')
     self.wids['tv_clientes'].connect("row-activated", self.abrir_cliente)
     cols = (('Descripción', 'gobject.TYPE_STRING', True, True, True, 
                 self.cambiar_descripcion_actividad),
             ('Evento', 'gobject.TYPE_STRING', False, True, False, None),
                 # TODO: ¿Cambiar por combo?
             ('Inicio', 'gobject.TYPE_STRING', True, True, False, 
                 self.cambiar_inicio_actividad),
             ('Fin', 'gobject.TYPE_STRING', True, True, False, 
                 self.cambiar_fin_actividad),
             ('PUID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_actividades'], cols, multi=True)
     self.wids['b_color'].set_use_alpha(False)
     utils.rellenar_lista(self.wids['cbe_empleadoID'], 
                          [(e.id, e.get_nombre_completo()) 
                           for e in pclases.Empleado.select(
                                             orderBy = "apellidos")]
                         )
Esempio n. 23
0
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     # Inicialmente no se muestra NADA. Sólo se le deja al
     # usuario la opción de buscar o crear nuevo.
     self.activar_widgets(False)
     self.wids['b_actualizar'].set_sensitive(False)
     self.wids['b_guardar'].set_sensitive(False)
     self.wids['b_nuevo'].set_sensitive(True)
     self.wids['b_buscar'].set_sensitive(True)
     provs = pclases.Proveedor.select(orderBy = 'nombre')
     lista_provs = [(p.id, p.nombre) for p in provs if not p.inhabilitado]
     utils.rellenar_lista(self.wids['cmbe_proveedor'], lista_provs)
     lista_alms = [(a.id, a.nombre) 
                   for a in pclases.Almacen.select(orderBy = "id")]
     utils.rellenar_lista(self.wids['cbe_almacenID'], lista_alms)
     # Inicialización del resto de widgets:
     cols = (('Código', 'gobject.TYPE_STRING', False, True, False, None),
             ('Descripción', 'gobject.TYPE_STRING', False,True,False,None),
             ('Cantidad recibida', 'gobject.TYPE_STRING', 
                 True, True, False, self.cambiar_cantidad),
             ('Precio s/IVA', 'gobject.TYPE_STRING', 
                 True, True, False, self.cambiar_precio),
             ('IVA', 'gobject.TYPE_STRING', 
                 True, True, False, self.cambiar_iva), 
             ('Descuento', 'gobject.TYPE_STRING', 
                 True, True, False, self.cambiar_descuento_ldc), 
             ('Total línea', 'gobject.TYPE_STRING', False,True,False,None),
             #('Silo', 'gobject.TYPE_STRING', False, True, False, None), 
             ('pedido en', 'gobject.TYPE_STRING', False, True, False, None), 
             ('con fecha', 'gobject.TYPE_STRING', False, True, False, None), 
             ('IDProducto', 'gobject.TYPE_INT64', False, False, False, None)
            )
     utils.preparar_listview(self.wids['tv_ldvs'], cols)
     for n in (2, 3, 4, 5, 6):
         for cell in self.wids['tv_ldvs'].get_column(n).get_cell_renderers():
             cell.set_property('xalign', 1.0)
     for n in (7, ):
         for cell in self.wids['tv_ldvs'].get_column(n).get_cell_renderers():
             cell.set_property('xalign', 0.5)
Esempio n. 24
0
 def rellenar_widgets(self):
     """
     Introduce la información del cuenta actual
     en los widgets.
     No se chequea que sea != None, así que
     hay que tener cuidado de no llamar a 
     esta función en ese caso.
     """
     if self.objeto.facturaCompra and self.objeto.facturaCompra.proveedor != self.objeto.proveedor: # Cuando hay que recurrir a estas cosas, es que el diseño no es bueno.
         self.objeto.facturaCompra = None
     if self.objeto.proveedorID != None:     # Meto en las cuentas sólo las del proveedor de la transferencia.
         utils.rellenar_lista(self.wids['cbe_destino'], 
                              [(p.id, p.nombre + " " + p.cuenta) for p in pclases.CuentaDestino.select(pclases.CuentaDestino.q.proveedorID == self.objeto.proveedor.id, orderBy = "nombre")])
     else:
         utils.rellenar_lista(self.wids['cbe_destino'], [(p.id, p.nombre + " " + p.cuenta) for p in pclases.CuentaDestino.select(orderBy = "nombre")])
     for nombre_col in self.dic_campos:
         self.escribir_valor(self.objeto._SO_columnDict[nombre_col], getattr(self.objeto, nombre_col), self.dic_campos[nombre_col])
     self.wids['e_factura'].set_text(self.objeto.concepto)
     self.objeto.make_swap()
Esempio n. 25
0
 def __init__(self, objeto = None, usuario = None):
     self.usuario = usuario
     Ventana.__init__(self, 'balas_cable.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_aplicar/clicked': self.actualizar_tabla, 
                    'b_add/clicked': self.crear_bala, 
                    'b_drop/clicked': self.drop_or_print, 
                    'b_etiqueta/clicked': self.drop_or_print, 
                    'b_mes/clicked': self.cambiar_mes_acumulado
                    }
     self.add_connections(connections)
     productos_cable = []
     for ceb in pclases.CamposEspecificosBala.select(pclases.CamposEspecificosBala.q.reciclada == True):
         productos_cable.append((ceb.productosVenta[0].id, ceb.productosVenta[0].descripcion))
     productos_cable.sort(lambda p1, p2: (p1[-1] < p2[-1] and -1) or (p1[-1] > p2[-1] and 1) or 0)
     utils.rellenar_lista(self.wids['cbe_producto'], productos_cable)
     self.wids['sp_ver'].set_value(15)
     self.preparar_tv(self.wids['tv_balas'])
     self.actualizar_tabla()
     gtk.main()
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_existencias_por_almacen.glade', 
                      objeto)
     while self.wids['notebook'].get_n_pages() > 1:
         self.wids['notebook'].remove_page(-1)
     self.wids['notebook'].set_tab_label_text(self.wids["scrolledwindow1"], 
                                              "Por producto")
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     cols = [('Código', 'gobject.TYPE_STRING', False, True, False, None),
             ('Producto', 'gobject.TYPE_STRING', False, True, True, None),
             ("Total", "gobject.TYPE_STRING", False, True, False, None), 
             ('PUID', 'gobject.TYPE_STRING', False, False, False, None)]
     for a in pclases.Almacen.select(orderBy = "-id"):
         # Por cada almacén una columna en el treeview 
         cols.insert(2, (a.nombre, "gobject.TYPE_STRING", 
                         False, True, False, None))
         # ...y una hoja más en el notebook
         self.add_hoja_notebook(a)
     utils.preparar_listview(self.wids['tv_por_producto'], cols)
     self.wids['tv_por_producto'].connect("row-activated", 
                                          self.abrir_producto)
     for numcol in range(2, len(cols)-1):
         self.wids['tv_por_producto'].get_column(numcol).get_cell_renderers()[0].set_property('xalign', 1) 
     self.wids['ventana'].maximize()
     tipos = [(tdm.id, tdm.descripcion) for tdm in pclases.TipoDeMaterial.select(orderBy = "descripcion")]
     tipos.insert(0, (0, "Todos los productos"))
     tipos.insert(1, (-1, "Todos los productos de venta"))
     tipos.insert(2, (-2, "Todos los productos de compra"))
     utils.rellenar_lista(self.wids['cbe_tipo'], tipos)
     utils.combo_set_from_db(self.wids['cbe_tipo'], 0)
     gtk.main()
Esempio n. 27
0
 def build_child(self, nombrecampo, tipocampo):
     """
     Construye el widget correspondiente al tipo de campo recibido y 
     establece su valor por defecto.
     """
     res = gtk.Label('ERROR: N/A')
     if isinstance(tipocampo, sqlobject.SOStringCol):  # Cadena: el widget es un entry
         res = gtk.Entry()
         if tipocampo.default != None and tipocampo.default != sqlobject.sqlbuilder.NoDefault:
             res.set_text("%s" % (tipocampo.default))
     elif isinstance(tipocampo, sqlobject.SOIntCol):   # Entero: el widget es un entry
         res = gtk.Entry()
         if tipocampo.default != None and tipocampo.default != sqlobject.sqlbuilder.NoDefault:
             res.set_text("%s" % (tipocampo.default))
     elif isinstance(tipocampo, sqlobject.SOBoolCol):  # Boolean: el widget es un checkbox
         label = self.build_label(nombrecampo)
         res = gtk.CheckButton(label = label.get_text())
         if tipocampo.default:
             res.set_active(True)
     elif isinstance(tipocampo, sqlobject.SOForeignKey):  # Entero-clave ajena: el widget es un comboboxentry
         res = gtk.ComboBoxEntry()
         ajena = tipocampo.foreignKey
         clase = getattr(pclases, ajena)
         COLUMNATEXTO = 'nombre'     # XXX: Cambiar si no tiene una columna "nombre"
         try:
             contenido = [(r.id, r._SO_getValue(COLUMNATEXTO)) for r in clase.select(orderBy='id')]
         except KeyError:
             COLUMNATEXTO = 'puesto'     # XXX: Cambiar si no tiene una columna "puesto"
             contenido = [(r.id, r._SO_getValue(COLUMNATEXTO)) for r in clase.select(orderBy='id')]
         utils.rellenar_lista(res, contenido)
     elif isinstance(tipocampo, sqlobject.SOCol):      # Clase base, casi seguro Float: el widget es un entry
         res = gtk.Entry()
         if tipocampo.default != None and tipocampo.default != sqlobject.sqlbuilder.NoDefault:
             res.set_text(utils.float2str("%s" % tipocampo.default))
     else:
         txt = "categorias_laborales.py: No se pudo construir el widget para %s." % nombrecampo
         print txt
         self.logger.error(txt)
     res.set_name(nombrecampo)
     self.wids[nombrecampo] = res
     return res
Esempio n. 28
0
 def rellenar_widgets(self):
     """
     Introduce la información de el presupuesto actual
     en los widgets.
     No se chequea que sea != None, así que
     hay que tener cuidado de no llamar a 
     esta función en ese caso.
     """
     utils.rellenar_lista(self.wids['cbe_cliente'], 
         [(p.id, p.nombre) for p in 
         pclases.Cliente.select(orderBy = "nombre") if not p.inhabilitado]) 
         # Lo pongo aquí por si crea un cliente nuevo sin cerrar esta 
         # ventana y lo quiere usar.
     comerciales = []
     if self.usuario and self.usuario.empleados:
         for e in self.usuario.empleados:
             for c in e.comerciales:
                 comerciales.append(c)
     if not comerciales or (self.usuario and self.usuario.nivel <= 2):
         comerciales = pclases.Comercial.select() 
     if self.objeto.comercial and self.objeto.comercial not in comerciales:
         comerciales.append(self.objeto.comercial)
     utils.rellenar_lista(self.wids['cbe_comercial'], 
         [(c.id, c.empleado and c.empleado.get_nombre_completo() 
             or "ERR_INC_BD") 
           for c in comerciales] + [(-1, "Sin comercial relacionado")]) 
     presupuesto = self.objeto
     for nombre_col in self.dic_campos:
         if nombre_col == "comercialID" and not presupuesto.comercial:
             self.wids['cbe_comercial'].child.set_text(
                 "Sin comercial relacionado")
             self.wids['cbe_comercial'].set_active(-1)
         else:
             self.escribir_valor(presupuesto._SO_columnDict[nombre_col], 
                                 getattr(presupuesto, nombre_col), 
                                 self.dic_campos[nombre_col])
     # El descuento global aparte, que lleva porcentaje
     self.wids['e_descuento'].set_text("%s %%" 
         % utils.float2str(self.objeto.descuento*100, autodec = True))
     self.rellenar_tablas()
     self.objeto.make_swap()
Esempio n. 29
0
 def _crear_widget(self, tipo, col, nombre = None):
     """
     Crea y devuelve un widget del tipo recibido y con 
     el nombre de la columna recibido.
     """
     if not nombre:
         nombre = col.name
     w = tipo()
     w.set_property("name", nombre)
     if (isinstance(w, self.TUPLACOMBO) 
        and isinstance(col, sqlobject.SOForeignKey)):
         import pclases
         tablajena = getattr(pclases, col.foreignKey)
         texto = tablajena.sqlmeta.columnList[0]
         ops = []
         for i in tablajena.select(orderBy = texto.name):
             id = i.id
             txt = getattr(i, texto.name)
             ops.append((id, txt))
         rellenar_lista(w, ops)
     return w
Esempio n. 30
0
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     global fin
     Ventana.__init__(self, 'consulta_bajoMinimos.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_crear_pedido/clicked': self.crear_pedido, 
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     cols = (('Código','gobject.TYPE_STRING', False, True, False, None),
             ('Descripción','gobject.TYPE_STRING', False, True, False, None),
             ('Mínimo','gobject.TYPE_FLOAT', False, True, False, None),
             ('Stock','gobject.TYPE_FLOAT', False, True, False, None),
             ('Unidad','gobject.TYPE_STRING', False, True, False, None),
             ('Proveedores habituales', 'gobject.TYPE_STRING', False, True, False, None),
             ('idproducto','gobject.TYPE_INT64',False,False,False,None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].get_selection().set_mode(gtk.SELECTION_MULTIPLE)
     i = 0
     for col in self.wids['tv_datos'].get_columns():
         cells = col.get_cell_renderers()
         for cell in cells:
             col.set_attributes(cell, markup = i)
         i += 1
     #if pclases.ProductoVenta.select().count() == 0:
     #    self.wids['r_venta'].set_sensitive(False)
     self.wids['r_venta'].set_property("visible", False)
     proveedores = pclases.Proveedor.select(
                             pclases.Proveedor.q.inhabilitado == False, 
                             orderBy = "nombre")
     proveedores = [(p.id, p.nombre) for p in proveedores]
     proveedores.insert(0, (0, "Todos los proveedores"))
     utils.rellenar_lista(self.wids['cbe_proveedor'], proveedores)
     gtk.main()