Beispiel #1
0
 def imprimir(self, boton):
     """
     Genera un PDF con los datos en pantalla.
     """
     try:
         tv = self.wids['tv_datos']
     except KeyError:
         return  # No es ventana estándar. Quien me herede, que redefina.
     titulo = self.wids['ventana'].get_title()
     from utils.treeview2pdf import treeview2pdf
     from utils.informes import abrir_pdf
     strfini = self.wids['e_fini'].get_text()
     strffin = self.wids['e_ffin'].get_text()
     if strfini and strfin:
         strfecha = "%s - %s" % (strfini, strffin)
     elif not strfini and strffin:
         strfecha = "Hasta %s" % (strffin)
     elif strfini and not strffin:
         strfecha = "Desde %s" % (strfini)
     else:
         strfecha = None
     nomarchivo = treeview2pdf(tv, 
         titulo = titulo,
         fecha = strfecha)
     abrir_pdf(nomarchivo)
def abrir_hoja_de_ruta(laborante, dia):
    """
    Genera y abre un PDF con la hoja de ruta del laborante para el día 
    recibido.
    """
    from reports import hoja_de_ruta
    from utils.informes import abrir_pdf 
    peticiones = laborante.get_peticiones(dia)
    pdf_hoja_ruta = hoja_de_ruta.hoja_ruta(laborante, peticiones)
    abrir_pdf(pdf_hoja_ruta)
Beispiel #3
0
 def imprimir(self, boton):
     """
     Genera y abre un documento imprimible a partir de la factura. 
     """
     if not self.objeto.obra:
         utils.ui.dialogo_info(titulo = "SELECCIONE CLIENTE", 
             texto = "Debe seleccionar una obra para la factura.", 
             padre = self.wids['ventana'])
     if not self.objeto.obra.cliente:
         utils.ui.dialogo_info(titulo = "SELECCIONE CLIENTE", 
             texto = "La obra debe estar asignada a un cliente.", 
             padre = self.wids['ventana'])
     else:
         if not self.objeto.formaDePago:
             formas_de_pago = [(f.puid, f.get_info()) for f in 
                               pclases.FormaDePago.select(orderBy = "id")]
             fdp_puid = utils.ui.dialogo_radio(
                 titulo = "SELECCIONE FORMA DE PAGO", 
                 texto = "Debe seleccionar una forma de pago para la "
                         "factura.", 
                 padre = self.wids['ventana'], 
                 ops = formas_de_pago)
             if fdp_puid:
                 fdp = pclases.getObjetoPUID(fdp_puid)
                 self.objeto.formaDePago = fdp
                 self.objeto.syncUpdate()
                 self.objeto.retencion = fdp.retencion
                 self.actualizar_ventana()
                 # FIXME: No sé por qué todavía, pero hay que actualizar 
                 # dos veces la ventana para que el importe de la retención 
                 # sea correcto, si no le asigna lo mismo que al resto de 
                 # vencimientos.
                 self.actualizar_ventana()
             else:
                 return
         pdf_fra = imprimir_factura(self.objeto)
         if pdf_fra:
             abrir_pdf(pdf_fra)
         else:
             utils.dialogo_info(titulo = "ERROR IMPRESIÓN", 
                 texto = "Ocurrió un error al generar la copia"
                         " impresa de la factura.", 
                 padre = self.wids['ventana'])
Beispiel #4
0
 def imprimir(self, boton):
     from utils.informes import abrir_pdf
     from reports.simple import simple
     lineas = []
     if self.objeto != None:
         for colname in self.clase.sqlmeta.columns:
             col = self.clase.sqlmeta.columns[colname]
             valor_objeto = getattr(self.objeto, col.name)
             lineas.append("{0}: {1}".format(colname, valor_objeto))
         lineas.append("\n")
         for pago in self.objeto.pagos:
             lineas.append("\t * " + pago.get_info())
         for cobro in self.objeto.cobros:
             lineas.append("\t * " + cobro.get_info())
     texto = "\n".join(lineas)
     filepdf = simple(texto, 
                      titulo = self.wids['ventana'].get_title(), 
                      basefilename = self.clase.__name__, 
                      watermark = "PRUEBA - BORRADOR")   # TODO: Cambiar cuando haga algo más decente.
     abrir_pdf(filepdf)
Beispiel #5
0
def probar():
    """
    Test
    """
    from gtk import TreeView
    from utils.ui import preparar_listview
    from random import randint, randrange
    from string import letters
    import datetime
    tv = TreeView()
    preparar_listview(tv, 
        (("Cadena", "gobject.TYPE_STRING", False, True, True, None), 
         ("Entero", "gobject.TYPE_INT", False, True, False, None), 
         ("PUID", "gobject.TYPE_STRING", False, False, False, None)))
    for i in range(randint(10, 100)):
        tv.get_model().append(("".join([letters[randrange(len(letters))] 
                                        for i in range(randint(5,11))]), 
                               randint(0, 1000),
                               ""))
    titulo = "Test"
    fecha = datetime.date.today()
    nomarchivo = treeview2pdf(tv, titulo, fecha)
    if nomarchivo:
        abrir_pdf(nomarchivo)
