Update api/views.py

api/views.py

@@ -7,16 +7,9 @@ from .models import Participant, Match, Whitelist
 
 # --- LOGIC HELPER ---
 def calculate_similarity(p1_data, p2_data):
-    """
-    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')} ---")
@@ -25,41 +18,26 @@ def calculate_similarity(p1_data, p2_data):
         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:
             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():
-    """
-    The Core Matching Algorithm (Thread-Safe Version).
-    Uses transaction.atomic() to ensure no double-booking of users.
-    """
     matches_created = []
-
-    # 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
+            .order_by('created_at')
         )
-        
         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:
@@ -68,46 +46,34 @@ def run_matching_logic():
                     best_partner_index = i
             
             if best_partner:
-                # Double check status (redundant but safe)
-                if person_a.is_matched or best_partner.is_matched:
-                    continue
-
+                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
+                    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
 
 # --- ENDPOINTS ---
 
 @api_view(['POST'])
 def verify_user(request):
-    """
-    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 (Redirect Logic)
+    # 1. IF ALREADY REGISTERED -> SEND SPECIAL SUCCESS STATUS (NOT ERROR)
     if Participant.objects.filter(email__iexact=email_input).exists():
         return Response({
             'success': True, 
-            'status': 'registered',  # Special flag for frontend
+            'status': 'registered',  # <--- Front-end looks for this!
             'message': 'User already registered. Redirecting...'
         })
 
-    # 2. CHECK WHITELIST (Supabase Table)
+    # 2. CHECK WHITELIST
     is_allowed = Whitelist.objects.filter(email__iexact=email_input).exists()
 
     if is_allowed:
@@ -120,39 +86,31 @@ def register_participant(request):
     data = request.data
     email = data.get('email')
 
-    # 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': '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'])
 def get_my_match(request):
     email = request.GET.get('email')
-    if not email:
-        return Response({'success': False, 'message': 'Email required'}, status=400)
+    if not email: return Response({'success': False, 'message': 'Email required'}, status=400)
     try:
         me = Participant.objects.get(email=email)
         response_data = {
-            'success': True,
-            'match_found': False,
+            'success': True, 'match_found': False,
             'participant': {'name': me.name, 'email': me.email, 'student_id': me.student_id}
         }
         if me.is_matched: