60 lines
2.0 KiB
Rust
60 lines
2.0 KiB
Rust
use serde_json::json;
|
|
use tracing::error;
|
|
|
|
use crate::{
|
|
lock_r, models::interaction::SendInteractionDto, services::ws::WS_EVENT, state::FDOLL,
|
|
};
|
|
|
|
pub async fn send_interaction(dto: SendInteractionDto) -> Result<(), String> {
|
|
// Check if WS is initialized
|
|
let client = {
|
|
let guard = lock_r!(FDOLL);
|
|
if let Some(clients) = &guard.network.clients {
|
|
if clients.is_ws_initialized {
|
|
clients.ws_client.clone()
|
|
} else {
|
|
return Err("WebSocket not initialized".to_string());
|
|
}
|
|
} else {
|
|
return Err("App not fully initialized".to_string());
|
|
}
|
|
};
|
|
|
|
if let Some(socket) = client {
|
|
// Prepare payload for client-send-interaction event
|
|
// The DTO structure matches what the server expects:
|
|
// { recipientUserId, content, type } (handled by serde rename_all="camelCase")
|
|
|
|
let payload = json!({
|
|
"recipientUserId": dto.recipient_user_id,
|
|
"content": dto.content,
|
|
"type": dto.type_
|
|
});
|
|
|
|
// Blocking emission because rust_socketio::Client::emit is synchronous/blocking
|
|
// but we are in an async context. Ideally we spawn_blocking.
|
|
let spawn_result = tauri::async_runtime::spawn_blocking(move || {
|
|
socket.emit(WS_EVENT::CLIENT_SEND_INTERACTION, payload)
|
|
})
|
|
.await;
|
|
|
|
match spawn_result {
|
|
Ok(emit_result) => match emit_result {
|
|
Ok(_) => Ok(()),
|
|
Err(e) => {
|
|
let err_msg = format!("Failed to emit interaction event: {}", e);
|
|
error!("{}", err_msg);
|
|
Err(err_msg)
|
|
}
|
|
},
|
|
Err(e) => {
|
|
let err_msg = format!("Failed to spawn blocking task for interaction emit: {}", e);
|
|
error!("{}", err_msg);
|
|
Err(err_msg)
|
|
}
|
|
}
|
|
} else {
|
|
Err("WebSocket client not available".to_string())
|
|
}
|
|
}
|