Exemplo n.º 1
0
 def mostrar_totales(self, devengado, soportado, base_devengado):
     """
     Muestra los totales, la diferencia de ambos y colorea los Entries.
     """
     # Base imponible de las facturas de venta. (Si trabajara con más IVAs debería haber una línea por cada tipo de IVA)
     self.wids['e_base_devengado'].set_text("%s €" % (utils.float2str(base_devengado, 2)))
     # Devengado
     self.wids['e_devengado'].set_text("%s €" % utils.float2str(devengado, 2))
     tips = gtk.Tooltips()
     tips.set_tip(self.wids['e_devengado'], str(devengado))
     tips.enable()
     self.wids['e_devengado'].modify_text(gtk.STATE_NORMAL, self.wids['e_devengado'].get_colormap().alloc_color("red"))
     # Soportado
     self.wids['e_soportado'].set_text("%s €" % utils.float2str(soportado, 2))
     tips = gtk.Tooltips()
     tips.set_tip(self.wids['e_soportado'], str(soportado))
     tips.enable()
     self.wids['e_soportado'].modify_text(gtk.STATE_NORMAL, self.wids['e_soportado'].get_colormap().alloc_color("blue"))
     # Diferencia
     diferencia = devengado - soportado
     self.wids['e_diferencia'].set_text("%s €" % utils.float2str(diferencia, 2))
     tips = gtk.Tooltips()
     tips.set_tip(self.wids['e_diferencia'], str(diferencia))
     tips.enable()
     if diferencia > 0:
         self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, self.wids['e_diferencia'].get_colormap().alloc_color("red"))
     else:
         self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, self.wids['e_diferencia'].get_colormap().alloc_color("blue"))
Exemplo n.º 2
0
def build_tabla_contenido(data):
    """
    Construye la tabla del contenido del albaranSalida.
    Los datos deben venir en listas. Cada línea de la tabla, una tupla o lista 
    con el código, descripción, cantidad, precio unitario (con dto. si lo 
    lleva e IVA) y número de pedido.
    El precio y cantidad deben ser flotantes para poder calcular el subtotal.
    """
    estilo_cabecera_tabla = ParagraphStyle("Cabecera tabla", 
                                           parent=estilos["Heading3"])
    estilo_cabecera_tabla.fontName = "Times-Bold"
    estilo_cabecera_tabla.alignment = enums.TA_CENTER
    estilo_numeros_tabla = ParagraphStyle("Números tabla", 
                                           parent=estilos["Normal"])
    estilo_numeros_tabla.alignment = enums.TA_RIGHT
    datos = [(Paragraph(escribe("Código"), estilo_cabecera_tabla), 
              Paragraph(escribe("Descripción"), estilo_cabecera_tabla), 
              Paragraph("Cantidad", estilo_cabecera_tabla), 
              Paragraph("Precio/U", estilo_cabecera_tabla), 
              #Paragraph("Total c/IVA", estilo_cabecera_tabla), 
              # CWT: Prefiere la carta de portes sin IVA.
              Paragraph("Total", estilo_cabecera_tabla), 
              Paragraph(escribe("Nº Pedido"), estilo_cabecera_tabla))
            ]
    for d in data:
        fila = (escribe(d[0]), 
                Paragraph(escribe(d[1]),estilos["Normal"]), 
                Paragraph(escribe(utils.float2str(d[2])),estilo_numeros_tabla),
                Paragraph(escribe(utils.float2str(d[3])),estilo_numeros_tabla),
                Paragraph(escribe(utils.float2str(d[2] * d[3])), 
                    estilo_numeros_tabla),
                escribe(d[4])
               )
        datos.append(fila)
    tabla = Table(datos, 
                  colWidths = (PAGE_WIDTH * 0.13, 
                               PAGE_WIDTH * 0.35, 
                               PAGE_WIDTH * 0.09, 
                               PAGE_WIDTH * 0.09, 
                               PAGE_WIDTH * 0.13, 
                               PAGE_WIDTH * 0.11), 
                  repeatRows = 1)
    tabla.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), colors.lightgrey), 
        ("LINEBEFORE", (0, 0), (-1, -1), 0.25, colors.black),
        ("LINEBELOW", (0, 0), (-1, 0), 1.0, colors.black), 
        ("LINEBELOW", (0, "splitlast"), (-1, "splitlast"), 1.0, colors.black), 
        ("BOX", (0, 0), (-1, -1), 1.0, colors.black),
        ("INNERGRID", (0, 0), (-1, -1), 0.25, colors.black), 
        ("VALIGN", (0, 0), (-1, 0), "CENTER"), 
        ("VALIGN", (0, 0), (0, -1), "TOP"), 
        ("ALIGN", (0, 0), (-1, 0), "CENTER"), 
        ("ALIGN", (-3, 1), (-1, -1), "RIGHT"), 
        #("ALIGN", (0, 1), (0, -1), "DECIMAL"), <- No puedo cambiar 
        #                               el pivotChar de "." a ",". No me vale.
        ("ALIGN", (-1, 1), (-1, -1), "CENTER"), 
        ("ALIGN", (0, 1), (0, -1), "CENTER"), 
        #("RIGHTPADDING", (0, 1), (0, -1), 0.75 * cm), 
        ]))
    return tabla
