예제 #1
0
파일: ausencias.py 프로젝트: pacoqueen/ginn
 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
             if isinstance(fechaintermedia, datetime.date):
                 fechaintermedia += datetime.timedelta(1)
             else:
                 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)
 def imprimir(self, boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     from formularios import reports
     from informes.treeview2pdf import treeview2pdf
     tv = self.wids['tv_datos']
     titulo = "Ofertas"
     totales = [6]
     extra_data = []
     if self.inicio:
         titulo += " desde %s" % utils.str_fecha(self.inicio)
     if self.fin:
         titulo += " hasta %s" % utils.str_fecha(self.fin)
     #import tempfile 
     #ruta_grafico = tempfile.NamedTemporaryFile(suffix = ".png").name
     #win = self.wids['eventbox_chart'].window
     #ancho, alto = win.get_size()
     #pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, ancho, alto)
     #captura = pb.get_from_drawable(win, win.get_colormap(), 0, 0, 0, 0, 
     #                               ancho, alto)
     # Por algún motivo, que tendrá que ver con los dpi, ppp o cualquiera 
     # sabe qué complejo cálculo gráfico, la imagen sale muy grande en el 
     # PDF. La reduzco cutremente:
     #escalado = captura.scale_simple(int(ancho * 0.75), int(alto * 0.75), 
     #                                gtk.gdk.INTERP_TILES)
     #escalado.save(ruta_grafico, "png")
     reports.abrir_pdf(treeview2pdf(tv, 
                                    titulo = titulo, 
                                    numcols_a_totalizar = totales, 
                                    #graficos = [ruta_grafico], 
                                    extra_data = extra_data))
예제 #3
0
    def rellenar_tabla(self, filtro=None):
        " Rellena el model con los items de la consulta. """
        facturas = pclases.FacturaVenta.select(orderBy='fecha')

        model = self.wids['tv_datos'].get_model()
        model.clear()
        for factura in facturas:
            if filtro == factura.estado():
                continue
            if factura.estado() == "No enviado":
                pdf = "factura_" + factura.numfactura.__str__()
                pdf.replace("/", "_")
                if (factura.cliente.email and enviar_correo("Factura",
                        factura.cliente.email, "Texto de prueba", [pdf])):
                    factura.observaciones = "Correo enviado"
            importe = factura.calcular_importe_total(iva=True)
            model.append((factura.id,
                    factura.numfactura,
                    factura.cliente.nombre,
                    utils.str_fecha(factura.fecha),
                    #utils.float2str(importe),
                    str(importe),
                    factura.estado(),#TODO "Pagado o no pagado
                    utils.str_fecha(factura.fecha_vencimiento()),
                    utils.str_fecha(factura.fecha_pago()),
                    factura.id))
        self.colorear(self.wids['tv_datos'])
예제 #4
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     from formularios import reports
     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 != []:
         reports.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))
    def imprimir(self, boton):
        """
        Prepara la vista preliminar para la impresión del informe
        """
        from formularios import reports

        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 != []:
            reports.abrir_pdf(geninformes.laboratorioPartidas(datos, fechaInforme))
 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()
예제 #7
0
파일: recibos.py 프로젝트: pacoqueen/ginn
 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
예제 #8
0
 def inicializar_ventana(self):
     """
     Inicializa los controles de la ventana, estableciendo sus
     valores por defecto, deshabilitando los innecesarios,
     rellenando los combos, formateando el TreeView -si lo hay-...
     """
     # Inicialmente no se muestra NADA. Sólo se le deja al
     # usuario la opción de buscar o crear nuevo.
     self.activar_widgets(False)
     # Inicialización del resto de widgets:
     camps = [(c.id, "%s - %s" % (utils.str_fecha(c.fechaInicio), 
                                  utils.str_fecha(c.fechaFin)))
              for c in pclases.Campanna.select(orderBy = "fechaInicio")]
     utils.rellenar_lista(self.wids['cb_campanna'], camps)
     self.wids['b_guardar'] = gtk.Button("N/A")
     self.wids['b_guardar'].set_property("visible", False)
     self.wids['b_guardar'].set_sensitive(False)
     i = -1
     anno_actual = mx.DateTime.localtime().year
     model = self.wids['cb_campanna'].get_model()
     for i in range(len(model)):
         if str(anno_actual) in model[i][1]:
             break
         # Y si el año no está, se queda en la última campaña.
     self.wids['cb_campanna'].set_active(i)
