las plantillas de Django: la versión detallada de una elección

Question

tengo un modelo:

from django.db import models 

CHOICES = (
    ('s', 'Glorious spam'), 
    ('e', 'Fabulous eggs'), 
) 

class MealOrder(models.Model): 
    meal = models.CharField(max_length=8, choices=CHOICES) 

Tengo una forma:

from django.forms import ModelForm 

class MealOrderForm(ModelForm): 
    class Meta: 
     model = MealOrder 

Y quiero usar formtools.preview. La plantilla por defecto imprime la versión corta de la elección ('e' en lugar de 'huevos' Fabulous), becuase que utiliza

{% for field in form %} 
<tr> 
<th>{{ field.label }}:</th> 
<td>{{ field.data }}</td> 
</tr> 
{% endfor %}. 

Me gustaría tener una plantilla tan general como el mencionado, pero la impresión 'huevos Fabulous 'en cambio.

[ya que tenía dudas dónde está la verdadera cuestión, que en negrita que para todos nosotros :)]

Yo sé cómo conseguir la versión detallada de la elección de una manera que es en sí misma fea:

{{ form.meal.field.choices.1.1 }} 

el dolor real es que necesito para obtener la opción seleccionada, y la única manera que viene a la mente es iteración a través de decisiones y el control de {% ifequals currentChoice.0 choiceField.data %}, lo que es aún más feo.

¿Se puede hacer fácilmente? ¿O necesita alguna programación de etiqueta de plantilla? ¿No debería estar ya disponible en django?

Answer 1

No creo que haya ninguna forma incorporada de hacerlo. Un filtro puede hacer el truco, sin embargo:

@register.filter(name='display') 
def display_value(bf): 
    """Returns the display value of a BoundField""" 
    return dict(bf.field.choices).get(bf.data, '') 

entonces usted puede hacer:

{% for field in form %} 
    <tr> 
     <th>{{ field.label }}:</th> 
     <td>{{ field.data|display }}</td> 
    </tr> 
{% endfor %} 

Answer 2

En Django plantillas que puede utilizar el método "get_FOO_display()", que devolverá el alias legible para el campo, donde 'FOO' es el nombre del campo.

Nota: en el caso de los estándares FormPreview plantillas no lo están utilizando, entonces siempre se puede provide your own templates de esa forma, que contendrá algo así como {{ form.get_meal_display }}.

Answer 3

Basándose en la respuesta de Noé, aquí es una versión inmune a campos sin opciones:

#annoyances/templatetags/data_verbose.py 
from django import template 

register = template.Library() 

@register.filter 
def data_verbose(boundField): 
    """ 
    Returns field's data or it's verbose version 
    for a field with choices defined. 

    Usage:: 

     {% load data_verbose %} 
     {{form.some_field|data_verbose}} 
    """ 
    data = boundField.data 
    field = boundField.field 
    return hasattr(field, 'choices') and dict(field.choices).get(data,'') or data 

No estoy seguro de carnero que es aceptable utilizar un filtro para tal fin. Si alguien tiene una solución mejor, estaré encantado de verla :) ¡Gracias, Noah!

Answer 4

podemos extender la solución de filtro por Noah ser más universal en el tratamiento de datos y tipos de campos:

<table> 
{% for item in query %} 
    <tr> 
     {% for field in fields %} 
      <td>{{item|human_readable:field}}</td> 
     {% endfor %} 
    </tr> 
{% endfor %} 
</table> 

Aquí está el código:

#app_name/templatetags/custom_tags.py 
def human_readable(value, arg): 
    if hasattr(value, 'get_' + str(arg) + '_display'): 
     return getattr(value, 'get_%s_display' % arg)() 
    elif hasattr(value, str(arg)): 
     if callable(getattr(value, str(arg))): 
      return getattr(value, arg)() 
     else: 
      return getattr(value, arg) 
    else: 
     try: 
      return value[arg] 
     except KeyError: 
      return settings.TEMPLATE_STRING_IF_INVALID 
register.filter('human_readable', human_readable) 

Answer 5

La mejor solución para su problema consiste en usa funciones de ayuda. Si las opciones se almacenan en las variables OPCIONES y el campo de modelo de almacenamiento de la opción seleccionada es '' opciones entonces se puede utilizar directamente

{{ x.get_choices_display }} 

en su plantilla. Aquí, x es la instancia modelo. Espero que ayude.

Answer 6

Añadir a su models.py una función simple:

def get_display(key, list): 
    d = dict(list) 
    if key in d: 
     return d[key] 
    return None 

Ahora, se puede obtener el valor detallado de los campos de selección por el estilo:

class MealOrder(models.Model): 
    meal = models.CharField(max_length=8, choices=CHOICES) 

    def meal_verbose(self): 
     return get_display(self.meal, CHOICES)  

UPD .: No estoy seguro, es esa solución "pythonic" y "django-way" suficiente o no, pero funciona. :)

Answer 7

Disculpe si esta respuesta es redundante con cualquiera de las enumeradas anteriormente, pero parece que esta no se ha ofrecido aún, y parece bastante limpia. Así es como he resuelto esto:

from django.db import models 

class Scoop(models.Model): 
    FLAVOR_CHOICES = [ 
     ('c', 'Chocolate'), 
     ('v', 'Vanilla'), 
    ] 

    flavor = models.CharField(choices=FLAVOR_CHOICES) 

    def flavor_verbose(self): 
     return dict(Scoop.FLAVOR_CHOCIES)[self.flavor] 

Mi punto de vista pasa una cucharada a la plantilla (nota: no Scoop.values ​​()), y la plantilla contiene:

{{ scoop.flavor_verbose }} 

Answer 8

Con el uso de una etiqueta de plantilla.

Casi lo mismo que Arthur Gawjowj, pero este es para opciones que SÓLO usan valores enteros en lugar de cadenas.

# project/templatetags/project_tags.py 

from django.template.base import Library 


register = Library() 

@register.filter(name='pretty_form_value') 
def pretty_form_value(field): 
    """ 
    Returns field's data or it's verbose version 
    for a field with choices defined. 

    Usage:: 

     {% load project_tags %} 
     {{form.some_field|pretty_form_value}} 
    """ 
    if hasattr(field.field, 'choices'): 
     try: 
      return dict(field.field.choices)[int(field.data)] 
     except ValueError: 
      pass 
    return field.data