Exemplo n.º 3
0
 def rellenar_tabla(self, tabla):
     """
     Rellena el model con las ldc existentes
     """
     albaran = self.objeto
     if albaran != None:
         lineas = albaran.lineasDeCompra
         try:
             lineas.sort(lambda l1, l2: l1.id - l2.id)
         except:
             pass
         model = self.wids['tv_ldvs'].get_model()
         model.clear()
         for l in lineas:
             model.append((l.productoCompra.codigo,
                           l.productoCompra.descripcion,
                           utils.float2str(l.cantidad, 2),
                           utils.float2str(l.precio, 4, autodec = True),
                           "%s %%" % (utils.float2str(l.iva * 100, 0)),
                           "%s %%" % (utils.float2str(l.descuento*100, 0)),
                           utils.float2str(l.get_subtotal(iva = True)),
                           l.silo and l.silo.nombre or "",
                           l.pedidoCompra
                             and l.pedidoCompra.numpedido or "",
                           l.pedidoCompra
                             and utils.str_fecha(l.pedidoCompra.fecha)
                             or "",
                           l.id))
Exemplo n.º 4
0
def valorar_a_precio_valoracion(tv):
    """
    Valora todos los productos de compra con existencias distintas a cero 
    (OJO: Incluye existencias negativas) según el precio de valoración 
    definido (precio por defecto, precio medio ponderado, etc.).
    """
    pcs = pclases.ProductoCompra.select(pclases.AND(
            pclases.ProductoCompra.q.controlExistencias == True, 
            pclases.ProductoCompra.q.obsoleto == False,
            pclases.ProductoCompra.q.existencias != 0))
    model = tv.get_model()
    tv.freeze_child_notify()
    tv.set_model(None)
    model.clear()
    suma = 0.0
    for pc in pcs:
        precio_valoracion = pc.get_precio_valoracion()
        valoracion = precio_valoracion * pc.existencias
        model.append((pc.codigo, 
                      pc.descripcion, 
                      utils.float2str(pc.existencias,precision=2,autodec=True),
                      utils.float2str(precio_valoracion, precision = 2), 
                      utils.float2str(valoracion, precision = 2), 
                      pc.id))
        suma += valoracion
    tv.set_model(model)
    tv.thaw_child_notify()
    return suma
Exemplo n.º 5
0
def setter_textview(objeto, col, w):
    """
    Muestra el valor del atributo "col" del objeto
    "objeto" en el textview "w".
    """
    valor = getattr(objeto, col.name)
    if isinstance(col, sqlobject.col.SODateCol):
        valor = str_fecha(valor)
    elif isinstance(col, sqlobject.col.SODateTimeCol):
        valor = str_fechahoralarga(valor)
    elif isinstance(col, sqlobject.col.SOTimeCol):
        valor = str_hora(valor)
    elif isinstance(col, sqlobject.col.SOFloatCol):
        # XXX
        # HACK: Workaround. Los valores que son porcentaje (descuentos e IVA)
        # se deben mostrar con el símbolo "%", pero la única manera de
        # distinguir esas columnas es mirar el nombre.
        if col.name in NOMBRES_COLUMNAS_PORCENTAJE:
            valor = "%s %%" % float2str(valor * 100, precision=5, autodec=True)
        # XXX
        else:
            valor = float2str(valor, autodec=False)
            # Si autodec=True y es número redondo > 1000 escribe 1.000 y el
            # getter lo interpreta como flotante.
    if not isinstance(valor, str):
        valor = str(valor)
    buf = w.get_buffer()
    buf.set_text(valor)
