[NOTICKET] [AI] Calculate Score - filtering profiles first before calculate => DONE

[NOTICKET] [AI] Endpoint score card jumlah extracted & processed data => DONE
[NOTICKET] [AI] Update end point get profile, tambahkan link untuk view blob => DONE

.env.example

@@ -1,13 +1,6 @@
 ## -------------------- DATABASE CONFIGURATION -------------------- ##
 
-# Local, Postgresql
-causalogy--pg--name = ""
-causalogy--pg--user = ""
-causalogy--pg--password = ""
-causalogy--pg--host = ""
-causalogy--pg--port = ""
-
-# Local Postgresql
+# Postgresql
 ss__postgresql__url = ""
 
 
@@ -55,6 +48,7 @@ azureai__embedmodel__name = ""
 
 # AZURE BLOB 
 azureai__search__sas = ""
+azureai__blob__sas = ""
 azureai__container__endpoint = ""
 azureai__container__name = ""
 azureai__container__account__name = ""

config/constant.py

@@ -23,6 +23,7 @@ class AzureBlobConstants:
     ENDPOINT: str = os.environ.get("azureai__container__endpoint")
     CONTAINER_NAME: str = os.environ.get("azureai__container__name")
     SAS_KEY: str = os.environ.get("azureai__search__sas")
+    BLOB_SAS_KEY: str = os.environ.get("azureai__blob__sas")
     CONTAINER_KEY: str = os.environ.get("azureai__container__key")
     MAX_FILE_SIZE_MB: int = int(os.getenv("azureai__max_file_size_mb", "5"))
     CHUNK_SIZE: int = 4 * 1024 * 1024

externals/databases/pg_crud.py

@@ -433,13 +433,65 @@ async def get_profiles_by_criteria_id(
     return result.scalars().all()
 
 
+# async def get_profile_by_id(
+#     db: AsyncSession,
+#     profile_id: str,
+# ) -> Optional[CVProfile]:
+#     stmt = select(CVProfile).where(CVProfile.profile_id == profile_id)
+#     result = await db.execute(stmt)
+#     return result.scalar_one_or_none()
+
+from typing import Tuple
+
+# async def get_profile_by_id(
+#     db: AsyncSession,
+#     profile_id: str,
+# ) -> Optional[Tuple[CVProfile, str]]:
+
+#     stmt = (
+#         select(CVProfile, CVFile.url)
+#         .join(CVFile, CVProfile.file_id == CVFile.file_id)
+#         .where(CVProfile.profile_id == profile_id)
+#     )
+
+#     result = await db.execute(stmt)
+#     result = result.scalar_one_or_none()
+
+#     if not result:
+#         return None
+    
+#     return result 
+
+
 async def get_profile_by_id(
     db: AsyncSession,
     profile_id: str,
-) -> Optional[CVProfile]:
-    stmt = select(CVProfile).where(CVProfile.profile_id == profile_id)
+) -> Optional[dict]:
+
+    stmt = (
+        select(CVProfile, CVFile.url)
+        .join(CVFile, CVProfile.file_id == CVFile.file_id)
+        .where(CVProfile.profile_id == profile_id)
+    )
+
     result = await db.execute(stmt)
-    return result.scalar_one_or_none()
+    row = result.first()
+
+    if not row:
+        return None
+
+    profile, url = row
+
+    # Convert SQLAlchemy model to dict safely
+    profile_dict = {
+        column.name: getattr(profile, column.name)
+        for column in CVProfile.__table__.columns
+    }
+
+    # Add file URL
+    profile_dict["url"] = url
+
+    return profile_dict
 
 
 async def list_profiles(

interfaces/api/profile.py

@@ -51,12 +51,6 @@ async def get_profile(
             detail="Profile not found",
         )
 
-    # 🔒 Tenant isolation (IMPORTANT)
-    if profile.tenant_id != current_user.tenant_id:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Not authorized to access this profile",
-        )
     return profile
 
 

services/agentic/profile_scoring.py

@@ -26,7 +26,7 @@ from services.agentic.weight import AgenticWeightService
 from services.agentic.filter import AgenticFilterService
 from services.knowledge.get_profile import KnowledgeGetProfileService
 from sqlalchemy.ext.asyncio import AsyncSession
