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, usuario = usuario)
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()
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)
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.suspender(self.wids['cbe_almacen'])
utils.combo_set_from_db(self.wids['cbe_almacen'],
self.objeto.almacenID,
forced_value = self.objeto.almacen
and self.objeto.almacen.nombre or None)
self.revivir(self.wids['cbe_almacen'])
self.objeto.make_swap()
def rellenar_widgets(self):
"""
Introduce la información de la 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.
"""
adaptadores = self.adaptador.get_adaptadores()
for col in adaptadores.keys():
adaptadores[col]['mostrar'](self.objeto)
self.objeto.mostrar_imagen_en(self.wids['plano'], MAX = 200)
self.objeto.make_swap()
self.wids['ventana'].set_title(self.objeto.get_info())
# Por defecto pongo la campaña que coincida con la fecha actual (si
# la hay, la primera que encuentre) como campaña activa.
hoy = mx.DateTime.localtime()
campannas = pclases.Campanna.select(pclases.AND(
pclases.Campanna.q.fechaInicio <= hoy,
pclases.Campanna.q.fechaFin >= hoy))
if campannas.count():
campanna = campannas[0]
utils.combo_set_from_db(self.wids['cb_campanna'], campanna.id)
# HACK: WORKAROUND: Debería lanzarse él solito con el changed
# del combo...
self.rellenar_tablas(self.wids['cb_campanna'])
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, usuario = 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)
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_fecha_fin'].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()
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.
"""
self.wids['b_guardar'].set_sensitive(False)
# Deshabilito el guardar antes de actualizar para
# evitar "falsos positivos".
albaran = self.objeto
if albaran == None:
return
self.wids['e_numalbaran'].set_text(albaran.numalbaran)
self.wids['e_fecha'].set_text(utils.str_fecha(albaran.fecha))
self.wids['ch_bloqueado'].set_active(self.objeto.bloqueado)
self.suspender(self.wids['cbe_almacen'])
utils.combo_set_from_db(self.wids['cbe_almacen'],
self.objeto.almacenOrigenID,
forced_value = self.objeto.almacenOrigen
and self.objeto.almacenOrigen.nombre
or None)
self.revivir(self.wids['cbe_almacen'])
self.rellenar_ldvs()
self.wids['b_guardar'].set_sensitive(False)
# Deshabilito el guardar antes de actualizar para
# evitar "falsos positivos".
self.objeto.make_swap()
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, usuario = usuario)
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()
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, pclases.SOStringCol): # Cadena: el widget es un entry
if valor != None:
w.set_text(valor)
else:
w.set_text("")
elif isinstance(tipocampo, pclases.SOIntCol): # Entero: el widget es un entry
try:
w.set_text("%d" % valor)
except TypeError:
w.set_text("0")
elif isinstance(tipocampo, pclases.SOBoolCol): # Boolean: el widget es un checkbox
w.set_active(valor)
elif isinstance(tipocampo, pclases.SOForeignKey): # Entero-clave ajena: el widget es un comboboxentry
utils.combo_set_from_db(w, valor)
elif isinstance(tipocampo, pclases.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)
def ir_a(self, objeto = None):
if not objeto:
self.ir_a_primero()
else:
# El comercial:
self.objeto = objeto
utils.combo_set_from_db(self.wids['cb_comercial'], self.objeto.id)
self.actualizar_ventana()
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, usuario = 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}
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
Ventana.__init__(self, 'consulta_pedidos_clientes.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,
'b_exportar/clicked': self.exportar,
'e_fecha_inicio/focus-out-event': act_fecha,
'e_fecha_fin/focus-out-event': act_fecha,
}
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),
('Pedido', 'gobject.TYPE_STRING', False, True, False, None),
('Producto', 'gobject.TYPE_STRING', False, True, False, None),
('Cantidad\npedida', 'gobject.TYPE_STRING',
False, True, False, None),
('Cantidad\nservida', 'gobject.TYPE_STRING',
False, True, False, None),
('Importe\npedido\n(c/IVA)', 'gobject.TYPE_STRING',
False, True, False, None),
('Importe\nservido\n(c/IVA)', 'gobject.TYPE_STRING',
False, True, False, None),
("Bloqueado", "gobject.TYPE_BOOLEAN", False, True, False, None),
("Cerrado", "gobject.TYPE_BOOLEAN", False, True, False, None),
('PUIDPEDIDO;PUIDPRODUCTO', 'gobject.TYPE_STRING', # HACK
False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
for ncol in (4, 5, 6, 7):
col = self.wids['tv_datos'].get_column(ncol)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
for col in self.wids['tv_datos'].get_columns():
col.connect("clicked", self.order_changed_refresh_grafica)
self.wids['tv_datos'].connect("row-activated", self.abrir_pedido)
self.resultado = []
self.fin = utils.str_fecha(datetime.date.today())
self.inicio = None
self.wids['e_fecha_fin'].set_text(self.fin)
self.wids['e_fecha_inicio'].set_text("")
if objeto != None:
utils.combo_set_from_db(self.wids["cmbe_cliente"], objeto.id)
self.wids["b_buscar"].clicked()
self.add_widgets_extra()
self.servido_por_producto = defaultdict(lambda: 0)
self.wids['cmbe_cliente'].grab_focus()
gtk.main()
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)
def rellenar_widgets(self):
"""
Introduce la información del proveedor 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.
"""
proveedor = self.objeto
if proveedor != None:
orden = utils.combo_get_value(self.wids["cb_orden"])
if orden == "Orden cronológico":
proveedores = pclases.Proveedor.select(orderBy="id")
elif orden == "Orden alfabético":
proveedores = pclases.Proveedor.select(orderBy="nombre")
proveedores_count = proveedores.count()
yo_index = pclases.SQLlist(proveedores).index(self.objeto) + 1
self.wids["ventana"].set_title(
"Proveedores - %s (%d de %d)" % (proveedor.nombre, yo_index, proveedores_count)
)
# Aprovechando que todo son "text" y los "entry" se llaman casi
# igual:
for c in proveedor.sqlmeta.columnList:
if c.name != "tipoDeProveedorID":
textobj = getattr(proveedor, c.name)
# Reparo los Nones que haya en la BD
if textobj == None:
proveedor.notificador.set_func(lambda: None)
textobj = ""
setattr(proveedor, c.name, textobj)
proveedor.notificador.set_func(self.aviso_actualizacion)
self.escribir_valor(self.wids["e_%s" % c.name], textobj)
else:
utils.combo_set_from_db(self.wids["cb_tipo_de_proveedor"], proveedor.tipoDeProveedorID)
self.rellenar_cuentas()
self.rellenar_tipos_de_material()
self.objeto.make_swap()
try:
doc_from_db = self.objeto.get_documentoDePago().documento
except AttributeError:
doc_from_db = None
if doc_from_db and doc_from_db != self.objeto.documentodepago:
if utils.dialogo(
titulo="CORREGIR DOCUMENTO DE PAGO",
texto="El cliente actual tiene como documento de pago:\n"
"«%s». Se aconseja usar «%s».\n"
"¿Corregirlo automáticamente?\n\n"
"(Responda «No» si la forma de pago es correcta \n"
"o prefiere corregirlo manualmente)" % (self.objeto.documentodepago, doc_from_db),
padre=self.wids["ventana"],
):
self.objeto.documentodepago = doc_from_db
self.objeto.syncUpdate()
self.wids["e_documentodepago"].set_text(self.objeto.documentodepago)
### Botones anterior/siguiente
self.actualizar_botones_anterior_siguiente()
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, self.VENTANA, objeto)
self.add_connections({"b_salir/clicked": self.salir,
"b_imprimir/clicked": self.imprimir,
"b_exportar/clicked": self.exportar,
"cb_empleado/changed": self.mostrar_produccion})
self.inicializar_ventana()
if objeto != None:
utils.combo_set_from_db(self.wids['cb_empleado'], objeto.id)
gtk.main()
def __init__(self, objeto = None, usuario = None):
self.usuario = usuario
Ventana.__init__(self, 'consulta_existencias_por_tipo.glade',
objeto, self.usuario)
connections = {'b_salir/clicked': self.salir,
'b_actualizar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'cb_almacen/changed': self.buscar}
self.add_connections(connections)
for nomtv in ("tv_fibra", "tv_gtx", "tv_cemento"):
cols = [
('Producto', 'gobject.TYPE_STRING', False, True, True, None),#0
('A (Kg)', 'gobject.TYPE_STRING', False, True, False, None),
('A (#)', 'gobject.TYPE_STRING', False, True, False, None),
('B (Kg)', 'gobject.TYPE_STRING', False, True, False, None),
('B (#)', 'gobject.TYPE_STRING', False, True, False, None),
('C (Kg)', 'gobject.TYPE_STRING', False, True, False, None),
('C (#)', 'gobject.TYPE_STRING', False, True, False, None),
('Total (Kg)', 'gobject.TYPE_STRING', False, True, False, None),
('Total (#)', 'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None)]#(5)
if nomtv == "tv_gtx":
cols.insert(2,
('A (m²)', 'gobject.TYPE_STRING', False, True, False, None))
cols.insert(5,
('B (m²)', 'gobject.TYPE_STRING', False, True, False, None))
cols.insert(8,
('C (m²)', 'gobject.TYPE_STRING', False, True, False, None))
cols.insert(11,
('Total (m²)',
'gobject.TYPE_STRING', False, True, False, None))
tv = self.wids[nomtv]
utils.preparar_listview(tv, cols)
tv.connect("row-activated", self.abrir_objeto)
for ncol in range(1, len(cols) - 1):
col = tv.get_column(ncol)
col.get_cell_renderers()[0].set_property('xalign', 1.0)
col = tv.get_column(0)
col.set_expand(True)
almacenes = pclases.Almacen.select(
pclases.Almacen.q.activo == True,
orderBy = "id")
opciones = [(0, "Todos")] + [(a.id, a.nombre) for a in almacenes]
utils.rellenar_lista(self.wids['cb_almacen'], opciones)
utils.combo_set_from_db(self.wids['cb_almacen'], 0)
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_saldo_proveedores.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,
'b_exportar/clicked': self.exportar,
'e_fecha_inicio/focus-out-event': act_fecha,
'e_fecha_fin/focus-out-event': act_fecha,
}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_proveedor'],
[(0, "Todos")] +
[(c.id, c.nombre)
for c in pclases.Proveedor.select(orderBy='nombre')])
cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
('Factura', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('Vencimientos', 'gobject.TYPE_STRING', False, True, False, None),
('Pagado', 'gobject.TYPE_STRING', False, True, False, None),
('Pendiente', 'gobject.TYPE_STRING', False, True, False, None),
('DBPUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for ncol in (3, 4, 5, 6):
col = self.wids['tv_datos'].get_column(ncol)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
self.wids['tv_datos'].connect("row-activated", self.abrir_objeto)
self.resultado = []
self.fin = utils.str_fecha(datetime.date.today())
self.inicio = None
self.wids['e_fecha_fin'].set_text(self.fin)
self.wids['e_fecha_inicio'].set_text("")
if objeto != None:
utils.combo_set_from_db(self.wids["cmbe_proveedor"], objeto.id)
self.wids["b_buscar"].clicked()
self.wids['cmbe_proveedor'].grab_focus()
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(pclases.Almacen.q.activo == True,
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()
def rellenar_widgets(self):
"""
Redimensiona «t» y crea dentro los widgets necesarios para
mostrar y editar los campos de «objeto».
"""
numcampos = len(self.objeto.sqlmeta.columns) - 1 # por el campo fecha
if numcampos % 2 != 0:
numwidgets = numcampos + 1
else:
numwidgets = numcampos
for child in self.wids['t'].get_children():
child.destroy()
self.wids['t'].resize(numwidgets / 2, 4)
icol = 0
irow = 0
for col in self.objeto.sqlmeta.columns:
if col == "fecha":
continue
if not isinstance(self.objeto.sqlmeta.columns[col],
pclases.SOBoolCol):
# Los checkboxes llevan su propio label.
label = self.build_label(col)
self.wids['t'].attach(label, icol, icol+1, irow, irow+1)
icol += 1
child = self.build_child(col, self.objeto.sqlmeta.columns[col])
self.set_valor(child, col, self.objeto.sqlmeta.columns[col])
self.wids['t'].attach(child, icol, icol+1, irow, irow+1)
icol += 1
if icol == 4:
icol = 0
irow += 1
self.wids['t'].show_all()
categorias = pclases.CategoriaLaboral.selectBy(
codigo = self.objeto.codigo)
fechas = [(c.id, utils.str_fecha(c.fecha)) for c in categorias]
utils.rellenar_lista(self.wids['cb_fecha'], fechas)
self.wids['cb_fecha'].disconnect(self.fecha_handler)
utils.combo_set_from_db(self.wids['cb_fecha'], self.objeto.id)
self.fecha_handler = self.wids['cb_fecha'].connect("changed",
self.fecha_changed)
self.objeto.make_swap()
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))
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)
utils.combo_set_from_db(self.wids["cb_orden"], self.wids["cb_orden"].get_model()[0][0])
self.wids["cb_orden"].connect("changed", self.actualizar_botones_anterior_siguiente)
cols = (
("Nombre", "gobject.TYPE_STRING", False, True, True, None),
("Banco", "gobject.TYPE_STRING", False, True, False, None),
("Swift", "gobject.TYPE_STRING", False, True, False, None),
("IBAN", "gobject.TYPE_STRING", False, True, False, None),
("Cuenta", "gobject.TYPE_STRING", False, True, False, None),
("Nombre banco", "gobject.TYPE_STRING", False, True, False, None),
("Observaciones", "gobject.TYPE_STRING", False, True, False, None),
("ID", "gobject.TYPE_INT64", False, False, False, None),
)
utils.preparar_listview(self.wids["tv_cuentas"], cols)
cols = (
("Tipo", "gobject.TYPE_STRING", False, True, True, None),
("ID", "gobject.TYPE_STRING", False, False, False, None),
)
utils.preparar_listview(self.wids["tv_tipos_de_materiales"], cols)
utils.rellenar_lista(
self.wids["cb_tipo_de_proveedor"],
[(t.id, t.descripcion) for t in pclases.TipoDeProveedor.select(orderBy="id")],
)
utils.rellenar_lista(
self.wids["cbe_documentodepago"],
[(d.id, d.documento) for d in pclases.DocumentoDePago.select(orderBy="id")],
)
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
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_ofertas_estudio.glade',
objeto, self.usuario)
# Son ofertas de estudio. Quito todo lo de pedidos.
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,
'notebook1/switch-page': self.cambiar_grafica}
self.add_connections(connections)
cols = (('Número', 'gobject.TYPE_STRING', False, True, True, None),#0
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Producto', 'gobject.TYPE_STRING', False, True, False, None),
('Cantidad', 'gobject.TYPE_STRING', False, True, False, None),
('Precio', 'gobject.TYPE_STRING', False, True, False, None), #5
('€/kg', 'gobject.TYPE_STRING', False, True, False, None),
('Obra', 'gobject.TYPE_STRING', False, True, False, None),
('Comercial', 'gobject.TYPE_STRING', False, True, False, None),
('Importe (s/IVA)',
'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
tv = self.wids['tv_datos']
utils.preparar_listview(tv, cols)
tv.connect("row-activated", self.abrir_objeto)
tv.get_column(4).get_cell_renderers()[0].set_property('xalign', 1)
tv.get_column(5).get_cell_renderers()[0].set_property('xalign', 1)
tv.get_column(6).get_cell_renderers()[0].set_property('xalign', 1)
self.colorear(tv)
cols = (('Producto', 'gobject.TYPE_STRING', False, True, True, None),
('Cantidad Ofertada',
'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_producto'], cols)
getcoltvpro = self.wids['tv_producto'].get_column
getcoltvpro(1).get_cell_renderers()[0].set_property('xalign', 1)
self.wids['tv_producto'].connect("row-activated", self.abrir_objeto)
cols = (('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
('CIF', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('Forma de cobro',
'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_cliente'], cols)
cell = self.wids['tv_cliente'].get_column(2).get_cell_renderers()[0]
cell.set_property('xalign', 1)
self.wids['tv_cliente'].connect("row-activated", self.abrir_objeto)
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))
self.fin = time.localtime()
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
### Combo clientes
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)
### Combo comerciales
comerciales_que_puedo_ver = [c for c
in pclases.Comercial.select(pclases.AND(
pclases.Comercial.q.empleadoID == pclases.Empleado.q.id,
pclases.Empleado.q.usuarioID == pclases.Usuario.q.id,
pclases.Usuario.q.nivel > self.usuario.nivel))]
for c in self.usuario.comerciales: # Los que están por debajo de mi
# nivel (0 = máximo, 5 = mínimo) más y myself.
comerciales_que_puedo_ver.append(c)
opciones = [(c.id, c.get_nombre_completo())
for c in pclases.Comercial.select()
if c.empleado and c.empleado.activo
and c in comerciales_que_puedo_ver]
todos_los_comerciales = [c for c in
pclases.Comercial.select() if c.empleado.activo]
opciones.sort(key = lambda c: c[1])
if len(comerciales_que_puedo_ver) > 1: # Con el esquema de permisos
# actual lo único que puedo hacer es asumir que si puede ver las
# ofertas de alguien más que no sea él mismo, entonces es que
# tiene permisos "de facto" para ver todas las ofertas.
opciones.insert(0, (-1, "Todos"))
utils.rellenar_lista(self.wids['cbe_comercial'], opciones)
if -1 in [item[0] for item in self.wids['cbe_comercial'].get_model()]:
utils.combo_set_from_db(self.wids['cbe_comercial'], -1)
else:
utils.combo_set_from_db(self.wids['cbe_comercial'],
self.usuario.comerciales
and self.usuario.comerciales[0].id or None)
cols = (('Comercial', 'gobject.TYPE_STRING', False, True, True, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Forma de pago',
'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_comercial'], cols)
tv = self.wids['tv_comercial']
tv.get_column(3).get_cell_renderers()[0].set_property('xalign', 1)
tv.connect("row-activated", self.abrir_objeto)
cols = (('Provincia', 'gobject.TYPE_STRING', False, True, True, None),
('Comercial', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Forma de pago',
'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_provincia'], cols)
tv = self.wids['tv_provincia']
tv.get_column(4).get_cell_renderers()[0].set_property('xalign', 1)
tv.connect("row-activated", self.abrir_objeto)
self.wids['ventana'].set_title("Consulta de ofertas de estudio")
self.por_oferta = {} # defaultdict(lambda: [])
self.por_producto = defaultdict(lambda: [])
self.por_cliente = defaultdict(lambda: [])
self.por_comercial = defaultdict(lambda: [])
self.por_provincia = defaultdict(lambda: [])
gtk.main()
widget.set_active(valor)
except TypeError:
pass # valor es None. No toco nada.
elif isinstance(col, pclases.SODateCol):
try:
valor = utils.str_fecha(valor)
except Exception, e:
if valor == None:
valor = "" # A veces es válido que sea fecha o nada.
else:
if pclases.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. A lo mejor faltaría intentarlo también como si fuera un TextView.
if hasattr(widget, "child"):
widget.child.set_text(`valor`)
else:
widget.set_text(`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.
"""
anterior = self.objeto
try:
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_partes_de_visita.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,
'b_exportar/clicked': self.exportar,
'e_fecha_inicio/focus-out-event': act_fecha,
'e_fecha_fin/focus-out-event': act_fecha,
}
self.add_connections(connections)
# Comerciales visibles según usuario "logueado"
comerciales = []
comerciales_del_usuario = []
if self.usuario and self.usuario.empleados:
for e in self.usuario.empleados:
for c in e.comerciales:
comerciales_del_usuario.append(c)
# También debe tener acceso a los comerciales por debajo de su nivel
for c in pclases.Comercial.select():
try:
activo = c.empleado.activo
nivel = c.empleado.usuario.nivel
except AttributeError:
continue
if activo and nivel > self.usuario.nivel:
comerciales_del_usuario.append(c)
if not comerciales_del_usuario or (self.usuario
and self.usuario.nivel <= NIVEL_SUPERVISOR):
comerciales = pclases.Comercial.select()
else:
comerciales = comerciales_del_usuario[:]
opciones_comerciales = [
(c.id, c.empleado and c.empleado.get_nombre_completo()
or "Comercial desconocido (%s)" % c.puid)
for c in comerciales
if c.empleado.activo or c in comerciales_del_usuario]
opciones_comerciales.sort(key = lambda i: i[1])
utils.rellenar_lista(self.wids['cb_comercial'],
[(0, "Todos los visibles por mí")] + opciones_comerciales)
cols = (('Comercial | Cliente/Institución', 'gobject.TYPE_STRING',
False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Motivo', 'gobject.TYPE_STRING', False, True, False, None),
('Observaciones', 'gobject.TYPE_STRING',
False, True, False, None),
('DBPUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_objeto)
self.resultado = []
self.fin = utils.str_fecha(datetime.date.today())
self.inicio = None
self.wids['e_fecha_fin'].set_text(self.fin)
self.wids['e_fecha_inicio'].set_text("")
if objeto != None:
utils.combo_set_from_db(self.wids["cb_comercial"], objeto.id)
self.wids["b_buscar"].clicked()
else:
utils.combo_set_from_db(self.wids['cb_comercial'], 0)
self.wids['cb_comercial'].grab_focus()
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_ofertas_pendientes_validar.glade',
objeto, self.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 = (('Número', 'gobject.TYPE_STRING', False, True, True, None),#0
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Obra', 'gobject.TYPE_STRING', False, True, False, None),
('Comercial', 'gobject.TYPE_STRING', False, True, False, None),
#('Tipo', 'gobject.TYPE_STRING', False, True, False, None),
# CWT: Solo ofertas de pedido. Nada de estudio.
('Estado', 'gobject.TYPE_STRING', False, True, False, None),#5
('Denegada', 'gobject.TYPE_BOOLEAN', False, True, False, None),
('Motivo', 'gobject.TYPE_STRING', False, True, False, None),
('Importe (c/IVA)',
'gobject.TYPE_STRING', False, True, False, None),
('Forma de pago',
'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None)) #10
tv = self.wids['tv_datos']
utils.preparar_listview(tv, cols)
tv.connect("row-activated", self.abrir_objeto)
tv.get_column(6).get_cell_renderers()[0].set_property('xalign', 0.5)
tv.get_column(8).get_cell_renderers()[0].set_property('xalign', 1)
self.colorear(tv)
self.inicio = None
self.wids['e_fechainicio'].set_text("")
self.fin = time.localtime()
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
### Combo clientes
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)
### Combo comerciales
comerciales_que_puedo_ver = [c for c
in pclases.Comercial.select(pclases.AND(
pclases.Comercial.q.empleadoID == pclases.Empleado.q.id,
pclases.Empleado.q.usuarioID == pclases.Usuario.q.id,
pclases.Usuario.q.nivel > self.usuario.nivel))]
for c in self.usuario.comerciales: # Los que están por debajo de mi
# nivel (0 = máximo, 5 = mínimo) más y myself.
comerciales_que_puedo_ver.append(c)
opciones = [(c.id, c.get_nombre_completo())
for c in pclases.Comercial.select()
if c.empleado and c.empleado.activo
and c in comerciales_que_puedo_ver]
todos_los_comerciales = [c for c in
pclases.Comercial.select() if c.empleado.activo]
opciones.sort(key = lambda c: c[1])
if len(comerciales_que_puedo_ver) > 1: # Con el esquema de permisos
# actual lo único que puedo hacer es asumir que si puede ver las
# ofertas de alguien más que no sea él mismo, entonces es que
# tiene permisos "de facto" para ver todas las ofertas.
opciones.insert(0, (-1, "Todos"))
utils.rellenar_lista(self.wids['cbe_comercial'], opciones)
if -1 in [item[0] for item in self.wids['cbe_comercial'].get_model()]:
utils.combo_set_from_db(self.wids['cbe_comercial'], -1)
else:
utils.combo_set_from_db(self.wids['cbe_comercial'],
self.usuario.comerciales
and self.usuario.comerciales[0].id or None)
self.wids['ventana'].set_title(
"Consulta de ofertas pendientes de validar")
self.por_oferta = {} # defaultdict(lambda: [])
gtk.main()
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 '')
categoriaLaboral = empleado.get_categoriaLaboral_vigente()
# TODO: Vigente... vigente hoy. ¿Pero qué pasa si cambio de año?
# ¿Y si hay cambios de días de convenio durante el mismo año?
# De momento lo dejo así, porque la lógica me dice que no se
# viaja en el tiempo para pedir días de años anteriores.
self.wids['e_dias_convenio'].set_text(categoriaLaboral
and "%d" % (categoriaLaboral.diasConvenio) or '')
self.wids['e_dias_asuntos_propios'].set_text(categoriaLaboral
and "%d" % (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"))
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)
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, usuario=usuario)
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()
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() # @UnusedVariable
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()
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-...
"""
# Inicialización del resto de widgets:
cols = (('Hora', 'gobject.TYPE_STRING', True, True, False,
self.cambiar_hora),
('Cliente o institución', 'gobject.TYPE_STRING',
False, True, True, None),
('Lugar', 'gobject.TYPE_STRING', True, True, False,
self.cambiar_lugar),
('Motivo', 'gobject.TYPE_STRING', False, True, False, None),
#self.cambiar_motivo),
('Observaciones', 'gobject.TYPE_STRING', True, True, False,
self.cambiar_observaciones),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
# La última columna (oculta en la Vista) siempre es el id.
utils.preparar_listview(self.wids['tv_visitas'], cols, multi=True)
# ·········· C A M B I O M O D E L O T R E E V I E W ··············
# Agrego un par de columnas para destacar visualmente clientes
# confirmados en la BD y visitas ya enviadas.
self.wids['tv_visitas'].set_model(
# Hora, Enviada, Cliente, ¿existe?, Lugar, Motivo, Observaciones, PUID
gtk.ListStore(str, str, str, str, str, str, str, str, str))
# Columna hora con candado si visita enviada.
# === Columna 0. Cells 0 y 1 ===
col_hora = self.wids['tv_visitas'].get_column(0)
cellhora = col_hora.get_cell_renderers()[0]
col_hora.set_attributes(cellhora, text = 0)
# Cell marca visita enviada.
cellcandado = gtk.CellRendererPixbuf()
col_hora.pack_start(cellcandado, expand = False)
col_hora.set_attributes(cellcandado, stock_id = 1)
# Columna cliente con autocompletado y símbolo "OK" si existe en la BD.
# === Columna 1. Cells 2 y 3 ===
opts_clientes = [("%s (%s)" % (c.nombre, c.cif), c.puid)
for c in pclases.Cliente.select(
pclases.Cliente.q.inhabilitado == False,
orderBy = "nombre")]
self.handler_cliente = utils.cambiar_por_combo(
tv = self.wids['tv_visitas'],
numcol = 1,
opts = opts_clientes,
clase = pclases.Visita,
campo = "nombrecliente",
ventana_padre = self.wids['ventana'],
entry = True,
numcol_model = 2)
col_cliente = self.wids['tv_visitas'].get_column(1)
cellcbcliente = col_cliente.get_cell_renderers()[0]
cellcbcliente.disconnect(self.handler_cliente)
cellcbcliente.connect("edited", self.cambiar_cliente,
cellcbcliente.completion.get_model(),
2,
self.wids['tv_visitas'].get_model())
# Y ahora añadir el icono
celldb = gtk.CellRendererPixbuf()
col_cliente.pack_start(celldb, expand = False)
col_cliente.set_attributes(cellcbcliente, text = 2)
col_cliente.set_attributes(celldb, stock_id = 3)
# === Columna 2. Cells 4 y 5 ===
# Columna lugar.
col_lugar = self.wids['tv_visitas'].get_column(2)
celllugar = col_lugar.get_cell_renderers()[0]
col_lugar.set_attributes(celllugar, text = 4)
# Cell lugar geolocalizado correctamente.
cellgis = gtk.CellRendererPixbuf()
col_lugar.pack_start(cellgis, expand = False)
col_lugar.set_attributes(cellgis, stock_id = 5)
self.wids['tv_visitas'].connect("button_press_event", self.search_gis)
# === Columna 3. Cell 6 ===
# Columna motivo con autocompletado
self.handler_motivo = utils.cambiar_por_combo(self.wids['tv_visitas'],
3,
[(m.motivo, m.puid) for m in
pclases.MotivoVisita.select(
orderBy = "motivo")],
pclases.Visita,
"motivoVisita",
self.wids['ventana'],
entry = False,
numcol_model = 6)
cellcbmotivo = self.wids['tv_visitas'].get_column(3
).get_cell_renderers()[0]
cellcbmotivo.disconnect(self.handler_motivo)
cellcbmotivo.connect("edited", self.cambiar_motivo)
# === Columna 4. Cell 7 ===
# Columna observaciones.
col_observaciones = self.wids['tv_visitas'].get_column(4)
cellobservaciones = col_observaciones.get_cell_renderers()[0]
col_observaciones.set_attributes(cellobservaciones, text = 7)
# ·····································································
# Control de permisos de edición si visitas enviadas:
for col in [self.wids['tv_visitas'].get_column(1),]:
for cell in col.get_cell_renderers():
cell.connect("editing-started", self.control_permisos_enviado,
self.wids['tv_visitas'].get_model())
# Comerciales visibles según usuario "logueado"
comerciales = []
comerciales_del_usuario = []
if self.usuario and self.usuario.empleados:
for e in self.usuario.empleados:
for c in e.comerciales:
comerciales_del_usuario.append(c)
# También debe tener acceso a los comerciales por debajo de su nivel
for c in pclases.Comercial.select():
try:
activo = c.empleado.activo
nivel = c.empleado.usuario.nivel
except AttributeError:
continue
if activo and nivel > self.usuario.nivel:
comerciales_del_usuario.append(c)
if not comerciales_del_usuario or (self.usuario
and self.usuario.nivel <= NIVEL_SUPERVISOR):
comerciales = pclases.Comercial.select()
else:
comerciales = comerciales_del_usuario[:]
opciones_comerciales = [
(c.id, c.empleado and c.empleado.get_nombre_completo()
or "Comercial desconocido (%s)" % c.puid)
for c in comerciales
if c.empleado.activo or c in comerciales_del_usuario]
opciones_comerciales.sort(key = lambda i: i[1])
utils.rellenar_lista(self.wids['cb_comercial'], opciones_comerciales)
if self.objeto:
utils.combo_set_from_db(self.wids['cb_comercial'], self.objeto.id)
# Si ha recibido el objeto, debe tener permiso para verlo. De otro
# modo... ¡me están juanqueando! (y petará).
if self.fecha_recibida:
hoy = self.fecha_recibida
else:
# Empiezo con el día actual.
hoy = datetime.date.today()
self.wids['calendario'].select_day(hoy.day)
self.wids['calendario'].select_month(hoy.month - 1, hoy.year)
# Tratamiento especial de los botones actualizar y guardar
self.activar_widgets(True, chequear_permisos = False)
self.wids['ventana'].resize(700, 500)
# Al principio pensé que podría ser útil. Ahora me ha entrado un poco
# de complejo de Jacob Nielsen y casi mejor lo quito:
self.wids['b_actualizar'].set_property("visible", False)
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.
"""
self.wids['b_guardar'].set_sensitive(False)
producto = self.objeto
linea = pclases.LineaDeProduccion.select(
pclases.LineaDeProduccion.q.nombre.contains('fibra'))[0]
lineaembol = pclases.LineaDeProduccion.select(
pclases.LineaDeProduccion.q.nombre.contains('bolsa'))[0]
productos = pclases.ProductoVenta.select(pclases.AND(
pclases.ProductoVenta.q.camposEspecificosBalaID != None,
pclases.OR(
pclases.ProductoVenta.q.lineaDeProduccionID == linea.id,
pclases.ProductoVenta.q.lineaDeProduccionID == lineaembol.id
)), orderBy = 'id')
productos_count = productos.count()
yo_index = pclases.SQLlist(productos).index(producto) + 1
self.wids['ventana'].set_title(
"Productos de venta: FIBRA - %s (%d de %d)" % (
producto.descripcion,
yo_index,
productos_count))
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.wids['e_cajasPale'].set_sensitive(not self.objeto.articulos)
try:
cliente = campos.cliente.id
except AttributeError:
cliente = 0
utils.combo_set_from_db(self.wids['cbe_cliente'], cliente)
# Nuevos campos de etiquetas norma13:
if self.objeto.annoCertificacion is None:
self.wids['sp_anno_certificacion'].set_text("")
self.wids['ch_no_anno_cert'].set_active(True)
else:
self.wids['sp_anno_certificacion'].set_value(
self.objeto.annoCertificacion)
utils.show_leading_zeros(self.wids['sp_anno_certificacion'])
self.wids['ch_no_anno_cert'].set_active(False)
self.wids['e_dni'].set_text(producto.dni)
self.wids['e_uso'].set_text(producto.uso)
try:
self.wids['ch_obsoleto'].set_active(self.objeto.obsoleto)
except (KeyError, AttributeError):
pass # Versión antigua de la base de datos.
### Botones anterior/siguiente
producto = self.objeto
try:
linea = pclases.LineaDeProduccion.select(
pclases.LineaDeProduccion.q.nombre.contains('fibra'))[0]
lineaembol = pclases.LineaDeProduccion.select(
pclases.LineaDeProduccion.q.nombre.contains('bolsa'))[0]
anteriores = pclases.ProductoVenta.select(pclases.AND(
pclases.ProductoVenta.q.camposEspecificosBalaID != None,
pclases.OR(
pclases.ProductoVenta.q.lineaDeProduccionID == linea.id,
pclases.ProductoVenta.q.lineaDeProduccionID == lineaembol.id
),
pclases.ProductoVenta.q.id < producto.id)).count()
siguientes = pclases.ProductoVenta.select(pclases.AND(
pclases.ProductoVenta.q.camposEspecificosBalaID != None,
pclases.OR(
pclases.ProductoVenta.q.lineaDeProduccionID == linea.id,
pclases.ProductoVenta.q.lineaDeProduccionID == lineaembol.id
),
pclases.ProductoVenta.q.id > producto.id)).count()
except:
pass
else:
self.wids['b_anterior'].set_sensitive(anteriores)
self.wids['b_siguiente'].set_sensitive(siguientes)
self.wids['b_guardar'].set_sensitive(False)
self.objeto.make_swap()
def iter_cliente_seleccionado(completion, model, itr):
idcliente = model[itr][0]
utils.combo_set_from_db(self.wids['cbe_cliente'], idcliente)