Exemplo n.º 6
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)))
Exemplo n.º 7
0
 def imprimir(self, boton):
     """
     Imprime la tarifa en pantalla.
     """
     from formularios import reports
     datos = []
     model = self.wids['tabla_productos'].get_model()
     for itr in model: 
         datos.append((itr[0], 
                       itr[1], 
                       "%s €" % (utils.float2str(itr[2], 3)), 
                       "%s €" % (utils.float2str(itr[3], 3))
                     ))
     def cmp_func(x, y):
         """
         Para ordenar por nombre de producto.
         """
         if x[1] < y[1]:
             return -1
         if x[1] > y[1]:
             return 1
         return 0
     datos.sort(cmp_func)
     if datos != []:
         nombre_tarifa = self.wids['cb_nombre_tarifa'].child.get_text()
         reports.abrir_pdf(geninformes.imprimir_tarifa(datos, nombre_tarifa, utils.str_fecha(mx.DateTime.localtime())))
 def rellenar_pies(self, 
                   total, pendiente, cobrado, 
                   total_pagares, pendiente_pagares, cobrado_pagares, 
                   total_otros, pendiente_otros, cobrado_otros, 
                   total_vencimientos, cobrado_strict):
     """
     Rellena los entries del pie del formulario con los totales recibidos.
     CWT: Al pendiente de cobro hay que restarle lo negociado en pagaré, 
     aunque no hayan vencido o estén marcados como pendiente.
     Por tanto, el 
     pendiente = total (facturado) - total_pagares - cobrado_otros
     y (lo mismo pero jugando con las incóginitas) el 
     cobrado = total_pagares + cobrado_otros = total - pendiente
     """
     self.wids['e_total'].set_text("%s €" % utils.float2str(total))
     # self.wids['e_pendiente'].set_text("%s €" % utils.float2str(pendiente))
     self.wids['e_pendiente'].set_text("%s €" % utils.float2str(total_vencimientos - total_pagares - cobrado_otros))
     self.wids['e_cobrado_strict'].set_text("%s €" % utils.float2str(cobrado_strict))
     # self.wids['e_cobrado'].set_text("%s €" % utils.float2str(cobrado))
     self.wids['e_cobrado'].set_text("%s €" % utils.float2str(total_pagares + cobrado_otros))
     self.wids['e_total_pagares'].set_text("%s €" % utils.float2str(total_pagares))
     self.wids['e_pendiente_pagares'].set_text("%s €" % utils.float2str(pendiente_pagares))
     self.wids['e_cobrado_pagares'].set_text("%s €" % utils.float2str(cobrado_pagares))
     self.wids['e_total_otros'].set_text("%s €" % utils.float2str(total_otros))
     self.wids['e_pendiente_otros'].set_text("%s €" % utils.float2str(pendiente_otros))
     self.wids['e_cobrado_otros'].set_text("%s €" % utils.float2str(cobrado_otros))
Exemplo n.º 9
0
 def rellenar_tabla(self, facturas):
     """
     Rellena el model con los items de la consulta.
     Elementos es un diccionario con objetos factura y una lista  
     de facturacion correspondientes a los meses de consulta.
     """
     idserie = utils.combo_get_value(self.wids["cb_serie"])
     if not idserie:
         serie = None
     else:
         serie = pclases.SerieFacturasVenta.get(idserie)
     model = self.wids["tv_datos"].get_model()
     model.clear()
     total = total_kg = 0
     for factura in facturas:
         if serie and factura.serieFacturasVenta != serie:
             continue
         importe = factura.calcular_importe_total(iva=True)
         kilos = factura.calcular_kilos()
         padre = model.append(
             (
                 factura.numfactura,
                 utils.str_fecha(factura.fecha),
                 factura.cliente.nombre,
                 utils.float2str(importe),
                 utils.float2str(kilos),
                 factura.id,
             )
         )
         total += importe
         total_kg += kilos
     self.wids["e_total_importes"].set_text("%s €" % utils.float2str(total))
     self.wids["e_total_cantidades"].set_text("%s kg" % utils.float2str(total_kg))
Exemplo n.º 10
0
 def rellenar_tabla(self, cuentas):
 	"""
     Rellena el model con los items de la consulta.
     Elementos es un diccionario con objetos cuentaGastos y una lista  
     de gastos correspondientes a los meses de consulta.
     """        
 	model = self.wids['tv_datos'].get_model()
 	model.clear()
     total = 0
 	for cuenta in cuentas:
         padre = model.append(None, (cuenta.descripcion, 
                                     "", 
                                     "", 
                                     "", 
                                     "", 
                                     utils.float2str(0.0), 
                                     cuenta.id))
         for gasto in cuentas[cuenta]:
             model.append(padre, (gasto.codigo, 
                                  gasto.concepto, 
                                  utils.str_fecha(gasto.fecha), 
                                  gasto.facturaCompra
                                     and gasto.facturaCompra.numfactura
                                     or "", 
                                  gasto.parcela 
                                     and gasto.parcela.parcela 
                                     or "", 
                                  utils.float2str(gasto.importe), 
                                  gasto.id))
             model[padre][5] = utils.float2str(
                 utils._float(model[padre][5]) + gasto.importe)
             total += gasto.importe
     self.wids['e_total'].set_text("%s €" % utils.float2str(total))
