Resolver errores de inicio de sesión del subdominio Django-Tenant con tokens Rest Framework

Manejo de problemas de inicio de sesión de subdominios en Django-Tenants con consultas de esquema optimizadas

Solución de backend que utiliza Django ORM con selección de esquema explícita y manejo de errores.

# 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)

Gestión explícita de tokens mediante esquemas compatibles con el inquilino

Una vista API de Django modularizada y reutilizable para iniciar sesión en una arquitectura multiinquilino.

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 interfaz para manejar solicitudes de inicio de sesión de subdominio

Solución de JavaScript para gestionar el envío de formularios y procesar el inicio de sesión basado en tokens para subdominios de inquilinos.

<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>

Prueba unitaria para verificar la autenticación de token compatible con esquemas

Prueba unitaria en Python para garantizar que la API maneje el cambio de esquema correctamente.

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())

Preguntas comunes sobre problemas de inicio de sesión de Django multiinquilino

1. ¿Qué causa un 500 Error interno del servidor durante el inicio de sesión?
2. El error ocurre porque Token.objects.get_or_create() consulta el esquema incorrecto, lo que provoca una falta de coincidencia al buscar registros de usuarios.
3. ¿Cómo me aseguro de que las consultas de tokens apunten al esquema de inquilino correcto?
4. Usar schema_context() desde django-inquilinos biblioteca para ajustar la ejecución de la consulta y cambiar al esquema correcto.
5. ¿Por qué funciona el inicio de sesión del panel de administración pero falla el inicio de sesión del usuario?
6. El administrador de Django ajusta automáticamente los contextos del esquema, pero las vistas personalizadas usan authenticate() o Token.objects puede que no, a menos que se configure explícitamente.
7. ¿Cómo recupero y almaceno un token de inicio de sesión en la interfaz?
8. Utilice la API de recuperación para enviar credenciales y luego almacene el token de respuesta utilizando localStorage.setItem() para autenticación persistente.
9. ¿Cómo puedo mostrar mejores mensajes de error para inicios de sesión fallidos?
10. Implemente alertas de interfaz utilizando bibliotecas como SweetAlert2 para notificar a los usuarios sobre credenciales incorrectas o problemas con el servidor.

Garantizar un inicio de sesión fluido en todos los subdominios de inquilinos

Resolver errores de inicio de sesión en aplicaciones multiinquilino de Django requiere garantizar que todas las consultas de la base de datos funcionen en el esquema adecuado. Al utilizar explícitamente herramientas como el contexto del esquema, podemos garantizar que los tokens de usuario se obtengan de la base de datos de inquilinos correcta, evitando conflictos de esquema.

Imagine trabajar en una plataforma SaaS donde los usuarios enfrentan fallas de inicio de sesión solo en subdominios. Con un cambio de esquema adecuado, estos problemas se resuelven, lo que garantiza una autenticación perfecta. Adoptar esta solución no sólo mejora experiencia de usuario sino que también garantiza un acceso seguro y eficiente a los datos para cada inquilino. 🔧