From 03ab8117c4ca34ec496166cb724f588cb2cee441 Mon Sep 17 00:00:00 2001 From: "Rodrigo Rodriguez (Pragmatismo)" Date: Sat, 11 Oct 2025 20:25:08 -0300 Subject: [PATCH] - Only 18 errors missing being fixed. --- src/automation/mod.rs | 57 ++++++++++++++++++------------ src/basic/keywords/set.rs | 6 ++-- src/basic/keywords/set_schedule.rs | 14 ++++---- src/bot/mod.rs | 14 ++++---- src/session/mod.rs | 54 +++++++++++++++------------- src/shared/state.rs | 1 + src/whatsapp/mod.rs | 3 +- 7 files changed, 82 insertions(+), 67 deletions(-) diff --git a/src/automation/mod.rs b/src/automation/mod.rs index 21ea463c0..1db2a35fa 100644 --- a/src/automation/mod.rs +++ b/src/automation/mod.rs @@ -194,31 +194,42 @@ impl AutomationService { async fn execute_action(&self, param: &str) { let full_path = Path::new(&self.scripts_dir).join(param); - match tokio::fs::read_to_string(&full_path).await { - Ok(script_content) => { - info!("Executing action with param: {}", param); - let user_session = crate::shared::models::UserSession { - id: Uuid::new_v4(), - user_id: Uuid::new_v4(), - bot_id: Uuid::new_v4(), - title: "Automation".to_string(), - answer_mode: "direct".to_string(), - current_tool: None, - context_data: None, - created_at: Utc::now(), - updated_at: Utc::now(), - }; - let script_service = ScriptService::new(&self.state, user_session); - match script_service.compile(&script_content) { - Ok(ast) => match script_service.run(&ast) { - Ok(result) => info!("Script executed successfully: {:?}", result), - Err(e) => error!("Error executing script: {}", e), - }, - Err(e) => error!("Error compiling script: {}", e), - } + let script_content = match tokio::fs::read_to_string(&full_path).await { + Ok(content) => content, + Err(e) => { + error!("Failed to read script {}: {}", full_path.display(), e); + return; + } + }; + + info!("Executing action with param: {}", param); + let user_session = crate::shared::models::UserSession { + id: Uuid::new_v4(), + user_id: Uuid::new_v4(), + bot_id: Uuid::new_v4(), + title: "Automation".to_string(), + answer_mode: "direct".to_string(), + current_tool: None, + context_data: serde_json::Value::Null, + created_at: Utc::now(), + updated_at: Utc::now(), + }; + + let script_service = ScriptService::new(&self.state, user_session); + let ast = match script_service.compile(&script_content) { + Ok(ast) => ast, + Err(e) => { + error!("Error compiling script: {}", e); + return; + } + }; + + match script_service.run(&ast) { + Ok(_result) => { + info!("Script executed successfully"); } Err(e) => { - error!("Failed to execute action {}: {}", full_path.display(), e); + error!("Error executing script: {}", e); } } } diff --git a/src/basic/keywords/set.rs b/src/basic/keywords/set.rs index 423e1d401..4a698f205 100644 --- a/src/basic/keywords/set.rs +++ b/src/basic/keywords/set.rs @@ -8,7 +8,7 @@ use std::error::Error; use crate::shared::models::UserSession; use crate::shared::state::AppState; -pub fn set_keyword(state: &AppState, user: UserSession, engine: &mut Engine) { +pub fn set_keyword(state: &AppState, _user: UserSession, engine: &mut Engine) { let state_clone = state.clone(); engine @@ -22,8 +22,8 @@ pub fn set_keyword(state: &AppState, user: UserSession, engine: &mut Engine) { let filter_str = filter.to_string(); let updates_str = updates.to_string(); - let conn = state_clone.conn.lock().unwrap(); - let result = execute_set(&*conn, &table_str, &filter_str, &updates_str) + let mut conn = state_clone.conn.lock().unwrap(); + let result = execute_set(&mut *conn, &table_str, &filter_str, &updates_str) .map_err(|e| format!("DB error: {}", e))?; if let Some(rows_affected) = result.get("rows_affected") { diff --git a/src/basic/keywords/set_schedule.rs b/src/basic/keywords/set_schedule.rs index 7e0ad2928..c4029e33e 100644 --- a/src/basic/keywords/set_schedule.rs +++ b/src/basic/keywords/set_schedule.rs @@ -1,14 +1,14 @@ +use diesel::prelude::*; use log::info; use rhai::Dynamic; use rhai::Engine; use serde_json::{json, Value}; -use diesel::prelude::*; use crate::shared::models::TriggerKind; -use crate::shared::state::AppState; use crate::shared::models::UserSession; +use crate::shared::state::AppState; -pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut Engine) { +pub fn set_schedule_keyword(state: &AppState, _user: UserSession, engine: &mut Engine) { let state_clone = state.clone(); engine @@ -17,8 +17,8 @@ pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut En let cron = context.eval_expression_tree(&inputs[0])?.to_string(); let script_name = format!("cron_{}.rhai", cron.replace(' ', "_")); - let conn = state_clone.conn.lock().unwrap(); - let result = execute_set_schedule(&*conn, &cron, &script_name) + let mut conn = state_clone.conn.lock().unwrap(); + let result = execute_set_schedule(&mut *conn, &cron, &script_name) .map_err(|e| format!("DB error: {}", e))?; if let Some(rows_affected) = result.get("rows_affected") { @@ -32,7 +32,7 @@ pub fn set_schedule_keyword(state: &AppState, user: UserSession, engine: &mut En } pub fn execute_set_schedule( - conn: &diesel::PgConnection, + conn: &mut diesel::PgConnection, cron: &str, script_name: &str, ) -> Result> { @@ -51,7 +51,7 @@ pub fn execute_set_schedule( let result = diesel::insert_into(system_automations::table) .values(&new_automation) - .execute(conn)?; + .execute(&mut *conn)?; Ok(json!({ "command": "set_schedule", diff --git a/src/bot/mod.rs b/src/bot/mod.rs index 22ad01e0a..339f6df0f 100644 --- a/src/bot/mod.rs +++ b/src/bot/mod.rs @@ -187,7 +187,7 @@ impl BotOrchestrator { message: &UserMessage, session: &UserSession, ) -> Result> { - let session_manager = self.session_manager.lock().await; + let mut session_manager = self.session_manager.lock().await; let history = session_manager.get_conversation_history(session.id, session.user_id)?; let mut prompt = String::new(); @@ -220,11 +220,9 @@ impl BotOrchestrator { }; if session.answer_mode == "tool" && session.current_tool.is_some() { - self.tool_manager.provide_user_response( - &message.user_id, - &message.bot_id, - message.content.clone(), - )?; + self.tool_manager + .provide_user_response(&message.user_id, &message.bot_id, message.content.clone()) + .await?; return Ok(()); } @@ -310,7 +308,7 @@ impl BotOrchestrator { &self, user_id: Uuid, ) -> Result, Box> { - let session_manager = self.session_manager.lock().await; + let mut session_manager = self.session_manager.lock().await; session_manager.get_user_sessions(user_id) } @@ -319,7 +317,7 @@ impl BotOrchestrator { session_id: Uuid, user_id: Uuid, ) -> Result, Box> { - let session_manager = self.session_manager.lock().await; + let mut session_manager = self.session_manager.lock().await; session_manager.get_conversation_history(session_id, user_id) } diff --git a/src/session/mod.rs b/src/session/mod.rs index fbf90f596..763af6987 100644 --- a/src/session/mod.rs +++ b/src/session/mod.rs @@ -18,15 +18,15 @@ impl SessionManager { pub fn get_user_session( &mut self, - user_id: Uuid, - bot_id: Uuid, + user_id_param: Uuid, + bot_id_param: Uuid, ) -> Result, Box> { if let Some(redis_client) = &self.redis { let mut conn = tokio::task::block_in_place(|| { tokio::runtime::Handle::current() .block_on(redis_client.get_multiplexed_async_connection()) })?; - let cache_key = format!("session:{}:{}", user_id, bot_id); + let cache_key = format!("session:{}:{}", user_id_param, bot_id_param); let session_json: Option = tokio::task::block_in_place(|| { tokio::runtime::Handle::current().block_on(conn.get(&cache_key)) })?; @@ -40,8 +40,8 @@ impl SessionManager { use crate::shared::models::user_sessions::dsl::*; let session = user_sessions - .filter(user_id.eq(user_id)) - .filter(bot_id.eq(bot_id)) + .filter(user_id.eq(user_id_param)) + .filter(bot_id.eq(bot_id_param)) .order_by(updated_at.desc()) .first::(&mut self.conn) .optional()?; @@ -52,7 +52,7 @@ impl SessionManager { tokio::runtime::Handle::current() .block_on(redis_client.get_multiplexed_async_connection()) })?; - let cache_key = format!("session:{}:{}", user_id, bot_id); + let cache_key = format!("session:{}:{}", user_id_param, bot_id_param); let session_json = serde_json::to_string(session)?; let _: () = tokio::task::block_in_place(|| { tokio::runtime::Handle::current().block_on(conn.set_ex( @@ -86,6 +86,7 @@ impl SessionManager { let session = insert_into(user_sessions::table) .values(&new_session) + .returning(UserSession::as_returning()) .get_result::(&mut self.conn)?; if let Some(redis_client) = &self.redis { @@ -110,7 +111,7 @@ impl SessionManager { pub fn save_message( &mut self, session_id: Uuid, - user_id: Uuid, + user_id_param: Uuid, role: &str, content: &str, message_type: &str, @@ -125,7 +126,7 @@ impl SessionManager { let new_message = ( message_history::session_id.eq(session_id), - message_history::user_id.eq(user_id), + message_history::user_id.eq(user_id_param), message_history::role.eq(role), message_history::content_encrypted.eq(content), message_history::message_type.eq(message_type), @@ -165,8 +166,8 @@ impl SessionManager { pub fn get_conversation_history( &mut self, - session_id: Uuid, - user_id: Uuid, + _session_id: Uuid, + _user_id: Uuid, ) -> Result, Box> { use crate::shared::models::message_history::dsl::*; @@ -182,12 +183,12 @@ impl SessionManager { pub fn get_user_sessions( &mut self, - user_id: Uuid, + user_id_param: Uuid, ) -> Result, Box> { use crate::shared::models::user_sessions::dsl::*; let sessions = user_sessions - .filter(user_id.eq(user_id)) + .filter(user_id.eq(user_id_param)) .order_by(updated_at.desc()) .load::(&mut self.conn)?; Ok(sessions) @@ -195,14 +196,14 @@ impl SessionManager { pub fn update_answer_mode( &mut self, - user_id: &str, - bot_id: &str, + user_id_param: &str, + bot_id_param: &str, mode: &str, ) -> Result<(), Box> { use crate::shared::models::user_sessions::dsl::*; - let user_uuid = Uuid::parse_str(user_id)?; - let bot_uuid = Uuid::parse_str(bot_id)?; + let user_uuid = Uuid::parse_str(user_id_param)?; + let bot_uuid = Uuid::parse_str(bot_id_param)?; diesel::update( user_sessions @@ -228,14 +229,14 @@ impl SessionManager { pub fn update_current_tool( &mut self, - user_id: &str, - bot_id: &str, + user_id_param: &str, + bot_id_param: &str, tool_name: Option<&str>, ) -> Result<(), Box> { use crate::shared::models::user_sessions::dsl::*; - let user_uuid = Uuid::parse_str(user_id)?; - let bot_uuid = Uuid::parse_str(bot_id)?; + let user_uuid = Uuid::parse_str(user_id_param)?; + let bot_uuid = Uuid::parse_str(bot_id_param)?; diesel::update( user_sessions @@ -321,21 +322,24 @@ impl SessionManager { pub fn set_current_tool( &mut self, - user_id: &str, - bot_id: &str, + user_id_param: &str, + bot_id_param: &str, tool_name: Option, ) -> Result<(), Box> { use crate::shared::models::user_sessions::dsl::*; - let user_uuid = Uuid::parse_str(user_id)?; - let bot_uuid = Uuid::parse_str(bot_id)?; + let user_uuid = Uuid::parse_str(user_id_param)?; + let bot_uuid = Uuid::parse_str(bot_id_param)?; diesel::update( user_sessions .filter(user_id.eq(user_uuid)) .filter(bot_id.eq(bot_uuid)), ) - .set((current_tool.eq(tool_name), updated_at.eq(diesel::dsl::now))) + .set(( + current_tool.eq(tool_name.as_deref()), + updated_at.eq(diesel::dsl::now), + )) .execute(&mut self.conn)?; if let Some(redis_client) = &self.redis { diff --git a/src/shared/state.rs b/src/shared/state.rs index 052b074e5..87673950b 100644 --- a/src/shared/state.rs +++ b/src/shared/state.rs @@ -28,6 +28,7 @@ impl Clone for AppState { s3_client: self.s3_client.clone(), config: self.config.clone(), conn: Arc::clone(&self.conn), + custom_conn: Arc::clone(&self.custom_conn), redis_client: self.redis_client.clone(), orchestrator: Arc::clone(&self.orchestrator), web_adapter: Arc::clone(&self.web_adapter), diff --git a/src/whatsapp/mod.rs b/src/whatsapp/mod.rs index c804aa3ca..57b75cdd9 100644 --- a/src/whatsapp/mod.rs +++ b/src/whatsapp/mod.rs @@ -141,7 +141,8 @@ impl WhatsAppAdapter { pub async fn process_incoming_message( &self, message: WhatsAppMessage, - ) -> Result, Box> { + ) -> Result, Box> + { let mut user_messages = Vec::new(); for entry in message.entry {