예제 #9
0
 def __init__(self, objeto = None, usuario = None):
     Ventana.__init__(self, 'consulta_beneficio.glade', objeto, usuario = usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar,
                    '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 = mx.DateTime.localtime()
     self.inicio = mx.DateTime.DateTimeFrom(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()
예제 #10
0
 def imprimir(self, boton):
     """
     Crea un PDF con el contenido del TreeView.
     """
     datos = []
     model = self.wids['tv_rollos'].get_model()
     for i in model:
         pas = pclases.AlbaranSalida
         if i[4] == "-" or pas.str_tipos[pas.MOVIMIENTO] in i[4]:
             en_almacen = i[6]
         else:
             en_almacen = ""
         if (  (self.wids['ch_filtrar'].get_active() 
                and i[4] == "-" 
                or pas.str_tipos[pas.MOVIMIENTO] in i[4]) 
             or 
               (not self.wids['ch_filtrar'].get_active())):
             datos.append((i[0], i[1], i[3], i[4], en_almacen, i[5]))
     datos.append(("---", ) * 6)
     datos.append(("Total almacén (no defectuosos):", self.wids['e_total_almacen'].get_text(), "Total fabricado (incluye defectuosos):", self.wids['e_total_fabricado'].get_text(), ""))
     if not self.inicio:
         fechaInforme = 'Hasta: %s' % (utils.str_fecha(self.fin))
     else:
         fechaInforme = utils.str_fecha(self.inicio) + ' - ' + utils.str_fecha(self.fin)
     if datos != []:
         desc_producto = self.wids['e_descripcion'].get_text()
         listado_pdf = geninformes.listado_rollos(datos, desc_producto,
                                                  fechaInforme)
         from formularios import reports
         reports.abrir_pdf(listado_pdf)
예제 #11
0
 def __init__(self, objeto = None, usuario = None):
     self.usuario = usuario
     Ventana.__init__(self, 'consulta_ventas_ticket.glade', objeto, usuario = usuario)
     connections = {'b_salir/clicked': self.salir,
                    'b_buscar/clicked': self.buscar,
                    'b_imprimir/clicked': self.imprimir,
                    'b_exportar/clicked': self.exportar,
                    '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 = 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))
     self.wids['hbox1'].set_property("visible", False)
     self.wids['hbox6'].set_property("visible", False)
     gtk.main()
예제 #12
0
 def imprimir(self, boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     from informes.treeview2pdf import treeview2pdf
     from formularios.reports 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 not self.inicio:            
             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)
예제 #13
0
 def rellenar_facturas(self):
     """
     Rellena el model con las facturas no bloqueadas.
     """        
     model = self.wids['tv_facturas'].get_model()
     model.clear()
     self.wids['tv_facturas'].freeze_child_notify()
     self.wids['tv_facturas'].set_model(None)
     vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     facturas = pclases.FacturaVenta.select(
             pclases.FacturaVenta.q.bloqueada == False, orderBy = "id")
     prefacturas = pclases.Prefactura.select(
             pclases.Prefactura.q.bloqueada == False, orderBy = "id")
     tot = facturas.count() + prefacturas.count()
     for factura in facturas:
         vpro.set_valor(i/tot, 
                        'Recuperando factura %s...' % (factura.numfactura))
         i += 1
         if factura.vencimientosCobro == []:
             motivo = "Sin vencimientos."
         elif (factura.cliente.cif == None 
                 or factura.cliente.cif.strip() == ""):
             motivo = "Cliente sin CIF."
         else:
             motivo = "Factura no bloqueada."
         model.append((factura.numfactura,
                       utils.str_fecha(factura.fecha),
                       factura.cliente and factura.cliente.nombre or "-",
                       "%s €" % (utils.float2str(factura.calcular_total())),
                       ", ".join([a.numalbaran 
                                  for a in factura.get_albaranes()]),
                       factura.bloqueada,
                       motivo,
                       factura.id))
     for factura in prefacturas:
         vpro.set_valor(i/tot, 
                        'Recuperando factura %s...' % (factura.numfactura))
         i += 1
         if factura.vencimientosCobro == []:
             motivo = "Sin vencimientos."
         elif (factura.cliente.cif == None 
                 or factura.cliente.cif.strip() == ""):
             motivo = "Cliente sin CIF."
         else:
             motivo = "Factura no bloqueada."
         model.append(
             (factura.numfactura,
              utils.str_fecha(factura.fecha),
              factura.cliente and factura.cliente.nombre or "-",
              "%s €" % (utils.float2str(factura.calcular_total())), 
              ", ".join([a.numalbaran for a in factura.get_albaranes()]),
              factura.bloqueada,
              motivo,
              factura.id))
     self.wids['tv_facturas'].set_model(model)
     self.wids['tv_facturas'].thaw_child_notify()
     vpro.ocultar()
예제 #14
0
 def __init__(self, objeto=None, usuario=None):
     self.usuario = usuario
     Ventana.__init__(self, "consulta_ventas_por_producto.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,
         "e_fechainicio/focus-out-event": act_fecha,
         "e_fechafin/focus-out-event": act_fecha,
         "b_map/clicked": self.exportar_a_html,
     }
     self.add_connections(connections)
     # TreeViews de fibra y cemento
     cols = [
         ("Producto", "gobject.TYPE_STRING", False, True, True, None),
         ("kg A", "gobject.TYPE_STRING", False, True, False, None),
         ("# A", "gobject.TYPE_STRING", False, True, False, None),
         ("kg B", "gobject.TYPE_STRING", False, True, False, None),
         ("# B", "gobject.TYPE_STRING", False, True, False, None),
         ("kg C", "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),
     ]
     for tv in (self.wids["tv_fibra"], self.wids["tv_cem"]):
         utils.preparar_treeview(tv, cols)
         tv.connect("row-activated", self.abrir_producto_albaran_o_abono)
         for n in range(1, 9):
             tv.get_column(n).get_cell_renderers()[0].set_property("xalign", 1)
     # TreeView de geotextiles
     cols.insert(1, ("m² A", "gobject.TYPE_STRING", False, True, False, None))
     cols.insert(4, ("m² B", "gobject.TYPE_STRING", False, True, False, None))
     cols.insert(7, ("m² C", "gobject.TYPE_STRING", False, True, False, None))
     cols.insert(10, ("Total m²", "gobject.TYPE_STRING", False, True, False, None))
     utils.preparar_treeview(self.wids["tv_gtx"], cols)
     self.wids["tv_gtx"].connect("row-activated", self.abrir_producto_albaran_o_abono)
     tv = self.wids["tv_gtx"]
     for n in range(1, 13):
         tv.get_column(n).get_cell_renderers()[0].set_property("xalign", 1)
     # TreeView de otros
     cols = [
         ("Producto", "gobject.TYPE_STRING", False, True, True, None),
         ("Cantidad", "gobject.TYPE_STRING", False, True, False, None),
         ("PUID", "gobject.TYPE_STRING", False, False, False, None),
     ]
     utils.preparar_treeview(self.wids["tv_otros"], cols)
     self.wids["tv_otros"].connect("row-activated", self.abrir_producto_albaran_o_abono)
     tv = self.wids["tv_otros"]
     tv.get_column(1).get_cell_renderers()[0].set_property("xalign", 1)
     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()
예제 #15
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
예제 #16
0
 def enviar_correo_visitas_confirmadas(self, confirmadas = []):
     """
     Igual que en ofertas, se envía un correo a quien corresponde con el
     resumen del día, destacando las recién confirmadas.
     """
     dests = select_correo_validador(self.usuario,
                                     copia_a_dircomercial = True)
     if not isinstance(dests, (list, tuple)):
         dests = [dests]
     servidor = self.usuario.smtpserver
     smtpuser = self.usuario.smtpuser
     smtppass = self.usuario.smtppassword
     rte = self.usuario.email
     year, month, day = self.wids['calendario'].get_date()
     fecha = datetime.date(year = year, month = month, day = day)
     texto = "Resumen de visitas de %s para el día %s:\n\n" % (
                     self.objeto.get_nombre_completo(),
                     utils.str_fecha(fecha))
     # TODO: Empepinar el correo usando una tabla HTML. No es tan difícil.
     for row in self.wids['tv_visitas'].get_model():
         visita = pclases.getObjetoPUID(row[-1])
         if not visita.enviada:
             continue
         texto += "%s%s\t%s%s\t%s\t%s\t%s%s\n" % (
                 visita in confirmadas and "*" or "",
                 utils.str_hora_corta(visita.fechahora),
                 visita.nombrecliente,
                 visita.cliente and "" or " (+)",
                 visita.lugar and visita.lugar or "",
                 visita.motivoVisita and visita.motivoVisita.motivo or "",
                 visita.observaciones,
                 visita in confirmadas and "*" or ""
                 )
     ok = utils.enviar_correoe(rte,
                               dests,
                               "Parte de visitas confirmado (%s)" 
                                 % utils.str_fecha(fecha),
                               texto,
                               servidor = servidor,
                               usuario = smtpuser,
                               password = smtppass)
     if ok:
         self.to_log(
             "Usuario %s envió correo de confirmación de visitas "
             "para el día %s."
                 % (self.usuario and self.usuario.usuario or "¡NADIE!",
                    utils.str_fecha(fecha)),
             nivel = 3)  # info
     else:
         self.to_log(
             "Falló envío de correo de solicitud de validación de la "
             "oferta %s del usuario %s."
                 % (utils.str_fecha(fecha),
                    self.usuario and self.usuario.usuario or "¡NADIE!"),
             nivel = 1)  # error
예제 #17
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
예제 #18
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))
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, mx.DateTime.RangeError, 
                # pero me curo en salud y capturo todas.
        entry.set_text(utils.str_fecha(utils.mostrar_calendario(padre=padre)))
예제 #20
0
파일: parcelas.py 프로젝트: Virako/fpinn
 def rellenar_cultivos(self):
     model = self.wids['tv_cultivos'].get_model()
     model.clear()
     for p in self.objeto.cultivos:
         model.append((p.cultivo, 
                       p.variedad, 
                       utils.str_fecha(p.siembra), 
                       utils.str_fecha(p.recoleccionInicio), 
                       utils.str_fecha(p.recoleccionFin), 
                       p.hidroponico, 
                       p.tradicional, 
                       p.id))
예제 #21
0
 def rellenar_partes(self):
     """
     Rellena el model con los partes no bloqueados.
     """
     model = self.wids['tv_partes'].get_model()
     # Primero verifico los que ya estaban (si es que había alguno):
     for fila in model:
         idparte = fila[-1]
         try:
             pdp = pclases.ParteDeProduccion.get(idparte)
         except pclases.SQLObjectNotFound:
             continue    # El parte se ha borrado entre actualización y 
                         # actualización de la ventana.
         pdp.sync()  # ¿Hay algún cambio pendiente de rescatar en local?
         if pdp.se_solapa():
             self.logger.warning("%spartes_no_bloqueados::rellenar_partes"
                 " -> El parte ID %d se solapa con otros de la misma línea."
                 "Si estaba verificado, lo desbloqueo para que se vuelva a"
                 " revisar." % (self.usuario 
                     and self.usuario.usuario + ": " or "", pdp.id))
             pdp.bloqueado = False
     # Y ahora meto los de la consulta real:
     model.clear()
     self.wids['tv_partes'].freeze_child_notify()
     self.wids['tv_partes'].set_model(None)
     vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     partes = pclases.ParteDeProduccion.select(
         pclases.ParteDeProduccion.q.bloqueado == False, orderBy = "id")
     tot = partes.count()
     for parte in partes:
         vpro.set_valor(i/tot, 'Recuperando parte %s' 
             % utils.str_fecha(parte.fecha))
         parte.sync()    # ¿Algún cambio en la BD no rescatado en local?
         i += 1
         lotepartida = "CLIC PARA VER"
         if (self.wids['rb_todos'].get_active() or 
            (self.wids['rb_balas'].get_active() and parte.es_de_balas()) or 
            (self.wids['rb_rollos'].get_active() and parte.es_de_rollos()) 
             or self.wids['rb_bolsas'].get_active() and parte.es_de_bolsas()
            ):
             model.append(("CLIC PARA VER",
                           utils.str_fecha(parte.fecha),
                           parte.horainicio.strftime('%H:%M'),
                           parte.horafin.strftime('%H:%M'),
                           parte.bloqueado,
                           lotepartida,
                           parte.id))
     self.wids['tv_partes'].set_model(model)
     self.wids['tv_partes'].thaw_child_notify()
     vpro.ocultar()
예제 #22
0
 def __init__(self, objeto = None, usuario = None, gui = True):
     """
     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).
     Si `gui` es True, tira de Gtk para preguntar, exportar y abrir los 
     PDF. En otro caso devuelve los nombres de fichero por salida estándar.
     """
     if gui:
         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
     else:
         csv = False
         ruta_csv = None
     ruta_pdf = geninformes.existencias_productos(
         'rollos', 
         "%s, %s" % (utils.str_fecha(time.localtime()), 
                     time.strftime("%H:%M")), 
         ruta_csv = ruta_csv)
     self.fich_generados = [ruta_pdf]
     if gui:
         from formularios import reports
         reports.abrir_pdf(ruta_pdf)
     if pclases.Almacen.select(pclases.Almacen.q.activo==True).count() > 1:
         for a in pclases.Almacen.select(pclases.Almacen.q.activo == True):
             if csv:
                 ruta_csv = tempfile.NamedTemporaryFile(
                     suffix = "_%s.csv" % a.nombre, 
                     delete = False).name
             ruta_pdf = geninformes.existencias_productos('rollos', 
                     "%s, %s" % (
                         utils.str_fecha(time.localtime()), 
                         time.strftime("%H:%M")), 
                     almacen = a, 
                     ruta_csv = ruta_csv)
             self.fich_generados.append(ruta_pdf)
             if gui: 
                 reports.abrir_pdf(ruta_pdf)
     if not gui:
         try:
             sys.stdout.write("\n".join(self.fich_generados))
             sys.stdout.write("\n")
         except IOError:
             pass    # No tengo salida estándar.
 def agregar_factura_de_abono(self, f, model, total, vencido):
     vtos = []
     vtos_emparejados = f.emparejar_vencimientos()
     for vto in vtos_emparejados['vtos']:
         try:
             cobro = vtos_emparejados[vto][0]
         except IndexError:
             cobro = None
         vtos.append([vto, None, cobro])
         # OJO: A diferencia que con el emparejar_vencimientos de pclases.FacturaCompra, no debería haber más de un 
         # cobro por vencimiento en los abonos ni haber cobros sin vencimientos (clave None del diccionario), ya 
         # que los vencimientos son ficticios, no se corresponden con ningún registro de la BD (es una clase "closured") 
         # y se crean sobre la marcha en la función. Como tampoco se permite asociar una misma factura de abono a más 
         # de un cobro (bien en factura o bien en pagaré), nunca habrá más de un "vencimiento" por abono.
     # XXX: Hasta aquí lo que hace el preparar_vencimientos con las facturasVenta. Ahora a agregarlo al TreeView.
     vtos = [v for v in vtos if (v[2]==None or (v[2].pagareCobro != None and v[2].pagareCobro.pendiente)) and v[0] != None]
         # Todos los que no tienen pagaré o si lo tienen, que esté pendiente
         # y los que sean realmente vencimientos (hay entradas en vtos que pueden tener v[0] a None).
     for v in vtos:
         if v[2]!=None and v[2].pagareCobro!=None:
             pagare = v[2].pagareCobro
         else:
             pagare = None
         fechavto = pagare and pagare.fechaCobro or v[0].fecha   # Fecha del vencimiento final: la del vencimiento de la factura
                                                                 # si no tiene pagaré o la del vencimiento del pagaré que cubre
                                                                 # el vencimiento de la factura.
         mes = utils.corregir_nombres_fecha(fechavto.strftime("%B '%y"))
         primero_mes = mx.DateTime.DateTimeFrom(day = 1, month = fechavto.month, year = fechavto.year)
         try:
             rowpadre = [r for r in model if r[2] == mes][0]
             padre = rowpadre.iter
         except IndexError:
             padre = model.append(None, ("", utils.str_fecha(primero_mes), mes, 0.0, "", "", 0))
         factura = v[0].get_factura_o_prefactura()
         model.append(padre, ("%s (%s)" % (factura.numfactura, factura.cliente and factura.cliente.nombre or "Sin cliente"), 
                              utils.str_fecha(factura.fecha), 
                              utils.str_fecha(v[0].fecha),
                              v[0].importe,
                              pagare and "%s (%s)" % (pagare.codigo, utils.str_fecha(pagare.fechaRecepcion)) or '',
                              pagare and utils.str_fecha(pagare.fechaCobro) or '',
                              pagare and pagare.id or v[0].id)
                      )
         total += v[0].importe
         model[padre][3] += v[0].importe
         if pagare:
             if pagare.fechaCobro <= mx.DateTime.localtime():
                 vencido += v[0].importe
         else:
             if v[0].fecha <= mx.DateTime.localtime():
                 vencido += v[0].importe
         # NOTA: Si la fecha del vencimiento ha vencido pero la del pagaré no, no la cuento como pendiente.
     return total, vencido
예제 #24
0
파일: iva.py 프로젝트: pacoqueen/ginn
 def set_fecha(self, boton):
     """
     Muestra el diálogo de selección de fecha en calendario.
     """
     if "inicio" in boton.name:
         e = self.wids['e_fecha_inicio']
     elif "fin" in boton.name:
         e = self.wids['e_fecha_fin']
     else:
         return
     try:
         e.set_text(utils.str_fecha(utils.mostrar_calendario(e.get_text(), self.wids['ventana'])))
     except:
         e.set_text(utils.str_fecha(utils.mostrar_calendario(padre = self.wids['ventana'])))
예제 #25
0
파일: remesas.py 프로젝트: pacoqueen/ginn
 def add_efecto(self, boton):
     """
     Añade un pagaré o un confirming a la remesa, creando si hace falta 
     el efecto "intermedio".
     """
     efectos = []
     # TODO: Aquí falta una barra de progreso y/o pedir un criterio de 
     #       búsqueda. O bien abrir la ventana de consulta pero con un 
     #       botón añadir a una remesa existente en lugar de "Generar".
     for p in pclases.PagareCobro.select():
         if not p.remesado and p.esta_pendiente():
             if not p.efecto:
                 pclases.Efecto(pagareCobro = p, 
                                confirming = None, 
                                cuentaBancariaCliente = None)
             efecto = p.efecto
             efectos.append(efecto)
     # Los confirming no se envían en remesas. Solo pagarés.
     #for c in pclases.Confirming.select():
     #    if not c.remesado and c.esta_pendiente():
     #        if not c.efecto:
     #            pclases.Efecto(pagareCobro = None, 
     #                           confirming = c, 
     #                           cuentaBancariaCliente = None)
     #        efecto = c.efecto
     #        efectos.append(efecto)
     efectos = [(e.id, 
                 e. codigo, 
                 e.cliente and e.cliente.nombre or "", 
                 utils.float2str(e.cantidad), 
                 utils.str_fecha(e.fechaVencimiento), 
                 utils.str_fecha(e.fechaRecepcion), 
                 e.get_str_tipo())
                for e in efectos]
     idefectos = utils.dialogo_resultado(efectos, 
         titulo = "SELECCIONE EFECTOS DE COBRO", 
         texto = "Seleccione uno o varios efectos a incluir en la remesa.",  
         padre = self.wids['ventana'], 
         cabeceras = ["ID", "Código", "Cliente", "Importe", 
                      "Fecha de vencimiento", "Fecha de recepción", "Tipo"],
         multi = True)
     # FIXME: Ojo. No se hacen las comprobaciones de límite de 
     #        concentraciones, disponible, etc. Ni siquiera se indican 
     #        visualmente en la ventana los valores para ver si la remesa
     #        excede los límites aceptados por el banco.
     for idefecto in idefectos:
         efecto = pclases.Efecto.get(idefecto)
         self.objeto.addEfecto(efecto)
     if idefectos:
         self.actualizar_ventana()
예제 #26
0
 def imprimir(self, boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     from informes.treeview2pdf import treeview2pdf
     from formularios.reports import abrir_pdf
     if not self.inicio:
         fecha_informe = 'Hasta ' + utils.str_fecha(self.fin)
     else:
         fecha_informe = (utils.str_fecha(self.inicio)
                         + ' - '
                         + utils.str_fecha(self.fin))
     abrir_pdf(treeview2pdf(self.wids['tv_datos'],
                            titulo = "Consulta visitas realizadas",
                            fecha = fecha_informe))
예제 #27
0
파일: iva.py 프로젝트: pacoqueen/ginn
 def rellenar_tabla(self, fras):
     """
     Introduce las facturas recibidas en el TreeView y 
     calcula el total de IVA para las facturas de compra 
     y de venta por separado.
     """
     tv = self.wids['tv_datos']
     model = tv.get_model()
     tv.freeze_child_notify()
     tv.set_model(None)
     model.clear()
     devengado = 0.0
     soportado = 0.0
     base_devengado = 0.0
     for fra in fras:
         if isinstance(fra, pclases.FacturaVenta):
             iva = fra.calcular_total_iva()
             base_devengado += fra.calcular_base_imponible()
             devengado += iva
             fila = [utils.str_fecha(fra.fecha), 
                     "%s (%s)" % (fra.numfactura, 
                                  fra.cliente and fra.cliente.nombre or ""),
                     "%s €" % utils.float2str(fra.calcular_importe_total()), 
                     "%s €" % utils.float2str(iva), 
                     "", 
                     "", 
                     "", 
                     "FV:%d" % fra.id
                     ]
         elif isinstance(fra, pclases.FacturaCompra):
             iva = fra.calcular_importe_iva()
             soportado += iva
             fila = [utils.str_fecha(fra.fecha), 
                     "", 
                     "",
                     "", 
                     "%s (%s)" % (fra.numfactura, fra.proveedor and fra.proveedor.nombre or ""), 
                     "%s €" % utils.float2str(fra.calcular_importe_total()), 
                     "%s €" % utils.float2str(iva), 
                     "FC:%d" % fra.id
                     ]
         else:
             self.logger.error("iva::rellenar_tabla -> Factura %s no es FacturaVenta ni FacturaCompra." % fra)
             continue
         model.append(fila)
     tv.set_model(model)
     tv.thaw_child_notify()
     self.mostrar_totales(devengado, soportado, base_devengado)
 def imprimir(self, boton):
     """
     Crea un impreso del albarán
     """
     self.guardar(None)  # Si se ha olvidado guardar, guardo yo.
     from formularios import reports
     albaran = self.objeto
     if albaran.proveedor != None:
         proveedor = albaran.proveedor.nombre
     else:
         proveedor = ''
     pedidos = []
     lineas = []
     for l in albaran.lineasDeCompra:
         if l.pedidoCompra != None:
             numpedido = l.pedidoCompra.numpedido
         else:
             numpedido = '-'
         lineas.append({'codigo': l.productoCompra.codigo, 'descripcion': l.productoCompra.descripcion, 'cantidad': l.cantidad, 'numped': numpedido })
         if l.pedidoCompra != None and l.pedidoCompra.numpedido not in pedidos:
             pedidos.append(l.pedidoCompra.numpedido)
     cadenaPedidos = ','.join(pedidos)
     general = {'albnum':albaran.numalbaran, 
                'fecha':utils.str_fecha(albaran.fecha), 
                'proveedor':proveedor, 
                'pednum':cadenaPedidos}
     observaciones = utils.dialogo_entrada(titulo = 'OBSERVACIONES', 
                                           texto = '¿Desea incluir alguna observación en el albarán?', 
                                           padre = self.wids['ventana'])
     if observaciones == None:
         return
     reports.abrir_pdf(geninformes.albaranEntrada(general, lineas, observaciones))
 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()
예제 #30
0
 def add(self, w):
     if self.loteCem != None:
         model = self.wids['tv_pruebas'].get_model()
         model.append((utils.str_fecha(time.localtime()),
                       "", "", "", "", "", "", "0,0,0,0,0,0"))
     else:
         print "WARNING: Se ha intentano añadir una prueba con loteCem = None"