Django combine DetailView et FormView

J'ai une vision où j'ai besoin d'afficher des informations sur un certain modèle de l'instance j'ai donc utiliser un DetailView. J'ai aussi besoin de ce même point de vue pour traiter une forme régulière (pas un modèle de formulaire), à la fois de l'affichage de la forme sur GET et de le valider sur POST. Pour ce faire, je suis en train d'utiliser un FormView cependant, la combinaison de deux clases ne fonctionne pas:

class FooView(FormView, DetailView):
    # configs here

Dans GET (pour des raisons de simplicité de la question, je ne montre que le problème avec GET depuis POST a un autre problème), il ne fonctionne pas parce que la forme n'est jamais ajouté au contexte. La raison a à voir avec la méthode de résolution de l'ordre pour la classe:

>>> inspect.getmro(FooView)
(FooView,
 django.views.generic.edit.FormView,
 django.views.generic.detail.DetailView,
 django.views.generic.detail.SingleObjectTemplateResponseMixin,
 django.views.generic.base.TemplateResponseMixin,
 django.views.generic.edit.BaseFormView,
 django.views.generic.edit.FormMixin,
 django.views.generic.detail.BaseDetailView,
 django.views.generic.detail.SingleObjectMixin,
 django.views.generic.base.ContextMixin,
 django.views.generic.edit.ProcessFormView,
 django.views.generic.base.View,
 object)

Dans la demande, Django a pour obtenir la forme et l'ajouter au contexte. Qui se passe dans ProcessFormView.get:

def get(self, request, *args, **kwargs):
    """
    Handles GET requests and instantiates a blank version of the form.
    """
    form_class = self.get_form_class()
    form = self.get_form(form_class)
    return self.render_to_response(self.get_context_data(form=form))

Cependant le premier de la classe avec la MRE qui a get défini est BaseDetailView:

def get(self, request, *args, **kwargs):
    self.object = self.get_object()
    context = self.get_context_data(object=self.object)
    return self.render_to_response(context)

Comme vous pouvez le voir le BaseDetailView.get n'appelle jamais super d'où le ProcessFormView.get ne sera jamais appelé d'où la forme ne sera pas ajouté au contexte. Ceci peut être résolu par la création d'un mixin point de vue où toutes ces nuances pour GET et POST peuvent être pris en charge, cependant je ne me sens pas c'est une solution propre.

Ma question: est-il possible d'accomplir ce que je veux avec Django par défaut de CBV mise en œuvre sans créer mixin?

source d'informationauteur miki725

django django-class-based-views

25

Une solution serait d'utiliser mixin, comme par limelights' commentaire ci-dessus.

