botserver/src/basic/keywords/format.rs

use rhai::{Dynamic, Engine};
use chrono::{NaiveDateTime, Timelike, Datelike};
use num_format::{Locale, ToFormattedString};
use std::str::FromStr;
pub fn format_keyword(engine: &mut Engine) {
 engine
 .register_custom_syntax(&["FORMAT", "$expr$", "$expr$"], false, {
 move |context, inputs| {
 let value_dyn = context.eval_expression_tree(&inputs[0])?;
 let pattern_dyn = context.eval_expression_tree(&inputs[1])?;
 let value_str = value_dyn.to_string();
 let pattern = pattern_dyn.to_string();
 if let Ok(num) = f64::from_str(&value_str) {
 let formatted = if pattern.starts_with("N") || pattern.starts_with("C") {
 let (prefix, decimals, locale_tag) = parse_pattern(&pattern);
 let locale = get_locale(&locale_tag);
 let symbol = if prefix == "C" { get_currency_symbol(&locale_tag) } else { "" };
 let int_part = num.trunc() as i64;
 let frac_part = num.fract();
 if decimals == 0 {
 format!("{}{}", symbol, int_part.to_formatted_string(&locale))
 } else {
 let frac_scaled = ((frac_part * 10f64.powi(decimals as i32)).round()) as i64;
 let decimal_sep = match locale_tag.as_str() {
 "pt" | "fr" | "es" | "it" | "de" => ",",
 _ => "."
 };
 format!("{}{}{}{:0width$}", symbol, int_part.to_formatted_string(&locale), decimal_sep, frac_scaled, width = decimals)
 }
 } else {
 match pattern.as_str() {
 "n" => format!("{:.2}", num),
 "F" => format!("{:.2}", num),
 "f" => format!("{}", num),
 "0%" => format!("{:.0}%", num * 100.0),
 _ => format!("{}", num),
 }
 };
 return Ok(Dynamic::from(formatted));
 }
 if let Ok(dt) = NaiveDateTime::parse_from_str(&value_str, "%Y-%m-%d %H:%M:%S") {
 let formatted = apply_date_format(&dt, &pattern);
 return Ok(Dynamic::from(formatted));
 }
 let formatted = apply_text_placeholders(&value_str, &pattern);
 Ok(Dynamic::from(formatted))
 }
 })
 .unwrap();
}
fn parse_pattern(pattern: &str) -> (String, usize, String) {
 let mut prefix = String::new();
 let mut decimals: usize = 2;
 let mut locale_tag = "en".to_string();
 if pattern.starts_with('C') {
 prefix = "C".to_string();
 } else if pattern.starts_with('N') {
 prefix = "N".to_string();
 }
 let rest = &pattern[1..];
 let mut num_part = String::new();
 for ch in rest.chars() {
 if ch.is_ascii_digit() {
 num_part.push(ch);
 } else {
 break;
 }
 }
 if !num_part.is_empty() {
 decimals = num_part.parse().unwrap_or(2);
 }
 if let Some(start) = pattern.find('[') {
 if let Some(end) = pattern.find(']') {
 if end > start {
 locale_tag = pattern[start + 1..end].to_string();
 }
 }
 }
 (prefix, decimals, locale_tag)
}
fn get_locale(tag: &str) -> Locale {
 match tag {
 "en" => Locale::en,
 "fr" => Locale::fr,
 "de" => Locale::de,
 "pt" => Locale::pt,
 "it" => Locale::it,
 "es" => Locale::es,
 _ => Locale::en,
 }
}
fn get_currency_symbol(tag: &str) -> &'static str {
 match tag {
 "en" => "$",
 "pt" => "R$ ",
 "fr" | "de" | "es" | "it" => "€",
 _ => "$",
 }
}
fn apply_date_format(dt: &NaiveDateTime, pattern: &str) -> String {
 let mut output = pattern.to_string();
 let year = dt.year();
 let month = dt.month();
 let day = dt.day();
 let hour24 = dt.hour();
 let minute = dt.minute();
 let second = dt.second();
 let millis = dt.and_utc().timestamp_subsec_millis();
 output = output.replace("yyyy", &format!("{:04}", year));
 output = output.replace("yy", &format!("{:02}", year % 100));
 output = output.replace("MM", &format!("{:02}", month));
 output = output.replace("M", &format!("{}", month));
 output = output.replace("dd", &format!("{:02}", day));
 output = output.replace("d", &format!("{}", day));
 output = output.replace("HH", &format!("{:02}", hour24));
 output = output.replace("H", &format!("{}", hour24));
 let mut hour12 = hour24 % 12;
 if hour12 == 0 { hour12 = 12; }
 output = output.replace("hh", &format!("{:02}", hour12));
 output = output.replace("h", &format!("{}", hour12));
 output = output.replace("mm", &format!("{:02}", minute));
 output = output.replace("m", &format!("{}", minute));
 output = output.replace("ss", &format!("{:02}", second));
 output = output.replace("s", &format!("{}", second));
 output = output.replace("fff", &format!("{:03}", millis));
 output = output.replace("tt", if hour24 < 12 { "AM" } else { "PM" });
 output = output.replace("t", if hour24 < 12 { "A" } else { "P" });
 output
}
fn apply_text_placeholders(value: &str, pattern: &str) -> String {
 let mut result = String::new();
 let mut i = 0;
 let chars: Vec<char> = pattern.chars().collect();
 while i < chars.len() {
 match chars[i] {
 '@' => result.push_str(value),
 '&' => {
 result.push_str(&value.to_lowercase());
 if i + 1 < chars.len() {
 match chars[i+1] {
 '!' => {
 result.push('!');
 i += 1;
 }
 '>' => {
 i += 1;
 }
 _ => ()
 }
 }
 }
 '>' | '!' => result.push_str(&value.to_uppercase()),
 _ => result.push(chars[i]),
 }
 i += 1;
 }
 result
}