rename category -> bucket

12 files changed, 283 insertions, 283 deletions

diff --git a/schist_core/schist_queries/src/bucket_transfers.rs b/schist_core/schist_queries/src/bucket_transfers.rs
new file mode 100644
index 0000000..2145944
--- /dev/null
+++ b/schist_core/schist_queries/src/bucket_transfers.rs
@@ -0,0 +1,74 @@
+use anyhow::{Context, Result};
+use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_schema::schema::bucket_transfers::{
+    self as bucket_transfers_schema,
+    dsl::bucket_transfers as bucket_transfers_table,
+};
+use schist_models::bucket_transfer::BucketTransfer;
+
+pub fn delete_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(bucket_transfers_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all bucket transfers")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<Vec<BucketTransfer>> {
+    let all_bucket_transfers = bucket_transfers_table
+        .select(BucketTransfer::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all bucket transfers")?;
+    Ok(all_bucket_transfers)
+}
+
+pub fn insert_bucket_transfers(
+    bucket_transfers: &[BucketTransfer],
+    connection: &mut SqliteConnection,
+) -> Result<usize> {
+    let num_rows_inserted = diesel::insert_into(bucket_transfers_table)
+        .values(bucket_transfers)
+        .execute(connection)
+        .with_context(|| insert_err_msg(&bucket_transfers))?;
+    Ok(num_rows_inserted)
+}
+
+fn insert_err_msg(bucket_transfers: &[BucketTransfer]) -> String {
+    format!(
+        "failed to insert bucket transfers: [{}]",
+        bucket_transfers
+            .iter()
+            .map(|ct| ct.id.to_string())
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
+
+pub fn sum_bucket_transfer_quantity_per_from_bucket_id(
+    connection: &mut SqliteConnection,
+) -> Result<Vec<(i32, i64)>> {
+    let sum = bucket_transfers_table
+        .group_by(bucket_transfers_schema::from_bucket_id)
+        .select((
+            bucket_transfers_schema::from_bucket_id,
+            sum(bucket_transfers_schema::quantity),
+        ))
+        .load::<(i32, Option<i64>)>(connection)
+        .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum bucket transfer quantity per from bucket ID")?;
+    Ok(sum)
+}
+
+pub fn sum_bucket_transfer_quantity_per_to_bucket_id(
+    connection: &mut SqliteConnection,
+) -> Result<Vec<(i32, i64)>> {
+    let sum = bucket_transfers_table
+        .group_by(bucket_transfers_schema::to_bucket_id)
+        .select((
+            bucket_transfers_schema::to_bucket_id,
+            sum(bucket_transfers_schema::quantity),
+        ))
+        .load::<(i32, Option<i64>)>(connection)
+        .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum bucket transfer quantity per to bucket ID")?;
+    Ok(sum)
+}
diff --git a/schist_core/schist_queries/src/buckets.rs b/schist_core/schist_queries/src/buckets.rs
new file mode 100644
index 0000000..c7cf213
--- /dev/null
+++ b/schist_core/schist_queries/src/buckets.rs
@@ -0,0 +1,49 @@
+use anyhow::{Context, Result};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::bucket::Bucket;
+use schist_schema::schema::buckets::{self as buckets_schema, dsl::buckets as buckets_table};
+
+pub fn delete_all_buckets(connection: &mut SqliteConnection) -> Result<usize> {
+    let num_rows_deleted = diesel::delete(buckets_table)
+        .execute(connection)
+        .with_context(|| "failed to delete all buckets")?;
+    Ok(num_rows_deleted)
+}
+
+pub fn get_all_buckets(connection: &mut SqliteConnection) -> Result<Vec<Bucket>> {
+    let all_buckets = buckets_table
+        .select(Bucket::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all buckets")?;
+    Ok(all_buckets)
+}
+
+pub fn get_all_bucket_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>> {
+    let all_bucket_ids = buckets_table
+        .select(buckets_schema::id)
+        .load(connection)
+        .with_context(|| "failed to get all bucket IDs")?;
+    Ok(all_bucket_ids)
+}
+
+pub fn insert_buckets(
+    buckets: &[Bucket],
+    connection: &mut SqliteConnection,
+) -> Result<usize> {
+    let num_buckets_inserted = diesel::insert_into(buckets_table)
+        .values(buckets)
+        .execute(connection)
+        .with_context(|| insert_err_msg(buckets))?;
+    Ok(num_buckets_inserted)
+}
+
+fn insert_err_msg(buckets: &[Bucket]) -> String {
+    format!(
+        "failed to insert buckets: [{}]",
+        buckets
+            .iter()
+            .map(|c| format!("\"{}\": \"{}\"", c.id, c.name))
+            .collect::<Vec<String>>()
+            .join(", ")
+    )
+}
diff --git a/schist_core/schist_queries/src/categories.rs b/schist_core/schist_queries/src/categories.rs
deleted file mode 100644
index f4a9747..0000000
--- a/schist_core/schist_queries/src/categories.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_models::category::Category;
-use schist_schema::schema::categories::{self as categories_schema, dsl::categories as categories_table};
-
-pub fn delete_all_categories(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(categories_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all categories")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_categories(connection: &mut SqliteConnection) -> Result<Vec<Category>> {
-    let all_categories = categories_table
-        .select(Category::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all categories")?;
-    Ok(all_categories)
-}
-
-pub fn get_all_category_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>> {
-    let all_category_ids = categories_table
-        .select(categories_schema::id)
-        .load(connection)
-        .with_context(|| "failed to get all category IDs")?;
-    Ok(all_category_ids)
-}
-
-pub fn insert_categories(
-    categories: &[Category],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_categories_inserted = diesel::insert_into(categories_table)
-        .values(categories)
-        .execute(connection)
-        .with_context(|| insert_err_msg(categories))?;
-    Ok(num_categories_inserted)
-}
-
-fn insert_err_msg(categories: &[Category]) -> String {
-    format!(
-        "failed to insert categories: [{}]",
-        categories
-            .iter()
-            .map(|c| format!("\"{}\": \"{}\"", c.id, c.name))
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
diff --git a/schist_core/schist_queries/src/category_transfers.rs b/schist_core/schist_queries/src/category_transfers.rs
deleted file mode 100644
index 33a53ea..0000000
--- a/schist_core/schist_queries/src/category_transfers.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_schema::schema::category_transfers::{
-    self as category_transfers_schema,
-    dsl::category_transfers as category_transfers_table,
-};
-use schist_models::category_transfer::CategoryTransfer;
-
-pub fn delete_all_category_transfers(connection: &mut SqliteConnection) -> Result<usize> {
-    let num_rows_deleted = diesel::delete(category_transfers_table)
-        .execute(connection)
-        .with_context(|| "failed to delete all category transfers")?;
-    Ok(num_rows_deleted)
-}
-
-pub fn get_all_category_transfers(connection: &mut SqliteConnection) -> Result<Vec<CategoryTransfer>> {
-    let all_category_transfers = category_transfers_table
-        .select(CategoryTransfer::as_select())
-        .load(connection)
-        .with_context(|| "failed to get all category transfers")?;
-    Ok(all_category_transfers)
-}
-
-pub fn insert_category_transfers(
-    category_transfers: &[CategoryTransfer],
-    connection: &mut SqliteConnection,
-) -> Result<usize> {
-    let num_rows_inserted = diesel::insert_into(category_transfers_table)
-        .values(category_transfers)
-        .execute(connection)
-        .with_context(|| insert_err_msg(&category_transfers))?;
-    Ok(num_rows_inserted)
-}
-
-fn insert_err_msg(category_transfers: &[CategoryTransfer]) -> String {
-    format!(
-        "failed to insert category transfers: [{}]",
-        category_transfers
-            .iter()
-            .map(|ct| ct.id.to_string())
-            .collect::<Vec<String>>()
-            .join(", ")
-    )
-}
-
-pub fn sum_category_transfer_quantity_per_from_category_id(
-    connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
-    let sum = category_transfers_table
-        .group_by(category_transfers_schema::from_category_id)
-        .select((
-            category_transfers_schema::from_category_id,
-            sum(category_transfers_schema::quantity),
-        ))
-        .load::<(i32, Option<i64>)>(connection)
-        .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum category transfer quantity per from category ID")?;
-    Ok(sum)
-}
-
-pub fn sum_category_transfer_quantity_per_to_category_id(
-    connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
-    let sum = category_transfers_table
-        .group_by(category_transfers_schema::to_category_id)
-        .select((
-            category_transfers_schema::to_category_id,
-            sum(category_transfers_schema::quantity),
-        ))
-        .load::<(i32, Option<i64>)>(connection)
-        .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum category transfer quantity per to category ID")?;
-    Ok(sum)
-}
diff --git a/schist_core/schist_queries/src/clear.rs b/schist_core/schist_queries/src/clear.rs
index 7cee699..6d2894d 100644
--- a/schist_core/schist_queries/src/clear.rs
+++ b/schist_core/schist_queries/src/clear.rs
@@ -2,14 +2,14 @@ use anyhow::Result;
 use diesel::SqliteConnection;
 
 use crate::{
-    accounts::delete_all_accounts, budget_drips::delete_all_budget_drips, categories::delete_all_categories, category_transfers::delete_all_category_transfers, transaction_categorisations::delete_all_transaction_categorisations, transactions::delete_all_transactions
+    accounts::delete_all_accounts, budget_drips::delete_all_budget_drips, buckets::delete_all_buckets, bucket_transfers::delete_all_bucket_transfers, transaction_categorisations::delete_all_transaction_categorisations, transactions::delete_all_transactions
 };
 
 pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
     delete_all_accounts(connection)?;
     delete_all_budget_drips(connection)?;
-    delete_all_categories(connection)?;
-    delete_all_category_transfers(connection)?;
+    delete_all_buckets(connection)?;
+    delete_all_bucket_transfers(connection)?;
     delete_all_transactions(connection)?;
     delete_all_transaction_categorisations(connection)?;
     Ok(())
diff --git a/schist_core/schist_queries/src/lib.rs b/schist_core/schist_queries/src/lib.rs
index a1a5c20..e3e5488 100644
--- a/schist_core/schist_queries/src/lib.rs
+++ b/schist_core/schist_queries/src/lib.rs
@@ -1,8 +1,8 @@
 pub mod accounts;
 pub mod account_transfers;
 pub mod budget_drips;
-pub mod categories;
-pub mod category_transfers;
+pub mod buckets;
+pub mod bucket_transfers;
 pub mod clear;
 pub mod transactions;
 pub mod transaction_categorisations;
diff --git a/schist_core/schist_queries/src/transaction_categorisations.rs b/schist_core/schist_queries/src/transaction_categorisations.rs
index 320782d..95aaf8d 100644
--- a/schist_core/schist_queries/src/transaction_categorisations.rs
+++ b/schist_core/schist_queries/src/transaction_categorisations.rs
@@ -43,17 +43,17 @@ fn insert_err_msg(transaction_categorisations: &[TransactionCategorisation]) ->
     )
 }
 
-pub fn sum_transaction_categorisation_quantity_per_category_id(
+pub fn sum_transaction_categorisation_quantity_per_bucket_id(
     connection: &mut SqliteConnection,
 ) -> Result<Vec<(i32, i64)>> {
     let sum = transaction_categorisations_table
-        .group_by(transaction_categorisations_schema::category_id)
+        .group_by(transaction_categorisations_schema::bucket_id)
         .select((
-            transaction_categorisations_schema::category_id,
+            transaction_categorisations_schema::bucket_id,
             sum(transaction_categorisations_schema::quantity),
         ))
         .load::<(i32, Option<i64>)>(connection)
-        .map(|vec| vec.iter().map(|(category_id, sum)| (*category_id, sum.unwrap_or(0))).collect())
-        .with_context(|| "failed to sum transaction categorisation quantity per category ID")?;
+        .map(|vec| vec.iter().map(|(bucket_id, sum)| (*bucket_id, sum.unwrap_or(0))).collect())
+        .with_context(|| "failed to sum transaction categorisation quantity per bucket ID")?;
     Ok(sum)
 }
diff --git a/schist_core/schist_queries/src/transactions.rs b/schist_core/schist_queries/src/transactions.rs
index 70b14e7..5941ebc 100644
--- a/schist_core/schist_queries/src/transactions.rs
+++ b/schist_core/schist_queries/src/transactions.rs
@@ -14,7 +14,7 @@ pub fn get_all_transactions(connection: &mut SqliteConnection) -> Result<Vec<Tra
     let all_transactions = transactions_table
         .select(Transaction::as_select())
         .load(connection)
-        .with_context(|| "failed to get all category transfers")?;
+        .with_context(|| "failed to get all bucket transfers")?;
     Ok(all_transactions)
 }
 
diff --git a/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs b/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
new file mode 100644
index 0000000..5194084
--- /dev/null
+++ b/schist_core/schist_queries/src/utils/calculate_bucket_balance.rs
@@ -0,0 +1,130 @@
+use anyhow::Result;
+use schist_models::{bucket::Bucket, budget_drip::BudgetDrip};
+
+use super::{calculate_budgets_accrual, find_by_id_or};
+
+pub fn calculate_bucket_balance(
+    bucket: &Bucket,
+    transaction_sums: &[(i32, i64)],
+    bucket_transfer_from_sums: &[(i32, i64)],
+    bucket_transfer_to_sums: &[(i32, i64)],
+    budget_drips: &[BudgetDrip],
+) -> Result<i64> {
+    let transaction_sum = find_by_id_or(transaction_sums, bucket.id, 0);
+    let bucket_transfer_from_sum = find_by_id_or(bucket_transfer_from_sums, bucket.id, 0);
+    let bucket_transfer_to_sum = find_by_id_or(bucket_transfer_to_sums, bucket.id, 0);
+    let budget_accruals_sum = calculate_budgets_accrual(bucket, budget_drips)?;
+
+    Ok(
+        transaction_sum
+            + budget_accruals_sum
+            + bucket_transfer_to_sum
+            - bucket_transfer_from_sum
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
+
+    use super::calculate_bucket_balance;
+
+    #[test]
+    fn when_no_data_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+
+        let result = calculate_bucket_balance(&bucket, &[], &[], &[], &[]);
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_data_only_for_another_bucket_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(1, 100)];
+        let bucket_transfer_from_sums = [(1, 91)];
+        let bucket_transfer_to_sums = [(2, 79)];
+        let budget_drips = [
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(1).build().unwrap(),
+        ];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_transaction_sum_is_zero_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(0, 0)];
+        let bucket_transfer_from_sums = [];
+        let bucket_transfer_to_sums = [];
+        let budget_drips = [];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_bucket_transfers_are_zero_then_returns_zero() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [];
+        let bucket_transfer_from_sums = [(0, 0)];
+        let bucket_transfer_to_sums = [(0, 0)];
+        let budget_drips = [];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), 0_i64);
+    }
+
+    #[test]
+    fn when_some_data_then_calculates_as_expected() {
+        let bucket = make_fake_bucket(0);
+        let transaction_sums = [(0, 100)];
+        let bucket_transfer_from_sums = [(0, 91)];
+        let bucket_transfer_to_sums = [(0, 79)];
+        let budget_drips = [
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(77).bucket_id(0).build().unwrap(),
+        ];
+
+        let result = calculate_bucket_balance(
+            &bucket,
+            &transaction_sums,
+            &bucket_transfer_from_sums,
+            &bucket_transfer_to_sums,
+            &budget_drips,
+        );
+
+        let expected_result = 100 + (-91) + 79 + 77 * 5;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), expected_result);
+    }
+}
diff --git a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs b/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
index ca82953..cbf7180 100644
--- a/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
+++ b/schist_core/schist_queries/src/utils/calculate_budgets_accrual.rs
@@ -1,13 +1,13 @@
 use anyhow::Result;
 use schist_models::{
     budget_drip::BudgetDrip,
-    category::Category,
+    bucket::Bucket,
 };
 
