diff options
Diffstat (limited to 'rust/schist_core/src')
56 files changed, 1686 insertions, 0 deletions
diff --git a/rust/schist_core/src/lib.rs b/rust/schist_core/src/lib.rs new file mode 100644 index 0000000..fd56999 --- /dev/null +++ b/rust/schist_core/src/lib.rs @@ -0,0 +1,10 @@ +use diesel_migrations::{embed_migrations, EmbeddedMigrations}; + +pub mod models; +pub mod queries; +pub mod schema; +pub mod traits; + +mod utils; + +pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations"); diff --git a/rust/schist_core/src/models/account.rs b/rust/schist_core/src/models/account.rs new file mode 100644 index 0000000..2df43e1 --- /dev/null +++ b/rust/schist_core/src/models/account.rs @@ -0,0 +1,15 @@ +use diesel::prelude::*; +use serde::{Deserialize, Serialize}; + +use crate::models::datetime_utc::DatetimeUtc; + +#[derive( + Insertable, Queryable, Identifiable, Selectable, Debug, PartialEq, Clone, Serialize, Deserialize, +)] +#[diesel(table_name = crate::schema::accounts)] +pub struct Account { + pub id: i32, + pub name: String, + pub opening_balance: i32, + pub opening_date: DatetimeUtc, +} diff --git a/rust/schist_core/src/models/budget.rs b/rust/schist_core/src/models/budget.rs new file mode 100644 index 0000000..e6fb4c9 --- /dev/null +++ b/rust/schist_core/src/models/budget.rs @@ -0,0 +1,42 @@ +use serde::Serialize; + +use super::budget_update::BudgetUpdate; + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +pub struct Budget { + pub quantity: i32, + pub period: i32, +} + +impl From<&BudgetUpdate> for Budget { + fn from(budget_update: &BudgetUpdate) -> Self { + Self { + quantity: budget_update.new_budget, + period: budget_update.new_period, + } + } +} + +#[cfg(test)] +mod test { + use crate::{models::date_utc::DateUtc, traits::nowlike::Nowlike}; + + use super::*; + + #[test] + fn when_from_budget_update_then_returns_budget() { + let quantity = 2; + let period = 3; + let budget_update = BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::now(), + new_budget: quantity, + new_period: period, + }; + + let budget = Budget::from(&budget_update); + + assert_eq!(budget, Budget { quantity, period }); + } +} diff --git a/rust/schist_core/src/models/budget_update.rs b/rust/schist_core/src/models/budget_update.rs new file mode 100644 index 0000000..c7221b1 --- /dev/null +++ b/rust/schist_core/src/models/budget_update.rs @@ -0,0 +1,16 @@ +use derive_builder::Builder; +use diesel::prelude::*; +use serde::Serialize; + +use crate::models::{category::Category, date_utc::DateUtc}; + +#[derive(Builder, Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Eq, Insertable)] +#[diesel(table_name = crate::schema::budget_updates)] +#[diesel(belongs_to(Category))] +pub struct BudgetUpdate { + pub id: i32, + pub category_id: i32, + pub date: DateUtc, + pub new_budget: i32, + pub new_period: i32, +} diff --git a/rust/schist_core/src/models/category.rs b/rust/schist_core/src/models/category.rs new file mode 100644 index 0000000..55c7b97 --- /dev/null +++ b/rust/schist_core/src/models/category.rs @@ -0,0 +1,10 @@ +use derive_builder::Builder; +use diesel::prelude::*; +use serde::{Deserialize, Serialize}; + +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)] +#[diesel(table_name = crate::schema::categories)] +pub struct Category { + pub id: i32, + pub name: String, +} diff --git a/rust/schist_core/src/models/category_balance.rs b/rust/schist_core/src/models/category_balance.rs new file mode 100644 index 0000000..796b40b --- /dev/null +++ b/rust/schist_core/src/models/category_balance.rs @@ -0,0 +1,7 @@ +use serde::Serialize; + +#[derive(Serialize)] +pub struct CategoryBalance { + pub category_id: i32, + pub balance: i32, +} diff --git a/rust/schist_core/src/models/category_budget.rs b/rust/schist_core/src/models/category_budget.rs new file mode 100644 index 0000000..9796261 --- /dev/null +++ b/rust/schist_core/src/models/category_budget.rs @@ -0,0 +1,9 @@ +use serde::Serialize; + +use super::budget::Budget; + +#[derive(Serialize)] +pub struct CategoryBudget { + pub category_id: i32, + pub budget: Option<Budget>, +} diff --git a/rust/schist_core/src/models/category_transfer.rs b/rust/schist_core/src/models/category_transfer.rs new file mode 100644 index 0000000..7b36054 --- /dev/null +++ b/rust/schist_core/src/models/category_transfer.rs @@ -0,0 +1,12 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)] +#[diesel(table_name = crate::schema::category_transfers)] +pub struct CategoryTransfer { + pub id: i32, + pub description: String, + pub quantity: i32, + pub from_category_id: i32, + pub to_category_id: i32, +} diff --git a/rust/schist_core/src/models/date_utc.rs b/rust/schist_core/src/models/date_utc.rs new file mode 100644 index 0000000..55d9e3f --- /dev/null +++ b/rust/schist_core/src/models/date_utc.rs @@ -0,0 +1,309 @@ +use std::{borrow::Borrow, fmt, str::FromStr}; + +use anyhow::{Context, Error, Result}; +use chrono::{DateTime, Datelike, NaiveDate, NaiveTime, Utc}; +use diesel::{ + backend::Backend, + deserialize::{self, FromSql, FromSqlRow}, + expression::AsExpression, + serialize::{self, ToSql}, + sql_types::Text, + sqlite::Sqlite, +}; +use serde::{Deserialize, Serialize}; + +use crate::traits::{dateable::Dateable, nowlike::Nowlike}; + +use super::datetime_utc::DatetimeUtc; + +#[derive( + Eq, + PartialEq, + Ord, + PartialOrd, + Serialize, + Deserialize, + Clone, + Debug, + AsExpression, + FromSqlRow, +)] +#[diesel(sql_type=Text)] +pub struct DateUtc { + chrono_datetime_utc: DateTime<Utc>, +} + +impl DateUtc { + pub fn from_ymd(year: i32, month: u32, day: u32) -> Result<Self> { + Ok(Self { + chrono_datetime_utc: NaiveDate::from_ymd_opt(year, month, day) + .with_context(|| format!("failed to construct date from ymd {:04}-{:02}-{:02}", year, month, day))? + .and_hms_opt(0, 0, 0).unwrap() + .and_utc() + }) + } + + pub fn with_hms(&mut self, hour: u32, min: u32, sec: u32) -> Result<DatetimeUtc> { + DatetimeUtc::from_ymd_and_hms( + self.year(), self.month(), self.day(), hour, min, sec, + ) + } + + pub fn day_diff(&self, other: &DateUtc) -> u32 { + self.chrono_datetime_utc + .num_days_from_ce() + .abs_diff(other.chrono_datetime_utc.num_days_from_ce()) + } + + fn is_day_str(str: &str) -> bool { + if str.len() != 10 { + return false; + } + for (ix, ch) in str.chars().enumerate() { + if ix == 4 || ix == 7 { + if ch != '-' { + return false; + } + } else { + if ch < '0' || ch > '9' { + return false; + } + } + } + return true; + } +} + +impl Nowlike for DateUtc { + fn now() -> Self { + let now = Utc::now(); + Self::from_ymd( + now.year(), + now.month(), + now.day(), + ).unwrap() + } +} + +impl Dateable for DateUtc { + fn year(&self) -> i32 { + self.chrono_datetime_utc.year() + } + + fn month(&self) -> u32 { + self.chrono_datetime_utc.month() + } + + fn day(&self) -> u32 { + self.chrono_datetime_utc.day() + } +} + +impl From<DatetimeUtc> for DateUtc { + fn from(datetime_utc: DatetimeUtc) -> Self { + Self { + chrono_datetime_utc: datetime_utc + .borrow() + .to_string() + .parse::<DateTime<Utc>>().unwrap() + .with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap()).unwrap(), + } + } +} + +impl<T> From<T> for DateUtc where T: Borrow<DateTime<Utc>> { + fn from(chrono_datetime_utc: T) -> Self { + Self { + chrono_datetime_utc: chrono_datetime_utc + .borrow() + .with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap()).unwrap(), + } + } +} + +impl fmt::Display for DateUtc { + /// Converts to a day string, YYYY-MM-DD, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24" + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + let date_str = self.chrono_datetime_utc.to_rfc3339(); + let day_str = date_str + .split_at_checked(10) + .unwrap() + .0; + write!(f, "{}", day_str) + } +} + +impl FromStr for DateUtc { + type Err = anyhow::Error; + + /// Constructs DatetimeUtc from a day string, YYYY-MM-DD, in UTC + /// Example: "2024-10-24" -> Midnight 24 Oct 2024 UTC + fn from_str(date_str: &str) -> Result<Self> { + if !Self::is_day_str(&date_str) { + Err(Error::msg(format!("{} is not a day string in YYYY-MM-DD format", date_str))) + } else { + let mut datetime_str = String::from(date_str); + datetime_str.push_str("T00:00:00.000Z"); + Ok(Self { + chrono_datetime_utc: datetime_str.parse()?, + }) + } + } +} + +impl ToSql<Text, Sqlite> for DateUtc { + fn to_sql<'b>( + &'b self, + out: &mut diesel::serialize::Output<'b, '_, Sqlite>, + ) -> serialize::Result { + out.set_value(self.to_string()); + Ok(serialize::IsNull::No) + } +} + +impl FromSql<Text, Sqlite> for DateUtc { + fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DateUtc> { + let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?; + Ok(str.parse()?) + } +} + +#[cfg(test)] +mod test { + use crate::traits::timeable::Timeable; + + use super::*; + + #[test] + fn when_from_ymd_then_ymd_are_as_expected() { + let date_utc = DateUtc::from_ymd(1970, 11, 23); + + assert!(date_utc.is_ok()); + let date_utc = date_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + } + + #[test] + fn when_from_ymd_then_to_string_as_expected() { + let date_utc = DateUtc::from_ymd(1970, 11, 23); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23"); + } + + #[test] + fn when_from_invalid_ymd_then_err() { + let date_utc_1 = DateUtc::from_ymd(1970, 0, 23); + let date_utc_2 = DateUtc::from_ymd(1970, 13, 23); + let date_utc_3 = DateUtc::from_ymd(1970, 11, 0); + let date_utc_4 = DateUtc::from_ymd(1970, 11, 31); + let date_utc_5 = DateUtc::from_ymd(1971, 2, 29); + + assert!(date_utc_1.is_err()); + assert_eq!(date_utc_1.unwrap_err().to_string(), "failed to construct date from ymd 1970-00-23"); + assert!(date_utc_2.is_err()); + assert_eq!(date_utc_2.unwrap_err().to_string(), "failed to construct date from ymd 1970-13-23"); + assert!(date_utc_3.is_err()); + assert_eq!(date_utc_3.unwrap_err().to_string(), "failed to construct date from ymd 1970-11-00"); + assert!(date_utc_4.is_err()); + assert_eq!(date_utc_4.unwrap_err().to_string(), "failed to construct date from ymd 1970-11-31"); + assert!(date_utc_5.is_err()); + assert_eq!(date_utc_5.unwrap_err().to_string(), "failed to construct date from ymd 1971-02-29"); + } + + #[test] + fn when_from_string_then_ymd_are_as_expected() { + let date_utc: Result<DateUtc> = "1970-11-23".parse(); + + assert!(date_utc.is_ok()); + let date_utc = date_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + } + + #[test] + fn when_from_string_then_to_string_as_expected() { + let date_utc: Result<DateUtc> = "1970-11-23".parse(); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23"); + } + + #[test] + fn when_from_invalid_string_then_err() { + let date_utc_1: Result<DateUtc> = "1970-00-23".parse(); + let date_utc_2: Result<DateUtc> = "1970-13-23".parse(); + let date_utc_3: Result<DateUtc> = "1970-11-0".parse(); + let date_utc_4: Result<DateUtc> = "1970-11-31".parse(); + let date_utc_5: Result<DateUtc> = "1971-02-29".parse(); + + assert!(date_utc_1.is_err()); + assert!(date_utc_2.is_err()); + assert!(date_utc_3.is_err()); + assert!(date_utc_4.is_err()); + assert!(date_utc_5.is_err()); + } + + #[test] + fn with_with_hms_then_ymd_hms_are_as_expected() { + let datetime_utc = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(12, 55, 16); + + assert!(datetime_utc.is_ok()); + let datetime_utc = datetime_utc.unwrap(); + assert_eq!(datetime_utc.year(), 1970); + assert_eq!(datetime_utc.month(), 11); + assert_eq!(datetime_utc.day(), 23); + assert_eq!(datetime_utc.hour(), 12); + assert_eq!(datetime_utc.minute(), 55); + assert_eq!(datetime_utc.second(), 16); + } + + #[test] + fn when_with_invalid_hms_then_err() { + let datetime_utc_1 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(25, 0, 0); + let datetime_utc_2 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 61, 0); + let datetime_utc_3 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 0, 61); + + assert!(datetime_utc_1.is_err()); + assert!(datetime_utc_2.is_err()); + assert!(datetime_utc_3.is_err()); + } + + #[test] + fn when_from_datetime_utc_at_different_times_on_same_day_then_eq() { + let datetime_utc1 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 0, 0).unwrap(); + let datetime_utc2 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(23, 59, 59).unwrap(); + let date_utc1 = DateUtc::from(datetime_utc1); + let date_utc2 = DateUtc::from(datetime_utc2); + + assert_eq!(date_utc1, date_utc2); + } + + #[test] + fn given_today_when_day_diff_today_then_return_0() { + let start = DateUtc::from_ymd(2000, 1, 1).unwrap(); + let end = DateUtc::from_ymd(2000, 1, 1).unwrap(); + + let day_diff = start.day_diff(&end); + let neg_day_diff = end.day_diff(&start); + + assert_eq!(day_diff, 0); + assert_eq!(day_diff, neg_day_diff); + } + + #[test] + fn given_today_when_day_diff_tomorrow_then_return_1() { + let start = DateUtc::from_ymd(2000, 1, 1).unwrap(); + let end = DateUtc::from_ymd(2000, 1, 2).unwrap(); + + let day_diff = start.day_diff(&end); + let neg_day_diff = end.day_diff(&start); + + assert_eq!(day_diff, 1); + assert_eq!(day_diff, neg_day_diff); + } +} diff --git a/rust/schist_core/src/models/datetime_utc.rs b/rust/schist_core/src/models/datetime_utc.rs new file mode 100644 index 0000000..98d1d6c --- /dev/null +++ b/rust/schist_core/src/models/datetime_utc.rs @@ -0,0 +1,223 @@ +use std::{fmt::Display, str::FromStr}; + +use anyhow::{Context, Result}; +use chrono::{DateTime, Datelike as ChronoDatelike, NaiveDate, Timelike as ChronoTimelike, Utc}; +use diesel::{ + backend::Backend, + deserialize::{self, FromSql, FromSqlRow}, + expression::AsExpression, + serialize::{self, ToSql}, + sql_types::Text, + sqlite::Sqlite, +}; +use serde::{Deserialize, Serialize}; + +use crate::traits::{dateable::Dateable, nowlike::Nowlike, timeable::Timeable}; + +#[derive( + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Clone, + Debug, + AsExpression, + FromSqlRow, +)] +#[diesel(sql_type=Text)] +pub struct DatetimeUtc { + chrono_datetime_utc: DateTime<Utc>, +} + +impl DatetimeUtc { + pub fn from_ymd_and_hms(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) -> Result<Self> { + Ok(Self { chrono_datetime_utc: NaiveDate + ::from_ymd_opt(year, month, day) + .with_context(|| format!("failed to construct datetime from ymd {:04}-{:02}-{:02}", year, month, day))? + .and_hms_opt(hour, min, sec) + .with_context(|| format!("failed to construct datetime from hms {:02}:{:02}:{:02}", hour, min, sec))? + .and_utc() + }) + } +} + +impl FromStr for DatetimeUtc { + type Err = anyhow::Error; + + /// Constructs DatetimeUtc from a date string in ISO format, in UTC + /// Example: "2024-10-24T10:30:00.000" -> 10.30am 24 Oct 2024 UTC + fn from_str(datetime_str: &str) -> Result<Self> { + let chrono_datetime_utc = datetime_str.parse::<DateTime<Utc>>()?; + Ok(Self { + chrono_datetime_utc, + }) + } +} + +impl Display for DatetimeUtc { + /// Converts to a date string in ISO format, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24T10:30:00.000Z" + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + write!(f, "{}", self.chrono_datetime_utc.to_rfc3339_opts(chrono::SecondsFormat::Millis, true)) + } +} + +impl Nowlike for DatetimeUtc { + fn now() -> Self { + let now = Utc::now(); + Self::from_ymd_and_hms( + now.year(), + now.month(), + now.day(), + now.hour(), + now.minute(), + now.second(), + ).unwrap() + } +} + +impl Dateable for DatetimeUtc { + fn year(&self) -> i32 { + self.chrono_datetime_utc.year() + } + + fn month(&self) -> u32 { + self.chrono_datetime_utc.month() + } + + fn day(&self) -> u32 { + self.chrono_datetime_utc.day() + } +} + +impl Timeable for DatetimeUtc { + fn hour(&self) -> u32 { + self.chrono_datetime_utc.hour() + } + + fn minute(&self) -> u32 { + self.chrono_datetime_utc.minute() + } + + fn second(&self) -> u32 { + self.chrono_datetime_utc.second() + } +} + +impl ToSql<Text, Sqlite> for DatetimeUtc { + fn to_sql<'b>( + &'b self, + out: &mut diesel::serialize::Output<'b, '_, Sqlite>, + ) -> serialize::Result { + out.set_value::<String>(self.to_string()); + Ok(serialize::IsNull::No) + } +} + +impl FromSql<Text, Sqlite> for DatetimeUtc { + fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DatetimeUtc> { + let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?; + Ok(str.parse()?) + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn when_from_ymd_and_hms_then_ymd_and_hms_are_as_expected() { + let datetime_utc = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 12, 55, 16); + + assert!(datetime_utc.is_ok()); + let date_utc = datetime_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + assert_eq!(date_utc.hour(), 12); + assert_eq!(date_utc.minute(), 55); + assert_eq!(date_utc.second(), 16); + } + + #[test] + fn when_from_ymd_and_hms_then_to_string_as_expected() { + let date_utc = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 12, 55, 16); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23T12:55:16.000Z") + } + + #[test] + fn when_with_invalid_ymd_and_hms_then_err() { + let datetime_utc_1 = DatetimeUtc::from_ymd_and_hms(1970, 0, 23, 12, 55, 16); + let datetime_utc_2 = DatetimeUtc::from_ymd_and_hms(1970, 13, 23, 12, 55, 16); + let datetime_utc_3 = DatetimeUtc::from_ymd_and_hms(1970, 11, 0, 12, 55, 16); + let datetime_utc_4 = DatetimeUtc::from_ymd_and_hms(1970, 11, 31, 12, 55, 16); + let datetime_utc_5 = DatetimeUtc::from_ymd_and_hms(1971, 2, 29, 12, 55, 16); + let datetime_utc_6 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 25, 0, 0); + let datetime_utc_7 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 0, 61, 0); + let datetime_utc_8 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 0, 0, 61); + + assert!(datetime_utc_1.is_err()); + assert_eq!(datetime_utc_1.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-00-23"); + assert!(datetime_utc_2.is_err()); + assert_eq!(datetime_utc_2.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-13-23"); + assert!(datetime_utc_3.is_err()); + assert_eq!(datetime_utc_3.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-11-00"); + assert!(datetime_utc_4.is_err()); + assert_eq!(datetime_utc_4.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-11-31"); + assert!(datetime_utc_5.is_err()); + assert_eq!(datetime_utc_5.unwrap_err().to_string(), "failed to construct datetime from ymd 1971-02-29"); + assert!(datetime_utc_6.is_err()); + assert_eq!(datetime_utc_6.unwrap_err().to_string(), "failed to construct datetime from hms 25:00:00"); + assert!(datetime_utc_7.is_err()); + assert_eq!(datetime_utc_7.unwrap_err().to_string(), "failed to construct datetime from hms 00:61:00"); + assert!(datetime_utc_8.is_err()); + assert_eq!(datetime_utc_8.unwrap_err().to_string(), "failed to construct datetime from hms 00:00:61"); + } + + #[test] + fn when_from_string_then_ymd_and_hms_are_as_expected() { + let date_utc: Result<DatetimeUtc> = "1970-11-23T12:55:16.000Z".parse(); + + assert!(date_utc.is_ok()); + let datetime_utc = date_utc.unwrap(); + assert_eq!(datetime_utc.year(), 1970); + assert_eq!(datetime_utc.month(), 11); + assert_eq!(datetime_utc.day(), 23); + assert_eq!(datetime_utc.hour(), 12); + assert_eq!(datetime_utc.minute(), 55); + assert_eq!(datetime_utc.second(), 16); + } + + #[test] + fn when_from_string_then_to_string_as_expected() { + let datetime_utc: Result<DatetimeUtc> = "1970-11-23T12:55:16.000Z".parse(); + + assert!(datetime_utc.is_ok()); + assert_eq!(datetime_utc.unwrap().to_string(), "1970-11-23T12:55:16.000Z") + } + + #[test] + fn when_from_invalid_string_then_err() { + let datetime_utc_1: Result<DatetimeUtc> = "1970-00-23T00:00:00.000Z".parse(); + let datetime_utc_2: Result<DatetimeUtc> = "1970-13-23T00:00:00.000Z".parse(); + let datetime_utc_3: Result<DatetimeUtc> = "1970-11-0T00:00:00.000Z".parse(); + let datetime_utc_4: Result<DatetimeUtc> = "1970-11-31T00:00:00.000Z".parse(); + let datetime_utc_5: Result<DatetimeUtc> = "1971-02-29T00:00:00.000Z".parse(); + let datetime_utc_6: Result<DatetimeUtc> = "1970-11-23T25:00:00.000Z".parse(); + let datetime_utc_7: Result<DatetimeUtc> = "1970-11-23T00:61:00.000Z".parse(); + let datetime_utc_8: Result<DatetimeUtc> = "1970-11-23T00:00:61.000Z".parse(); + + assert!(datetime_utc_1.is_err()); + assert!(datetime_utc_2.is_err()); + assert!(datetime_utc_3.is_err()); + assert!(datetime_utc_4.is_err()); + assert!(datetime_utc_5.is_err()); + assert!(datetime_utc_6.is_err()); + assert!(datetime_utc_7.is_err()); + assert!(datetime_utc_8.is_err()); + } +} diff --git a/rust/schist_core/src/models/mod.rs b/rust/schist_core/src/models/mod.rs new file mode 100644 index 0000000..2eb7ac2 --- /dev/null +++ b/rust/schist_core/src/models/mod.rs @@ -0,0 +1,11 @@ +pub mod account; +pub mod budget; +pub mod budget_update; +pub mod category; +pub mod category_balance; +pub mod category_budget; +pub mod category_transfer; +pub mod date_utc; +pub mod datetime_utc; +pub mod transaction; +pub mod transaction_categorisation; diff --git a/rust/schist_core/src/models/transaction.rs b/rust/schist_core/src/models/transaction.rs new file mode 100644 index 0000000..18a4c0e --- /dev/null +++ b/rust/schist_core/src/models/transaction.rs @@ -0,0 +1,18 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +use crate::models::account::Account; + +use super::datetime_utc::DatetimeUtc; + +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)] +#[diesel(table_name = crate::schema::transactions)] +#[diesel(belongs_to(Account))] +pub struct Transaction { + pub id: i32, + pub description: String, + pub payee: String, + pub quantity: i32, + pub date: DatetimeUtc, + pub account_id: i32, +} diff --git a/rust/schist_core/src/models/transaction_categorisation.rs b/rust/schist_core/src/models/transaction_categorisation.rs new file mode 100644 index 0000000..c6ac6ea --- /dev/null +++ b/rust/schist_core/src/models/transaction_categorisation.rs @@ -0,0 +1,12 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)] +#[diesel(table_name = crate::schema::transaction_categorisations)] +pub struct TransactionCategorisation { + pub id: i32, + pub description: String, + pub quantity: i32, + pub transaction_id: i32, + pub category_id: i32, +} diff --git a/rust/schist_core/src/queries/accounts/delete_all.rs b/rust/schist_core/src/queries/accounts/delete_all.rs new file mode 100644 index 0000000..84d7bf6 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::accounts::dsl::accounts; + +pub fn delete_all_accounts(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(accounts) + .execute(connection) + .with_context(|| "failed to delete all accounts")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/accounts/get_all.rs b/rust/schist_core/src/queries/accounts/get_all.rs new file mode 100644 index 0000000..ab53729 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/get_all.rs @@ -0,0 +1,10 @@ +use anyhow::{Context, Result}; +use crate::{models::account::Account, schema::accounts::dsl::accounts}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_accounts(connection: &mut SqliteConnection) -> Result<Vec<Account>> { + let all_accounts = accounts.select(Account::as_select()) + .load(connection) + .with_context(|| "failed to get all accounts")?; + Ok(all_accounts) +} diff --git a/rust/schist_core/src/queries/accounts/insert.rs b/rust/schist_core/src/queries/accounts/insert.rs new file mode 100644 index 0000000..7020b68 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::account::Account, + schema::accounts::dsl::accounts as accounts_table, +}; +use diesel::prelude::*; + +pub fn insert_accounts( + accounts: &[Account], + connection: &mut SqliteConnection, +) -> Result<usize> { + let num_accounts_inserted = diesel::insert_into(accounts_table) + .values(accounts) + .execute(connection) + .with_context(|| err_msg(accounts))?; + Ok(num_accounts_inserted) +} + +fn err_msg(accounts: &[Account]) -> String { + format!( + "failed to insert accounts: [{}]", + accounts + .iter() + .map(|a| format!("\"{}\": \"{}\"", a.id, a.name)) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/accounts/mod.rs b/rust/schist_core/src/queries/accounts/mod.rs new file mode 100644 index 0000000..222b180 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/mod.rs @@ -0,0 +1,7 @@ +mod delete_all; +mod get_all; +mod insert; + +pub use delete_all::delete_all_accounts; +pub use get_all::get_all_accounts; +pub use insert::insert_accounts; diff --git a/rust/schist_core/src/queries/budget_updates/delete_all.rs b/rust/schist_core/src/queries/budget_updates/delete_all.rs new file mode 100644 index 0000000..b7ad082 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::budget_updates::dsl::budget_updates; + +pub fn delete_all_budget_updates(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(budget_updates) + .execute(connection) + .with_context(|| "failed to delete all budget updates")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_all.rs b/rust/schist_core/src/queries/budget_updates/get_all.rs new file mode 100644 index 0000000..9c9310b --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_all.rs @@ -0,0 +1,16 @@ +use anyhow::{Context, Result}; +use crate::{ + models::budget_update::BudgetUpdate, + schema::budget_updates::dsl::budget_updates as budget_updates_table, +}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_budget_updates( + connection: &mut SqliteConnection, +) -> Result<Vec<BudgetUpdate>> { + let all_budget_updates = budget_updates_table + .select(BudgetUpdate::as_select()) + .load::<BudgetUpdate>(connection) + .with_context(|| "failed to get all budget updates")?; + Ok(all_budget_updates) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs b/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs new file mode 100644 index 0000000..2d8f97c --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs @@ -0,0 +1,25 @@ +use anyhow::{Context, Result}; +use crate::{ + models::{budget_update::BudgetUpdate, date_utc::DateUtc}, + schema::budget_updates::{ + self as budget_updates_schema, dsl::budget_updates as budget_updates_table, + }, +}; +use diesel::{ + ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection +}; + +pub fn get_first_budget_update_with_date_and_category_id( + date: &DateUtc, + category_id: i32, + connection: &mut SqliteConnection, +) -> Result<Option<BudgetUpdate>> { + let first_budget_update = budget_updates_table + .select(BudgetUpdate::as_select()) + .filter(budget_updates_schema::date.eq(date.to_string())) + .filter(budget_updates_schema::category_id.eq(category_id)) + .first(connection) + .optional() + .with_context(|| format!("failed to get first budget update with date {}", date.to_string()))?; + Ok(first_budget_update) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs b/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs new file mode 100644 index 0000000..41ef5ec --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs @@ -0,0 +1,21 @@ +use anyhow::{Context, Result}; +use crate::{ + models::date_utc::DateUtc, + schema::budget_updates::{ + self as budget_updates_schema, dsl::budget_updates as budget_updates_table, + }, traits::nowlike::Nowlike, +}; +use diesel::{dsl::max, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn get_most_recent_budget_update_date_with_category_id( + category_id: i32, + connection: &mut SqliteConnection, +) -> Result<Option<DateUtc>> { + let most_recent_date = budget_updates_table + .select(max(budget_updates_schema::date)) + .filter(budget_updates_schema::category_id.eq(category_id)) + .filter(budget_updates_schema::date.le(DateUtc::now())) + .first(connection) + .with_context(|| format!("failed to get most recent budget update date with category ID {}", category_id))?; + Ok(most_recent_date) +} diff --git a/rust/schist_core/src/queries/budget_updates/insert.rs b/rust/schist_core/src/queries/budget_updates/insert.rs new file mode 100644 index 0000000..e8ae271 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::budget_update::BudgetUpdate, + schema::budget_updates::dsl::budget_updates as budget_updates_table, +}; +use diesel::prelude::*; + +pub fn insert_budget_updates( + budget_updates: &[BudgetUpdate], + connection: &mut SqliteConnection, +) -> Result<usize> { + let num_rows_inserted = diesel::insert_into(budget_updates_table) + .values(budget_updates) + .execute(connection) + .with_context(|| err_msg(budget_updates))?; + Ok(num_rows_inserted) +} + +fn err_msg(budget_updates: &[BudgetUpdate]) -> String { + format!( + "failed to insert budget updates: [{}]", + budget_updates + .iter() + .map(|a| a.id.to_string()) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/budget_updates/mod.rs b/rust/schist_core/src/queries/budget_updates/mod.rs new file mode 100644 index 0000000..6fc7de0 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/mod.rs @@ -0,0 +1,11 @@ +mod delete_all; +mod get_all; +mod get_first_with_date_and_category_id; +mod get_most_recent_with_category_id; +mod insert; + +pub use delete_all::delete_all_budget_updates; +pub use get_all::get_all_budget_updates; +pub use get_first_with_date_and_category_id::get_first_budget_update_with_date_and_category_id; +pub use get_most_recent_with_category_id::get_most_recent_budget_update_date_with_category_id; +pub use insert::insert_budget_updates; diff --git a/rust/schist_core/src/queries/categories/delete_all.rs b/rust/schist_core/src/queries/categories/delete_all.rs new file mode 100644 index 0000000..1fd2581 --- /dev/null +++ b/rust/schist_core/src/queries/categories/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::categories::dsl::categories; + +pub fn delete_all_categories(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(categories) + .execute(connection) + .with_context(|| "failed to delete all categories")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/categories/get_all.rs b/rust/schist_core/src/queries/categories/get_all.rs new file mode 100644 index 0000000..431ed9c --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::category::Category, schema::categories::dsl::categories as categories_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +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) +} diff --git a/rust/schist_core/src/queries/categories/get_all_balances.rs b/rust/schist_core/src/queries/categories/get_all_balances.rs new file mode 100644 index 0000000..c9a0102 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all_balances.rs @@ -0,0 +1,47 @@ +use anyhow::{Context, Result}; +use crate::{models::category_balance::CategoryBalance, queries::{ + budget_updates::get_all_budget_updates, + categories::get_all_categories, + category_transfers::{ + sum_category_transfer_quantity_per_from_category_id, + sum_category_transfer_quantity_per_to_category_id, + }, + transaction_categorisations::sum_transaction_categorisation_quantity_per_category_id, + }, utils::calculate_category_balance}; +use diesel::SqliteConnection; + +pub fn get_all_category_balances( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBalance>> { + get_all_category_balances_without_context(connection) + .with_context(|| "failed to get all category balances") +} + +fn get_all_category_balances_without_context( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBalance>> { + let categories = get_all_categories(connection)?; + let transaction_sums = sum_transaction_categorisation_quantity_per_category_id(connection)?; + let category_transfer_from_sums = + sum_category_transfer_quantity_per_from_category_id(connection)?; + let category_transfer_to_sums = sum_category_transfer_quantity_per_to_category_id(connection)?; + let budget_updates = get_all_budget_updates(connection)?; + + let mut balances = Vec::<CategoryBalance>::new(); + for category in categories { + let balance = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + )?; + + balances.push(CategoryBalance { + category_id: category.id, + balance: balance.try_into().unwrap(), + }) + } + + Ok(balances) +} diff --git a/rust/schist_core/src/queries/categories/get_all_ids.rs b/rust/schist_core/src/queries/categories/get_all_ids.rs new file mode 100644 index 0000000..8505e71 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all_ids.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::schema::categories::{self as categories_schema, dsl::categories as categories_table}; +use diesel::{QueryDsl, RunQueryDsl, SqliteConnection}; + +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) +} diff --git a/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs b/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs new file mode 100644 index 0000000..9f2e4f6 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs @@ -0,0 +1,52 @@ +use anyhow::{Context, Result}; +use crate::{models::{budget::Budget, category_budget::CategoryBudget}, queries::{ + budget_updates::{ + get_first_budget_update_with_date_and_category_id, get_most_recent_budget_update_date_with_category_id, + }, + categories::get_all_category_ids, +}}; +use diesel::SqliteConnection; + +pub fn get_most_recent_category_budget_per_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBudget>> { + get_most_recent_category_budget_per_category_id_without_context(connection) + .with_context(|| "failed to get most recent category budget per category ID") +} + +fn get_most_recent_category_budget_per_category_id_without_context( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBudget>> { + let category_ids: Vec<i32> = get_all_category_ids(connection)?; + + let mut budgets = Vec::<CategoryBudget>::new(); + for category_id in category_ids { + let most_recent_budget_update_date = + get_most_recent_budget_update_date_with_category_id(category_id, connection)?; + + if most_recent_budget_update_date.is_none() { + budgets.push(CategoryBudget { + category_id, + budget: Option::None, + }); + continue; + } + let most_recent_budget_update_date = most_recent_budget_update_date.unwrap(); + + let most_recent_budget_update = get_first_budget_update_with_date_and_category_id( + &most_recent_budget_update_date, + category_id, + connection, + )?; + // The fact we found the date by getting the most recent budget update + // date guarantees that the Option is Some + let most_recent_budget_update = most_recent_budget_update.unwrap(); + + budgets.push(CategoryBudget { + category_id, + budget: Some(Budget::from(&most_recent_budget_update)), + }); + } + + Ok(budgets) +} diff --git a/rust/schist_core/src/queries/categories/insert.rs b/rust/schist_core/src/queries/categories/insert.rs new file mode 100644 index 0000000..bccba72 --- /dev/null +++ b/rust/schist_core/src/queries/categories/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::category::Category, + schema::categories::dsl::categories as categories_table, +}; +use diesel::prelude::*; + +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(|| err_msg(categories))?; + Ok(num_categories_inserted) +} + +fn err_msg(categories: &[Category]) -> String { + format!( + "failed to insert categories: [{}]", + categories + .iter() + .map(|a| format!("\"{}\": \"{}\"", a.id, a.name)) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/categories/mod.rs b/rust/schist_core/src/queries/categories/mod.rs new file mode 100644 index 0000000..edeeebf --- /dev/null +++ b/rust/schist_core/src/queries/categories/mod.rs @@ -0,0 +1,13 @@ +mod delete_all; +mod get_all; +mod get_all_balances; +mod get_all_ids; +mod get_most_recent_budget_per_category_id; +mod insert; + +pub use delete_all::delete_all_categories; +pub use get_all::get_all_categories; +pub use get_all_balances::get_all_category_balances; +pub use get_all_ids::get_all_category_ids; +pub use get_most_recent_budget_per_category_id::get_most_recent_category_budget_per_category_id; +pub use insert::insert_categories; diff --git a/rust/schist_core/src/queries/category_transfers/delete_all.rs b/rust/schist_core/src/queries/category_transfers/delete_all.rs new file mode 100644 index 0000000..406b80b --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::category_transfers::dsl::category_transfers; + +pub fn delete_all_category_transfers(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(category_transfers).execute(connection) +} diff --git a/rust/schist_core/src/queries/category_transfers/get_all.rs b/rust/schist_core/src/queries/category_transfers/get_all.rs new file mode 100644 index 0000000..73d7e10 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::category_transfer::CategoryTransfer, schema::category_transfers::dsl::category_transfers as category_transfers_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +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) +} diff --git a/rust/schist_core/src/queries/category_transfers/insert.rs b/rust/schist_core/src/queries/category_transfers/insert.rs new file mode 100644 index 0000000..e1db167 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::category_transfer::CategoryTransfer, + schema::category_transfers::dsl::category_transfers as category_transfers_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_category_transfers( + category_transfers: &[CategoryTransfer], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(category_transfers_table) + .values(category_transfers) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/category_transfers/mod.rs b/rust/schist_core/src/queries/category_transfers/mod.rs new file mode 100644 index 0000000..eed7946 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/mod.rs @@ -0,0 +1,11 @@ +mod delete_all; +mod get_all; +mod insert; +mod sum_quantity_per_from_category_id; +mod sum_quantity_per_to_category_id; + +pub use delete_all::delete_all_category_transfers; +pub use get_all::get_all_category_transfers; +pub use insert::insert_category_transfers; +pub use sum_quantity_per_from_category_id::sum_category_transfer_quantity_per_from_category_id; +pub use sum_quantity_per_to_category_id::sum_category_transfer_quantity_per_to_category_id; diff --git a/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs new file mode 100644 index 0000000..a9c2a8c --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::category_transfers::{ + self as category_transfers_schema, + dsl::category_transfers as category_transfers_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_category_transfer_quantity_per_from_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + 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()) +} diff --git a/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs new file mode 100644 index 0000000..f041477 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::category_transfers::{ + self as category_transfers_schema, + dsl::category_transfers as category_transfers_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_category_transfer_quantity_per_to_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + 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()) +} diff --git a/rust/schist_core/src/queries/clear.rs b/rust/schist_core/src/queries/clear.rs new file mode 100644 index 0000000..e704634 --- /dev/null +++ b/rust/schist_core/src/queries/clear.rs @@ -0,0 +1,20 @@ +use anyhow::Result; +use crate::queries::{ + accounts::delete_all_accounts, + budget_updates::delete_all_budget_updates, + categories::delete_all_categories, + category_transfers::delete_all_category_transfers, + transactions::delete_all_transactions, + transaction_categorisations::delete_all_transaction_categorisations, +}; +use diesel::SqliteConnection; + +pub fn clear(connection: &mut SqliteConnection) -> Result<()> { + delete_all_accounts(connection)?; + delete_all_budget_updates(connection)?; + delete_all_categories(connection)?; + delete_all_category_transfers(connection)?; + delete_all_transactions(connection)?; + delete_all_transaction_categorisations(connection)?; + Ok(()) +} diff --git a/rust/schist_core/src/queries/mod.rs b/rust/schist_core/src/queries/mod.rs new file mode 100644 index 0000000..f0852ce --- /dev/null +++ b/rust/schist_core/src/queries/mod.rs @@ -0,0 +1,7 @@ +pub mod accounts; +pub mod budget_updates; +pub mod categories; +pub mod category_transfers; +pub mod clear; +pub mod transactions; +pub mod transaction_categorisations; diff --git a/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs b/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs new file mode 100644 index 0000000..e80a0ca --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::transaction_categorisations::dsl::transaction_categorisations; + +pub fn delete_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(transaction_categorisations).execute(connection) +} diff --git a/rust/schist_core/src/queries/transaction_categorisations/get_all.rs b/rust/schist_core/src/queries/transaction_categorisations/get_all.rs new file mode 100644 index 0000000..0cacfe6 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::transaction_categorisation::TransactionCategorisation, schema::transaction_categorisations::dsl::transaction_categorisations as transaction_categorisations_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<Vec<TransactionCategorisation>> { + let all_transaction_categorisations = transaction_categorisations_table + .select(TransactionCategorisation::as_select()) + .load(connection) + .with_context(|| "failed to get all transaction categorisations")?; + Ok(all_transaction_categorisations) +} diff --git a/rust/schist_core/src/queries/transaction_categorisations/insert.rs b/rust/schist_core/src/queries/transaction_categorisations/insert.rs new file mode 100644 index 0000000..3da1c33 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::transaction_categorisation::TransactionCategorisation, + schema::transaction_categorisations::dsl::transaction_categorisations as transaction_categorisations_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_transaction_categorisations( + transaction_categorisations: &[TransactionCategorisation], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(transaction_categorisations_table) + .values(transaction_categorisations) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/transaction_categorisations/mod.rs b/rust/schist_core/src/queries/transaction_categorisations/mod.rs new file mode 100644 index 0000000..d383791 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/mod.rs @@ -0,0 +1,9 @@ +mod delete_all; +mod get_all; +mod insert; +mod sum_quantity_per_category_id; + +pub use delete_all::delete_all_transaction_categorisations; +pub use get_all::get_all_transaction_categorisations; +pub use insert::insert_transaction_categorisations; +pub use sum_quantity_per_category_id::sum_transaction_categorisation_quantity_per_category_id; diff --git a/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs b/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs new file mode 100644 index 0000000..61f3492 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::transaction_categorisations::{ + self as transaction_categorisations_schema, + dsl::transaction_categorisations as transaction_categorisations_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_transaction_categorisation_quantity_per_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + transaction_categorisations_table + .group_by(transaction_categorisations_schema::category_id) + .select(( + transaction_categorisations_schema::category_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()) +} diff --git a/rust/schist_core/src/queries/transactions/delete_all.rs b/rust/schist_core/src/queries/transactions/delete_all.rs new file mode 100644 index 0000000..43b7976 --- /dev/null +++ b/rust/schist_core/src/queries/transactions/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::transactions::dsl::transactions; + +pub fn delete_all_transactions(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(transactions).execute(connection) +} diff --git a/rust/schist_core/src/queries/transactions/get_all.rs b/rust/schist_core/src/queries/transactions/get_all.rs new file mode 100644 index 0000000..afb87f4 --- /dev/null +++ b/rust/schist_core/src/queries/transactions/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::transaction::Transaction, schema::transactions::dsl::transactions as transactions_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_transactions(connection: &mut SqliteConnection) -> Result<Vec<Transaction>> { + let all_transactions = transactions_table + .select(Transaction::as_select()) + .load(connection) + .with_context(|| "failed to get all category transfers")?; + Ok(all_transactions) +} diff --git a/rust/schist_core/src/queries/transactions/insert.rs b/rust/schist_core/src/queries/transactions/insert.rs new file mode 100644 index 0000000..32f3dc2 --- /dev/null +++ b/rust/schist_core/src/queries/transactions/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::transaction::Transaction, + schema::transactions::dsl::transactions as transactions_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_transactions( + transactions: &[Transaction], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(transactions_table) + .values(transactions) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/transactions/mod.rs b/rust/schist_core/src/queries/transactions/mod.rs new file mode 100644 index 0000000..983e9af --- /dev/null +++ b/rust/schist_core/src/queries/transactions/mod.rs @@ -0,0 +1,7 @@ +mod delete_all; +mod get_all; +mod insert; + +pub use delete_all::delete_all_transactions; +pub use get_all::get_all_transactions; +pub use insert::insert_transactions; diff --git a/rust/schist_core/src/schema.rs b/rust/schist_core/src/schema.rs new file mode 100644 index 0000000..372f8f3 --- /dev/null +++ b/rust/schist_core/src/schema.rs @@ -0,0 +1,72 @@ +// @generated automatically by Diesel CLI. + +diesel::table! { + accounts (id) { + id -> Integer, + name -> Text, + opening_balance -> Integer, + opening_date -> Text, + } +} + +diesel::table! { + budget_updates (id) { + id -> Integer, + category_id -> Integer, + date -> Text, + new_budget -> Integer, + new_period -> Integer, + } +} + +diesel::table! { + categories (id) { + id -> Integer, + name -> Text, + } +} + +diesel::table! { + category_transfers (id) { + id -> Integer, + description -> Text, + quantity -> Integer, + from_category_id -> Integer, + to_category_id -> Integer, + } +} + +diesel::table! { + transaction_categorisations (id) { + id -> Integer, + description -> Text, + quantity -> Integer, + transaction_id -> Integer, + category_id -> Integer, + } +} + +diesel::table! { + transactions (id) { + id -> Integer, + description -> Text, + payee -> Text, + quantity -> Integer, + date -> Text, + account_id -> Integer, + } +} + +diesel::joinable!(budget_updates -> categories (category_id)); +diesel::joinable!(transaction_categorisations -> categories (category_id)); +diesel::joinable!(transaction_categorisations -> transactions (transaction_id)); +diesel::joinable!(transactions -> accounts (account_id)); + +diesel::allow_tables_to_appear_in_same_query!( + accounts, + budget_updates, + categories, + category_transfers, + transaction_categorisations, + transactions, +); diff --git a/rust/schist_core/src/traits/dateable.rs b/rust/schist_core/src/traits/dateable.rs new file mode 100644 index 0000000..05f2d74 --- /dev/null +++ b/rust/schist_core/src/traits/dateable.rs @@ -0,0 +1,5 @@ +pub trait Dateable { + fn year(&self) -> i32; + fn month(&self) -> u32; + fn day(&self) -> u32; +} diff --git a/rust/schist_core/src/traits/mod.rs b/rust/schist_core/src/traits/mod.rs new file mode 100644 index 0000000..ab5caca --- /dev/null +++ b/rust/schist_core/src/traits/mod.rs @@ -0,0 +1,3 @@ +pub mod dateable; +pub mod nowlike; +pub mod timeable; diff --git a/rust/schist_core/src/traits/nowlike.rs b/rust/schist_core/src/traits/nowlike.rs new file mode 100644 index 0000000..bae2309 --- /dev/null +++ b/rust/schist_core/src/traits/nowlike.rs @@ -0,0 +1,3 @@ +pub trait Nowlike { + fn now() -> Self; +} diff --git a/rust/schist_core/src/traits/timeable.rs b/rust/schist_core/src/traits/timeable.rs new file mode 100644 index 0000000..f6f9244 --- /dev/null +++ b/rust/schist_core/src/traits/timeable.rs @@ -0,0 +1,5 @@ +pub trait Timeable { + fn hour(&self) -> u32; + fn minute(&self) -> u32; + fn second(&self) -> u32; +} diff --git a/rust/schist_core/src/utils/calculate_budgets_accrual.rs b/rust/schist_core/src/utils/calculate_budgets_accrual.rs new file mode 100644 index 0000000..56171ca --- /dev/null +++ b/rust/schist_core/src/utils/calculate_budgets_accrual.rs @@ -0,0 +1,155 @@ +use anyhow::Result; +use crate::{models::{ + budget_update::BudgetUpdate, category::Category, date_utc::DateUtc +}, traits::nowlike::Nowlike}; + +pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUpdate]) -> Result<i64> { + let mut budget_updates = budget_updates + .iter() + .filter(|bu| bu.category_id == category.id) + .collect::<Vec<&BudgetUpdate>>(); + budget_updates.sort_by_key(|bu| bu.date.clone()); + budget_updates.reverse(); + + let mut budgets_accrual = 0.0_f64; + let mut calculated_back_to_date = DateUtc::now(); + + for budget_update in budget_updates { + let days_on_this_budget = calculated_back_to_date.day_diff(&budget_update.date); + if days_on_this_budget == 0_u32 { + return Err(anyhow::Error::msg(format!( + "failed to calculate budgets accrual since two budget updates had the same date ({})", + budget_update.date, + ))); + } + let budget_per_day = budget_update.new_budget as f64 / budget_update.new_period as f64; + budgets_accrual += days_on_this_budget as f64 * budget_per_day; + calculated_back_to_date = budget_update.date.clone(); + } + + Ok(budgets_accrual.floor() as i64) +} + +#[cfg(test)] +mod test { + use chrono::{Days, Utc}; + + use crate::{ + models::{budget_update::BudgetUpdate, category::Category, date_utc::DateUtc}, traits::nowlike::Nowlike, utils::calculate_budgets_accrual + }; + + #[test] + fn when_no_budget_updates_then_return_zero() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = []; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_one_budget_update_for_another_category_then_return_zero() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::now(), + new_budget: 100, + new_period: 1, + }]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_one_budget_update_then_return_quantity_times_days_in_past() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 100, + new_period: 1, + }]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 12_000); + } + + #[test] + fn when_two_budget_updates_then_calculates_as_expected() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [ + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(60)).unwrap()), + new_budget: 200, + new_period: 1, + }, + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 100, + new_period: 1, + }, + ]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 18_000); + } + + #[test] + fn when_two_budget_updates_on_same_day_then_returns_err() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [ + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from_ymd(2020, 12, 25).unwrap(), + new_budget: 200, + new_period: 1, + }, + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from_ymd(2020, 12, 25).unwrap(), + new_budget: 100, + new_period: 1, + }, + ]; + let mut budget_updates_reversed = budget_updates.clone(); + budget_updates_reversed.reverse(); + + let result_leftways = calculate_budgets_accrual(&category, &budget_updates); + let result_rightways = calculate_budgets_accrual(&category, &budget_updates_reversed); + + assert!(result_leftways.is_err()); + assert!(result_rightways.is_err()); + } +} diff --git a/rust/schist_core/src/utils/calculate_category_balance.rs b/rust/schist_core/src/utils/calculate_category_balance.rs new file mode 100644 index 0000000..61b94a8 --- /dev/null +++ b/rust/schist_core/src/utils/calculate_category_balance.rs @@ -0,0 +1,153 @@ +use anyhow::Result; +use crate::{ + models::{budget_update::BudgetUpdate, category::Category}, + utils::{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_updates: &[BudgetUpdate], +) -> 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_updates)?; + + Ok( + transaction_sum + + budget_accruals_sum + + category_transfer_to_sum + - category_transfer_from_sum + ) +} + +#[cfg(test)] +mod test { + use chrono::{Days, Utc}; + + use crate::{ + models::{budget_update::BudgetUpdate, category::Category, date_utc::DateUtc}, + utils::calculate_category_balance + }; + + #[test] + fn when_no_data_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + + 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 = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(1, 100)]; + let category_transfer_from_sums = [(1, 91)]; + let category_transfer_to_sums = [(2, 79)]; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::from(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 77, + new_period: 1, + }]; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_transaction_sum_is_zero_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(0, 0)]; + let category_transfer_from_sums = []; + let category_transfer_to_sums = []; + let budget_updates = []; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_category_transfers_are_zero_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = []; + let category_transfer_from_sums = [(0, 0)]; + let category_transfer_to_sums = [(0, 0)]; + let budget_updates = []; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_some_data_then_calculates_as_expected() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(0, 100)]; + let category_transfer_from_sums = [(0, 91)]; + let category_transfer_to_sums = [(0, 79)]; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 77, + new_period: 1, + }]; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + let expected_result = 100 + (-91) + 79 + 77 * 120; + assert!(result.is_ok()); + assert_eq!(result.unwrap(), expected_result); + } +} diff --git a/rust/schist_core/src/utils/find_by_id_or.rs b/rust/schist_core/src/utils/find_by_id_or.rs new file mode 100644 index 0000000..8335e5c --- /dev/null +++ b/rust/schist_core/src/utils/find_by_id_or.rs @@ -0,0 +1,41 @@ +pub fn find_by_id_or<Id: PartialEq, Val: Copy>( + arr: &[(Id, Val)], + id: Id, + default: Val, +) -> Val { + arr.iter() + .find(|(elem_id, _)| *elem_id == id) + .map_or(default, |row| row.1) +} + +#[cfg(test)] +mod test { + use super::find_by_id_or; + + #[test] + fn when_no_elements_then_return_default() { + let arr = []; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 42); + } + + #[test] + fn when_id_not_in_elements_then_return_default() { + let arr = [(0, 100), (2, 200)]; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 42); + } + + #[test] + fn when_id_in_elements_then_return_value() { + let arr = [(1, 67)]; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 67); + } +} diff --git a/rust/schist_core/src/utils/mod.rs b/rust/schist_core/src/utils/mod.rs new file mode 100644 index 0000000..84a27af --- /dev/null +++ b/rust/schist_core/src/utils/mod.rs @@ -0,0 +1,7 @@ +mod calculate_budgets_accrual; +mod calculate_category_balance; +mod find_by_id_or; + +pub use calculate_budgets_accrual::calculate_budgets_accrual; +pub use calculate_category_balance::calculate_category_balance; +pub use find_by_id_or::find_by_id_or; |