コード例 #1
0
 def __init__(self, objeto = None, usuario = None):
     """
     Constructor. objeto puede ser un objeto de pclases con el que
     comenzar la ventana (en lugar del primero de la tabla, que es
     el que se muestra por defecto).
     """
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_ventas_por_producto.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     cols = (('Producto', 'gobject.TYPE_STRING', False, True, True, None),
             ('Cantidad', 'gobject.TYPE_STRING', False, True, False, None),
             ('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
             ('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
             ('Albarán', 'gobject.TYPE_STRING', False, True, False, None),
             ('ID', 'gobject.TYPE_STRING', False, False, False, None))    # Del producto, de la LDV o de la LDD.
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_producto_albaran_o_abono)
     self.wids['tv_datos'].get_column(1).get_cell_renderers()[0].set_property('xalign', 1) 
     self.wids['tv_datos'].get_column(2).get_cell_renderers()[0].set_property('xalign', 1) 
     self.wids['tv_datos'].get_column(3).get_cell_renderers()[0].set_property('xalign', 0.5) 
     fin = mx.DateTime.localtime()
     inicio = mx.DateTime.localtime() - mx.DateTime.oneWeek
     self.wids['e_fechainicio'].set_text(utils.str_fecha(inicio))
     self.wids['e_fechafin'].set_text(utils.str_fecha(fin))
     gtk.main()
コード例 #2
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     total = 0
     self.resultados.sort(self.por_fecha_ldc)
     for ldc in self.resultados:
         subtotal = ldc.cantidad * ldc.precio
         datos.append((ldc.nombre_proveedor,
                       ldc.albaranEntrada.numalbaran,
                       utils.str_fecha(ldc.albaranEntrada.fecha),
                       ldc.descripcion_productoCompra,
                       utils.float2str(ldc.cantidad),
                       utils.float2str(ldc.precio),
                       utils.float2str(subtotal)
                     ))
         total += subtotal
     if len(self.resultados) > 0:
         datos.append(("", "", "", "", "", "", "-"*20))
         datos.append(("", "", "", "", "", "", utils.float2str(total)))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
     else:
         fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
     if datos != []:
         informes.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))
