Qual è l'opposto di @login_required decorator per le viste Django?

Question

Se voglio assicurarmi che una vista sia elencata come dotata di accesso pubblico, c'è un decoratore equivalente a @public_access che sarebbe l'opposto di @login_required e chiarire che la vista dovrebbe essere accessibile pubblicamente sempre?

Un caso d'uso che ho in mente è quello di aggiungere automaticamente "@csrf_exempt" per tutte le opinioni pubbliche oltre a rendere in chiaro nel codice che la vista dovrebbe essere accessibile al pubblico.

Answer 1

Purtroppo, non c'è attualmente alcun supporto integrato per questo in Django, lasciando a rischio di esporre informazioni sensibili quando @login_required è accidentalmente dimenticato.

Ecco una soluzione da uno dei miei progetti:

middleware/security.py:

def public(function): 
    """Decorator for public views that do not require authentication 
    """ 
    orig_func = function 
    while isinstance(orig_func, partial): # if partial - use original function for authorization 
     orig_func = orig_func.func 
    orig_func.is_public_view = True 

    return function 

def is_public(function): 
    try:         # cache is found 
     return function.is_public_view 
    except AttributeError:     # cache is not found 
     result = function.__module__.startswith('django.') and not function.__module__.startswith('django.views.generic') # Avoid modifying admin and other built-in views 

     try:        # try to recreate cache 
      function.is_public_view = result 
     except AttributeError: 
      pass 

     return result 


class NonpublicMiddleware(object): 

    def process_view_check_logged(self, request, view_func, view_args, view_kwargs): 
     return 

    def process_view(self, request, view_func, view_args, view_kwargs): 
     while isinstance(view_func, partial): # if partial - use original function for authorization 
      view_func = view_func.func 

     request.public = is_public(view_func) 
     if not is_public(view_func): 
      if request.user.is_authenticated():  # only extended checks are needed 
       return self.process_view_check_logged(request, view_func, view_args, view_kwargs) 

      return self.redirect_to_login(request.get_full_path()) # => login page 

    def redirect_to_login(self, original_target, login_url=settings.LOGIN_URL): 
     return HttpResponseRedirect("%s?%s=%s" % (login_url, REDIRECT_FIELD_NAME, urlquote(original_target))) 

settings.py:

MIDDLEWARE_CLASSES = (
    #... 
    'middleware.security.NonpublicProfilefullMiddleware', 
    #... 
) 

e, infine, codice della vista:

from <projname>.middleware import publi 

@public 
def some_view(request): 
    #... 

# Login required is added automatically 
def some_private_view(request): 
    #... 

Inoltre, potresti voler dare un'occhiata al post del blog "Automatically decorating all views of a django project"

Answer 2

"Login non richiesto" è l'impostazione predefinita. Se si desidera annotare che una vista non deve mai essere limitata al login, è necessario farlo nella docstring.

Answer 3

Come un precedente poster menzionato, l'accesso non richiesto è l'impostazione predefinita.

Tuttavia, a volte è utile per bloccare certe viste da utenti registrati - per esempio, non ha senso per un utente connesso per essere in grado di utilizzare pagina di registrazione del sito. In tal caso, si potrebbe fare qualcosa di simile, in base al largo la login_required decoratore esistente

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

LOGGED_IN_HOME = settings.LOGGED_IN_HOME 

def login_forbidden(function=None, redirect_field_name=None, redirect_to=LOGGED_IN_HOME): 
    """ 
    Decorator for views that checks that the user is NOT logged in, redirecting 
    to the homepage if necessary. 
    """ 
    actual_decorator = user_passes_test(
     lambda u: not u.is_authenticated(), 
     login_url=redirect_to, 
     redirect_field_name=redirect_field_name 
    ) 
    if function: 
     return actual_decorator(function) 
    return actual_decorator 

Answer 4

un po 'tardi, ma un altro modo semplice per affrontare questo problema sarebbe quella di fare affidamento su un'altra decoratore e aggiungere una funzione lambda:

from django.contrib.auth.decorators import user_passes_test 

@user_passes_test(lambda u: u.is_anonymous) 

Answer 5

@permission_classes ([permissions.AllowAny])