Django szablony: verbose wersja wyboru

Question

Mam model:

from django.db import models 

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

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

mam postać:

from django.forms import ModelForm 

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

I chcę używać formtools.preview. Domyślny szablon wypisuje krótką wersję wyboru („e” zamiast „Wspaniali jaj”), ponieważ posiadał wykorzystuje

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

Chciałbym szablon jako ogólne, jak wspomniano, ale drukowanie „Fabulous jaja ' zamiast.

[jak miałem wątpliwości, gdzie jest prawdziwe pytanie, mam pogrubione to dla nas wszystkich :)]

wiem jak uzyskać opisowy wersję wyboru w sposób, który sam jest brzydki:

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

prawdziwy ból jest potrzebne, aby uzyskać wybrany wyboru, a jedynym sposobem, zbliża się do mojego umysłu jest iteracja wyborów i sprawdzania {% ifequals currentChoice.0 choiceField.data %}, który jest jeszcze brzydsze.

Czy można to łatwo zrobić? Lub potrzebuje programowania szablonów? Czy nie powinno to być już dostępne w django?

Answer 1

Nie sądzę, że istnieje jakiś wbudowany sposób, aby to zrobić. Filtr może załatwić sprawę, ale:

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

Następnie można zrobić:

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

Answer 2

W Django szablony można użyć „get_FOO_display()” metodę, która będzie zwracać się do odczytania alias dla tej dziedzinie, gdzie "FOO" to nazwa pola.

Uwaga: w przypadku, gdy standardowe szablony FormPreview go nie używają, zawsze można provide your own templates dla tego formularza, który będzie zawierał coś w rodzaju {{ form.get_meal_display }}.

Answer 3

Na podstawie odpowiedzi Noego, oto wersja odporna na polach bez możliwości:

#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 

Nie jestem pewien pogoda jest ok aby użyć filtra do tego celu. Jeśli ktokolwiek ma lepsze rozwiązanie, chętnie go zobaczę :) Dziękuję Noah!

Answer 4

Możemy rozszerzyć rozwiązanie filtra przez Noah być bardziej powszechne w kontaktach z danych i typów pól:

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

Oto kod:

#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

Najlepszym rozwiązaniem problemu jest używać funkcji pomocniczych. Jeśli wybory są przechowywane w zmiennej WYBORÓW i pole modelu przechowywania wybrany wybór jest „wybory” następnie można bezpośrednio wykorzystać

{{ x.get_choices_display }} 

w szablonie. Tutaj x jest instancją modelu. Mam nadzieję, że to pomaga.

Answer 6

Dodaj do models.py jedną prostą funkcję:

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

Teraz można dostać opisowy wartość pola wyboru tak:

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

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

Upd .: Nie jestem pewien, czy to rozwiązanie "pythonic" i "django-way" wystarczy czy nie, ale działa. :)

Answer 7

Przepraszam, jeśli ta odpowiedź jest zbędna z wymienionymi powyżej, ale wygląda na to, że ta nie została jeszcze zaoferowana i wydaje się dość czysta. Oto jak mam rozwiązać ten:

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] 

Mój pogląd przechodzi gałką do szablonu (uwaga: nie Scoop.values ​​()), a szablon zawiera:

{{ scoop.flavor_verbose }} 

Answer 8

Z użycie tagu szablonu.

Prawie tak samo jak Arthur Gawjowj, ale ten jest przeznaczony do wyborów, które TYLKO używają wartości całkowitych zamiast ciągów.

# 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