update formula and top 10 remaining life

src/equipment/service.py

@@ -391,7 +391,7 @@ async def get_top_10_economic_life(*, db_session: DbSession, common) -> list[Equ
                     (current_year - Equipment.minimum_eac_year),
                 ),
                 else_=0,
-            ).label("economic_life")
+            ).label("remaining_life")
         )
         .filter(Equipment.minimum_eac_year != None)
         .filter((Equipment.minimum_eac != None) & (Equipment.minimum_eac != 0))
@@ -423,7 +423,7 @@ async def get_top_10_replacement_priorities(*, db_session: DbSession, common) ->
                     (current_year - Equipment.minimum_eac_year),
                 ),
                 else_=0,
-            ).label("economic_life")
+            ).label("remaining_life")
         )
         .filter(Equipment.minimum_eac_year != None)
         .filter((Equipment.minimum_eac != None) & (Equipment.minimum_eac != 0))

src/modules/equipment/Prediksi.py

@@ -101,9 +101,7 @@ class Prediksi:
                 raw_predictive_material_cost AS predictive_material_cost,
                 raw_predictive_labor_time AS predictive_labor_time,
                 raw_predictive_labor_human AS predictive_labor_human,
-                raw_predictive_interval AS predictive_interval,
+                raw_predictive_interval AS predictive_interval
-                "raw_loss_output_MW" AS loss_output_mw,
-                raw_loss_output_price AS loss_price
             FROM lcc_equipment_tr_data
             WHERE assetnum = %s
             and is_actual=1
@@ -199,10 +197,9 @@ class Prediksi:
                 raw_pm_material_cost, raw_pm_labor_time, raw_pm_labor_human,
                 raw_oh_interval, raw_oh_material_cost, raw_oh_labor_time, raw_oh_labor_human,
                 raw_predictive_interval, raw_predictive_material_cost, raw_predictive_labor_time, raw_predictive_labor_human,
