Istnieje alternatywa dla umieszczenia dekoratora na każdej funkcji widoku. Możesz również umieścić dekorator login_required() w pliku urls.py. Chociaż jest to nadal zadanie ręczne, przynajmniej masz to wszystko w jednym miejscu, co ułatwia kontrolę.

Np.,

    from my_views import home_view

    urlpatterns = patterns('',
        # "Home":
        (r'^$', login_required(home_view), dict(template_name='my_site/home.html', items_per_page=20)),
    )

Zauważ, że funkcje widoku są nazwane i importowane bezpośrednio, a nie jako ciągi znaków.

Zauważ również, że działa to z dowolnym wywoływalnym obiektem widoku, w tym z klasami.

W Django 2.1 możemy ozdobić wszystkie metody w klasie za pomocą:

from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.views.generic import TemplateView

@method_decorator(login_required, name='dispatch')
class ProtectedView(TemplateView):
    template_name = 'secret.html'

Aktualizacja: Znalazłem również następujące do pracy:

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView

class ProtectedView(LoginRequiredMixin, TemplateView):
    template_name = 'secret.html'

I ustaw LOGIN_URL = '/accounts/login/' w swoim settings.py

Trudno jest zmienić wbudowane założenia w Django bez przeróbki sposobu przekazywania adresów url do wyświetlania funkcji.

Zamiast rozprawiać się z wewnętrznymi Django, oto audyt, którego możesz użyć. Wystarczy sprawdzić każdą funkcję widoku.

import os
import re

def view_modules( root ):
    for path, dirs, files in os.walk( root ):
        for d in dirs[:]:
            if d.startswith("."):
                dirs.remove(d)
        for f in files:
            name, ext = os.path.splitext(f)
            if ext == ".py":
                if name == "views":
                    yield os.path.join( path, f )

def def_lines( root ):
    def_pat= re.compile( "\n(\S.*)\n+(^def\s+.*:$)", re.MULTILINE )
    for v in view_modules( root ):
        with open(v,"r") as source:
            text= source.read()
            for p in def_pat.findall( text ):
                yield p

def report( root ):
    for decorator, definition in def_lines( root ):
        print decorator, definition

Uruchom to i sprawdź wyjście dla defs bez odpowiednich dekoratorów.

Oto rozwiązanie middleware dla django 1.10 +

Middleware w muszą być napisane w nowy sposób w django 1.10 + .

Kod

import re

from django.conf import settings
from django.contrib.auth.decorators import login_required


class RequireLoginMiddleware(object):

    def __init__(self, get_response):
         # One-time configuration and initialization.
        self.get_response = get_response

        self.required = tuple(re.compile(url)
                              for url in settings.LOGIN_REQUIRED_URLS)
        self.exceptions = tuple(re.compile(url)
                                for url in settings.LOGIN_REQUIRED_URLS_EXCEPTIONS)

    def __call__(self, request):

        response = self.get_response(request)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        # No need to process URLs if user already logged in
        if request.user.is_authenticated:
            return None

        # An exception match should immediately return None
        for url in self.exceptions:
            if url.match(request.path):
                return None

        # Requests matching a restricted URL pattern are returned
        # wrapped with the login_required decorator
        for url in self.required:
            if url.match(request.path):
                return login_required(view_func)(request, *view_args, **view_kwargs)

        # Explicitly return None for all non-matching requests
        return None

Instalacja

1. skopiuj kod do folderu projektu i zapisz jako middleware.py

