Comment Django connaît-il l'ordre de rendu des champs de formulaire?

Si j'ai un formulaire Django tel que:

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()

Et j'appelle la méthode as_table () d'une instance de ce formulaire, Django rendra les champs dans le même ordre que spécifié ci-dessus.

Ma question est de savoir comment Django connaît l'ordre dans lequel les variables de classe ont été définies?

(Comment puis-je remplacer cet ordre, par exemple lorsque je veux ajouter un champ à partir de la méthode init de la classe ?)

[REMARQUE: cette réponse est maintenant complètement obsolète - veuillez consulter la discussion ci-dessous et les réponses plus récentes].

Si fest un formulaire, ses champs sont f.fields, qui est un django.utils.datastructures.SortedDict (il présente les éléments dans l'ordre où ils sont ajoutés). Après la construction du formulaire, f.fields a un attribut keyOrder, qui est une liste contenant les noms de champs dans l'ordre dans lequel ils doivent être présentés. Vous pouvez le définir dans le bon ordre (bien que vous deviez faire attention pour vous assurer de ne pas omettre d'articles ou d'ajouter des extras).

Voici un exemple que je viens de créer dans mon projet actuel:

class PrivEdit(ModelForm):
    def __init__(self, *args, **kw):
        super(ModelForm, self).__init__(*args, **kw)
        self.fields.keyOrder = [
            'super_user',
            'all_districts',
            'multi_district',
            'all_schools',
            'manage_users',
            'direct_login',
            'student_detail',
            'license']
    class Meta:
        model = Privilege

Les nouveautés de Django 1.9 sont Form.field_order et Form.order_fields () .

# forms.Form example
class SignupForm(forms.Form):

    password = ...
    email = ...
    username = ...

    field_order = ['username', 'email', 'password']


# forms.ModelForm example
class UserAccount(forms.ModelForm):

    custom_field = models.CharField(max_length=254)

    def Meta:
        model = User
        fields = ('username', 'email')

    field_order = ['username', 'custom_field', 'password']

Je suis allé de l'avant et j'ai répondu à ma propre question. Voici la réponse pour référence future:

Dans Django form.pyfait de la magie noire en utilisant la __new__méthode pour charger finalement vos variables de classe self.fieldsdans l'ordre défini dans la classe. self.fieldsest une SortedDictinstance Django (définie dans datastructures.py).

Donc, pour remplacer cela, disons dans mon exemple que vous vouliez que l'expéditeur vienne en premier mais que vous deviez l'ajouter dans une méthode init , vous feriez:

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    def __init__(self,*args,**kwargs):
        forms.Form.__init__(self,*args,**kwargs)
        #first argument, index is the position of the field you want it to come before
        self.fields.insert(0,'sender',forms.EmailField(initial=str(time.time())))

Les champs sont répertoriés dans l'ordre dans lequel ils sont définis dans ModelClass._meta.fields. Mais si vous souhaitez modifier l'ordre dans Form, vous pouvez le faire en utilisant la fonction keyOrder. Par exemple :

class ContestForm(ModelForm):
  class Meta:
    model = Contest
    exclude=('create_date', 'company')

  def __init__(self, *args, **kwargs):
    super(ContestForm, self).__init__(*args, **kwargs)
    self.fields.keyOrder = [
        'name',
        'description',
        'image',
        'video_link',
        'category']

Avec Django> = 1.7, vous devez modifier ContactForm.base_fieldscomme ci-dessous:

from collections import OrderedDict

...

class ContactForm(forms.Form):
    ...

ContactForm.base_fields = OrderedDict(
    (k, ContactForm.base_fields[k])
    for k in ['your', 'field', 'in', 'order']
)

Cette astuce est utilisée dans Django Admin PasswordChangeForm: Source sur Github

Les champs de formulaire ont un attribut pour l'ordre de création, appelé creation_counter. .fieldsL'attribut est un dictionnaire, donc un simple ajout au dictionnaire et la modification des creation_counterattributs dans tous les champs pour refléter le nouvel ordre devrait suffire (jamais essayé cela, cependant).

Utilisez un compteur dans la classe Field. Trier par ce compteur:

import operator
import itertools

class Field(object):
    _counter = itertools.count()
    def __init__(self):
        self.count = Field._counter.next()
        self.name = ''
    def __repr__(self):
        return "Field(%r)" % self.name

class MyForm(object):
    b = Field()
    a = Field()
    c = Field()

    def __init__(self):
        self.fields = []
        for field_name in dir(self):
            field = getattr(self, field_name)
            if isinstance(field, Field):
                field.name = field_name
                self.fields.append(field)
        self.fields.sort(key=operator.attrgetter('count'))

m = MyForm()
print m.fields # in defined order

Production:

[Field('b'), Field('a'), Field('c')]

Depuis les formulaires Django 1.7, utilisez OrderedDict qui ne prend pas en charge l'opérateur d'ajout. Il faut donc reconstruire le dictionnaire à partir de zéro ...

class ChecklistForm(forms.ModelForm):

  class Meta:
    model = Checklist
    fields = ['name', 'email', 'website']

  def __init__(self, guide, *args, **kwargs):
    self.guide = guide
    super(ChecklistForm, self).__init__(*args, **kwargs)

    new_fields = OrderedDict()
    for tier, tasks in guide.tiers().items():
      questions = [(t['task'], t['question']) for t in tasks if 'question' in t]
      new_fields[tier.lower()] = forms.MultipleChoiceField(
        label=tier,
        widget=forms.CheckboxSelectMultiple(),
        choices=questions,
        help_text='desired set of site features'
      )

    new_fields['name'] = self.fields['name']
    new_fields['email'] = self.fields['email']
    new_fields['website'] = self.fields['website']
    self.fields = new_fields 

Pour référence future: les choses ont un peu changé depuis les nouvelles formes. C'est une façon de réorganiser les champs des classes de formulaire de base sur lesquelles vous n'avez aucun contrôle:

def move_field_before(form, field, before_field):
    content = form.base_fields[field]
    del(form.base_fields[field])
    insert_at = list(form.base_fields).index(before_field)
    form.base_fields.insert(insert_at, field, content)
    return form

De plus, il y a un peu de documentation sur le SortedDict qui base_fieldsutilise ici: http://code.djangoproject.com/wiki/SortedDict

Si l'un ou l'autre fields = '__all__':

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = '__all__'

ou excludesont utilisés:

class PartialAuthorForm(ModelForm):
    class Meta:
        model = Author
        exclude = ['title']

Django référence ensuite l'ordre des champs tel que défini dans le modèle . Cela m'a juste surpris, alors j'ai pensé le mentionner. Il est référencé dans la documentation ModelForm :

Si l'un de ces éléments est utilisé, l'ordre dans lequel les champs apparaissent dans le formulaire sera l'ordre dans lequel les champs sont définis dans le modèle, les instances ManyToManyField apparaissant en dernier.

La manière la plus simple de classer les champs dans les formulaires django 1.9 est d'utiliser field_orderdans votre formulaire Form.field_order

Voici un petit exemple

class ContactForm(forms.Form):
     subject = forms.CharField(max_length=100)
     message = forms.CharField()
     sender = forms.EmailField()
     field_order = ['sender','message','subject']

Cela affichera tout dans l'ordre que vous avez spécifié dans field_orderdict.

L'utilisation fieldsen Metaclasse interne est ce qui a fonctionné pour moi Django==1.6.5:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Example form declaration with custom field order.
"""

from django import forms

from app.models import AppModel


class ExampleModelForm(forms.ModelForm):
    """
    An example model form for ``AppModel``.
    """
    field1 = forms.CharField()
    field2 = forms.CharField()

    class Meta:
        model = AppModel
        fields = ['field2', 'field1']

Aussi simple que cela.

J'ai utilisé ceci pour déplacer des champs sur:

def move_field_before(frm, field_name, before_name):
    fld = frm.fields.pop(field_name)
    pos = frm.fields.keys().index(before_name)
    frm.fields.insert(pos, field_name, fld)

Cela fonctionne dans la version 1.5 et je suis raisonnablement sûr que cela fonctionne toujours dans les versions plus récentes.

Cela a à voir avec la classe méta utilisée pour définir la classe de formulaire. Je pense qu'il garde une liste interne des champs et si vous insérez au milieu de la liste, cela pourrait fonctionner. Cela fait un moment que j'ai regardé ce code.