fix minor

src/calculation_target_reliability/service.py

@@ -7,19 +7,20 @@ from src.database.core import DbSession
 from src.auth.service import CurrentUser
 from src.scope_equipment.model import ScopeEquipment
 from src.scope_equipment.service import get_by_scope_name
-
+from src.scope_equipment_job.service import get_equipment_level_by_no
 
 async def get_all_target_reliability(*, db_session: DbSession, scope_name: str, eaf_threshold: float = 100.0):
-    """Get all overhaul overview with EAF values that sum to 100%."""
+    """Get all overhaul overview with EAF values that sum to 100%, aggregated by system."""
     equipments = await get_by_scope_name(db_session=db_session, scope_name=scope_name)
-
+    equipment_system = await get_equipment_level_by_no(db_session=db_session, level=1)
+    equipment_subsystem = await get_equipment_level_by_no(db_session=db_session, level=2)
+    
     # If no equipments found, return empty list
     if not equipments:
         return []
 
     import random
 
-
     n = len(equipments)
     base_value = 100 / n  # Even distribution as base
     
@@ -39,23 +40,46 @@ async def get_all_target_reliability(*, db_session: DbSession, scope_name: str,
             'id': equipment.id,
             'assetnum': equipment.assetnum,
             'location_tag': equipment.master_equipment.location_tag,
-            'name' : equipment.master_equipment.name,
+            'name': equipment.master_equipment.name,
+            'parent_id': equipment.master_equipment.parent_id,  # Add parent_id to identify the system
             'eaf': round(eaf, 4)  # Add EAF value
         }
         for equipment, eaf in zip(equipments, eaf_values)
     ]
 
-    result.sort(key=lambda x: x['eaf'], reverse=True)
+    # Group equipment by system
+    sub_system = {subsystem.id: subsystem.parent_id for subsystem in equipment_subsystem}
+    systems = {system.id: {'name': system.name, 'total_eaf': 0, 'equipments': []} for system in equipment_system}
+    
+    for equipment in result:
+        if equipment['parent_id'] in sub_system:
+            systems[sub_system[equipment['parent_id']]]['equipments'].append(equipment)
+            systems[sub_system[equipment['parent_id']]]['total_eaf'] += equipment['eaf']
+            
+
+    # Convert the systems dictionary to a list of aggregated results
+    aggregated_result = [
+        {
+            'system_id': system_id,
+            'system_name': system_data['name'],
+            'total_eaf': round(system_data['total_eaf'], 4),
+            'equipments': system_data['equipments']
+        }
+        for system_id, system_data in systems.items()
+    ]
+
+    # Sort the aggregated result by total_eaf in descending order
+    aggregated_result.sort(key=lambda x: x['total_eaf'], reverse=True)
 
-    # Filter equipment up to threshold
+    # Filter systems up to the threshold
     cumulative_eaf = 0
-    filtered_result = []
+    filtered_aggregated_result = []
 
-    for equipment in result:
+    for system in aggregated_result:
-        cumulative_eaf += equipment['eaf']
+        cumulative_eaf += system['total_eaf']
-        filtered_result.append(equipment)
+        filtered_aggregated_result.append(system)
 
         if cumulative_eaf >= eaf_threshold:
             break
 
-    return filtered_result
+    return filtered_aggregated_result

src/scope_equipment/service.py

@@ -171,7 +171,9 @@ async def get_all_master_equipment(*, common: CommonParameters, scope_name):
 
 
 async def get_equipment_level_by_no(*, db_session: DbSession, level: int):
-    query = Select(MasterEquipmentTree).filter(
+    query = Select(MasterEquipment).join(MasterEquipment.equipment_tree).where(
         MasterEquipmentTree.level_no == level)
-    result = await db_session.scalar(query)
+    
-    return result
+    result = await db_session.execute(query)
+    return result.scalars().all()
+