-from externals.databases.pg_crud import get_profiles, create_matchings, create_scores
+from externals.databases.pg_crud import get_profiles, create_matchings, create_scores, get_profiles_by_criteria_id, get_weight_by_id
 from utils.logger import get_logger
 
 
@@ -423,12 +423,12 @@ class AgenticScoringService:
         try:
             results = []
             for i, p in enumerate(profiles):
-                print(f"==> {i+1} profile: {p} vs criteria: {criteria}")
+                # print(f"==> {i+1} profile: {p} vs criteria: {criteria}")
                 tmp_matching:AIMatchProfile = await self._ai_matching(profile=p, criteria=criteria)
                 results.append(tmp_matching)
             return results
         except Exception as E:
-            print(f"❌ error in _ai_matching_bulk: {E}")
+            logger.error(f"❌ error in _ai_matching_bulk: {E}")
             raise
     
     def _calculate_score(self, match_result:AIMatchProfile, weight_data:CriteriaWeight) -> float:
@@ -450,7 +450,7 @@ class AgenticScoringService:
         for k, v in weight_data.items():
             total_weight += v
 
-        logger.info(f"👁️ helper_calculate_score/total_weight: {total_weight}")
+        # logger.info(f"👁️ helper_calculate_score/total_weight: {total_weight}")
         
         if total_weight > 1.0:
             # normalized weight
@@ -489,13 +489,14 @@ class AgenticScoringService:
     async def scoring(self, weight_id: str):
         try:
             # Get profile data all
-            all_profiles = await get_profiles(self.db)
-            print(f"Found {len(all_profiles)} profiles to be scored")
-            
+            # all_profiles = await get_profiles(self.db)
+            weight = await get_weight_by_id(self.db, weight_id=weight_id)
+            all_profiles = await get_profiles_by_criteria_id(db=self.db, criteria_id=weight.criteria_id, current_user=self.user)
+            print(f"🫡 Found {len(all_profiles)} profiles to be scored")
             
             _weight:CVWeight = await self.weight_service.get_weight_by_weight_id(weight_id=weight_id)
-            print(f"Found weight: {_weight}")
-            print(f"--> criteria id: {_weight.criteria_id}")
+            # print(f"Found weight: {_weight}")
+            # print(f"--> criteria id: {_weight.criteria_id}")
 
             _criteria:CVFilter = await self.criteria_service.get_filter_by_id(criteria_id=_weight.criteria_id)
             

services/knowledge/get_profile.py

@@ -3,6 +3,7 @@ from externals.databases.pg_models import CVUser, CVProfile
 from services.models.data_model import Profile
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import List, Dict, Generator, Union, Any
+from config.constant import AzureBlobConstants
 from utils.logger import get_logger
 
 logger = get_logger("get profile")
@@ -27,10 +28,19 @@ class KnowledgeGetProfileService:
 
         return profile
 
+    
+    def add_sas_blob(self, url: str) -> str:
+        sas_token = AzureBlobConstants.BLOB_SAS_KEY
+        if '?' in url:
+            return f"{url}&{sas_token}"
+        else:
+            return f"{url}?{sas_token}"
+
 
     async def get_profile(self, profile_id: str) -> CVProfile:
         try:
-            profile = await get_profile_by_id(profile_id=profile_id)
+            profile = await get_profile_by_id(db=self.db, profile_id=profile_id)
+            profile["url"] = self.add_sas_blob(profile["url"])
             return profile
         except Exception as E:
             logger.error(f"❌ get profile error for profile_id {profile_id}, {E}")
@@ -39,10 +49,10 @@ class KnowledgeGetProfileService:
 
     async def get_profile_generator(self, profile_id: str):
         try:
-            profile = await get_profile_by_id(profile_id=profile_id)
+            profile = await get_profile_by_id(db=self.db, profile_id=profile_id)
             yield profile
         except Exception as E:
-            logger.error(f"❌ get profile error for profile_id {profile_id}, {E}")
+            logger.error(f"❌ get profile generator error for profile_id {profile_id}, {E}")
             return