-pub fn calculate_budgets_accrual(category: &Category, budget_drips: &[BudgetDrip]) -> Result<i64> {
+pub fn calculate_budgets_accrual(bucket: &Bucket, budget_drips: &[BudgetDrip]) -> Result<i64> {
     Ok(budget_drips
         .iter()
-        .filter(|bd| bd.category_id == category.id)
+        .filter(|bd| bd.bucket_id == bucket.id)
         .map(|bd| Into::<i64>::into(bd.quantity))
         .sum()
     )
@@ -15,29 +15,29 @@ pub fn calculate_budgets_accrual(category: &Category, budget_drips: &[BudgetDrip
 
 #[cfg(test)]
 mod test {
-    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
+    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
 
     use super::calculate_budgets_accrual;
 
     #[test]
     fn when_no_budget_drips_then_return_zero() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 0_i64);
     }
 
     #[test]
-    fn when_one_budget_drip_for_another_category_then_return_zero() {
-        let category = make_fake_category(0);
+    fn when_one_budget_drip_for_another_bucket_then_return_zero() {
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(1).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(1).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 0_i64);
@@ -45,12 +45,12 @@ mod test {
 
     #[test]
     fn when_one_budget_drip_then_return_quantity() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(0).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 100);
@@ -58,13 +58,13 @@ mod test {
 
     #[test]
     fn when_two_budget_drips_then_return_sum() {
-        let category = make_fake_category(0);
+        let bucket = make_fake_bucket(0);
         let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(1).quantity(120).category_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(0).quantity(100).bucket_id(0).build().unwrap(),
+            make_fake_budget_drip_builder(1).quantity(120).bucket_id(0).build().unwrap(),
         ];
 
-        let result = calculate_budgets_accrual(&category, &budget_drips);
+        let result = calculate_budgets_accrual(&bucket, &budget_drips);
 
         assert!(result.is_ok());
         assert_eq!(result.unwrap(), 220);
diff --git a/schist_core/schist_queries/src/utils/calculate_category_balance.rs b/schist_core/schist_queries/src/utils/calculate_category_balance.rs
deleted file mode 100644
index 73e80cd..0000000
--- a/schist_core/schist_queries/src/utils/calculate_category_balance.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use anyhow::Result;
-use schist_models::{budget_drip::BudgetDrip, category::Category};
-
-use super::{calculate_budgets_accrual, find_by_id_or};
-
-pub fn calculate_category_balance(
-    category: &Category,
-    transaction_sums: &[(i32, i64)],
-    category_transfer_from_sums: &[(i32, i64)],
-    category_transfer_to_sums: &[(i32, i64)],
-    budget_drips: &[BudgetDrip],
-) -> Result<i64> {
-    let transaction_sum = find_by_id_or(transaction_sums, category.id, 0);
-    let category_transfer_from_sum = find_by_id_or(category_transfer_from_sums, category.id, 0);
-    let category_transfer_to_sum = find_by_id_or(category_transfer_to_sums, category.id, 0);
-    let budget_accruals_sum = calculate_budgets_accrual(category, budget_drips)?;
-
-    Ok(
-        transaction_sum
-            + budget_accruals_sum
-            + category_transfer_to_sum
-            - category_transfer_from_sum
-    )
-}
-
-#[cfg(test)]
-mod test {
-    use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
-
-    use super::calculate_category_balance;
-
-    #[test]
-    fn when_no_data_then_returns_zero() {
-        let category = make_fake_category(0);
-
-        let result = calculate_category_balance(&category, &[], &[], &[], &[]);
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_data_only_for_another_category_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(1, 100)];
-        let category_transfer_from_sums = [(1, 91)];
-        let category_transfer_to_sums = [(2, 79)];
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(100).category_id(1).build().unwrap(),
-        ];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_transaction_sum_is_zero_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(0, 0)];
-        let category_transfer_from_sums = [];
-        let category_transfer_to_sums = [];
-        let budget_drips = [];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_category_transfers_are_zero_then_returns_zero() {
-        let category = make_fake_category(0);
-        let transaction_sums = [];
-        let category_transfer_from_sums = [(0, 0)];
-        let category_transfer_to_sums = [(0, 0)];
-        let budget_drips = [];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), 0_i64);
-    }
-
-    #[test]
-    fn when_some_data_then_calculates_as_expected() {
-        let category = make_fake_category(0);
-        let transaction_sums = [(0, 100)];
-        let category_transfer_from_sums = [(0, 91)];
-        let category_transfer_to_sums = [(0, 79)];
-        let budget_drips = [
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-            make_fake_budget_drip_builder(0).quantity(77).category_id(0).build().unwrap(),
-        ];
-
-        let result = calculate_category_balance(
-            &category,
-            &transaction_sums,
-            &category_transfer_from_sums,
-            &category_transfer_to_sums,
-            &budget_drips,
-        );
-
-        let expected_result = 100 + (-91) + 79 + 77 * 5;
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), expected_result);
-    }
-}
diff --git a/schist_core/schist_queries/src/utils/mod.rs b/schist_core/schist_queries/src/utils/mod.rs
index f2653d8..c006a9b 100644
--- a/schist_core/schist_queries/src/utils/mod.rs
+++ b/schist_core/schist_queries/src/utils/mod.rs
@@ -1,8 +1,8 @@
 mod calculate_budgets_accrual;
-mod calculate_category_balance;
+mod calculate_bucket_balance;
 mod find_by_id_or;
 
 use calculate_budgets_accrual::calculate_budgets_accrual;
 
-pub use calculate_category_balance::calculate_category_balance;
+pub use calculate_bucket_balance::calculate_bucket_balance;
 pub use find_by_id_or::find_by_id_or;