update APIs

src/controllers/__init__.py

@@ -9,25 +9,11 @@ from ._evaluation_controller import EvaluationController
 api_router = APIRouter()
 
 api_router.include_router(RFPController().router)
-api_router.include_router(
-    ProposalController().router
-)
-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
-)
-api_router.include_router(
-    EvaluationController().router
-)
+api_router.include_router(ProposalController().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)
 
 __all__ = ["api_router"]
 __version__ = "0.1.0"

src/controllers/_evaluation_controller.py

@@ -29,12 +29,22 @@ class EvaluationRequest(BaseModel):
     evaluation_criteria_type: EvaluationCriteriaType
 
 
+class CreateEvaluationRequest(BaseModel):
+    evaluation_criteria: str
+    evaluation_criteria_type: EvaluationCriteriaType
+
+
 class UpdateEvaluationRequest(BaseModel):
     rfp_id: Optional[UUID] = None
     evaluation_criteria: Optional[str] = None
     evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
 
 
+class UpdateEvaluationCriteriaByRFPRequest(BaseModel):
+    evaluation_criteria: Optional[str] = None
+    evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
+
+
 class DeleteResponse(BaseModel):
     status: str
 
@@ -58,14 +68,14 @@ class EvaluationController:
             tags=["Evaluation Criteria by ID"],
         )
         self.router.add_api_route(
-            "/rpfs/{rfp_id}/evaluation_criteria",
+            "/rfps/{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}",
+            "/rfps/{rfp_id}/evaluation_criteria/{id}",
             self.get_criteria_by_proposal_and_rfp_id,
             methods=["GET"],
             response_model=EvaluationResponse,
@@ -78,6 +88,13 @@ class EvaluationController:
             response_model=EvaluationResponse,
             tags=["Evaluation Criteria"],
         )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/evaluation_criteria",
+            self.create_criteria_by_rfp_id,
+            methods=["POST"],
+            response_model=EvaluationResponse,
+            tags=["Evaluation Criteria by RFP ID"],
+        )
         self.router.add_api_route(
             "/evaluation_criteria/{id}",
             self.update_criteria,
@@ -85,6 +102,13 @@ class EvaluationController:
             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,
+            methods=["PUT"],
+            response_model=EvaluationResponse,
+            tags=["Evaluation Criteria by Proposal and RFP ID"],
+        )
         self.router.add_api_route(
             "/evaluation_criteria/{id}",
             self.delete_criteria,
@@ -93,23 +117,21 @@ class EvaluationController:
             tags=["Evaluation Criteria by ID"],
         )
         self.router.add_api_route(
-            "/rpfs/{rfp_id}/evaluation_criteria",
+            "/rfps/{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}",
+            "/rfps/{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
-    ):
+    async def get_criteria(self):
         try:
             async with self.evaluation_service() as service:
                 result = await service.get_criteria()
@@ -121,7 +143,7 @@ class EvaluationController:
             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:
@@ -134,11 +156,17 @@ class EvaluationController:
             raise HTTPException(
                 status_code=500, detail="Error fetching evaluation criteria"
             )
-        
-    async def get_criteria_by_rfp_id(self, rfp_id: str = Path(...)):
+
+    async def get_criteria_by_rfp_id(
+        self,
+        rfp_id: str = Path(...),
+        criteria_type: Optional[EvaluationCriteriaType] = Query(None),
+    ):
         try:
             async with self.evaluation_service() as service:
-                result = await service.get_criteria(rfp_id=rfp_id)
+                result = await service.get_criteria(
+                    rfp_id=rfp_id, evaluation_criteria_type=criteria_type
+                )
             return EvaluationResponse(
                 status="success", data=[EvaluationCriteria(**r) for r in result]
             )
@@ -147,8 +175,10 @@ class EvaluationController:
             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(...)):
+
+    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)
@@ -176,11 +206,33 @@ class EvaluationController:
                 status_code=500, detail="Error creating evaluation criteria"
             )
 
-    async def update_criteria(self, criteria: UpdateEvaluationRequest, id: str = Path(...)):
+    async def create_criteria_by_rfp_id(
+        self, criteria: CreateEvaluationRequest, rfp_id: str = Path(...)
+    ):
+        try:
+            async with self.evaluation_service() as service:
+                data = criteria.model_dump(exclude_unset=True, mode="json")
+                data["rfp_id"] = rfp_id
+                result = await service.create_criteria(evaluation_criteria=data)
+            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, id: str = Path(...)
+    ):
         try:
             async with self.evaluation_service() as service:
                 result = await service.update_criteria(
-                    id=id, evaluation_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]
@@ -191,9 +243,27 @@ class EvaluationController:
                 status_code=500, detail="Error updating evaluation criteria"
             )
 
-    async def delete_criteria(
-        self, id: str = Path(...)
+    async def update_criteria_by_proposal_and_rfp_id(
+        self,
+        criteria: UpdateEvaluationCriteriaByRFPRequest,
+        rfp_id: str = Path(...),
+        id: str = Path(...),
     ):
+        try:
+            async with self.evaluation_service() as service:
+                data = criteria.model_dump(exclude_unset=True, mode="json")
+                data["rfp_id"] = rfp_id
+                result = await service.update_criteria(id=id, evaluation_criteria=data)
+            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: str = Path(...)):
         try:
             async with self.evaluation_service() as service:
                 await service.delete_criteria(id=id)
@@ -203,7 +273,7 @@ class EvaluationController:
             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:
@@ -214,8 +284,10 @@ class EvaluationController:
             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(...)):
+
+    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)

src/controllers/_letter_controller.py

@@ -29,12 +29,22 @@ class LetterRequest(BaseModel):
     letter_type: LetterType
 
 
+class CreateLetterRequest(BaseModel):
+    letter: str
+    letter_type: LetterType
+
+
 class UpdateLetterRequest(BaseModel):
     proposal_id: Optional[UUID] = None
     letter: Optional[str] = None
     letter_type: Optional[LetterType] = None
 
 
+class UpdateLetterRequestByProposalAndId(BaseModel):
+    letter: Optional[str] = None
+    letter_type: Optional[LetterType] = None
+
+
 class DeleteResponse(BaseModel):
     status: str
 
@@ -44,7 +54,11 @@ class LetterController:
         self.letter_service = LetterService
         self.router = APIRouter()
         self.router.add_api_route(
-            "/letters", self.get_letters, methods=["GET"], response_model=Response, tags=["Letters"]
+            "/letters",
+            self.get_letters,
+            methods=["GET"],
+            response_model=Response,
+            tags=["Letters"],
         )
         self.router.add_api_route(
             "/letters/{id}",
@@ -54,24 +68,46 @@ class LetterController:
             tags=["Letters by ID"],
         )
         self.router.add_api_route(
-            "proposals/{proposal_id}/letters",
+            "/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}",
+            "/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"]
+            "/letters",
+            self.create_letter,
+            methods=["POST"],
+            response_model=Response,
+            tags=["Letters"],
+        )
+        self.router.add_api_route(
+            "/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"]
+            "/letters/{id}",
+            self.update_letter,
+            methods=["PUT"],
+            response_model=Response,
+            tags=["Letters by ID"],
+        )
+        self.router.add_api_route(
+            "/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}",
@@ -95,9 +131,7 @@ class LetterController:
             tags=["Letters by Proposal and ID"],
         )
 
-    async def get_letters(
-        self
-    ):
+    async def get_letters(self):
         try:
             async with self.letter_service() as service:
                 result = await service.get_letters()
@@ -105,7 +139,7 @@ class LetterController:
         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:
@@ -114,17 +148,23 @@ class LetterController:
         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(...)):
+
+    async def get_letters_by_proposal_id(
+        self, proposal_id: str = Path(...), letter_type: LetterType = Query(None)
+    ):
         try:
             async with self.letter_service() as service:
-                result = await service.get_letters(proposal_id=proposal_id)
+                result = await service.get_letters(
+                    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 letter")
-        
-    async def get_letters_by_proposal_and_id(self, proposal_id: str = Path(...), id: str = Path(...)):
+
+    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)
@@ -144,6 +184,19 @@ class LetterController:
             logger.error(e)
             raise HTTPException(status_code=500, detail="Error creating letter")
 
