django TemplateView und form

Ich habe ein problem, herauszufinden, wie die neue django-views (template view) und Formen arbeiten kann ich auch nicht finden können gute Ressourcen, offizielle doc nicht erklären Sie mir, wie kann eine get-Anfrage ( ich meine get und post) und Formen in der neuen django-views-Klasse

Dank

Hinzugefügt, um besser zu erklären,

ich habe zum Beispiel in dieser form :

from django import forms

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

- und dies ist der code für Lesen und drucken Sie das Formular (alte Art):

def contact(request):
    if request.method == 'POST': # If the form has been submitted...
        form = ContactForm(request.POST) # A form bound to the POST data
        if form.is_valid(): # All validation rules pass
            # Process the data in form.cleaned_data
            # ...
            return HttpResponseRedirect('/thanks/') # Redirect after POST
    else:
        form = ContactForm() # An unbound form

    return render_to_response('contact.html', {
        'form': form,
    })

gut, meine Frage ist, wie können Sie das gleiche tun mit template-Ansicht Dank

warum -3 was ist falsch in meiner Frage?

InformationsquelleAutor LXG | 2011-11-15

  1. 13

    Ich würde empfehlen, nur Schaffe durch die offizielle tutorial und ich denke, Realisierung dawn und die Erleuchtung wird kommen automatisch.

    Grundsätzlich:
    Wenn Sie eine Anfrage an: "'http://mydomain/myblog/foo/bar"'
    Django:

    1. beheben myblog/foo/bar einer Funktion/Methode call through definierte Muster in urls.py
    2. rufen Sie die Funktion mit der Anfrage als parameter, z.B. myblog.views.foo_bar_index(request).
    3. und senden Sie einfach beliebige Zeichenfolge, die Funktion gibt zurück an den browser. In der Regel, dass Ihre generierten html-code.

    Den view-Funktion in der Regel die folgenden:

    1. Füllen Sie das Kontext-dict für die Ansicht
    2. Rendern des templates mit, dass der Kontext
    3. gibt den resultierenden string zurück

    Der Vorlage generic-Ansicht können Sie überspringen, schreiben, die Funktion, und übergeben Sie im Kontext-Wörterbuch.

    Unter Angabe der django-Dokumentation:

    from django.views.generic import TemplateView

class AboutView(TemplateView):
    template_name = "about.html"

    Alle Ansichten.generic.*View-Klassen haben Aussicht.generisches.Ansicht als Ihre Basis. In der docs zu, dass Sie die Informationen finden, die Sie benötigen.
    Grundsätzlich:

    # urls.py
urlpatterns = patterns('',
        (r'^view/$', MyView.as_view(size=42)),
    )

    MyView.as_view erzeugt ein callable, Aufrufe views.generisches.Blick.dispatch()
    die wiederum rufen MyView.get(), MyView.post(), MyView.update () - etc.
    die Sie überschreiben können.

    Zitieren der Dokumente:

    Klasse Blick

    Versand(Anfrage, *args, **kwargs)

    Ansicht Teil des Ansicht-die Methode akzeptiert eine Anfrage
    argument-plus-Argumente und liefert eine HTTP-Antwort. Der Standard
    die Implementierung prüft die HTTP-Methode und Versuch zu übertragen
    eine Methode, die Spiele der HTTP-Methode GET wird delegiert werden
    get(), POST(), und so weiter.

    Die Standard-Implementierung setzt außerdem verlangen, args und kwargs als
    Instanz-Variablen, so dass jede Methode auf die Ansicht können Sie den vollständigen
    details der Anfrage, die gestellt wurde, zum aufrufen der Ansicht.

    Die großen Pluspunkte von class based views (meiner Meinung nach):

    1. Erbschaft macht Sie trocken.
    2. Deklarativer form der Programmierung
    vielen Dank, aber bitte aktualisieren Sie die Antwort bytheway erhältst du +1

    InformationsquelleAutor AndreasT

  2. 34

    Verwenden Sie eine FormView statt, d.h.

    from django.views.generic import TemplateView, FormView

from forms import ContactUsEmailForm


class ContactView(FormView):
    template_name = 'contact_us/contact_us.html'
    form_class = ContactUsEmailForm
    success_url = '.'

    def get_context_data(self, **kwargs):
        context = super(ContactView, self).get_context_data(**kwargs)
        #context["testing_out"] = "this is a new context var"
        return context

    def form_valid(self, form):
        # This method is called when valid form data has been POSTed.
        # It should return an HttpResponse.
        #form.send_email()
        #print "form is valid"
        return super(ContactView, self).form_valid(form)

    Mehr auf FormView in Django-Docs

    Technisch TemplateView kann auch verwendet werden, nur überschreiben der Methode post, da per default template-Ansicht können Sie keine post von ihm:

    class ContactUsView(TemplateView):
    template_name = 'contact_us/contact_us.html'

    def post(self, request, *args, **kwargs):
        context = self.get_context_data()
        if context["form"].is_valid():
            print 'yes done'
            #save your model
            #redirect

        return super(TemplateView, self).render_to_response(context)

    def get_context_data(self, **kwargs):
        context = super(ContactUsView, self).get_context_data(**kwargs)

        form = ContactUsEmailForm(self.request.POST or None)  # instance= None

        context["form"] = form
        #context["latest_article"] = latest_article

        return context

    Ich denke, das FormView macht mehr Sinn, obwohl.

    Auch ich stick mit TemplateView, es scheint die meisten flexibel für meine Zwecke. Ich habe manchmal auch das überschreiben bekommen.

    InformationsquelleAutor radtek

Schreibe einen Kommentar