def __init__(self, objeto = None, usuario = None, fini = None, ffin = 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, 'facturacion_por_cliente_y_fechas.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_imprimir/clicked': self.imprimir, 
                    'cbe_cliente/changed': self.cambiar_cliente, 
                    'b_fechaini/clicked': self.cambiar_fechaini, 
                    'b_fechafin/clicked': self.cambiar_fechafin, 
                    'b_export/clicked': self.exportar_a_csv, }
                    #'tv_facturas/row-expanded': self.expandir_subramas}  
     self.add_connections(connections)
     self.wids['tv_facturas'].connect("row-expanded", 
                                      self.expandir_subramas)
     self.inicializar_ventana()
     if fini:
         self.wids['e_fechaini'].set_text(utils.str_fecha(fini))
     if ffin:
         self.wids['e_fechafin'].set_text(utils.str_fecha(ffin))
     if objeto != None:
         utils.combo_set_from_db(self.wids['cbe_cliente'], objeto.id)
     gtk.main()
Esempio n. 2
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, 'up_facturar.glade', objeto)
     self.objeto = objeto
     self.usuario = usuario
     connections = {'b_salir/clicked': self.salir,
                    'b_imprimir/clicked': self.imprimir,
                    'b_buscar/clicked': self.rellenar_widgets, 
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_facturar/clicked': self.facturar_seleccionado, 
                    'b_facturar_todo/clicked': self.facturar_todo, 
                    'b_clear_fechainicio/clicked': self.limpiar_fecha, 
                    'b_clear_fechafin/clicked': self.limpiar_fecha, 
                   }
     self.add_connections(connections)
     self.inicializar_ventana()
     if self.objeto:
         utils.combo_set_from_db(self.wids['cbe_cliente'], objeto.id)
         self.rellenar_widgets()
     else:
         utils.combo_set_from_db(self.wids['cbe_cliente'], None)
     self.wids['e_fechainicio'].set_text(
         utils.str_fecha(utils.primero_de_mes()))
     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. 4
