GeneralBots/botserver
2
1
Fork 0
Code Issues Pull requests Projects Releases 323 Packages Wiki Activity Actions 1

- Only 18 errors missing being fixed.

Browse source
This commit is contained in:
Rodrigo Rodriguez (Pragmatismo) 2025-10-11 20:25:08 -03:00
parent 147d12b7c0
commit 03ab8117c4
7 changed files with 82 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
src/automation/mod.rs
View file

@ -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);
}
}
}

6
src/basic/keywords/set.rs
View file

@ -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") {

14
src/basic/keywords/set_schedule.rs
View file

@ -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<Value, Box<dyn std::error::Error>> {
@ -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",

14
src/bot/mod.rs
View file

@ -187,7 +187,7 @@ impl BotOrchestrator {
message: &UserMessage,
session: &UserSession,
) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
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<Vec<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
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<Vec<(String, String)>, Box<dyn std::error::Error + Send + Sync>> {
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)
}

54
src/session/mod.rs
View file

@ -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<Option<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
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<String> = 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::<UserSession>(&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::<UserSession>(&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<Vec<(String, String)>, Box<dyn std::error::Error + Send + Sync>> {
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<Vec<UserSession>, Box<dyn std::error::Error + Send + Sync>> {
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::<UserSession>(&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<dyn std::error::Error + Send + Sync>> {
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<dyn std::error::Error + Send + Sync>> {
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<String>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
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 {

1
src/shared/state.rs
View file

@ -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),

3
src/whatsapp/mod.rs
View file

@ -141,7 +141,8 @@ impl WhatsAppAdapter {
pub async fn process_incoming_message(
&self,
message: WhatsAppMessage,
) -> Result<Vec<crate::shared::UserMessage>, Box<dyn std::error::Error + Send + Sync>> {
) -> Result<Vec<crate::shared::models::UserMessage>, Box<dyn std::error::Error + Send + Sync>>
{
let mut user_messages = Vec::new();
for entry in message.entry {