Exemplo n.º 11
0
 def rellenar_widgets(self, boton = None):
     """
     Introduce la información de la cuenta actual
     en los widgets.
     No se chequea que sea != None, así que
     hay que tener cuidado de no llamar a 
     esta función en ese caso.
     """
     if self.empleado != None:
         gtkimage = self.empleado.get_gtkimage(125)
         self.wids['im_foto'].set_from_pixbuf(gtkimage.get_pixbuf())
         self.wids['e_codigo'].set_text(str(self.empleado.id))
         self.wids['e_nombre'].set_text(self.empleado.nombre)
         anno, mes, dia = self.wids['cal_trabajo'].get_date()
         fecha = mx.DateTime.DateTimeFrom(day = dia, 
                                          month = mes + 1, 
                                          year = anno)
         prod = self.empleado.calcular_produccion_personal(fecha)
         self.wids['e_prod_personal'].set_text(utils.float2str(prod))
         mediaglobal = pclases.Jornal.calcular_media_global(fecha)
         self.wids['e_media_global'].set_text(utils.float2str(mediaglobal))
         ratio = self.empleado.calcular_ratio()
         self.wids['e_ratio'].set_text(utils.float2str(ratio))
         dibujar_grafico(self.wids['grafico'], self.empleado)
         empleados = pclases.Empleado.select(orderBy = "nombre")
         ids = [e.id for e in empleados]
         idactual = self.empleado.id
         self.wids['b_atras'].set_sensitive(ids[0] != idactual)
         self.wids['b_adelante'].set_sensitive(ids[-1] != idactual)
     else:
         self.activar_widgets(False)
Exemplo n.º 12
0
 def es_diferente(self):
     """
     Devuelve True si la información en pantalla es distinta a la
     del objeto en memoria.
     """
     producto = self.objeto
     if producto == None: return False   # Si no hay producto activo, devuelvo que no hay cambio respecto a la ventana
     condicion = producto.codigo == self.wids['e_codigo'].get_text()
     # print condicion
     if producto.camposEspecificosEspecialID != None:
         producto.camposEspecificosEspecial.sync()
         producto.camposEspecificosEspecial.chequear_cambios()
         condicion = condicion and (utils.float2str(producto.camposEspecificosEspecial.stock) == self.wids['e_stock'].get_text())
         condicion = condicion and (producto.camposEspecificosEspecial.unidad == self.wids['e_unidad'].get_text())
         condicion = condicion and (producto.camposEspecificosEspecial.observaciones == self.wids['e_observaciones'].get_text())
         condicion = condicion and (str(producto.camposEspecificosEspecial.existencias) == self.wids['e_existencias'].get_text())
     condicion = condicion and (producto.descripcion == self.wids['e_descripcion'].get_text())
     condicion = condicion and (producto.nombre == self.wids['e_nombre'].get_text())
     condicion = condicion and (str(producto.preciopordefecto) == self.wids['e_precio'].get_text())
     condicion = condicion and (str(producto.minimo) == self.wids['e_minimo'].get_text())
     condicion = condicion and (str(producto.arancel) == self.wids['e_arancel'].get_text())
     condicion = condicion and (utils.float2str(producto.prodestandar) == self.wids['e_prodestandar'].get_text())
     try:
         condicion = (condicion and self.objeto.obsoleto 
                                 == self.wids['ch_obsoleto'].get_active())
     except (KeyError, AttributeError):
         pass    # Versión antigua de la base de datos.
     return not condicion    # Concición verifica que sea igual
Exemplo n.º 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()
Exemplo n.º 14
0
    def rellenar_widgets(self):
        """
        Introduce la información del producto actual
        en los widgets.
        No se chequea que sea != None, así que
        hay que tener cuidado de no llamar a 
        esta función en ese caso.
        """
        producto = self.objeto
        productos = pclases.ProductoVenta.select(
            pclases.ProductoVenta.q.camposEspecificosEspecialID != None, 
            orderBy='id')
        productos_count = productos.count()
        yo_index = pclases.SQLlist(productos).index(producto) + 1
        self.wids['ventana'].set_title(
            "Productos de venta: ESPECIAL - %s (%d de %d)" % (
                producto.descripcion, 
                yo_index, 
                productos_count))

        self.wids['i_barcode'].set_from_file(EanBarCode().getImage(
            producto.codigo))
        self.wids['e_codigo'].set_text(producto.codigo)
        self.wids['e_descripcion'].set_text(producto.descripcion)
        self.wids['e_nombre'].set_text(producto.nombre)
        self.wids['e_precio'].set_text(str(producto.preciopordefecto))
        self.wids['e_minimo'].set_text(str(producto.minimo))
        self.wids['e_arancel'].set_text(str(producto.arancel))
        self.wids['e_prodestandar'].set_text(utils.float2str(producto.prodestandar))
        campos = producto.camposEspecificosEspecial
        self.wids['e_stock'].set_text(utils.float2str(campos.stock))
        self.wids['e_existencias'].set_text(str(campos.existencias))
        try:
            pesobulto = utils.float2str(producto.calcular_razon_bultos())
        except (ValueError, TypeError):
            pesobulto = "N/A"
        self.wids['e_razon'].set_text(pesobulto)
        self.wids['e_unidad'].set_text(campos.unidad)
        self.wids['e_observaciones'].set_text(campos.observaciones)
        # Datos no modificables:
        self.wids['e_idproducto'].set_text(`producto.id`)
        try:
            self.wids['ch_obsoleto'].set_active(self.objeto.obsoleto)
        except (KeyError, AttributeError):
            pass    # Versión antigua de la base de datos.
        self.mostrar_especificos()
        self.rellenar_tabla_tarifas()
        self.rellenar_existencias_almacen(producto)
        self.objeto.make_swap()
        self.objeto.camposEspecificosEspecial.make_swap()
        # Sombreado de botones anterior-siguiente
        anteriores = pclases.ProductoVenta.select(pclases.AND(
            pclases.ProductoVenta.q.camposEspecificosEspecialID != None, 
            pclases.ProductoVenta.q.id < producto.id),orderBy='-id').count()
        siguientes = pclases.ProductoVenta.select(pclases.AND(
            pclases.ProductoVenta.q.camposEspecificosEspecialID != None, 
            pclases.ProductoVenta.q.id > producto.id),orderBy='id').count()
        self.wids['b_anterior'].set_sensitive(anteriores)
        self.wids['b_siguiente'].set_sensitive(siguientes)
