fix

src/calculation_time_constrains/flows.py

@@ -0,0 +1,46 @@
+from sqlalchemy import Select, func, select
+from src.workorder.model import MasterWorkOrder
+from src.scope_equipment.model import ScopeEquipment
+from src.scope.model import Scope
+from src.database.core import DbSession
+
+
+async def get_cost_per_failure(*, db_session: DbSession):
+    stmt = (
+        select(
+            ScopeEquipment.scope_id,
+            func.avg(MasterWorkOrder.total_cost_max).label('average_cost')
+        )
+        .outerjoin(MasterWorkOrder, ScopeEquipment.assetnum == MasterWorkOrder.assetnum)
+        .group_by(ScopeEquipment.scope_id)
+        .order_by(ScopeEquipment.scope_id)
+    )
+
+    results = await db_session.execute(stmt)
+
+    return results.all()
+
+
+async def create_calculation(*, db_session: DbSession):
+    return {
+        "id": "calc_123",
+        "result": {
+            "summary": {
+                "scope": "B",
+                "numberOfFailures": 59,
+                "optimumOHTime": 90,
+                "optimumTotalCost": 500000000
+            },
+            "chartData": {},
+            "comparisons": {
+                "vsLastCalculation": {
+                    "costDifference": -50000000,
+                    "timeChange": "+15 days"
+                }
+            }
+        },
+        "simulationLimits": {
+            "minInterval": 30,
+            "maxInterval": 180
+        }
+    }

src/calculation_time_constrains/router.py

@@ -4,32 +4,24 @@ from fastapi import APIRouter, HTTPException, status
 from .schema import CalculationTimeConstrainsParametersRead, CalculationTimeConstrainsRead, CalculationTimeConstrainsCreate
 from src.database.core import DbSession
 from src.models import StandardResponse
+from .flows import get_cost_per_failure, create_calculation
+from src.scope.service import get_all
 
 router = APIRouter()
 
 
 @router.get("/parameters", response_model=StandardResponse[CalculationTimeConstrainsParametersRead])
-async def get_calculation_parameters():
+async def get_calculation_parameters(db_session: DbSession):
     """Get all calculation parameter pagination."""
 
-    #     {
-    #     "costPerFailure": 733.614,
-    #     "availableScopes": ["A", "B"],
-    #     "recommendedScope": "B",
-    #     "historicalData": {
-    #         "averageOverhaulCost": 10000000,
-    #         "lastCalculation": {
-    #             "id": "calc_122",
-    #             "date": "2024-10-15",
-    #             "scope": "B"
-    #         }
-    #     }
-    # }
+    avaiableScopes = {scope.id: scope.scope_name for scope in await get_all(db_session=db_session)}
+    costFailurePerScope = {avaiableScopes.get(
+        costPerFailure[0]): costPerFailure[1] for costPerFailure in await get_cost_per_failure(db_session=db_session)}
 
     return StandardResponse(
         data=CalculationTimeConstrainsParametersRead(
-            costPerFailure=733.614,
-            availableScopes=["A", "B"],
+            costPerFailure=costFailurePerScope,
+            availableScopes=avaiableScopes.values(),
             recommendedScope="B",
             historicalData={
                 "averageOverhaulCost": 10000000,
@@ -47,28 +39,8 @@ async def get_calculation_parameters():
 @router.post("", response_model=StandardResponse[CalculationTimeConstrainsRead])
 async def create_calculation_time_constrains(db_session: DbSession, calculation_time_constrains_in: CalculationTimeConstrainsCreate):
     """Calculate Here"""
-    calculation_result = {
-        "id": "calc_123",
-        "result": {
-            "summary": {
-                "scope": "B",
-                "numberOfFailures": 59,
-                "optimumOHTime": 90,
-                "optimumTotalCost": 500000000
-            },
-            "chartData": {},
-            "comparisons": {
-                "vsLastCalculation": {
-                    "costDifference": -50000000,
-                    "timeChange": "+15 days"
-                }
-            }
-        },
-        "simulationLimits": {
-            "minInterval": 30,
-            "maxInterval": 180
-        }
-    }
+    calculation_result = await create_calculation(db_session=db_session)
+    
 
     return StandardResponse(data=CalculationTimeConstrainsRead(
         id=calculation_result["id"],
@@ -92,5 +64,5 @@ async def get_simulation_result():
             },
         }
     }
-    
+
     return StandardResponse(data=results, message="Data retrieved successfully")

src/calculation_time_constrains/schema.py

@@ -27,7 +27,7 @@ class CalculationTimeConstrainsBase(DefultBase):
 
 
 class CalculationTimeConstrainsParametersRead(CalculationTimeConstrainsBase):
-    costPerFailure: float = Field(..., description="Cost per failure")
+    costPerFailure: dict = Field(..., description="Cost per failure")
     availableScopes: List[str] = Field(..., description="Available scopes")
     recommendedScope: str = Field(..., description="Recommended scope")
     historicalData: Dict[str, Any] = Field(..., description="Historical data")
@@ -73,6 +73,7 @@ class CalculationTimeConstrainsCreate(CalculationTimeConstrainsBase):
 #     }
 # }
 
+
 class CalculationTimeConstrainsRead(CalculationTimeConstrainsBase):
     id: Union[UUID, str]
     result: Dict[str, Any]