Implement evaluation status API and enhance RFP service with deficiency check logic

src/controllers/_rfp_controller.py

@@ -1,14 +1,14 @@
 from fastapi import Path
 from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel, Field, field_validator
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 from uuid import UUID
 
 from src.config import logger
 from src.services import RFPService
 from datetime import datetime
 
-from src.models import RFPStatus
+from src.models import RFPStatus, AnalysisType
 
 
 class RFP(BaseModel):
@@ -65,6 +65,13 @@ class RFPDeleteResponse(BaseModel):
     status: str
 
 
+class EvaluationStatusResponse(BaseModel):
+    status: bool
+
+class EvaluationStatus(BaseModel):
+    data: EvaluationStatusResponse
+
+
 class RFPController:
     def __init__(self):
         self.__rfp_service = RFPService
@@ -104,6 +111,13 @@ class RFPController:
             response_model=RFPDeleteResponse,
             tags=["RFPs by ID"],
         )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/evaluation-status",
+            self.get_evaluation_status,
+            methods=["GET"],
+            response_model=EvaluationStatus,
+            tags=["RFPs Evaluation Status"],
+        )
 
     async def get_rfps(self, status: Optional[RFPStatus] = Query(None)):
         async with self.__rfp_service() as service:
@@ -168,3 +182,15 @@ class RFPController:
             except Exception as e:
                 logger.exception(e)
                 raise HTTPException(status_code=500, detail="Failed to delete RFP.")
+
+    async def get_evaluation_status(self, rfp_id: str = Path(...)):
+        async with self.__rfp_service() as service:
+            try:
+                has_deficiencies = await service.check_deficiencies(rfp_id)
+                return EvaluationStatus(data=EvaluationStatusResponse(status=has_deficiencies))
+            except HTTPException as e:
+                logger.warning(e)
+                raise e
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(status_code=500, detail="Failed to check evaluation status.")

src/services/_rfp_service.py

@@ -1,10 +1,13 @@
-from src.models import RFP, RFPStatus
-from src.repositories import RFPRepository
+from src.models import RFP, RFPStatus, AnalysisType
+from src.repositories import RFPRepository, ProposalRepository, ProposalEvaluationRepository, AnalysisRepository
 
 
 class RFPService:
     def __init__(self):
         self.rfp_repository = RFPRepository
+        self.proposal_repository = ProposalRepository
+        self.evaluation_repository = ProposalEvaluationRepository
+        self.analysis_repository = AnalysisRepository
 
     async def __aenter__(self):
         return self
@@ -27,3 +30,32 @@ class RFPService:
     async def delete_rfp(self, rfp_id: str):
         async with self.rfp_repository() as repository:
             return await repository.delete_rfp(rfp_id)
+
+    async def check_deficiencies(self, rfp_id: str) -> bool:
+        async with self.proposal_repository() as proposal_repo:
+            proposals = await proposal_repo.get_proposals(rfp_id=rfp_id)
+            if not proposals:
+                return False
+            
+            for proposal in proposals:
+                proposal_id = proposal["id"]
+                
+                async with self.evaluation_repository() as eval_repo:
+                    evaluations = await eval_repo.get_evaluations(proposal_id=proposal_id)
+                    
+                    if not evaluations:
+                        continue
+                        
+                    for evaluation in evaluations:
+                        evaluation_id = evaluation["id"]
+                        
+                        async with self.analysis_repository() as analysis_repo:
+                            deficiencies = await analysis_repo.get_analysis(
+                                evaluation_id=evaluation_id,
+                                analysis_type=AnalysisType.DEFICIENCIES
+                            )
+                            
+                            if deficiencies:
+                                return True
+            
+            return False