コード例 #3
0
ファイル: up_consulta_facturas.py プロジェクト: pacoqueen/upy
 def __init__(self, objeto = None, usuario = None):
     Ventana.__init__(self, 'up_consulta_facturas.glade', objeto)
     self.usuario = usuario
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_ticket/clicked': self.imprimir_ticket, 
                    'tv_datos/cursor-changed': self.mostrar_info_factura}
     self.add_connections(connections)
     cols = (('Cliente','gobject.TYPE_STRING', False, True, False, None),
             ('Importe','gobject.TYPE_STRING', False, True, False, None),
             ('Fecha','gobject.TYPE_STRING', False, True, False, None),
             ('Pendiente de cobro','gobject.TYPE_STRING', 
                 False, True, False, None),
             ('PUID','gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
     for col in (self.wids['tv_datos'].get_column(1), 
                 self.wids['tv_datos'].get_column(3)):
         for cell in col.get_cell_renderers():
             cell.set_property("xalign", 1.0)
     self.fin = datetime.date.today()
     self.inicio = datetime.date(day = 1, month = self.fin.month, 
                                 year = self.fin.year)
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     gtk.main()
コード例 #4
0
ファイル: ausencias.py プロジェクト: pacoqueen/bbinn
 def cambiar_fecha_fin_baja(self, cell, path, texto):
     try:
         fecha = utils.parse_fecha(texto)
     except (ValueError, TypeError):
         utils.dialogo_info(
             titulo="FECHA INCORRECTA", texto="La fecha introducida no es válida", padre=self.wids["ventana"]
         )
         return
     model = self.wids["tv_bajas"].get_model()
     baja = pclases.Baja.get(model[path][-1])
     for bajaexistente in self.objeto.bajas:
         if bajaexistente == baja:
             continue
         iniciorango = baja.fechaInicio
         finrango = fecha
         if iniciorango > finrango:
             iniciorango, finrango = finrango, iniciorango
         fechaintermedia = iniciorango
         while fechaintermedia < finrango:
             if bajaexistente.esta_vigente(fechaintermedia):
                 utils.dialogo_info(
                     titulo="BAJA SOLAPADA",
                     texto="Las bajas médicas no pueden solaparse entre sí, elija otra fecha.",
                     padre=self.wids["ventana"],
                 )
                 return
             fechaintermedia += mx.DateTime.oneDay
     baja.fechaFin = fecha
     if baja.fechaInicio > baja.fechaFin:
         baja.fechaInicio, baja.fechaFin = baja.fechaFin, baja.fechaInicio
     baja.sync()
     model[path][0] = utils.str_fecha(baja.fechaInicio)
     model[path][1] = utils.str_fecha(baja.fechaFin)
コード例 #5
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     for pago in self.resultado:
         datos.append((pago.facturaCompra.numfactura,
                       utils.str_fecha(pago.fecha),
                       utils.float2str(pago.importe),
                       pago.observaciones,
                       pago.facturaCompra.proveedor.nombre))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
     else:
         fechaInforme = (utils.str_fecha(self.inicio) + ' - ' 
                         + utils.str_fecha(self.fin))
     if datos != []:
         model = self.wids['tv_totales'].get_model()
         datos.append(("---", )*5)
         datos.append(("TOTALES POR MES Y AÑO", ">->", ">->", ">->", ">->"))
         for fila in model:
             datos.append((fila[0], "", fila[1], "", ""))
             iter_filames = model.iter_children(fila.iter)
             while iter_filames:
                 filames = model[iter_filames]
                 datos.append(("", filames[0], filames[1], "", ""))
                 iter_filames = model.iter_next(iter_filames)
         datos.append(("---", )*5)
         datos.append(("", 
                       "Total", 
                       self.wids['e_total'].get_text(), 
                       "", 
                       ""))
         informes.abrir_pdf(geninformes.vencimientosPago(datos,fechaInforme))
コード例 #6
0
ファイル: pagares_cobros.py プロジェクト: pacoqueen/upy
 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))
コード例 #7
0
 def __init__(self, objeto=None, usuario=None):
     self.usuario = usuario
     Ventana.__init__(self, "consulta_ventas_ticket.glade", objeto)
     connections = {
         "b_salir/clicked": self.salir,
         "b_buscar/clicked": self.buscar,
         "b_imprimir/clicked": self.imprimir,
         "b_exportar/clicked": self.exportar,
         "b_fecha_inicio/clicked": self.set_inicio,
         "b_fecha_fin/clicked": self.set_fin,
     }
     self.add_connections(connections)
     cols = (
         ("Fecha", "gobject.TYPE_STRING", False, True, False, None),
         ("Ticket", "gobject.TYPE_STRING", False, True, True, None),
         ("Imp. total", "gobject.TYPE_STRING", False, True, False, None),
         ("Imp. (s/IVA)", "gobject.TYPE_STRING", False, True, False, None),
         ("Ben. sobre tarifa", "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 self.wids["tv_datos"].get_columns()[2:]:
         for cell in col.get_cell_renderers():
             cell.set_property("xalign", 1.0)
         col.set_alignment(0.5)
     self.wids["tv_datos"].connect("row-activated", self.abrir_producto)
     self.fin = datetime.date.today()
     self.inicio = self.fin
     self.wids["e_fechafin"].set_text(utils.str_fecha(self.fin))
     self.wids["e_fechainicio"].set_text(utils.str_fecha(self.inicio))
     self.wids["hbox1"].set_property("visible", False)
     self.wids["hbox6"].set_property("visible", False)
     gtk.main()
コード例 #8
0
ファイル: consulta_producido.py プロジェクト: pacoqueen/bbinn
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     model = self.wids['tv_datos'].get_model()
     for i in model:
         datos.append((i[0],
                       i[1],
                       i[2]))
     if self.balas != 0:
         datos.append(("", "", ""))
         datos.append(("", "-" * 30 , "-" * 30))
         datos.append(("", "", ""))
         datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.kilos)), self.balas))
     if self.rollos != 0:
         datos.append(("", "", ""))
         datos.append(("", "-" * 30 , "-" * 30))
         datos.append(("", "", ""))
         datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.metros)), self.rollos))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
     else:
         fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
     if datos != []:
         informes.abrir_pdf(geninformes.producido_produccion(datos, fechaInforme, self.grafico))
