update letters and evaluation apis

src/controllers/__init__.py

@@ -23,12 +23,10 @@ api_router.include_router(
     tags=["Proposal Detailed Analysis"],
 )
 api_router.include_router(
-    LetterController().router, prefix="/letters", tags=["Letters"]
+    LetterController().router
 )
 api_router.include_router(
-    EvaluationController().router,
-    prefix="/evaluation_criteria",
-    tags=["Evaluation Criteria"],
+    EvaluationController().router
 )
 
 __all__ = ["api_router"]

src/controllers/_evaluation_controller.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, Path
 from pydantic import BaseModel
 from typing import List, Optional
 from uuid import UUID
@@ -30,7 +30,6 @@ class EvaluationRequest(BaseModel):
 
 
 class UpdateEvaluationRequest(BaseModel):
-    id: UUID
     rfp_id: Optional[UUID] = None
     evaluation_criteria: Optional[str] = None
     evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
@@ -49,39 +48,110 @@ class EvaluationController:
             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(
+            "/rpfs/{rfp_id}/evaluation_criteria",
+            self.get_criteria_by_rfp_id,
+            methods=["GET"],
+            response_model=EvaluationResponse,
+            tags=["Evaluation Criteria by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rpfs/{rfp_id}/evaluation_criteria/{id}",
+            self.get_criteria_by_proposal_and_rfp_id,
+            methods=["GET"],
+            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",
+            "/evaluation_criteria/{id}",
             self.update_criteria,
             methods=["PUT"],
             response_model=EvaluationResponse,
+            tags=["Evaluation Criteria by ID"],
         )
         self.router.add_api_route(
-            "/evaluation_criteria",
+            "/evaluation_criteria/{id}",
             self.delete_criteria,
             methods=["DELETE"],
             response_model=DeleteResponse,
+            tags=["Evaluation Criteria by ID"],
+        )
+        self.router.add_api_route(
+            "/rpfs/{rfp_id}/evaluation_criteria",
+            self.delete_criteria_by_rfp_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Evaluation Criteria by RFP ID"],
+        )
+        self.router.add_api_route(
+            "/rpfs/{rfp_id}/evaluation_criteria/{id}",
+            self.delete_criteria_by_proposal_and_rfp_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Evaluation Criteria by Proposal and RFP ID"],
         )
 
     async def get_criteria(
-        self,
-        id: Optional[str] = Query(None),
-        rfp_id: Optional[str] = Query(None),
-        evaluation_criteria_type: Optional[EvaluationCriteriaType] = Query(None),
+        self
     ):
         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,
-                )
+                result = await service.get_criteria()
+            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 get_criteria_by_id(self, id: str = Path(...)):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.get_criteria(id=id)
+            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 get_criteria_by_rfp_id(self, rfp_id: str = Path(...)):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.get_criteria(rfp_id=rfp_id)
+            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 get_criteria_by_proposal_and_rfp_id(self, rfp_id: str = Path(...), id: str = Path(...)):
+        try:
+            async with self.evaluation_service() as service:
+                result = await service.get_criteria(rfp_id=rfp_id, id=id)
             return EvaluationResponse(
                 status="success", data=[EvaluationCriteria(**r) for r in result]
             )
@@ -106,11 +176,11 @@ class EvaluationController:
                 status_code=500, detail="Error creating evaluation criteria"
             )
 
-    async def update_criteria(self, criteria: UpdateEvaluationRequest):
+    async def update_criteria(self, criteria: UpdateEvaluationRequest, id: str = Path(...)):
         try:
             async with self.evaluation_service() as service:
                 result = await service.update_criteria(
-                    criteria.model_dump(exclude_unset=True, mode="json")
+                    id=id, evaluation_criteria=criteria.model_dump(exclude_unset=True, mode="json")
                 )
             return EvaluationResponse(
                 status="success", data=[EvaluationCriteria(**r) for r in result]
@@ -122,13 +192,33 @@ class EvaluationController:
             )
 
     async def delete_criteria(
-        self, id: Optional[str] = Query(None), rfp_id: Optional[str] = Query(None)
+        self, id: str = Path(...)
     ):
         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)