2. Dodaj do MIDDLEWARE

   MIDDLEWARE = [ ... '.middleware.RequireLoginMiddleware', # Require login ]

3. Dodaj do swojego settings.py:

LOGIN_REQUIRED_URLS = (
    r'(.*)',
)
LOGIN_REQUIRED_URLS_EXCEPTIONS = (
    r'/admin(.*)$',
)
LOGIN_URL = '/admin'

Źródła:

1. Ta ODPOWIEDŹ by Daniel Naab

2. Django Middleware tutorial by Max Goodridge

3. Django Middleware Docs

Zainspirowany odpowiedzią Bera napisałem mały fragment, który zastępuje funkcję patterns, owijając wszystkie wywołania zwrotne URL dekoratorem login_required. Działa to w Django 1.6.

def login_required_patterns(*args, **kw):
    for pattern in patterns(*args, **kw):
        # This is a property that should return a callable, even if a string view name is given.
        callback = pattern.callback

        # No property setter is provided, so this will have to do.
        pattern._callback = login_required(callback)

        yield pattern

Używanie go działa w ten sposób (wywołanie do {[4] } jest wymagane ze względu na yield).

urlpatterns = list(login_required_patterns('', url(r'^$', home_view)))

Jest aplikacja, która zapewnia rozwiązanie plug-and-play:

Https://github.com/mgrouchy/django-stronghold

pip install django-stronghold

# settings.py

INSTALLED_APPS = (
    #...
    'stronghold',
)

MIDDLEWARE_CLASSES = (
    #...
    'stronghold.middleware.LoginRequiredMiddleware',
)

Nie możesz tego wygrać. Po prostu musisz złożyć deklarację wymagań autoryzacji. Gdzie indziej można umieścić tę deklarację, z wyjątkiem funkcji widoku?

Rozważ zastąpienie funkcji widoku obiektami do wywołania.

class LoginViewFunction( object ):
    def __call__( self, request, *args, **kw ):
        p1 = self.login( request, *args, **kw )
        if p1 is not None:
            return p1
        return self.view( request, *args, **kw )
    def login( self, request )
        if not request.user.is_authenticated():
            return HttpResponseRedirect('/login/?next=%s' % request.path)
    def view( self, request, *args, **kw ):
        raise NotImplementedError

Następnie tworzysz podklasy funkcji widoku z LoginViewFunction.

class MyRealView( LoginViewFunction ):
    def view( self, request, *args, **kw ):
        .... the real work ...

my_real_view = MyRealView()  

Nie zapisuje żadnych linii kodu. I to nie pomaga w problemie "zapomnieliśmy". Wszystko, co możesz zrobić, to sprawdzić kod, aby upewnić się, że funkcje widoku są obiektami. Odpowiedniej klasy.

Ale nawet wtedy, nigdy nie dowiesz się, że Każda Funkcja widoku jest poprawna bez zestawu testów jednostkowych.

Byłoby możliwe, aby mieć jeden punkt wyjścia dla wszystkich urls w rodzaju include i że ozdobić go za pomocą tego pakietu https://github.com/vorujack/decorate_url .

Począwszy od Django 3+, możesz zmienić domyślne ustawienia jak poniżej:

Krok 1: Utwórz nowy plik anything.py w Twoim katalogu yourapp i napisz co następuje:

import re
from django.conf import settings
from django.contrib.auth.decorators import login_required

//for registering a class as middleware you at least __init__() and __call__()
//for this case we additionally need process_view() which will be automatically called by Django before rendering a view/template

class ClassName(object):
    
    //need for one time initialization, here response is a function which will be called to get response from view/template
    def __init__(self, response):
        self.get_response = response
        self.required = tuple(re.compile(url) for url in settings.AUTH_URLS)
        self.exceptions = tuple(re.compile(url)for url in settings.NO_AUTH_URLS)

    def __call__(self, request):
        //any code written here will be called before requesting response
        response = self.get_response(request)
        //any code written here will be called after response
        return response

    //this is called before requesting response
    def process_view(self, request, view_func, view_args, view_kwargs):
        //if authenticated return no exception
        if request.user.is_authenticated:
            return None
                
        //default case, no exception
        return login_required(view_func)(request, *view_args, **view_kwargs)

Krok 2: dodaj to anything.py do Middleware [] w project/settings.py like following

MIDDLEWARE = [
    // your previous middleware
    'yourapp.anything.ClassName',
]