Rozwiązywanie błędów logowania do subdomeny Django-Tenant za pomocą tokenów Rest Framework

Obsługa problemów z logowaniem do subdomen w Django-Tenants za pomocą zoptymalizowanych zapytań o schemat

Rozwiązanie backendowe wykorzystujące Django ORM z jawnym wyborem schematu i obsługą błędów.

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

Jawne zarządzanie tokenami przy użyciu schematów obsługujących dzierżawcę

Modułowy widok API Django wielokrotnego użytku do logowania w architekturze z wieloma dzierżawcami.

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)

Skrypt frontendowy do obsługi żądań logowania do subdomen

Rozwiązanie JavaScript do obsługi przesyłania formularzy i przetwarzania logowania opartego na tokenach dla subdomen dzierżawców.

<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 jednostkowy w celu sprawdzenia uwierzytelnienia tokenu uwzględniającego schemat

Test jednostkowy w Pythonie, aby upewnić się, że interfejs API poprawnie obsługuje przełączanie schematów.

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

Często zadawane pytania dotyczące problemów z logowaniem do Django dla wielu dzierżawców

1. Co powoduje 500 Wewnętrzny błąd serwera podczas logowania?
2. Błąd występuje, ponieważ Token.objects.get_or_create() wysyła zapytanie do niewłaściwego schematu, powodując niezgodność podczas wyszukiwania rekordów użytkowników.
3. Jak upewnić się, że zapytania tokenu wskazują prawidłowy schemat dzierżawy?
4. Używać schema_context() z najemcy django biblioteka, aby zakończyć wykonanie zapytania i przełączyć się na właściwy schemat.
5. Dlaczego logowanie do panelu administracyjnego działa, ale logowanie użytkownika nie działa?
6. Administrator Django automatycznie dostosowuje konteksty schematu, ale używa niestandardowych widoków authenticate() Lub Token.objects może nie, chyba że zostanie wyraźnie skonfigurowany.
7. Jak odzyskać i zapisać token logowania na interfejsie użytkownika?
8. Użyj interfejsu API pobierania, aby wysłać dane uwierzytelniające, a następnie zapisz token odpowiedzi za pomocą localStorage.setItem() do trwałego uwierzytelniania.
9. Jak mogę wyświetlać lepsze komunikaty o błędach w przypadku nieudanego logowania?
10. Implementuj alerty frontendowe przy użyciu bibliotek takich jak SweetAlert2 aby powiadomić użytkowników o nieprawidłowych poświadczeniach lub problemach z serwerem.

Zapewnienie płynnego logowania w subdomenach dzierżawców

Rozwiązywanie błędów logowania w aplikacjach Django dla wielu dzierżawców wymaga upewnienia się, że wszystkie zapytania do bazy danych działają w odpowiednim schemacie. Używając jawnie narzędzi, takich jak kontekst schematu, możemy zagwarantować, że tokeny użytkownika zostaną pobrane z właściwej bazy danych dzierżawy, unikając konfliktów schematów.

Wyobraź sobie pracę na platformie SaaS, w której użytkownicy borykają się z błędami logowania tylko w subdomenach. Dzięki odpowiedniemu przełączaniu schematów problemy te zostaną rozwiązane, zapewniając bezproblemowe uwierzytelnianie. Przyjęcie tej poprawki nie tylko poprawia doświadczenie użytkownika ale także gwarantuje bezpieczny i wydajny dostęp do danych dla każdego najemcy. 🔧