En anglais, quelles sont les vues génériques de Django?

Question

Les deux premiers paragraphes de cette page expliquent que les vues génériques sont censés rendre ma vie plus facile, moins monotone, et me rendre plus attrayant pour les femmes (je compose ce dernier):

https://docs.djangoproject.com/en/1.4/topics/generic-views/

I Suis tout pour améliorer ma vie, mais que font réellement les vues génériques? Il semble que beaucoup de mots à la mode sont jetés autour, qui confondent plus qu'ils n'expliquent.

Les vues génériques sont-elles similaires à l'échafaudage dans Ruby on Rails? Le dernier point de l'intro semble indiquer cela. Est-ce une déclaration précise?

Answer 1

Les vues génériques Django ne sont que des fonctions d'affichage (anciennes fonctions python classiques) qui font des choses très courantes dans les applications Web. En fonction du type d'application que vous créez, ils peuvent vous éviter d'écrire beaucoup de vues très simples. Par exemple, la vue générique direct_to_template affiche simplement un modèle avec le RequestContext (ce qui signifie que le modèle a accès aux informations sur la requête, comme l'utilisateur actuel, etc.).

Comme un exemple simple, vous pouvez passer d'écrire des choses comme ceci:

# urls.py 
url('^some-url/$', some_view) 

# views.py 
def some_view(request): 
    return render_to_response('template_name.html', context_instance=RequestContext(request)) 

Pour ceci:

# urls.py 
url('^some-url/$', direct_to_template, {'template': 'template_name.html'}) 

# views.py doesn't need any code for this view anymore 

Il y a aussi des vues génériques plus complexes pour des actions communes telles que « montrant une liste de modèles ", ou" ajouter un modèle à la base de données ". De plus, comme les vues génériques ne sont que des fonctions, vous pouvez les appeler dans vos propres fonctions d'affichage pour effectuer «la majeure partie du travail», lorsque vous avez besoin de quelque chose de différent des cas génériques.

Answer 2

Pour répondre à votre deuxième question: non, les vues génériques ne sont pas liées à l'échafaudage dans RoR. L'échafaudage, comme son nom l'indique, s'apparente à la génération de code. Les vues génériques sont quelque chose d'autre.

Mon utilisation principale de la vue générique est un remplacement de plus haut niveau des fonctions très basiques render_to_response. Voici comment vous pouvez écrire une vue simple avec render_to_response:

def my_view(request): 
    return render_to_response('my_template.html') 

Mais ce qui est très basique! Par exemple, le modèle n'aura pas accès au contexte de la demande, sauf si vous le transmettez explicitement.

Je préfère donc utiliser une vue générique à la place:

def my_view(request): 
    return direct_to_template(request, template='my_template.html') 

Maintenant, le contexte de la demande sera transmise! Et ce n'est qu'un début. Les vues génériques sont pratiques lorsque vous souhaitez afficher des listes ou des vues détaillées, par exemple. Ils vont gérer l'interrogation de la base de données, et la messagerie de l'utilisateur, entre autres.

Les vues génériques sont des fonctions de haut niveau qui vous aident à créer une réponse à partir d'une vue.

Answer 3

Les vues génériques vous permettent d'écrire du code beaucoup plus court.

Comparez:

from django.http import HttpResponse, HttpResponseRedirect, Http404 
from django.shortcuts import render_to_response, get_object_or_404, redirect 
from myapp.models import Context 

def edit(request, item_id): 
    object = get_object_or_404(Context, pk=item_id) 

    if request.method == 'POST': 
     form = ContextForm(request.POST, instance=object) 
     if form.is_valid(): 
      form.save() 
      return redirect('myapp-context-index') 
    else: 
     form = ContextForm(instance=object) 

    return render_to_response("myapp/context/edit.html", {'object': object, 'form': form}) 

avec:

from django.core import urlresolvers 
from django.views.generic.create_update import update_object 
from myapp.models import Context 

def edit(request, item_id):  
    return update_object(request, 
     object_id=item_id,    
     form_class=ContextForm,    
     template_name="myapp/context/edit.html", 
     post_save_redirect=urlresolvers.reverse("myapp-context-index") 
    ) 

Comme vos vues normales, ils ne sont que des fonctions normales. Il est possible de configurer la vue complètement dans l'URLconf si vous le souhaitez, à travers je trouve cet usage ci-dessus un peu plus clair.

En prime, vous obtenez également:

• contrôles d'authentification de connexion (passe login_required=True)
• état de réussite message de django.contrib.messages.
• Moins de code pour vérifier les erreurs.
• Valeur par défaut ModelForm lorsque vous indiquez un paramètre model au lieu de form_class.

Le template_name a par défaut "appname/model_form.html", mais c'est un peu trop pour moi.

---

est ici la classe forme les deux actions:

class ContextForm(forms.ModelForm): 
    """The form for a context""" 
    class Meta: 
     model = Context 
     exclude = ('collection',) 

    def save(self, commit=True): 
     """Overwritten save to force collection_id to a value""" 
     model = super(ContextForm, self).save(commit=False) 
     model.collection_id = 1 
     if commit: 
      model.save() 
     return model