Refactor notification handling in Workers: Centralize notification insertion and frontend updates by replacing direct SQL queries with dedicated functions. This improves code maintainability and reduces redundancy across character creation, events, and transport processing.

src/worker/transport.rs

@@ -1,6 +1,7 @@
 use crate::db::{ConnectionPool, DbError};
 use crate::message_broker::MessageBroker;
 use std::cmp::min;
+use std::collections::HashSet;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -14,7 +15,11 @@ use crate::worker::sql::{
     QUERY_DELETE_TRANSPORT,
     QUERY_GET_BRANCH_REGION,
     QUERY_UPDATE_TRANSPORT_SIZE,
+    QUERY_GET_BROKEN_VEHICLES,
+    QUERY_DELETE_TRANSPORTS_BY_VEHICLE,
+    QUERY_DELETE_VEHICLE,
 };
+use crate::worker::{insert_notification_conn, publish_update_status};
 #[derive(Debug, Clone)]
 struct ArrivedTransport {
     id: i32,
@@ -46,11 +51,24 @@ impl TransportWorker {
     }
 
     fn run_loop(pool: ConnectionPool, broker: MessageBroker, state: Arc<WorkerState>) {
+        let mut last_vehicle_check: Option<Instant> = None;
         while state.running_worker.load(Ordering::Relaxed) {
             if let Err(err) = Self::process_arrived_transports(&pool, &broker) {
                 eprintln!("[TransportWorker] Fehler in process_arrived_transports: {err}");
             }
 
+            // Stündlich Fahrzeuge prüfen (condition==0 => löschen + Notification)
+            let now = Instant::now();
+            let should_vehicle_check = last_vehicle_check
+                .map(|t| now.saturating_duration_since(t) >= Duration::from_secs(3600))
+                .unwrap_or(true);
+            if should_vehicle_check {
+                if let Err(err) = Self::cleanup_broken_vehicles(&pool, &broker) {
+                    eprintln!("[TransportWorker] Fehler in cleanup_broken_vehicles: {err}");
+                }
+                last_vehicle_check = Some(now);
+            }
+
             // Minütlich prüfen (nicht sekündlich pollen)
             for _ in 0..60 {
                 if !state.running_worker.load(Ordering::Relaxed) {
@@ -61,6 +79,86 @@ impl TransportWorker {
         }
     }
 
+    fn cleanup_broken_vehicles(
+        pool: &ConnectionPool,
+        broker: &MessageBroker,
+    ) -> Result<(), DbError> {
+        let mut conn = pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_broken_vehicles", QUERY_GET_BROKEN_VEHICLES)?;
+        conn.prepare(
+            "delete_transports_by_vehicle",
+            QUERY_DELETE_TRANSPORTS_BY_VEHICLE,
+        )?;
+        conn.prepare("delete_vehicle", QUERY_DELETE_VEHICLE)?;
+
+        let rows = conn.execute("get_broken_vehicles", &[])?;
+        if rows.is_empty() {
+            return Ok(());
+        }
+
+        let mut affected_users: HashSet<i32> = HashSet::new();
+        let mut deleted_count = 0usize;
+
+        for row in rows {
+            let vehicle_id = parse_i32(&row, "vehicle_id", -1);
+            let user_id = parse_i32(&row, "user_id", -1);
+            if vehicle_id < 0 || user_id < 0 {
+                continue;
+            }
+
+            // 1) Laufende/alte Transporte des Fahrzeugs entfernen (falls vorhanden),
+            //    damit das Löschen des Fahrzeugs nicht an FK-Constraints scheitert.
+            if let Err(err) = conn.execute("delete_transports_by_vehicle", &[&vehicle_id]) {
+                eprintln!(
+                    "[TransportWorker] Fehler beim Löschen von Transporten für vehicle_id={}: {}",
+                    vehicle_id, err
+                );
+                // weiter versuchen: evtl. existieren keine oder keine Constraints
+            }
+
+            // 2) Fahrzeug löschen
+            if let Err(err) = conn.execute("delete_vehicle", &[&vehicle_id]) {
+                eprintln!(
+                    "[TransportWorker] Fehler beim Löschen von vehicle_id={}: {}",
+                    vehicle_id, err
+                );
+                continue;
+            }
+
+            // 3) Notification an Besitzer (DB)
+            let tr = format!(
+                r#"{{"tr":"vehicle_destroyed","vehicle_id":{}}}"#,
+                vehicle_id
+            );
+            if let Err(err) = insert_notification_conn(&mut conn, user_id, &tr, None) {
+                eprintln!(
+                    "[TransportWorker] Fehler beim Schreiben der Vehicle-Notification (user_id={}, vehicle_id={}): {}",
+                    user_id, vehicle_id, err
+                );
+            }
+
+            affected_users.insert(user_id);
+            deleted_count += 1;
+        }
+
+        if deleted_count > 0 {
+            eprintln!(
+                "[TransportWorker] {} Fahrzeug(e) mit condition=0 gelöscht",
+                deleted_count
+            );
+        }
+
+        // 4) Frontend informieren: Branches/Status neu laden
+        for user_id in affected_users {
+            publish_update_status(broker, user_id);
+        }
+
+        Ok(())
+    }
+
     fn process_arrived_transports(
         pool: &ConnectionPool,
         broker: &MessageBroker,