Exemplo n.º 15
0
 def rellenar_tabla_XXX(self):
     model = self.wids["XXXtv_treeview"].get_model()
     model.clear()
     total = 0.0
     for p in self.objeto.XXXunoamuchos:
         total += p.XXXcampoacumulable
         model.append((p.XXXcampo1, utils.float2str(p.XXXcampoacumulable), p.id))
     self.wids["XXXe_total_si_lo_hay"].set_text(utils.float2str(total))
Exemplo n.º 16
0
 def rellenar_tabla(self, items):
     """
     Rellena el model con los items de la consulta
     """
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     vpro.set_valor(0.0, "Contando existencias...")
     act = 0.0
     tot = len(items) * len(self.tvs)
     try:
         fecha = utils.parse_fecha(self.wids['e_fecha'].get_text())
     except (TypeError, ValueError, AttributeError):
         fecha = mx.DateTime.today()
         self.wids['e_fecha'].set_text(utils.str_fecha(fecha))
     # XXX: Optimización (cosas de cómo están hechas las funciones de get_*
     #      por dentro en pclases):
     if fecha >= mx.DateTime.today():
         fecha = None
     for tv, kg, bultos, a in self.tvs:
         model = tv.get_model()
         model.clear()
         totalkgs = 0.0
         totalbultos = 0
         for pv in items:
             vpro.set_valor(act/tot, 
                            "Contando existencias...\t[%s]" % pv.get_puid())
             stock = pv.get_stock(hasta = fecha, almacen = a)
             totalkgs += stock
             existencias = pv.get_existencias(hasta=fecha, almacen = a)
             totalbultos += existencias
             stock_A = pv.get_stock_A(hasta = fecha, almacen = a)
             existencias_A = pv.get_existencias_A(hasta=fecha, almacen = a)
             stock_B = pv.get_stock_B(hasta = fecha, almacen = a)
             existencias_B = pv.get_existencias_B(hasta=fecha, almacen = a)
             stock_C = pv.get_stock_C(hasta = fecha, almacen = a)
             existencias_C = pv.get_existencias_C(hasta=fecha, almacen = a)
             model.append((pv.codigo,
                           pv.descripcion,
                           utils.float2str(stock),
                           utils.float2str(existencias, autodec = True),
                           utils.float2str(stock_A!=None and stock_A or 0),
                           utils.float2str(existencias_A != None and 
                                           existencias_A or 0, 
                                           autodec = True),
                           utils.float2str(stock_B!=None and stock_B or 0),
                           utils.float2str(existencias_B != None and 
                                           existencias_B or 0, 
                                           autodec = True),
                           utils.float2str(stock_C!=None and stock_C or 0),
                           utils.float2str(existencias_C != None and 
                                           existencias_C or 0, 
                                           autodec = True),
                           pv.get_puid()))
             act += 1
         kg.set_text(utils.float2str(totalkgs))
         bultos.set_text(utils.float2str(totalbultos, autodec = True))
     vpro.ocultar()