0
 def crear_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í.
     """
     pagare = self.objeto
     if pagare != None:
         pagare.notificador.set_func(lambda : None)
     self.objeto = pclases.PagareCobro(fechaCobro = datetime.date.today(), 
                                 cantidad = 0, 
                                 cobrado = -1, 
                                 fechaRecepcion = datetime.date.today(), 
                                 fechaCobrado = None, 
                                 procesado = False)
     pagare = self.objeto
     pagare.notificador.set_func(self.aviso_actualizacion)
     utils.dialogo_info(titulo = 'PAGARÉ CREADO', 
                        texto = 'No olvide relacionar las facturas que cubre el efecto.', 
                        padre = self.wids['ventana'])
     utils.combo_set_from_db(self.wids['cbe_cliente'], -1)   # Esto quitará el elemento activo del combo.
     self.wids['cbe_cliente'].child.set_text("")
     self.actualizar_ventana()
Esempio n. 5
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. 6
0
 def rellenar_cobros(self):
     model = self.wids['tv_cobros'].get_model()
     model.clear()
     if self.objeto.cobros != []:
         utils.combo_set_from_db(self.wids['cbe_cliente'], 
                                 self.objeto.cobros[0].cliente.id)
     for c in self.objeto.cobros:
         if c.facturaVentaID != None:
             importe_factura = c.facturaVenta.importeTotal
             vencimientos = "(%d) " % len(c.facturaVenta.vencimientosCobro)
             vencimientos += "; ".join(
                 ["%s: %s €" % (utils.str_fecha(v.fecha), 
                  utils.float2str(v.importe)) 
                  for v in c.facturaVenta.vencimientosCobro])
         elif c.prefacturaID != None:
             importe_factura = c.prefactura.importeTotal
             vencimientos = "(%d) " % (len(c.prefactura.vencimientosCobro))
             vencimientos += "; ".join(
                 ["%s: %s €" % (utils.str_fecha(v.fecha), 
                                utils.float2str(v.importe)) 
                  for v in c.prefactura.vencimientosCobro])
         model.append((c.numfactura, 
                       "%s €" % (utils.float2str(c.importe)), 
                       utils.str_fecha(c.fecha), 
                       "%s €" % (utils.float2str(importe_factura)),
                       vencimientos,  
                       c.id))
Esempio n. 7
0
    def set_valor(self, w, nombrecampo, tipocampo):
#        valor = self.objeto._SO_getValue(nombrecampo)
        get_valor = getattr(self.objeto, '_SO_get_%s' % (nombrecampo))
        valor = get_valor()
        if isinstance(tipocampo, sqlobject.SOStringCol):  # Cadena: el widget es un entry
            if valor != None:
                w.set_text(valor)
            else:
                w.set_text("")
        elif isinstance(tipocampo, sqlobject.SOIntCol):   # Entero: el widget es un entry
            try:
                w.set_text("%d" % valor)
            except TypeError:
                w.set_text("0")
        elif isinstance(tipocampo, sqlobject.SOBoolCol):  # Boolean: el widget es un checkbox
            w.set_active(valor)
        elif isinstance(tipocampo, sqlobject.SOForeignKey):  # Entero-clave ajena: el widget es un comboboxentry
            utils.combo_set_from_db(w, valor)
        elif isinstance(tipocampo, sqlobject.SOCol):      # Clase base, casi seguro Float: el widget es un entry
            if valor != None:
                try:
                    w.set_text(utils.float2str(valor))
                except ValueError:
                    w.set_text('0')
        else:
            txt = "categorias_laborales.py: No se pudo establecer el valor %s para %s." % (valor, w)
            print txt
            self.logger.error(txt)
Esempio n. 8
0
 def rellenar_widgets(self):
     """
     Introduce la información del albaran 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.
     """
     albaran = self.objeto
     self.wids['e_numalbaran'].set_text(albaran.numalbaran)
     self.wids['e_fecha'].set_text(utils.str_fecha(albaran.fecha))
     self.rellenar_tabla(self.wids['tv_ldvs'])
     if albaran.proveedorID == None:
         self.wids['cmbe_proveedor'].set_active(-1)
         self.wids['cmbe_proveedor'].child.set_text("")
     else:
         utils.combo_set_from_db(self.wids['cmbe_proveedor'], albaran.proveedorID)
     if albaran.almacenID == None:
         self.wids['cbe_almacenID'].set_active(-1)
         self.wids['cbe_almacenID'].child.set_text("")
     else:
         utils.combo_set_from_db(self.wids['cbe_almacenID'], albaran.almacenID)
     self.wids['e_facturas'].set_text(", ".join([f.numfactura for f in albaran.facturasCompra]))
     self.wids['e_pedidos'].set_text(", ".join([p.numpedido for p in albaran.pedidosCompra]))
     self.objeto.make_swap()
     self.wids['cbe_almacenID'].set_sensitive(not self.objeto.lineasDeCompra)
 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()
Esempio n. 10
0
def setter_combobox(objeto, col, w):
    """
    Muestra el valor del atributo "col" del objeto
    "objeto" en el entry hijo del combobox "w".
    """
    valor = getattr(objeto, col.name)
    # TODO: Comprobar qué tipo de SOCol es y convertir el valor si 
    #       es una fecha, un float, etc.
    combo_set_from_db(w, valor)
Esempio n. 11
0
 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)
Esempio n. 12
0
 def rellenar_widgets(self):
     """
     Introduce la información del producto 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.
     """
     producto = self.objeto
     if len(producto.articulos) > 0:
         self.wids['ch_reciclada'].set_sensitive(False)  
         # Una vez se ha fabricado algo no puedo dejar que cambie la fibra a reciclada y viceversa, puesto que entonces me
         # alteraría el cálculo de stock, la forma de dar de alta más balas, etiquetas etc...
     self.wids['i_barcode'].set_from_file(EanBarCode().getImage(producto.codigo))
     self.wids['e_codigo'].set_text(producto.codigo)
     self.wids['e_descripcion'].set_text(producto.descripcion)
     self.wids['e_nombre'].set_text(producto.nombre)
     self.wids['e_precio'].set_text(str(producto.preciopordefecto))
     self.wids['e_minimo'].set_text(str(producto.minimo))
     self.wids['e_arancel'].set_text(str(producto.arancel))
     self.wids['e_prodestandar'].set_text(utils.float2str(producto.prodestandar))
     campos = producto.camposEspecificosBala
     self.wids['ch_reciclada'].set_active(campos.reciclada)
     self.wids['e_dtex'].set_text(str(campos.dtex))
     self.wids['e_corte'].set_text(str(campos.corte))
     self.wids['e_color'].set_text(str(campos.color))
     self.wids['chk_antiuv'].set_active(campos.antiuv)
     utils.combo_set_from_db(self.wids['cb_material'], 
                             campos.tipoMaterialBalaID)
     # Campos para bolsas de fibra de cemento:
     if campos.gramosBolsa != None:
         self.wids['e_gramosBolsa'].set_text(str(campos.gramosBolsa))
     else:
         self.wids['e_gramosBolsa'].set_text("N/A")
     if campos.bolsasCaja != None:
         self.wids['e_bolsasCaja'].set_text(str(campos.bolsasCaja))
     else:
         self.wids['e_bolsasCaja'].set_text("N/A")
     if campos.cajasPale != None:
         self.wids['e_cajasPale'].set_text(str(campos.cajasPale))
     else:
         self.wids['e_cajasPale'].set_text("N/A")
     # Datos no modificables:
     self.wids['e_idproducto'].set_text(`producto.id`)
     self.muestra_stock()
     # self.wids['e_stock'].set_text('Pulsar botón "Contar stock"')
     self.mostrar_especificos()
     self.rellenar_tabla_tarifas()
     self.objeto.make_swap()
     self.wids['e_cajasPale'].set_sensitive(not self.objeto.articulos)
 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. 14
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
     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. 16
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)
     if self.lista_empleados and self.lista_empleados[0] != None:
         empleados = self.lista_empleados
     else:
         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 
         and 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)
     if not self.fecha:
         self.fecha = datetime.datetime.today()
     self.wids['e_fecha'].set_text(utils.str_fecha(self.fecha))
     self.wids['ventana'].resize(
         int(self.wids['ventana'].get_size()[0]*2), 
         self.wids['ventana'].get_size()[1]*2)
Esempio n. 17
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`)
         cuentas_cliente = pclases.CuentaBancariaCliente.select(
                 pclases.CuentaBancariaCliente.q.clienteID==self.cliente.id,
                 orderBy = "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 cuentas_cliente])
         if cuentas_cliente.count():
             utils.combo_set_from_db(
                 self.wids['cbe_cuenta_bancaria_cliente'], 
                 cuentas_cliente[-1].id)
             self.objeto.cuentaBancariaCliente = cuentas_cliente[-1]
             self.objeto.syncUpdate()
         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))
Esempio n. 18
0
def build_combo_dia_grupo(dia, idgrupo, funcion, turnos, turnoid):
    """
    Construye y devuelve un comboBoxEntry.
    Conecta la señal "changed" a 'funcion'.
    El nombre estará compuesto por el día y el id del grupo separados por «_».
    Los valores de la lista son los de los turnos definidos en la BD (que como
    mínimo deberían ser: Mañana, Tarde, Noche, Recuperación)
    [Los festivos se toman de FestivosGenericos, no se consideran turno].
    [Vacaciones y festivos adicionales se pueden marcar mediante dos checkboxes
    en el lateral derecho]
    'turnos' es una lista de tuplas (id, nombre) de los turnos ordenada por 
    hora de inicio.
    turnoid es el ID del turno que debe aparecer seleccionado o None si no 
    debe tener valor.
    """
    combo = gtk.ComboBoxEntry()
    combo.set_name("%d_%d" % (dia, idgrupo))
    utils.rellenar_lista(combo, turnos)
    combo.set_size_request(100, 19)
    utils.combo_set_from_db(combo, turnoid)
    combo.child.modify_base(gtk.STATE_NORMAL, combo.child.get_colormap().alloc_color(get_color_turno(turnoid)))
    combo.connect('changed', funcion)
    return combo
Esempio n. 19
0
 def rellenar_widgets(self):
     """
     Introduce la información del empleado 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.
     """
     empleado = self.objeto
     if empleado != None:
         self.wids["e_centro"].set_text(empleado.centroTrabajo and empleado.centroTrabajo.nombre or "")
         self.wids["e_dias_convenio"].set_text(
             empleado.categoriaLaboral and "%d" % (empleado.categoriaLaboral.diasConvenio) or ""
         )
         self.wids["e_dias_asuntos_propios"].set_text(
             empleado.categoriaLaboral and "%d" % (empleado.categoriaLaboral.diasAsuntosPropios) or ""
         )
         anno = self.wids["sp_anno"].get_value()
         diasConvenioRestantes = empleado.get_diasConvenioRestantes(anno)
         self.wids["e_dc_restantes"].set_text("%d" % diasConvenioRestantes)
         if diasConvenioRestantes > 0:
             self.wids["e_dc_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dc_restantes"].get_colormap().alloc_color("white")
             )
         elif diasConvenioRestantes == 0:
             self.wids["e_dc_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dc_restantes"].get_colormap().alloc_color("orange")
             )
         else:
             self.wids["e_dc_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dc_restantes"].get_colormap().alloc_color("red")
             )
         diasAsuntosPropiosRestantes = empleado.get_diasAsuntosPropiosRestantes(anno)
         self.wids["e_dap_restantes"].set_text("%d" % diasAsuntosPropiosRestantes)
         if diasAsuntosPropiosRestantes > 0:
             self.wids["e_dap_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dap_restantes"].get_colormap().alloc_color("white")
             )
         elif diasAsuntosPropiosRestantes == 0:
             self.wids["e_dap_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dap_restantes"].get_colormap().alloc_color("orange")
             )
         else:
             self.wids["e_dap_restantes"].modify_base(
                 gtk.STATE_NORMAL, self.wids["e_dap_restantes"].get_colormap().alloc_color("red")
             )
         self.rellenar_ausencias(empleado)
         self.rellenar_bajas(empleado)
         try:
             utils.combo_set_from_db(self.wids["cbe_empleado"], empleado.id)
             # No sé qué pasa con el model cuando se abre la ventana
             # en un objeto determinado pero casca diciendo que es
             # None. Lo ignoro y punto. En siguientes llamadas a
             # rellenar_widgets ya no peta.
         except:
             pass
         self.objeto = empleado
         self.objeto.make_swap()
     else:
         utils.combo_set_from_db(-1)
         self.wids["e_centro"].set_text("")
         self.wids["e_dias_convenio"].set_text("")
         self.wids["e_dias_asuntos_propios"].set_text("")
         self.wids["e_dc_restantes"].set_text("")
         self.wids["e_dap_restantes"].set_text("")
         self.rellenar_ausencias(empleado)
         self.rellenar_bajas(empleado)
Esempio n. 20
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, 'busca_partida.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_ayuda/clicked': self.ayuda}
     self.add_connections(connections)
     cols = (('Num. Partida', 'gobject.TYPE_INT64', 
                 False, True, False, None),
             ('Código', 'gobject.TYPE_STRING', False, True, False, None),
             ('Longitudinal', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Transversal', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Compresión', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Perforación', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Permeabilidad', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Poros', 'gobject.TYPE_STRING', False, True, False, None),
             ('Espesor', 'gobject.TYPE_STRING', False, True, False, None),
             ('Piramidal', 'gobject.TYPE_STRING', False, True, False, None),
             ('Idpartida', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_listview(self.wids['tv_resultado'], cols)
     combos = ('cmb_longitudinal', 'cmb_transversal', 'cmb_compresion', 
               'cmb_perforacion', 'cmb_permeabilidad', 'cmb_poros', 
               'cmb_piramidal', 'cmb_espesor')
     for c in combos:
         utils.rellenar_lista(self.wids[c], 
             enumerate(("<", "<=", "=", ">=", ">", "<>")))
             # [(0, '<'), (1, '='), (2, '>')])
         utils.combo_set_from_db(self.wids[c], 2)
     
     utils.rellenar_lista(self.wids['cmbe_producto'], 
         [(p.id, p.descripcion) 
          for p in pclases.ProductoVenta.select(
             pclases.ProductoVenta.q.camposEspecificosRolloID != None, 
             orderBy = 'descripcion')
         ])
     self.rellenar_tabla()
     # Valores por defecto:
     self.wids['e_longitudinal'].set_text('0')
     self.wids['e_transversal'].set_text('0')
     self.wids['e_compresion'].set_text('0')
     self.wids['e_perforacion'].set_text('0')
     self.wids['e_permeabilidad'].set_text('0')
     self.wids['e_poros'].set_text('0')
     self.wids['e_piramidal'].set_text('0')
     self.wids['e_espesor'].set_text('0')
     self.wids['chk_longitudinal'].set_active(True)
     self.wids['chk_transversal'].set_active(True)
     self.wids['chk_compresion'].set_active(True)
     self.wids['chk_perforacion'].set_active(True)
     self.wids['chk_permeabilidad'].set_active(True)
     self.wids['chk_poros'].set_active(True)
     self.wids['chk_piramidal'].set_active(False)
     self.wids['chk_espesor'].set_active(True)
     self.wids['chk_producto'].set_active(True)
     gtk.main()
Esempio n. 21
0
                if DEBUG:
                    print "Excepción %s capturada al convertir %s de flotante a cadena." % (e, valor)
                raise e
            widget.set_text(valor)
        elif isinstance(col, pclases.SOBoolCol):
            widget.set_active(valor)
        elif isinstance(col, pclases.SODateCol):
            try:
                valor = utils.str_fecha(valor)
            except Exception, e:
                if DEBUG:
                    print "Excepción %s capturada al convertir %s de fecha a cadena." % (e, valor)
                raise e
            widget.set_text(valor)
        elif isinstance(col, pclases.SOForeignKey):
            utils.combo_set_from_db(widget, valor)
        else:
            # Lo intento como puedo. 
            if hasattr(widget, "child"):
                widget.child.set_text(str(valor))
            else:
                try:
                    widget.set_text(str(valor))
                except AttributeError:  # Puede ser un TextView
                    widget.get_buffer().set_text(str(valor))

    def ir_a_primero(self, invertir = True):
        """
        Hace activo el primer objeto de la clase si "invertir" es False.
        Si es True (valor por defecto), el activo es el último objeto 
        creado en la tabla.
 def iter_cliente_seleccionado(completion, model, iter):
     idcliente = model[iter][0]
     utils.combo_set_from_db(self.wids['cbe_cliente'], idcliente)
