Question

I have some problem to figure out how new django views (template view) and forms can works I also can’t find good resources, official doc don’t explain me how can get request ( I mean get and post) and forms in new django views class

Thanks

added for better explain

for example I have this 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)

and this is the code for read and print the form (old fashion way):

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,
    })

well my question is how you can do the same thing with template view thanks

Answer 1

I would recommend just plodding through the official tutorial and I think realization will dawn and enlightenment will come automatically.

Basically:
When you issue a request: ”’http://mydomain/myblog/foo/bar”’
Django will:

1. resolve myblog/foo/bar to a function/method call through the patterns defined in urls.py
2. call that function with the request as parameter, e.g. myblog.views.foo_bar_index(request).
3. and just send whatever string that function returns to the browser. Usually that’s your generated html code.

The view function usually does the following:

1. Fill the context dict for the view
2. Renders the template using that context
3. returns the resulting string

The template generic view allows you to skip writing that function, and just pass in the context dictionary.

Quoting the django docs:

from django.views.generic import TemplateView

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

All views.generic.*View classes have views.generic.View as their base. In the docs to that you find the information you require.
Basically:

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

MyView.as_view will generate a callable that calls views.generic.View.dispatch()
which in turn will call MyView.get(), MyView.post(), MyView.update() etc.
which you can override.

To quote the docs:

class View

dispatch(request, *args, **kwargs)

The view part of the view — the method that accepts a request
argument plus arguments, and returns a HTTP response. The default
implementation will inspect the HTTP method and attempt to delegate to
a method that matches the HTTP method; a GET will be delegated to
get(), a POST to post(), and so on.

The default implementation also sets request, args and kwargs as
instance variables, so any method on the view can know the full
details of the request that was made to invoke the view.

The big plusses of the class based views (in my opinion):

1. Inheritance makes them dry.
2. More declarative form of programming