Exemplo n.º 17
0
 def rellenar_tabla_por_provincia(self, vpro):
     """
     Rellena el model de la lista de ofertas clasificada por comercial. 
     Recibe la ventana de progreso.
     """ 
     model = self.wids['tv_provincia'].get_model()
     model.clear()
     tot = sum([len(self.por_producto[k]) 
                for k in self.por_producto.keys()])
     i = 0.0
     try:
         vpro.set_valor(i/tot, "Mostrando ofertas por provincia...")
     except ZeroDivisionError:
         return  # No hay ofertas que mostrar
     padres = {}
     for provincia in self.por_provincia:
         for presupuesto in self.por_provincia[provincia]: 
             vpro.set_valor(i/tot, "Mostrando ofertas por provincia... (%d)" 
                                                     % presupuesto.id)
             try:
                 padre = padres[provincia]
             except KeyError:
                 padre = padres[provincia] = model.append(None, 
                         (provincia, 
                          "", 
                          "", 
                          "", 
                          "0.0", 
                          None))
             importe = presupuesto.calcular_importe_total()
             try:
                 comercial = presupuesto.comercial
                 nombre_comercial = comercial.get_nombre_completo()
             except AttributeError:
                 nombre_comercial = "Sin comercial relacionado"
             fila = ("Presupuesto %d" % presupuesto.id, 
                     nombre_comercial, 
                     presupuesto.cliente and presupuesto.cliente.nombre 
                         or presupuesto.nombrecliente,
                     presupuesto.formaDePago 
                         and presupuesto.formaDePago.toString(
                             presupuesto.cliente) or "", 
                     utils.float2str(importe), 
                     presupuesto.puid)
             model.append(padre, fila)
             # Actualizo totales fila padre.
             model[padre][4] = utils.float2str(
                     utils._float(model[padre][4]) + importe)
             if nombre_comercial not in model[padre][1]:
                 if not model[padre][1]:
                     model[padre][1] = nombre_comercial
                 else:
                     model[padre][1] += "; " + nombre_comercial
             i += 1
     # Y ahora la gráfica.
     if self.wids['notebook1'].get_current_page() == 4:
         self.graficar_por_provincia()
Exemplo n.º 18
0
 def rellenar_totales(self, totf, tots, totb):
     """
     Introduce los totales en los "entries".
     """
     self.wids['e_total'].set_text(utils.float2str(totf))
     self.wids['e_siniva'].set_text(utils.float2str(tots))
     try:
         beneficio = totb * 100.0 / tots
     except ZeroDivisionError:
         beneficio = 0
     self.wids['e_beneficio'].set_text("%s (%s %%)" % (utils.float2str(totb), utils.float2str(beneficio, 4, autodec = True)))
Exemplo n.º 19
0
 def rellenar_tabla_efectos(self):
     model = self.wids['tv_efectos'].get_model()
     model.clear()
     total = 0.0
     for p in self.objeto.efectos:
         total += p.cantidad
         model.append((self.objeto.aceptada, # False, 
                       p.codigo, 
                       p.cliente and p.cliente.nombre or "", 
                       utils.float2str(p.cantidad), 
                       p.puid))
     self.wids['e_importe'].set_text(utils.float2str(total))
Exemplo n.º 20
0
 def rellenar_tabla_gastos(self):
     model = self.wids['tv_gastos'].get_model()
     model.clear()
     total = 0.0
     for p in self.objeto.gastos:
         total += p.importe
         model.append((p.codigo, 
                       p.concepto, 
                       utils.str_fecha(p.fecha), 
                       utils.float2str(p.importe), 
                       p.id))
     self.wids['e_importe'].set_text(utils.float2str(total))
Exemplo n.º 21
0
 def insert_finca(self, finca, fila, columna):
     """
     Inserta en self.wids['tabla'] -en (fila, columna)- la información de 
     la finca a través de un gtk.Image y un label dentro de un VBox que a 
     su vez está dentro de un HBox de dos columnas y con la información de 
     la finca como ToolTip.
     """
     #MAX = 50    # Máximo ancho y alto de píxeles para el mapa de la finca.
     MAX = 100   # Máximo ancho y alto de píxeles para el mapa de la finca.
     vbox = gtk.VBox()
     image = gtk.Image()
     #image.set_from_file(finca.get_ruta_completa_plano())
     finca.mostrar_imagen_en(image, MAX)
     label = gtk.Label(' <span foreground="Gray"><big><i>' 
                         + finca.nombre 
                         + '</i></big></span> ')
     label.set_use_markup(True)
     label.set_angle(90)
     idcampanna = utils.combo_get_value(self.wids['cb_campanna'])
     campanna = pclases.Campanna.get(idcampanna)
     prod = sum([parcela.calcular_produccion(campanna)
                 for parcela in finca.parcelas])
     plantas = sum([p.numeroDePlantas for p in finca.parcelas])
     if plantas != 0:
         kgplanta = sum([parcela.calcular_produccion(campanna)
                         for parcela in finca.parcelas]) / plantas
     else:
         kgplanta = 0.0
     apertura = sum([parcela.get_total_gastos_apertura(campanna)
                     for parcela in finca.parcelas])
     varios = sum([parcela.get_total_gastos_varios(campanna)
                   for parcela in finca.parcelas])
     cierre = sum([parcela.get_total_gastos_cierre(campanna)
                   for parcela in finca.parcelas])
     texto_tip = "<big><big>%s</big>\nProducción: <b>%s kg</b>\n<b>%s kg/planta</b>\nGastos apertura: %s €\nGastos varios: %s €\nGastos de cierre: %s €</big>" % (
                             finca.nombre, 
                             utils.float2str(prod),
                             utils.float2str(kgplanta), 
                             utils.float2str(apertura), 
                             utils.float2str(varios), 
                             utils.float2str(cierre))
     #image.set_tooltip_text(texto_tip)
     try:
         image.set_tooltip_markup(texto_tip)
     except:
         pass    # No tiene este método en GTK/PyGTK 2.10 de WXP
     vbox.pack_start(image)
     vbox.pack_start(label)
     hbox = gtk.HBox()
     hbox.pack_start(vbox)
     widparcelas = self.insert_parcelas(finca)
     hbox.pack_start(widparcelas)
     self.wids['tabla'].attach(hbox, columna, columna+1, fila, fila+1)
