Løse Django-Tenant Subdomain Login Feil med Rest Framework Tokens

Håndtering av underdomenepåloggingsproblemer i Django-Tenants med optimaliserte skjemaforespørsler

Backend-løsning med Django ORM med eksplisitt skjemavalg og feilhåndtering.

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

Eksplisitt tokenadministrasjon ved bruk av leietakerbevisste skjemaer

En modularisert og gjenbrukbar Django API View for pålogging i en multi-tenant-arkitektur.

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)

Frontend-skript for håndtering av påloggingsforespørsler for underdomene

JavaScript-løsning for å håndtere innsending av skjemaer og behandle token-basert pålogging for leietakers underdomener.

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

Enhetstest for å bekrefte Schema-Aware Token Authentication

Enhetstest i Python for å sikre at API-en håndterer skjemabytte riktig.

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

Vanlige spørsmål om Django-påloggingsproblemer med flere leietakere

1. Hva forårsaker a 500 Intern serverfeil under pålogging?
2. Feilen oppstår pga Token.objects.get_or_create() spør etter feil skjema, noe som forårsaker uoverensstemmelse når du slår opp brukerposter.
3. Hvordan sikrer jeg at tokenspørringer peker til riktig leietakerskjema?
4. Bruk schema_context() fra django-leietakere biblioteket for å omslutte spørringskjøringen og bytte til riktig skjema.
5. Hvorfor fungerer administrasjonspanelets pålogging, men brukerinnloggingen mislykkes?
6. Django-administratoren justerer automatisk skjemakontekster, men tilpassede visninger ved hjelp av authenticate() eller Token.objects kanskje ikke med mindre det er eksplisitt konfigurert.
7. Hvordan henter og lagrer jeg et påloggingstoken på frontend?
8. Bruk hente-API-en til å sende legitimasjon, og lagre deretter svartokenet ved hjelp av localStorage.setItem() for vedvarende autentisering.
9. Hvordan kan jeg vise bedre feilmeldinger for mislykkede pålogginger?
10. Implementer frontend-varsler ved å bruke biblioteker som SweetAlert2 for å varsle brukere om feil legitimasjon eller serverproblemer.

Sikre jevn pålogging på tvers av leietakers underdomener

Å løse påloggingsfeil i Django multi-tenant-apper krever å sikre at alle databasespørringer fungerer i riktig skjema. Ved eksplisitt å bruke verktøy som skjemakontekst, kan vi garantere at brukertokener hentes fra riktig leietakerdatabase, og unngår skjemakonflikter.

Tenk deg å jobbe på en SaaS-plattform der brukere møter påloggingsfeil kun på underdomener. Med riktig skjemabytte løses disse problemene, noe som sikrer sømløs autentisering. Å ta i bruk denne løsningen forbedrer ikke bare brukeropplevelse men garanterer også sikker, effektiv datatilgang for hver leietaker. 🔧