[NOTICKET] Feat: score card

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, or_
+from sqlalchemy import select, and_, update, delete, or_, func
 from sqlalchemy.ext.asyncio import AsyncSession
 from externals.databases.pg_models import (
     CVUser,
@@ -200,6 +200,30 @@ async def get_file_by_filename(
     return result.scalar_one_or_none()
 
 
+async def count_files_by_user(
+    db: AsyncSession,
+    user_id: str,
+) -> int:
+    """Return number of CVFile rows belonging to a user."""
+    result = await db.execute(
+        select(func.count(CVFile.file_id)).where(CVFile.user_id == user_id)
+    )
+    return int(result.scalar_one())
+
+
+async def count_profiles_by_user(
+    db: AsyncSession,
+    user_id: str,
+) -> int:
+    """Return number of CVProfile rows that are associated with files of a user."""
+    result = await db.execute(
+        select(func.count(CVProfile.profile_id))
+        .join(CVFile, CVProfile.file_id == CVFile.file_id)
+        .where(CVFile.user_id == user_id)
+    )
+    return int(result.scalar_one())
+
+
 async def mark_file_extracted(db: AsyncSession, file_id: UUID):
     await db.execute(
         update(CVFile)
@@ -262,8 +286,13 @@ async def create_profile(
 async def get_profile_by_filename(
     db: AsyncSession,
     filename: str,
+    current_user: CVUser,
 ) -> Optional[CVProfile]:
-    stmt = select(CVProfile).where(CVProfile.filename == filename)
+    stmt = (
+        select(CVProfile)
+        .join(CVFile, CVProfile.file_id == CVFile.file_id)
+        .where(CVProfile.filename == filename, CVFile.user_id == current_user.user_id)
+    )
     result = await db.execute(stmt)
     return result.scalar_one_or_none()
 

externals/storages/azure_blob.py

@@ -50,8 +50,6 @@ async def get_container_client() -> ContainerClient:
         )
         return container_client
 
-
-
 # async def get_container_client() -> ContainerClient:
 #     service = await get_blob_service_client()
 #     container = service.get_container_client(

interfaces/api/file.py

@@ -51,7 +51,7 @@ async def upload_knowledge_many(
     }
 
 @router.get(
-    "/{user_id}",
+    "/user/{user_id}",
     status_code=status.HTTP_200_OK,
     summary="Get file metadata by user ID",
 )
@@ -105,3 +105,41 @@ async def delete_knowledge_file(
         "deleted_by": current_user.email,
     }
 
+
+
+@router.get(
+    "/score_card",
+    status_code=status.HTTP_200_OK,
+    summary="Get score card data for dashboard summary",
+)
+async def get_score_card(
+    db=Depends(get_db),
+    current_user=Depends(get_current_user),
+):
+    """
+    Retrieve all file metadata uploaded by a specific user.
+
+    Return:
+    - total file
+    - total profile extracted
+    - percent profile extracted
+    """
+    try:
+        knowledge_service = KnowledgeService(
+            db=db,
+            user=current_user,
+        )
+
+        data = await knowledge_service.score_card.get_score_card()
+
+        return {
+            "status": "success",
+            "message": "Score card retrieved successfully",
+            "data": data,
+        }
+    except Exception as E:
+        logger.error(f"get score card error: {E}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"get score card error: {E}"
+        )

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
+            
             
             _weight:CVWeight = await self.weight_service.get_weight_by_weight_id(weight_id=weight_id)
             print(f"Found weight: {_weight}")

services/knowledge/get_profile.py

@@ -21,14 +21,10 @@ class KnowledgeGetProfileService:
 
         logger.info(f"📄 Fetching profile: {filename}")
 
-        profile = await get_profile_by_filename(self.db, filename)
+        profile = await get_profile_by_filename(self.db, filename, current_user=self.user)
         if not profile:
             return None
 
-        # 🔐 Tenant isolation
-        if profile.tenant_id != self.user.tenant_id:
-            raise PermissionError("Access denied")
-
         return profile
 
 

services/knowledge/knowledge_setup.py

@@ -16,6 +16,7 @@ from services.knowledge.upload_file import KnowledgeFileService
 from services.knowledge.get_profile import KnowledgeGetProfileService
 from services.knowledge.delete_file import KnowledgeDeleteService
 from services.knowledge.extract_profile import KnowledgeExtractService
+from services.knowledge.score_card import KnowledgeScoreCardService
 
 
 class KnowledgeService:
@@ -31,3 +32,4 @@ class KnowledgeService:
         self.profile = KnowledgeGetProfileService(db, user)
         self.delete = KnowledgeDeleteService(db, user)
         self.extract = KnowledgeExtractService(db, user)
+        self.score_card = KnowledgeScoreCardService(db, user)

services/knowledge/score_card.py

@@ -0,0 +1,37 @@
+from externals.databases.pg_crud import (
+    count_files_by_user,
+    count_profiles_by_user,
+)
+from externals.databases.pg_models import CVUser
+from sqlalchemy.ext.asyncio import AsyncSession
+from utils.logger import get_logger
+
+logger = get_logger("score card")
+
+
+class KnowledgeScoreCardService:
+
+    def __init__(self, db: AsyncSession, user: CVUser):
+        self.db = db
+        self.user = user
+
+    async def get_score_card(self) -> dict:
+        """
+        Retrieve extracted profile securely
+        """
+        # Count total files for this user (from cv_file table)
+        total_file = await count_files_by_user(self.db, self.user.user_id)
+
+        # Count total extracted profiles associated with this user's files
+        total_extracted = await count_profiles_by_user(self.db, self.user.user_id)
+
+        # percent as 0-1, safely handle division by zero
+        percent_extracted = round(total_extracted / total_file, 2) if total_file else 0.0
+
+        score_card = {
+            "total_file": total_file,
+            "total_extracted": total_extracted,
+            "percent_extracted": percent_extracted*100,
+        }
+
+        return score_card

services/knowledge/upload_file.py

@@ -90,8 +90,6 @@ class KnowledgeFileService:
                 if existing:
                     return existing
 
-            
-    
 
     async def get_files_by_user(self, user_id: str):
         """