add evaluation

alembic/versions/c70330d677c0_add_evaluation_criteria.py

@@ -0,0 +1,38 @@
+"""add evaluation_criteria
+
+Revision ID: c70330d677c0
+Revises: e825902b2e8a
+Create Date: 2025-06-02 19:38:53.073958
+
+"""
+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 = 'c70330d677c0'
+down_revision: Union[str, None] = 'e825902b2e8a'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    op.create_table(
+        "evaluation_criteria_details",
+        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),
+        sa.Column("evaluation_criteria", sa.String(), nullable=True),
+        sa.Column("evaluation_criteria_type", sa.Enum("EVALUATION", "GATE", name="evaluationcriteriatype"), 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_table("evaluation_criteria_details")

src/controllers/__init__.py

@@ -4,6 +4,7 @@ from ._proposal_controller import ProposalController
 from ._proposal_ai_analysis_controller import ProposalAIController
 from ._proposal_detailed_analysis_controller import ProposalDetailedController
 from ._letter_controller import LetterController
+from ._evaluation_controller import EvaluationController
 
 api_router = APIRouter()
 
@@ -12,6 +13,7 @@ api_router.include_router(ProposalController().router, prefix="/proposal", tags=
 api_router.include_router(ProposalAIController().router, prefix="/proposal_ai_analysis", tags=["Proposal AI Analysis"])
 api_router.include_router(ProposalDetailedController().router, prefix="/proposal_detailed_analysis", tags=["Proposal Detailed Analysis"])
 api_router.include_router(LetterController().router, prefix="/letter", tags=["Letter"])
+api_router.include_router(EvaluationController().router, prefix="/evaluation_criteria", tags=["Evaluation Criteria"])
 
 __all__ = ["api_router"]
 __version__ = "0.1.0"

src/controllers/_evaluation_controller.py

@@ -0,0 +1,102 @@
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+from typing import List, Optional
+from uuid import UUID
+from datetime import datetime
+
+from src.config import logger
+from src.services import EvaluationService
+from src.models import EvaluationCriteriaType
+
+class EvaluationCriteria(BaseModel):
+    id: UUID
+    rfp_id: UUID
+    evaluation_criteria: str
+    evaluation_criteria_type: EvaluationCriteriaType
+    created_at: datetime
+    updated_at: datetime
+
+class EvaluationResponse(BaseModel):
+    status: str
+    data: List[EvaluationCriteria]
+
+class EvaluationRequest(BaseModel):
+    rfp_id: UUID
+    evaluation_criteria: str
+    evaluation_criteria_type: EvaluationCriteriaType
+
+class UpdateEvaluationRequest(BaseModel):
+    id: UUID
+    rfp_id: Optional[UUID] = None
+    evaluation_criteria: Optional[str] = None
+    evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
+
+class DeleteResponse(BaseModel):
+    status: str
+
+class EvaluationController:
+    def __init__(self):
+        self.evaluation_service = EvaluationService
+        self.router = APIRouter()
+        self.router.add_api_route(
+            "/get_evaluation_criteria",
+            self.get_criteria,
+            methods=["GET"],
+            response_model=EvaluationResponse
+        )
+        self.router.add_api_route(
+            "/create_evaluation_criteria",
+            self.create_criteria,
+            methods=["POST"],
+            response_model=EvaluationResponse
+        )
+        self.router.add_api_route(
+            "/update_evaluation_criteria",
+            self.update_criteria,
+            methods=["PUT"],
+            response_model=EvaluationResponse
+        )
+        self.router.add_api_route(
+            "/delete_evaluation_criteria",
+            self.delete_criteria,
+            methods=["DELETE"],
+            response_model=DeleteResponse
+        )
+
+    async def get_criteria(self, id: Optional[str] = Query(None), rfp_id: Optional[str] = Query(None), evaluation_criteria_type: Optional[EvaluationCriteriaType] = Query(None)):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.get_criteria(id=id, rfp_id=rfp_id, evaluation_criteria_type=evaluation_criteria_type)
+            return EvaluationResponse(status="success", data=[EvaluationCriteria(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error fetching evaluation criteria")
+
+    async def create_criteria(self, criteria: EvaluationRequest):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.create_criteria(criteria.model_dump(exclude_unset=True, mode="json"))
+            return EvaluationResponse(status="success", data=[EvaluationCriteria(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error creating evaluation criteria")
+
+    async def update_criteria(self, criteria: UpdateEvaluationRequest):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.update_criteria(criteria.model_dump(exclude_unset=True, mode="json"))
+            return EvaluationResponse(status="success", data=[EvaluationCriteria(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error updating evaluation criteria")
+
+    async def delete_criteria(self, id: Optional[str] = Query(None), rfp_id: Optional[str] = Query(None)):
+        try:
+            if not id and not rfp_id:
+                return DeleteResponse(status="Failed to delete evaluation criteria")
+            async with self.evaluation_service() as service:
+                await service.delete_criteria(id=id, rfp_id=rfp_id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error deleting evaluation criteria")

src/models/__init__.py

@@ -11,6 +11,7 @@ from ._proposal_ai_analysis import (
 from ._proposal_detailed_analysis import ProposalDetailAnalysis, OperationCriteria
 from ._proposal_query_models import QueryType, CreateOrUpdateType
 from ._letters import Letter, LetterType
+from ._evaluation import EvaluationCriteria, EvaluationCriteriaType
 
 __all__ = [
     "Base",
@@ -29,6 +30,8 @@ __all__ = [
     "GateCriteria",
     "Letter",
     "LetterType",
+    "EvaluationCriteria",
+    "EvaluationCriteriaType",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/models/_evaluation.py

@@ -0,0 +1,28 @@
+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 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)
+    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())

src/repositories/__init__.py

@@ -3,6 +3,7 @@ from ._rfp_repository import RFPRepository
 from ._proposal_repository import ProposalRepository
 from ._proposal_detailed_analysis_repository import ProposalDetailedAnalysisRepository
 from ._letter_repository import LetterRepository
+from ._evaluation_repository import EvaluationRepository
 
 __all__ = [
     "BaseRepository",
@@ -10,6 +11,7 @@ __all__ = [
     "ProposalRepository",
     "ProposalDetailedAnalysisRepository",
     "LetterRepository",
+    "EvaluationRepository",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/repositories/_evaluation_repository.py

@@ -0,0 +1,77 @@
+from ._base_repository import BaseRepository
+from src.models import EvaluationCriteria, EvaluationCriteriaType
+
+import uuid
+from sqlalchemy import select
+
+class EvaluationRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(EvaluationCriteria)
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_criteria(self, id: str = None, rfp_id: str = None, evaluation_criteria_type: EvaluationCriteriaType = None):
+        async with self.get_session() as session:
+            query = select(EvaluationCriteria)
+            if id:
+                query = query.where(EvaluationCriteria.id == id)
+            if rfp_id:
+                query = query.where(EvaluationCriteria.rfp_id == rfp_id)
+            if evaluation_criteria_type:
+                query = query.where(EvaluationCriteria.evaluation_criteria_type == evaluation_criteria_type)
+            output = await session.execute(query)
+            results = output.scalars().all()
+        return [{k: v for k, v in result.__dict__.items() if not k.startswith('_')} for result in results]
+    
+    async def create_criteria(self, evaluation_criteria: dict):
+        async with self.get_session() as session:
+            evaluation_criteria_type = evaluation_criteria["evaluation_criteria_type"]
+            rfp_id = evaluation_criteria["rfp_id"]
+            query = select(EvaluationCriteria).where(EvaluationCriteria.evaluation_criteria_type == evaluation_criteria_type, EvaluationCriteria.rfp_id == rfp_id)
+            output = await session.execute(query)
+            instances = output.scalars().all()
+            if instances:
+                return False
+            evaluation_criteria["id"] = str(uuid.uuid4())
+            instance = EvaluationCriteria(**evaluation_criteria)
+            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_criteria(self, evaluation_criteria: dict):
+        async with self.get_session() as session:
+            id = evaluation_criteria["id"]
+            query = select(EvaluationCriteria).where(EvaluationCriteria.id == id)
+            output = await session.execute(query)
+            instance = output.scalars().one()
+            rfp_id  = instance.rfp_id
+            if "evaluation_criteria_type" in evaluation_criteria:
+                query = select(EvaluationCriteria).where(EvaluationCriteria.evaluation_criteria_type == evaluation_criteria["evaluation_criteria_type"], EvaluationCriteria.rfp_id == rfp_id)
+                output = await session.execute(query)
+                instances = output.scalars().all()
+                if instances:
+                    return False
+            for k, v in evaluation_criteria.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_criteria(self, id: str = None, rfp_id: str = None):
+        async with self.get_session() as session:
+            query = select(EvaluationCriteria)
+            if id:
+                query = query.where(EvaluationCriteria.id == id)
+            if rfp_id:
+                query = query.where(EvaluationCriteria.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/services/__init__.py

@@ -7,6 +7,7 @@ from ._proposal_ai_analysis_service import (
 )
 from ._proposal_detailed_analysis_service import ProposalDetailedAnalysisService
 from ._letter_service import LetterService
+from ._evaluation_service import EvaluationService
 
 __all__ = [
     "RFPService",
@@ -16,6 +17,7 @@ __all__ = [
     "CreateOrUpdateType",
     "ProposalDetailedAnalysisService",
     "LetterService",
+    "EvaluationService",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/services/_evaluation_service.py

@@ -0,0 +1,28 @@
+from src.repositories import EvaluationRepository
+from src.models import EvaluationCriteriaType
+
+class EvaluationService:
+    def __init__(self):
+        self._evaluation_repository = EvaluationRepository
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_criteria(self, id: str = None, rfp_id: str = None, evaluation_criteria_type: EvaluationCriteriaType = None):
+        async with self._evaluation_repository() as repository:
+            return await repository.get_criteria(id=id, rfp_id=rfp_id, evaluation_criteria_type=evaluation_criteria_type)
+        
+    async def create_criteria(self, evaluation_criteria: dict):
+        async with self._evaluation_repository() as repository:
+            return await repository.create_criteria(evaluation_criteria)
+        
+    async def update_criteria(self, evaluation_criteria: dict):
+        async with self._evaluation_repository() as repository:
+            return await repository.update_criteria(evaluation_criteria)
+        
+    async def delete_criteria(self, id: str = None, rfp_id: str = None):
+        async with self._evaluation_repository() as repository:
+            return await repository.delete_criteria(id=id, rfp_id=rfp_id)