Exemplo n.º 22
0
 def rellenar_tabla_por_cliente(self, vpro):
     """
     Rellena el model de la lista de ofertas clasificada por cliente. 
     Recibe la ventana de progreso.
     """ 
     model = self.wids['tv_cliente'].get_model()
     model.clear()
     tot = sum([len(self.por_producto[k]) 
                for k in self.por_producto.keys()])
     i = 0.0
     try:
         vpro.set_valor(i/tot, "Mostrando ofertas por cliente...")
     except ZeroDivisionError:
         return  # No hay ofertas que mostrar.
     padres = {}
     for cliente in self.por_cliente:
         for presupuesto in self.por_cliente[cliente]: 
             vpro.set_valor(i/tot, "Mostrando ofertas por cliente... (%d)" 
                                                     % presupuesto.id)
             try:
                 padre = padres[cliente]
             except KeyError:
                 try:
                     nombre_cliente = cliente.descripcion
                     cif = cliente.cif
                     puid = cliente.puid
                 except AttributeError:
                     nombre_cliente = presupuesto.nombrecliente 
                     cif = presupuesto.cif
                     puid = None
                 padre = padres[cliente] = model.append(None, 
                         (nombre_cliente, 
                          cif, 
                          "0.0", 
                          "", 
                          puid))
             importe = presupuesto.calcular_importe_total()
             fila = ("Presupuesto %d" % presupuesto.id, 
                     utils.str_fecha(presupuesto.fecha),
                     utils.float2str(importe), 
                     presupuesto.formaDePago 
                         and presupuesto.formaDePago.toString(
                             presupuesto.cliente) or "", 
                     presupuesto.puid)
             model.append(padre, fila)
             # Actualizo totales fila padre.
             model[padre][2] = utils.float2str(
                     utils._float(model[padre][2]) + importe)
             i += 1
     # Y ahora la gráfica.
     if self.wids['notebook1'].get_current_page() == 2:
         self.graficar_por_cliente()
Exemplo n.º 23
0
 def rellenar_tabla_ldvs(self):
     model = self.wids['tv_ldvs'].get_model()
     model.clear()
     total = 0.0
     for ldv in self.objeto.lineasDeVenta:
         importe = ldv.calcular_importe(iva = False)
         total += importe 
         model.append((ldv.productoVenta.nombre, 
                       utils.float2str(ldv.cantidad), 
                       utils.float2str(ldv.precio), 
                       utils.float2str(importe), 
                       ldv.id))
     return total
Exemplo n.º 24
0
 def rellenar_totales(self, tot, tipo):
     """
     Rellena los totales de fibra, geotextiles y cemento.
     """
     for dim in tot.keys():
         total = 0.0
         for qlty in tot[dim].keys():
             cantidad = tot[dim][qlty]
             total += cantidad
             nomentry = "e_%s_%s_%s" % (tipo, dim, qlty)
             w = self.wids[nomentry]
             w.set_text(utils.float2str(cantidad, autodec=True))
         e_total = "e_%s_%s_total" % (tipo, dim)
         self.wids[e_total].set_text(utils.float2str(total, autodec=True))
Exemplo n.º 25
0
 def rellenar_tabla_transferencias(self):
     model = self.wids['tv_transferencias'].get_model()
     model.clear()
     total = 0.0
     for p in self.objeto.pagos:
         total += p.importe
         model.append((p.proveedor and p.proveedor.nombre, 
                       p.cuentaOrigen and p.cuentaOrigen.nombre, 
                       utils.float2str(p.importe), 
                       utils.str_fecha(p.fecha), 
                       p.observaciones, 
                       p.concepto, 
                       p.id))
     self.wids['e_total'].set_text(utils.float2str(total))
