nicolas.borges/piperun-bot
1
0
Fork 0
forked from jelson.rodrigues/piperun-bot
Code Pull Requests Activity

style: apply cargo fmt

Browse Source
This commit is contained in:
Jelson Stoelben Rodrigues
2025-11-03 10:56:00 -03:00
parent 5477f91bb9
commit 14bf25e83a
2 changed files with 535 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

394
src/groupped_repport.rs
View File

@@ -6,9 +6,9 @@ use polars::prelude::buffer::validate_utf8;
use polars::prelude::*; use polars::prelude::*;
use reqwest; use reqwest;
use serde::Deserialize; use serde::Deserialize;
use walkdir;
use std::time::Duration;
use std::env; use std::env;
use std::time::Duration;
use walkdir;
use csv; use csv;
@@ -29,7 +29,7 @@ struct CsvEvaluation {
DISPONIBILIDADE: u8, DISPONIBILIDADE: u8,
CONHECIMENTO_TÉCNICO: u8, CONHECIMENTO_TÉCNICO: u8,
DIDATISMO: u8, DIDATISMO: u8,
ID_TALK: String ID_TALK: String,
} }
// impl TryFrom::<csv::DeserializeRecordsIter<&[u8], CsvHeader>> for CsvEvaluation { // impl TryFrom::<csv::DeserializeRecordsIter<&[u8], CsvHeader>> for CsvEvaluation {
@@ -52,7 +52,8 @@ fn main() {
.unwrap_or("11432".to_string()) .unwrap_or("11432".to_string())
.parse::<u16>() .parse::<u16>()
.unwrap_or(11432); .unwrap_or(11432);
let OLLAMA_AI_MODEL_DATA_SANITIZATION = env::var("OLLAMA_AI_MODEL_DATA_SANITIZATION").expect("Missing environment variable OLLAMA_AI_MODEL_DATA_SANITIZATION"); let OLLAMA_AI_MODEL_DATA_SANITIZATION = env::var("OLLAMA_AI_MODEL_DATA_SANITIZATION")
.expect("Missing environment variable OLLAMA_AI_MODEL_DATA_SANITIZATION");
let ip_address = ipaddress::IPAddress::parse(OLLAMA_URL.to_string()); let ip_address = ipaddress::IPAddress::parse(OLLAMA_URL.to_string());
let OLLAMA_SANITIZED_IP = match ip_address { let OLLAMA_SANITIZED_IP = match ip_address {
@@ -70,166 +71,253 @@ fn main() {
let current_date = chrono::Local::now(); let current_date = chrono::Local::now();
let formatted_date = current_date.format("%Y-%m-%d").to_string(); let formatted_date = current_date.format("%Y-%m-%d").to_string();
let previous_week_folder_names = std::fs::read_dir(std::path::Path::new("./evaluations")).expect("Failed to read directory ./evaluations") let previous_week_folder_names = std::fs::read_dir(std::path::Path::new("./evaluations"))
.filter_map_ok(|entry| { .expect("Failed to read directory ./evaluations")
if entry.metadata().unwrap().is_dir(){ .filter_map_ok(|entry| {
Some(entry.file_name()) if entry.metadata().unwrap().is_dir() {
} Some(entry.file_name())
else { } else {
None None
} }
}) })
.filter_map_ok(|entry_string_name| { .filter_map_ok(|entry_string_name| {
let regex_match_date = regex::Regex::new(r"(\d{4}-\d{2}-\d{2})").expect("Failed to build regex"); let regex_match_date =
regex::Regex::new(r"(\d{4}-\d{2}-\d{2})").expect("Failed to build regex");
let filename = entry_string_name.to_str().unwrap();
let matches_find = regex_match_date.find(filename);
match matches_find { let filename = entry_string_name.to_str().unwrap();
Some(found) => { let matches_find = regex_match_date.find(filename);
let date = chrono::NaiveDate::parse_from_str(found.as_str(), "%Y-%m-%d");
return Some((date.unwrap().week(chrono::Weekday::Sun), entry_string_name));
},
None => {return None;}
};
})
.filter_map_ok(|(week, directory_string)| {
let current_date = chrono::Local::now();
let first_day_of_current_week = current_date.date_naive().week(chrono::Weekday::Sun).first_day();
let current_date_minus_one_week = first_day_of_current_week.checked_sub_days(chrono::Days::new(1)).expect("Failed to subtract one day");
let first_day_of_last_week = current_date_minus_one_week.week(chrono::Weekday::Sun).first_day();
let first_day_of_week_in_folder_name = week.first_day();
if first_day_of_last_week == first_day_of_week_in_folder_name { match matches_find {
return Some(directory_string); Some(found) => {
} let date = chrono::NaiveDate::parse_from_str(found.as_str(), "%Y-%m-%d");
return None; return Some((date.unwrap().week(chrono::Weekday::Sun), entry_string_name));
}) }
.filter_map(|value| { None => {
if value.is_ok() {return Some(value.unwrap());} return None;
else {return None;} }
}) };
.sorted() })
.collect_vec(); .filter_map_ok(|(week, directory_string)| {
let current_date = chrono::Local::now();
let first_day_of_current_week = current_date
.date_naive()
.week(chrono::Weekday::Sun)
.first_day();
let current_date_minus_one_week = first_day_of_current_week
.checked_sub_days(chrono::Days::new(1))
.expect("Failed to subtract one day");
let first_day_of_last_week = current_date_minus_one_week
.week(chrono::Weekday::Sun)
.first_day();
let first_day_of_week_in_folder_name = week.first_day();
if first_day_of_last_week == first_day_of_week_in_folder_name {
return Some(directory_string);
}
return None;
})
.filter_map(|value| {
if value.is_ok() {
return Some(value.unwrap());
} else {
return None;
}
})
.sorted()
.collect_vec();
println!("{:?}", previous_week_folder_names); println!("{:?}", previous_week_folder_names);
let prompt_data_sanitization = std::fs::read_to_string("./PROMPT_DATA_SANITIZATION.txt").expect("Failed to read PROMPT_DATA_SANITIZATION.txt"); let prompt_data_sanitization = std::fs::read_to_string("./PROMPT_DATA_SANITIZATION.txt")
.expect("Failed to read PROMPT_DATA_SANITIZATION.txt");
let client = reqwest::blocking::Client::new(); let client = reqwest::blocking::Client::new();
let a = previous_week_folder_names.iter().map(|folder_name| { let a = previous_week_folder_names
.iter()
.map(|folder_name| {
let folder_base_path = std::path::Path::new("./evaluations"); let folder_base_path = std::path::Path::new("./evaluations");
let folder_date_path = folder_base_path.join(folder_name); let folder_date_path = folder_base_path.join(folder_name);
std::fs::read_dir(folder_date_path) std::fs::read_dir(folder_date_path)
}) })
.filter_map_ok(|files_inside_folder_on_date | .take(1)
{ .filter_map_ok(|files_inside_folder_on_date| {
files_inside_folder_on_date.filter_ok(|entry| { let groupped_by_user_on_day = files_inside_folder_on_date
let entry_file_name_as_str = entry.file_name().into_string().expect("Failed to get filename as a String"); .filter_ok(|entry| {
let entry_file_name_as_str = entry
.file_name()
.into_string()
.expect("Failed to get filename as a String");
entry_file_name_as_str.ends_with(".csv") && entry_file_name_as_str.ends_with(".csv")
!entry_file_name_as_str.contains("response_time.csv") && !entry_file_name_as_str.contains("response_time.csv")
})
.filter_map(|value|{
if value.is_ok() {return Some(value.unwrap());}
None
})
.take(1)
.map(|file_name_csv| {
println!("{:?}", file_name_csv.path());
let file_contents = std::fs::read_to_string(file_name_csv.path()).expect("Failed to read CSV file");
let ollama_api_request = client.post(format!("http://{OLLAMA_SANITIZED_IP}:{OLLAMA_PORT}/api/generate"))
.body(
serde_json::json!({
"model": OLLAMA_AI_MODEL_DATA_SANITIZATION,
"prompt": format!("{prompt_data_sanitization} \n{file_contents}"),
"temperature": 0.0, // Get predictable and reproducible output
"stream": false,
}).to_string()
);
let result = ollama_api_request.timeout(Duration::from_secs(3600)).send();
match result {
Ok(response) => {println!("Response: {:?}", response);
let response_json = response.json::<serde_json::Value>().expect("Failed to deserialize response to JSON");
let ai_response = response_json["response"]
.as_str()
.expect("Failed to get AI response as string");
let ai_response = ai_response.to_string();
let ai_response = if let Some(resp) = ai_response.strip_prefix(" ").unwrap_or(&ai_response).strip_prefix("```csv\n") { resp.to_string() } else { ai_response };
let ai_response = if let Some(resp) = ai_response.strip_suffix(" ").unwrap_or(&ai_response).strip_suffix("```") { resp.to_string() } else { ai_response };
return Ok((ai_response, file_name_csv));
},
Err(error) => {println!("Error {error}"); return Err(error);}
};
})
.filter_map_ok(|(ai_repsonse, file_path_csv)| {
let mut reader = csv::ReaderBuilder::new()
.has_headers(true)
.delimiter(b';')
.from_reader(ai_repsonse.as_bytes());
let mut deserialized_iter = reader.deserialize::<CsvHeader>();
let mut columns = deserialized_iter.filter_ok(|value| {
value.PONTOS.is_some()
}) })
.map_ok(|value| { .filter_map(|value| {
let col = Column::new(value.CATEGORIA.into(), [value.PONTOS.unwrap() as u32]); if value.is_ok() {
col return Some(value.unwrap());
}) }
.filter_map(|value|{
if value.is_ok() {return Some(value.unwrap());}
None None
}) })
// .take(1)
.map(|file_name_csv| {
println!("{:?}", file_name_csv.path());
let file_contents = std::fs::read_to_string(file_name_csv.path())
.expect("Failed to read CSV file");
let ollama_api_request = client
.post(format!(
"http://{OLLAMA_SANITIZED_IP}:{OLLAMA_PORT}/api/generate"
))
.body(
serde_json::json!({
"model": OLLAMA_AI_MODEL_DATA_SANITIZATION,
"prompt": format!("{prompt_data_sanitization} \n{file_contents}"),
"temperature": 0.0, // Get predictable and reproducible output
"stream": false,
})
.to_string(),
);
let result = ollama_api_request.timeout(Duration::from_secs(3600)).send();
match result {
Ok(response) => {
println!("Response: {:?}", response);
let response_json = response
.json::<serde_json::Value>()
.expect("Failed to deserialize response to JSON");
let ai_response = response_json["response"]
.as_str()
.expect("Failed to get AI response as string");
let ai_response = ai_response.to_string();
let ai_response = if let Some(resp) = ai_response
.strip_prefix(" ")
.unwrap_or(&ai_response)
.strip_prefix("```csv\n")
{
resp.to_string()
} else {
ai_response
};
let ai_response = if let Some(resp) = ai_response
.strip_suffix(" ")
.unwrap_or(&ai_response)
.strip_suffix("```")
{
resp.to_string()
} else {
ai_response
};
return Ok((ai_response, file_name_csv));
}
Err(error) => {
println!("Error {error}");
return Err(error);
}
};
})
.filter_map_ok(|(ai_repsonse, file_path_csv)| {
let mut reader = csv::ReaderBuilder::new()
.has_headers(true)
.delimiter(b';')
.from_reader(ai_repsonse.as_bytes());
let mut deserialized_iter = reader.deserialize::<CsvHeader>();
let mut columns = deserialized_iter
.filter_ok(|value| value.PONTOS.is_some())
.map_ok(|value| {
let col =
Column::new(value.CATEGORIA.into(), [value.PONTOS.unwrap() as u32]);
col
})
.filter_map(|value| {
if value.is_ok() {
return Some(value.unwrap());
}
None
})
.collect_vec();
if columns.len() != 9 {
return None;
}
// Parse id talk from file_path
// filename example is: CC - Erraoander Quintana - 515578 - 20251020515578.csv
// id talk is the last information, so in the example is: 20251020515578
let regex_filename =
regex::Regex::new(r"(CC - )((\w+\s*)+) - (\d+) - (\d+).csv").unwrap();
let filename = file_path_csv
.file_name()
.into_string()
.expect("Failed to convert file name as Rust &str");
let found_regex_groups_in_filename = regex_filename
.captures(filename.as_str())
.expect("Failed to do regex capture");
let user_name = found_regex_groups_in_filename
.get(2)
.expect("Failed to get the id from regex maches");
let talk_id = found_regex_groups_in_filename
.get(5)
.expect("Failed to get the id from regex maches");
columns.push(Column::new("ID_TALK".into(), [talk_id.clone().as_str()]));
let df = polars::frame::DataFrame::new(columns)
.expect("Failed to concatenate into a dataframe");
// println!("{:?}", df);
// Create a dataframe with the evaluation columns plus the talk id
// return a tuple with the dataframe and the user name, so it can be correctly merged after
return Some((user_name.as_str().to_owned(), df));
})
.filter_map(|res| {
if res.is_ok() {
return Some(res.unwrap());
}
return None;
})
.into_group_map()
.into_iter()
.map(|(name, eval_dataframe_vec)| {
let groupped_df = eval_dataframe_vec
.iter()
.cloned()
.reduce(|acc, e| acc.vstack(&e).unwrap())
.expect("Failed to concatenate dataframes");
(name, groupped_df)
})
.collect_vec(); .collect_vec();
if columns.len() != 9 { return None;}
// Parse id talk from file_path return Some(groupped_by_user_on_day);
// filename example is: CC - Erraoander Quintana - 515578 - 20251020515578.csv
// id talk is the last information, so in the example is: 20251020515578
let regex_filename = regex::Regex::new(r"(CC - )((\w+\s*)+) - (\d+) - (\d+).csv").unwrap();
let filename = file_path_csv
.file_name()
.into_string()
.expect("Failed to convert file name as Rust &str");
let found_regex_groups_in_filename = regex_filename.captures(
filename.as_str()
).expect("Failed to do regex capture");
let user_name = found_regex_groups_in_filename.get(2).expect("Failed to get the id from regex maches");
let talk_id = found_regex_groups_in_filename.get(5).expect("Failed to get the id from regex maches");
columns.push(Column::new("ID_TALK".into(), [talk_id.clone().as_str()]));
let df = polars::frame::DataFrame::new(columns).expect("Failed to concatenate into a dataframe");
println!("{:?}", df);
// Create a dataframe with the evaluation columns plus the talk id
// return a tuple with the dataframe and the user name, so it can be correctly merged after
return Some((user_name.as_str().to_owned(), df));
})
.for_each(|username| {});
// println!("{:?}", files_inside_folder_on_date);
return Some(());
}) })
.filter_map(|res| {
if res.is_ok() {
return Some(res.unwrap());
}
return None;
})
.into_group_map()
.into_iter()
.map(|(name, eval_dataframe_vec)| {
let groupped_df = eval_dataframe_vec
.iter()
.cloned()
.reduce(|acc, e| acc.vstack(&e).unwrap())
.expect("Failed to concatenate dataframes");
(name, groupped_df)
})
// .collect_vec();
.collect_vec(); .collect_vec();
// println!("{:?}", a); println!("{:?}", a);
// Read CSV files inside folder // Read CSV files inside folder
@@ -238,14 +326,12 @@ fn main() {
// Save into a hashmap, with the user name as key, the date, evaluation // Save into a hashmap, with the user name as key, the date, evaluation
// Final file should look like // Final file should look like
/* /*
Header: Att1, att2, att3, ... Header: Att1, att2, att3, ...
categoria1 categoria1
categoria2 categoria2
categoria3 categoria3
... ...
*/ */
}
}

447
src/main.rs
View File

@@ -166,20 +166,34 @@ fn main() -> anyhow::Result<()> {
// Create a folder named with the day_before // Create a folder named with the day_before
if !std::fs::exists(format!("./evaluations/{formatted_day_before}")).unwrap() { if !std::fs::exists(format!("./evaluations/{formatted_day_before}")).unwrap() {
std::fs::create_dir(format!("./evaluations/{formatted_day_before}")).expect("Failed to create directory") std::fs::create_dir(format!("./evaluations/{formatted_day_before}"))
.expect("Failed to create directory")
} }
// Create the response time folder // Create the response time folder
if !std::fs::exists(format!("./evaluations/{formatted_day_before}/response_time.csv")).unwrap() { if !std::fs::exists(format!(
let mut response_time_file = std::fs::File::create_new(format!("./evaluations/{formatted_day_before}/response_time.csv")).expect("Failed to response_time.csv"); "./evaluations/{formatted_day_before}/response_time.csv"
))
.unwrap()
{
let mut response_time_file = std::fs::File::create_new(format!(
"./evaluations/{formatted_day_before}/response_time.csv"
))
.expect("Failed to response_time.csv");
} }
// Read system prompt // Read system prompt
let prompt = std::fs::read_to_string("PROMPT.txt").unwrap(); let prompt = std::fs::read_to_string("PROMPT.txt").unwrap();
let filter_file_contents = std::fs::read_to_string("FILTER.txt").unwrap_or(String::new()); let filter_file_contents = std::fs::read_to_string("FILTER.txt").unwrap_or(String::new());
let filter_keywords = filter_file_contents.split("\n").collect::<Vec<&str>>(); let filter_keywords = filter_file_contents.split("\n").collect::<Vec<&str>>();
let talks_array = get_piperun_chats_on_date(&PIPERUN_API_URL, &client, &access_token, formatted_day_before_at_midnight, formatted_day_before_at_23_59_59); let talks_array = get_piperun_chats_on_date(
&PIPERUN_API_URL,
&client,
&access_token,
formatted_day_before_at_midnight,
formatted_day_before_at_23_59_59,
);
println!("Number of consolidated talks: {}", talks_array.len()); println!("Number of consolidated talks: {}", talks_array.len());
@@ -215,41 +229,82 @@ fn main() -> anyhow::Result<()> {
let talk_id_get_result = talk_id_get_request.send(); let talk_id_get_result = talk_id_get_request.send();
return talk_id_get_result; return talk_id_get_result;
}).filter_map_ok(|result| { })
let json = result.json::<serde_json::Value>().expect("Failed to deserialize response to JSON").to_owned(); .filter_map_ok(|result| {
let json = result
.json::<serde_json::Value>()
.expect("Failed to deserialize response to JSON")
.to_owned();
let talk_histories = &json["talk_histories"]; let talk_histories = &json["talk_histories"];
let data = &talk_histories["data"]; let data = &talk_histories["data"];
// Filter chats that have very few messages // Filter chats that have very few messages
let talk_lenght = talk_histories.as_array().expect("Wrong message type received from talk histories").len(); let talk_lenght = talk_histories
if talk_lenght < MINIMUM_NUMBER_OF_MESSAGES_TO_EVALUATE {return None;} .as_array()
.expect("Wrong message type received from talk histories")
.len();
if talk_lenght < MINIMUM_NUMBER_OF_MESSAGES_TO_EVALUATE {
return None;
}
// Filter chats that have less that specified ammount of talks with support agent form the last queue transfer // Filter chats that have less that specified ammount of talks with support agent form the last queue transfer
let found = talk_histories.as_array().expect("Wrong message type received from talk histories").into_iter().enumerate().find(|(pos, message_object)|{ let found = talk_histories
let message = message_object["message"].as_str().expect("Failed to decode message as string"); .as_array()
let found = message.find("Atendimento transferido para a fila [NovaNet -> Atendimento -> Suporte]"); .expect("Wrong message type received from talk histories")
found.is_some() .into_iter()
}); .enumerate()
.find(|(pos, message_object)| {
let message = message_object["message"]
.as_str()
.expect("Failed to decode message as string");
let found = message.find(
"Atendimento transferido para a fila [NovaNet -> Atendimento -> Suporte]",
);
found.is_some()
});
match found { match found {
None => {return None;}, None => {
return None;
}
Some(pos) => { Some(pos) => {
let pos_found = pos.0; let pos_found = pos.0;
if pos_found < MINIMUM_NUMBER_OF_MESSAGES_WITH_AGENT_TO_EVALUATE {return None;} if pos_found < MINIMUM_NUMBER_OF_MESSAGES_WITH_AGENT_TO_EVALUATE {
return None;
}
} }
}; };
// Filter Bot finished chats // Filter Bot finished chats
if json["agent"]["user"]["name"].as_str().unwrap_or("unknown_user") == "PipeBot" {return None;} if json["agent"]["user"]["name"]
.as_str()
.unwrap_or("unknown_user")
== "PipeBot"
{
return None;
}
// Apply keyword based filtering // Apply keyword based filtering
let filter_keywords_found = talk_histories.as_array().expect("Wrong message type received from talk histories").into_iter().any(|message_object|{ let filter_keywords_found = talk_histories
let message = message_object["message"].as_str().expect("Failed to decode message as string"); .as_array()
let found = filter_keywords.iter().any(|keyword|{message.to_uppercase().find(&keyword.to_uppercase()).is_some()}); .expect("Wrong message type received from talk histories")
found .into_iter()
}); .any(|message_object| {
let message = message_object["message"]
.as_str()
.expect("Failed to decode message as string");
let found = filter_keywords.iter().any(|keyword| {
message
.to_uppercase()
.find(&keyword.to_uppercase())
.is_some()
});
found
});
if filter_keywords_found {return None;} if filter_keywords_found {
return None;
}
return Some(json); return Some(json);
}); });
@@ -264,80 +319,122 @@ fn main() -> anyhow::Result<()> {
// dbg!(&talk_histories); // dbg!(&talk_histories);
// talk_histories.as_array().unwrap().into_iter().enumerate().for_each(|(pos, message_obj)|{println!("{}: {}", pos, message_obj["message"])}); // talk_histories.as_array().unwrap().into_iter().enumerate().for_each(|(pos, message_obj)|{println!("{}: {}", pos, message_obj["message"])});
// find the bot transfer message // find the bot transfer message
let bot_transfer_message = talk_histories let bot_transfer_message = talk_histories
.as_array().expect("Wrong message type received from talk histories").into_iter() .as_array()
.enumerate() .expect("Wrong message type received from talk histories")
.filter(|(pos, message_object)| { .into_iter()
let user_name = message_object["user"]["name"].as_str().expect("Failed to decode message as string"); .enumerate()
user_name == "PipeBot".to_string() .filter(|(pos, message_object)| {
}).find(|(pos, message_object)|{ let user_name = message_object["user"]["name"]
let message = message_object["message"].as_str().expect("Failed to decode message as string"); .as_str()
// let found = message.find("Atendimento transferido para a fila [NovaNet -> Atendimento -> Suporte]"); .expect("Failed to decode message as string");
let found = message.find("Atendimento entregue da fila de espera para o agente"); user_name == "PipeBot".to_string()
found.is_some() })
}); .find(|(pos, message_object)| {
let message = message_object["message"]
.as_str()
.expect("Failed to decode message as string");
// let found = message.find("Atendimento transferido para a fila [NovaNet -> Atendimento -> Suporte]");
let found =
message.find("Atendimento entregue da fila de espera para o agente");
found.is_some()
});
// Find first agent message sent after the last bot message // Find first agent message sent after the last bot message
let (pos, transfer_message) = bot_transfer_message.expect("Failed to get the transfer bot message position"); let (pos, transfer_message) =
bot_transfer_message.expect("Failed to get the transfer bot message position");
let msg = talk_histories.as_array().expect("Wrong message type received from talk histories").into_iter()
.take(pos) let msg = talk_histories
.rev() .as_array()
.filter(|message| { .expect("Wrong message type received from talk histories")
message["type"] == "out".to_string() && message["user"]["name"] != "PipeBot".to_string() .into_iter()
}) .take(pos)
.take(1).collect_vec(); .rev()
.filter(|message| {
message["type"] == "out".to_string()
&& message["user"]["name"] != "PipeBot".to_string()
})
.take(1)
.collect_vec();
let agent_first_message = msg[0]; let agent_first_message = msg[0];
// Calculate time difference between bot message and agent message // Calculate time difference between bot message and agent message
let date_user_message_sent = agent_first_message["sent_at"].as_str().unwrap(); let date_user_message_sent = agent_first_message["sent_at"].as_str().unwrap();
let format = "%Y-%m-%d %H:%M:%S"; let format = "%Y-%m-%d %H:%M:%S";
let date_user_message_sent_parsed = match chrono::NaiveDateTime::parse_from_str(date_user_message_sent, format) { let date_user_message_sent_parsed =
Ok(dt) => dt, match chrono::NaiveDateTime::parse_from_str(date_user_message_sent, format) {
Err(e) => {println!("Error parsing DateTime: {}", e); panic!("Failed parsing date")}, Ok(dt) => dt,
Err(e) => {
println!("Error parsing DateTime: {}", e);
panic!("Failed parsing date")
}
};
let date_transfer_message_sent_parsed = match chrono::NaiveDateTime::parse_from_str(
transfer_message["sent_at"].as_str().unwrap(),
format,
) {
Ok(dt) => dt,
Err(e) => {
println!("Error parsing DateTime: {}", e);
panic!("Failed parsing date")
}
}; };
let date_transfer_message_sent_parsed = match chrono::NaiveDateTime::parse_from_str(transfer_message["sent_at"].as_str().unwrap(), format) { let response_time = (date_user_message_sent_parsed - date_transfer_message_sent_parsed)
Ok(dt) => dt, .as_seconds_f32();
Err(e) => {println!("Error parsing DateTime: {}", e); panic!("Failed parsing date")}, let name = agent_first_message["user"]["name"]
}; .as_str()
.unwrap()
let response_time = (date_user_message_sent_parsed - date_transfer_message_sent_parsed).as_seconds_f32(); .to_owned();
let name = agent_first_message["user"]["name"].as_str().unwrap().to_owned();
let id = json["tracking_number"].as_str().unwrap_or("").to_owned(); let id = json["tracking_number"].as_str().unwrap_or("").to_owned();
let bot_transfer_date = date_transfer_message_sent_parsed.to_owned(); let bot_transfer_date = date_transfer_message_sent_parsed.to_owned();
let user_response_date = date_user_message_sent.to_owned(); let user_response_date = date_user_message_sent.to_owned();
println!("response_time: {}s", (date_user_message_sent_parsed - date_transfer_message_sent_parsed).as_seconds_f32()); println!(
"response_time: {}s",
(date_user_message_sent_parsed - date_transfer_message_sent_parsed)
.as_seconds_f32()
);
format!("{};{};{};{};{}", name, id, response_time, bot_transfer_date, user_response_date) format!(
}).reduce(|acc, e|{format!("{}\n{}",acc,e)}) "{};{};{};{};{}",
name, id, response_time, bot_transfer_date, user_response_date
)
})
.reduce(|acc, e| format!("{}\n{}", acc, e))
.unwrap_or("".to_string()); .unwrap_or("".to_string());
// return Ok(()); // return Ok(());
// Open file and write to it // Open file and write to it
let header = "NOME;ID_TALK;TEMPO DE RESPOSTA;TRANFERENCIA PELO BOT;PRIMEIRA RESPOSTA DO AGENTE"; let header = "NOME;ID_TALK;TEMPO DE RESPOSTA;TRANFERENCIA PELO BOT;PRIMEIRA RESPOSTA DO AGENTE";
let mut response_time_file = std::fs::OpenOptions::new().write(true).open(format!("./evaluations/{formatted_day_before}/response_time.csv")).expect("Failed to open response time file for write"); let mut response_time_file = std::fs::OpenOptions::new()
response_time_file.write_all(format!("{header}\n{response_time}").as_bytes()).expect("Failed to write header to file"); .write(true)
.open(format!(
"./evaluations/{formatted_day_before}/response_time.csv"
))
.expect("Failed to open response time file for write");
response_time_file
.write_all(format!("{header}\n{response_time}").as_bytes())
.expect("Failed to write header to file");
filtered_chats filtered_chats.clone().skip(0).take(10).for_each(|result| {
.clone() let json = result.unwrap();
.skip(0) let talk_histories = &json["talk_histories"];
.take(10) let data = &talk_histories["data"];
.for_each(|result| {
let json = result.unwrap();
let talk_histories = &json["talk_histories"];
let data = &talk_histories["data"];
let talk = talk_histories.as_array().expect("Wrong message type received from talk histories").iter().rev().map(|message_object|
{
let new_json_filtered = format!( let talk = talk_histories
"{{ .as_array()
.expect("Wrong message type received from talk histories")
.iter()
.rev()
.map(|message_object| {
let new_json_filtered = format!(
"{{
message: {}, message: {},
sent_at: {}, sent_at: {},
type: {}, type: {},
@@ -350,44 +447,71 @@ fn main() -> anyhow::Result<()> {
); );
// println!("{}", new_json_filtered); // println!("{}", new_json_filtered);
new_json_filtered new_json_filtered
}).reduce(|acc, e| {format!("{acc}\n{e}")}).expect("Error extracting talk"); })
.reduce(|acc, e| format!("{acc}\n{e}"))
.expect("Error extracting talk");
println!("{prompt}\n {talk}"); println!("{prompt}\n {talk}");
let ollama_api_request = client.post(format!("http://{OLLAMA_SANITIZED_IP}:{OLLAMA_PORT}/api/generate")) let ollama_api_request = client
.body( .post(format!(
serde_json::json!({ "http://{OLLAMA_SANITIZED_IP}:{OLLAMA_PORT}/api/generate"
"model": OLLAMA_AI_MODEL, ))
"prompt": format!("{prompt} \n{talk}"), .body(
// "options": serde_json::json!({"temperature": 0.1}), serde_json::json!({
"stream": false, "model": OLLAMA_AI_MODEL,
}).to_string() "prompt": format!("{prompt} \n{talk}"),
); // "options": serde_json::json!({"temperature": 0.1}),
"stream": false,
})
.to_string(),
);
let result = ollama_api_request.timeout(Duration::from_secs(3600)).send(); let result = ollama_api_request.timeout(Duration::from_secs(3600)).send();
match result { match result {
Ok(response) => {println!("Response: {:?}", response); Ok(response) => {
let response_json = response.json::<serde_json::Value>().expect("Failed to deserialize response to JSON"); println!("Response: {:?}", response);
println!("{}", response_json); let response_json = response
let ai_response = response_json["response"] .json::<serde_json::Value>()
.as_str() .expect("Failed to deserialize response to JSON");
.expect("Failed to get AI response as string"); println!("{}", response_json);
println!("AI Response: {}", ai_response); let ai_response = response_json["response"]
.as_str()
.expect("Failed to get AI response as string");
println!("AI Response: {}", ai_response);
let csv_response = ai_response.replace("```csv\n", "").replace("```", ""); let csv_response = ai_response.replace("```csv\n", "").replace("```", "");
// Save the CSV response to a file // Save the CSV response to a file
let user_name = &json["agent"]["user"]["name"].as_str().unwrap_or("unknown_user"); let user_name = &json["agent"]["user"]["name"]
let talk_id = &json["id"].as_u64().unwrap_or(0); .as_str()
let tracking_number = &json["tracking_number"].as_str().unwrap_or(""); .unwrap_or("unknown_user");
std::fs::write(format!("./evaluations/{}/{} - {} - {}.csv", formatted_day_before, user_name, talk_id, tracking_number), csv_response).expect("Unable to write file"); let talk_id = &json["id"].as_u64().unwrap_or(0);
std::fs::write(format!("./evaluations/{}/{} - {} - {} - prompt.txt", formatted_day_before, user_name, talk_id, tracking_number), format!("{prompt} \n{talk}")).expect("Unable to write file"); let tracking_number = &json["tracking_number"].as_str().unwrap_or("");
}, std::fs::write(
Err(error) => {println!("Error {error}");} format!(
}; "./evaluations/{}/{} - {} - {}.csv",
}); formatted_day_before, user_name, talk_id, tracking_number
),
csv_response,
)
.expect("Unable to write file");
std::fs::write(
format!(
"./evaluations/{}/{} - {} - {} - prompt.txt",
formatted_day_before, user_name, talk_id, tracking_number
),
format!("{prompt} \n{talk}"),
)
.expect("Unable to write file");
}
Err(error) => {
println!("Error {error}");
}
};
});
// Compress folder into zip // Compress folder into zip
let source_dir_str = format!("./evaluations/{formatted_day_before}"); let source_dir_str = format!("./evaluations/{formatted_day_before}");
@@ -410,7 +534,13 @@ fn main() -> anyhow::Result<()> {
return Ok(()); return Ok(());
} }
fn get_piperun_chats_on_date(PIPERUN_API_URL: &String, client: &reqwest::blocking::Client, access_token: &String, formatted_day_before_at_midnight: String, formatted_day_before_at_23_59_59: String) -> Vec<serde_json::Value> { fn get_piperun_chats_on_date(
PIPERUN_API_URL: &String,
client: &reqwest::blocking::Client,
access_token: &String,
formatted_day_before_at_midnight: String,
formatted_day_before_at_23_59_59: String,
) -> Vec<serde_json::Value> {
let start_of_talk_code: String = "talk_start".to_string(); let start_of_talk_code: String = "talk_start".to_string();
let support_queue_id: String = "13".to_string(); let support_queue_id: String = "13".to_string();
@@ -455,57 +585,70 @@ fn get_piperun_chats_on_date(PIPERUN_API_URL: &String, client: &reqwest::blockin
} }
}; };
let mut aggregated_talks = json_response["data"].as_array().expect("Failed to parse messages as array").to_owned(); let mut aggregated_talks = json_response["data"]
.as_array()
.expect("Failed to parse messages as array")
.to_owned();
let current_page = json_response["current_page"].as_i64().expect("Failed to obtain current page number"); let current_page = json_response["current_page"]
let last_page = json_response["last_page"].as_i64().expect("Failed to obtain current page number"); .as_i64()
.expect("Failed to obtain current page number");
let last_page = json_response["last_page"]
.as_i64()
.expect("Failed to obtain current page number");
let mut all_other_messages = (current_page..last_page).into_iter() let mut all_other_messages = (current_page..last_page)
.map(|page| { .into_iter()
let page_to_request = page + 1; .map(|page| {
let talks_request = client let page_to_request = page + 1;
.get(format!("https://{}/api/v2/reports/talks", PIPERUN_API_URL)) let talks_request = client
.bearer_auth(access_token) .get(format!("https://{}/api/v2/reports/talks", PIPERUN_API_URL))
.header("Content-Type", "application/json") .bearer_auth(access_token)
.header("Accept", "application/json") .header("Content-Type", "application/json")
.query(&[ .header("Accept", "application/json")
("page", page_to_request.to_string()), .query(&[
("perPage", per_page.clone()), ("page", page_to_request.to_string()),
("report_type", report_type.clone()), ("perPage", per_page.clone()),
("start_date", formatted_day_before_at_midnight.clone()), ("report_type", report_type.clone()),
("end_date", formatted_day_before_at_23_59_59.clone()), ("start_date", formatted_day_before_at_midnight.clone()),
("date_range_type", start_of_talk_code.clone()), ("end_date", formatted_day_before_at_23_59_59.clone()),
("queue_id[]", support_queue_id.clone()), ("date_range_type", start_of_talk_code.clone()),
]); ("queue_id[]", support_queue_id.clone()),
]);
println!("Sending request for consolidated talks... {talks_request:?}"); println!("Sending request for consolidated talks... {talks_request:?}");
let talks_response = talks_request.send(); let talks_response = talks_request.send();
let json_response = match talks_response { let json_response = match talks_response {
Ok(resp) => { Ok(resp) => {
if resp.status().is_success() { if resp.status().is_success() {
let json: serde_json::Value = resp.json().unwrap(); let json: serde_json::Value = resp.json().unwrap();
json json
} else { } else {
eprintln!("Failed to get consolidated talks: {}", resp.status()); eprintln!("Failed to get consolidated talks: {}", resp.status());
let json: serde_json::Value = resp.json().unwrap(); let json: serde_json::Value = resp.json().unwrap();
eprintln!("Response body: {:?}", json); eprintln!("Response body: {:?}", json);
panic!("Failed to retrieve consolidated talks from Piperun API"); panic!("Failed to retrieve consolidated talks from Piperun API");
} }
} }
Err(e) => { Err(e) => {
eprintln!("Error: {e}"); eprintln!("Error: {e}");
panic!("Failed to send the request for talks to PipeRUN API"); panic!("Failed to send the request for talks to PipeRUN API");
} }
}; };
let aggregated_talks = json_response["data"].as_array().expect("Failed to parse messages as array").to_owned(); let aggregated_talks = json_response["data"]
.as_array()
return aggregated_talks; .expect("Failed to parse messages as array")
}) .to_owned();
.reduce(|mut this, mut acc| {acc.append(&mut this); acc})
.expect("Failed to concatenate all vectors of messages");
return aggregated_talks;
})
.reduce(|mut this, mut acc| {
acc.append(&mut this);
acc
})
.expect("Failed to concatenate all vectors of messages");
aggregated_talks.append(&mut all_other_messages); aggregated_talks.append(&mut all_other_messages);
aggregated_talks aggregated_talks
@@ -596,7 +739,7 @@ fn send_email(
let filebody = std::fs::read(zip_file_name).unwrap(); let filebody = std::fs::read(zip_file_name).unwrap();
let content_type = ContentType::parse("application/zip").unwrap(); let content_type = ContentType::parse("application/zip").unwrap();
let attachment = Attachment::new(zip_file_name.to_string()).body(filebody, content_type); let attachment = Attachment::new(zip_file_name.to_string()).body(filebody, content_type);
let mailboxes : Mailboxes = to.parse().unwrap(); let mailboxes: Mailboxes = to.parse().unwrap();
let to_header: message::header::To = mailboxes.into(); let to_header: message::header::To = mailboxes.into();
let email = Message::builder() let email = Message::builder()