server/command/

split.rs

use finance::{split::Split, tag::Tag};
use sqlx::types::Uuid;
use std::{collections::HashMap, fmt::Debug};
use supp_macro::command;

use super::{CmdError, CmdResult};
use crate::{command::FinanceEntity, config::ConfigError, user::User};

command! {
    ListSplits {
        #[required]
        user_id: Uuid,
        #[optional]
        account: Uuid,
        #[optional]
        transaction: Uuid,
    } => {
        let user = User { id: user_id };
        let mut conn = user.get_connection().await.map_err(|err| {
            log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
            ConfigError::DB
        })?;

        // Ensure at least one filter is provided
        if account.is_none() && transaction.is_none() {
            return Err(CmdError::Args(
                "At least one filter (account or transaction) is required".to_string(),
            ));
        }

        // Execute the appropriate query based on provided filters
        let splits = match (account, transaction) {
            (Some(account_id), Some(tx_id)) => {
                // Filter by both account and transaction
                sqlx::query_file_as!(
                    Split,
                    "sql/select/splits/by_account_and_transaction.sql",
                    account_id,
                    tx_id
                )
                .fetch_all(&mut *conn)
                .await?
            }
            (Some(account_id), None) => {
                // Filter by account only
                sqlx::query_file_as!(
                    Split,
                    "sql/select/splits/by_account.sql",
                    account_id
                )
                .fetch_all(&mut *conn)
                .await?
            }
            (None, Some(tx_id)) => {
                // Filter by transaction only
                sqlx::query_file_as!(
                    Split,
                    "sql/select/splits/by_transaction.sql",
                    tx_id
                )
                .fetch_all(&mut *conn)
                .await?
            }
            _ => unreachable!(), // We already checked this case above
        };

        // Convert Split objects to tagged entities
        let mut split_entities = Vec::new();
        for split in splits {
            // Get tags for this split
            let tags: HashMap<String, FinanceEntity> = sqlx::query_file!(
                "sql/select/tags/by_split.sql",
                split.id
            )
            .fetch_all(&mut *conn)
            .await?
            .into_iter()
            .map(|row| {
                (
                    row.tag_name.clone(),
                    FinanceEntity::Tag(Tag {
                        id: row.id,
                        tag_name: row.tag_name,
                        tag_value: row.tag_value,
                        description: row.description,
                    }),
                )
            })
            .collect();

            split_entities.push((FinanceEntity::Split(split), tags));
        }

        Ok(Some(CmdResult::TaggedEntities {
            entities: split_entities,
            pagination: None,
        }))
    }
}

#[cfg(test)]
mod command_tests {
    use super::*;
    use crate::{
        command::{
            account::CreateAccount, commodity::CreateCommodity, transaction::CreateTransaction,
        },
        db::DB_POOL,
    };
    use sqlx::{PgPool, types::chrono::Utc};
    use supp_macro::local_db_sqlx_test;
    use tokio::sync::OnceCell;

    /// Context for keeping environment intact
    static CONTEXT: OnceCell<()> = OnceCell::const_new();
    static USER: OnceCell<User> = OnceCell::const_new();

    async fn setup() {
        CONTEXT
            .get_or_init(|| async {
                #[cfg(feature = "testlog")]
                let _ = env_logger::builder()
                    .is_test(true)
                    .filter_level(log::LevelFilter::Trace)
                    .try_init();
            })
            .await;
        USER.get_or_init(|| async { User { id: Uuid::new_v4() } })
            .await;
    }

