chore: update dependencies and improve presence handling[latest]

Author: shenjinti

Cargo.toml

@@ -141,7 +141,7 @@ toml_edit = { version = "0.25.12", features = ["serde"] }
 rand = "0.10.1"
 chrono = { version = "0.4", features = ["serde"] }
 chrono-tz = "0.10.4"
-rsipstack = "0.5.15"
+rsipstack = "0.5.16"
 hex = { version = "0.4.3", optional = true }
 #rsipstack = { path = "../rsipstack" }
 audio-codec = "0.3.39"
@@ -248,7 +248,7 @@ ldap3 = { version = "0.12.1", optional = true }
 ring = { version = "0.17", optional = true }
 tempfile = "3.27.0"
 country-emoji = { version = "0.3.5", optional = true }
-flowdb = { version = "0.7.2", default-features = false }
+flowdb = { version = "0.7.4", default-features = false }
 
 
 [dev-dependencies]

src/addons/cc

@@ -606,6 +606,16 @@ impl EntryAction {
     pub fn is_dtmf_menu(&self) -> bool {
         matches!(self, EntryAction::DtmfMenu { .. })
     }
+
+    pub fn is_interruptible(&self) -> bool {
+        matches!(
+            self,
+            EntryAction::Prompt {
+                interruptible: true,
+                ..
+            }
+        )
+    }
 }
 
 #[cfg(test)]

src/call/app/ivr/config.rs