+                await service.delete_criteria(id=id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(
+                status_code=500, detail="Error deleting evaluation criteria"
+            )
+        
+    async def delete_criteria_by_rfp_id(self, rfp_id: str = Path(...)):
+        try:
+            async with self.evaluation_service() as service:
+                await service.delete_criteria(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"
+            )
+        
+    async def delete_criteria_by_proposal_and_rfp_id(self, rfp_id: str = Path(...), id: str = Path(...)):
+        try:
+            async with self.evaluation_service() as service:
+                await service.delete_criteria(rfp_id=rfp_id, id=id)
             return DeleteResponse(status="success")
         except Exception as e:
             logger.error(e)

src/controllers/_letter_controller.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Query, Path
 from pydantic import BaseModel
 from typing import List, Optional
 from uuid import UUID
@@ -30,7 +30,6 @@ class LetterRequest(BaseModel):
 
 
 class UpdateLetterRequest(BaseModel):
-    id: UUID
     proposal_id: Optional[UUID] = None
     letter: Optional[str] = None
     letter_type: Optional[LetterType] = None
@@ -45,36 +44,94 @@ class LetterController:
         self.letter_service = LetterService
         self.router = APIRouter()
         self.router.add_api_route(
-            "/letter", self.get_letters, methods=["GET"], response_model=Response
+            "/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(
-            "/letter", self.create_letter, methods=["POST"], response_model=Response
+            "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(
-            "/letter", self.update_letter, methods=["PUT"], response_model=Response
+            "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(
-            "/letter",
+            "/letters", self.create_letter, methods=["POST"], response_model=Response, tags=["Letters"]
+        )
+        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.delete_letter,
             methods=["DELETE"],
             response_model=DeleteResponse,
+            tags=["Letters by ID"],
+        )
+        self.router.add_api_route(
+            "/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}",
+            self.delete_letters_by_proposal_and_id,
+            methods=["DELETE"],
+            response_model=DeleteResponse,
+            tags=["Letters by Proposal and ID"],
         )
 
     async def get_letters(
-        self,
-        id: Optional[str] = Query(None),
-        proposal_id: Optional[str] = Query(None),
-        letter_type: Optional[LetterType] = Query(None),
+        self
     ):
         try:
             async with self.letter_service() as service:
-                result = await service.get_letters(
-                    id=id, proposal_id=proposal_id, letter_type=letter_type
-                )
+                result = await service.get_letters()
             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 get_letters_by_id(self, id: str = Path(...)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.get_letters(id=id)
+            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 letter")
+        
+    async def get_letters_by_proposal_id(self, proposal_id: str = Path(...)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.get_letters(proposal_id=proposal_id)
+            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 letter")
+        
+    async def get_letters_by_proposal_and_id(self, proposal_id: str = Path(...), id: str = Path(...)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.get_letters(proposal_id=proposal_id, id=id)
+            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 letter")
 
     async def create_letter(self, letter: LetterRequest):
         try:
@@ -87,11 +144,11 @@ class LetterController:
             logger.error(e)
             raise HTTPException(status_code=500, detail="Error creating letter")
 
-    async def update_letter(self, letter: UpdateLetterRequest):
+    async def update_letter(self, letter: UpdateLetterRequest, id: str = Path(...)):
         try:
             async with self.letter_service() as service:
                 result = await service.update_letter(
-                    letter.model_dump(exclude_unset=True, mode="json")
+                    id=id, letter=letter.model_dump(exclude_unset=True, mode="json")
                 )
             return Response(status="success", data=[Letter(**r) for r in result])
         except Exception as e:
@@ -99,13 +156,29 @@ class LetterController:
             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)
+        self, id: str = Path(...)
     ):
         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)
+                result = await service.delete_letter(id=id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail="Error deleting letter")
+        
+    async def delete_letters_by_proposal_id(self, proposal_id: str = Path(...)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.delete_letter(proposal_id=proposal_id)
+            return DeleteResponse(status="success")
+        except Exception as e:
+            logger.error(e)
+            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(...)):
+        try:
+            async with self.letter_service() as service:
+                result = await service.delete_letter(proposal_id=proposal_id, id=id)
             return DeleteResponse(status="success")
         except Exception as e:
             logger.error(e)

src/repositories/_evaluation_repository.py

@@ -60,9 +60,8 @@ class EvaluationRepository(BaseRepository):
                 {k: v for k, v in instance.__dict__.items() if not k.startswith("_")}
             ]
 
-    async def update_criteria(self, evaluation_criteria: dict):
+    async def update_criteria(self, id: str, 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()

src/repositories/_letter_repository.py

@@ -55,9 +55,8 @@ class LetterRepository(BaseRepository):
                 {k: v for k, v in instance.__dict__.items() if not k.startswith("_")}
             ]
 
-    async def update_letter(self, letter: dict):
+    async def update_letter(self, id: str, 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()

src/services/_evaluation_service.py

@@ -27,9 +27,9 @@ class EvaluationService:
         async with self._evaluation_repository() as repository:
             return await repository.create_criteria(evaluation_criteria)
 
-    async def update_criteria(self, evaluation_criteria: dict):
+    async def update_criteria(self, id: str, evaluation_criteria: dict):
         async with self._evaluation_repository() as repository:
-            return await repository.update_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/_letter_service.py

@@ -24,9 +24,9 @@ class LetterService:
         async with self.letter_repository() as repository:
             return await repository.create_letter(letter)
 
-    async def update_letter(self, letter: dict):
+    async def update_letter(self, id: str, letter: dict):
         async with self.letter_repository() as repository:
-            return await repository.update_letter(letter)
+            return await repository.update_letter(id=id, letter=letter)
 
     async def delete_letter(self, id: str = None, proposal_id: str = None):
         async with self.letter_repository() as repository: