Resolvendo erros de login de subdomínio Django-Tenant com tokens Rest Framework

Lidando com problemas de login de subdomínio em Django-Tenants com consultas de esquema otimizadas

Solução de backend usando Django ORM com seleção explícita de esquema e tratamento de erros.

# Import necessary libraries
from django.db import connection
from rest_framework.authtoken.models import Token
from django.contrib.auth import authenticate, login
from django.http import JsonResponse
from django_tenants.utils import schema_context
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def dual_login_view(request):
    """Handle login for multi-tenant subdomains with correct schema."""
    if request.method == "POST":
        username = request.POST.get("login")
        password = request.POST.get("password")
        tenant_schema_name = connection.tenant.schema_name
        try:
            # Switch to the correct tenant schema
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is not None:
                    login(request, user)
                    # Generate or retrieve token
                    token, created = Token.objects.get_or_create(user=user)
                    return JsonResponse({"status": "success", "token": token.key})
                else:
                    return JsonResponse({"status": "error", "message": "Invalid credentials"}, status=400)
        except Exception as e:
            return JsonResponse({"status": "error", "message": str(e)}, status=500)
    return JsonResponse({"status": "error", "message": "Invalid request method"}, status=405)

Gerenciamento explícito de tokens usando esquemas com reconhecimento de locatário

Uma API Django modularizada e reutilizável para login em uma arquitetura multi-tenant.

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
from django_tenants.utils import schema_context
class TenantAwareLoginAPIView(APIView):
    """Login endpoint that ensures tenant-aware schema handling."""
    def post(self, request):
        username = request.data.get("username")
        password = request.data.get("password")
        tenant_schema_name = request.tenant.schema_name
        if not username or not password:
            return Response({"error": "Username and password required"}, status=status.HTTP_400_BAD_REQUEST)
        try:
            with schema_context(tenant_schema_name):
                user = authenticate(request, username=username, password=password)
                if user is None:
                    return Response({"error": "Invalid credentials"}, status=status.HTTP_401_UNAUTHORIZED)
                # Generate or retrieve token for the user
                token, created = Token.objects.get_or_create(user=user)
                return Response({"token": f"Token {token.key}"}, status=status.HTTP_200_OK)
        except Exception as e:
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

Script de front-end para lidar com solicitações de login de subdomínio

Solução JavaScript para lidar com o envio de formulários e processar login baseado em token para subdomínios de locatários.

<script>
document.querySelector('form').addEventListener('submit', function(event) {
    event.preventDefault();
    let form = event.target;
    let formData = new FormData(form);
    fetch("{% url 'tenant_aware_login' %}", {
        method: 'POST',
        body: JSON.stringify(Object.fromEntries(formData)),
        headers: {
            'Content-Type': 'application/json',
            'X-CSRFToken': formData.get('csrfmiddlewaretoken')
        }
    })
    .then(response => {
        if (!response.ok) throw new Error('Server Error');
        return response.json();
    })
    .then(data => {
        if (data.token) {
            localStorage.setItem('token', data.token);
            window.location.href = '/';
        } else {
            Swal.fire({
                icon: 'error',
                title: 'Login Failed',
                text: data.error || 'Invalid credentials'
            });
        }
    })
    .catch(error => {
        console.error('Error:', error);
    });
});
</script>

Teste de unidade para verificar a autenticação de token com reconhecimento de esquema

Teste de unidade em Python para garantir que a API lide com a alternância de esquema corretamente.

from django.test import TestCase
from rest_framework.test import APIClient
from django_tenants.utils import schema_context
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
class TenantLoginTest(TestCase):
    def setUp(self):
        self.client = APIClient()
        with schema_context('test_tenant'):  # Switch to tenant schema
            self.user = User.objects.create_user(username='testuser', password='testpass')
    def test_successful_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'testuser',
                'password': 'testpass'
            })
            self.assertEqual(response.status_code, 200)
            self.assertIn('token', response.json())
    def test_invalid_login(self):
        with schema_context('test_tenant'):
            response = self.client.post('/api/login/', {
                'username': 'wronguser',
                'password': 'wrongpass'
            })
            self.assertEqual(response.status_code, 401)
            self.assertIn('error', response.json())

Perguntas comuns sobre problemas de login do Django multilocatário

1. O que causa um 500 Erro interno do servidor durante o login?
2. O erro ocorre porque Token.objects.get_or_create() consulta o esquema errado, causando uma incompatibilidade ao procurar registros do usuário.
3. Como posso garantir que as consultas de token apontem para o esquema de locatário correto?
4. Usar schema_context() do inquilinos Django biblioteca para encerrar a execução da consulta e mudar para o esquema correto.
5. Por que o login do painel de administração funciona, mas o login do usuário falha?
6. O administrador do Django ajusta automaticamente os contextos do esquema, mas as visualizações personalizadas usando authenticate() ou Token.objects não pode, a menos que seja explicitamente configurado.
7. Como recupero e armazeno um token de login no frontend?
8. Use a API fetch para enviar credenciais e, em seguida, armazene o token de resposta usando localStorage.setItem() para autenticação persistente.
9. Como posso exibir mensagens de erro melhores para logins com falha?
10. Implemente alertas de front-end usando bibliotecas como SweetAlert2 para notificar os usuários sobre credenciais incorretas ou problemas de servidor.

Garantindo login tranquilo em subdomínios de locatários

Resolver falhas de login em aplicativos Django multilocatários requer a garantia de que todas as consultas ao banco de dados operem no esquema adequado. Ao usar explicitamente ferramentas como contexto de esquema, podemos garantir que os tokens do usuário sejam obtidos do banco de dados de locatários correto, evitando conflitos de esquema.

Imagine trabalhar em uma plataforma SaaS onde os usuários enfrentam falhas de login apenas em subdomínios. Com a troca de esquema adequada, esses problemas são resolvidos, garantindo uma autenticação perfeita. Adotar essa correção não apenas melhora experiência do usuário mas também garante acesso seguro e eficiente aos dados para cada locatário. 🔧