Lines
37.13 %
Functions
12.5 %
Branches
100 %
//web/src/pages/transaction/util.rs - Shared utility functions for transaction operations
use axum::{Json, http::StatusCode};
use chrono::{Local, NaiveDateTime};
use finance::price::Price;
use serde::Deserialize;
use server::command::{CmdResult, FinanceEntity, commodity::GetCommodity};
use sqlx::types::Uuid;
use std::collections::HashMap;
/// Common `SplitData` structure used by both create and edit
#[derive(Deserialize, Debug)]
pub struct SplitData {
pub split_id: Option<String>, // Only used by edit
pub amount: String,
pub amount_converted: String,
pub from_account: String,
pub to_account: String,
pub from_commodity: String,
pub to_commodity: String,
pub from_tags: Option<Vec<TagData>>,
pub to_tags: Option<Vec<TagData>>,
}
pub struct TagData {
pub name: String,
pub value: String,
pub description: Option<String>,
/// Result of processing a single split
pub struct ProcessedSplit {
pub from_split: finance::split::Split,
pub to_split: finance::split::Split,
pub price: Option<Price>,
pub from_split_tags: Option<Vec<TagData>>,
pub to_split_tags: Option<Vec<TagData>>,
/// Get commodity fraction for precise calculations
pub async fn get_commodity_fraction(
user_id: Uuid,
commodity_id: Uuid,
) -> Result<i64, (StatusCode, Json<serde_json::Value>)> {
if let Ok(Some(CmdResult::TaggedEntities {
entities: commodities,
..
})) = GetCommodity::new()
.user_id(user_id)
.commodity_id(commodity_id)
.run()
.await
{
if let Some((FinanceEntity::Commodity(c), _)) = commodities.first() {
Ok(c.fraction)
} else {
let error_response = serde_json::json!({
"status": "fail",
"message": "Commodity not found",
});
log::error!("Commodity not found");
Err((StatusCode::INTERNAL_SERVER_ERROR, Json(error_response)))
/// Get account name by ID
pub async fn get_account_name(
account_id: Uuid,
) -> Result<String, Box<dyn std::error::Error>> {
match server::command::account::GetAccount::new()
.account_id(account_id)
.await?
Some(CmdResult::TaggedEntities { entities, .. }) => {
if let Some((FinanceEntity::Account(_account), tags)) = entities.first() {
if let Some(FinanceEntity::Tag(name_tag)) = tags.get("name") {
Ok(name_tag.tag_value.clone())
Ok("Unnamed Account".to_string())
Ok("Unknown Account".to_string())
_ => Ok("Unknown Account".to_string()),
/// Get commodity symbol (or name as fallback) by ID
pub async fn get_commodity_name(
match GetCommodity::new()
if let Some((FinanceEntity::Commodity(_commodity), tags)) = entities.first() {
if let Some(FinanceEntity::Tag(symbol_tag)) = tags.get("symbol") {
Ok(symbol_tag.tag_value.clone())
} else if let Some(FinanceEntity::Tag(name_tag)) = tags.get("name") {
Ok("Unknown Currency".to_string())
_ => Ok("Unknown Currency".to_string()),
/// Parse date string or return current time
#[must_use]
pub fn parse_transaction_date(date_str: Option<&str>) -> NaiveDateTime {
if let Some(datetime_str) = date_str {
match chrono::DateTime::parse_from_rfc3339(datetime_str) {
Ok(datetime) => datetime.naive_utc(),
Err(_) => Local::now().naive_utc(),
Local::now().naive_utc()
/// Parse and validate UUID with custom error message
pub fn parse_uuid(
uuid_str: &str,
field_name: &str,
) -> Result<Uuid, (StatusCode, Json<serde_json::Value>)> {
Uuid::parse_str(uuid_str).map_err(|_| {
"message": format!("Invalid {}: {}", field_name, uuid_str),
(StatusCode::BAD_REQUEST, Json(error_response))
})
/// Validate basic amount parsing and positivity (without precision checking)
pub fn validate_basic_amount(
amount_str: &str,
) -> Result<f64, (StatusCode, Json<serde_json::Value>)> {
let amount_value = amount_str.parse::<f64>().map_err(|_| {
"message": format!("Invalid amount: {}", amount_str),
})?;
if amount_value <= 0.0 {
"message": t!("Split amount must be positive"),
return Err((StatusCode::BAD_REQUEST, Json(error_response)));
Ok(amount_value)
/// Validate and convert amount with precision checking
pub fn validate_and_convert_amount(
fraction: i64,
let amount_value = validate_basic_amount(amount_str)?;
let converted_amount = (amount_value * fraction as f64).round() as i64;
let reconverted_value = converted_amount as f64 / fraction as f64;
let epsilon = 0.5 / fraction as f64;
if (reconverted_value - amount_value).abs() > epsilon {
"message": format!("Precision loss detected: {} cannot be precisely represented with fraction {}", amount_str, fraction),
Ok(converted_amount)
/// Process a single split data into finance entities
pub async fn process_split_data(
tx_id: Uuid,
split_data: SplitData,
) -> Result<ProcessedSplit, (StatusCode, Json<serde_json::Value>)> {
validate_basic_amount(&split_data.amount)?;
let from_account_id = parse_uuid(&split_data.from_account, "from account ID")?;
let to_account_id = parse_uuid(&split_data.to_account, "to account ID")?;
let from_commodity = parse_uuid(&split_data.from_commodity, "from commodity ID")?;
let to_commodity = parse_uuid(&split_data.to_commodity, "to commodity ID")?;
// Only validate amount_converted if currency conversion is needed
let conversion = from_commodity != to_commodity;
if conversion {
validate_basic_amount(&split_data.amount_converted)?;
// Get commodity fractions
let from_fraction = get_commodity_fraction(user_id, from_commodity).await?;
let to_fraction = get_commodity_fraction(user_id, to_commodity).await?;
// Validate and convert amounts with full precision checking
let from_amount = validate_and_convert_amount(&split_data.amount, from_fraction)?;
let from_split_id = Uuid::new_v4();
let to_split_id = Uuid::new_v4();
let (converted_to_amount, price) = if conversion {
let to_amount = validate_and_convert_amount(&split_data.amount_converted, to_fraction)?;
let price = Price {
id: Uuid::new_v4(),
date: chrono::Utc::now(),
commodity_id: to_commodity,
currency_id: from_commodity,
commodity_split: Some(to_split_id),
currency_split: Some(from_split_id),
value_num: from_amount,
value_denom: to_amount,
};
(to_amount, Some(price))
(from_amount, None)
// Create split entities
let from_split = finance::split::Split {
id: from_split_id,
tx_id,
account_id: from_account_id,
commodity_id: from_commodity,
value_num: -from_amount,
value_denom: from_fraction,
reconcile_state: None,
reconcile_date: None,
lot_id: None,
let to_split = finance::split::Split {
id: to_split_id,
account_id: to_account_id,
value_num: if conversion {
converted_to_amount
from_amount
},
value_denom: if conversion {
to_fraction
from_fraction
Ok(ProcessedSplit {
from_split,
to_split,
price,
from_split_tags: split_data.from_tags,
to_split_tags: split_data.to_tags,
/// Create transaction tags from note
pub fn create_transaction_tags(note: Option<&str>) -> HashMap<String, FinanceEntity> {
let mut tags = HashMap::new();
if let Some(note_str) = note
&& !note_str.trim().is_empty()
let tag = finance::tag::Tag {
tag_name: "note".to_string(),
tag_value: note_str.to_string(),
description: None,
tags.insert("note".to_string(), FinanceEntity::Tag(tag));
tags
/// Validate that splits are not empty
pub fn validate_splits_not_empty<T>(
splits: &[T],
) -> Result<(), (StatusCode, Json<serde_json::Value>)> {
if splits.is_empty() {
"message": t!("At least one split is required for a transaction"),
Ok(())