コード例 #9
0
 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()
コード例 #10
0
    def imprimir(self, boton):
        """
        Prepara la vista preliminar para la impresión del informe
        """
        import informes
        datos = []
        for i in self.resultado:
            datos.append((i.cliente.nombre,
                          utils.str_fecha(i.fecha),
                          i.numpedido,
                          "%s €" % (utils.float2str(i.calcular_importe_total())),
                          i.bloqueado and "Sí" or "No",
                          i.cerrado and "Sí" or "No"))
        datos.append(("", "", "", "---", "", ""))
        datos.append(("%s pedidos listados." % (self.wids['e_total'].get_text()),
                      "",
                      "Importe total:",
                      self.wids['e_importe_total'].get_text(),
                      "",
                      ""))
        if (self.inicio) == None:
            fechaInforme = 'Hasta ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
        else:
            fechaInforme = utils.str_fecha(time.strptime(self.inicio, "%Y/%m/%d")) + ' - ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))

        if datos != []:
            informes.abrir_pdf(geninformes.pedidosCliente(datos, self.cliente and self.cliente.nombre or "?", fechaInforme))
コード例 #11
0
ファイル: consulta_beneficio.py プロジェクト: pacoqueen/upy
 def __init__(self, objeto = None, usuario = None):
     Ventana.__init__(self, 'consulta_beneficio.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin}
     self.add_connections(connections)
     cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None),
             ('Nº Factura','gobject.TYPE_STRING', False, True, True, None),
             ('Cliente','gobject.TYPE_STRING', False, True, False, None),
             ('Importe','gobject.TYPE_STRING', False, True, False, None),
             ('Base imponible','gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Beneficio sobre tarifa','gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Idfactura','gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     for col in (self.wids['tv_datos'].get_columns()[0:2] 
                 + self.wids['tv_datos'].get_columns()[3:]):
         for cell in col.get_cell_renderers():
             cell.set_property("xalign", 1.0)
         col.set_alignment(0.5)
     self.fin = datetime.date.today()
     self.inicio = datetime.date(day = 1, month = self.fin.month, year = self.fin.year)
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     gtk.main()
コード例 #12
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     lista = self.resultado
   	for elem in lista:
 		datos.append((elem.numpartida,
                 "%.2f" % elem.longitudinal,
                 "%.2f" % elem.transversal,
                 "%.2f" % elem.compresion,
                 "%.2f" % elem.perforacion,
                 "%.2f" % elem.permeabilidad,
                 "%.2f" % elem.poros,
                 "%.2f" % elem.piramidal, 
                 "%.2f" % elem.espesor))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
     else:
         fechaInforme = (utils.str_fecha(self.inicio) + ' - ' + 
                         utils.str_fecha(self.fin))
     if datos != []:
         informes.abrir_pdf(geninformes.laboratorioPartidas(datos, 
                                                            fechaInforme))