+    async def create_letters_by_proposal_id(
+        self, letter: CreateLetterRequest, proposal_id: str = Path(...)
+    ):
+        try:
+            async with self.letter_service() as service:
+                data = letter.model_dump(exclude_unset=True, mode="json")
+                data["proposal_id"] = proposal_id
+                result = await service.create_letter(letter=data)
+            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, id: str = Path(...)):
         try:
             async with self.letter_service() as service:
@@ -155,9 +208,23 @@ class LetterController:
             logger.error(e)
             raise HTTPException(status_code=500, detail="Error updating letter")
 
-    async def delete_letter(
-        self, id: str = Path(...)
+    async def update_letters_by_proposal_and_id(
+        self,
+        letter: UpdateLetterRequestByProposalAndId,
+        proposal_id: str = Path(...),
+        id: str = Path(...),
     ):
+        try:
+            async with self.letter_service() as service:
+                data = letter.model_dump(exclude_unset=True, mode="json")
+                data["proposal_id"] = proposal_id
+                result = await service.update_letter(id=id, letter=data)
+            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: str = Path(...)):
         try:
             async with self.letter_service() as service:
                 result = await service.delete_letter(id=id)
@@ -165,7 +232,7 @@ class LetterController:
         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:
@@ -174,8 +241,10 @@ class LetterController:
         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(...)):
+
+    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)

src/controllers/_proposal_ai_analysis_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
@@ -119,7 +119,6 @@ class ProposalStrengthRequest(BaseModel):
 
 
 class UpdateProposalStrengthRequest(BaseModel):
-    id: UUID
     proposal_id: Optional[UUID] = None
     strength_point: Optional[str] = None
 
@@ -130,7 +129,6 @@ class ProposalWeaknessRequest(BaseModel):
 
 
 class UpdateProposalWeaknessRequest(BaseModel):
-    id: UUID
     proposal_id: Optional[UUID] = None
     weakness_point: Optional[str] = None
 
@@ -141,7 +139,6 @@ class ProposalRejectionReasonRequest(BaseModel):
 
 
 class UpdateProposalRejectionReasonRequest(BaseModel):
-    id: UUID
     proposal_id: Optional[UUID] = None
     reason: Optional[str] = None
 
@@ -152,7 +149,6 @@ class ProposalImprovementRequest(BaseModel):
 
 
 class UpdateProposalImprovementRequest(BaseModel):
-    id: UUID
     proposal_id: Optional[UUID] = None
     improvement_point: Optional[str] = None
 
@@ -161,35 +157,33 @@ class CreateAiAnalysisRequest(BaseModel):
     proposal_id: UUID
     ai_score: float
 
+class CreateAIAnalysisRequestByProposalId(BaseModel):
+    ai_score: float
 
 class UpdateAiAnalysisRequest(BaseModel):
-    id: Optional[UUID] = None
     proposal_id: Optional[UUID] = None
     ai_score: Optional[float] = None
 
+class UpdateAIAnalysisRequestByProposalId(BaseModel):
+    ai_score: Optional[float] = None
 
 class CreateAllProposalStrengthsRequest(BaseModel):
-    proposal_id: UUID
     strength_point: List[str]
 
 
 class CreateAllProposalWeaknessRequest(BaseModel):
-    proposal_id: UUID
     weakness_point: List[str]
 
 
 class CreateAllProposalRejectionReasonsRequest(BaseModel):
-    proposal_id: UUID
     reason: List[str]
 
 
 class CreateAllProposalImprovementsRequest(BaseModel):
-    proposal_id: UUID
     improvement_point: List[str]
 
 
 class CreateAllProposalAnalysisRequest(BaseModel):
-    proposal_id: UUID
     ai_score: float
     strengths: Optional[List[str]] = None
     weaknesses: Optional[List[str]] = None
@@ -198,7 +192,6 @@ class CreateAllProposalAnalysisRequest(BaseModel):
 
 
 class UpdateAllProposalAnalysisRequest(BaseModel):
-    proposal_id: UUID
     ai_score: Optional[float] = None
     strengths: Optional[List[str]] = None
     weaknesses: Optional[List[str]] = None
@@ -218,6 +211,27 @@ class ProposalAIController:
             tags=["Proposal Strengths"],
             response_model=ProposalStrengthResponse,
         )