Beispiel #6
0
    def facturar_pendiente(self, boton = None):
        """
        Busca todos los resultados de laboratorio no facturados, los agrupa 
        por mes, crea una factura por cada uno de ellos y obra y las "imprime".
        """
        # TODO: PORASQUI: No lo está haciendo bien. Después del cambio para 
        # poder facturar por informes, se hacen bien las facturas.
        # Informes no facturados:
        informes = pclases.Informe.select(
            pclases.Informe.q.lineaDeVentaID == None)
        _resultados = []
        for i in informes:
            for r in i.resultados:
                _resultados.append(r)
        #_resultados = pclases.Resultado.select(
        #    pclases.Resultado.q.lineaDeVenta == None)
        # Ahora filtro los del cliente y clasifico:
        resultados = {}
        for r in _resultados:
            if r.cliente == self.objeto:
                obra = r.obra
                if obra not in resultados:
                    resultados[obra] = {}
                mes = r.fecha.month
                if mes not in resultados[obra]:
                    resultados[obra][mes] = {}
                ensayo = r.ensayo
                try:
                    resultados[obra][mes][ensayo].append(r)
                except KeyError:
                    resultados[obra][mes][ensayo] = [r]
        if not resultados:
            utils.ui.dialogo_info(titulo = "NADA PENDIENTE", 
                texto = "El cliente no tiene nada pendiente que facturar.", 
                padre = self.wids['ventana'])
        else:
            ver_facturas_en_pantalla = utils.ui.dialogo(
                titulo = "¿VER FACTURAS?", 
                texto = "¿Desea repasar las facturas antes de imprimirlas?", 
                padre = self.wids['ventana'])
        # Genero las facturas... si es que hay resultados.
        for obra in resultados:
            for mes in resultados[obra]:  
                                    # TODO: Debería tener en cuenta el día 
                                    # de pago del cliente para meter en el mes
                                    # siguiente los resultados que se pasaran 
                                    # de esa fecha y generar la factura con 
                                    # esa fecha.
                try:
                    tipo = pclases.TipoFactura.selectBy(nombre="servicios")[0]
                except IndexError:
                    tipo = None
                serie_numerica = obra.cliente.serieNumerica
                fecha = datetime.date.today()
                fdp = obra.formaDePago
                try:
                    retencion = fdp.retencion
                except AttributeError:
                    retencion = 0.0
                numfactura = serie_numerica.get_next_numfactura(commit = True)
                f = pclases.FacturaVenta(
                        tipoFactura = tipo, 
                        obra = obra, 
                        serieNumerica = serie_numerica,  
                        formaDePago = fdp, 
                        numfactura = numfactura, 
                        fecha = fecha, 
                        retencion = retencion, 
                        observaciones = "Factura correspondiente a los "
                            "servicios prestados en el mes de {0}.".format(
                                fecha.strftime("%B"))
                        )

                # ... y las líneas de venta
                for ensayo in resultados[obra][mes]:
                    precio = ensayo.precio
                    cantidad = len(resultados[obra][mes][ensayo])
                    ldv = pclases.LineaDeVenta(
                            producto = None, 
                            facturaVenta = f, 
                            cantidad = cantidad, 
                            precio = precio, 
                            descuento = 0.0, 
                            iva = self.objeto.iva, 
                            descripcion = ensayo.get_info())
                    # Asocio los resultados a la LDV para que se queden 
                    # marcados como facturados:
                    for resultado in resultados[obra][mes][ensayo]:
                        resultado.lineaDeVenta = ldv
                        resultado.syncUpdate()
                        # Y las muestras, ensayos e informes para que se 
                        # vean después en la ventana de facturas de venta.
                        resultado.informe.lineaDeVenta = ldv
                        resultado.informe.syncUpdate()
                # Vencimientos:
                f.crear_vencimientos()
                # Abro las facturas... si quiere el usuario, claro.
                if ver_facturas_en_pantalla:
                    from formularios import facturas_venta
                    v = facturas_venta.FacturasVenta(objeto = f, 
                                                 usuario = self.get_usuario(), 
                                                 run = True)
                else:
                    # ... y las "imprimo":
                    from informes import factura_multipag
                    fpdf = factura_multipag.go_from_facturaVenta(f)
                    abrir_pdf(fpdf)
Beispiel #7
0
 def imprimir(self, boton):
     abrir_pdf(pedido(self.objeto))
Beispiel #8
0
    basefilename += "".join([i[0].lower() 
                             for i in laborante.get_nombre_completo().split()])
    nomarchivo = gettempfilename(basefilename)
    peticiones = clasificar_peticiones(peticiones)
    nomarchivo = go(nomarchivo, 
                    laborante, 
                    peticiones, 
                    "Hoja de ruta - {0}".format(
                        laborante.get_nombre_completo()))
    return nomarchivo

def clasificar_peticiones(ps):
    res = {}
    for p in ps:
        fecha = p.fechaRecogida
        try:
            res[fecha].append(p)
        except KeyError:
            res[fecha] = [p]
    for fecha in res:
        res[fecha].sort(key = lambda p: p.horaRecogida)
    return res


if __name__ == "__main__":
    from utils.informes import abrir_pdf
    from __init__ import * 
    abrir_pdf(hoja_ruta(pclases.Empleado.select()[0], 
                        pclases.Peticion.select()[:5]))