[NOTICKET] Feat: get profiles by criteria_id

externals/databases/pg_crud.py

@@ -1,7 +1,7 @@
 from typing import Optional, List
 from uuid import UUID
 
-from sqlalchemy import select, and_, update, delete
+from sqlalchemy import select, and_, update, delete, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from externals.databases.pg_models import (
     CVUser,
@@ -274,6 +274,136 @@ async def get_profiles(
     result = await db.execute(stmt)
     return result.scalars().all()
 
+from sqlalchemy import func
+
+from sqlalchemy import select, and_, func, cast, String
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.dialects.postgresql import ARRAY
+from typing import List
+
+async def get_profiles_by_criteria_id(
+    db: AsyncSession,
+    criteria_id: str,
+    current_user: CVUser,
+) -> List[CVProfile]:
+
+    filter = await get_filter_by_id(db, criteria_id)
+
+    if not filter:
+        return []
+
+    conditions = []
+
+    # --- GPA ---
+    if filter.gpa_edu_1 is not None:
+        conditions.append(CVProfile.gpa_edu_1 >= filter.gpa_edu_1)
+
+    if filter.gpa_edu_2 is not None:
+        conditions.append(CVProfile.gpa_edu_2 >= filter.gpa_edu_2)
+
+    if filter.gpa_edu_3 is not None:
+        conditions.append(CVProfile.gpa_edu_3 >= filter.gpa_edu_3)
+
+    # --- University (case-insensitive) ---
+    if filter.univ_edu_1:
+        conditions.append(
+            func.lower(CVProfile.univ_edu_1) ==
+            filter.univ_edu_1.lower()
+        )
+
+    if filter.univ_edu_2:
+        conditions.append(
+            func.lower(CVProfile.univ_edu_2) ==
+            filter.univ_edu_2.lower()
+        )
+
+    if filter.univ_edu_3:
+        conditions.append(
+            func.lower(CVProfile.univ_edu_3) ==
+            filter.univ_edu_3.lower()
+        )
+
+    # --- Major (case-insensitive) ---
+    if filter.major_edu_1:
+        conditions.append(
+            func.lower(CVProfile.major_edu_1) ==
+            filter.major_edu_1.lower()
+        )
+
+    if filter.major_edu_2:
+        conditions.append(
+            func.lower(CVProfile.major_edu_2) ==
+            filter.major_edu_2.lower()
+        )
+
+    if filter.major_edu_3:
+        conditions.append(
+            func.lower(CVProfile.major_edu_3) ==
+            filter.major_edu_3.lower()
+        )
+
+    # --- Others ---
+    if filter.domicile:
+        conditions.append(
+            func.lower(CVProfile.domicile) ==
+            filter.domicile.lower()
+        )
+
+    if filter.yoe is not None:
+        conditions.append(CVProfile.yoe >= filter.yoe)
+
+    # --- ARRAY fields (Postgres-safe cast) ---
+    if filter.hardskills:
+        conditions.append(
+            CVProfile.hardskills.overlap(
+                cast(filter.hardskills, ARRAY(String))
+            )
+        )
+
+    if filter.softskills:
+        conditions.append(
+            CVProfile.softskills.overlap(
+                cast(filter.softskills, ARRAY(String))
+            )
+        )
+
+    if filter.certifications:
+        conditions.append(
+            CVProfile.certifications.overlap(
+                cast(filter.certifications, ARRAY(String))
+            )
+        )
+
+    if filter.business_domain:
+        conditions.append(
+            CVProfile.business_domain.overlap(
+                cast(filter.business_domain, ARRAY(String))
+            )
+        )
+
+    if not conditions:
+        return []
+
+    # 🔐 Tenant-safe JOIN
+    stmt = (
+        select(CVProfile)
+        .join(CVFile, CVProfile.file_id == CVFile.file_id)
+        .join(CVUser, CVFile.user_id == CVUser.user_id)
+        .where(
+            CVUser.tenant_id == current_user.tenant_id,
+            *conditions
+        )
+    )
+
+    compiled = stmt.compile(
+        dialect=db.bind.dialect,
+        compile_kwargs={"literal_binds": True}
+    )
+    print(compiled)
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+
 async def get_profile_by_id(
     db: AsyncSession,
     profile_id: str,
@@ -338,16 +468,16 @@ async def get_filter(
 
     # --- ARRAY fields (exact match) ---
     if filter.hardskills:
-        conditions.append(CVFilter.hardskills == filter.hardskills)
+        conditions.append(CVFilter.hardskills.overlap(filter.hardskills))
 
     if filter.softskills:
-        conditions.append(CVFilter.softskills == filter.softskills)
+        conditions.append(CVFilter.softskills.overlap(filter.softskills))
 
     if filter.certifications:
-        conditions.append(CVFilter.certifications == filter.certifications)
+        conditions.append(CVFilter.certifications.overlap(filter.certifications))
 
     if filter.business_domain:
-        conditions.append(CVFilter.business_domain == filter.business_domain)
+        conditions.append(CVFilter.business_domain.overlap(filter.business_domain))
 
     # ⛔ Prevent full table scan
     if not conditions:

interfaces/api/profile.py

@@ -1,3 +1,5 @@
+import profile
+
 from externals.databases.pg_models import CVUser
 from externals.databases.database import get_db
 from fastapi import APIRouter, Depends, status, HTTPException
@@ -35,15 +37,14 @@ async def extract_profile(
 @router.get("/{profile_id}")
 async def get_profile(
     profile_id: str,
+    db=Depends(get_db),
     current_user: CVUser = Depends(get_current_user),
 ):
     """
     Get extracted profile by ID
     """
-    knowledge_service = KnowledgeService(user=current_user)
-
+    knowledge_service = KnowledgeService(db=db, user=current_user)
     profile = await knowledge_service.profile.get_profile(profile_id)
-
     if not profile:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -56,7 +57,31 @@ async def get_profile(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Not authorized to access this profile",
         )
-
     return profile
 
 
+
+
+@router.get("/profiles/{criteria_id}")
+async def get_profiles(
+    criteria_id: str,
+    db=Depends(get_db),
+    current_user: CVUser = Depends(get_current_user),
+):
+    """
+    Get profiles based on criteria id 
+    """
+    
+    knowledge_service = KnowledgeService(db=db, user=current_user)
+
+    profiles = await knowledge_service.profile.get_profiles_by_criteria(criteria_id=criteria_id)
+    logger.info(f"retrieved profiles: {profiles}")
+    
+    if not profiles:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Profiles not found",
+        )
+
+    return profiles
+

services/agentic/profile_scoring.py

@@ -491,7 +491,7 @@ class AgenticScoringService:
             # Get profile data all
             all_profiles = await get_profiles(self.db)
             print(f"Found {len(all_profiles)} profiles to be scored")
-            all_profiles = all_profiles[:5] # FIXME: DELETE LATER
+            # all_profiles = all_profiles[:5] # FIXME: DELETE LATER
             
             _weight:CVWeight = await self.weight_service.get_weight_by_weight_id(weight_id=weight_id)
             print(f"Found weight: {_weight}")
@@ -572,4 +572,4 @@ class AgenticScoringService:
         except Exception as E: 
             logger.error(f"profile scoring error, {E}")
             traceback.print_exc() 
-            raise
+            raise

services/knowledge/get_profile.py

@@ -1,4 +1,4 @@
-from externals.databases.pg_crud import get_profile_by_filename, get_profile_by_id
+from externals.databases.pg_crud import get_profile_by_filename, get_profile_by_id, get_profiles_by_criteria_id
 from externals.databases.pg_models import CVUser, CVProfile
 from services.models.data_model import Profile
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -71,4 +71,15 @@ class KnowledgeGetProfileService:
                 return profiles
         except Exception as E:
             logger.error(f"❌ get profile error, {E}")
-            return {}
+            return {}
+        
+
+    async def get_profiles_by_criteria(self, criteria_id: str) -> List[CVProfile]:
+        try:
+            profiles: List[CVProfile] = await get_profiles_by_criteria_id(self.db, criteria_id=criteria_id, current_user=self.user)
+            logger.info(f"get_profiles_by_criteria/profiles: {profiles}")
+                
+            return profiles
+        except Exception as E:
+            logger.error(f"❌ get profiles by criteria id '{criteria_id}' error, {E}")
+            return []