feat: add matching api functions

app/main.py

@@ -1,13 +1,14 @@
 import os
 import sendgrid
 from sendgrid.helpers.mail import Mail
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Query
 from supabase import create_client
 from dotenv import load_dotenv
 from datetime import datetime, timedelta
 
 from app.utils import *
 from app.models import *
+from app.services import get_candidates, match_user_to_mentors
 
 
 load_dotenv()
@@ -33,24 +34,6 @@ JWT_EXPIRES_IN = os.getenv("JWT_EXPIRES_IN")
 app = FastAPI()
 
 
-@app.get("/")
-def root():
-    return {"success": True, "message": "API is running"}
-
-
-@app.get("/users")
-def get_users():
-    response = supabase.table("users").select("*").execute()
-    return response.data
-
-
-@app.post("/add_user")
-def add_user(email: str):
-    response = supabase.table("users").insert({
-        "email": email
-    }).execute()
-    return {"status": "ok", "inserted": response.data}
-
 @app.post("/auth/send-verification")
 def send_verification(data: EmailRequest):
     email = data.email
@@ -173,3 +156,213 @@ def verify(data: VerifyRequest):
             "onboardingCompleted": user['onboardingCompleted']
         }
     }
+
+
+@app.post("/matches/candidates")
+def match_candidate(
+    data: UserRequest,
+    limit: int = Query(20),
+    offset: int = Query(0)
+):
+    user_id = data.user_id
+    return get_candidates(user_id, limit=limit, offset=offset, supabase=supabase)
+
+
+@app.post("/matches/request")
+def match_request(data: MatchRequest):
+    user_id             = data.user_id
+    candidate_id        = data.candidate_id
+    candidate_name      = data.candidate_name
+    message             = data.message
+    compatibility_score = data.compatibility_score
+
+    # Insert match request into the database
+    response = supabase.table("matches").insert({
+        "mentee_id": user_id,
+        "mentor_id": candidate_id,
+        "message": message,
+        "compatibility_score": compatibility_score,
+    })
+
+    if response.error:
+        raise HTTPException(status_code=500, detail="Error creating match request")
+    
+    match_data = response.execute().data[0]
+
+    return {
+        "success": True,
+        "match": {
+            "id": match_data["id"],
+            "mentee_id": match_data["mentee_id"],
+            "mentor_id": match_data["mentor_id"],
+            "message": match_data["message"],
+            "compatibility_score": match_data["compatibility_score"],
+            "created_at": match_data["created_at"]
+        },
+        "message": f"Solicitud enviada a {candidate_name}. Te notificaremos cuando responda."
+    }
+
+
+@app.get("/matches/skip")
+def match_skip():
+    return {
+        "success": True,
+        "message": "Candidato omitido. Mostrando siguiente."
+    }
+
+
+@app.post("/matches/my-matches")
+def get_matches(
+    data: UserRequest,
+    status: str = Query("all"),
+    role: str = Query("all")
+):
+    user_id = data.user_id
+    
+    # Build filters
+    query = supabase.table("matches").select("*")
+
+    if status != "all":
+        query = query.eq("status", status)
+    
+    if role == "mentor":
+        query = query.eq("mentor_id", user_id)
+    elif role == "mentee":
+        query = query.eq("mentee_id", user_id)
+    else:
+        query = query.or_(f"mentor_id.eq.{user_id},mentee_id.eq.{user_id}")
+    
+    # Execute
+    response = query.execute()
+    matches = response.data
+
+    full_matches = []
+    status_count = {
+        "pending": 0,
+        "active": 0,
+        "completed": 0
+    }
+
+    for m in matches:
+        if m["status"] in status_count:
+            status_count[m["status"]] += 1
+        
+        if m["mentee_id"] == user_id:
+            other_user_id = m["mentor_id"]
+        else:
+            other_user_id = m["mentee_id"]
+        
+        user_response = (
+            supabase.table("users")
+            .select("*")
+            .eq("id", other_user_id)
+            .execute()
+        )
+
+        if not user_response.data:
+            continue
+            
+        other_user = user_response.data[0]
+
+        # Mock
+        last_message = {
+            "content": "Último mensaje de prueba",
+            "sentAt": "2024-11-02T10:20:00Z",
+            "isRead": True
+        }
+
+        upcoming_session = {
+            "id": "session-mock-1",
+            "scheduledAt": "2024-11-06T16:00:00Z",
+            "duration": 60
+        }
+
+        stats = {
+            "totalSessions": 2,
+            "totalMessages": 15
+        }
+
+        full_matches.append({
+            "id": m["id"],
+            "status": m["status"],
+            "matchType": m["match_type"],
+            "compatibilityScore": m["compatibility_score"],
+            "createdAt": m["created_at"],
+            "acceptedAt": m["accepted_at"],
+            "otherUser": {
+                "id": other_user["id"],
+                "firstName": other_user["firstname"],
+                "lastName": other_user["lastname"][0] + '.',
+                "profileImage": other_user["profileimage"],
+                "career": other_user["career"],
+                "semester": other_user["semester"],
+            },
+            "lastMessage": last_message,
+            "upcomingSession": upcoming_session,
+            "stats": stats
+        })
+    
+    return {
+        "matches": full_matches,
+        "counts": status_count
+    }
+
+
+@app.post("/matches/{match_id}/respond")
+def respond_match(
+    match_id: str,
+    data: MatchRespondRequest
+):
+    match_res = (
+        supabase.table("matches")
+        .select("*")
+        .eq("id", match_id)
+        .execute()
+    )
+
+    if not match_res.data:
+        raise HTTPException(status_code=404, detail="Match not found")
+    
+    user_id = data.user_id
+    action = data.action
+    message = data.message
+    match_data = match_res.data[0]
+
+    if match_data["mentor_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Unauthorized action")
+    
+    new_status = "accepted" if action == "accept" else "rejected"
+    update_data = {
+        "status": new_status,
+        "message": message or None,
+        "accepted_at": None,
+    }
+
+    if action == "accept":
+        update_data["accepted_at"] = datetime.utcnow().isoformat()
+    
+    update_res = (
+        supabase.table("matches")
+        .update(update_data)
+        .eq("id", match_id)
+        .execute()
+    )
+
+    updated_match = update_res.data[0]
+
+    points_earned = 50 if action == "accept" else 0
+
+    return {
+        "success": True,
+        "match": {
+            "id": updated_match["id"],
+            "status": updated_match["status"],
+            "acceptedAt": updated_match["accepted_at"],
+        },
+        "pointsEarned": points_earned,
+        "message": (
+            "Match aceptado! Ahora pueden chatear y agendar sesiones."
+            if action == "accept"
+            else "Has rechazado la solicitud."
+        )   
+    }

