update database schema

alembic/versions/e825902b2e8a_alter_tables.py

@@ -0,0 +1,49 @@
+"""alter tables
+
+Revision ID: e825902b2e8a
+Revises: 11d43047d470
+Create Date: 2025-06-02 16:32:45.552509
+
+"""
+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 = 'e825902b2e8a'
+down_revision: Union[str, None] = '11d43047d470'
+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("name", sa.String(), nullable=True))
+
+    op.add_column("proposals", sa.Column("tep", sa.String(), nullable=True))
+
+    gate_criteria_enum = sa.Enum('PASS', 'FAIL', 'IN_REVIEW', name='gatecriteria')
+    gate_criteria_enum.create(op.get_bind())
+    op.add_column('proposals', sa.Column('gate_criteria', gate_criteria_enum, nullable=False, server_default='IN_REVIEW'))
+
+    op.create_table(
+        "letters",
+        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("letter", sa.Text(), nullable=True),
+        sa.Column("letter_type", sa.Enum("UO", "DEBRIEF", name="lettertype"), 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("letters")
+    sa.Enum(name='gatecriteria').drop(op.get_bind(), checkfirst=True)
+    op.drop_column("proposals", "gate_criteria")
+    op.drop_column("proposals", "tep")
+    op.drop_column("rfps", "name")

src/controllers/__init__.py

@@ -3,6 +3,7 @@ from ._rfp_controller import RFPController
 from ._proposal_controller import ProposalController
 from ._proposal_ai_analysis_controller import ProposalAIController
 from ._proposal_detailed_analysis_controller import ProposalDetailedController
+from ._letter_controller import LetterController
 
 api_router = APIRouter()
 
@@ -10,6 +11,7 @@ api_router.include_router(RFPController().router, prefix="/rfp", tags=["RFP"])
 api_router.include_router(ProposalController().router, prefix="/proposal", tags=["Proposal"])
 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"])
 
 __all__ = ["api_router"]
 __version__ = "0.1.0"

src/controllers/_letter_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 LetterService
+from src.models import LetterType
+
+class Letter(BaseModel):
+    id: UUID
+    proposal_id: UUID
+    letter: str
+    letter_type: LetterType
+    created_at: datetime
+    updated_at: datetime
+
+class Response(BaseModel):
+    status: str
+    data: List[Letter]
+
+class LetterRequest(BaseModel):
+    proposal_id: UUID
+    letter: str
+    letter_type: LetterType
+
+class UpdateLetterRequest(BaseModel):
+    id: UUID
+    proposal_id: Optional[UUID] = None
+    letter: Optional[str] = None
+    letter_type: Optional[LetterType] = None
+
+class DeleteResponse(BaseModel):
+    status: str
+
+class LetterController:
+    def __init__(self):
+        self.letter_service = LetterService
+        self.router = APIRouter()
+        self.router.add_api_route(
+            "/get_letters",
+            self.get_letters,
+            methods=["GET"],
+            response_model=Response
+        )
+        self.router.add_api_route(
+            "/create_letter",
+            self.create_letter,
+            methods=["POST"],
+            response_model=Response
+        )
+        self.router.add_api_route(
+            "/update_letter",
+            self.update_letter,
+            methods=["PUT"],
+            response_model=Response
+        )
+        self.router.add_api_route(
+            "/delete_letter",
+            self.delete_letter,
+            methods=["DELETE"],
+            response_model=DeleteResponse
+        )
+
+    async def get_letters(self, id: Optional[str] = Query(None), proposal_id: Optional[str] = Query(None), letter_type: Optional[LetterType] = Query(None)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.get_letters(id=id, proposal_id=proposal_id, letter_type=letter_type)
+            return Response(status="success", data=[Letter(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error fetching letters")
+        
+    async def create_letter(self, letter: LetterRequest):
+        try:
+            async with self.letter_service() as service:
+                result = await service.create_letter(letter.model_dump(exclude_unset=True, mode="json"))
+            return Response(status="success", data=[Letter(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error creating letter")
+        
+    async def update_letter(self, letter: UpdateLetterRequest):
+        try:
+            async with self.letter_service() as service:
+                result = await service.update_letter(letter.model_dump(exclude_unset=True, mode="json"))
+            return Response(status="success", data=[Letter(**r) for r in result])
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error updating letter")
+        
+    async def delete_letter(self, id: Optional[str] = Query(None), proposal_id: Optional[str] = Query(None)):
+        try:
+            if not id and not proposal_id:
+                return DeleteResponse(status="Failed to delete letter")
+            async with self.letter_service() as service:
+                result = await service.delete_letter(id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error deleting letter")

src/controllers/_proposal_controller.py

@@ -6,13 +6,15 @@ from datetime import datetime
 
 from src.config import logger
 from src.services import ProposalService
-from src.models import ProposalStatus
+from src.models import ProposalStatus, GateCriteria
 
 
 class Proposal(BaseModel):
     id: UUID
     rfp_id: UUID
     name: str
+    tep: str
+    gate_criteria: GateCriteria
     status: ProposalStatus
     created_at: datetime
     updated_at: datetime
@@ -21,6 +23,8 @@ class Proposal(BaseModel):
 class ProposalRequest(BaseModel):
     rfp_id: UUID
     name: str
+    tep: str
+    gate_criteria: GateCriteria
     status: ProposalStatus
 
 
@@ -28,6 +32,8 @@ class ProposalUpdateRequest(BaseModel):
     id: UUID
     rfp_id: Optional[UUID] = None
     name: Optional[str] = None
+    tep: Optional[str] = None
+    gate_criteria: Optional[GateCriteria] = None
     status: Optional[ProposalStatus] = None
 
 

src/controllers/_rfp_controller.py

@@ -10,6 +10,7 @@ from datetime import datetime
 class RFP(BaseModel):
     id: UUID
     rfp_number: str
+    name: str
     received_proposals: int
     evaluated_count: int
     awaiting_evaluation: int
@@ -22,6 +23,7 @@ class ResponseRFP(BaseModel):
 
 class RFPRequest(BaseModel):
     rfp_number: str
+    name: str
     received_proposals: int
     evaluated_count: int
     awaiting_evaluation: int
@@ -29,6 +31,7 @@ class RFPRequest(BaseModel):
 class RFPUpdateRequest(BaseModel):
     id: str
     rfp_number: Optional[str] = None
+    name: Optional[str] = None
     received_proposals: Optional[int] = None
     evaluated_count: Optional[int] = None
     awaiting_evaluation: Optional[int] = None

src/models/__init__.py

@@ -1,5 +1,5 @@
 from ._base import Base
-from ._proposal import Proposal, ProposalStatus
+from ._proposal import Proposal, ProposalStatus, GateCriteria
 from ._rfp import RFP
 from ._proposal_ai_analysis import (
     ProposalAIAnalysis,
@@ -10,6 +10,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
 
 __all__ = [
     "Base",
@@ -25,6 +26,9 @@ __all__ = [
     "QueryType",
     "CreateOrUpdateType",
     "OperationCriteria",
+    "GateCriteria",
+    "Letter",
+    "LetterType",
 ]
 __version__ = "0.1.0"
 __author__ = "Aryan Jain"

src/models/_letters.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 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)
+    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())

src/models/_proposal.py

@@ -19,6 +19,10 @@ class ProposalStatus(PyEnum):
     EVALUATED = "EVALUATED"
     IN_REVIEW = "IN_REVIEW"
 
+class GateCriteria(PyEnum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+    IN_REVIEW = "IN_REVIEW"
 
 class Proposal(Base):
     __tablename__ = "proposals"
@@ -28,6 +32,8 @@ class Proposal(Base):
         UUID(as_uuid=True), ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False
     )
     name = Column(String, nullable=False)
+    tep = Column(String, nullable=False)
+    gate_criteria = Column(Enum(GateCriteria), nullable=False)
     status = Column(Enum(ProposalStatus), nullable=False)
     created_at = Column(DateTime, nullable=False, default=func.now())
     updated_at = Column(

src/models/_rfp.py

@@ -19,6 +19,7 @@ class RFP(Base):
 
     id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
     rfp_number = Column(String, nullable=False)
+    name = Column(String, nullable=False)
     received_proposals = Column(Integer, nullable=False)
     evaluated_count = Column(Integer, nullable=False)
     awaiting_evaluation = Column(Integer, nullable=False)

src/repositories/__init__.py

@@ -2,7 +2,14 @@ from ._base_repository import BaseRepository
 from ._rfp_repository import RFPRepository
 from ._proposal_repository import ProposalRepository
 from ._proposal_detailed_analysis_repository import ProposalDetailedAnalysisRepository
+from ._letter_repository import LetterRepository
 
-__all__ = ["BaseRepository", "RFPRepository", "ProposalRepository", "ProposalDetailedAnalysisRepository"]
+__all__ = [
+    "BaseRepository",
+    "RFPRepository",
+    "ProposalRepository",
+    "ProposalDetailedAnalysisRepository",
+    "LetterRepository",
+]
 __version__ = "0.1.0"
-__author__ = "Aryan Jain"
+__author__ = "Aryan Jain"

src/repositories/_letter_repository.py

@@ -0,0 +1,79 @@
+import uuid
+from sqlalchemy import select
+
+from src.models import Letter, LetterType
+
+from ._base_repository import BaseRepository
+
+class LetterRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(Letter)
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_letters(self, id: str = None, proposal_id: str = None, letter_type: LetterType = None):
+        async with self.get_session() as session:
+            query = select(Letter)
+            if id:
+                query = query.where(Letter.id == id)
+            if proposal_id:
+                query = query.where(Letter.proposal_id == proposal_id)
+            if letter_type:
+                query = query.where(Letter.letter_type == letter_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_letter(self, letter: dict):
+        async with self.get_session() as session:
+            letter_type = letter["letter_type"]
+            proposal_id = letter["proposal_id"]
+            query = select(Letter).where(Letter.proposal_id == proposal_id, Letter.letter_type == letter_type)
+            output = await session.execute(query)
+            instances = output.scalars().all()
+            if instances:
+                return False
+            id = str(uuid.uuid4())
+            letter["id"] = id
+            instance = Letter(**letter)
+            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_letter(self, letter: dict):
+        async with self.get_session() as session:
+            id = letter["id"]
+            query = select(Letter).where(Letter.id == id)
+            output = await session.execute(query)
+            instance = output.scalars().one()
+            proposal_id = instance.proposal_id
+            if "letter_type" in letter:
+                query = select(Letter).where(Letter.proposal_id == proposal_id, Letter.letter_type == letter["letter_type"])
+                output = await session.execute(query)
+                instances = output.scalars().all()
+                if instances:
+                    return False
+            for key, value in letter.items():
+                setattr(instance, key, value)
+            await session.commit()
+            await session.refresh(instance)
+            return [{k: v for k, v in instance.__dict__.items() if not k.startswith('_')}]
+    
+    async def delete_letter(self, id: str = None, proposal_id: str = None):
+        async with self.get_session() as session:
+            query = select(Letter)
+            if id:
+                query = query.where(Letter.id == id)
+            if proposal_id:
+                query = query.where(Letter.proposal_id == proposal_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

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

src/services/_letter_service.py

@@ -0,0 +1,28 @@
+from src.repositories import LetterRepository
+from src.models import Letter, LetterType
+
+class LetterService:
+    def __init__(self):
+        self.letter_repository = LetterRepository
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def get_letters(self, id: str = None, proposal_id: str = None, letter_type: LetterType = None):
+        async with self.letter_repository() as repository:
+            return await repository.get_letters(id=id, proposal_id=proposal_id, letter_type=letter_type)
+        
+    async def create_letter(self, letter: dict):
+        async with self.letter_repository() as repository:
+            return await repository.create_letter(letter)
+        
+    async def update_letter(self, letter: dict):
+        async with self.letter_repository() as repository:
+            return await repository.update_letter(letter)
+        
+    async def delete_letter(self, id: str = None, proposal_id: str = None):
+        async with self.letter_repository() as repository:
+            return await repository.delete_letter(id)