Django-Vorlagen: ausführliche Version einer Auswahl

Ich habe ein Modell:

from django.db import models

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

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

Ich habe ein Formular:

from django.forms import ModelForm

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

Und ich möchte formtools.preview verwenden. Die Standardvorlage druckt die Kurzversion der Auswahl ('e' anstelle von 'Fabulous Eggs'), da sie verwendet wird

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

Ich hätte gerne eine Vorlage, die so allgemein ist wie die erwähnte, aber stattdessen 'Fabulous Eggs' druckt.

[Da ich Zweifel hatte, wo die eigentliche Frage ist, habe ich sie für uns alle kühn gemacht :)]

Ich weiß, wie man die ausführliche Version einer Wahl auf eine Weise erhält, die selbst hässlich ist:

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

Der wahre Schmerz ist, dass ich die ausgewählte Wahl treffen muss, und der einzige Weg, der mir in den Sinn kommt, besteht darin, durch Entscheidungen und Überprüfungen zu iterieren {% ifequals currentChoice.0 choiceField.data %}, was noch hässlicher ist.

Kann es leicht gemacht werden? Oder braucht es eine Template-Tag-Programmierung? Sollte das nicht schon in Django verfügbar sein?

In Django-Vorlagen können Sie die get_FOO_display()Methode " " verwenden, die den lesbaren Alias ​​für das Feld zurückgibt, wobei 'FOO' der Name des Felds ist.

Hinweis: Falls die Standardvorlagen FormPreviewes nicht verwenden, können Sie jederzeit Ihre eigenen Vorlagen für dieses Formular bereitstellen , die so etwas wie enthalten {{ form.get_meal_display }}.

Die beste Lösung für Ihr Problem ist die Verwendung von Hilfsfunktionen. Wenn die Auswahlmöglichkeiten in der Variablen CHOICES gespeichert sind und das Modellfeld, in dem die ausgewählte Auswahl gespeichert ist, " Auswahlmöglichkeiten " lautet, können Sie sie direkt verwenden

 {{ x.get_choices_display }}

in Ihrer Vorlage. Hier ist x die Modellinstanz. Ich hoffe es hilft.

Ich entschuldige mich, wenn diese Antwort mit einer der oben aufgeführten überflüssig ist, aber es scheint, dass diese noch nicht angeboten wurde, und sie scheint ziemlich sauber zu sein. So habe ich das gelöst:

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]

Meine Ansicht übergibt einen Scoop an die Vorlage (Hinweis: nicht Scoop.values ​​()), und die Vorlage enthält:

{{ scoop.flavor_verbose }}

Basierend auf Noahs Antwort ist hier eine Version, die gegen Felder ohne Auswahlmöglichkeiten immun ist:

#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

Ich bin mir nicht sicher, ob es in Ordnung ist, einen Filter für diesen Zweck zu verwenden. Wenn jemand eine bessere Lösung hat, werde ich mich freuen, sie zu sehen :) Danke Noah!

Wir können die Filterlösung von Noah erweitern , um universeller mit Daten und Feldtypen umzugehen:

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

Hier ist der Code:

#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)

Ich glaube nicht, dass es dafür einen eingebauten Weg gibt. Ein Filter könnte jedoch den Trick machen:

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

Dann können Sie tun:

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

Fügen Sie Ihren models.py eine einfache Funktion hinzu:

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

Jetzt können Sie einen ausführlichen Wert für Auswahlfelder wie folgt erhalten:

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

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

Upd.: Ich bin mir nicht sicher, ob diese Lösung "pythonic" und "django-way" genug ist oder nicht, aber sie funktioniert. :) :)

Sie haben Model.get_FOO_display (), wobei FOO der Name des Felds ist, für das Auswahlmöglichkeiten bestehen.

Führen Sie in Ihrer Vorlage Folgendes aus:

{{ scoop.get_flavor_display }}