-                "raw_loss_output_MW", raw_loss_output_price
+                 created_by, created_at
-                , created_by, created_at
             ) VALUES (
-                %s, %s, 0, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'Sys', NOW()
+                %s, %s, 0, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'Sys', NOW()
             )
             """
 
@@ -431,112 +428,6 @@ class Prediksi:
             if connection:
                 connection.close()
 
-    # Fungsi untuk mengambil labour cost
-    def __get_labour_cost(self, equipment_id, worktype, existing_connection=None):
-        """Return labour cost totals per tahun for the given worktype."""
-        labour_costs = {}
-        connection = existing_connection
-        cursor = None
-        close_connection = False
-
-        try:
-            if connection is None:
-                connections = get_production_connection()
-                connection = connections[0] if isinstance(connections, tuple) else connections
-                close_connection = True
-
-            if connection is None:
-                print("Database connection failed.")
-                return labour_costs
-
-            cursor = connection.cursor()
-
-            worktype_upper = (worktype or "").upper()
-            worktype_condition = "AND a.worktype IN ('CM', 'PROACTIVE', 'WA')"
-            params = [equipment_id]
-
-            if worktype_upper != "CM":
-                worktype_condition = "AND a.worktype = %s"
-                params.append(worktype_upper)
-
-            exclude_condition = "AND a.wojp8 != 'S1'" if worktype_upper == "CM" else ""
-
-            query = f"""
-            SELECT
-                EXTRACT(YEAR FROM x.reportdate)::int AS tahun,
-                SUM(x.upah_per_wonum) AS total_upah_per_tahun
-            FROM (
-                SELECT
-                    bw.wonum,
-                    bw.reportdate,
-                    bw.jumlah_jam_kerja,
-                    CASE
-                        WHEN COUNT(b.laborcode) FILTER (WHERE b.laborcode IS NOT NULL) > 0 THEN
-                            SUM(
-                                COALESCE(emp_cost.salary_per_hour_idr,
-                                        (SELECT salary_per_hour_idr FROM lcc_manpower_cost WHERE UPPER(staff_job_level) = UPPER('Junior') LIMIT 1))
-                                * bw.jumlah_jam_kerja
-                            )
-                        ELSE
-                            3 * (SELECT salary_per_hour_idr FROM lcc_manpower_cost WHERE UPPER(staff_job_level) = UPPER('Junior') LIMIT 1) * bw.jumlah_jam_kerja
-                    END AS upah_per_wonum
-                FROM (
-                    SELECT
-                        a.wonum,
-                        a.reportdate,
-                        CASE
-                            WHEN (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) = 0
-                                THEN 1
-                            ELSE (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0)
-                        END AS jumlah_jam_kerja
-                    FROM public.wo_maximo a
-                    WHERE
-                        a.asset_unit = '3'
-                        AND a.wonum NOT LIKE 'T%'
-                        AND a.asset_assetnum = %s
-                        AND (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) <= 730
-                        {worktype_condition}
-                        {exclude_condition}
-                ) bw
-                LEFT JOIN public.wo_maximo_labtrans b ON b.wonum = bw.wonum
-                LEFT JOIN lcc_ms_manpower emp ON UPPER(TRIM(emp."ID Number")) = UPPER(TRIM(b.laborcode))
-                LEFT JOIN lcc_manpower_cost emp_cost ON UPPER(TRIM(emp_cost.staff_job_level)) = UPPER(TRIM(emp."Position"))
-                GROUP BY bw.wonum, bw.reportdate, bw.jumlah_jam_kerja
-            ) x
-            GROUP BY 1
-            ORDER BY 1;
-            """
-
-            cursor.execute(query, tuple(params))
-            rows = cursor.fetchall()
-            for tahun, total in rows:
-                try:
-                    year_int = int(tahun) if tahun is not None else None
-                except (TypeError, ValueError):
-                    year_int = None
-                if year_int is None:
-                    continue
-                try:
-                    labour_costs[year_int] = float(total) if total is not None else 0.0
-                except (TypeError, ValueError):
-                    labour_costs[year_int] = 0.0
-
-            return labour_costs
-        except Exception as e:
-            print(f"Error saat mendapatkan labour cost dari database: {e}")
-            return labour_costs
-        finally:
-            if cursor:
-                try:
-                    cursor.close()
-                except Exception:
-                    pass
-            if close_connection and connection:
-                try:
-                    connection.close()
-                except Exception:
-                    pass
-
 
     # Fungsi untuk menghapus data proyeksi pada tahun tertentu
     def __update_data_lcc(self, equipment_id):
@@ -555,27 +446,14 @@ class Prediksi:
 
             cursor = connection.cursor(cursor_factory=DictCursor)
 
-            labour_cost_maps = {
-                "CM": self.__get_labour_cost(equipment_id, "CM", production_connection),
-                "PM": self.__get_labour_cost(equipment_id, "PM", production_connection),
-                "PDM": self.__get_labour_cost(equipment_id, "PDM", production_connection),
-                "OH": self.__get_labour_cost(equipment_id, "OH", production_connection),
-            }
-            cm_labour_costs = labour_cost_maps.get("CM", {}) or {}
-            pm_labour_costs = labour_cost_maps.get("PM", {}) or {}
-            pdm_labour_costs = labour_cost_maps.get("PDM", {}) or {}
-            oh_labour_costs = labour_cost_maps.get("OH", {}) or {}
-
             # Ambil semua baris untuk assetnum
             select_q = '''
             SELECT id, seq, tahun,
-                raw_cm_interval, raw_cm_material_cost, raw_cm_labor_time, raw_cm_labor_human,
+                raw_cm_interval, raw_cm_material_cost, rc_cm_labor_cost,
-                raw_pm_interval, raw_pm_material_cost, raw_pm_labor_time, raw_pm_labor_human,
+                raw_pm_interval, raw_pm_material_cost, rc_pm_labor_cost,
-                raw_predictive_interval, raw_predictive_material_cost, raw_predictive_labor_time, raw_predictive_labor_human,
+                raw_predictive_interval, raw_predictive_material_cost, rc_predictive_labor_cost,
-                raw_oh_interval, raw_oh_material_cost, raw_oh_labor_time, raw_oh_labor_human,
+                raw_oh_interval, raw_oh_material_cost, rc_oh_labor_cost,
-                raw_predictive_interval, raw_predictive_material_cost, raw_predictive_labor_time, raw_predictive_labor_human,
+                raw_predictive_interval, raw_predictive_material_cost, rc_predictive_labor_cost,
-                "raw_loss_output_MW" as raw_loss_output_mw, raw_loss_output_price,
-                raw_operational_cost, raw_maintenance_cost,
                 efdh_equivalent_forced_derated_hours, foh_forced_outage_hours
             FROM lcc_equipment_tr_data
             WHERE assetnum = %s;
@@ -623,30 +501,12 @@ class Prediksi:
 
                     seq = int(r.get("seq") or 0) if isinstance(r, dict) else int(r[1] or 0)
 
-                    raw_cm_interval = float(r.get("raw_cm_interval") or 0.0)
-                    raw_cm_labor_time = float(r.get("raw_cm_labor_time") or 0.0)
-                    raw_cm_labor_human = float(r.get("raw_cm_labor_human") or 0.0)
 
-                    raw_pm_interval = float(r.get("raw_pm_interval") or 0.0)
-                    raw_pm_material_cost = float(r.get("raw_pm_material_cost") or 0.0)
-                    raw_pm_labor_time = float(r.get("raw_pm_labor_time") or 0.0)
-                    raw_pm_labor_human = float(r.get("raw_pm_labor_human") or 0.0)
 
-                    raw_predictive_interval = float(r.get("raw_predictive_interval") or 0.0)
+                    raw_pm_material_cost = float(r.get("raw_pm_material_cost") or 0.0)
                     raw_predictive_material_cost = float(r.get("raw_predictive_material_cost") or 0.0)
-                    raw_predictive_labor_time = float(r.get("raw_predictive_labor_time") or 0.0)
-                    raw_predictive_labor_human = float(r.get("raw_predictive_labor_human") or 0.0)
-
-                    raw_oh_interval = float(r.get("raw_oh_interval") or 0.0)
                     raw_oh_material_cost = float(r.get("raw_oh_material_cost") or 0.0)
-                    raw_oh_labor_time = float(r.get("raw_oh_labor_time") or 0.0)
-                    raw_oh_labor_human = float(r.get("raw_oh_labor_human") or 0.0)
-
-                    # raw_loss_output_mw = float(r.get("raw_loss_output_mw") or 0.0)
-                    # raw_loss_output_price = float(r.get("raw_loss_output_price") or 0.0)
 
-                    # raw_operational_cost = float(r.get("raw_operational_cost") or 0.0)
-                    # raw_maintenance_cost = float(r.get("raw_maintenance_cost") or 0.0)
                     efdh_equivalent_forced_derated_hours = float(r.get("efdh_equivalent_forced_derated_hours") or 0.0)
                     foh_forced_outage_hours = float(r.get("foh_forced_outage_hours") or 0.0)
 
@@ -654,13 +514,10 @@ class Prediksi:
 
                     # compute per-column costs using helpers
                     rc_cm_material = rc_cm_material_cost
-                    rc_cm_labor = rc_labor_cost(raw_cm_interval, raw_cm_labor_time, raw_cm_labor_human, man_hour)
+                    rc_cm_labor = float(r.get("rc_cm_labor_cost") or 0.0)
-                    cm_labor_total = cm_labour_costs.get(yr)
+                    rc_pm_labor = float(r.get("rc_pm_labor_cost") or 0.0)
-                    if cm_labor_total is not None:
+                    rc_predictive_labor = float(r.get("rc_predictive_labor_cost") or 0.0)
-                        try:
+                    rc_oh_labor = float(r.get("rc_oh_labor_cost") or 0.0)
-                            rc_cm_labor = float(cm_labor_total)
-                        except (TypeError, ValueError):
-                            rc_cm_labor = 0.0
 
                     try:
                         # if np.isfinite(raw_pm_interval) and raw_pm_interval != 0:
@@ -669,13 +526,7 @@ class Prediksi:
                         rc_pm_material = raw_pm_material_cost
                     except Exception:
                         rc_pm_material = 0.0
-                    rc_pm_labor = rc_labor_cost(raw_pm_interval, raw_pm_labor_time, raw_pm_labor_human, man_hour)
+
-                    pm_labor_total = pm_labour_costs.get(yr)
-                    if pm_labor_total is not None:
-                        try:
-                            rc_pm_labor = float(pm_labor_total)
-                        except (TypeError, ValueError):
-                            rc_pm_labor = 0.0
 
                     try:
                         # if np.isfinite(raw_predictive_interval) and raw_predictive_interval != 0:
@@ -685,31 +536,7 @@ class Prediksi:
                     except Exception:
                         rc_predictive_material = 0.0
 
-                    rc_predictive_labor = raw_predictive_labor_human
-                    try:
-                        rc_predictive_labor = rc_labor_cost(raw_predictive_interval, raw_predictive_labor_time, raw_predictive_labor_human, man_hour)
-                    except Exception:
-                        rc_predictive_labor = 0.0
-                    predictive_labor_total = pdm_labour_costs.get(yr)
-                    if predictive_labor_total is not None:
-                        try:
-                            rc_predictive_labor = float(predictive_labor_total)
-                        except (TypeError, ValueError):
-                            rc_predictive_labor = 0.0
-
                     rc_oh_material = raw_oh_material_cost
-                    rc_oh_labor = rc_labor_cost(raw_oh_interval, raw_oh_labor_time, raw_oh_labor_human, man_hour)
-                    oh_labor_total = oh_labour_costs.get(yr)
-                    if oh_labor_total is not None:
-                        try:
-                            rc_oh_labor = float(oh_labor_total)
-                        except (TypeError, ValueError):
-                            rc_oh_labor = 0.0
-
-                    # rc_lost = rc_lost_cost(raw_loss_output_mw, raw_loss_output_price, raw_cm_interval)
-
-                    # rc_operation = raw_operational_cost
-                    # rc_maintenance = raw_maintenance_cost
 
                     asset_criticality_data = self.__get_asset_criticality_params(equipment_id)
                     asset_criticality_value = 0.0
@@ -734,9 +561,6 @@ class Prediksi:
                         rc_pm=rc_pm_material + rc_pm_labor + ac_multiplier,
                         rc_predictive=rc_predictive_material + rc_predictive_labor + ac_multiplier,
                         rc_oh=rc_oh_material + rc_oh_labor + ac_multiplier,
-                        # rc_lost=rc_lost,
-                        # rc_operation=rc_operation,
-                        # rc_maintenance=rc_maintenance,
                     )
 
                     id_val = r.get("id") if isinstance(r, dict) else r[0]
@@ -752,9 +576,6 @@ class Prediksi:
                             rc_predictive_labor,
                             rc_oh_material,
                             rc_oh_labor,
-                            # rc_lost,
-                            # rc_operation,
-                            # rc_maintenance,
                             total,
                             id_val,
                         ),

src/modules/equipment/insert_actual_data.py

@@ -150,78 +150,90 @@ def get_labour_cost_totals(cursor, assetnum: str, worktype: str) -> dict:
     if not assetnum or not worktype:
         return {}
 
-    worktype_condition = "AND a.worktype IN ('CM', 'PROACTIVE', 'WA')"
-    worktype_params = [assetnum]
-
-    if worktype.upper() != "CM":
-        worktype_condition = "AND a.worktype = %s"
-        worktype_params.append(worktype.upper())
-
-    exclude_condition = "AND a.wojp8 != 'S1'" if worktype.upper() == "CM" else ""
-
     query = f"""
