implement calculation for adjusted score

src/controllers/_analysis_conteoller.py

@@ -32,6 +32,7 @@ class CreateAnalysis(BaseModel):
 
 class CreateAnalysisRequest(BaseModel):
     data: List[CreateAnalysis]
+    analysis_score_type: Optional[str] = None
 
 
 class UpdateAnalysis(BaseModel):
@@ -148,11 +149,17 @@ class AnalysisController:
     ):
         try:
             async with self.service() as service:
+                evaluation_analysis = analysis.model_dump(
+                    mode="json", exclude_unset=True
+                )
                 results = await service.create_analysis(
                     evaluation_id=evaluation_id,
-                    evaluation_analysis=analysis.model_dump(
-                        mode="json", exclude_unset=True
-                    )["data"],
+                    evaluation_analysis=evaluation_analysis["data"],
+                    analysis_score_type=(
+                        evaluation_analysis["analysis_score_type"]
+                        if "analysis_score_type" in evaluation_analysis
+                        else None
+                    ),
                 )
                 return Response(
                     status="success",

src/repositories/_analysis_repository.py

@@ -37,7 +37,12 @@ class AnalysisRepository(BaseRepository):
             for result in results
         ]
 
-    async def create_analysis(self, evaluation_id: str, evaluation_analysis: dict):
+    async def create_analysis(
+        self,
+        evaluation_id: str,
+        evaluation_analysis: dict,
+        analysis_score_type: str = None,
+    ):
         async with self.get_session() as session:
             for analysis in evaluation_analysis:
                 analysis["evaluation_id"] = evaluation_id
@@ -47,7 +52,9 @@ class AnalysisRepository(BaseRepository):
                 await session.commit()
                 await session.refresh(instance)
         async with self.score_client() as score_client:
-            await score_client.update_ai_score(evaluation_id=evaluation_id)
+            await score_client.update_ai_score(
+                evaluation_id=evaluation_id, analysis_score_type=analysis_score_type
+            )
         return await self.get_analysis(evaluation_id=evaluation_id)
 
     async def update_analysis(

src/services/_analysis_service.py

@@ -23,10 +23,17 @@ class AnalysisService:
                 evaluation_id=evaluation_id, analysis_type=analysis_type, id=id
             )
 
-    async def create_analysis(self, evaluation_id: str, evaluation_analysis: dict):
+    async def create_analysis(
+        self,
+        evaluation_id: str,
+        evaluation_analysis: dict,
+        analysis_score_type: str = None,
+    ):
         async with self.analysis_repository() as repo:
             return await repo.create_analysis(
-                evaluation_id=evaluation_id, evaluation_analysis=evaluation_analysis
+                evaluation_id=evaluation_id,
+                evaluation_analysis=evaluation_analysis,
+                analysis_score_type=analysis_score_type,
             )
 
     async def update_analysis(

src/utils/_score_client.py

@@ -12,6 +12,7 @@ from src.models import (
     Weights,
     Evaluations,
     EvaluationType,
+    AnalysisStatus,
 )
 
 
@@ -26,12 +27,21 @@ class ScoreClient:
     async def __aexit__(self, exc_type, exc_value, traceback):
         pass
 
-    async def update_ai_score(self, evaluation_id: str):
+    async def update_ai_score(
+        self, evaluation_id: str, analysis_score_type: str = None
+    ):
         async with self.repository(model=Evaluations).get_session() as session:
             query = select(Evaluations).where(Evaluations.id == evaluation_id)
             result = await session.execute(query)
             evaluation = result.scalars().first()
             proposal_id = evaluation.proposal_id
+
+        async with self.repository(model=Proposal).get_session() as session:
+            query = select(Proposal).where(Proposal.id == proposal_id)
+            result = await session.execute(query)
+            proposal = result.scalars().first()
+            rfp_id = proposal.rfp_id
+
         async with self.repository(model=Analysis).get_session() as session:
             query = select(Analysis).where(Analysis.evaluation_id == evaluation_id)
             result = await session.execute(query)
@@ -51,14 +61,27 @@ class ScoreClient:
                 for result in results
                 if result.analysis_type == AnalysisType.STRENGTHS
             ]
+            if analysis_score_type != "AI":
+                deficiency = [
+                    result.insights
+                    for result in results
+                    if result.analysis_type == AnalysisType.DEFICIENCIES
+                    and result.status != AnalysisStatus.REJECTED
+                ]
+                weaknesses = [
+                    result.insights
+                    for result in results
+                    if result.analysis_type == AnalysisType.WEAKNESSES
+                    and result.status != AnalysisStatus.REJECTED
+                ]
+                strengths = [
+                    result.insights
+                    for result in results
+                    if result.analysis_type == AnalysisType.STRENGTHS
+                    and result.status != AnalysisStatus.REJECTED
+                ]
             start_score = 0 if deficiency else 100
 
-        async with self.repository(model=Proposal).get_session() as session:
-            query = select(Proposal).where(Proposal.id == proposal_id)
-            result = await session.execute(query)
-            proposal = result.scalars().first()
-            rfp_id = proposal.rfp_id
-
         async with self.repository(model=ComparativeWeights).get_session() as session:
             query = select(ComparativeWeights).where(
                 ComparativeWeights.rfp_id == rfp_id
@@ -73,8 +96,11 @@ class ScoreClient:
             query = select(Evaluations).where(Evaluations.id == evaluation_id)
             result = await session.execute(query)
             evaluation = result.scalars().first()
-            evaluation.ai_score = start_score
-            evaluation.adjusted_score = start_score
+            if analysis_score_type == "AI":
+                evaluation.ai_score = start_score
+                evaluation.adjusted_score = start_score
+            else:
+                evaluation.adjusted_score = start_score
             await session.commit()
             await session.refresh(evaluation)
             query = select(Evaluations).where(Evaluations.proposal_id == proposal_id)
@@ -106,6 +132,32 @@ class ScoreClient:
             and evaluation.ai_score is not None
         ]
 
+        if analysis_score_type != "AI":
+            technical_ai_score = [
+                evaluation.adjusted_score
+                for evaluation in evaluations
+                if evaluation.evaluation_type == EvaluationType.TECHNICAL
+                and evaluation.adjusted_score is not None
+            ]
+            management_ai_score = [
+                evaluation.adjusted_score
+                for evaluation in evaluations
+                if evaluation.evaluation_type == EvaluationType.MANAGEMENT
+                and evaluation.adjusted_score is not None
+            ]
+            past_performance_ai_score = [
+                evaluation.adjusted_score
+                for evaluation in evaluations
+                if evaluation.evaluation_type == EvaluationType.PAST_PERFORMANCE
+                and evaluation.adjusted_score is not None
+            ]
+            price_ai_score = [
+                evaluation.adjusted_score
+                for evaluation in evaluations
+                if evaluation.evaluation_type == EvaluationType.PRICE
+                and evaluation.adjusted_score is not None
+            ]
+
         technical_ai_score = technical_ai_score[0] if technical_ai_score else 0
         management_ai_score = management_ai_score[0] if management_ai_score else 0
         past_performance_ai_score = (
@@ -141,7 +193,10 @@ class ScoreClient:
             query = select(Proposal).where(Proposal.id == proposal_id)
             result = await session.execute(query)
             evaluation = result.scalars().first()
-            evaluation.ai_score = ai_score
-            evaluation.final_score = ai_score
+            if analysis_score_type == "AI":
+                evaluation.ai_score = ai_score
+                evaluation.final_score = ai_score
+            else:
+                evaluation.final_score = ai_score
             await session.commit()
             await session.refresh(evaluation)