app/models.py

@@ -1,8 +1,25 @@
 from pydantic import BaseModel, EmailStr
+from typing import Optional
 
 class EmailRequest(BaseModel):
     email: EmailStr
 
 class VerifyRequest(BaseModel):
     email: EmailStr
-    code: str
+    code: str
+
+class UserRequest(BaseModel):
+    user_id: int
+
+class MatchRequest(BaseModel):
+    user_id: int
+    candidate_id: int
+    candidate_name: str
+    message: Optional[str] = None
+    match_type: Optional[str] = 'MENTOR'
+    compatibility_score: Optional[int] = 0
+
+class MatchRespondRequest(BaseModel):
+    user_id: int
+    action: str
+    message: Optional[str] = None

app/services.py

@@ -0,0 +1,263 @@
+from sentence_transformers import SentenceTransformer, util
+
+# Embedder instance and weights for different criteria
+embedder = SentenceTransformer("intfloat/multilingual-e5-small")
+WEIGHTS = {
+    "weakness_support": 3.0,
+    "interest_semantic": 2.0,
+    "future_roles_semantic": 1.5,
+    "study_style": 1.2,
+    "bio_semantic": 1.0,
+    "career_match": 0.8,
+    "semester_advantage": 0.5,
+}
+
+
+# Get functions
+def get_mentors(user_id: int, supabase: any):
+    response = (
+        supabase.table("user_grades")
+        .select("*, users!inner(*, user_profiles(*))")
+        .eq("status", "approved")
+        .neq("user_id", user_id)
+        .execute()
+    )
+
+    mentors = []
+    for record in response.data:
+        user = record['users']
+        user_profile = user['user_profiles']
+
+        mentor = {
+            'coursename': record['coursename'],
+            'grade': record['grade'],
+            'id': f"uuid-{user['id']}",
+            'firstName': user['firstname'],
+            'lastName': user['lastname'],
+            'career': user['career'],
+            'semester': user['semester'],
+            'profileimage': user['profileimage'],
+            'bio': user_profile['bio'],
+            'strengths': user_profile['strengths'],
+            'futureroles': user_profile['futureroles'],
+            'studystyle': user_profile['studystyle'],
+            'availabletimes': user_profile['availabletimes'],
+            'careerinterests': user_profile['careerinterests']
+        }
+
+        mentors.append(mentor)
+    
+    grouped = {}
+
+    for m in mentors:
+        name = m["firstName"]
+
+        if name not in grouped:
+            grouped[name] = {
+                "id": m["id"],
+                "firstName": m["firstName"],
+                "lastName": m["lastName"],
+                "career": m["career"],
+                "semester": m["semester"],
+                "profileImage": m["profileimage"],
+                "bio": m["bio"],
+                "strengths": m["strengths"],
+                "futureroles": m["futureroles"],
+                "studystyle": m["studystyle"],
+                "availabletimes": m["availabletimes"],
+                "careerinterests": m["careerinterests"],
+                "courses": []
+            }
+
+        grouped[name]["courses"].append({
+            "coursename": m["coursename"],
+            "grade": m["grade"]
+        })
+    
+    return {"mentors": list(grouped.values())}
+
+def get_user_profile(user_id: int, supabase: any):
+    response = (
+        supabase.table("users")
+        .select("*, user_profiles(*)")
+        .eq("id", user_id)
+        .execute()
+    )
+
+    user = response.data[0]
+
+    return {
+        'career': user['career'],
+        'semester': user['semester'],
+        'bio': user['user_profiles']['bio'],
+        'weaknesses': user['user_profiles']['weaknesses'],
+        'futureroles': user['user_profiles']['futureroles'],
+        'studystyle': user['user_profiles']['studystyle'],
+        'availabletimes': user['user_profiles']['availabletimes'],
+        'careerinterests': user['user_profiles']['careerinterests']
+    }
+
+def extract_common_interests(user, mentor):
+    ui = set(user.get("careerinterests", []))
+    mi = set(mentor.get("careerinterests", []))
+    return list(ui & mi)
+
+
+# Similarity functions
+def text_list_similarity(list1, list2):
+    if not list1 or not list2:
+        return 0.0
+
+    sims = []
+    for t1 in list1:
+        emb1 = embedder.encode(t1, normalize_embeddings=True)
+        for t2 in list2:
+            emb2 = embedder.encode(t2, normalize_embeddings=True)
+            sims.append(float(util.cos_sim(emb1, emb2)))
+
+    if not sims:
+        return 0.0
+
+    # Return average similarity
+    return sum(sims) / len(sims)
+
+def compute_embedding_similarity(text1, text2):
+    emb1 = embedder.encode(text1, normalize_embeddings=True)
+    emb2 = embedder.encode(text2, normalize_embeddings=True)
+    return float(util.cos_sim(emb1, emb2))
+
+
+# Matching function
+def match_user_to_mentors(user, mentors):
+    results = []
+
+    for mentor in mentors:
+        score = 0
+        reasons = []
+
+        # ------------------------------------------------------
+        # 1. Weakness support
+        # ------------------------------------------------------
+        if "weaknesses" in user and "courses" in mentor:
+            mentor_courses = {c["coursename"].lower(): c["grade"] for c in mentor["courses"]}
+
+            for weak in user["weaknesses"]:
+                w = weak.lower()
+                if w in mentor_courses and mentor_courses[w] >= 15:
+                    score += WEIGHTS["weakness_support"]
+                    reasons.append(f"El mentor tiene buena calificación en {weak}.")
+
+        # ------------------------------------------------------
+        # 2. Interest semantic
+        # ------------------------------------------------------
+        interest_sim = text_list_similarity(
+            user.get("careerinterests", []),
+            mentor.get("careerinterests", [])
+        )
+        if interest_sim > 0.3:
+            score += interest_sim * WEIGHTS["interest_semantic"]
+            reasons.append(f"Alta similitud semántica en intereses ({interest_sim:.2f}).")
+
+        # ------------------------------------------------------
+        # 3. Future roles semantic
+        # ------------------------------------------------------
+        roles_sim = text_list_similarity(
+            user.get("futureroles", []),
+            mentor.get("futureroles", [])
+        )
+        if roles_sim > 0.3:
+            score += roles_sim * WEIGHTS["future_roles_semantic"]
+            reasons.append(f"Similitud en roles futuros ({roles_sim:.2f}).")
+
+        # ------------------------------------------------------
+        # 4. Study style
+        # ------------------------------------------------------
+        if user["studystyle"] == mentor["studystyle"]:
+            score += WEIGHTS["study_style"]
+            reasons.append(f"Ambos tienen un estilo de estudio similar: {user['studystyle']}.")
+
+        # ------------------------------------------------------
+        # 5. Career match
+        # ------------------------------------------------------
+        if user["career"] == mentor["career"]:
+            score += WEIGHTS["career_match"]
+
+        # ------------------------------------------------------
+        # 6. Semester advantage
+        # ------------------------------------------------------
+        if mentor["semester"] > user["semester"]:
+            score += WEIGHTS["semester_advantage"]
+
+        # ------------------------------------------------------
+        # 7. Bio semantic
+        # ------------------------------------------------------
+        sim = compute_embedding_similarity(user["bio"], mentor["bio"])
+        score += sim * WEIGHTS["bio_semantic"]
+
+        # ------------------------------------------------------
+        # Save result
+        # ------------------------------------------------------
+        results.append({
+            "mentor": mentor,
+            "compatibilityScore": round(score * 10, 2),
+            "matchReasons": reasons
+        })
+
+    results.sort(key=lambda x: x["compatibilityScore"], reverse=True)
+
+    return {
+        "candidates": results,
+        "total": len(results)
+    }
+
+def format_match_result(raw, user):
+    mentor = raw["mentor"]
+
+    return {
+        "id": mentor.get("id", None),  # si no tienes id aún puedes dejar None
+        "user": {
+            "id": mentor.get("id", None),
+            "firstName": mentor["firstName"],
+            "lastName": mentor["lastName"][0] + '.',
+            "career": mentor["career"],
+            "semester": mentor["semester"],
+            "profileImage": mentor.get("profileImage", None),
+            "bio": mentor["bio"]
+        },
+        "compatibilityScore": raw["compatibilityScore"],
+        "matchType": "MENTOR",
+        "matchReasons": raw["matchReasons"],
+        "commonInterests": extract_common_interests(user, mentor),
+        "mentorStats": {
+            "successRate": mentor.get("successRate", 0),
+            "avgRating": mentor.get("avgRating", 0),
+            "totalSessions": mentor.get("totalSessions", 0)
+        }
+    }
+
+def get_candidates(user_id: int, limit: int, offset: int, supabase):
+    user = get_user_profile(user_id, supabase)
+    mentors_data = get_mentors(user_id, supabase)
+    mentors = mentors_data["mentors"]
+
+    # Matching
+    match_results = match_user_to_mentors(user, mentors)
+    candidates = match_results["candidates"]
+
+    total = len(candidates)
+
+    # Pagination
+    sliced = candidates[offset : offset + limit]
+
+    # Final formatting
+    formatted = [format_match_result(c, user) for c in sliced]
+
+    return {
+        "candidates": formatted,
+        "pagination": {
+            "total": total,
+            "limit": limit,
+            "offset": offset,
+            "hasMore": offset + limit < total
+        }
+    }

requirements.txt

@@ -35,3 +35,9 @@ email-validator
 # 📨 Optional: Email Templates (HTML)
 # -----------------------------
 jinja2
+
+# -----------------------------
+# 🤖 Artificial Intelligence Integration
+# -----------------------------
+torch
+sentence-transformers