    #[local_db_sqlx_test]
    async fn test_list_splits(pool: PgPool) -> anyhow::Result<()> {
        let user = USER.get().unwrap();
        user.commit()
            .await
            .expect("Failed to commit user to database");

        // First create a commodity
        let commodity_result = CreateCommodity::new()
            .symbol("TST".to_string())
            .name("Test Commodity".to_string())
            .user_id(user.id)
            .run()
            .await?;

        // Get the commodity ID
        let commodity_id = if let Some(CmdResult::String(id)) = commodity_result {
            uuid::Uuid::parse_str(&id)?
        } else {
            panic!("Expected commodity ID string result");
        };

        // Create two accounts
        let account1 = if let Some(CmdResult::Entity(FinanceEntity::Account(account))) =
            CreateAccount::new()
                .name("Account 1".to_string())
                .user_id(user.id)
                .run()
                .await?
        {
            account
        } else {
            panic!("Expected account entity result");
        };

        let account2 = if let Some(CmdResult::Entity(FinanceEntity::Account(account))) =
            CreateAccount::new()
                .name("Account 2".to_string())
                .user_id(user.id)
                .run()
                .await?
        {
            account
        } else {
            panic!("Expected account entity result");
        };

        // Create a transaction between the accounts
        let tx_id = Uuid::new_v4();
        let now = Utc::now();

        let split1_id = Uuid::new_v4();
        let split1 = Split {
            id: split1_id,
            tx_id,
            account_id: account1.id,
            commodity_id,
            value_num: -100,
            value_denom: 1,
            reconcile_state: None,
            reconcile_date: None,
            lot_id: None,
        };

        let split2_id = Uuid::new_v4();
        let split2 = Split {
            id: split2_id,
            tx_id,
            account_id: account2.id,
            commodity_id,
            value_num: 100,
            value_denom: 1,
            reconcile_state: None,
            reconcile_date: None,
            lot_id: None,
        };

        let splits = vec![FinanceEntity::Split(split1), FinanceEntity::Split(split2)];
        CreateTransaction::new()
            .user_id(user.id)
            .splits(splits)
            .id(tx_id)
            .post_date(now)
            .enter_date(now)
            .note("Test transaction".to_string())
            .run()
            .await?;

        // List splits for account1
        if let Some(CmdResult::TaggedEntities { entities, .. }) = ListSplits::new()
            .user_id(user.id)
            .account(account1.id)
            .run()
            .await?
        {
            assert_eq!(entities.len(), 1, "Expected one split for account1");

            let (entity, _tags) = &entities[0];
            if let FinanceEntity::Split(split) = entity {
                assert_eq!(split.id, split1_id);
                assert_eq!(split.account_id, account1.id);
                assert_eq!(split.value_num, -100);
                assert_eq!(split.value_denom, 1);
            } else {
                panic!("Expected Split entity");
            }
        } else {
            panic!("Expected TaggedEntities result");
        }

        // List splits for account2
        if let Some(CmdResult::TaggedEntities { entities, .. }) = ListSplits::new()
            .user_id(user.id)
            .account(account2.id)
            .run()
            .await?
        {
            assert_eq!(entities.len(), 1, "Expected one split for account2");

            let (entity, _tags) = &entities[0];
            if let FinanceEntity::Split(split) = entity {
                assert_eq!(split.id, split2_id);
                assert_eq!(split.account_id, account2.id);
                assert_eq!(split.value_num, 100);
                assert_eq!(split.value_denom, 1);
            } else {
                panic!("Expected Split entity");
            }
        } else {
            panic!("Expected TaggedEntities result");
        }

        // List splits for non-existent account
        if let Some(CmdResult::TaggedEntities { entities, .. }) = ListSplits::new()
            .user_id(user.id)
            .account(Uuid::new_v4())
            .run()
            .await?
        {
            assert_eq!(
                entities.len(),
                0,
                "Expected no splits for non-existent account"
            );
        } else {
            panic!("Expected TaggedEntities result");
        }
    }

    #[local_db_sqlx_test]
    async fn test_list_splits_by_transaction(pool: PgPool) -> anyhow::Result<()> {
        let user = USER.get().unwrap();
        user.commit()
            .await
            .expect("Failed to commit user to database");

        let commodity_result = CreateCommodity::new()
            .symbol("TRX".to_string())
            .name("Transaction Test Commodity".to_string())
            .user_id(user.id)
            .run()
            .await?;

        let commodity_id = if let Some(CmdResult::String(id)) = commodity_result {
            uuid::Uuid::parse_str(&id)?
        } else {
            panic!("Expected commodity ID string result");
        };

        let account1 = if let Some(CmdResult::Entity(FinanceEntity::Account(account))) =
            CreateAccount::new()
                .name("TxTest Account 1".to_string())
                .user_id(user.id)
                .run()
                .await?
        {
            account
        } else {
            panic!("Expected account entity result");
        };

        let account2 = if let Some(CmdResult::Entity(FinanceEntity::Account(account))) =
            CreateAccount::new()
                .name("TxTest Account 2".to_string())
                .user_id(user.id)
                .run()
                .await?
        {
            account
        } else {
            panic!("Expected account entity result");
        };

        let tx_id = Uuid::new_v4();
        let now = Utc::now();

        let split1_id = Uuid::new_v4();
        let split1 = Split {
            id: split1_id,
            tx_id,
            account_id: account1.id,
            commodity_id,
            value_num: -200,
            value_denom: 1,
            reconcile_state: None,
            reconcile_date: None,
            lot_id: None,
        };

        let split2_id = Uuid::new_v4();
        let split2 = Split {
            id: split2_id,
            tx_id,
            account_id: account2.id,
            commodity_id,
            value_num: 200,
            value_denom: 1,
            reconcile_state: None,
            reconcile_date: None,
            lot_id: None,
        };

        let splits = vec![FinanceEntity::Split(split1), FinanceEntity::Split(split2)];
        CreateTransaction::new()
            .user_id(user.id)
            .splits(splits)
            .id(tx_id)
            .post_date(now)
            .enter_date(now)
            .note("Transaction test".to_string())
            .run()
            .await?;

        if let Some(CmdResult::TaggedEntities { entities, .. }) = ListSplits::new()
            .user_id(user.id)
            .transaction(tx_id)
            .run()
            .await?
        {
            assert_eq!(entities.len(), 2, "Expected two splits for transaction");

            let split_ids: Vec<Uuid> = entities
                .iter()
                .filter_map(|(entity, _)| {
                    if let FinanceEntity::Split(s) = entity {
                        Some(s.id)
                    } else {
                        None
                    }
                })
                .collect();

            assert!(split_ids.contains(&split1_id));
            assert!(split_ids.contains(&split2_id));
        } else {
            panic!("Expected TaggedEntities result");
        }

        if let Some(CmdResult::TaggedEntities { entities, .. }) = ListSplits::new()
            .user_id(user.id)
            .transaction(Uuid::new_v4())
            .run()
            .await?
        {
            assert_eq!(
                entities.len(),
                0,
                "Expected no splits for non-existent transaction"
            );
        } else {
            panic!("Expected TaggedEntities result");
        }
    }
}