Une autre approche est d'avoir deux points de vue distincts, l'un pour un DetailView et de l'autre un FormView. Ensuite, le modèle de l'ancien, d'afficher le même formulaire que vous utilisez dans le dernier, sauf que vous ne pouvez pas laisser la action attribut vide -- au lieu de cela, mettre l'url de la FormView. Quelque chose le long des lignes de ce (veuillez méfiez-vous de toutes les erreurs que j'écris ceci sans aucun test):

Dans views.py:
```
class MyDetailView(DetailView):
    model = MyModel
    template_name = 'my_detail_view.html'

    def get_context_data(self, **kwargs):
        context = super(MyDetailView, self).get_context_data(**kwargs)
        context['form'] = MyFormClass
        return context

class MyFormView(FormView):
    form_class = MyFormClass
    success_url = 'go/here/if/all/works'
```
Dans my_detail_view.html:
```


<form method="post" action="{% url "my_form_view_url" %}">

{{ form }}

</form>
```
Dans urls.py:
```
# ...
url('^my_model/(?P<pk>\d+)/$', MyDetailView.as_view(), name='my_detail_view_url'),
url('^my_form/$', require_POST(MyFormView.as_view()), name='my_form_view_url'),
# ...
```
Noter que le require_POST décorateur est facultatif, dans le cas que vous ne voulez pas le MyFormView pour être accessible par les GET et voulez seulement être traitées que lorsque le formulaire est soumis.

Django a aussi une assez longue de la documentation à propos de ce problème.

https://docs.djangoproject.com/en/1.8/topics/class-based-views/mixins/#using-formmixin-with-detailview

Ils conseillent d'en faire 2 points de vue différents, et ont la vue de détails, reportez-vous à la vue de formulaire sur le post.

Je suis en train de voir si ce hack peut fonctionner:

class MyDetailFormView(FormView, DetailView):
    model = MyModel
    form_class = MyFormClass
    template_name = 'my_template.html'

    def get_context_data(self, **kwargs):
        context = super(MyDetailFormView, self).get_context_data(**kwargs)
        context['form'] = self.get_form()
        return context

    def post(self, request, *args, **kwargs):
        return FormView.post(self, request, *args, **kwargs)

1

Dans Django Par Exemple de lightbird, ils sont à l'aide d'une bibliothèque, MCBV, mélanger générique vues:

Mon guide du tuto utiliser une bibliothèque de la classe de base des points de vue modifiés sur la base de Django générique vues; la bibliothèque est appelée MCBV (M stands modulaires) et la principale différence par rapport aux génériques CBVs est qu'il est possible de mélanger et assortir plusieurs génériques de vues facilement (par exemple ListView et CreateView, la fenêtre detravail et UpdateView, etc.)

Vous pouvez suivre les explications ici: aide-fonctions

Et de l'utiliser pour mélanger FormView et la fenêtre detravail, ou que ce soit

Code: MCBV

En utilisant FormMixin

views.py

from django.contrib.auth import get_user_model
from django.core.urlresolvers import (
reverse_lazy
)
from django.http import Http404
from django.shortcuts import (
render,
redirect
)
from django.views.generic import (
DetailView,
FormView,
)
from django.views.generic.edit import FormMixin    
from .forms import SendRequestForm
User = get_user_model()  
class ViewProfile(FormMixin, DetailView):
model = User
context_object_name = 'profile'
template_name = 'htmls/view_profile.html'
form_class = SendRequestForm
def get_success_url(self):
return reverse_lazy('view-profile', kwargs={'pk': self.object.pk})
def get_object(self):
try:
my_object = User.objects.get(id=self.kwargs.get('pk'))
return my_object
except self.model.DoesNotExist:
raise Http404("No MyModel matches the given query.")
def get_context_data(self, *args, **kwargs):
context = super(ViewProfile, self).get_context_data(*args, **kwargs)
profile = self.get_object()
# form
context['form'] = self.get_form()
context['profile'] = profile
return context
def post(self, request, *args, **kwargs):
self.object = self.get_object()
form = self.get_form()
if form.is_valid():
return self.form_valid(form)
else:
return self.form_invalid(form)    
def form_valid(self, form):
#put logic here
return super(ViewProfile, self).form_valid(form)
def form_invalid(self, form):
#put logic here
return super(ViewProfile, self).form_invalid(form)

forms.py

from django import forms 
class SendRequestForm(forms.Form):
request_type = forms.CharField()
def clean_request_type(self):
request_type = self.cleaned_data.get('request_type')
if 'something' not in request_type:
raise forms.ValidationError('Something must be in request_type field.')
return request_type

urls.py

urlpatterns = [
url(r'^view-profile/(?P<pk>\d+)', ViewProfile.as_view(), name='view-profile'),
]

modèle

username -{{object.username}}
id -{{object.id}}
<form action="{% url 'view-profile' object.id %}" method="POST">
{% csrf_token %}
{{form}}
<input type="submit" value="Send request">
</form>

J'ai effectué ma solution à l'aide ModelForms et quelque chose comme ceci:
Sur la méthode get_context_data de ma fenêtre detravail j'ai fait:

form = CommentForm(
instance=Comment(
school=self.object, user=self.request.user.profile
)
)
context['form'] = form

Et mon FormView était comme:

class SchoolComment(FormView):
form_class = CommentForm
def get_success_url(self):
return resolve_url('schools:school-profile', self.kwargs.get('pk'))
def form_valid(self, form):
form.save()
return super(SchoolComment, self).form_valid(form)

Vous devez vous connecter pour publier un commentaire.