Что нужно указать во views, чтобы данные отображались только для авторизованный пользователей?

Защита Views в Django: Ограничение доступа для авторизованных пользователей

Краткий ответ

Используй @login_required decorator или LoginRequiredMixin для защиты view функций и классов от неавторизованных пользователей. В Django есть несколько подходов в зависимости от типа view.

1. Функциональные views (FBV)

Использование @login_required:

from django.contrib.auth.decorators import login_required
from django.http import HttpResponse
from django.shortcuts import render

@login_required
def profile(request):
    """Только авторизованные пользователи могут видеть профиль"""
    return render(request, 'profile.html', {
        'user': request.user
    })

@login_required
def edit_post(request, post_id):
    """Редактирование поста доступно только авторизованным"""
    post = Post.objects.get(id=post_id)
    
    if request.user != post.author:
        return HttpResponse("Forbidden", status=403)
    
    if request.method == 'POST':
        post.title = request.POST['title']
        post.save()
    
    return render(request, 'edit_post.html', {'post': post})

Параметры @login_required:

from django.contrib.auth.decorators import login_required

# Перенаправить на кастомный login URL
@login_required(login_url='login')  # По умолчанию '/accounts/login/'
def my_view(request):
    return render(request, 'template.html')

# Или использовать от settings
# settings.py
LOGIN_URL = '/custom-login/'
LOGIN_REDIRECT_URL = '/dashboard/'

# Тогда просто
@login_required
def my_view(request):
    pass

2. Класс-based views (CBV)

Использование LoginRequiredMixin:

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import DetailView, ListView, UpdateView
from .models import Post, UserProfile

# Простой пример
class ProfileDetailView(LoginRequiredMixin, DetailView):
    """Только авторизованные пользователи видят профиль"""
    model = UserProfile
    template_name = 'profile_detail.html'
    context_object_name = 'profile'

# Пример со списком
class PostListView(LoginRequiredMixin, ListView):
    """Только авторизованные видят свои посты"""
    model = Post
    template_name = 'my_posts.html'
    context_object_name = 'posts'
    
    def get_queryset(self):
        """Показать только посты текущего пользователя"""
        return Post.objects.filter(author=self.request.user)

# Пример с обновлением
class PostUpdateView(LoginRequiredMixin, UpdateView):
    """Редактирование поста для авторизованного пользователя"""
    model = Post
    template_name = 'post_update.html'
    fields = ['title', 'content']
    
    def get_queryset(self):
        """Только автор может редактировать"""
        return Post.objects.filter(author=self.request.user)
    
    def get_success_url(self):
        return self.object.get_absolute_url()

Параметры LoginRequiredMixin:

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

class MyView(LoginRequiredMixin, TemplateView):
    # Кастомный URL для перенаправления
    login_url = '/login/'
    
    # Или использовать из settings.LOGIN_URL
    # login_url = None
    
    # Параметр для перенаправления после входа
    redirect_field_name = 'next'  # По умолчанию
    
    template_name = 'my_template.html'

3. Проверка прав доступа (Permission-based)

Когда нужно более сложное управление доступом:

from django.contrib.auth.decorators import permission_required, user_passes_test
from django.contrib.auth.mixins import UserPassesTestMixin
from django.http import HttpResponseForbidden

# Проверка конкретного permission
@permission_required('posts.change_post')
def edit_any_post(request, post_id):
    """Может редактировать любой пост, если есть permission"""
    post = Post.objects.get(id=post_id)
    return render(request, 'edit_post.html', {'post': post})

# Проверка через функцию
def is_moderator(user):
    return user.is_staff or user.groups.filter(name='Moderator').exists()

@user_passes_test(is_moderator)
def moderation_panel(request):
    """Только модераторы видят панель"""
    return render(request, 'moderation.html')

# Для CBV
class ModerationPanelView(UserPassesTestMixin, TemplateView):
    template_name = 'moderation.html'
    
    def test_func(self):
        """Проверка условия доступа"""
        return self.request.user.is_staff or \
               self.request.user.groups.filter(name='Moderator').exists()
    
    # Где перенаправить при отказе
    def handle_no_permission(self):
        from django.shortcuts import redirect
        return redirect('login')

4. Полный пример: Защита данных

from django.db import models
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    is_private = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        permissions = (
            ("can_publish", "Can publish posts"),
            ("can_moderate", "Can moderate posts"),
        )

# Views для защиты
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import ListView, DetailView, UpdateView, DeleteView

