1 class View(object):
 2 
 3     @classonlymethod
 4     def as_view(cls, **initargs):
 5         def view(*args, **kwargs):
 6             self = cls(**initargs)
 7             return self.dispatch(*args, **kwargs)
 8         update_wrapper(view, cls, updated=())
 9         update_wrapper(view, cls.dispatch, assigned=())
10         return view
11 
12     def dispatch(self, request, *args, **kwargs):
13         if request.method.lower() in self.http_method_names:
14             handler = getattr(self, request.method.lower(), 
15                 self.http_method_not_allowed)
16         else:
17             handler = self.http_method_not_allowed
18         self.request = request
19         self.args = args
20         self.kwargs = kwargs
21         return handler(request, *args, **kwargs)
22 
23 # urls.py
24 url('^sample-view/$', View.as_view(), name="sample_view")

 1 class ArticleList(View):
 2     template_name = "article_list.html"
 3 
 4    def get(self, request, *args, **kwargs):
 5         self.article_list = self.get_queryset()
 6         return self.render_to_response(
 7             self.get_context_data(articles=self.article_list))
 8 
 9     def render_to_response(self, context):
10         return render_to_response(self.get_template_names(),
11             context, RequestContext(self.request))
12 
13     def get_queryset(self):
14         return Article.objects.all()
15 
16     def get_template_names(self):
17         return [self.template_name] if self.template_name is not None else []
18 
19     def get_context_data(self, **kwargs):
20         return kwargs
21 
22 # urls.py
23 url('^articles/$', ArticleList.as_view(template_name="alternative.html"))

 1 from django.views.generic.base import TemplateResponseMixin, View
 2 from django.views.generic.list import ListView, MultipleObjectMixin
 3 
 4 class ArticleList(TemplateResponseMixin, MultipleObjectMixin, View):
 5     model = Article 
 6     template_name = "articles/article_list.html"
 7 
 8     def get(self, request, *args, **kwargs):
 9         self.object_list = self.get_queryset()
10         context = self.get_context_data(object_list=self.object_list)
11         return self.render_to_response(context)
12 
13 class ArticleListTwo(ListView):
14     model = Article

1 class JSONArticles(JSONMixin, ArticleList):
2     pass

 1 from django.views.generic import CreateView
 2 from myapp.signals import custom_signal
 3 
 4 class CreateArticleView(CreateView):
 5 
 6     def get_form_kwargs(self):
 7         kwargs = super(CreateArticleView, self).get_form_kwargs()
 8         # domyślnie: 'data', 'files' i 'initial'
 9         kwargs['author'] = self.request.user
10         return kwargs
11 
12     def form_valid(self, form):
13         """Called when the form is valid"""
14         response = super(CreateArticleView, self).form_valid(form)
15         if self.object:
16             custom_signal.send(sender=type(self.object), instance=self.object)
17         # dodaj `message`, dodaj zadanie do Celery, itp.
18         return response

 1 class DelayedModelFormMixin(ModelFormMixin):
 2 
 3     def form_valid(self, form):
 4         self.object = form.save(commit=False)
 5         self.prepare_object_for_save(self.object)
 6         self.object.save()
 7         self.object.save_m2m()
 8         # wyślij sygnał...
 9         return super(ModelFormMixin, self).form_valid(form)
10 
11     def prepare_object_for_save(self, obj):
12         pass
13 
14 class CreateCommentView(DelayedModelFormMixin, CreateView):
15 
16     def prepare_object_for_save(self, obj)
17         obj.author = self.request.user

1 from django.views.generic import TemplateView
2 from django.contrib.auth.decorators import login_required
3 
4 url(r'^/protected/$', login_required(
5         TemplateView.as_view(template_name="secret.html")))

1 from django.utils.decorators import method_decorator
2 
3 class ProtectedView(View):
4 
5     @method_decorator(login_required):
6     def dispatch(self, request, *args, **kwargs):
7         return super(ProtectedView, self).dispatch(request, *args, **kwargs)

 1 def view_decorator(fdec)
 2     def decorator(cls):
 3         original = cls.as_view.im_func
 4 
 5         @functools.wraps(original)
 6         def as_view(current, **initkwargs):
 7             return fdec(original(current, **initkwargs))
 8 
 9         cls.as_view = classmethod(as_view) 
10         return cls
11     return decorator
12 
13 # użycie:
14 
15 @view_decorator(login_required)
16 class ProtectedView(TemplateView):
17     pass
18 
19 # *UWAGA*: można sobie strzelić w stopę
20 
21 ProtectedView = view_decorator(login_required)(TemplateView)