diff --git a/src/calculation_budget_constrains/router.py b/src/calculation_budget_constrains/router.py index 65f2d85..b6af7fb 100644 --- a/src/calculation_budget_constrains/router.py +++ b/src/calculation_budget_constrains/router.py @@ -11,18 +11,21 @@ from .service import get_all_budget_constrains router = APIRouter() -@router.get("", response_model=StandardResponse[List[Dict]]) +@router.get("/{session_id}", response_model=StandardResponse[Dict]) async def get_target_reliability( db_session: DbSession, - scope_name: Optional[str] = Query(None), + session_id: str, cost_threshold: float = Query(100), ): """Get all scope pagination.""" - results = await get_all_budget_constrains( - db_session=db_session, scope_name=scope_name, cost_threshold=cost_threshold + results, consequesce = await get_all_budget_constrains( + db_session=db_session, session_id=session_id, cost_threshold=cost_threshold ) return StandardResponse( - data=results, + data={ + "results": results, + "consequence": consequesce + }, message="Data retrieved successfully", ) diff --git a/src/calculation_budget_constrains/service.py b/src/calculation_budget_constrains/service.py index 851415c..095c18b 100644 --- a/src/calculation_budget_constrains/service.py +++ b/src/calculation_budget_constrains/service.py @@ -7,41 +7,123 @@ from src.auth.service import CurrentUser from src.database.core import DbSession from src.scope_equipment.model import ScopeEquipment from src.scope_equipment.service import get_by_scope_name +from src.overhaul_activity.service import get_all_by_session_id +# async def get_all_budget_constrains( +# *, db_session: DbSession, session_id: str, cost_threshold: float = 100000000 +# ): + +# At the module level, add this dictionary to store persistent EAF values +_equipment_eaf_cache = {} + +import random async def get_all_budget_constrains( - *, db_session: DbSession, scope_name: str, cost_threshold: float = 100.0 + *, db_session: DbSession, session_id: str, cost_threshold: float = 100000000 ): """Get all overhaul overview with EAF values that sum to 100%.""" - equipments = await get_by_scope_name(db_session=db_session, scope_name=scope_name) + equipments = await get_all_by_session_id(db_session=db_session, overhaul_session_id=session_id) # If no equipments found, return empty list if not equipments: - return [] + return [], [] + + # Create or retrieve persistent EAF values + global _equipment_eaf_cache + + # Generate EAF values for new equipment IDs + equipment_ids = [equipment.id for equipment in equipments] + + # Generate new random EAF values if they don't exist + if not _equipment_eaf_cache or set(equipment_ids) != set(_equipment_eaf_cache.keys()): + total_eaf = 100.0 + remaining_items = len(equipment_ids) + + _equipment_eaf_cache.clear() + + # Ensure minimum EAF value for each equipment + min_eaf = 1.0 # Minimum 1% for each equipment + reserved_eaf = min_eaf * remaining_items + distributable_eaf = total_eaf - reserved_eaf + + for eq_id in equipment_ids[:-1]: # All except last item + if remaining_items > 1: + # Generate a random value between min_eaf and the remaining distributable EAF + max_allowed = distributable_eaf / (remaining_items - 1) + eaf = round(min_eaf + random.uniform(0, max_allowed), 2) + _equipment_eaf_cache[eq_id] = eaf + distributable_eaf -= (eaf - min_eaf) + remaining_items -= 1 + + # Assign remaining EAF to last item, ensuring it's at least min_eaf + _equipment_eaf_cache[equipment_ids[-1]] = round(distributable_eaf + min_eaf, 2) + # Create result array of dictionaries result = [ { "id": equipment.id, "assetnum": equipment.assetnum, - "location_tag": equipment.master_equipment.location_tag, - "name": equipment.master_equipment.name, - "total_cost": 1000000 + random.randint(10000, 5000000), + "location_tag": equipment.equipment.location_tag, + "name": equipment.equipment.name, + "total_cost": equipment.material_cost + equipment.service_cost, + "eaf_contribution": _equipment_eaf_cache[equipment.id] } for equipment in equipments ] - result.sort(key=lambda x: x["total_cost"], reverse=True) + # Sort by EAF contribution (highest to lowest) + result.sort(key=lambda x: x["eaf_contribution"], reverse=True) # Filter equipment up to threshold cumulative_cost = 0 - filtered_result = [] + included_results = [] for equipment in result: cumulative_cost += equipment["total_cost"] - if cumulative_cost >= cost_threshold: break + included_results.append(equipment) + + # Rest equipment is consequence list + consequence_results = result[len(included_results):] + + return included_results, consequence_results +# """Get all overhaul overview with EAF values that sum to 100%.""" +# # equipments = await get_by_scope_name(db_session=db_session, scope_name=scope_name) +# equipments = await get_all_by_session_id(db_session=db_session, overhaul_session_id=session_id) + +# # If no equipments found, return empty list +# if not equipments: +# return [] +# # Create result array of dictionaries +# result = [ +# { +# "id": equipment.id, +# "assetnum": equipment.assetnum, +# "location_tag": equipment.equipment.location_tag, +# "name": equipment.equipment.name, +# "total_cost": equipment.material_cost + equipment.service_cost +# "eaf_contribution": ## Create Dummy % number, each equipment has different value +# } +# for equipment in equipments +# ] + +# result.sort(key=lambda x: x["eaf_contribution"], reverse=True) #Sort from biggest contribution + +# # Filter equipment up to threshold +# cumulative_cost = 0 +# included_results = [] + +# for equipment in result: +# cumulative_cost += equipment["total_cost"] + +# if cumulative_cost >= cost_threshold: +# break + +# included_results.append(equipment) + +# # rest equipemnt is consequence list +# consequence_results = result[len(included_results):] - filtered_result.append(equipment) - return filtered_result +# return included_results ,consequence_results