class PostListView(LoginRequiredMixin, ListView):
    """Список постов для авторизованных"""
    model = Post
    template_name = 'posts/list.html'
    context_object_name = 'posts'
    paginate_by = 20
    
    def get_queryset(self):
        """Показать публичные посты и личные посты автора"""
        return Post.objects.filter(
            models.Q(is_private=False) |  # Публичные посты
            models.Q(author=self.request.user)  # Личные посты пользователя
        ).order_by('-created_at')

class PostDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
    """Детали поста с проверкой прав"""
    model = Post
    template_name = 'posts/detail.html'
    context_object_name = 'post'
    
    def test_func(self):
        """Только автор может видеть приватный пост"""
        post = self.get_object()
        if post.is_private:
            return self.request.user == post.author
        return True
    
    def handle_no_permission(self):
        from django.http import Http404
        raise Http404("Post not found")

class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
    """Редактирование только для автора"""
    model = Post
    fields = ['title', 'content', 'is_private']
    template_name = 'posts/update.html'
    
    def test_func(self):
        post = self.get_object()
        return self.request.user == post.author
    
    def get_success_url(self):
        return self.object.get_absolute_url()

class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
    """Удаление только для автора"""
    model = Post
    template_name = 'posts/confirm_delete.html'
    
    def test_func(self):
        post = self.get_object()
        return self.request.user == post.author or self.request.user.is_staff
    
    def get_success_url(self):
        return reverse('posts:list')

5. Настройка в settings.py

# settings.py

# URL для перенаправления неавторизованных
LOGIN_URL = 'login'  # имя URL pattern
# или
LOGIN_URL = '/accounts/login/'

# URL для перенаправления после успешного входа
LOGIN_REDIRECT_URL = 'dashboard'

# Установленные приложения
INSTALLED_APPS = [
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    # ...
]

# Middleware для обработки сессий и аутентификации
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',  # Нужна для auth
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',  # Нужна
    'django.contrib.messages.middleware.MessageMiddleware',
    # ...
]

6. URL конфигурация

# urls.py
from django.urls import path
from django.contrib.auth import views as auth_views
from . import views

urlpatterns = [
    # Встроенные views для аутентификации
    path('login/', auth_views.LoginView.as_view(), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
    path('password_reset/', auth_views.PasswordResetView.as_view(), name='password_reset'),
    
    # Твои защищённые views
    path('profile/', views.ProfileDetailView.as_view(), name='profile'),
    path('posts/', views.PostListView.as_view(), name='posts'),
    path('posts/<int:pk>/', views.PostDetailView.as_view(), name='post_detail'),
    path('posts/<int:pk>/edit/', views.PostUpdateView.as_view(), name='post_update'),
    path('posts/<int:pk>/delete/', views.PostDeleteView.as_view(), name='post_delete'),
]

7. Шаблон с проверкой авторизации

<!-- template.html -->
{% if user.is_authenticated %}
    <h1>Welcome, {{ user.username }}!</h1>
    <a href="{% url 'profile' %}">My Profile</a>
    <a href="{% url 'logout' %}">Logout</a>
{% else %}
    <h1>Please login</h1>
    <a href="{% url 'login' %}">Login</a>
    <a href="{% url 'signup' %}">Sign up</a>
{% endif %}

8. Комбинирование нескольких проверок

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import UpdateView
from django.contrib.auth.decorators import login_required, permission_required
from django.utils.decorators import method_decorator

# Для CBV
class AdminPanelView(LoginRequiredMixin, UserPassesTestMixin, TemplateView):
    template_name = 'admin_panel.html'
    
    def test_func(self):
        """Проверка: авторизован И админ"""
        return self.request.user.is_staff

# Для FBV
@login_required
@permission_required('auth.change_user')
def manage_users(request):
    """Нужна авторизация И специальный permission"""
    users = User.objects.all()
    return render(request, 'manage_users.html', {'users': users})

# Для методов в CBV
class SensitiveDataView(LoginRequiredMixin, DetailView):
    model = Document
    
    @method_decorator(permission_required('documents.view_document'))
    def get(self, request, *args, **kwargs):
        return super().get(request, *args, **kwargs)

Итоговая таблица

Вывод: В Django используй @login_required для функциональных views и LoginRequiredMixin для class-based views. Для более сложного управления доступом комбинируй с UserPassesTestMixin и @permission_required. Всегда проверяй права на уровне БД (queryset) и view (decorator/mixin).