Exemplo n.º 26
0
 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     from formularios import reports
     datos = []
     for i in self.resultado:
         if not i[2]:    # i[2] = False cuando es vencimiento normal de la BD
             if isinstance(i[1], pclases.FacturaDeAbono):
                 importe = i[1].calcular_importe_total()
                 datos.append((i[1].numfactura,
                               utils.str_fecha(i[1].fecha),
                               utils.float2str(importe),
                               "",
                               i[1].cliente and i[1].cliente.nombre or ""))
             else:
                 fra = i[1].facturaVenta or i[1].prefactura
                 datos.append((fra.numfactura,
                               utils.str_fecha(i[1].fecha),
                               utils.float2str(i[1].importe),
                               i[1].observaciones,
                               fra.cliente.nombre))
         else:   # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
             datos.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']))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta %s' % (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(), 
                       "Vencido a la fecha", 
                       self.wids['e_vencido'].get_text()))
         reports.abrir_pdf(geninformes.vencimientosCobro(datos,fechaInforme))
Exemplo n.º 27
0
 def rellenar_tabla(self, facturas):
     """
     Rellena el model con los facturas de la consulta.
     """
     from formularios.ventana_progreso import VentanaProgreso
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     tot = facturas.count()
     vpro.mostrar()
     model = self.wids['tv_datos'].get_model()
     model.clear()
     total = 0.0
     rows_proveedor = {}
     total_facturado = 0.0
     for fra in facturas:
         vpro.set_valor(total / tot,
                        "Recuperando facturas... [%d/%d]" % (total, tot))
         total += 1
         proveedor = fra.proveedor
         importe = fra.calcular_importe_total()
         total_facturado += importe
         vencimientos = sum([vto.importe for vto in fra.vencimientosPago])
         pagado = sum([c.importe for c in fra.pagos])
         pendiente = importe - pagado
         try:
             row_proveedor = rows_proveedor[proveedor.puid]
         except KeyError:
             rows_proveedor[proveedor.puid] = row_proveedor = model.append(
                     None, (proveedor.nombre,
                            "",
                            "",
                            "0",
                            "0",
                            "0",
                            "0",
                            proveedor.puid))
         model.append(row_proveedor, ("",
                                      fra.numfactura,
                                      utils.str_fecha(fra.fecha),
                                      utils.float2str(importe),
                                      utils.float2str(vencimientos),
                                      utils.float2str(pagado),
                                      utils.float2str(pendiente),
                                      fra.puid))
         model[row_proveedor][3] = utils.float2str(
                 utils._float(model[row_proveedor][3]) + importe)
         model[row_proveedor][4] = utils.float2str(
                 utils._float(model[row_proveedor][4]) + vencimientos)
         model[row_proveedor][5] = utils.float2str(
                 utils._float(model[row_proveedor][5]) + pagado)
         model[row_proveedor][6] = utils.float2str(
                 utils._float(model[row_proveedor][6]) + pendiente)
     self.wids['e_facturas'].set_text(str(facturas.count()))
     self.wids['e_total'].set_text(utils.float2str(total_facturado))
     vpro.ocultar()
Exemplo n.º 28
0
 def rellenar_tabla(self,lista = []):
     """
     Rellena el model con los resultados de la búsqueda almacenados
     en una lista de lotes.
     """        
     model = self.wids['tv_resultado'].get_model()
     model.clear()
     for elem in lista:
         model.append((elem.numlote,
                 elem.codigo,
                 "%s (%s)" % (str(elem.tenacidad), utils.float2str(elem.calcular_tenacidad_media())),
                 "%s (%s)" % (str(elem.elongacion), utils.float2str(elem.calcular_elongacion_media())),
                 "%s (%s)" % (elem.rizo, utils.float2str(elem.calcular_rizo_medio())),
                 "%s (%s)" % (elem.encogimiento, utils.float2str(elem.calcular_encogimiento_medio())),
                 elem.id))
Exemplo n.º 29
0
 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)
Exemplo n.º 30
0
 def rellenar_cesce(self, cobros, pagares, confirmings, vpro):
     """
     Rellena la tabla específica para la empresa de crédito, donde no
     se permite agrupación y las columnas deben seguir un orden determinado.
     """
     self.wids['notebook1'].set_current_page(1)
     model = self.wids['tv_cesce'].get_model()
     model.clear()
     vpro.mover()
     cobros_pagares = []
     for p in pagares:
         for c in p.cobros:
             cobros_pagares.append(c)
     cobros_confirmings = []
     for p in confirmings:
         for c in p.cobros:
             cobros_confirmings.append(c)
     cobros_efect_o_transf = [c for c in cobros]
     for c in cobros_efect_o_transf + cobros_pagares + cobros_confirmings:
         vpro.mover()
         numfactura = c.get_numfactura()
         if not numfactura:
             try:
                 numfactura = c.get_factura_o_prefactura().numfactura
             except AttributeError:
                 numfactura = ""
         if c.cliente and c.cliente.riesgoAsegurado != -1: 
             model.append((c.cliente and c.cliente.nombre or "", 
                           "", # Suplemento. Vacío (al menos de momento)
                           c.cliente and c.cliente.cif or "", 
                           "", # Código CESCE. Vacío
                           utils.float2str(c.importe), 
                           utils.str_fecha(c.fecha), 
                           numfactura, 
                           c.puid))