@@ -645,6 +645,8 @@ impl StepIvrApp {
         if let ActionResult::WaitFor(WaitEvent::AudioComplete { .. }) = &result {
             if node.action.is_dtmf_menu() {
                 self.pending_menu = Some(self.build_pending_menu(&node.action));
+            } else if node.action.is_interruptible() {
+                self.interrupt_on_dtmf = true;
             }
         }
         if matches!(&result, ActionResult::WaitFor(WaitEvent::NoAudio)) {
@@ -1801,6 +1803,62 @@ mod tests {
             .await;
     }
 
+    /// Regression: DTMF during an *interruptible* Prompt must be forwarded to
+    /// the provider.  The `awaiting_dtmf` / `interrupt_on_dtmf` flags should
+    /// NOT block legitimate input when the node explicitly allows interruption.
+    #[tokio::test]
+    async fn test_interruptible_prompt_forwards_dtmf_to_provider() {
+        let prompt = ActionNode::new(EntryAction::Prompt {
+            file: Some("hello.wav".into()),
+            tts_text: None,
+            tts_voice: None,
+            record_name_list: None,
+            interruptible: true,
+            tts_api_url: None,
+        });
+        let transfer = ActionNode::new(EntryAction::Transfer {
+            target: "2001".into(),
+        });
+
+        let mut stack =
+            MockCallStack::run(Box::new(mock_app(vec![prompt, transfer])), "1001", "2000");
+        stack
+            .assert_cmd(200, "accept", |c| matches!(c, CallCommand::Answer { .. }))
+            .await;
+        stack
+            .assert_cmd(200, "play", |c| {
+                matches!(
+                    c,
+                    CallCommand::Play {
+                        source: crate::call::domain::MediaSource::File { path },
+                        ..
+                    } if path == "hello.wav"
+                )
+            })
+            .await;
+
+        // While the interruptible prompt is still playing, inject a DTMF digit.
+        // It MUST be forwarded to the provider (not silently ignored).
+        let _ = stack.drain_cmds();
+        stack.dtmf("5");
+        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+        // The app should stop the audio first, then ask the provider for
+        // the next action (MockProvider returns Transfer("2001")).
+        stack
+            .assert_cmd(200, "stop", |c| {
+                matches!(c, CallCommand::StopPlayback { .. })
+            })
+            .await;
+        stack
+            .assert_cmd(
+                200,
+                "transfer",
+                |c| matches!(c, CallCommand::Transfer { target, .. } if target == "2001"),
+            )
+            .await;
+    }
+
     // ── True E2E: HTTP → Python provider ─────────────────────────────────
     //
     // Validates the FULL IVR protocol chain:

src/call/app/ivr/executor.rs

@@ -226,10 +226,28 @@ async fn download_call_record_sip_flow(
     // Default main call_id to "primary" if not overridden
     call_id_roles.insert(record.call_id.clone(), "primary".to_string());
 
-    let cdr_data = load_cdr_data(&state, &record).await;
-    if let Some(cdr) = &cdr_data {
-        for (cid, role) in &cdr.record.sip_leg_roles {
-            call_id_roles.insert(cid.clone(), role.clone());
+    // Load sip_leg_roles from DB metadata first (faster, no file I/O),
+    // then fall back to the CDR JSON file.
+    let mut sip_leg_roles_loaded = false;
+    if let Some(ref meta) = record.metadata {
+        if let Some(meta_map) = meta.as_object() {
+            if let Some(json_str) = meta_map.get("sip_leg_roles").and_then(|v| v.as_str()) {
+                if let Ok(roles) = serde_json::from_str::<HashMap<String, String>>(json_str) {
+                    for (cid, role) in roles {
+                        call_id_roles.insert(cid, role);
+                    }
+                    sip_leg_roles_loaded = true;
+                }
+            }
+        }
+    }
+
+    if !sip_leg_roles_loaded {
+        let cdr_data = load_cdr_data(&state, &record).await;
+        if let Some(cdr) = &cdr_data {
+            for (cid, role) in &cdr.record.sip_leg_roles {
+                call_id_roles.insert(cid.clone(), role.clone());
+            }
         }
     }
 

src/console/handlers/call_record.rs

@@ -183,6 +183,8 @@ impl ConsoleState {
                 serde_json::Value::String("© 2025 RustPBX. All rights reserved.".to_string())
             });
             let static_path = self.config().static_path();
+            map.entry("static_path")
+                .or_insert_with(|| serde_json::Value::String(static_path.clone()));
             map.entry("site_logo").or_insert_with(|| {
                 serde_json::Value::String(format!("{}/images/logo.png", static_path))
             });

src/console/mod.rs

@@ -111,10 +111,14 @@ pub async fn persist_call_record(
         transcript_language: Set(transcript_language.clone()),
         tags: Set(tags.clone()),
         leg_timeline: Set(leg_timeline_json),
-        metadata: Set(details
-            .metadata
-            .as_ref()
-            .and_then(|m| serde_json::to_value(m).ok())),
+        metadata: Set({
+            let mut m = details.metadata.clone().unwrap_or_default();
+            if !record.sip_leg_roles.is_empty() {
+                let json = serde_json::to_string(&record.sip_leg_roles).unwrap_or_default();
+                m.insert("sip_leg_roles".to_string(), json);
+            }
+            serde_json::to_value(&m).ok()
+        }),
         created_at: Set(record.start_time),
         updated_at: Set(record.end_time),
         archived_at: Set(None),

src/models/call_record.rs

@@ -506,14 +506,10 @@ impl ProxyModule for AuthModule {
                             vec![Header::WwwAuthenticate(www_auth)],
                         )
                     } else {
-                        let www_auth = self.create_www_auth_challenge(&realm)?;
                         let proxy_auth = self.create_proxy_auth_challenge(&realm)?;
                         (
                             rsipstack::sip::StatusCode::ProxyAuthenticationRequired,
-                            vec![
-                                Header::WwwAuthenticate(www_auth),
-                                Header::ProxyAuthenticate(proxy_auth),
-                            ],
+                            vec![Header::ProxyAuthenticate(proxy_auth)],
                         )
                     };
 

src/proxy/auth.rs

@@ -117,8 +117,11 @@ impl ClusterPresenceMessage {
         let status = match self.status.as_str() {
             "available" => PresenceStatus::Available,
             "busy" => PresenceStatus::Busy,
-            "away" => PresenceStatus::Away,
-            _ => PresenceStatus::Offline,
+            "away" => PresenceStatus::Away(String::new()),
+            "dnd" => PresenceStatus::Dnd,
+            "offline" => PresenceStatus::Offline,
+            "" => PresenceStatus::Offline,
+            other => PresenceStatus::Away(other.to_string()),
         };
         Some(PresenceState {
             status,
@@ -842,7 +845,7 @@ mod tests {
             last_updated: 0,
         };
         let state = msg.to_state().unwrap();
-        assert_eq!(state.status, PresenceStatus::Away);
+        assert_eq!(state.status, PresenceStatus::Away(String::new()));
     }
 
     #[test]
@@ -859,16 +862,16 @@ mod tests {
     }
 
     #[test]
-    fn test_presence_message_to_state_unknown_falls_to_offline() {
+    fn test_presence_message_to_state_custom_falls_to_away() {
         let msg = ClusterPresenceMessage {
             identity: "test".to_string(),
-            status: "dnd".to_string(),
+            status: "lunch".to_string(),
             note: None,
             activity: None,
             last_updated: 0,
         };
         let state = msg.to_state().unwrap();
-        assert_eq!(state.status, PresenceStatus::Offline);
+        assert_eq!(state.status, PresenceStatus::Away("lunch".to_string()));
     }
 
     // ── LocatorEvent → ClusterLocatorMessage conversion ─────────────────────
@@ -1267,7 +1270,7 @@ mod tests {
     #[test]
     fn test_presence_state_full_round_trip() {
         let original = PresenceState {
-            status: PresenceStatus::Away,
+            status: PresenceStatus::Away(String::new()),
             note: Some("Lunch".to_string()),
             activity: Some("meal".to_string()),
             last_updated: 1715000000,
@@ -1286,7 +1289,7 @@ mod tests {
         };
 
         // Assert
-        assert_eq!(reconstructed.status, PresenceStatus::Away);
+        assert_eq!(reconstructed.status, PresenceStatus::Away(String::new()));
         assert_eq!(reconstructed.note.as_deref(), Some("Lunch"));
         assert_eq!(reconstructed.activity.as_deref(), Some("meal"));
         assert_eq!(reconstructed.last_updated, 1715000000);