update the apis according to the scores

alembic/versions/3ba37b484f31_update_enum_type.py

@@ -0,0 +1,56 @@
+"""update enum type
+
+Revision ID: 3ba37b484f31
+Revises: 718e96a6869a
+Create Date: 2025-06-05 10:04:03.238833
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "3ba37b484f31"
+down_revision: Union[str, None] = "718e96a6869a"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.execute(
+        "CREATE TYPE analysistype_new AS ENUM ('STRENGTHS', 'WEAKNESSES', 'DEFICIENCIES')"
+    )
+
+    op.execute(
+        """
+        ALTER TABLE analysis
+        ALTER COLUMN analysis_type TYPE analysistype_new
+        USING analysis_type::text::analysistype_new
+    """
+    )
+
+    op.execute("DROP TYPE analysistype")
+
+    op.execute("ALTER TYPE analysistype_new RENAME TO analysistype")
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.execute(
+        "CREATE TYPE analysistype_old AS ENUM ('STRENGHTS', 'WEAKNESSES', 'DEFICIENCIES')"
+    )
+
+    op.execute(
+        """
+        ALTER TABLE analysis
+        ALTER COLUMN analysis_type TYPE analysistype_old
+        USING analysis_type::text::analysistype_old
+    """
+    )
+
+    op.execute("DROP TYPE analysistype")
+    op.execute("ALTER TYPE analysistype_old RENAME TO analysistype")

alembic/versions/718e96a6869a_update_tables.py

@@ -0,0 +1,125 @@
+"""update tables
+
+Revision ID: 718e96a6869a
+Revises: a3bbab758ddb
+Create Date: 2025-06-05 05:27:57.408552
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "718e96a6869a"
+down_revision: Union[str, None] = "a3bbab758ddb"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.add_column("rfps", sa.Column("ko_name", sa.String(), nullable=True))
+    op.add_column("rfps", sa.Column("award_type", sa.String(), nullable=True))
+    op.add_column("rfps", sa.Column("google_drive_id", sa.String(), nullable=True))
+
+    op.add_column("proposals", sa.Column("ai_score", sa.Float(), nullable=True))
+    op.add_column("proposals", sa.Column("final_score", sa.Float(), nullable=True))
+
+    op.create_table(
+        "comparative_weights",
+        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
+        sa.Column(
+            "rfp_id",
+            postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("rfps.id", ondelete="CASCADE"),
+            nullable=False,
+            unique=True,
+        ),
+        sa.Column(
+            "technical_weight",
+            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
+            nullable=False,
+        ),
+        sa.Column(
+            "management_weight",
+            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
+            nullable=False,
+        ),
+        sa.Column(
+            "past_performance_weight",
+            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
+            nullable=False,
+        ),
+        sa.Column(
+            "price_weight",
+            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
+            nullable=False,
+        ),
+        sa.Column("strengths_weight", sa.Float(), nullable=False, default=15),
+        sa.Column("weaknesses_weight", sa.Float(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+    )
+
+    op.create_table(
+        "evaluations",
+        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
+        sa.Column(
+            "proposal_id",
+            postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("proposals.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column(
+            "evaluation_type",
+            sa.Enum(
+                "TECHNICAL",
+                "MANAGEMENT",
+                "PAST_PERFORMANCE",
+                "PRICE",
+                name="evaluationtype",
+            ),
+            nullable=False,
+        ),
+        sa.Column("ai_score", sa.Float(), nullable=True),
+        sa.Column("adjusted_score", sa.Float(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+    )
+
+    op.create_table(
+        "analysis",
+        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
+        sa.Column(
+            "evaluation_id",
+            postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("evaluations.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("insights", sa.Text(), nullable=True),
+        sa.Column(
+            "analysis_type",
+            sa.Enum("STRENGHTS", "WEAKNESSES", "DEFICIENCIES", name="analysistype"),
+            nullable=False,
+        ),
+        sa.Column("created_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+    )
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    op.drop_column("rfps", "ko_name")
+    op.drop_column("rfps", "award_type")
+    op.drop_column("rfps", "google_drive_id")
+
+    op.drop_column("proposals", "ai_score")
+    op.drop_column("proposals", "final_score")
+
+    op.drop_table("comparative_weights")
+    op.drop_table("evaluations")
+    op.drop_table("analysis")

src/controllers/__init__.py

@@ -5,15 +5,21 @@ from ._proposal_ai_analysis_controller import ProposalAIController
 from ._proposal_detailed_analysis_controller import ProposalDetailedController
 from ._letter_controller import LetterController
 from ._evaluation_controller import EvaluationController
+from ._comparative_weight_controller import ComparativeWeightController
+from ._proposal_evaluation_controller import ProposalEvaluationController
+from ._analysis_conteoller import AnalysisController
 
 api_router = APIRouter()
 
 api_router.include_router(RFPController().router)
 api_router.include_router(ProposalController().router)
-api_router.include_router(ProposalAIController().router)
-api_router.include_router(ProposalDetailedController().router)
+# api_router.include_router(ProposalAIController().router)
+# api_router.include_router(ProposalDetailedController().router)
 api_router.include_router(LetterController().router)
 api_router.include_router(EvaluationController().router)
+api_router.include_router(ComparativeWeightController().router)
+api_router.include_router(ProposalEvaluationController().router)
+api_router.include_router(AnalysisController().router)
 
 __all__ = ["api_router"]
 __version__ = "0.1.0"

src/controllers/_analysis_conteoller.py

@@ -0,0 +1,239 @@
+from fastapi import APIRouter, Body, HTTPException, Query, Path
+from pydantic import BaseModel
+from typing import List, Optional
+from uuid import UUID
+from datetime import datetime
+
+from src.config import logger
+from src.models import AnalysisType
+from src.services import AnalysisService
+
+
+class Analysis(BaseModel):
+    id: UUID
+    evaluation_id: UUID
+    insights: str
+    analysis_type: AnalysisType
+    created_at: datetime
+    updated_at: datetime
+
+
+class Response(BaseModel):
+    status: str
+    analysis: Optional[List[Analysis]] = None
+
+
+class CreateAnalysis(BaseModel):
+    insights: str
+    analysis_type: AnalysisType
+
+
+class CreateAnalysisRequest(BaseModel):
+    data: List[CreateAnalysis]
+
+
+class UpdateAnalysis(BaseModel):
+    insights: Optional[str] = None
+    analysis_type: Optional[AnalysisType] = None
+
+
+class Deleteresponse(BaseModel):
+    status: str
+
+
+class AnalysisController:
+    def __init__(self):
+        self.service = AnalysisService
+        self.router = APIRouter()
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
+            self.get_analysis_by_proposal_and_rfp_id_and_evaluation_id,
+            methods=["GET"],
+            response_model=Response,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
+            self.get_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
+            methods=["GET"],
+            response_model=Response,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
+            self.create_analysis_by_proposal_and_rfp_id_and_evaluation_id,
+            methods=["POST"],
+            response_model=Response,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
+            self.update_analysis_by_proposal_and_rfp_id_and_evaluation_id,
+            methods=["PUT"],
+            response_model=Response,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
+            self.update_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
+            methods=["PUT"],
+            response_model=Response,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
+            self.delete_analysis_by_proposal_and_rfp_id_and_evaluation_id,
+            methods=["DELETE"],
+            response_model=Deleteresponse,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
+            self.delete_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
+            methods=["DELETE"],
+            response_model=Deleteresponse,
+            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
+        )
+
+    async def get_analysis_by_proposal_and_rfp_id_and_evaluation_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        analysis_type: AnalysisType = Query(None),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.get_analysis(
+                    evaluation_id=evaluation_id, analysis_type=analysis_type
+                )
+                return Response(
+                    status="success",
+                    analysis=[Analysis(**result) for result in results],
+                )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def get_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        id: str = Path(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.get_analysis(evaluation_id=evaluation_id, id=id)
+                return Response(
+                    status="success",
+                    analysis=[Analysis(**result) for result in results],
+                )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def create_analysis_by_proposal_and_rfp_id_and_evaluation_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        analysis: CreateAnalysisRequest = Body(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.create_analysis(
+                    evaluation_id=evaluation_id,
+                    evaluation_analysis=analysis.model_dump(
+                        mode="json", exclude_unset=True
+                    )["data"],
+                )
+                return Response(
+                    status="success",
+                    analysis=[Analysis(**result) for result in results],
+                )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def update_analysis_by_proposal_and_rfp_id_and_evaluation_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        analysis: CreateAnalysisRequest = Body(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.update_analysis(
+                    evaluation_id=evaluation_id,
+                    proposal_analysis=analysis.model_dump(
+                        mode="json", exclude_unset=True
+                    )["data"],
+                )
+                return Response(
+                    status="success",
+                    analysis=[Analysis(**result) for result in results],
+                )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def update_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        id: str = Path(...),
+        analysis: UpdateAnalysis = Body(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.update_analysis(
+                    evaluation_id=evaluation_id,
+                    id=id,
+                    proposal_analysis=analysis.model_dump(
+                        mode="json", exclude_unset=True
+                    ),
+                )
+                return Response(
+                    status="success",
+                    analysis=[Analysis(**result) for result in results],
+                )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def delete_analysis_by_proposal_and_rfp_id_and_evaluation_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.delete_analysis(evaluation_id=evaluation_id)
+                return Deleteresponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def delete_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_id: str = Path(...),
+        id: str = Path(...),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.delete_analysis(
+                    evaluation_id=evaluation_id, id=id
+                )
+                return Deleteresponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))

src/controllers/_comparative_weight_controller.py

@@ -0,0 +1,233 @@
+from fastapi import APIRouter, HTTPException, Query, Path
+from pydantic import BaseModel
+from typing import List, Optional
+from uuid import UUID
+from datetime import datetime
+
+from src.config import logger
+from src.models import Weights
+from src.services import ComparativeWeightService
+
+
+class ComparitiveWeight(BaseModel):
+    id: UUID
+    rfp_id: UUID
+    technical_weight: Weights
+    management_weight: Weights
+    past_performance_weight: Weights
+    price_weight: Weights
+    strengths_weight: float
+    weaknesses_weight: float
+
+
+class ResponseComparativeWeight(BaseModel):
+    status: str
+    data: Optional[List[ComparitiveWeight]]
+
+
+class DeleteResponse(BaseModel):
+    status: str
+
+
+class ComparativeWeightRequest(BaseModel):
+    technical_weight: Optional[Weights] = None
+    management_weight: Optional[Weights] = None
+    past_performance_weight: Optional[Weights] = None
+    price_weight: Optional[Weights] = None
+    strengths_weight: Optional[float] = None
+    weaknesses_weight: Optional[float] = None
+
+
+class ComparativeWeightController:
+    def __init__(self):
+        self.comparative_weight_service = ComparativeWeightService
+        self.router = APIRouter()
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights",
+            self.get_comparative_weights_by_rfp_id,
+            methods=["GET"],
+            response_model=ResponseComparativeWeight,
+            tags=["Comparative Weights by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights/{id}",
+            self.get_comparative_weights_by_id,
+            methods=["GET"],
+            response_model=ResponseComparativeWeight,
+            tags=["Comparative Weights by RFP ID and ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights",
+            self.create_comparative_weights,
+            methods=["POST"],
+            response_model=ResponseComparativeWeight,
+            tags=["Comparative Weights by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights/{id}",
+            self.update_comparative_weights_by_id,
+            methods=["PUT"],
+            response_model=ResponseComparativeWeight,
+            tags=["Comparative Weights by RFP ID and ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights",
+            self.update_comparative_weights,
+            methods=["PUT"],
+            response_model=ResponseComparativeWeight,
+            tags=["Comparative Weights by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights",
+            self.delete_comparative_weights,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Comparative Weights by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/comparative-weights/{id}",
+            self.delete_comparative_weights_by_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Comparative Weights by RFP ID and ID"],
+        )
+
+    async def get_comparative_weights_by_rfp_id(self, rfp_id: str = Path(...)):
+        try:
+            async with self.comparative_weight_service() as service:
+                comparative_weights = await service.get_comparative_weights(
+                    rfp_id=rfp_id
+                )
+            return ResponseComparativeWeight(
+                status="success",
+                data=[
+                    ComparitiveWeight(**comparative_weight)
+                    for comparative_weight in comparative_weights
+                ],
+            )
+        except Exception as e:
+            logger.error(f"Error getting comparative weights by rfp id: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error getting comparative weights by rfp id"
+            )
+
+    async def get_comparative_weights_by_id(
+        self, rfp_id: str = Path(...), id: str = Path(...)
+    ):
+        try:
+            async with self.comparative_weight_service() as service:
+                comparative_weights = await service.get_comparative_weights(
+                    rfp_id=rfp_id, id=id
+                )
+            return ResponseComparativeWeight(
+                status="success",
+                data=[
+                    ComparitiveWeight(**comparative_weight)
+                    for comparative_weight in comparative_weights
+                ],
+            )
+        except Exception as e:
+            logger.error(f"Error getting comparative weights by id: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error getting comparative weights by id"
+            )
+
+    async def create_comparative_weights(
+        self, comparative_weights: ComparativeWeightRequest, rfp_id: str = Path(...)
+    ):
+        try:
+            async with self.comparative_weight_service() as service:
+                comparative_weights = await service.create_comparative_weights(
+                    rfp_id=rfp_id,
+                    comparative_weights=comparative_weights.model_dump(
+                        mode="json", exclude_unset=True
+                    ),
+                )
+            return ResponseComparativeWeight(
+                status="success",
+                data=[
+                    ComparitiveWeight(**comparative_weight)
+                    for comparative_weight in comparative_weights
+                ],
+            )
+        except Exception as e:
+            logger.error(f"Error creating comparative weights: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error creating comparative weights"
+            )
+
+    async def update_comparative_weights(
+        self, comparative_weights: ComparativeWeightRequest, rfp_id: str = Path(...)
+    ):
+        try:
+            async with self.comparative_weight_service() as service:
+                comparative_weights = await service.update_comparative_weights(
+                    rfp_id=rfp_id,
+                    comparative_weights=comparative_weights.model_dump(
+                        mode="json", exclude_unset=True
+                    ),
+                )
+            return ResponseComparativeWeight(
+                status="success",
+                data=[
+                    ComparitiveWeight(**comparative_weight)
+                    for comparative_weight in comparative_weights
+                ],
+            )
+        except Exception as e:
+            logger.error(f"Error updating comparative weights: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error updating comparative weights"
+            )
+
+    async def update_comparative_weights_by_id(
+        self,
+        comparative_weights: ComparativeWeightRequest,
+        rfp_id: str = Path(...),
+        id: str = Path(...),
+    ):
+        try:
+            async with self.comparative_weight_service() as service:
+                comparative_weights = await service.update_comparative_weights(
+                    rfp_id=rfp_id,
+                    id=id,
+                    comparative_weights=comparative_weights.model_dump(
+                        mode="json", exclude_unset=True
+                    ),
+                )
+            return ResponseComparativeWeight(
+                status="success",
+                data=[
+                    ComparitiveWeight(**comparative_weight)
+                    for comparative_weight in comparative_weights
+                ],
+            )
+        except Exception as e:
+            logger.error(f"Error updating comparative weights by id: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error updating comparative weights by id"
+            )
+
+    async def delete_comparative_weights(self, rfp_id: str = Path(...)):
+        try:
+            async with self.comparative_weight_service() as service:
+                await service.delete_comparative_weights(rfp_id=rfp_id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(f"Error deleting comparative weights: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error deleting comparative weights"
+            )
+
+    async def delete_comparative_weights_by_id(
+        self, rfp_id: str = Path(...), id: str = Path(...)
+    ):
+        try:
+            async with self.comparative_weight_service() as service:
+                await service.delete_comparative_weights(rfp_id=rfp_id, id=id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(f"Error deleting comparative weights: {e}")
+            raise HTTPException(
+                status_code=500, detail="Error deleting comparative weights"
+            )

src/controllers/_evaluation_controller.py

@@ -53,20 +53,20 @@ class EvaluationController:
     def __init__(self):
         self.evaluation_service = EvaluationService
         self.router = APIRouter()
-        self.router.add_api_route(
-            "/evaluation-criteria",
-            self.get_criteria,
-            methods=["GET"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria"],
-        )
-        self.router.add_api_route(
-            "/evaluation-criteria/{id}",
-            self.get_criteria_by_id,
-            methods=["GET"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/evaluation-criteria",
+        #     self.get_criteria,
+        #     methods=["GET"],
+        #     response_model=EvaluationResponse,
+        #     tags=["Evaluation Criteria"],
+        # )
+        # self.router.add_api_route(
+        #     "/evaluation-criteria/{id}",
+        #     self.get_criteria_by_id,
+        #     methods=["GET"],
+        #     response_model=EvaluationResponse,
+        #     tags=["Evaluation Criteria by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/evaluation-criteria",
             self.get_criteria_by_rfp_id,
@@ -81,13 +81,13 @@ class EvaluationController:
             response_model=EvaluationResponse,
             tags=["Evaluation Criteria by Proposal and RFP ID"],
         )
-        self.router.add_api_route(
-            "/evaluation-criteria",
-            self.create_criteria,
-            methods=["POST"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria"],
-        )
+        # self.router.add_api_route(
+        #     "/evaluation-criteria",
+        #     self.create_criteria,
+        #     methods=["POST"],
+        #     response_model=EvaluationResponse,
+        #     tags=["Evaluation Criteria"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/evaluation-criteria",
             self.create_criteria_by_rfp_id,
@@ -95,13 +95,13 @@ class EvaluationController:
             response_model=EvaluationResponse,
             tags=["Evaluation Criteria by RFP ID"],
         )
-        self.router.add_api_route(
-            "/evaluation-criteria/{id}",
-            self.update_criteria,
-            methods=["PUT"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/evaluation-criteria/{id}",
+        #     self.update_criteria,
+        #     methods=["PUT"],
+        #     response_model=EvaluationResponse,
+        #     tags=["Evaluation Criteria by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/evaluation-criteria/{id}",
             self.update_criteria_by_proposal_and_rfp_id,
@@ -109,13 +109,13 @@ class EvaluationController:
             response_model=EvaluationResponse,
             tags=["Evaluation Criteria by Proposal and RFP ID"],
         )
-        self.router.add_api_route(
-            "/evaluation-criteria/{id}",
-            self.delete_criteria,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Evaluation Criteria by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/evaluation-criteria/{id}",
+        #     self.delete_criteria,
+        #     methods=["DELETE"],
+        #     response_model=DeleteResponse,
+        #     tags=["Evaluation Criteria by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/evaluation-criteria",
             self.delete_criteria_by_rfp_id,

src/controllers/_letter_controller.py

@@ -53,78 +53,78 @@ class LetterController:
     def __init__(self):
         self.letter_service = LetterService
         self.router = APIRouter()
+        # self.router.add_api_route(
+        #     "/letters",
+        #     self.get_letters,
+        #     methods=["GET"],
+        #     response_model=Response,
+        #     tags=["Letters"],
+        # )
+        # self.router.add_api_route(
+        #     "/letters/{id}",
+        #     self.get_letters_by_id,
+        #     methods=["GET"],
+        #     response_model=Response,
+        #     tags=["Letters by ID"],
+        # )
         self.router.add_api_route(
-            "/letters",
-            self.get_letters,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Letters"],
-        )
-        self.router.add_api_route(
-            "/letters/{id}",
-            self.get_letters_by_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Letters by ID"],
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/letters",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
             self.get_letters_by_proposal_id,
             methods=["GET"],
             response_model=Response,
             tags=["Letters by Proposal ID"],
         )
         self.router.add_api_route(
-            "/proposals/{proposal_id}/letters/{id}",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
             self.get_letters_by_proposal_and_id,
             methods=["GET"],
             response_model=Response,
             tags=["Letters by Proposal and ID"],
         )
+        # self.router.add_api_route(
+        #     "/letters",
+        #     self.create_letter,
+        #     methods=["POST"],
+        #     response_model=Response,
+        #     tags=["Letters"],
+        # )
         self.router.add_api_route(
-            "/letters",
-            self.create_letter,
-            methods=["POST"],
-            response_model=Response,
-            tags=["Letters"],
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/letters",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
             self.create_letters_by_proposal_id,
             methods=["POST"],
             response_model=Response,
             tags=["Letters by Proposal ID"],
         )
+        # self.router.add_api_route(
+        #     "/letters/{id}",
+        #     self.update_letter,
+        #     methods=["PUT"],
+        #     response_model=Response,
+        #     tags=["Letters by ID"],
+        # )
         self.router.add_api_route(
-            "/letters/{id}",
-            self.update_letter,
-            methods=["PUT"],
-            response_model=Response,
-            tags=["Letters by ID"],
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/letters/{id}",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
             self.update_letters_by_proposal_and_id,
             methods=["PUT"],
             response_model=Response,
             tags=["Letters by Proposal and ID"],
         )
+        # self.router.add_api_route(
+        #     "/letters/{id}",
+        #     self.delete_letter,
+        #     methods=["DELETE"],
+        #     response_model=DeleteResponse,
+        #     tags=["Letters by ID"],
+        # )
         self.router.add_api_route(
-            "/letters/{id}",
-            self.delete_letter,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Letters by ID"],
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/letters",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
             self.delete_letters_by_proposal_id,
             methods=["DELETE"],
             response_model=DeleteResponse,
             tags=["Letters by Proposal ID"],
         )
         self.router.add_api_route(
-            "/proposals/{proposal_id}/letters/{id}",
+            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
             self.delete_letters_by_proposal_and_id,
             methods=["DELETE"],
             response_model=DeleteResponse,
@@ -150,7 +150,10 @@ class LetterController:
             raise HTTPException(status_code=500, detail="Error fetching letter")
 
     async def get_letters_by_proposal_id(
-        self, proposal_id: str = Path(...), letter_type: LetterType = Query(None)
+        self,
+        proposal_id: str = Path(...),
+        letter_type: LetterType = Query(None),
+        rfp_id: str = Path(...),
     ):
         try:
             async with self.letter_service() as service:
@@ -163,7 +166,7 @@ class LetterController:
             raise HTTPException(status_code=500, detail="Error fetching letter")
 
     async def get_letters_by_proposal_and_id(
-        self, proposal_id: str = Path(...), id: str = Path(...)
+        self, proposal_id: str = Path(...), id: str = Path(...), rfp_id: str = Path(...)
     ):
         try:
             async with self.letter_service() as service:
@@ -185,7 +188,10 @@ class LetterController:
             raise HTTPException(status_code=500, detail="Error creating letter")
 
     async def create_letters_by_proposal_id(
-        self, letter: CreateLetterRequest, proposal_id: str = Path(...)
+        self,
+        letter: CreateLetterRequest,
+        proposal_id: str = Path(...),
+        rfp_id: str = Path(...),
     ):
         try:
             async with self.letter_service() as service:
@@ -213,6 +219,7 @@ class LetterController:
         letter: UpdateLetterRequestByProposalAndId,
         proposal_id: str = Path(...),
         id: str = Path(...),
+        rfp_id: str = Path(...),
     ):
         try:
             async with self.letter_service() as service:
@@ -233,7 +240,9 @@ class LetterController:
             logger.error(e)
             raise HTTPException(status_code=500, detail="Error deleting letter")
 
-    async def delete_letters_by_proposal_id(self, proposal_id: str = Path(...)):
+    async def delete_letters_by_proposal_id(
+        self, proposal_id: str = Path(...), rfp_id: str = Path(...)
+    ):
         try:
             async with self.letter_service() as service:
                 result = await service.delete_letter(proposal_id=proposal_id)
@@ -243,7 +252,7 @@ class LetterController:
             raise HTTPException(status_code=500, detail="Error deleting letter")
 
     async def delete_letters_by_proposal_and_id(
-        self, proposal_id: str = Path(...), id: str = Path(...)
+        self, proposal_id: str = Path(...), id: str = Path(...), rfp_id: str = Path(...)
     ):
         try:
             async with self.letter_service() as service:

src/controllers/_proposal_controller.py

@@ -16,6 +16,8 @@ class Proposal(BaseModel):
     tep: str
     gate_criteria: GateCriteria
     status: ProposalStatus
+    ai_score: Optional[float] = None
+    final_score: Optional[float] = None
     created_at: datetime
     updated_at: datetime
 
@@ -26,6 +28,8 @@ class ProposalRequest(BaseModel):
     tep: str
     gate_criteria: GateCriteria
     status: ProposalStatus
+    ai_score: Optional[float] = None
+    final_score: Optional[float] = None
 
 
 class CreateProposalRequest(BaseModel):
@@ -33,6 +37,8 @@ class CreateProposalRequest(BaseModel):
     tep: str
     gate_criteria: GateCriteria
     status: ProposalStatus
+    ai_score: Optional[float] = None
+    final_score: Optional[float] = None
 
 
 class ProposalUpdateRequest(BaseModel):
@@ -41,6 +47,8 @@ class ProposalUpdateRequest(BaseModel):
     tep: Optional[str] = None
     gate_criteria: Optional[GateCriteria] = None
     status: Optional[ProposalStatus] = None
+    ai_score: Optional[float] = None
+    final_score: Optional[float] = None
 
 
 class UpdateProposalRequest(BaseModel):
@@ -48,6 +56,8 @@ class UpdateProposalRequest(BaseModel):
     tep: Optional[str] = None
     gate_criteria: Optional[GateCriteria] = None
     status: Optional[ProposalStatus] = None
+    ai_score: Optional[float] = None
+    final_score: Optional[float] = None
 
 
 class ProposalDeleteResponse(BaseModel):
@@ -63,20 +73,20 @@ class ProposalController:
     def __init__(self):
         self.__proposal_service = ProposalService
         self.router = APIRouter()
-        self.router.add_api_route(
-            "/proposals",
-            self.get_proposals,
-            methods=["GET"],
-            response_model=ResponseProposal,
-            tags=["Proposals"],
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}",
-            self.get_proposals_by_id,
-            methods=["GET"],
-            response_model=ResponseProposal,
-            tags=["Proposals by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/proposals",
+        #     self.get_proposals,
+        #     methods=["GET"],
+        #     response_model=ResponseProposal,
+        #     tags=["Proposals"],
+        # )
+        # self.router.add_api_route(
+        #     "/proposals/{proposal_id}",
+        #     self.get_proposals_by_id,
+        #     methods=["GET"],
+        #     response_model=ResponseProposal,
+        #     tags=["Proposals by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/proposals",
             self.get_proposals_by_rfp_id,
@@ -91,13 +101,13 @@ class ProposalController:
             response_model=ResponseProposal,
             tags=["Proposals by Proposal and RFP ID"],
         )
-        self.router.add_api_route(
-            "/proposals",
-            self.create_proposal,
-            methods=["POST"],
-            response_model=ResponseProposal,
-            tags=["Proposals"],
-        )
+        # self.router.add_api_route(
+        #     "/proposals",
+        #     self.create_proposal,
+        #     methods=["POST"],
+        #     response_model=ResponseProposal,
+        #     tags=["Proposals"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/proposals",
             self.create_proposal_by_rfp_id,
@@ -105,13 +115,13 @@ class ProposalController:
             response_model=ResponseProposal,
             tags=["Proposals by RFP ID"],
         )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}",
-            self.update_proposal,
-            methods=["PUT"],
-            response_model=ResponseProposal,
-            tags=["Proposals by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/proposals/{proposal_id}",
+        #     self.update_proposal,
+        #     methods=["PUT"],
+        #     response_model=ResponseProposal,
+        #     tags=["Proposals by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/proposals/{proposal_id}",
             self.update_proposal_by_proposal_and_rfp_id,
@@ -119,13 +129,13 @@ class ProposalController:
             response_model=ResponseProposal,
             tags=["Proposals by Proposal and RFP ID"],
         )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}",
-            self.delete_proposal,
-            methods=["DELETE"],
-            response_model=ProposalDeleteResponse,
-            tags=["Proposals by ID"],
-        )
+        # self.router.add_api_route(
+        #     "/proposals/{proposal_id}",
+        #     self.delete_proposal,
+        #     methods=["DELETE"],
+        #     response_model=ProposalDeleteResponse,
+        #     tags=["Proposals by ID"],
+        # )
         self.router.add_api_route(
             "/rfps/{rfp_id}/proposals",
             self.delete_proposals_by_rfp_id,

src/controllers/_proposal_evaluation_controller.py

@@ -0,0 +1,202 @@
+from fastapi import APIRouter, HTTPException, Query, Path
+from pydantic import BaseModel
+from typing import List, Optional
+from uuid import UUID
+from datetime import datetime
+
+from src.config import logger
+from src.models import EvaluationType
+from src.services import ProposalEvaluationService
+
+
+class Evaluation(BaseModel):
+    id: UUID
+    proposal_id: UUID
+    evaluation_type: EvaluationType
+    ai_score: Optional[float] = None
+    adjusted_score: Optional[float] = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class Response(BaseModel):
+    status: str
+    evaluations: Optional[List[Evaluation]] = None
+
+
+class RequestEvaluation(BaseModel):
+    evaluation_type: Optional[EvaluationType] = None
+    ai_score: Optional[float] = None
+    adjusted_score: Optional[float] = None
+
+
+class DeleteResponse(BaseModel):
+    status: str
+
+
+class CreateEvaluation(BaseModel):
+    evaluation_type: EvaluationType
+    ai_score: Optional[float] = None
+    adjusted_score: Optional[float] = None
+
+
+class CreateEvaluationRequest(BaseModel):
+    data: List[CreateEvaluation]
+
+
+class UpdateEvaluation(BaseModel):
+    evaluation_type: Optional[EvaluationType] = None
+    ai_score: Optional[float] = None
+    adjusted_score: Optional[float] = None
+
+
+class ProposalEvaluationController:
+    def __init__(self):
+        self.service = ProposalEvaluationService
+        self.router = APIRouter()
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation",
+            self.get_evaluation_by_proposal_and_rfp_id,
+            methods=["GET"],
+            response_model=Response,
+            tags=["Evaluations by Proposal and RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation/{id}",
+            self.get_evaluation_by_proposal_and_rfp_id_and_id,
+            methods=["GET"],
+            response_model=Response,
+            tags=["Evaluations by Proposal and RFP ID and ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation",
+            self.create_evaluation_by_proposal_and_rfp_id,
+            methods=["POST"],
+            response_model=Response,
+            tags=["Evaluations by Proposal and RFP ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation/{id}",
+            self.update_evaluation_by_proposal_and_rfp_id_and_id,
+            methods=["PUT"],
+            response_model=Response,
+            tags=["Evaluations by Proposal and RFP ID and ID"],
+        )
+
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation",
+            self.delete_evaluation_by_proposal_and_rfp_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Evaluations by Proposal and RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluation/{id}",
+            self.delete_evaluation_by_proposal_and_rfp_id_and_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Evaluations by Proposal and RFP ID and ID"],
+        )
+
+    async def get_evaluation_by_proposal_and_rfp_id(
+        self,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        evaluation_type: Optional[EvaluationType] = Query(None),
+    ):
+        try:
+            async with self.service() as service:
+                results = await service.get_evaluations(
+                    proposal_id=proposal_id, evaluation_type=evaluation_type
+                )
+                return Response(
+                    status="success",
+                    evaluations=[Evaluation(**result) for result in results],
+                )
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
+
+    async def get_evaluation_by_proposal_and_rfp_id_and_id(
+        self, rfp_id: str = Path(...), proposal_id: str = Path(...), id: str = Path(...)
+    ):
+        try:
+            async with self.service() as service:
+                result = await service.get_evaluations(proposal_id=proposal_id, id=id)
+                return Response(
+                    status="success",
+                    evaluations=[Evaluation(**result) for result in result],
+                )
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
+
+    async def create_evaluation_by_proposal_and_rfp_id(
+        self,
+        evaluation: CreateEvaluationRequest,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+    ):
+        try:
+            async with self.service() as service:
+                result = await service.create_evaluations(
+                    proposal_id=proposal_id,
+                    evaluations=evaluation.model_dump(mode="json", exclude_unset=True)[
+                        "data"
+                    ],
+                )
+                return Response(
+                    status="success",
+                    evaluations=[Evaluation(**result) for result in result],
+                )
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
+
+    async def update_evaluation_by_proposal_and_rfp_id_and_id(
+        self,
+        evaluation: UpdateEvaluation,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
+        id: str = Path(...),
+    ):
+        try:
+            async with self.service() as service:
+                result = await service.update_evaluations(
+                    proposal_id=proposal_id,
+                    id=id,
+                    evaluations=evaluation.model_dump(mode="json", exclude_unset=True),
+                )
+                return Response(
+                    status="success",
+                    evaluations=[Evaluation(**result) for result in result],
+                )
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
+
+    async def delete_evaluation_by_proposal_and_rfp_id(
+        self, rfp_id: str = Path(...), proposal_id: str = Path(...)
+    ):
+        try:
+            async with self.service() as service:
+                result = await service.delete_evaluations(proposal_id=proposal_id)
+                return DeleteResponse(status="success")
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
+
+    async def delete_evaluation_by_proposal_and_rfp_id_and_id(
+        self, rfp_id: str = Path(...), proposal_id: str = Path(...), id: str = Path(...)
+    ):
+        try:
+            async with self.service() as service:
+                result = await service.delete_evaluations(
+                    proposal_id=proposal_id, id=id
+                )
+                return DeleteResponse(status="success")
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")

src/controllers/_rfp_controller.py

@@ -19,6 +19,9 @@ class RFP(BaseModel):
     evaluated_count: int
     awaiting_evaluation: int
     target_award_date: Optional[datetime] = None
+    ko_name: Optional[str] = None
+    award_type: Optional[str] = None
+    google_drive_id: Optional[str] = None
     status: RFPStatus
     created_at: datetime
     updated_at: datetime
@@ -34,7 +37,10 @@ class RFPRequest(BaseModel):
     name: str
     received_proposals: int
     evaluated_count: int
-    target_award_date: datetime
+    target_award_date: Optional[datetime] = None
+    ko_name: Optional[str] = None
+    award_type: Optional[str] = None
+    google_drive_id: Optional[str] = None
     status: RFPStatus
     awaiting_evaluation: int
 
@@ -45,6 +51,9 @@ class RFPUpdateRequest(BaseModel):
     received_proposals: Optional[int] = None
     evaluated_count: Optional[int] = None
     target_award_date: Optional[datetime] = None
+    ko_name: Optional[str] = None
+    award_type: Optional[str] = None
+    google_drive_id: Optional[str] = None
     status: Optional[RFPStatus] = None
     awaiting_evaluation: Optional[int] = None
 
@@ -58,16 +67,32 @@ class RFPController:
         self.__rfp_service = RFPService
         self.router = APIRouter()
         self.router.add_api_route(
-            "/rfps", self.get_rfps, methods=["GET"], response_model=ResponseRFP, tags=["RFPs"]
+            "/rfps",
+            self.get_rfps,
+            methods=["GET"],
+            response_model=ResponseRFP,
+            tags=["RFPs"],
         )
         self.router.add_api_route(
-            "/rfps/{rfp_id}", self.get_rfps_by_id, methods=["GET"], response_model=ResponseRFP, tags=["RFPs by ID"]
+            "/rfps/{rfp_id}",
+            self.get_rfps_by_id,
+            methods=["GET"],
+            response_model=ResponseRFP,
+            tags=["RFPs by ID"],
         )
         self.router.add_api_route(
-            "/rfps", self.create_rfp, methods=["POST"], response_model=ResponseRFP, tags=["RFPs"]
+            "/rfps",
+            self.create_rfp,
+            methods=["POST"],
+            response_model=ResponseRFP,
+            tags=["RFPs"],
         )
         self.router.add_api_route(
-            "/rfps/{rfp_id}", self.update_rfp, methods=["PUT"], response_model=ResponseRFP, tags=["RFPs by ID"]
+            "/rfps/{rfp_id}",
+            self.update_rfp,
+            methods=["PUT"],
+            response_model=ResponseRFP,
+            tags=["RFPs by ID"],
         )
         self.router.add_api_route(
             "/rfps/{rfp_id}",
@@ -88,7 +113,7 @@ class RFPController:
             except Exception as e:
                 logger.exception(e)
                 raise HTTPException(status_code=500, detail="Failed to retrieve RFPs.")
-            
+
     async def get_rfps_by_id(self, rfp_id: str = Path(...)):
         async with self.__rfp_service() as service:
             try:
@@ -116,7 +141,9 @@ class RFPController:
     async def update_rfp(self, rfp: RFPUpdateRequest, rfp_id: str = Path(...)):
         async with self.__rfp_service() as service:
             try:
-                rfp = await service.update_rfp(rfp_id=rfp_id, rfp=rfp.model_dump(exclude_unset=True))
+                rfp = await service.update_rfp(
+                    rfp_id=rfp_id, rfp=rfp.model_dump(exclude_unset=True)
+                )
                 return ResponseRFP(status="success", data=[RFP(**rfp)])
             except HTTPException as e:
                 logger.warning(e)

src/models/__init__.py

@@ -13,6 +13,9 @@ from ._proposal_detailed_analysis import ProposalDetailAnalysis, OperationCriter
 from ._proposal_query_models import QueryType, CreateOrUpdateType
 from ._letters import Letter, LetterType
 from ._evaluation import EvaluationCriteria, EvaluationCriteriaType
+from ._comparitive_weights import ComparativeWeights, Weights
+from ._proposal_evaluation import Evaluations, EvaluationType
+from ._analysis import Analysis, AnalysisType
 
 __all__ = [
     "Base",
@@ -35,6 +38,12 @@ __all__ = [
     "EvaluationCriteriaType",
     "RFPStatus",
     "Category",
+    "ComparativeWeights",
+    "Weights",
+    "Evaluations",
+    "EvaluationType",
+    "Analysis",
+    "AnalysisType",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/models/_analysis.py

@@ -0,0 +1,37 @@
+from enum import Enum as PyEnum
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from pydantic import BaseModel
+from ._base import Base
+
+
+class AnalysisType(PyEnum):
+    STRENGTHS = "STRENGTHS"
+    WEAKNESSES = "WEAKNESSES"
+    DEFICIENCIES = "DEFICIENCIES"
+
+
+class Analysis(Base):
+    __tablename__ = "analysis"
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    evaluation_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("evaluations.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    insights = Column(String, nullable=False)
+    analysis_type = Column(Enum(AnalysisType), nullable=False)
+    created_at = Column(DateTime(), nullable=False, default=func.now())
+    updated_at = Column(
+        DateTime(), nullable=False, default=func.now(), onupdate=func.now()
+    )

src/models/_comparitive_weights.py

@@ -0,0 +1,45 @@
+from enum import Enum as PyEnum
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from pydantic import BaseModel
+from ._base import Base
+
+
+class Weights(PyEnum):
+    NONE = "NONE"
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+
+
+class ComparativeWeights(Base):
+    __tablename__ = "comparative_weights"
+    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
+    rfp_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("rfps.id", ondelete="CASCADE"),
+        nullable=False,
+        unique=True,
+    )
+    technical_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
+    management_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
+    past_performance_weight = Column(
+        Enum(Weights, name="comparativeweights"), nullable=False
+    )
+    price_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
+    strengths_weight = Column(Float, nullable=False, default=15)
+    weaknesses_weight = Column(Float, nullable=False, default=5)
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(
+        DateTime, nullable=False, default=func.now(), onupdate=func.now()
+    )

src/models/_evaluation.py

@@ -14,15 +14,21 @@ from sqlalchemy.dialects.postgresql import UUID
 from pydantic import BaseModel
 from ._base import Base
 
+
 class EvaluationCriteriaType(PyEnum):
     EVALUATION = "EVALUATION"
     GATE = "GATE"
 
+
 class EvaluationCriteria(Base):
     __tablename__ = "evaluation_criteria_details"
     id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    rfp_id = Column(UUID(as_uuid=True), ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False)
+    rfp_id = Column(
+        UUID(as_uuid=True), ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False
+    )
     evaluation_criteria = Column(String, nullable=True)
     evaluation_criteria_type = Column(Enum(EvaluationCriteriaType), nullable=False)
     created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    updated_at = Column(
+        DateTime, nullable=False, default=func.now(), onupdate=func.now()
+    )

src/models/_letters.py

@@ -14,15 +14,23 @@ from sqlalchemy.dialects.postgresql import UUID
 from pydantic import BaseModel
 from ._base import Base
 
+
 class LetterType(PyEnum):
     UO = "UO"
     DEBRIEF = "DEBRIEF"
 
+
 class Letter(Base):
     __tablename__ = "letters"
     id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(UUID(as_uuid=True), ForeignKey("proposals.id", ondelete="CASCADE"), nullable=False)
+    proposal_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("proposals.id", ondelete="CASCADE"),
+        nullable=False,
+    )
     letter = Column(String, nullable=True)
     letter_type = Column(Enum(LetterType), nullable=False)
     created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    updated_at = Column(
+        DateTime, nullable=False, default=func.now(), onupdate=func.now()
+    )

src/models/_proposal.py

@@ -14,16 +14,19 @@ from sqlalchemy.dialects.postgresql import UUID
 from pydantic import BaseModel
 from ._base import Base
 
+
 class ProposalStatus(PyEnum):
     APPROVED = "APPROVED"
     EVALUATED = "EVALUATED"
     IN_REVIEW = "IN_REVIEW"
 
+
 class GateCriteria(PyEnum):
     PASS = "PASS"
     FAIL = "FAIL"
     IN_REVIEW = "IN_REVIEW"
 
+
 class Proposal(Base):
     __tablename__ = "proposals"
 
@@ -35,6 +38,8 @@ class Proposal(Base):
     tep = Column(String, nullable=False)
     gate_criteria = Column(Enum(GateCriteria), nullable=False)
     status = Column(Enum(ProposalStatus), nullable=False)
+    ai_score = Column(Float, nullable=True)
+    final_score = Column(Float, nullable=True)
     created_at = Column(DateTime, nullable=False, default=func.now())
     updated_at = Column(
         DateTime, nullable=False, default=func.now(), onupdate=func.now()

src/models/_proposal_evaluation.py

@@ -0,0 +1,40 @@
+from enum import Enum as PyEnum
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Enum,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from pydantic import BaseModel
+from ._base import Base
+
+
+class EvaluationType(PyEnum):
+    TECHNICAL = "TECHNICAL"
+    MANAGEMENT = "MANAGEMENT"
+    PAST_PERFORMANCE = "PAST_PERFORMANCE"
+    PRICE = "PRICE"
+
+
+class Evaluations(Base):
+    __tablename__ = "evaluations"
+
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    proposal_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("proposals.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    evaluation_type = Column(Enum(EvaluationType), nullable=False)
+    ai_score = Column(Float(), nullable=True)
+    adjusted_score = Column(Float(), nullable=True)
+    created_at = Column(DateTime(), nullable=False, default=func.now())
+    updated_at = Column(
+        DateTime(), nullable=False, default=func.now(), onupdate=func.now()
+    )

src/models/_rfp.py

@@ -14,6 +14,7 @@ from sqlalchemy.dialects.postgresql import UUID
 from pydantic import BaseModel
 from ._base import Base
 
+
 class RFPStatus(PyEnum):
     ACTIVE = "ACTIVE"
     IN_PROGRESS = "IN_PROGRESS"
@@ -23,6 +24,7 @@ class RFPStatus(PyEnum):
     AWARDED = "AWARDED"
     PROTESTED = "PROTESTED"
 
+
 class RFP(Base):
     __tablename__ = "rfps"
 
@@ -33,6 +35,9 @@ class RFP(Base):
     evaluated_count = Column(Integer, nullable=False)
     awaiting_evaluation = Column(Integer, nullable=False)
     target_award_date = Column(DateTime, nullable=True)
+    ko_name = Column(String, nullable=True)
+    award_type = Column(String, nullable=True)
+    google_drive_id = Column(String, nullable=True)
     status = Column(Enum(RFPStatus), nullable=False)
     created_at = Column(DateTime, nullable=False, default=func.now())
     updated_at = Column(

src/repositories/__init__.py

@@ -4,6 +4,9 @@ from ._proposal_repository import ProposalRepository
 from ._proposal_detailed_analysis_repository import ProposalDetailedAnalysisRepository
 from ._letter_repository import LetterRepository
 from ._evaluation_repository import EvaluationRepository
+from ._comparative_weight_repository import ComparativeWeightRepository
+from ._proposal_evaluation_repository import ProposalEvaluationRepository
+from ._analysis_repository import AnalysisRepository
 
 __all__ = [
     "BaseRepository",
@@ -12,6 +15,9 @@ __all__ = [
     "ProposalDetailedAnalysisRepository",
     "LetterRepository",
     "EvaluationRepository",
+    "ComparativeWeightRepository",
+    "ProposalEvaluationRepository",
+    "AnalysisRepository",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/repositories/_analysis_repository.py

@@ -0,0 +1,92 @@
+import uuid
+from sqlalchemy import select
+from ._base_repository import BaseRepository
+from src.models import AnalysisType, Analysis
+from src.utils import ScoreClient
+
+
+class AnalysisRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(Analysis)
+        self.score_client = ScoreClient
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_analysis(
+        self,
+        evaluation_id: str = None,
+        analysis_type: AnalysisType = None,
+        id: str = None,
+    ):
+        async with self.get_session() as session:
+            query = select(Analysis)
+            if evaluation_id is not None:
+                query = query.filter(Analysis.evaluation_id == evaluation_id)
+            if analysis_type is not None:
+                query = query.filter(Analysis.analysis_type == analysis_type)
+            if id is not None:
+                query = query.filter(Analysis.id == id)
+            result = await session.execute(query)
+            results = result.scalars().all()
+        return [
+            {k: v for k, v in result.__dict__.items() if not k.startswith("_")}
+            for result in results
+        ]
+
+    async def create_analysis(self, evaluation_id: str, evaluation_analysis: dict):
+        async with self.get_session() as session:
+            for analysis in evaluation_analysis:
+                analysis["evaluation_id"] = evaluation_id
+                analysis["id"] = str(uuid.uuid4())
+                instance = Analysis(**analysis)
+                session.add(instance)
+                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)
+        return await self.get_analysis(evaluation_id=evaluation_id)
+
+    async def update_analysis(
+        self, evaluation_id: str = None, id: str = None, proposal_analysis: dict = None
+    ):
+        async with self.get_session() as session:
+            if id:
+                query = select(Analysis).where(Analysis.id == id)
+                result = await session.execute(query)
+                instance = result.scalars().one()
+                for k, v in proposal_analysis.items():
+                    setattr(instance, k, v)
+                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)
+                return [
+                    {
+                        k: v
+                        for k, v in instance.__dict__.items()
+                        if not k.startswith("_")
+                    }
+                ]
+            else:
+                await self.delete_analysis(evaluation_id=evaluation_id)
+                return await self.create_analysis(
+                    evaluation_id=evaluation_id, evaluation_analysis=proposal_analysis
+                )
+
+    async def delete_analysis(self, evaluation_id: str = None, id: str = None):
+        async with self.get_session() as session:
+            query = select(Analysis)
+            if evaluation_id:
+                query = query.filter(Analysis.evaluation_id == evaluation_id)
+            if id:
+                query = query.filter(Analysis.id == id)
+            result = await session.execute(query)
+            instances = result.scalars().all()
+            for instance in instances:
+                await session.delete(instance)
+            await session.commit()
+            return True

src/repositories/_comparative_weight_repository.py

@@ -0,0 +1,74 @@
+import uuid
+from sqlalchemy import select
+from ._base_repository import BaseRepository
+from src.models import ComparativeWeights
+
+
+class ComparativeWeightRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(model=ComparativeWeights)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_comparative_weights(self, rfp_id: str = None, id: str = None):
+        async with self.get_session() as session:
+            query = select(ComparativeWeights)
+            if rfp_id:
+                query = query.where(ComparativeWeights.rfp_id == rfp_id)
+            if id:
+                query = query.where(ComparativeWeights.id == id)
+            result = await session.execute(query)
+            results = result.scalars().all()
+        return [
+            {k: v for k, v in result.__dict__.items() if not k.startswith("_")}
+            for result in results
+        ]
+
+    async def create_comparative_weights(self, rfp_id: str, comparative_weights: dict):
+        comparative_weights["rfp_id"] = rfp_id
+        comparative_weights["id"] = str(uuid.uuid4())
+        async with self.get_session() as session:
+            instance = ComparativeWeights(**comparative_weights)
+            session.add(instance)
+            await session.commit()
+            await session.refresh(instance)
+            return [
+                {k: v for k, v in instance.__dict__.items() if not k.startswith("_")}
+            ]
+
+    async def update_comparative_weights(
+        self, id: str = None, rfp_id: str = None, comparative_weights: dict = None
+    ):
+        async with self.get_session() as session:
+            query = select(ComparativeWeights)
+            if id:
+                query = query.where(ComparativeWeights.id == id)
+            if rfp_id:
+                query = query.where(ComparativeWeights.rfp_id == rfp_id)
+            output = await session.execute(query)
+            instance = output.scalars().one()
+            for k, v in comparative_weights.items():
+                setattr(instance, k, v)
+            await session.commit()
+            await session.refresh(instance)
+            return [
+                {k: v for k, v in instance.__dict__.items() if not k.startswith("_")}
+            ]
+
+    async def delete_comparative_weights(self, id: str = None, rfp_id: str = None):
+        async with self.get_session() as session:
+            query = select(ComparativeWeights)
+            if id:
+                query = query.where(ComparativeWeights.id == id)
+            if rfp_id:
+                query = query.where(ComparativeWeights.rfp_id == rfp_id)
+            output = await session.execute(query)
+            instances = output.scalars().all()
+            for instance in instances:
+                await session.delete(instance)
+            await session.commit()
+            return True

src/repositories/_proposal_evaluation_repository.py

@@ -0,0 +1,92 @@
+import uuid
+from sqlalchemy import select
+from ._base_repository import BaseRepository
+from src.models import Evaluations, EvaluationType
+
+
+class ProposalEvaluationRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(Evaluations)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_evaluations(
+        self,
+        proposal_id: str = None,
+        id: str = None,
+        evaluation_type: EvaluationType = None,
+    ):
+        async with self.get_session() as session:
+            query = select(Evaluations)
+            if proposal_id is not None:
+                query = query.filter(Evaluations.proposal_id == proposal_id)
+            if id is not None:
+                query = query.filter(Evaluations.id == id)
+            if evaluation_type is not None:
+                query = query.filter(Evaluations.evaluation_type == evaluation_type)
+            result = await session.execute(query)
+            results = result.scalars().all()
+        return [
+            {k: v for k, v in result.__dict__.items() if not k.startswith("_")}
+            for result in results
+        ]
+
+    async def craete_evaluations(self, proposal_id: str, proposal_evaluations: dict):
+        for evaluations in proposal_evaluations:
+            evaluations["proposal_id"] = proposal_id
+            evaluations["id"] = str(uuid.uuid4())
+            async with self.get_session() as session:
+                query = select(Evaluations).where(
+                    Evaluations.proposal_id == proposal_id,
+                    Evaluations.evaluation_type == evaluations["evaluation_type"],
+                )
+                result = await session.execute(query)
+                instances = result.scalars().all()
+                if instances:
+                    for instance in instances:
+                        await session.delete(instance)
+                        await session.commit()
+                print(evaluations)
+                instance = Evaluations(**evaluations)
+                session.add(instance)
+                await session.commit()
+                await session.refresh(instance)
+        return await self.get_evaluations(proposal_id=proposal_id)
+
+    async def update_evaluations(self, proposal_id: str, id: str, evaluations: dict):
+        async with self.get_session() as session:
+            if "evaluation_type" in evaluations:
+                query = select(Evaluations).where(
+                    Evaluations.proposal_id == proposal_id,
+                    Evaluations.evaluation_type == evaluations["evaluation_type"],
+                )
+                result = await session.execute(query)
+                instance = result.scalars().all()
+                if instance:
+                    return False
+            query = select(Evaluations).where(Evaluations.id == id)
+            result = await session.execute(query)
+            instance = result.scalars().one()
+            for k, v in evaluations.items():
+                setattr(instance, k, v)
+            await session.commit()
+            await session.refresh(instance)
+        return [{k: v for k, v in instance.__dict__.items() if not k.startswith("_")}]
+
+    async def delete_evaluations(self, proposal_id: str = None, id: str = None):
+        async with self.get_session() as session:
+            query = select(Evaluations)
+            if proposal_id:
+                query = query.where(Evaluations.proposal_id == proposal_id)
+            if id:
+                query = query.where(Evaluations.id == id)
+            result = await session.execute(query)
+            instances = result.scalars().all()
+            for instance in instances:
+                await session.delete(instance)
+            await session.commit()
+        return True

src/services/__init__.py

@@ -8,6 +8,9 @@ from ._proposal_ai_analysis_service import (
 from ._proposal_detailed_analysis_service import ProposalDetailedAnalysisService
 from ._letter_service import LetterService
 from ._evaluation_service import EvaluationService
+from ._comparative_weight_service import ComparativeWeightService
+from ._proposal_evaluation_service import ProposalEvaluationService
+from ._analysis_service import AnalysisService
 
 __all__ = [
     "RFPService",
@@ -18,6 +21,9 @@ __all__ = [
     "ProposalDetailedAnalysisService",
     "LetterService",
     "EvaluationService",
+    "ComparativeWeightService",
+    "ProposalEvaluationService",
+    "AnalysisService",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/services/_analysis_service.py

@@ -0,0 +1,42 @@
+from src.repositories import AnalysisRepository
+from src.models import AnalysisType
+
+
+class AnalysisService:
+    def __init__(self):
+        self.analysis_repository = AnalysisRepository
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_analysis(
+        self,
+        evaluation_id: str = None,
+        analysis_type: AnalysisType = None,
+        id: str = None,
+    ):
+        async with self.analysis_repository() as repo:
+            return await repo.get_analysis(
+                evaluation_id=evaluation_id, analysis_type=analysis_type, id=id
+            )
+
+    async def create_analysis(self, evaluation_id: str, evaluation_analysis: dict):
+        async with self.analysis_repository() as repo:
+            return await repo.create_analysis(
+                evaluation_id=evaluation_id, evaluation_analysis=evaluation_analysis
+            )
+
+    async def update_analysis(
+        self, evaluation_id: str = None, id: str = None, proposal_analysis: dict = None
+    ):
+        async with self.analysis_repository() as repo:
+            return await repo.update_analysis(
+                evaluation_id=evaluation_id, id=id, proposal_analysis=proposal_analysis
+            )
+
+    async def delete_analysis(self, evaluation_id: str = None, id: str = None):
+        async with self.analysis_repository() as repo:
+            return await repo.delete_analysis(evaluation_id=evaluation_id, id=id)

src/services/_comparative_weight_service.py

@@ -0,0 +1,38 @@
+from src.repositories import ComparativeWeightRepository
+
+
+class ComparativeWeightService:
+    def __init__(self):
+        self.comparative_weight_repository = ComparativeWeightRepository
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_comparative_weights(self, rfp_id: str = None, id: str = None):
+        async with self.comparative_weight_repository() as comparative_weight_repository:
+            return await comparative_weight_repository.get_comparative_weights(
+                rfp_id=rfp_id, id=id
+            )
+
+    async def create_comparative_weights(self, rfp_id: str, comparative_weights: dict):
+        async with self.comparative_weight_repository() as comparative_weight_repository:
+            return await comparative_weight_repository.create_comparative_weights(
+                rfp_id=rfp_id, comparative_weights=comparative_weights
+            )
+
+    async def update_comparative_weights(
+        self, id: str = None, rfp_id: str = None, comparative_weights: dict = None
+    ):
+        async with self.comparative_weight_repository() as comparative_weight_repository:
+            return await comparative_weight_repository.update_comparative_weights(
+                id=id, rfp_id=rfp_id, comparative_weights=comparative_weights
+            )
+
+    async def delete_comparative_weights(self, id: str = None, rfp_id: str = None):
+        async with self.comparative_weight_repository() as comparative_weight_repository:
+            return await comparative_weight_repository.delete_comparative_weights(
+                id=id, rfp_id=rfp_id
+            )

src/services/_evaluation_service.py

@@ -29,7 +29,9 @@ class EvaluationService:
 
     async def update_criteria(self, id: str, evaluation_criteria: dict):
         async with self._evaluation_repository() as repository:
-            return await repository.update_criteria(id=id, evaluation_criteria=evaluation_criteria)
+            return await repository.update_criteria(
+                id=id, evaluation_criteria=evaluation_criteria
+            )
 
     async def delete_criteria(self, id: str = None, rfp_id: str = None):
         async with self._evaluation_repository() as repository:

src/services/_proposal_ai_analysis_service.py

@@ -27,7 +27,10 @@ class ProposalAIAnalysisService:
                 return await client.get_complete_analysis(proposal_id=proposal_id)
             else:
                 return await client.get_all_data(
-                    query_type=query_type, id=id, proposal_id=proposal_id, category=category
+                    query_type=query_type,
+                    id=id,
+                    proposal_id=proposal_id,
+                    category=category,
                 )
 
     async def create_data(
@@ -74,5 +77,8 @@ class ProposalAIAnalysisService:
                 return await client.delete_complete_analysis(proposal_id=proposal_id)
             else:
                 return await client.delete_data(
-                    query_type=query_type, id=id, proposal_id=proposal_id, category=category
+                    query_type=query_type,
+                    id=id,
+                    proposal_id=proposal_id,
+                    category=category,
                 )

src/services/_proposal_evaluation_service.py

@@ -0,0 +1,40 @@
+from src.repositories import ProposalEvaluationRepository
+from src.models import EvaluationType
+
+
+class ProposalEvaluationService:
+    def __init__(self):
+        self.repo = ProposalEvaluationRepository
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_evaluations(
+        self,
+        proposal_id: str = None,
+        id: str = None,
+        evaluation_type: EvaluationType = None,
+    ):
+        async with self.repo() as repo:
+            return await repo.get_evaluations(
+                proposal_id=proposal_id, id=id, evaluation_type=evaluation_type
+            )
+
+    async def create_evaluations(self, proposal_id: str, evaluations: dict):
+        async with self.repo() as repo:
+            return await repo.craete_evaluations(
+                proposal_id=proposal_id, proposal_evaluations=evaluations
+            )
+
+    async def update_evaluations(self, proposal_id: str, id: str, evaluations: dict):
+        async with self.repo() as repo:
+            return await repo.update_evaluations(
+                proposal_id=proposal_id, id=id, evaluations=evaluations
+            )
+
+    async def delete_evaluations(self, proposal_id: str = None, id: str = None):
+        async with self.repo() as repo:
+            return await repo.delete_evaluations(proposal_id=proposal_id, id=id)

src/services/_proposal_service.py

@@ -30,7 +30,9 @@ class ProposalService:
 
     async def update_proposal(self, proposal_id: str, proposal: dict):
         async with self.proposal_repository() as repository:
-            return await repository.update_proposal(proposal_id=proposal_id, proposal=proposal)
+            return await repository.update_proposal(
+                proposal_id=proposal_id, proposal=proposal
+            )
 
     async def delete_proposal(self, proposal_id: str = None, rfp_id: str = None):
         async with self.proposal_repository() as repository:

src/utils/__init__.py

@@ -1,5 +1,6 @@
 from ._proposal_ai_analysis_client import ProposalAIAnalysisClient
+from ._score_client import ScoreClient
 
-__all__ = ["ProposalAIAnalysisClient"]
+__all__ = ["ProposalAIAnalysisClient", "ScoreClient"]
 __version__ = "0.1.0"
-__author__ = "Aryan Jain"
+__author__ = "Aryan Jain"

src/utils/_score_client.py

@@ -0,0 +1,145 @@
+from uuid import UUID
+import uuid
+
+from sqlalchemy import select
+from src.repositories import BaseRepository
+
+from src.models import (
+    AnalysisType,
+    Analysis,
+    Proposal,
+    ComparativeWeights,
+    Weights,
+    Evaluations,
+    EvaluationType,
+)
+
+
+class ScoreClient:
+    def __init__(self):
+        self.repository = BaseRepository
+        self.weighted_scores = {"NONE": 0, "LOW": 1, "MEDIUM": 3, "HIGH": 7}
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def update_ai_score(self, evaluation_id: str):
+        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=Analysis).get_session() as session:
+            query = select(Analysis).where(Analysis.evaluation_id == evaluation_id)
+            result = await session.execute(query)
+            results = result.scalars().all()
+            deficiency = [
+                result.insights
+                for result in results
+                if result.analysis_type == AnalysisType.DEFICIENCIES
+            ]
+            weaknesses = [
+                result.insights
+                for result in results
+                if result.analysis_type == AnalysisType.WEAKNESSES
+            ]
+            strengths = [
+                result.insights
+                for result in results
+                if result.analysis_type == AnalysisType.STRENGTHS
+            ]
+            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
+            )
+            result = await session.execute(query)
+            comparative_weights = result.scalars().first()
+
+        start_score += len(strengths) * comparative_weights.strengths_weight
+        start_score -= len(weaknesses) * comparative_weights.weaknesses_weight
+
+        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()
+            evaluation.ai_score = start_score
+            await session.commit()
+            await session.refresh(evaluation)
+            query = select(Evaluations).where(Evaluations.proposal_id == proposal_id)
+            result = await session.execute(query)
+            evaluations = result.scalars().all()
+
+        technical_ai_score = [
+            evaluation.ai_score
+            for evaluation in evaluations
+            if evaluation.evaluation_type == EvaluationType.TECHNICAL
+            and evaluation.ai_score is not None
+        ]
+        management_ai_score = [
+            evaluation.ai_score
+            for evaluation in evaluations
+            if evaluation.evaluation_type == EvaluationType.MANAGEMENT
+            and evaluation.ai_score is not None
+        ]
+        past_performance_ai_score = [
+            evaluation.ai_score
+            for evaluation in evaluations
+            if evaluation.evaluation_type == EvaluationType.PAST_PERFORMANCE
+            and evaluation.ai_score is not None
+        ]
+        price_ai_score = [
+            evaluation.ai_score
+            for evaluation in evaluations
+            if evaluation.evaluation_type == EvaluationType.PRICE
+            and evaluation.ai_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 = (
+            past_performance_ai_score[0] if past_performance_ai_score else 0
+        )
+        price_ai_score = price_ai_score[0] if price_ai_score else 0
+
+        technical_weight = self.weighted_scores[
+            comparative_weights.technical_weight.name
+        ]
+        management_weight = self.weighted_scores[
+            comparative_weights.management_weight.name
+        ]
+        past_performance_weight = self.weighted_scores[
+            comparative_weights.past_performance_weight.name
+        ]
+        price_weight = self.weighted_scores[comparative_weights.price_weight.name]
+
+        ai_score = (
+            technical_ai_score * technical_weight
+            + management_ai_score * management_weight
+            + past_performance_ai_score * past_performance_weight
+            + price_ai_score * price_weight
+        )
+        ai_score /= (
+            technical_weight
+            + management_weight
+            + past_performance_weight
+            + price_weight
+        )
+
+        async with self.repository(model=Proposal).get_session() as session:
+            query = select(Proposal).where(Proposal.id == proposal_id)
+            result = await session.execute(query)
+            evaluation = result.scalars().first()
+            evaluation.ai_score = ai_score
+            await session.commit()
+            await session.refresh(evaluation)