Résoudre les erreurs de connexion au sous-domaine Django-Tenant avec les jetons Rest Framework

Gestion des problèmes de connexion aux sous-domaines dans Django-Tenants avec des requêtes de schéma optimisées

Solution backend utilisant Django ORM avec sélection de schéma explicite et gestion des erreurs.

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

Gestion explicite des jetons à l'aide de schémas tenant compte des locataires

Une vue API Django modularisée et réutilisable pour la connexion dans une architecture 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 frontend pour gérer les demandes de connexion aux sous-domaines

Solution JavaScript pour gérer la soumission de formulaires et traiter la connexion basée sur des jetons pour les sous-domaines des locataires.

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

Test unitaire pour vérifier l'authentification par jeton prenant en compte le schéma

Test unitaire en Python pour garantir que l'API gère correctement le changement de schéma.

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

Questions courantes sur les problèmes de connexion Django multi-locataires

1. Qu'est-ce qui cause un 500 Erreur de serveur interne lors de la connexion ?
2. L'erreur se produit parce que Token.objects.get_or_create() interroge le mauvais schéma, provoquant une incohérence lors de la recherche des enregistrements utilisateur.
3. Comment puis-je m'assurer que les requêtes de jetons pointent vers le bon schéma de locataire ?
4. Utiliser schema_context() de la Django-locataires bibliothèque pour encapsuler l’exécution de la requête et passer au schéma correct.
5. Pourquoi la connexion au panneau d'administration fonctionne-t-elle mais la connexion de l'utilisateur échoue ?
6. L'administrateur Django ajuste automatiquement les contextes de schéma, mais les vues personnalisées à l'aide de authenticate() ou Token.objects ne peut pas s'il n'est pas explicitement configuré.
7. Comment récupérer et stocker un jeton de connexion sur le frontend ?
8. Utilisez l'API fetch pour envoyer des informations d'identification, puis stockez le jeton de réponse à l'aide localStorage.setItem() pour une authentification persistante.
9. Comment puis-je afficher de meilleurs messages d’erreur en cas d’échec de connexion ?
10. Implémentez des alertes frontales à l'aide de bibliothèques telles que SweetAlert2 pour informer les utilisateurs des informations d'identification incorrectes ou des problèmes de serveur.

Garantir une connexion fluide sur les sous-domaines des locataires

La résolution des échecs de connexion dans les applications multi-locataires Django nécessite de s'assurer que toutes les requêtes de base de données fonctionnent dans le schéma approprié. En utilisant explicitement des outils tels que le contexte de schéma, nous pouvons garantir que les jetons utilisateur sont récupérés à partir de la bonne base de données de locataires, évitant ainsi les conflits de schéma.

Imaginez travailler sur une plate-forme SaaS où les utilisateurs sont confrontés à des échecs de connexion uniquement sur les sous-domaines. Avec une commutation de schéma appropriée, ces problèmes sont résolus, garantissant une authentification transparente. L'adoption de ce correctif améliore non seulement expérience utilisateur mais garantit également un accès aux données sécurisé et efficace pour chaque locataire. 🔧