+SELECT
+    EXTRACT(YEAR FROM x.reportdate)::int AS tahun,
+    SUM(x.upah_per_wonum) AS total_upah_per_tahun
+FROM (
     SELECT
-        EXTRACT(YEAR FROM x.reportdate)::int AS tahun,
+        bw.wonum,
-        SUM(x.upah_per_wonum) AS total_upah_per_tahun
+        bw.reportdate,
+        bw.jumlah_jam_kerja,
+        CASE
+            WHEN COUNT(b.laborcode) FILTER (WHERE b.laborcode IS NOT NULL) > 0 THEN
+                SUM(
+                    COALESCE(emp_cost.salary_per_hour_idr, (select salary_per_hour_idr from lcc_manpower_cost where upper(staff_job_level)= upper('Junior') limit 1))
+                    * bw.jumlah_jam_kerja
+                )
+            ELSE
+                3 * (select salary_per_hour_idr from lcc_manpower_cost where upper(staff_job_level)= upper('Junior') limit 1) * bw.jumlah_jam_kerja
+        END AS upah_per_wonum
     FROM (
         SELECT
-            bw.wonum,
+            a.wonum,
-            bw.reportdate,
+            a.reportdate,
-            bw.jumlah_jam_kerja,
             CASE
-                WHEN COUNT(b.laborcode) FILTER (WHERE b.laborcode IS NOT NULL) > 0 THEN
+                WHEN (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) = 0
-                    SUM(
+                    THEN 1
-                        COALESCE(emp_cost.salary_per_hour_idr,
+                ELSE (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0)
-                                (SELECT salary_per_hour_idr FROM lcc_manpower_cost WHERE UPPER(staff_job_level) = UPPER('Junior') LIMIT 1))
+            END AS jumlah_jam_kerja
-                        * bw.jumlah_jam_kerja
+
-                    )
+        FROM public.wo_maximo a
-                ELSE
+        WHERE
-                    3 * (SELECT salary_per_hour_idr FROM lcc_manpower_cost WHERE UPPER(staff_job_level) = UPPER('Junior') LIMIT 1) * bw.jumlah_jam_kerja
+            a.asset_unit = '3'
-            END AS upah_per_wonum
+            AND a.wonum NOT LIKE 'T%'
-        FROM (
+            AND a.asset_assetnum = '{assetnum}'
-            SELECT
+            AND (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) <= 730
-                a.wonum,
+            AND a.worktype = '{worktype}'
-                a.reportdate,
+            AND (
-                CASE
+		        a.description NOT ILIKE '%U4%'
-                    WHEN (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) = 0
+		     OR (
-                        THEN 1
+		            a.description ILIKE '%U3%'
-                    ELSE (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0)
+		        AND a.description ILIKE '%U4%'
-                END AS jumlah_jam_kerja
+		        )
-            FROM public.wo_maximo a
+		    )
-            WHERE
+    ) bw
-                a.asset_unit = '3'
+    LEFT JOIN public.wo_maximo_labtrans b
-                AND a.wonum NOT LIKE 'T%'
+        ON b.wonum = bw.wonum
-                AND a.asset_assetnum = %s
+    LEFT JOIN lcc_ms_manpower emp
-                AND (EXTRACT(EPOCH FROM (a.actfinish - a.actstart)) / 3600.0) <= 730
+        ON UPPER(TRIM(emp."ID Number")) = UPPER(TRIM(b.laborcode))
-                {worktype_condition}
+    LEFT JOIN lcc_manpower_cost emp_cost
-                {exclude_condition}
+        ON UPPER(TRIM(emp_cost.staff_job_level)) = UPPER(TRIM(emp."Position"))
-        ) bw
+    GROUP BY
-        LEFT JOIN public.wo_maximo_labtrans b ON b.wonum = bw.wonum
+        bw.wonum, bw.reportdate, bw.jumlah_jam_kerja
-        LEFT JOIN lcc_ms_manpower emp ON UPPER(TRIM(emp."ID Number")) = UPPER(TRIM(b.laborcode))
+) x
-        LEFT JOIN lcc_manpower_cost emp_cost ON UPPER(TRIM(emp_cost.staff_job_level)) = UPPER(TRIM(emp."Position"))
+GROUP BY 1
-        GROUP BY bw.wonum, bw.reportdate, bw.jumlah_jam_kerja
+ORDER BY 1;
-    ) x
-    GROUP BY 1
-    ORDER BY 1;
     """
 
     try:
-        cursor.execute(query, tuple(worktype_params))
+        cursor.execute(query)
         rows = cursor.fetchall()
     except Exception as exc:
         print(f"Error fetching labour cost for {assetnum} ({worktype}): {exc}")
         return {}
 
     labour_costs = {}
-    for tahun, total in rows:
+    for row in rows:
+        if isinstance(row, dict):
+            tahun_value = row.get("tahun")
+            total_value = row.get("total_upah_per_tahun")
+        else:
+            try:
+                tahun_value, total_value = row[0], row[1]
+            except (IndexError, TypeError):
+                continue
+
         try:
-            year_int = int(tahun) if tahun is not None else None
+            year_int = int(tahun_value) if tahun_value is not None else None
         except (TypeError, ValueError):
             year_int = None
+
         if year_int is None:
             continue
+
         try:
-            labour_costs[year_int] = float(total) if total is not None else 0.0
+            labour_costs[year_int] = float(total_value) if total_value is not None else 0.0
         except (TypeError, ValueError):
             labour_costs[year_int] = 0.0
 
@@ -331,8 +343,6 @@ def _build_tr_row_values(
             "raw_predictive_material_cost": 0,
             "raw_predictive_labor_time": 0,
             "raw_predictive_labor_human": 0,
-            "raw_loss_output_MW": 0,
-            "raw_loss_output_price": 0,
             "rc_cm_material_cost": 0,
             "rc_cm_labor_cost": 0,
             "rc_pm_material_cost": 0,
@@ -371,17 +381,6 @@ def _build_tr_row_values(
         data_predictive_row, "raw_predictive_labor_human"
     )
 
-    # raw_loss_output_MW = (
-    #     data_tahunan_row.get("total_lost")
-    #     if data_tahunan_row and data_tahunan_row.get("total_lost") is not None
-    #     else 0
-    # )
-    # raw_loss_output_price = (
-    #     data_tahunan_row.get("rp_per_kwh")
-    #     if data_tahunan_row and data_tahunan_row.get("rp_per_kwh") is not None
-    #     else 0
-    # )
-
     man_hour_value = (
         data_tahunan_row.get("man_hour")
         if data_tahunan_row and data_tahunan_row.get("man_hour") is not None
@@ -389,48 +388,48 @@ def _build_tr_row_values(
     )
 
     rc_cm_material_cost = raw_cm_material_cost_total
-    rc_cm_labor_cost = (
+    # rc_cm_labor_cost = (
-        data_cm_row.get("raw_cm_labor_time")
+    #     data_cm_row.get("raw_cm_labor_time")
-        * data_cm_row.get("rc_cm_labor_human")
+    #     * data_cm_row.get("rc_cm_labor_human")
-        * man_hour_value
+    #     * man_hour_value
-        if data_cm_row
+    #     if data_cm_row
-        and data_cm_row.get("rc_cm_labor_cost")
+    #     and data_cm_row.get("rc_cm_labor_cost")
-        and data_cm_row.get("rc_cm_labor_human")
+    #     and data_cm_row.get("rc_cm_labor_human")
-        and man_hour_value is not None
+    #     and man_hour_value is not None
-        else 0
+    #     else 0
-    )
+    # )
 
     rc_pm_material_cost = raw_pm_material_cost
-    rc_pm_labor_cost = (
+    # rc_pm_labor_cost = (
-        data_pm_row.get("raw_pm_labor_time")
+    #     data_pm_row.get("raw_pm_labor_time")
-        * data_pm_row.get("rc_pm_labor_human")
+    #     * data_pm_row.get("rc_pm_labor_human")
-        * man_hour_value
+    #     * man_hour_value
-        if data_pm_row
+    #     if data_pm_row
-        and data_pm_row.get("rc_pm_labor_cost")
+    #     and data_pm_row.get("rc_pm_labor_cost")
-        and data_pm_row.get("rc_pm_labor_human")
+    #     and data_pm_row.get("rc_pm_labor_human")
-        and man_hour_value is not None
+    #     and man_hour_value is not None
-        else 0
+    #     else 0
-    )
+    # )
 
     rc_oh_material_cost = raw_oh_material_cost
-    rc_oh_labor_cost = (
+    # rc_oh_labor_cost = (
-        data_oh_row.get("raw_oh_labor_time")
+    #     data_oh_row.get("raw_oh_labor_time")
-        * data_oh_row.get("rc_oh_labor_human")
+    #     * data_oh_row.get("rc_oh_labor_human")
-        * man_hour_value
+    #     * man_hour_value
-        if data_oh_row
+    #     if data_oh_row
-        and data_oh_row.get("rc_oh_labor_cost")
+    #     and data_oh_row.get("rc_oh_labor_cost")
-        and data_oh_row.get("rc_oh_labor_human")
+    #     and data_oh_row.get("rc_oh_labor_human")
-        and man_hour_value is not None
+    #     and man_hour_value is not None
-        else 0
+    #     else 0
-    )
+    # )
 
-    rc_predictive_labor_cost = (
+    # rc_predictive_labor_cost = (
-        data_predictive_row.get("raw_predictive_labor_human") * man_hour_value
+    #     data_predictive_row.get("raw_predictive_labor_human") * man_hour_value
-        if data_predictive_row
+    #     if data_predictive_row
-        and data_predictive_row.get("rc_predictive_labor_cost")
+    #     and data_predictive_row.get("rc_predictive_labor_cost")
-        and man_hour_value is not None
+    #     and man_hour_value is not None
-        else 0
+    #     else 0
-    )
+    # )
 
     if labour_cost_lookup and year is not None:
         cm_lookup = labour_cost_lookup.get("CM", {})
@@ -442,27 +441,10 @@ def _build_tr_row_values(
         pm_value = pm_lookup.get(year)
         oh_value = oh_lookup.get(year)
         pdm_value = pdm_lookup.get(year)
-
+        rc_cm_labor_cost = float(cm_value) if cm_value is not None else 0.0
-        if cm_value is not None:
+        rc_pm_labor_cost = float(pm_value) if pm_value is not None else 0.0
-            try:
+        rc_oh_labor_cost = float(oh_value) if oh_value is not None else 0.0
-                rc_cm_labor_cost = float(cm_value)
+        rc_predictive_labor_cost = float(pdm_value) if pdm_value is not None else 0.0
-            except (TypeError, ValueError):
-                rc_cm_labor_cost = 0.0
-        if pm_value is not None:
-            try:
-                rc_pm_labor_cost = float(pm_value)
-            except (TypeError, ValueError):
-                rc_pm_labor_cost = 0.0
-        if oh_value is not None:
-            try:
-                rc_oh_labor_cost = float(oh_value)
-            except (TypeError, ValueError):
-                rc_oh_labor_cost = 0.0
-        if pdm_value is not None:
-            try:
-                rc_predictive_labor_cost = float(pdm_value)
-            except (TypeError, ValueError):
-                rc_predictive_labor_cost = 0.0
 
     return {
         "raw_cm_interval": raw_cm_interval,
@@ -481,8 +463,6 @@ def _build_tr_row_values(
         "raw_predictive_material_cost": raw_pdm_material_cost,
         "raw_predictive_labor_time": raw_pdm_labor_time,
         "raw_predictive_labor_human": raw_pdm_labor_human,
-        # "raw_loss_output_MW": raw_loss_output_MW,
-        # "raw_loss_output_price": raw_loss_output_price,
         "rc_cm_material_cost": rc_cm_material_cost,
         "rc_cm_labor_cost": rc_cm_labor_cost,
         "rc_pm_material_cost": rc_pm_material_cost,
@@ -931,7 +911,6 @@ async def query_data():
                 raw_pm_interval, raw_pm_material_cost, raw_pm_labor_time, raw_pm_labor_human,
                 raw_oh_interval, raw_oh_material_cost, raw_oh_labor_time, raw_oh_labor_human,
                 raw_predictive_interval, raw_predictive_material_cost, raw_predictive_labor_time, raw_predictive_labor_human,
-                "raw_loss_output_MW", raw_loss_output_price,
                 "rc_cm_material_cost", "rc_cm_labor_cost",
                 "rc_pm_material_cost", "rc_pm_labor_cost",
                 "rc_oh_material_cost", "rc_oh_labor_cost",
@@ -946,7 +925,6 @@ async def query_data():
                 %s, %s,
                 %s, %s,
                 %s, %s,
-                %s, %s,
                 %s,
                 'Sys', NOW()
             )
@@ -972,8 +950,6 @@ async def query_data():
                 raw_predictive_material_cost = %s,
                 raw_predictive_labor_time = %s,
                 raw_predictive_labor_human = %s,
-                "raw_loss_output_MW" = %s,
-                raw_loss_output_price = %s,
                 "rc_cm_material_cost" = %s,
                 "rc_cm_labor_cost" = %s,
                 "rc_pm_material_cost" = %s,
@@ -1114,8 +1090,6 @@ async def query_data():
                             row_values["raw_predictive_material_cost"],
                             row_values["raw_predictive_labor_time"],
                             row_values["raw_predictive_labor_human"],
-                            row_values["raw_loss_output_MW"],
-                            row_values["raw_loss_output_price"],
                             row_values["rc_cm_material_cost"],
                             row_values["rc_cm_labor_cost"],
                             row_values["rc_pm_material_cost"],
@@ -1149,8 +1123,6 @@ async def query_data():
                             row_values["raw_predictive_material_cost"],
                             row_values["raw_predictive_labor_time"],
                             row_values["raw_predictive_labor_human"],
-                            row_values["raw_loss_output_MW"],
-                            row_values["raw_loss_output_price"],
                             row_values["rc_cm_material_cost"],
                             row_values["rc_cm_labor_cost"],
                             row_values["rc_pm_material_cost"],
@@ -1162,6 +1134,8 @@ async def query_data():
                             year,
                         ),
                     )
+                    inserted_this_asset += 1
+                    total_inserted += 1
                 seq = seq + 1
 
             # commit per asset to persist progress and free transaction

src/modules/equipment/run.py

@@ -22,12 +22,6 @@ async def main():
     except Exception as e:
         print(f"Error in query_data: {str(e)}")
         return
-
-    try:
-        await insert_acquisition_cost_data()
-    except Exception as e:
-        print(f"Error in insert_acquisition_cost_data: {str(e)}")
-        return
     
     try:
         await predict_run()

src/modules/plant/run2.py

@@ -349,9 +349,31 @@ def main():
                 revenue_c = price_c * production_netto * 1000 / 1000000
                 revenue_d = price_d * production_netto * 1000 / 1000000
                 cost_c_fuel = fuel_consumption * harga_bahan_bakar / 1000000
-                cost_bd_om = cost_bd_om  # last value
+                # Linear prediction for cost_bd_om, cost_bd_pm_nonmi, cost_bd_bd
-                cost_bd_pm_nonmi = cost_bd_pm_nonmi  # last value
+                # Use last 2 actual values to predict next value (simple linear extrapolation)
-                cost_bd_bd = cost_bd_bd  # last value
+                def linear_predict(last_vals):
+                    if len(last_vals) >= 2:
+                        return last_vals[-1] + (last_vals[-1] - last_vals[-2])
+                    elif len(last_vals) == 1:
+                        return last_vals[-1]
+                    else:
+                        return 0
+
+                # Collect actual values up to now
+                if not hasattr(main, "_cost_bd_om_actuals"):
+                    main._cost_bd_om_actuals = []
+                    main._cost_bd_pm_nonmi_actuals = []
+                    main._cost_bd_bd_actuals = []
+
+                # If actual, append to history
+                if data["is_actual"] == 1:
+                    main._cost_bd_om_actuals.append(cost_bd_om)
+                    main._cost_bd_pm_nonmi_actuals.append(cost_bd_pm_nonmi)
+                    main._cost_bd_bd_actuals.append(cost_bd_bd)
+                else:
+                    cost_bd_om = linear_predict(main._cost_bd_om_actuals)
+                    cost_bd_pm_nonmi = linear_predict(main._cost_bd_pm_nonmi_actuals)
+                    cost_bd_bd = linear_predict(main._cost_bd_bd_actuals)
 
             net_capacity_factor = net_capacity_factor_v
             eaf = eaf_v