+        self.router.add_api_route(
+            "/proposal_strengths/{id}",
+            self.get_proposal_strengths_by_id,
+            methods=["GET"],
+            tags=["Proposal Strengths by ID"],
+            response_model=ProposalStrengthResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_strengths",
+            self.get_proposal_strengths_by_proposal_id,
+            methods=["GET"],
+            tags=["Proposal Strengths by Proposal ID"],
+            response_model=ProposalAllStrengthsResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_strengths/{id}",
+            self.get_proposal_strengths_by_proposal_and_id,
+            methods=["GET"],
+            tags=["Proposal Strengths by Proposal and ID"],
+            response_model=ProposalStrengthResponse,
+        )
         self.router.add_api_route(
             "/proposal_strengths",
             self.create_proposal_strengths,
@@ -226,31 +240,45 @@ class ProposalAIController:
             response_model=ProposalStrengthResponse,
         )
         self.router.add_api_route(
-            "/proposal_strengths/all",
+            "/proposals/{proposal_id}/proposal_strengths",
             self.create_all_proposal_strengths,
             methods=["POST"],
-            tags=["Proposal All Strengths"],
-            response_model=ProposalStrengthResponse,
+            tags=["Proposal Strengths by Proposal ID"],
+            response_model=ProposalAllStrengthsResponse,
         )
         self.router.add_api_route(
-            "/proposal_strengths",
+            "/proposal_strengths/{id}",
             self.update_proposal_strengths,
             methods=["PUT"],
-            tags=["Proposal Strengths"],
+            tags=["Proposal Strengths by ID"],
             response_model=ProposalStrengthResponse,
         )
         self.router.add_api_route(
-            "/proposal_strengths/all",
+            "/proposals/{proposal_id}/proposal_strengths",
             self.update_all_proposal_strengths,
             methods=["PUT"],
-            tags=["Proposal All Strengths"],
-            response_model=ProposalStrengthResponse,
+            tags=["Proposal Strengths by Proposal ID"],
+            response_model=ProposalAllStrengthsResponse,
         )
         self.router.add_api_route(
-            "/proposal_strengths",
+            "/proposal_strengths/{id}",
             self.delete_proposal_strength,
             methods=["DELETE"],
-            tags=["Proposal Strengths"],
+            tags=["Proposal Strengths by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_strengths",
+            self.delete_all_proposal_strengths,
+            methods=["DELETE"],
+            tags=["Proposal Strengths by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_strengths/{id}",
+            self.delete_proposal_strengths_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal Strengths by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
@@ -261,6 +289,27 @@ class ProposalAIController:
             tags=["Proposal Weakness"],
             response_model=ProposalWeaknessResponse,
         )
+        self.router.add_api_route(
+            "/proposal_weakness/{id}",
+            self.get_proposal_weakness_by_id,
+            methods=["GET"],
+            tags=["Proposal Weakness by ID"],
+            response_model=ProposalWeaknessResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_weakness",
+            self.get_proposal_weakness_by_proposal_id,
+            methods=["GET"],
+            tags=["Proposal Weakness by Proposal ID"],
+            response_model=ProposalAllWeaknessesResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_weakness/{id}",
+            self.get_proposal_weakness_by_proposal_and_id,
+            methods=["GET"],
+            tags=["Proposal Weakness by Proposal and ID"],
+            response_model=ProposalWeaknessResponse,
+        )
         self.router.add_api_route(
             "/proposal_weakness",
             self.create_proposal_weakness,
@@ -269,31 +318,45 @@ class ProposalAIController:
             response_model=ProposalWeaknessResponse,
         )
         self.router.add_api_route(
-            "/proposal_weakness/all",
+            "/proposals/{proposal_id}/proposal_weakness",
             self.create_all_proposal_weakness,
             methods=["POST"],
-            tags=["Proposal All Weakness"],
-            response_model=ProposalWeaknessResponse,
+            tags=["Proposal Weakness by Proposal ID"],
+            response_model=ProposalAllWeaknessesResponse,
         )
         self.router.add_api_route(
-            "/proposal_weakness",
+            "/proposal_weakness/{id}",
             self.update_proposal_weakness,
             methods=["PUT"],
-            tags=["Proposal Weakness"],
+            tags=["Proposal Weakness by ID"],
             response_model=ProposalWeaknessResponse,
         )
         self.router.add_api_route(
-            "/proposal_weakness/all",
+            "/proposals/{proposal_id}/proposal_weakness",
             self.update_all_proposal_weakness,
             methods=["PUT"],
-            tags=["Proposal All Weakness"],
-            response_model=ProposalWeaknessResponse,
+            tags=["Proposal Weakness by Proposal ID"],
+            response_model=ProposalAllWeaknessesResponse,
         )
         self.router.add_api_route(
-            "/proposal_weakness",
+            "/proposal_weakness/{id}",
             self.delete_proposal_weakness,
             methods=["DELETE"],
-            tags=["Proposal Weakness"],
+            tags=["Proposal Weakness by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_weakness",
+            self.delete_all_proposal_weakness,
+            methods=["DELETE"],
+            tags=["Proposal Weakness by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_weakness/{id}",
+            self.delete_proposal_weakness_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal Weakness by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
@@ -304,6 +367,27 @@ class ProposalAIController:
             tags=["Proposal Rejections"],
             response_model=ProposalRejectionReasonResponse,
         )
+        self.router.add_api_route(
+            "/proposal_rejections/{id}",
+            self.get_proposal_rejections_by_id,
+            methods=["GET"],
+            tags=["Proposal Rejections by ID"],
+            response_model=ProposalRejectionReasonResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_rejections",
+            self.get_proposal_rejections_by_proposal_id,
+            methods=["GET"],
+            tags=["Proposal Rejections by Proposal ID"],
+            response_model=ProposalAllRejectionReasonsResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_rejections/{id}",
+            self.get_proposal_rejections_by_proposal_and_id,
+            methods=["GET"],
+            tags=["Proposal Rejections by Proposal and ID"],
+            response_model=ProposalRejectionReasonResponse,
+        )
         self.router.add_api_route(
             "/proposal_rejections",
             self.create_proposal_rejections,
@@ -312,31 +396,45 @@ class ProposalAIController:
             response_model=ProposalRejectionReasonResponse,
         )
         self.router.add_api_route(
-            "/proposal_rejections/all",
+            "/proposals/{proposal_id}/proposal_rejections",
             self.create_all_proposal_rejections,
             methods=["POST"],
-            tags=["Proposal All Rejections"],
-            response_model=ProposalRejectionReasonResponse,
+            tags=["Proposal Rejections by Proposal ID"],
+            response_model=ProposalAllRejectionReasonsResponse,
         )
         self.router.add_api_route(
-            "/proposal_rejections",
+            "/proposal_rejections/{id}",
             self.update_proposal_rejections,
             methods=["PUT"],
-            tags=["Proposal Rejections"],
+            tags=["Proposal Rejections by ID"],
             response_model=ProposalRejectionReasonResponse,
         )
         self.router.add_api_route(
-            "/proposal_rejections/all",
+            "/proposals/{proposal_id}/proposal_rejections",
             self.update_all_proposal_rejections,
             methods=["PUT"],
-            tags=["Proposal All Rejections"],
-            response_model=ProposalRejectionReasonResponse,
+            tags=["Proposal Rejections by Proposal ID"],
+            response_model=ProposalAllRejectionReasonsResponse,
         )
         self.router.add_api_route(
-            "/proposal_rejections",
+            "/proposal_rejections/{id}",
             self.delete_proposal_rejections,
             methods=["DELETE"],
-            tags=["Proposal Rejections"],
+            tags=["Proposal Rejections by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_rejections",
+            self.delete_all_proposal_rejections,
+            methods=["DELETE"],
+            tags=["Proposal Rejections by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_rejections/{id}",
+            self.delete_proposal_rejections_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal Rejections by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
@@ -347,6 +445,27 @@ class ProposalAIController:
             tags=["Proposal Improvements"],
             response_model=ProposalImprovementResponse,
         )
+        self.router.add_api_route(
+            "/proposal_improvements/{id}",
+            self.get_proposal_improvements_by_id,
+            methods=["GET"],
+            tags=["Proposal Improvements by ID"],
+            response_model=ProposalImprovementResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_improvements",
+            self.get_proposal_improvements_by_proposal_id,
+            methods=["GET"],
+            tags=["Proposal Improvements by Proposal ID"],
+            response_model=ProposalAllImprovementsResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_improvements/{id}",
+            self.get_proposal_improvements_by_proposal_and_id,
+            methods=["GET"],
+            tags=["Proposal Improvements by Proposal and ID"],
+            response_model=ProposalImprovementResponse,
+        )
         self.router.add_api_route(
             "/proposal_improvements",
             self.create_proposal_improvements,
@@ -355,31 +474,45 @@ class ProposalAIController:
             response_model=ProposalImprovementResponse,
         )
         self.router.add_api_route(
-            "/proposal_improvements/all",
+            "/proposals/{proposal_id}/proposal_improvements",
             self.create_all_proposal_improvements,
             methods=["POST"],
-            tags=["Proposal All Improvements"],
-            response_model=ProposalImprovementResponse,
+            tags=["Proposal Improvements by Proposal ID"],
+            response_model=ProposalAllImprovementsResponse,
         )
         self.router.add_api_route(
-            "/proposal_improvements",
+            "/proposal_improvements/{id}",
             self.update_proposal_improvements,
             methods=["PUT"],
-            tags=["Proposal Improvements"],
+            tags=["Proposal Improvements by ID"],
             response_model=ProposalImprovementResponse,
         )
         self.router.add_api_route(
-            "/proposal_improvements/all",
+            "/proposals/{proposal_id}/proposal_improvements",
             self.update_all_proposal_improvements,
             methods=["PUT"],
-            tags=["Proposal All Improvements"],
-            response_model=ProposalImprovementResponse,
+            tags=["Proposal Improvements by Proposal ID"],
+            response_model=ProposalAllImprovementsResponse,
         )
         self.router.add_api_route(
-            "/proposal_improvements",
+            "/proposal_improvements/{id}",
             self.delete_proposal_improvements,
             methods=["DELETE"],
-            tags=["Proposal Improvements"],
+            tags=["Proposal Improvements by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_improvements",
+            self.delete_all_proposal_improvements,
+            methods=["DELETE"],
+            tags=["Proposal Improvements by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_improvements/{id}",
+            self.delete_proposal_improvements_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal Improvements by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
@@ -390,6 +523,27 @@ class ProposalAIController:
             tags=["Proposal AI Score"],
             response_model=ProposalAIAnalysisResponse,
         )
+        self.router.add_api_route(
+            "/proposal_ai_score/{id}",
+            self.get_proposal_ai_score_by_id,
+            methods=["GET"],
+            tags=["Proposal AI Score by ID"],
+            response_model=ProposalAIAnalysisResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_ai_score",
+            self.get_proposal_ai_score_by_proposal_id,
+            methods=["GET"],
+            tags=["Proposal AI Score by Proposal ID"],
+            response_model=ProposalAIAnalysisResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_ai_score/{id}",
+            self.get_proposal_ai_score_by_proposal_and_id,
+            methods=["GET"],
+            tags=["Proposal AI Score by Proposal and ID"],
+            response_model=ProposalAIAnalysisResponse,
+        )
         self.router.add_api_route(
             "/proposal_ai_score",
             self.create_proposal_ai_score,
@@ -398,43 +552,71 @@ class ProposalAIController:
             response_model=ProposalAIAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_ai_score",
+            "/proposals/{proposal_id}/proposal_ai_score",
+            self.create_proposal_ai_score_by_proposal_id,
+            methods=["POST"],
+            tags=["Proposal AI Score by Proposal ID"],
+            response_model=ProposalAIAnalysisResponse,
+        )
+        self.router.add_api_route(
+            "/proposal_ai_score/{id}",
             self.update_proposal_ai_score,
             methods=["PUT"],
-            tags=["Proposal AI Score"],
+            tags=["Proposal AI Score by ID"],
             response_model=ProposalAIAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_ai_score",
+            "/proposals/{proposal_id}/proposal_ai_score",
+            self.update_proposal_ai_score_by_proposal_id,
+            methods=["PUT"],
+            tags=["Proposal AI Score by Proposal ID"],
+            response_model=ProposalAIAnalysisResponse,
+        )
+        self.router.add_api_route(
+            "/proposal_ai_score/{id}",
             self.delete_proposal_ai_score,
             methods=["DELETE"],
-            tags=["Proposal AI Score"],
+            tags=["Proposal AI Score by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_ai_score",
+            self.delete_proposal_ai_score_by_proposal_id,
+            methods=["DELETE"],
+            tags=["Proposal AI Score by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_ai_score/{id}",
+            self.delete_proposal_ai_score_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal AI Score by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
         self.router.add_api_route(
-            "/proposal_analysis",
+            "/proposals/{proposal_id}/proposal_analysis",
             self.get_all_proposal_analysis,
             methods=["GET"],
             tags=["Proposal Complete Analysis"],
             response_model=ProposalCompleteAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_analysis",
+            "/proposals/{proposal_id}/proposal_analysis",
             self.create_proposal_analysis,
             methods=["POST"],
             tags=["Proposal Complete Analysis"],
             response_model=ProposalCompleteAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_analysis",
+            "/proposals/{proposal_id}/proposal_analysis",
             self.update_proposal_analysis,
             methods=["PUT"],
             tags=["Proposal Complete Analysis"],
             response_model=ProposalCompleteAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_analysis",
+            "/proposals/{proposal_id}/proposal_analysis",
             self.delete_proposal_analysis,
             methods=["DELETE"],
             tags=["Proposal Complete Analysis"],
@@ -442,14 +624,12 @@ class ProposalAIController:
         )
 
     async def get_proposal_strengths(
-        self, proposal_strength_id: str = Query(None), proposal_id: UUID = Query(None)
+        self
     ):
         async with self.__service() as service:
             try:
                 strengths = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS,
-                    id=proposal_strength_id,
-                    proposal_id=proposal_id,
+                    query_type=QueryType.STRENGTHS
                 )
                 return ProposalStrengthResponse(
                     status="success", data=[ProposalStrength(**s) for s in strengths]
@@ -459,6 +639,51 @@ class ProposalAIController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve strengths."
                 )
+            
+    async def get_proposal_strengths_by_id(self, id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                strength = await service.get_all_data(
+                    query_type=QueryType.STRENGTHS, id=id
+                )
+                return ProposalStrengthResponse(
+                    status="success", data=[ProposalStrength(**s) for s in strength]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve strength."
+                )
+            
+    async def get_proposal_strengths_by_proposal_id(self, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                strength = await service.get_all_data(
+                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id
+                )
+                return ProposalAllStrengthsResponse(
+                    status="success", data=[s["strength_point"] for s in strength]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve strength."
+                )
+            
+    async def get_proposal_strengths_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                strength = await service.get_all_data(
+                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, id=id
+                )
+                return ProposalStrengthResponse(
+                    status="success", data=[ProposalStrength(**s) for s in strength]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve strength."
+                )
 
     async def create_proposal_strengths(self, strength: ProposalStrengthRequest):
         async with self.__service() as service:
@@ -478,17 +703,19 @@ class ProposalAIController:
                 )
 
     async def create_all_proposal_strengths(
-        self, strengths: CreateAllProposalStrengthsRequest
+        self, strengths: CreateAllProposalStrengthsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                strengths_request = strengths.model_dump(mode="json", exclude_unset=True)
+                strengths_request["proposal_id"] = proposal_id
                 created = await service.create_data(
                     query_type=QueryType.STRENGTHS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=strengths.model_dump(mode="json"),
+                    data=strengths_request,
                 )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in created]
+                return ProposalAllStrengthsResponse(
+                    status="success", data=[s["strength_point"] for s in created]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -496,13 +723,15 @@ class ProposalAIController:
                     status_code=500, detail="Failed to create strengths."
                 )
 
-    async def update_proposal_strengths(self, strength: UpdateProposalStrengthRequest):
+    async def update_proposal_strengths(self, strength: UpdateProposalStrengthRequest, id: UUID = Path(...)):
         async with self.__service() as service:
             try:
+                strength_request = strength.model_dump(mode="json", exclude_unset=True)
+                strength_request["id"] = id
                 updated = await service.update_data(
                     query_type=QueryType.STRENGTHS,
                     create_or_update_type=CreateOrUpdateType.ID,
-                    data=strength.model_dump(mode="json", exclude_unset=True),
+                    data=strength_request,
                 )
                 return ProposalStrengthResponse(
                     status="success", data=[ProposalStrength(**s) for s in updated]
@@ -514,17 +743,19 @@ class ProposalAIController:
                 )
 
     async def update_all_proposal_strengths(
-        self, strengths: CreateAllProposalStrengthsRequest
+        self, strengths: CreateAllProposalStrengthsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                strengths_request = strengths.model_dump(mode="json", exclude_unset=True)
+                strengths_request["proposal_id"] = proposal_id
                 updated = await service.update_data(
                     query_type=QueryType.STRENGTHS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=strengths.model_dump(mode="json", exclude_unset=True),
+                    data=strengths_request,
                 )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in updated]
+                return ProposalAllStrengthsResponse(
+                    status="success", data=[s["strength_point"] for s in updated]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -533,17 +764,38 @@ class ProposalAIController:
                 )
 
     async def delete_proposal_strength(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self, id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
-                if not id and not proposal_id:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Either id or proposal_id must be provided.",
-                    )
                 result = await service.delete_data(
-                    query_type=QueryType.STRENGTHS, id=id, proposal_id=proposal_id
+                    query_type=QueryType.STRENGTHS, id=id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete strength."
+                )
+            
+    async def delete_all_proposal_strengths(self, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete strengths."
+                )
+            
+    async def delete_proposal_strengths_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, id=id
                 )
                 return DeleteResponse(status="success")
             except Exception as e:
@@ -553,14 +805,12 @@ class ProposalAIController:
                 )
 
     async def get_proposal_weakness(
-        self, proposal_weakness_id: str = Query(None), proposal_id: UUID = Query(None)
+        self
     ):
         async with self.__service() as service:
             try:
                 weaknesses = await service.get_all_data(
-                    query_type=QueryType.WEAKNESSES,
-                    id=proposal_weakness_id,
-                    proposal_id=proposal_id,
+                    query_type=QueryType.WEAKNESSES
                 )
                 return ProposalWeaknessResponse(
                     status="success", data=[ProposalWeakness(**w) for w in weaknesses]
@@ -570,6 +820,51 @@ class ProposalAIController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve weaknesses."
                 )
+            
+    async def get_proposal_weakness_by_id(self, id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                weakness = await service.get_all_data(
+                    query_type=QueryType.WEAKNESSES, id=id
+                )
+                return ProposalWeaknessResponse(
+                    status="success", data=[ProposalWeakness(**w) for w in weakness]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve weakness."
+                )
+            
+    async def get_proposal_weakness_by_proposal_id(self, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                weakness = await service.get_all_data(
+                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id
+                )
+                return ProposalAllWeaknessesResponse(
+                    status="success", data=[w["weakness_point"] for w in weakness]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve weakness."
+                )
+            
+    async def get_proposal_weakness_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                weakness = await service.get_all_data(
+                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, id=id
+                )
+                return ProposalWeaknessResponse(
+                    status="success", data=[ProposalWeakness(**w) for w in weakness]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve weakness."
+                )
 
     async def create_proposal_weakness(self, weakness: ProposalWeaknessRequest):
         async with self.__service() as service:
@@ -589,17 +884,19 @@ class ProposalAIController:
                 )
 
     async def create_all_proposal_weakness(
-        self, weaknesses: CreateAllProposalWeaknessRequest
+        self, weaknesses: CreateAllProposalWeaknessRequest, proposal_id: UUID
     ):
         async with self.__service() as service:
             try:
+                weakness_request = weaknesses.model_dump(mode="json", exclude_unset=True)
+                weakness_request["proposal_id"] = proposal_id
                 created = await service.create_data(
                     query_type=QueryType.WEAKNESSES,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=weaknesses.model_dump(mode="json"),
+                    data=weakness_request,
                 )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in created]
+                return ProposalAllWeaknessesResponse(
+                    status="success", data=[w["weakness_point"] for w in created]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -607,13 +904,15 @@ class ProposalAIController:
                     status_code=500, detail="Failed to create weaknesses."
                 )
 
-    async def update_proposal_weakness(self, weakness: UpdateProposalWeaknessRequest):
+    async def update_proposal_weakness(self, weakness: UpdateProposalWeaknessRequest, id: UUID = Path(...)):
         async with self.__service() as service:
             try:
+                weakness_request = weakness.model_dump(mode="json", exclude_unset=True)
+                weakness_request["id"] = id
                 updated = await service.update_data(
                     query_type=QueryType.WEAKNESSES,
                     create_or_update_type=CreateOrUpdateType.ID,
-                    data=weakness.model_dump(mode="json", exclude_unset=True),
+                    data=weakness_request,
                 )
                 return ProposalWeaknessResponse(
                     status="success", data=[ProposalWeakness(**w) for w in updated]
@@ -625,17 +924,19 @@ class ProposalAIController:
                 )
 
     async def update_all_proposal_weakness(
-        self, weaknesses: CreateAllProposalWeaknessRequest
+        self, weaknesses: CreateAllProposalWeaknessRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                weakness_request = weaknesses.model_dump(mode="json", exclude_unset=True)
+                weakness_request["proposal_id"] = proposal_id
                 updated = await service.update_data(
                     query_type=QueryType.WEAKNESSES,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=weaknesses.model_dump(mode="json", exclude_unset=True),
+                    data=weakness_request,
                 )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in updated]
+                return ProposalAllWeaknessesResponse(
+                    status="success", data=[w["weakness_point"] for w in updated]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -644,12 +945,40 @@ class ProposalAIController:
                 )
 
     async def delete_proposal_weakness(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self, id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
                 result = await service.delete_data(
-                    query_type=QueryType.WEAKNESSES, id=id, proposal_id=proposal_id
+                    query_type=QueryType.WEAKNESSES, id=id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete weakness."
+                )
+            
+    async def delete_all_proposal_weakness(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete weaknesses."
+                )
+            
+    async def delete_proposal_weakness_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, id=id
                 )
                 return DeleteResponse(status="success")
             except Exception as e:
@@ -659,14 +988,12 @@ class ProposalAIController:
                 )
 
     async def get_proposal_rejections(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self
     ):
         async with self.__service() as service:
             try:
                 rejection_reasons = await service.get_all_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    id=id,
-                    proposal_id=proposal_id,
+                    query_type=QueryType.REJECTION_REASONS
                 )
                 return ProposalRejectionReasonResponse(
                     status="success",
@@ -677,6 +1004,51 @@ class ProposalAIController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve rejection reasons."
                 )
+    
+    async def get_proposal_rejections_by_id(self, id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                rejection_reason = await service.get_all_data(
+                    query_type=QueryType.REJECTION_REASONS, id=id
+                )
+                return ProposalRejectionReasonResponse(
+                    status="success", data=[ProposalRejectionReason(**r) for r in rejection_reason]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve rejection reason."
+                )
+            
+    async def get_proposal_rejections_by_proposal_id(self, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                rejection_reason = await service.get_all_data(
+                    query_type=QueryType.REJECTION_REASONS, proposal_id=proposal_id
+                )
+                return ProposalAllRejectionReasonsResponse(
+                    status="success", data=[r["reason"] for r in rejection_reason]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve rejection reason."
+                )
+            
+    async def get_proposal_rejections_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                rejection_reason = await service.get_all_data(
+                    query_type=QueryType.REJECTION_REASONS, proposal_id=proposal_id, id=id
+                )
+                return ProposalRejectionReasonResponse(
+                    status="success", data=[ProposalRejectionReason(**r) for r in rejection_reason]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve rejection reason."
+                )
 
     async def create_proposal_rejections(
         self, rejection_reason: ProposalRejectionReasonRequest
@@ -699,18 +1071,20 @@ class ProposalAIController:
                 )
 
     async def create_all_proposal_rejections(
-        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest
+        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                rejection_reasons_data = rejection_reasons.model_dump(mode="json", exclude_unset=True)
+                rejection_reasons_data["proposal_id"] = proposal_id
                 created = await service.create_data(
                     query_type=QueryType.REJECTION_REASONS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=rejection_reasons.model_dump(mode="json"),
+                    data=rejection_reasons_data,
                 )
-                return ProposalRejectionReasonResponse(
+                return ProposalAllRejectionReasonsResponse(
                     status="success",
-                    data=[ProposalRejectionReason(**r) for r in created],
+                    data=[r["reason"] for r in created],
                 )
             except Exception as e:
                 logger.exception(e)
@@ -719,14 +1093,16 @@ class ProposalAIController:
                 )
 
     async def update_proposal_rejections(
-        self, rejection_reason: UpdateProposalRejectionReasonRequest
+        self, rejection_reason: UpdateProposalRejectionReasonRequest, id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                rejection_reason_data = rejection_reason.model_dump(mode="json", exclude_unset=True)
+                rejection_reason_data["id"] = id
                 updated = await service.update_data(
                     query_type=QueryType.REJECTION_REASONS,
                     create_or_update_type=CreateOrUpdateType.ID,
-                    data=rejection_reason.model_dump(mode="json", exclude_unset=True),
+                    data=rejection_reason_data,
                 )
                 return ProposalRejectionReasonResponse(
                     status="success",
@@ -739,18 +1115,20 @@ class ProposalAIController:
                 )
 
     async def update_all_proposal_rejections(
-        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest
+        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                rejection_reasons_data = rejection_reasons.model_dump(mode="json", exclude_unset=True)
+                rejection_reasons_data["proposal_id"] = proposal_id
                 updated = await service.update_data(
                     query_type=QueryType.REJECTION_REASONS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=rejection_reasons.model_dump(mode="json", exclude_unset=True),
+                    data=rejection_reasons_data,
                 )
-                return ProposalRejectionReasonResponse(
+                return ProposalAllRejectionReasonsResponse(
                     status="success",
-                    data=[ProposalRejectionReason(**r) for r in updated],
+                    data=[r["reason"] for r in updated],
                 )
             except Exception as e:
                 logger.exception(e)
@@ -759,19 +1137,46 @@ class ProposalAIController:
                 )
 
     async def delete_proposal_rejections(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self, id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.REJECTION_REASONS,
+                    id=id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete rejection reason."
+                )
+            
+    async def delete_all_proposal_rejections(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.REJECTION_REASONS,
+                    proposal_id=proposal_id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete rejection reasons."
+                )
+            
+    async def delete_proposal_rejections_by_proposal_and_id(
+        self, proposal_id: UUID = Path(...), id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
-                if not id and not proposal_id:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Either id or proposal_id must be provided.",
-                    )
                 result = await service.delete_data(
                     query_type=QueryType.REJECTION_REASONS,
                     id=id,
-                    proposal_id=proposal_id,
+                    proposal_id=proposal_id
                 )
                 return DeleteResponse(status="success")
             except Exception as e:
@@ -781,12 +1186,70 @@ class ProposalAIController:
                 )
 
     async def get_proposal_improvements(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self
     ):
         async with self.__service() as service:
             try:
                 improvements = await service.get_all_data(
-                    query_type=QueryType.IMPROVEMENTS, id=id, proposal_id=proposal_id
+                    query_type=QueryType.IMPROVEMENTS
+                )
+                return ProposalImprovementResponse(
+                    status="success",
+                    data=[ProposalImprovement(**r) for r in improvements],
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve improvements."
+                )
+            
+    async def get_proposal_improvements_by_id(
+        self, id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                improvements = await service.get_all_data(
+                    query_type=QueryType.IMPROVEMENTS,
+                    id=id
+                )
+                return ProposalImprovementResponse(
+                    status="success",
+                    data=[ProposalImprovement(**r) for r in improvements],
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve improvements."
+                )
+            
+    async def get_proposal_improvements_by_proposal_id(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                improvements = await service.get_all_data(
+                    query_type=QueryType.IMPROVEMENTS,
+                    proposal_id=proposal_id
+                )
+                return ProposalAllImprovementsResponse(
+                    status="success",
+                    data=[r["improvement_point"] for r in improvements],
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve improvements."
+                )
+            
+    async def get_proposal_improvements_by_proposal_and_id(
+        self, proposal_id: UUID = Path(...), id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                improvements = await service.get_all_data(
+                    query_type=QueryType.IMPROVEMENTS,
+                    id=id,
+                    proposal_id=proposal_id
                 )
                 return ProposalImprovementResponse(
                     status="success",
@@ -818,17 +1281,19 @@ class ProposalAIController:
                 )
 
     async def create_all_proposal_improvements(
-        self, improvements: CreateAllProposalImprovementsRequest
+        self, improvements: CreateAllProposalImprovementsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                data = improvements.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
                 created = await service.create_data(
                     query_type=QueryType.IMPROVEMENTS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=improvements.model_dump(mode="json"),
+                    data=data,
                 )
-                return ProposalImprovementResponse(
-                    status="success", data=[ProposalImprovement(**r) for r in created]
+                return ProposalAllImprovementsResponse(
+                    status="success", data=[r["improvement_point"] for r in created]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -837,14 +1302,16 @@ class ProposalAIController:
                 )
 
     async def update_proposal_improvements(
-        self, improvement: UpdateProposalImprovementRequest
+        self, improvement: UpdateProposalImprovementRequest, id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                data = improvement.model_dump(mode="json", exclude_unset=True)
+                data["id"] = id
                 updated = await service.update_data(
                     query_type=QueryType.IMPROVEMENTS,
                     create_or_update_type=CreateOrUpdateType.ID,
-                    data=improvement.model_dump(mode="json", exclude_unset=True),
+                    data=data,
                 )
                 return ProposalImprovementResponse(
                     status="success", data=[ProposalImprovement(**r) for r in updated]
@@ -856,17 +1323,19 @@ class ProposalAIController:
                 )
 
     async def update_all_proposal_improvements(
-        self, improvements: CreateAllProposalImprovementsRequest
+        self, improvements: CreateAllProposalImprovementsRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                data = improvements.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
                 updated = await service.update_data(
                     query_type=QueryType.IMPROVEMENTS,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=improvements.model_dump(mode="json", exclude_unset=True),
+                    data=data,
                 )
-                return ProposalImprovementResponse(
-                    status="success", data=[ProposalImprovement(**r) for r in updated]
+                return ProposalAllImprovementsResponse(
+                    status="success", data=[r["improvement_point"] for r in updated]
                 )
             except Exception as e:
                 logger.exception(e)
@@ -875,15 +1344,40 @@ class ProposalAIController:
                 )
 
     async def delete_proposal_improvements(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self, id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.IMPROVEMENTS, id=id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete improvement."
+                )
+            
+    async def delete_all_proposal_improvements(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.IMPROVEMENTS, proposal_id=proposal_id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete improvements."
+                )
+            
+    async def delete_proposal_improvements_by_proposal_and_id(
+        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
-                if not id and not proposal_id:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Either id or proposal_id must be provided.",
-                    )
                 result = await service.delete_data(
                     query_type=QueryType.IMPROVEMENTS, id=id, proposal_id=proposal_id
                 )
@@ -895,7 +1389,58 @@ class ProposalAIController:
                 )
 
     async def get_proposal_ai_score(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self
+    ):
+        async with self.__service() as service:
+            try:
+                scores = await service.get_all_data(
+                    query_type=QueryType.AI_SCORE
+                )
+                return ProposalAIAnalysisResponse(
+                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve AI scores."
+                )
+            
+    async def get_proposal_ai_score_by_id(
+        self, id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                scores = await service.get_all_data(
+                    query_type=QueryType.AI_SCORE, id=id
+                )
+                return ProposalAIAnalysisResponse(
+                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve AI scores."
+                )
+            
+    async def get_proposal_ai_score_by_proposal_id(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                scores = await service.get_all_data(
+                    query_type=QueryType.AI_SCORE, proposal_id=proposal_id
+                )
+                return ProposalAIAnalysisResponse(
+                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to retrieve AI scores."
+                )
+            
+    async def get_proposal_ai_score_by_proposal_and_id(
+        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
@@ -927,25 +1472,36 @@ class ProposalAIController:
                 raise HTTPException(
                     status_code=500, detail="Failed to create AI score."
                 )
+            
+    async def create_proposal_ai_score_by_proposal_id(self, score: CreateAIAnalysisRequestByProposalId, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                data = score.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
+                created = await service.create_data(
+                    query_type=QueryType.AI_SCORE,
+                    create_or_update_type=CreateOrUpdateType.ID,
+                    data=data,
+                )
+                return ProposalAIAnalysisResponse(
+                    status="success", data=[ProposalAIAnalysis(**r) for r in created]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to create AI score."
+                )
 
-    async def update_proposal_ai_score(self, score: UpdateAiAnalysisRequest):
-        if not score.id and not score.proposal_id:
-            raise HTTPException(
-                status_code=400, detail="Either 'id' or 'proposal_id' must be provided."
-            )
+    async def update_proposal_ai_score(self, score: UpdateAiAnalysisRequest, id: UUID = Path(...)):
         async with self.__service() as service:
             try:
-                if score.id:
+                if id:
+                    data = score.model_dump(mode="json", exclude_unset=True)
+                    data["id"] = id
                     updated = await service.update_data(
                         query_type=QueryType.AI_SCORE,
                         create_or_update_type=CreateOrUpdateType.ID,
-                        data=score.model_dump(mode="json", exclude_unset=True),
-                    )
-                elif score.proposal_id:
-                    updated = await service.update_data(
-                        query_type=QueryType.AI_SCORE,
-                        create_or_update_type=CreateOrUpdateType.ALL,
-                        data=score.model_dump(mode="json", exclude_unset=True),
+                        data=data,
                     )
                 return ProposalAIAnalysisResponse(
                     status="success", data=[ProposalAIAnalysis(**r) for r in updated]
@@ -955,17 +1511,61 @@ class ProposalAIController:
                 raise HTTPException(
                     status_code=500, detail="Failed to update AI score."
                 )
+            
+    async def update_proposal_ai_score_by_proposal_id(self, score: UpdateAIAnalysisRequestByProposalId, proposal_id: UUID = Path(...)):
+        async with self.__service() as service:
+            try:
+                data = score.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
+                updated = await service.update_data(
+                    query_type=QueryType.AI_SCORE,
+                    create_or_update_type=CreateOrUpdateType.ALL,
+                    data=data,
+                )
+                return ProposalAIAnalysisResponse(
+                    status="success", data=[ProposalAIAnalysis(**r) for r in updated]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to update AI score."
+                )
 
     async def delete_proposal_ai_score(
-        self, id: UUID = Query(None), proposal_id: UUID = Query(None)
+        self, id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.AI_SCORE, id=id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete AI score."
+                )
+            
+    async def delete_proposal_ai_score_by_proposal_id(
+        self, proposal_id: UUID = Path(...)
+    ):
+        async with self.__service() as service:
+            try:
+                result = await service.delete_data(
+                    query_type=QueryType.AI_SCORE, proposal_id=proposal_id
+                )
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete AI score."
+                )
+            
+    async def delete_proposal_ai_score_by_proposal_and_id(
+        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
-                if not id and not proposal_id:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Either id or proposal_id must be provided.",
-                    )
                 result = await service.delete_data(
                     query_type=QueryType.AI_SCORE, id=id, proposal_id=proposal_id
                 )
@@ -976,7 +1576,7 @@ class ProposalAIController:
                     status_code=500, detail="Failed to delete AI score."
                 )
 
-    async def get_all_proposal_analysis(self, proposal_id: UUID = Query(...)):
+    async def get_all_proposal_analysis(self, proposal_id: UUID = Path(...)):
         async with self.__service() as service:
             try:
                 analysis = await service.get_all_data(
@@ -993,14 +1593,16 @@ class ProposalAIController:
                 )
 
     async def create_proposal_analysis(
-        self, analysis: CreateAllProposalAnalysisRequest
+        self, analysis: CreateAllProposalAnalysisRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                data = analysis.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
                 created = await service.create_data(
                     query_type=QueryType.ALL,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=analysis.model_dump(mode="json", exclude_unset=True),
+                    data=data,
                 )
                 return ProposalCompleteAnalysisResponse(
                     status="success",
@@ -1013,14 +1615,16 @@ class ProposalAIController:
                 )
 
     async def update_proposal_analysis(
-        self, analysis: UpdateAllProposalAnalysisRequest
+        self, analysis: UpdateAllProposalAnalysisRequest, proposal_id: UUID = Path(...)
     ):
         async with self.__service() as service:
             try:
+                data = analysis.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
                 updated = await service.update_data(
                     query_type=QueryType.ALL,
                     create_or_update_type=CreateOrUpdateType.ALL,
-                    data=analysis.model_dump(mode="json", exclude_unset=True),
+                    data=data,
                 )
                 return ProposalCompleteAnalysisResponse(
                     status="success",
@@ -1032,11 +1636,11 @@ class ProposalAIController:
                     status_code=500, detail="Failed to update analysis."
                 )
 
-    async def delete_proposal_analysis(self, id: UUID = Query(...)):
+    async def delete_proposal_analysis(self, proposal_id: UUID = Path(...)):
         async with self.__service() as service:
             try:
                 result = await service.delete_data(
-                    query_type=QueryType.ALL, proposal_id=id
+                    query_type=QueryType.ALL, proposal_id=proposal_id
                 )
                 return DeleteResponse(status="success")
             except Exception as e:

src/controllers/_proposal_controller.py

@@ -28,6 +28,13 @@ class ProposalRequest(BaseModel):
     status: ProposalStatus
 
 
+class CreateProposalRequest(BaseModel):
+    name: str
+    tep: str
+    gate_criteria: GateCriteria
+    status: ProposalStatus
+
+
 class ProposalUpdateRequest(BaseModel):
     rfp_id: Optional[UUID] = None
     name: Optional[str] = None
@@ -36,6 +43,13 @@ class ProposalUpdateRequest(BaseModel):
     status: Optional[ProposalStatus] = None
 
 
+class UpdateProposalRequest(BaseModel):
+    name: Optional[str] = None
+    tep: Optional[str] = None
+    gate_criteria: Optional[GateCriteria] = None
+    status: Optional[ProposalStatus] = None
+
+
 class ProposalDeleteResponse(BaseModel):
     status: str
 
@@ -84,6 +98,13 @@ class ProposalController:
             response_model=ResponseProposal,
             tags=["Proposals"],
         )
+        self.router.add_api_route(
+            "/rfps/{rfp_id}/proposals",
+            self.create_proposal_by_rfp_id,
+            methods=["POST"],
+            response_model=ResponseProposal,
+            tags=["Proposals by RFP ID"],
+        )
         self.router.add_api_route(
             "/proposals/{proposal_id}",
             self.update_proposal,
@@ -91,6 +112,13 @@ class ProposalController:
             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,
+            methods=["PUT"],
+            response_model=ResponseProposal,
+            tags=["Proposals by Proposal and RFP ID"],
+        )
         self.router.add_api_route(
             "/proposals/{proposal_id}",
             self.delete_proposal,
@@ -113,9 +141,7 @@ class ProposalController:
             tags=["Proposals by Proposal and RFP ID"],
         )
 
-    async def get_proposals(
-        self
-    ):
+    async def get_proposals(self):
         async with self.__proposal_service() as service:
             try:
                 proposals = await service.get_proposals()
@@ -127,7 +153,7 @@ class ProposalController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve proposals."
                 )
-            
+
     async def get_proposals_by_id(
         self,
         proposal_id: str = Path(...),
@@ -143,7 +169,7 @@ class ProposalController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve proposals."
                 )
-            
+
     async def get_proposals_by_rfp_id(
         self,
         rfp_id: str = Path(...),
@@ -159,7 +185,7 @@ class ProposalController:
                 raise HTTPException(
                     status_code=500, detail="Failed to retrieve proposals."
                 )
-            
+
     async def get_proposals_by_proposal_and_rfp_id(
         self,
         rfp_id: str = Path(...),
@@ -167,7 +193,9 @@ class ProposalController:
     ):
         async with self.__proposal_service() as service:
             try:
-                proposals = await service.get_proposals(rfp_id=rfp_id, proposal_id=proposal_id)
+                proposals = await service.get_proposals(
+                    rfp_id=rfp_id, proposal_id=proposal_id
+                )
                 return ResponseProposal(
                     status="success", data=[Proposal(**p) for p in proposals]
                 )
@@ -192,12 +220,31 @@ class ProposalController:
                     status_code=500, detail="Failed to create proposal."
                 )
 
-    async def update_proposal(self, proposal: ProposalUpdateRequest, proposal_id: str = Path(...)):
+    async def create_proposal_by_rfp_id(
+        self, proposal: CreateProposalRequest, rfp_id: str = Path(...)
+    ):
+        async with self.__proposal_service() as service:
+            try:
+                data = proposal.model_dump(exclude_unset=True, mode="json")
+                data["rfp_id"] = rfp_id
+                new_proposal = await service.create_proposal(proposal=data)
+                return ResponseProposal(
+                    status="success", data=[Proposal(**new_proposal)]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to create proposal."
+                )
+
+    async def update_proposal(
+        self, proposal: ProposalUpdateRequest, proposal_id: str = Path(...)
+    ):
         async with self.__proposal_service() as service:
             try:
                 updated_proposal = await service.update_proposal(
                     proposal_id=proposal_id,
-                    proposal=proposal.model_dump(exclude_unset=True)
+                    proposal=proposal.model_dump(exclude_unset=True),
                 )
                 return ResponseProposal(
                     status="success", data=[Proposal(**updated_proposal)]
@@ -208,14 +255,33 @@ class ProposalController:
                     status_code=500, detail="Failed to update proposal."
                 )
 
-    async def delete_proposal(
-        self, proposal_id: str = Path(...)
+    async def update_proposal_by_proposal_and_rfp_id(
+        self,
+        proposal: UpdateProposalRequest,
+        rfp_id: str = Path(...),
+        proposal_id: str = Path(...),
     ):
         async with self.__proposal_service() as service:
             try:
-                status = await service.delete_proposal(
-                    proposal_id=proposal_id
+                data = proposal.model_dump(exclude_unset=True, mode="json")
+                data["rfp_id"] = rfp_id
+                updated_proposal = await service.update_proposal(
+                    proposal_id=proposal_id,
+                    proposal=proposal.model_dump(exclude_unset=True),
                 )
+                return ResponseProposal(
+                    status="success", data=[Proposal(**updated_proposal)]
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to update proposal."
+                )
+
+    async def delete_proposal(self, proposal_id: str = Path(...)):
+        async with self.__proposal_service() as service:
+            try:
+                status = await service.delete_proposal(proposal_id=proposal_id)
                 if not status:
                     raise HTTPException(status_code=404, detail="Proposal not found.")
                 return ProposalDeleteResponse(status="success")
@@ -224,15 +290,11 @@ class ProposalController:
                 raise HTTPException(
                     status_code=500, detail="Failed to delete proposal."
                 )
-            
-    async def delete_proposals_by_rfp_id(
-        self, rfp_id: str = Path(...)
-    ):
+
+    async def delete_proposals_by_rfp_id(self, rfp_id: str = Path(...)):
         async with self.__proposal_service() as service:
             try:
-                status = await service.delete_proposal(
-                    rfp_id=rfp_id
-                )
+                status = await service.delete_proposal(rfp_id=rfp_id)
                 if not status:
                     raise HTTPException(status_code=404, detail="Proposal not found.")
                 return ProposalDeleteResponse(status="success")
@@ -241,7 +303,7 @@ class ProposalController:
                 raise HTTPException(
                     status_code=500, detail="Failed to delete proposal."
                 )
-            
+
     async def delete_proposals_by_proposal_and_rfp_id(
         self, rfp_id: str = Path(...), proposal_id: str = Path(...)
     ):
@@ -257,4 +319,4 @@ class ProposalController:
                 logger.exception(e)
                 raise HTTPException(
                     status_code=500, detail="Failed to delete proposal."
-                )
+                )

src/controllers/_proposal_detailed_analysis_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
@@ -39,7 +39,6 @@ class ProposalCompleteDetailedAnalysis(BaseModel):
 
 
 class CreateProposalDetailedAnalysisRequest(BaseModel):
-    proposal_id: UUID
     data: ProposalCompleteDetailedAnalysis
 
 
@@ -60,7 +59,6 @@ class CreateDetailedAnalysisRequest(BaseModel):
 
 
 class UpdateDetailedAnalysisRequest(BaseModel):
-    id: Optional[UUID] = None
     proposal_id: Optional[UUID] = None
     confidence: Optional[float] = None
     ai_assessment_result: Optional[str] = None
@@ -79,10 +77,17 @@ class ProposalDetailedController:
             response_model=ProposalDetailedAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_detailed_analysis/all",
+            "/proposal_detailed_analysis/{id}",
+            self.get_proposal_analysis_by_id,
+            methods=["GET"],
+            tags=["Proposal Detailed Analysis by ID"],
+            response_model=ProposalDetailedAnalysisResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_detailed_analysis",
             self.get_proposal_analysis_by_proposal_id,
             methods=["GET"],
-            tags=["Proposal Complete Detailed Analysis"],
+            tags=["Proposal Detailed Analysis by Proposal ID"],
             response_model=CompleteAnalysisResponse,
         )
         self.router.add_api_route(
@@ -93,37 +98,52 @@ class ProposalDetailedController:
             response_model=ProposalDetailedAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_detailed_analysis/all",
+            "/proposals/{proposal_id}/proposal_detailed_analysis",
             self.create_complete_proposal_analysis,
             methods=["POST"],
-            tags=["Proposal Complete Detailed Analysis"],
+            tags=["Proposal Detailed Analysis by Proposal ID"],
             response_model=CompleteAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_detailed_analysis",
+            "/proposal_detailed_analysis/{id}",
             self.update_proposal_analysis,
             methods=["PUT"],
-            tags=["Proposal Detailed Analysis"],
+            tags=["Proposal Detailed Analysis by ID"],
             response_model=ProposalDetailedAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_detailed_analysis/all",
+            "/proposals/{proposal_id}/proposal_detailed_analysis",
             self.update_complete_proposal_analysis,
             methods=["PUT"],
-            tags=["Proposal Complete Detailed Analysis"],
+            tags=["Proposal Detailed Analysis by Proposal ID"],
             response_model=CompleteAnalysisResponse,
         )
         self.router.add_api_route(
-            "/proposal_detailed_analysis",
+            "/proposal_detailed_analysis/{id}",
             self.delete_proposal_analysis,
             methods=["DELETE"],
+            tags=["Proposal Detailed Analysis by ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_detailed_analysis",
+            self.delete_proposal_analysis_by_proposal_id,
+            methods=["DELETE"],
+            tags=["Proposal Detailed Analysis by Proposal ID"],
+            response_model=DeleteResponse,
+        )
+        self.router.add_api_route(
+            "/proposals/{proposal_id}/proposal_detailed_analysis/{id}",
+            self.delete_proposal_analysis_by_proposal_and_id,
+            methods=["DELETE"],
+            tags=["Proposal Detailed Analysis by Proposal and ID"],
             response_model=DeleteResponse,
         )
 
-    async def get_proposal_analysis(self, id: str = Query(None)):
+    async def get_proposal_analysis(self):
         async with self.service() as service:
             try:
-                result = await service.get_proposal_analysis(id=id)
+                result = await service.get_proposal_analysis()
                 if not result:
                     return ProposalDetailedAnalysisResponse(status="success", data=[])
                 return ProposalDetailedAnalysisResponse(
@@ -136,7 +156,21 @@ class ProposalDetailedController:
                     status_code=500, detail="Failed to get proposal analysis."
                 )
 
-    async def get_proposal_analysis_by_proposal_id(self, proposal_id: str = Query(...)):
+    async def get_proposal_analysis_by_id(self, id: str = Path(...)):
+        async with self.service() as service:
+            try:
+                result = await service.get_proposal_analysis(id=id)
+                return ProposalDetailedAnalysisResponse(
+                    status="success",
+                    data=[ProposalDetailedAnalysis(**r) for r in result],
+                )
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to get proposal analysis."
+                )
+
+    async def get_proposal_analysis_by_proposal_id(self, proposal_id: str = Path(...)):
         async with self.service() as service:
             try:
                 result = await service.get_proposal_analysis_by_proposal_id(
@@ -166,13 +200,15 @@ class ProposalDetailedController:
                 )
 
     async def create_complete_proposal_analysis(
-        self, analysis: CreateProposalDetailedAnalysisRequest
+        self,
+        analysis: CreateProposalDetailedAnalysisRequest,
+        proposal_id: UUID = Path(...),
     ):
         async with self.service() as service:
             try:
-                result = await service.create_complete_proposal_analysis(
-                    data=analysis.model_dump(mode="json", exclude_unset=True)
-                )
+                data = analysis.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
+                result = await service.create_complete_proposal_analysis(data=data)
                 return CompleteAnalysisResponse(status="success", data=result)
             except Exception as e:
                 logger.exception(e)
@@ -180,12 +216,14 @@ class ProposalDetailedController:
                     status_code=500, detail="Failed to create proposal analysis."
                 )
 
-    async def update_proposal_analysis(self, analysis: UpdateDetailedAnalysisRequest):
+    async def update_proposal_analysis(
+        self, analysis: UpdateDetailedAnalysisRequest, id: UUID = Path(...)
+    ):
         async with self.service() as service:
             try:
-                result = await service.update_proposal_analysis(
-                    data=analysis.model_dump(mode="json", exclude_unset=True)
-                )
+                data = analysis.model_dump(mode="json", exclude_unset=True)
+                data["id"] = id
+                result = await service.update_proposal_analysis(data=data)
                 return ProposalDetailedAnalysisResponse(
                     status="success",
                     data=[ProposalDetailedAnalysis(**r) for r in result],
@@ -197,13 +235,15 @@ class ProposalDetailedController:
                 )
 
     async def update_complete_proposal_analysis(
-        self, analysis: CreateProposalDetailedAnalysisRequest
+        self,
+        analysis: CreateProposalDetailedAnalysisRequest,
+        proposal_id: UUID = Path(...),
     ):
         async with self.service() as service:
             try:
-                result = await service.update_complete_proposal_analysis(
-                    data=analysis.model_dump(mode="json", exclude_unset=True)
-                )
+                data = analysis.model_dump(mode="json", exclude_unset=True)
+                data["proposal_id"] = proposal_id
+                result = await service.update_complete_proposal_analysis(data=data)
                 return CompleteAnalysisResponse(status="success", data=result)
             except Exception as e:
                 logger.exception(e)
@@ -211,18 +251,37 @@ class ProposalDetailedController:
                     status_code=500, detail="Failed to update proposal analysis."
                 )
 
-    async def delete_proposal_analysis(
-        self, id: str = Query(None), proposal_id: str = Query(None)
+    async def delete_proposal_analysis(self, id: str = Path(...)):
+        async with self.service() as service:
+            try:
+                result = await service.delete_proposal_analysis(id=id)
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete proposal analysis."
+                )
+
+    async def delete_proposal_analysis_by_proposal_id(
+        self, proposal_id: str = Path(...)
+    ):
+        async with self.service() as service:
+            try:
+                result = await service.delete_proposal_analysis(proposal_id=proposal_id)
+                return DeleteResponse(status="success")
+            except Exception as e:
+                logger.exception(e)
+                raise HTTPException(
+                    status_code=500, detail="Failed to delete proposal analysis."
+                )
+
+    async def delete_proposal_analysis_by_proposal_and_id(
+        self, proposal_id: str = Path(...), id: str = Path(...)
     ):
         async with self.service() as service:
             try:
-                if not id and not proposal_id:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Either id or proposal_id must be provided.",
-                    )
                 result = await service.delete_proposal_analysis(
-                    id=id, proposal_id=proposal_id
+                    proposal_id=proposal_id, id=id
                 )
                 return DeleteResponse(status="success")
             except Exception as e: