Django User Authentication: Login, Logout, and Registration

# Using built-in LoginView
from django.contrib.auth import views as auth_views
from django.urls import path

# urls.py - Direct usage
urlpatterns = [
    path('login/', auth_views.LoginView.as_view(
        template_name='accounts/login.html',
        redirect_authenticated_user=True,
        next_page='dashboard'
    ), name='login'),
]

# Custom LoginView
from django.contrib.auth.views import LoginView
from django.contrib import messages

class CustomLoginView(LoginView):
    template_name = 'accounts/login.html'
    redirect_authenticated_user = True
    
    def get_success_url(self):
        # Custom redirect logic
        if self.request.user.is_staff:
            return reverse_lazy('admin-dashboard')
        return reverse_lazy('user-dashboard')
    
    def form_valid(self, form):
        # Custom logic on successful login
        remember_me = form.cleaned_data.get('remember_me')
        if not remember_me:
            # Session expires when browser closes
            self.request.session.set_expiry(0)
        
        messages.success(self.request, f'Welcome back, {form.get_user().username}!')
        return super().form_valid(form)
    
    def form_invalid(self, form):
        messages.error(self.request, 'Invalid username or password')
        return super().form_invalid(form)

# Login template: accounts/login.html
"""
{% extends 'base.html' %}

{% block content %}
<h2>Login</h2>
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Login</button>
</form>
<p>Don't have an account? <a href="{% url 'register' %}">Register</a></p>
<p><a href="{% url 'password_reset' %}">Forgot password?</a></p>
{% endblock %}
"""

# settings.py
LOGIN_URL = '/login/'
LOGIN_REDIRECT_URL = '/dashboard/'
LOGOUT_REDIRECT_URL = '/'

# Custom authentication form with remember me
from django.contrib.auth.forms import AuthenticationForm
from django import forms

class CustomAuthenticationForm(AuthenticationForm):
    remember_me = forms.BooleanField(required=False, initial=True)
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['username'].widget.attrs.update({
            'class': 'form-control',
            'placeholder': 'Username'
        })
        self.fields['password'].widget.attrs.update({
            'class': 'form-control',
            'placeholder': 'Password'
        })

# Using custom form
class LoginViewWithCustomForm(LoginView):
    template_name = 'accounts/login.html'
    authentication_form = CustomAuthenticationForm

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

# urls.py - Direct usage
urlpatterns = [
    path('logout/', auth_views.LogoutView.as_view(
        next_page='home',
        template_name='accounts/logout.html'
    ), name='logout'),
]

# Custom LogoutView
from django.contrib.auth.views import LogoutView
from django.contrib import messages

class CustomLogoutView(LogoutView):
    template_name = 'accounts/logout.html'
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated:
            messages.success(request, f'Goodbye, {request.user.username}!')
        return super().dispatch(request, *args, **kwargs)

# Function-based logout (alternative)
from django.contrib.auth import logout
from django.shortcuts import redirect

def custom_logout_view(request):
    if request.method == 'POST':
        username = request.user.username
        logout(request)
        messages.success(request, f'You have been logged out, {username}')
        return redirect('home')
    return render(request, 'accounts/logout_confirm.html')

# Logout template with confirmation
"""
{% extends 'base.html' %}

{% block content %}
<h2>Logout</h2>
<form method="post">
    {% csrf_token %}
    <p>Are you sure you want to logout?</p>
    <button type="submit">Confirm Logout</button>
    <a href="{% url 'dashboard' %}">Cancel</a>
</form>
{% endblock %}
"""

# Navigation bar with login/logout
"""
<nav>
    {% if user.is_authenticated %}
        <span>Welcome, {{ user.username }}</span>
        <form method="post" action="{% url 'logout' %}" style="display:inline;">
            {% csrf_token %}
            <button type="submit">Logout</button>
        </form>
    {% else %}
        <a href="{% url 'login' %}">Login</a>
        <a href="{% url 'register' %}">Register</a>
    {% endif %}
</nav>
"""

# Registration implementation
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.contrib.auth import login
from django.views.generic import CreateView
from django.urls import reverse_lazy
from django import forms

# Custom registration form
class CustomUserCreationForm(UserCreationForm):
    email = forms.EmailField(required=True)
    first_name = forms.CharField(max_length=30, required=True)
    last_name = forms.CharField(max_length=30, required=True)
    
    class Meta:
        model = User
        fields = ('username', 'email', 'first_name', 'last_name', 'password1', 'password2')
    
    def clean_email(self):
        email = self.cleaned_data.get('email')
        if User.objects.filter(email=email).exists():
            raise forms.ValidationError('Email already registered')
        return email
    
    def save(self, commit=True):
        user = super().save(commit=False)
        user.email = self.cleaned_data['email']
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        if commit:
            user.save()
        return user

# Registration view
class RegisterView(CreateView):
    form_class = CustomUserCreationForm
    template_name = 'accounts/register.html'
    success_url = reverse_lazy('dashboard')
    
    def dispatch(self, request, *args, **kwargs):
        # Redirect authenticated users
        if request.user.is_authenticated:
            return redirect('dashboard')
        return super().dispatch(request, *args, **kwargs)
    
    def form_valid(self, form):
        # Save user and login automatically
        response = super().form_valid(form)
        user = form.save()
        login(self.request, user)
        messages.success(self.request, f'Welcome, {user.username}! Your account has been created.')
        return response

# Registration with email verification
from django.contrib.sites.shortcuts import get_current_site
from django.template.loader import render_to_string
from django.utils.http import urlsafe_base64_encode
from django.utils.encoding import force_bytes
from django.contrib.auth.tokens import default_token_generator

class RegisterWithEmailView(CreateView):
    form_class = CustomUserCreationForm
    template_name = 'accounts/register.html'
    success_url = reverse_lazy('registration-complete')
    
    def form_valid(self, form):
        user = form.save(commit=False)
        user.is_active = False  # Deactivate until email confirmed
        user.save()
        
        # Send verification email
        current_site = get_current_site(self.request)
        subject = 'Activate Your Account'
        message = render_to_string('accounts/activation_email.html', {
            'user': user,
            'domain': current_site.domain,
            'uid': urlsafe_base64_encode(force_bytes(user.pk)),
            'token': default_token_generator.make_token(user),
        })
        user.email_user(subject, message)
        
        messages.success(self.request, 'Please check your email to activate your account')
        return super().form_valid(form)

# Activation view
from django.utils.http import urlsafe_base64_decode
from django.views import View

class ActivateAccountView(View):
    def get(self, request, uidb64, token):
        try:
            uid = urlsafe_base64_decode(uidb64).decode()
            user = User.objects.get(pk=uid)
        except (TypeError, ValueError, OverflowError, User.DoesNotExist):
            user = None
        
        if user and default_token_generator.check_token(user, token):
            user.is_active = True
            user.save()
            login(request, user)
            messages.success(request, 'Your account has been activated!')
            return redirect('dashboard')
        else:
            messages.error(request, 'Activation link is invalid')
            return redirect('home')

# urls.py
urlpatterns = [
    path('register/', RegisterView.as_view(), name='register'),
    path('activate/<uidb64>/<token>/', ActivateAccountView.as_view(), name='activate'),
]

# Protecting views with decorators and mixins
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import TemplateView, ListView

# Function-based view protection
@login_required
def dashboard_view(request):
    return render(request, 'dashboard.html')

@login_required(login_url='/login/', redirect_field_name='next')
def profile_view(request):
    return render(request, 'profile.html', {'user': request.user})

# Class-based view protection
class DashboardView(LoginRequiredMixin, TemplateView):
    template_name = 'dashboard.html'
    login_url = '/login/'
    redirect_field_name = 'next'

class ProfileView(LoginRequiredMixin, TemplateView):
    template_name = 'profile.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['user_posts'] = Post.objects.filter(author=self.request.user)
        return context

# Custom authorization test
class UserPostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
    model = Post
    fields = ['title', 'content']
    template_name = 'post_form.html'
    
    def test_func(self):
        post = self.get_object()
        return self.request.user == post.author

# Template usage
"""
{% if user.is_authenticated %}
    <p>Welcome, {{ user.username }}!</p>
    <a href="{% url 'logout' %}">Logout</a>
{% else %}
    <a href="{% url 'login' %}">Login</a>
{% endif %}
"""