feat: implement dynamic scoring, webhooks, and resume download

backend/api.py

@@ -55,10 +55,10 @@ async def process_resume_endpoint(request: ResumeRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 # ---------------------------------------------------------------------
-# WEBHOOK ENDPOINT (Called by Supabase)
+# WEBHOOK ENDPOINTS (Called by Supabase)
 # ---------------------------------------------------------------------
 
-class StorageEventRequest(BaseModel):
+class WebhookRequest(BaseModel):
     type: str
     table: str
     record: Dict[str, Any]
@@ -66,7 +66,7 @@ class StorageEventRequest(BaseModel):
     old_record: Optional[Dict[str, Any]] = None
 
 @app.post("/webhook/storage")
-async def storage_webhook(request: StorageEventRequest):
+async def storage_webhook(request: WebhookRequest):
     """
     Handles Database Webhooks from Supabase (storage.objects insert).
     """
@@ -105,7 +105,7 @@ async def storage_webhook(request: StorageEventRequest):
 
 
 @app.post("/webhook/jobs")
-async def jobs_webhook(request: StorageEventRequest):
+async def jobs_webhook(request: WebhookRequest):
     """
     Handles Database Webhooks from Supabase (jobs table UPDATE/INSERT).
     """
@@ -157,6 +157,130 @@ async def analyze_ats_endpoint(
 # CANDIDATE ANALYSIS ENDPOINT
 # ---------------------------------------------------------------------
 
+# ---------------------------------------------------------------------
+# CORE ANALYSIS LOGIC
+# ---------------------------------------------------------------------
+
+async def perform_candidate_analysis(candidate_id: str, job_id: str, force_refresh: bool = False):
+    """
+    Shared logic to analyze a candidate for a job.
+    Checks for cached results first unless force_refresh is True.
+    """
+    # 0. Check for existing analysis in applications table
+    if not force_refresh:
+        app_resp = client.table("applications").select("ai_summary, ai_insights, AI_score").eq("user_id", candidate_id).eq("job_id", job_id).execute()
+        
+        if app_resp.data and app_resp.data[0].get("ai_summary"):
+            app_data = app_resp.data[0]
+            insights = app_data.get("ai_insights") or {}
+            
+            # Use cached missing_skills if available
+            if "missing_skills" in insights:
+                print(f"✅ Found fully cached analysis for {candidate_id}")
+                return {
+                    "summary": app_data.get("ai_summary"),
+                    "strengths": insights.get("strengths") or [],
+                    "weaknesses": insights.get("weaknesses") or [],
+                    "score": app_data.get("AI_score") or 0,
+                    "missing_skills": insights.get("missing_skills") or []
+                }
+
+    # 1. Fetch Candidate Data
+    prof_resp = client.table("profiles").select("*").eq("id", candidate_id).execute()
+    if not prof_resp.data:
+        raise HTTPException(status_code=404, detail="Candidate not found")
+    
+    profile = prof_resp.data[0]
+    
+    # 2. Fetch Job Data
+    job_description = ""
+    job_skills = []
+    
+    if job_id:
+        job_resp = client.table("jobs").select("*").eq("id", job_id).execute()
+        if job_resp.data:
+            job = job_resp.data[0]
+            job_description = job.get("description") or ""
+            raw_job_skills = job.get("skills") if job.get("skills") else job.get("technical_skills")
+            if isinstance(raw_job_skills, str):
+                job_skills = [s.strip() for s in raw_job_skills.split(",") if s.strip()]
+            elif isinstance(raw_job_skills, list):
+                job_skills = raw_job_skills
+
+    # 3. Prepare Profile Skills
+    profile_skills = []
+    raw_skills = profile.get("skills") or []
+    if isinstance(raw_skills, str):
+        profile_skills = [s.strip() for s in raw_skills.split(",") if s.strip()]
+    else:
+        profile_skills = raw_skills
+        
+    raw_tech_skills = profile.get("technical_skills") or []
+    if isinstance(raw_tech_skills, str):
+        profile_skills.extend([s.strip() for s in raw_tech_skills.split(",") if s.strip()])
+    else:
+        profile_skills.extend(raw_tech_skills)
+
+    # 4. Identify Missing Skills (Semantic)
+    missing = []
+    if job_skills:
+        missing = identify_missing_skills(job_skills, profile_skills)
+
+    # 4a. If we had half-cached data (summary exists but missing_skills don't)
+    # We check cache again just in case it was partially filled
+    app_resp = client.table("applications").select("ai_summary, ai_insights, AI_score").eq("user_id", candidate_id).eq("job_id", job_id).execute()
+    if not force_refresh and app_resp.data and app_resp.data[0].get("ai_summary"):
+        app_data = app_resp.data[0]
+        insights = app_data.get("ai_insights") or {}
+        return {
+            "summary": app_data.get("ai_summary"),
+            "strengths": insights.get("strengths") or [],
+            "weaknesses": insights.get("weaknesses") or [],
+            "score": app_data.get("AI_score") or 0,
+            "missing_skills": missing
+        }
+
+    # 5. Generate fresh AI Insights
+    profile_summary = f"""
+    Role: {profile.get('role')}
+    Headline: {profile.get('headline')}
+    Summary: {profile.get('summary')}
+    Experience: {profile.get('experience_years')} years
+    Work Experience: {profile.get('work_experience')}
+    Education: {profile.get('education')}
+    Skills: {", ".join(profile_skills)}
+    """
+    
+    ai_insights = generate_ai_analysis(profile_summary, job_description)
+    
+    # 6. Persist to Database
+    try:
+        data_to_save = {
+            "ai_summary": ai_insights.get("summary"),
+            "ai_insights": {
+                "strengths": ai_insights.get("strengths") or [],
+                "weaknesses": ai_insights.get("weaknesses") or [],
+                "missing_skills": missing
+            },
+            "AI_score": ai_insights.get("score") or 0
+        }
+        client.table("applications").update(data_to_save).eq("user_id", candidate_id).eq("job_id", job_id).execute()
+        print(f"💾 Persisted AI analysis for candidate {candidate_id}")
+    except Exception as db_err:
+        print(f"⚠️ Failed to persist AI analysis: {db_err}")
+
+    return {
+        "summary": ai_insights.get("summary"),
+        "strengths": ai_insights.get("strengths"),
+        "weaknesses": ai_insights.get("weaknesses"),
+        "score": ai_insights.get("score") or 0,
+        "missing_skills": missing
+    }
+
+# ---------------------------------------------------------------------
+# CANDIDATE ANALYSIS ENDPOINT
+# ---------------------------------------------------------------------
+
 class AnalysisRequest(BaseModel):
     candidate_id: str
     job_id: Optional[str] = None
@@ -168,77 +292,43 @@ async def analyze_candidate_endpoint(request: AnalysisRequest):
     """
     print(f"🔬 Analyzing candidate {request.candidate_id} for job {request.job_id}")
     
+    if not request.job_id:
+        raise HTTPException(status_code=400, detail="job_id is required for analysis")
+
     try:
-        # 1. Fetch Candidate Data
-        prof_resp = client.table("profiles").select("*").eq("id", request.candidate_id).execute()
-        if not prof_resp.data:
-            raise HTTPException(status_code=404, detail="Candidate not found")
-        
-        profile = prof_resp.data[0]
-        
-        # 2. Fetch Job Data
-        job_description = ""
-        job_skills = []
-        
-        if request.job_id:
-            job_resp = client.table("jobs").select("*").eq("id", request.job_id).execute()
-            if job_resp.data:
-                job = job_resp.data[0]
-                job_description = job.get("description") or ""
-                # Assume job.skills is a list or comma-separated string
-                raw_job_skills = job.get("skills") if job.get("skills") else job.get("technical_skills")
-                if isinstance(raw_job_skills, str):
-                    job_skills = [s.strip() for s in raw_job_skills.split(",") if s.strip()]
-                elif isinstance(raw_job_skills, list):
-                    job_skills = raw_job_skills
-                else:
-                    job_skills = []
-
-        # 3. Prepare Profile Skills
-        profile_skills = []
-        raw_skills = profile.get("skills") or []
-        if isinstance(raw_skills, str):
-            profile_skills = [s.strip() for s in raw_skills.split(",") if s.strip()]
-        else:
-            profile_skills = raw_skills
-            
-        raw_tech_skills = profile.get("technical_skills") or []
-        if isinstance(raw_tech_skills, str):
-            profile_skills.extend([s.strip() for s in raw_tech_skills.split(",") if s.strip()])
-        else:
-            profile_skills.extend(raw_tech_skills)
-
-        # 4. Generate AI Insights (Summary, Strengths, Weaknesses)
-        profile_summary = f"""
-        Role: {profile.get('role')}
-        Headline: {profile.get('headline')}
-        Summary: {profile.get('summary')}
-        Experience: {profile.get('experience_years')} years
-        Work Experience: {profile.get('work_experience')}
-        Education: {profile.get('education')}
-        Skills: {", ".join(profile_skills)}
-        """
-        
-        ai_insights = generate_ai_analysis(profile_summary, job_description)
-        
-        # 5. Identify Missing Skills (Semantic)
-        missing = []
-        if job_skills:
-            missing = identify_missing_skills(job_skills, profile_skills)
+        result = await perform_candidate_analysis(request.candidate_id, request.job_id)
+        return {"status": "success", "data": result}
+    except Exception as e:
+        print(f"❌ Analysis endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        return {
-            "status": "success",
-            "data": {
-                "summary": ai_insights.get("summary"),
-                "strengths": ai_insights.get("strengths"),
-                "weaknesses": ai_insights.get("weaknesses"),
-                "score": ai_insights.get("score") or 0,
-                "missing_skills": missing
-            }
-        }
+@app.post("/webhook/applications")
+async def applications_webhook(request: WebhookRequest):
+    """
+    Handles Database Webhooks from Supabase (applications table UPDATE/INSERT).
+    """
+    print(f"🔔 Webhook received: {request.type} on {request.table}")
+    
+    if request.table != "applications":
+        return {"status": "ignored", "reason": "wrong table"}
+    
+    record = request.record
+    # Avoid infinite loop: if this update already contains ai_summary, ignore it
+    if request.type == "UPDATE" and record.get("ai_summary"):
+        return {"status": "skipped", "reason": "already analyzed"}
+
+    candidate_id = record.get("user_id")
+    job_id = record.get("job_id")
+
+    if not candidate_id or not job_id:
+        return {"status": "error", "message": "missing ids"}
 
+    print(f"▶️ Auto-triggering AI analysis for {candidate_id} / {job_id}")
+    try:
+        await perform_candidate_analysis(candidate_id, job_id)
+        return {"status": "success"}
     except Exception as e:
-        print(f"❌ Analysis failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        print(f"❌ Webhook analysis failed: {e}")
+        return {"status": "error", "message": str(e)}
 
 # Run with: uvicorn api:app --reload

src/components/Admin/AdminSortingPage.jsx

@@ -142,8 +142,8 @@ const ScoringPanel = ({ config, setConfig, onReset, onClose }) => {
                     <ConfigSlider label="Experience Weight" value={config.experienceWeight} min={1} max={10} onChangeKey="experienceWeight" />
                 </div>
                 <div>
-                    <ConfigSlider label="Certification Bonus" value={config.certBonus} min={0} max={50} onChangeKey="certBonus" />
-                    <ConfigSlider label="Languages Weight" value={config.langWeight} min={1} max={10} onChangeKey="langWeight" />
+                    <ConfigSlider label="Certification Bonus" value={config.certBonus} min={1} max={10} onChangeKey="certBonus" />
+                    <ConfigSlider label="Projects Weight" value={config.projectsWeight} min={1} max={10} onChangeKey="projectsWeight" />
                 </div>
             </div>
             <div style={{ display: 'flex', justifyContent: 'space-between', marginTop: '1rem' }}>
@@ -173,7 +173,7 @@ export default function AdminSortingPage() {
     const [filters, setFilters] = useState(initialFilters);
 
     // Scoring
-    const defaultScoring = { skillsWeight: 2, experienceWeight: 5, certBonus: 15, langWeight: 1 };
+    const defaultScoring = { skillsWeight: 2, experienceWeight: 5, certBonus: 3, projectsWeight: 3 };
     const [scoringConfig, setScoringConfig] = useState(defaultScoring);
 
     //candidate overview
@@ -193,9 +193,15 @@ export default function AdminSortingPage() {
                     id, 
                     created_at, 
                     status, 
-                    score: match_score, 
+                    match_score, 
                     skills,
-                    profiles ( id, full_name, email, avatar_url, experience_years ),
+                    skills_match,
+                    technical_skills_match,
+                    work_experience_match,
+                    education_match,
+                    certifications_match,
+                    project_match,
+                    profiles ( id, full_name, email, avatar_url, experience_years, languages, resume_url ),
                     jobs ( id, title )
                     `);
 
@@ -212,7 +218,17 @@ export default function AdminSortingPage() {
                     experience: parseInt(app.profiles?.experience_years) || 'Fresher',
                     skills: app.skills || [],
                     status: app.status,
-                    score: app.score || 0
+                    resumeUrl: app.profiles?.resume_url,
+                    dbScore: app.match_score || 0,
+                    scores: {
+                        skills: app.skills_match || 0,
+                        technical: app.technical_skills_match || 0,
+                        experience: app.work_experience_match || 0,
+                        certifications: app.certifications_match || 0,
+                        languages: 0,
+                        education: app.education_match || 0,
+                        projects: app.project_match || 0
+                    }
                 }));
 
                 setApplicants(formattedData);
@@ -279,7 +295,27 @@ export default function AdminSortingPage() {
 
     // --- SORTING & FILTERING ---
     const filteredApplicants = useMemo(() => {
-        return applicants.filter(app => {
+        return applicants.map(app => {
+            // Dynamic Score Calculation
+            const { skillsWeight, experienceWeight, certBonus, projectsWeight } = scoringConfig;
+
+            // Using a weighted average formula
+            // Denominator: weights + fixed education(2)
+            const totalWeight = skillsWeight + experienceWeight + projectsWeight + certBonus;
+
+            const dynamicScore = Math.round(
+                (Math.max(app.scores.skills, app.scores.technical) * skillsWeight +
+                    app.scores.experience * experienceWeight +
+                    app.scores.education * 2 + // Education as a 2x base
+                    app.scores.projects * projectsWeight + // Projects now dynamic
+                    app.scores.certifications * certBonus) / (totalWeight + 2)
+            );
+
+            // If calculation leads to 0 but DB has a score, and weights are default, show DB score
+            const finalScore = (dynamicScore === 0 && app.dbScore > 0) ? app.dbScore : dynamicScore;
+
+            return { ...app, score: finalScore };
+        }).filter(app => {
             const matchesSearch = app.name.toLowerCase().includes(searchQuery.toLowerCase()) || (app.jobTitle || '').toLowerCase().includes(searchQuery.toLowerCase());
             const matchesStatus = filters.status === 'All' || app.status === filters.status;
             const matchesScore = (app.score || 0) >= filters.minScore;
@@ -294,7 +330,7 @@ export default function AdminSortingPage() {
             if (filters.sortBy === 'Name') return a.name.localeCompare(b.name);
             return 0;
         });
-    }, [searchQuery, filters, applicants]);
+    }, [searchQuery, filters, applicants, scoringConfig]);
 
     // Check if every single selected person is already 'Accepted'
     const allSelectedAreApproved = selectedIds.length > 0 && selectedIds.every(id => {

src/components/Adminfront/TopPerformers.jsx

@@ -48,7 +48,7 @@ export default function TopPerformers() {
                     .select(`
                         id, 
                         experience,
-                        user_id:profiles(id, full_name, avatar_url, summary),
+                        user_id:profiles(id, full_name, avatar_url, summary, resume_url),
                         job_id:jobs(id, title),
                         match_score
                     `)
@@ -64,6 +64,7 @@ export default function TopPerformers() {
                         jobId: item.job_id?.id,
                         name: item.user_id?.full_name || 'Candidate',
                         avatar: item.user_id?.avatar_url,
+                        resumeUrl: item.user_id?.resume_url,
                         jobTitle: item.job_id?.title || 'Applicant',
                         experience: item.experience,
                         summary: item.user_id?.summary,

src/components/CandidateDrawer.jsx

@@ -132,7 +132,7 @@ const CandidateDrawer = ({ isOpen, onClose, candidate }) => {
 
               <div style={{ marginBottom: '2rem', padding: '1rem', backgroundColor: 'rgba(239, 68, 68, 0.05)', borderRadius: '0.75rem', border: '1px solid rgba(239, 68, 68, 0.2)' }}>
                 <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '0.5rem' }}>
-                  <span style={{ fontWeight: 'bold', color: '#EF4444' }}>{analysis?.score !== undefined ? 'Gemini AI Score' : 'Semantic Match Score'}</span>
+                  <span style={{ fontWeight: 'bold', color: '#EF4444' }}>{analysis?.score !== undefined ? 'AI Score' : 'Semantic Match Score'}</span>
                   <span style={{ fontWeight: 'bold', color: 'white' }}>{analysis?.score ?? (candidate.score || candidate.matchScore || 0)}%</span>
                 </div>
                 <div style={{ width: '100%', height: '6px', backgroundColor: 'rgba(255,255,255,0.1)', borderRadius: '3px' }}>