コード例 #13
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).
     """
     if utils.dialogo(titulo = "¿EXPORTAR A CSV?", 
                      texto = "¿Quiere generar también un archivo CSV por "
                              "cada PDF que se cree a continuación?", 
                      defecto = False, 
                      tiempo = 15):
         csv = True 
         ruta_csv = tempfile.NamedTemporaryFile(suffix = ".csv").name
     else:
         csv = False
         ruta_csv = None
     import informes
     informes.abrir_pdf(geninformes.existencias_productos(
         'rollos', 
         "%s, %s" % (utils.str_fecha(time.localtime()), 
                     time.strftime("%H:%M")), 
         ruta_csv = ruta_csv))
     if pclases.Almacen.select().count() > 1:
         for a in pclases.Almacen.select():
             if csv:
                 ruta_csv = tempfile.NamedTemporaryFile(
                     suffix = "_%s.csv" % a.nombre, 
                     delete = False).name
             informes.abrir_pdf(
                 geninformes.existencias_productos('rollos', "%s, %s" % (
                         utils.str_fecha(time.localtime()), 
                         time.strftime("%H:%M")), 
                     almacen = a, 
                     ruta_csv = ruta_csv))
コード例 #14
0
ファイル: pagares_cobros.py プロジェクト: pacoqueen/upy
 def refinar_resultados_busqueda(self, resultados):
     """
     Muestra en una ventana de resultados todos los
     registros de "resultados".
     Devuelve el id (primera columna de la ventana
     de resultados) de la fila seleccionada o None
     si se canceló.
     """
     filas_res = []
     for r in resultados:
         cliente = r.cliente
         filas_res.append((r.id, 
                           r.codigo, 
                           cliente != None and cliente.nombre or "", 
                           utils.str_fecha(r.fechaRecepcion), 
                           "%s €" % (utils.float2str(r.cantidad)), 
                           utils.str_fecha(r.fechaCobro), 
                           r.pendiente and "Sí" or "No", 
                           ", ".join([c.numfactura for c in r.cobros])))
     idpagare = utils.dialogo_resultado(filas_res,
                 titulo = 'Seleccione Pagaré',
                 cabeceras = ('ID', 'Número', 'Cliente', 'Fecha recepción', 
                         'Importe', 'Vencimiento', 'Pendiente', 'Facturas'), 
                 padre = self.wids['ventana'])
     if idpagare < 0:
         return None
     else:
         return idpagare
コード例 #15
0
    def imprimir(self,boton):
        """
        Prepara la vista preliminar para la impresión del informe
        """
        import informes
        datos = []
        for i in self.resultado:
#            if len(i.observaciones) > 35:
#                observaciones = i.observaciones[:35]+'...'
#            else:
#                observaciones = i.observaciones        # Ya administra bien el salto de línea. No hace falta cortar.
            observaciones = i.observaciones        # Ya administra bien el salto de línea. No hace falta cortar.
            datos.append((i.tipoDeIncidencia.descripcion,
                          utils.str_hora_corta(i.horainicio),
                          utils.str_hora_corta(i.horafin),
                          utils.str_fecha(i.parteDeProduccion.fecha),
                          utils.str_hora_corta(i.parteDeProduccion.horainicio)+'-'+utils.str_hora_corta(i.parteDeProduccion.horafin),
                          observaciones))

        if (self.inicio) == None:            
            fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
        else:
            fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))

        if datos != []:
            informes.abrir_pdf(geninformes.incidencias(datos,fechaInforme))
コード例 #16
0
ファイル: recibos.py プロジェクト: pacoqueen/bbinn
 def refinar_resultados_busqueda(self, resultados):
     """
     Muestra en una ventana de resultados todos los
     registros de "resultados".
     Devuelve el id (primera columna de la ventana
     de resultados) de la fila seleccionada o None
     si se canceló.
     """
     filas_res = []
     for r in resultados:
         filas_res.append((r.id, 
                           r.numrecibo, 
                           r.anno, 
                           r.get_cliente() and r.get_cliente().nombre or "", 
                           ", ".join([f.numfactura for f 
                                      in r.get_facturas()]), 
                           utils.float2str(r.calcular_importe()), 
                           utils.str_fecha(r.fechaLibramiento), 
                           utils.str_fecha(r.fechaVencimiento)
                          ))
     idrecibo = utils.dialogo_resultado(filas_res,
                                        titulo = 'SELECCIONE RECIBO',
                                        cabeceras = ('ID', 
                                                     'Número', 
                                                     'Año', 
                                                     'Cliente', 
                                                     'Facturas', 
                                                     'Importe', 
                                                     'Libramiento', 
                                                     'Vencimiento'), 
                                        padre = self.wids['ventana'])
     if idrecibo < 0:
         return None
     else:
         return idrecibo
コード例 #17
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     # for i in self.resultado:
     #     datos.append((i.cliente.nombre,
     #                 utils.str_fecha(i.fecha),
     #                 i.numalbaran,
     #                 i.nombre))
     model = self.wids['tv_datos'].get_model()
     for i in model:
         datos.append((i[0], i[1], i[2], i[3], i[5]))        
     if (self.inicio) == None:            
         fechaInforme = ('Hasta '   
             + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d")))
     else:
         fechaInforme = (
             utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d")) 
             + ' - ' 
             + utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d")))
     if datos != []:
         datos.append(("Total albaranes: ", 
                       self.wids["e_total"].get_text(), 
                       "", "", ""))
         informes.abrir_pdf(
             geninformes.albaranesCliente(datos, 
                 self.cliente and self.cliente.nombre or "", 
                 fechaInforme))
コード例 #18
0
ファイル: up_report_diario.py プロジェクト: pacoqueen/upy
 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_report_diario.glade", objeto)
     self.objeto = objeto
     self.usuario = usuario
     self.inicializar_ventana()
     connections = {
         "b_salir/clicked": self.salir,
         "b_imprimir/clicked": self.imprimir,
         "b_refrescar/clicked": self.actualizar,
         "b_send/clicked": self.enviar_por_correoe,
         "b_fecha_ini/clicked": self.set_inicio,
         "b_fecha_fin/clicked": self.set_fin,
     }
     self.add_connections(connections)
     hoy = datetime.datetime.today()
     self.wids["e_fecha_ini"].set_text(utils.str_fecha(hoy))
     self.wids["e_fecha_fin"].set_text(utils.str_fecha(hoy))
     self.dia_seleccionado, self.fechafin = self.get_fechas_mostradas()
     self.fechaini = self.dia_seleccionado
     self.actualizar()
     gtk.main()
コード例 #19
0
 def __init__(self, objeto = None, usuario = None):
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_ventas_ticket.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin}
     self.add_connections(connections)
     cols = (('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
             ('T./Alb./Fra.','gobject.TYPE_STRING',False,True,True,None),
             ('Imp. total', 'gobject.TYPE_STRING',False,True,False,None),
             ('Imp. (s/IVA)','gobject.TYPE_STRING',False,True,False,None),
             ('Ben. sobre tarifa', '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 self.wids['tv_datos'].get_columns()[2:]:
         for cell in col.get_cell_renderers():
             cell.set_property("xalign", 1.0)
         col.set_alignment(0.5)
     self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
     self.fin = mx.DateTime.today()
     #self.inicio = mx.DateTime.DateTimeFrom(day = 1, month = self.fin.month, year = self.fin.year)
     self.inicio = self.fin
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     gtk.main()
コード例 #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, 'up_consulta_clientes_por_mes.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_fechainicio/clicked': self.set_inicio,
                    'b_fechafin/clicked': self.set_fin,
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     cols = (('Mes', 'gobject.TYPE_STRING', False, True, False, None),
             ('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
             ('Clases a las que asistió', 
                 'gobject.TYPE_STRING', False, True, False, None),
             ('PUDI_cliente', 'gobject.TYPE_STRING', 
                 False, False, False, None))
     utils.preparar_treeview(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)
     hoy = datetime.date.today()
     self.fechainicio = datetime.date(hoy.year, hoy.month, 1)
     for i in range(28, 32):
         try:
             self.fechafin = datetime.date(hoy.year, hoy.month, i)
         except ValueError:
             pass
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.fechainicio))
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fechafin))
     gtk.main()
コード例 #21
0
 def imprimir(self, boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import sys, os
     sys.path.append(os.path.join("..", "informes"))
     from treeview2pdf import treeview2pdf
     from informes import abrir_pdf
     idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
     if idcliente == None:
         utils.dialogo_info(titulo = 'ERROR',
                            texto = 'Seleccione un cliente',
                            padre = self.wids['ventana'])
     else:
         idcliente = utils.combo_get_value(self.wids['cmbe_cliente'])
         self.cliente = pclases.Cliente.get(idcliente)
         cliente = self.cliente
         if self.inicio == None:            
             fechaInforme = 'Hasta ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
         else:
             fechaInforme = utils.str_fecha(time.strptime(self.inicio, "%Y/%m/%d")) + ' - ' + utils.str_fecha(time.strptime(self.fin, "%Y/%m/%d"))
     
         strfecha = fechaInforme
         informe = treeview2pdf(self.wids['tv_datos'], 
                     titulo = "Productos comprados por " + cliente.nombre, 
                     fecha = strfecha) 
         if informe:
             abrir_pdf(informe)
コード例 #22
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_productividad.glade', objeto)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin, 
                    'b_imprimir/clicked': self.imprimir, 
                    'b_exportar/clicked': self.exportar}
     self.add_connections(connections)
     cols = (('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
             ('Inicio del turno', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Fin del turno', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Producción', 'gobject.TYPE_STRING', False, True, False, None),
             ('Productividad', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Idparte', 'gobject.TYPE_INT64', False, False, False, None))
     utils.preparar_treeview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_parte)
     # XXX
     import gobject
     model = gtk.TreeStore(gobject.TYPE_STRING, 
                           gobject.TYPE_STRING, 
                           gobject.TYPE_STRING, 
                           gobject.TYPE_STRING,
                           gobject.TYPE_STRING,
                           gobject.TYPE_FLOAT,
                           gobject.TYPE_INT64)
     self.wids['tv_datos'].set_model(model)
     model.set_sort_func(0, utils.funcion_orden, 0)
     cell = gtk.CellRendererProgress()
     column = gtk.TreeViewColumn('', cell)
     column.add_attribute(cell, 'value', 5)
     column.set_sort_column_id(5)
     self.wids['tv_datos'].insert_column(column, 5)
     # XXX
     self.wids['tv_datos'].add_events(gtk.gdk.BUTTON_PRESS_MASK)
     self.wids['tv_datos'].connect('button_press_event', 
                                   self.button_clicked) 
     # XXX
     self.colorear(self.wids['tv_datos'])
     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.wids['e_fechainicio'].set_text(utils.str_fecha(
         mx.DateTime.localtime() - (7 * mx.DateTime.oneDay)))
     self.inicio = self.wids['e_fechainicio'].get_text().split('/')
     self.inicio.reverse()
     self.inicio = '/'.join(self.inicio)
     gtk.main()
コード例 #23
0
 def show_fecha(self, entry, event):
     """
     Muestra la fecha en modo texto después de parsearla.
     """
     if entry.get_text():
         try:
             entry.set_text(utils.str_fecha(utils.parse_fecha(entry.get_text())))
         except (ValueError, TypeError):
             entry.set_text(utils.str_fecha(mx.DateTime.localtime()))
コード例 #24
0
 def rellenar_tabla(self, items):
 	"""
     Rellena el model con los items de la consulta
     """        
 	model = self.wids['tv_datos'].get_model()
 	model.clear()
     total = 0
     vencido = 0
     hoy = datetime.date.today()
     por_fecha = {}
 	for i in items:
         if not i[2]:  # i[2] = False cuando es vencimiento normal de la BD
             total += i[1].importe 
             importe = i[1].importe
             anno = i[1].fecha.year
             mes = i[1].fecha.month
             if i[1].fecha < hoy:
                 vencido += i[1].importe
             fra = i[1].facturaVenta or i[1].prefactura
             model.append((fra.numfactura,
                           utils.str_fecha(i[1].fecha),
                           utils.float2str(importe),
                           i[1].observaciones,
                           fra.cliente.nombre,
                           "V:" + `i[1].id`))
         else:   # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
             importe = i[1]['importe']
             anno = i[1]['fecha'].year
             mes = i[1]['fecha'].month
             total += i[1]['importe']
             if i[1]['fecha'] < hoy:
                 vencido += i[1]['importe']
             model.append(("LOGIC",      # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
                           utils.str_fecha(i[1]['fecha']),
                           utils.float2str(i[1]['importe']),
                           i[1]['comentario'],
                           i[1]['cuenta'],
                           "L:" + i[1]['id']))
         if anno not in por_fecha:
             por_fecha[anno] = {}
         if mes not in por_fecha[anno]:
             por_fecha[anno][mes] = 0.0
         por_fecha[anno][mes] += importe
     self.wids['e_total'].set_text("%s €" % utils.float2str(total))
     self.wids['e_vencido'].set_text("%s €" % utils.float2str(vencido))
     # Relleno el model de totales.
     annos = por_fecha.keys()
     annos.sort()
     model = self.wids['tv_totales'].get_model()
     model.clear()
     for anno in annos:
         total_anno = sum([por_fecha[anno][mes] for mes in por_fecha[anno]])
         anno_padre = model.append(None, (`anno`, 
                                          utils.float2str(total_anno), 
                                          ""))
         meses = por_fecha[anno].keys()
コード例 #25
0
def get_txtfechavtopago(pago):
    """
    Devuelve la fecha de vencimiento del propio pago.
    """
    res = ""
    if pago and pago.fecha:
        res = utils.str_fecha(pago.fecha)
        if pago.pagarePago:
            res = utils.str_fecha(pago.pagarePago.fechaVencimiento)
    return res
コード例 #26
0
ファイル: consulta_cobros.py プロジェクト: pacoqueen/upy
 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_cobros.glade", objeto)
     connections = {
         "b_salir/clicked": self.salir,
         "b_buscar/clicked": self.buscar,
         "b_imprimir/clicked": self.imprimir,
         "b_fecha_inicio/clicked": self.set_inicio,
         "b_fecha_fin/clicked": self.set_fin,
         "b_exportar/clicked": self.exportar,
     }
     self.add_connections(connections)
     cols = (
         ("Fecha", "gobject.TYPE_STRING", False, True, True, None),
         ("Vencimientos", "gobject.TYPE_STRING", False, False, False, None),
         ("Factura(Cliente)", "gobject.TYPE_STRING", False, True, False, None),
         ("Cobros", "gobject.TYPE_STRING", False, False, False, None),
         ("Factura(Cliente)", "gobject.TYPE_STRING", False, True, False, None),
         ("id", "gobject.TYPE_STRING", False, False, False, None),
     )
     utils.preparar_treeview(self.wids["tv_datos"], cols)
     col = self.wids["tv_datos"].get_column(1)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     col = self.wids["tv_datos"].get_column(3)
     for cell in col.get_cell_renderers():
         cell.set_property("xalign", 1)
     cols2 = (
         ("Forma de pago", "gobject.TYPE_STRING", False, True, True, None),
         ("Factura", "gobject.TYPE_STRING", False, False, False, None),
         ("Cliente", "gobject.TYPE_STRING", False, True, False, None),
         ("Importe", "gobject.TYPE_STRING", False, False, False, None),
         ("PUID", "gobject.TYPE_STRING", False, False, False, None),
     )
     utils.preparar_treeview(self.wids["tv_datos_cobros_formapago"], cols2)
     self.wids["tv_datos_cobros_formapago"].connect("row-activated", self.abrir_factura)
     utils.preparar_treeview(self.wids["tv_datos_vtos_formapago"], cols2)
     self.wids["tv_datos_vtos_formapago"].connect("row-activated", self.abrir_factura)
     temp = time.localtime()
     self.fin = str(temp[0]) + "/" + str(temp[1]) + "/" + str(temp[2])
     self.wids["e_fechafin"].set_text(utils.str_fecha(temp))
     tempinicio = datetime.date.today() - datetime.timedelta(days=1) * 30
     tempinicio = utils.str_fecha(tempinicio)
     self.inicio = tempinicio
     self.wids["e_fechainicio"].set_text(tempinicio)
     self.wids["e_estimados"].set_property("visible", False)
     self.wids["label8"].set_property("visible", False)
     gtk.main()
コード例 #27
0
def get_txtfecha(pago, vto):
    """
    Devuelve la fecha de vencimiento al que corresponde el pago. Si no hay 
    vencimiento, entonces la fecha del pago en sí. Y si no, cadena vacía.
    """
    res = ""
    if vto:
        res = utils.str_fecha(vto.fecha)
    elif pago and pago.fecha:
        res = utils.str_fecha(pago.fecha)
    return res
コード例 #28
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_pendientes_vto_bueno.glade', objeto, 
                      usuario = self.usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_pendientes/clicked': self.buscar,
                    'b_todas/clicked': self.buscar,
                    'b_fecha_inicio/clicked': self.set_inicio,
                    'b_fecha_fin/clicked': self.set_fin}
     self.add_connections(connections)
     utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) 
                          for c 
                          in pclases.Proveedor.select(orderBy='nombre')])
     cols = (('Factura', 'gobject.TYPE_STRING', False, True, True, None),
             ('Código vto. bueno', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
             ('Importe', 'gobject.TYPE_STRING', False, False, False, None),
             ('Fecha fra.', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Fecha recepción', 'gobject.TYPE_STRING', 
                 False, True, False, None),
             ('Automático', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('Usuario', 'gobject.TYPE_BOOLEAN', False, True, False, None),
             ('Técnico', 'gobject.TYPE_BOOLEAN', False, True, False, None),
             ('Comercial', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('D. General', 'gobject.TYPE_BOOLEAN', 
                 False, True, False, None),
             ('id', 'gobject.TYPE_STRING', False, False, False, None))
     utils.preparar_listview(self.wids['tv_datos'], cols)
     self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
     self.colorear(self.wids['tv_datos'])
     temp = time.localtime()
     self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
     self.inicio = self.fin - datetime.timedelta(days = 4 * 7)
     self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
     self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
     sens = (self.usuario == None 
             or self.usuario.firmaUsuario 
             or self.usuario.firmaComercial 
             # or self.usuario.firmaTecnico 
             or self.usuario.firmaDirector 
             or self.usuario.firmaTotal)
     self.wids['b_pendientes'].set_sensitive(sens)
     self.wids['b_pendientes'].child.child.get_children()[1].set_text("Ver pendientes de mi firma (%s)" % (self.usuario and self.usuario.usuario or "cualquiera"))
     gtk.main()
コード例 #29
0
 def rellenar_muestras(self):
     """
     Rellena el TreeView de las muestras extraídas a la partida.
     """
     model = self.wids['tv_muestras'].get_model()
     model.clear()
     if self.partida != None:
         for m in self.partida.muestras:
             model.append((m.codigo, m.observaciones, m.pendiente, 
                           utils.str_fecha(m.envio), 
                           utils.str_fecha(m.recepcion), m.id))
コード例 #30
0
def cambiar_fecha(entry, padre = None):
    """
    Cambia el texto del entry por la fecha seleccionada en un diálogo 
    centrado en la ventana "padre".
    """
    try:
        entry.set_text(utils.str_fecha(utils.mostrar_calendario(
            fecha_defecto = utils.parse_fecha(entry.get_text()), 
            padre = padre)))
    except:     # Probablemente fecha mal formada, 
                # pero me curo en salud y capturo todas.
        entry.set_text(utils.str_fecha(utils.mostrar_calendario(padre=padre)))