Logic changed for existing user

api/views.py

@@ -1,50 +1,92 @@
 from django.conf import settings
+from django.db import transaction
+from django.db.models import Q
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
 from .models import Participant, Match, Whitelist
-from django.db.models import Q
 
 # --- LOGIC HELPER ---
 def calculate_similarity(p1_data, p2_data):
-    score = 0
+    """
+    Advanced Matching Logic:
+    - Starts with 30% Base Compatibility.
+    - Remaining 70% is distributed among the 15 questions.
+    """
+    base_score = 30.0
     total_questions = 15
+    matches_found = 0
+    
+    # Calculate points per question (approx 4.66%)
+    points_per_match = 70.0 / total_questions
+    
+    print(f"--- COMPARING {p1_data.get('name', 'User A')} vs {p2_data.get('name', 'User B')} ---")
+    
     for i in range(1, total_questions + 1):
         key = f'q{i}'
         val1 = p1_data.get(key)
         val2 = p2_data.get(key)
+        
+        # Check for exact match (A==A, B==B)
         if val1 and val2 and val1 == val2:
-            score += 1
-    return round((score / total_questions) * 100, 1)
+            matches_found += 1
+            
+    final_score = base_score + (matches_found * points_per_match)
+    print(f"Matches: {matches_found}/{total_questions} | Final Score: {round(final_score, 1)}%")
+    
+    return min(round(final_score, 1), 100.0)
 
 def run_matching_logic():
-    unmatched_pool = list(Participant.objects.filter(is_matched=False))
+    """
+    The Core Matching Algorithm (Thread-Safe Version).
+    Uses transaction.atomic() to ensure no double-booking of users.
+    """
     matches_created = []
-    
-    while len(unmatched_pool) >= 2:
-        person_a = unmatched_pool.pop(0)
-        best_partner = None
-        best_score = -1
-        best_partner_index = -1
-        
-        for i, candidate in enumerate(unmatched_pool):
-            score = calculate_similarity(person_a.quiz_data, candidate.quiz_data)
-            if score > best_score:
-                best_score = score
-                best_partner = candidate
-                best_partner_index = i
+
+    # Lock the database rows to prevent concurrent matches
+    with transaction.atomic():
+        # Fetch only users who are strictly NOT matched yet
+        # select_for_update() locks these rows until the transaction finishes
+        unmatched_pool = list(
+            Participant.objects.select_for_update()
+            .filter(is_matched=False)
+            .order_by('created_at') # Order ensures consistent locking
+        )
         
-        if best_partner:
-            Match.objects.create(
-                participant_1=person_a,
-                participant_2=best_partner,
-                compatibility_score=best_score
-            )
-            person_a.is_matched = True
-            best_partner.is_matched = True
-            person_a.save()
-            best_partner.save()
-            unmatched_pool.pop(best_partner_index)
-            matches_created.append(f"{person_a.name} & {best_partner.name}")
+        while len(unmatched_pool) >= 2:
+            person_a = unmatched_pool.pop(0)
+            
+            best_partner = None
+            best_score = -1
+            best_partner_index = -1
+            
+            # Compare person_a against everyone else waiting
+            for i, candidate in enumerate(unmatched_pool):
+                score = calculate_similarity(person_a.quiz_data, candidate.quiz_data)
+                if score > best_score:
+                    best_score = score
+                    best_partner = candidate
+                    best_partner_index = i
+            
+            if best_partner:
+                # Double check status (redundant but safe)
+                if person_a.is_matched or best_partner.is_matched:
+                    continue
+
+                Match.objects.create(
+                    participant_1=person_a,
+                    participant_2=best_partner,
+                    compatibility_score=best_score
+                )
+                
+                # Mark both as matched
+                person_a.is_matched = True
+                best_partner.is_matched = True
+                person_a.save()
+                best_partner.save()
+                
+                # Remove partner from the pool so they aren't matched again
+                unmatched_pool.pop(best_partner_index)
+                matches_created.append(f"{person_a.name} & {best_partner.name} ({best_score}%)")
 
     return matches_created
 
@@ -53,20 +95,23 @@ def run_matching_logic():
 @api_view(['POST'])
 def verify_user(request):
     """
-    Checks if Email exists in the Supabase Whitelist table.
+    Checks if Email exists in Whitelist AND if they are already registered.
     """
     email_input = request.data.get('email', '').strip().lower()
     
-    # 1. Check if already registered (Prevent duplicate work)
+    # 1. CHECK IF ALREADY REGISTERED (Redirect Logic)
     if Participant.objects.filter(email__iexact=email_input).exists():
-        return Response({'success': False, 'message': 'You are already registered!'}, status=400)
+        return Response({
+            'success': True, 
+            'status': 'registered',  # Special flag for frontend
+            'message': 'User already registered. Redirecting...'
+        })
 
-    # 2. Check the Whitelist Table (Database)
-    # iexact makes it case-insensitive
+    # 2. CHECK WHITELIST (Supabase Table)
     is_allowed = Whitelist.objects.filter(email__iexact=email_input).exists()
 
     if is_allowed:
-        return Response({'success': True, 'message': 'Verified'})
+        return Response({'success': True, 'status': 'new', 'message': 'Verified'})
     else:
         return Response({'success': False, 'message': 'Access Denied: Email not in whitelist.'}, status=403)
 
@@ -75,26 +120,27 @@ def register_participant(request):
     data = request.data
     email = data.get('email')
 
-    # Double check whitelist (security best practice)
+    # Security: Double check whitelist before saving
     if not Whitelist.objects.filter(email__iexact=email).exists():
          return Response({'success': False, 'message': 'Email removed from whitelist.'}, status=403)
 
     if Participant.objects.filter(email=email).exists():
-        return Response({
-            'success': False, 
-            'message': 'This email is already registered.'
-        }, status=400)
+        return Response({'success': False, 'message': 'Already registered.'}, status=400)
 
+    # Save User
     participant = Participant.objects.create(
         name=data.get('name'),
         email=email,
         student_id=data.get('student_id'),
         role=data.get('role', 'fullstack'),
+        # Save only question answers (q1, q2...)
         quiz_data={k: v for k, v in data.items() if k.startswith('q')},
         is_matched=False
     )
     
+    # Run Matching Immediately
     run_matching_logic()
+    
     return Response({'success': True, 'id': participant.id})
 
 @api_view(['GET'])