Esempio n. 23
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
     global fin
     Ventana.__init__(self, 'consulta_control_horas.glade', objeto, usuario)
     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 = (('Fecha', 'gobject.TYPE_STRING', False, True, True, None),
             ('Horas regulares día', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Horas regulares noche', 'gobject.TYPE_STRING', 
                 False, True, False, None), 
             ('Horas extras día', 'gobject.TYPE_STRING', 
                 False, True, False, None), 
             ('Horas extras noche', 'gobject.TYPE_STRING', 
                 False, True, False, None), 
             ('ID', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     for col in range(1, 5):
         columna = self.wids['tv_datos'].get_column(col)
         for cell in columna.get_cell_renderers():
             cell.set_property("xalign", 1)
     # Cuatro columnas ocultas para colorear:
     tipos = [c[1] for c in cols]
     tipos.insert(-1, "gobject.TYPE_BOOLEAN") # Baja
     tipos.insert(-1, "gobject.TYPE_BOOLEAN") # Vacaciones y asuntos prop.
     tipos.insert(-1, "gobject.TYPE_BOOLEAN") # Festivo
     tipos.insert(-1, "gobject.TYPE_BOOLEAN") # Bloqueado
     tipos = [eval(t) for t in tipos]
     new_model = gtk.TreeStore(*tipos)
     new_model.set_sort_func(0, utils.funcion_orden, 0)
     self.wids['tv_datos'].set_model(new_model)
     # ListViews de totales:
     conceptos = ("Tipo de hora", "Hora del día", "Actividad desarrollada", 
                  "Centro de trabajo")
     for c, nombretabla in zip(conceptos, 
         ("tv_tipo", "tv_hora", "tv_actividad", "tv_centro")):
         cols = ((c, "gobject.TYPE_STRING", False, True, True, False),
                 ("Horas totales", "gobject.TYPE_STRING", 
                     False, True, False, None), 
                 ("", "gobject.TYPE_STRING", False, False, False, None))
         if nombretabla == "tv_centro":
             utils.preparar_treeview(self.wids[nombretabla], cols)
         else:
             utils.preparar_listview(self.wids[nombretabla], cols)
         columna = self.wids[nombretabla].get_column(1)
         for cell in columna.get_cell_renderers():
             cell.set_property("xalign", 1)
     # Fechas iniciales de la ventana:
     temp = time.localtime()
     self.inicio = mx.DateTime.localtime() - (7*mx.DateTime.oneDay)
     self.fin = mx.DateTime.localtime()
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     empleados = [(0, "Todos")]
     empleados += [(e.id, "%s, %s" % (e.apellidos, e.nombre)) 
                   for e in pclases.Empleado.select(pclases.AND(
                         pclases.Empleado.q.planta == True, 
                         pclases.Empleado.q.activo == True),
                     orderBy = "apellidos")]
     utils.rellenar_lista(self.wids['cbe_empleado'], empleados)
     utils.combo_set_from_db(self.wids['cbe_empleado'], 0)
     self.colorear()
     self.wids['tv_datos'].connect("row-activated", self.abrir_fila)
     gtk.main()