use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use uuid::Uuid; use super::direction::Direction; use crate::domain; #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "snake_case")] #[serde(tag = "type")] pub enum ScheduledTransactionRequest { Recurring(RecurringTransactionRequest), } #[derive(Debug, Clone, Serialize)] #[serde(rename_all = "snake_case")] #[serde(tag = "type")] pub enum ScheduledTransactionResponse { Recurring(RecurringTransactionResponse), } impl From for ScheduledTransactionResponse { fn from(transaction: RecurringTransactionResponse) -> Self { Self::Recurring(transaction) } } #[derive(Debug, Clone, Deserialize)] pub struct RecurringTransactionRequest { pub name: String, pub amount_cents: u64, pub direction: Direction, pub source_account: Option, pub destination_account: Option, pub schedule: ScheduleRequest, } impl RecurringTransactionRequest { pub fn into_domain( self, id: Uuid, ) -> Result { let recurrence = domain::Recurrence { every: domain::RecurrenceInterval::try_from(self.schedule.recurrence.every)?, unit: self.schedule.recurrence.unit.into(), }; Ok(domain::RecurringTransaction { id, name: self.name, amount: domain::Cents::try_from(self.amount_cents)?, direction: self.direction.into(), source_account_id: self.source_account.as_ref().map(|account| account.id), destination_account_id: self.destination_account.as_ref().map(|account| account.id), schedule: domain::Schedule::new( self.schedule.start, self.schedule.end, recurrence, self.schedule.weekend_adjustment.map(Into::into), )?, }) } } #[derive(Debug, Clone, Serialize)] pub struct RecurringTransactionResponse { pub id: Uuid, pub name: String, pub amount_cents: u64, pub direction: Direction, pub source_account: Option, pub destination_account: Option, pub schedule: ScheduleResponse, } impl RecurringTransactionResponse { pub fn new( transaction: domain::RecurringTransaction, source_account: Option, destination_account: Option, schedule_next: Option>, ) -> Self { Self { id: transaction.id, name: transaction.name, amount_cents: transaction.amount.get(), direction: transaction.direction.into(), source_account: source_account.map(|account| AccountResponse { id: account.id, name: account.name, }), destination_account: destination_account.map(|account| AccountResponse { id: account.id, name: account.name, }), schedule: ScheduleResponse::new(transaction.schedule, schedule_next), } } } #[derive(Debug, Clone, Deserialize)] pub struct AccountRequest { pub id: Uuid, } #[derive(Debug, Clone, Serialize)] pub struct AccountResponse { pub id: Uuid, pub name: String, } #[derive(Debug, Clone, Deserialize)] pub struct ScheduleRequest { pub start: DateTime, pub end: Option>, pub recurrence: Recurrence, pub weekend_adjustment: Option, } #[derive(Debug, Clone, Serialize)] pub struct ScheduleResponse { pub start: DateTime, pub end: Option>, pub recurrence: Recurrence, pub weekend_adjustment: Option, pub next: Option>, } impl ScheduleResponse { fn new(schedule: domain::Schedule, next: Option>) -> Self { Self { start: schedule.start(), end: schedule.end(), recurrence: schedule.recurrence().into(), weekend_adjustment: schedule.weekend_adjustment().map(Into::into), next, } } } #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Recurrence { pub every: u32, pub unit: RecurrenceUnit, } impl From for Recurrence { fn from(recurrence: domain::Recurrence) -> Self { Self { every: recurrence.every.get(), unit: recurrence.unit.into(), } } } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum RecurrenceUnit { Day, Week, Month, Year, } impl From for domain::RecurrenceUnit { fn from(unit: RecurrenceUnit) -> Self { match unit { RecurrenceUnit::Day => Self::Day, RecurrenceUnit::Week => Self::Week, RecurrenceUnit::Month => Self::Month, RecurrenceUnit::Year => Self::Year, } } } impl From for RecurrenceUnit { fn from(unit: domain::RecurrenceUnit) -> Self { match unit { domain::RecurrenceUnit::Day => Self::Day, domain::RecurrenceUnit::Week => Self::Week, domain::RecurrenceUnit::Month => Self::Month, domain::RecurrenceUnit::Year => Self::Year, } } } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum WeekendAdjustment { PreviousBusinessDay, NextBusinessDay, } impl From for domain::WeekendAdjustment { fn from(adjustment: WeekendAdjustment) -> Self { match adjustment { WeekendAdjustment::PreviousBusinessDay => Self::PreviousBusinessDay, WeekendAdjustment::NextBusinessDay => Self::NextBusinessDay, } } } impl From for WeekendAdjustment { fn from(adjustment: domain::WeekendAdjustment) -> Self { match adjustment { domain::WeekendAdjustment::PreviousBusinessDay => Self::PreviousBusinessDay, domain::WeekendAdjustment::NextBusinessDay => Self::NextBusinessDay, } } } #[cfg(test)] mod tests { use chrono::{TimeDelta, TimeZone, Utc}; use uuid::Uuid; use super::{ Recurrence, RecurrenceUnit, RecurringTransactionRequest, RecurringTransactionResponse, ScheduleRequest, ScheduledTransactionRequest, ScheduledTransactionResponse, WeekendAdjustment, }; use crate::{ domain::{self, ScheduleError}, routes::dtos::direction::Direction, }; fn request(amount_cents: u64) -> RecurringTransactionRequest { RecurringTransactionRequest { name: String::new(), amount_cents, direction: Direction::Out, source_account: None, destination_account: None, schedule: ScheduleRequest { start: Utc.with_ymd_and_hms(2026, 9, 24, 12, 0, 0).unwrap(), end: None, recurrence: Recurrence { every: 2, unit: RecurrenceUnit::Month, }, weekend_adjustment: Some(WeekendAdjustment::NextBusinessDay), }, } } #[test] fn serializes_scheduled_transaction_with_nested_schedule() { let transaction = request(1234).into_domain(Uuid::nil()).unwrap(); let source_account = None; let destination_account = None; let schedule_next = None; let response = ScheduledTransactionResponse::from(RecurringTransactionResponse::new( transaction, source_account, destination_account, schedule_next, )); let response = serde_json::to_value(response).unwrap(); assert_eq!(response["type"], "recurring"); assert_eq!(response["id"], Uuid::nil().to_string()); assert_eq!(response["amount_cents"], 1234); assert!(response["source_account"].is_null()); assert!(response["destination_account"].is_null()); assert_eq!(response["schedule"]["recurrence"]["unit"], "month"); assert_eq!( response["schedule"]["weekend_adjustment"], "next_business_day" ); assert!(response["schedule"]["next"].is_null()); assert!(response.get("next").is_none()); assert!(response.get("data").is_none()); let request: ScheduledTransactionRequest = serde_json::from_value(response).unwrap(); let ScheduledTransactionRequest::Recurring(request) = request; assert_eq!(request.amount_cents, 1234); assert_eq!(request.schedule.recurrence.every, 2); } #[test] fn serializes_source_and_destination_accounts() { let source_id = Uuid::new_v4(); let destination_id = Uuid::new_v4(); let mut transaction = request(1234); transaction.source_account = Some(super::AccountRequest { id: source_id }); transaction.destination_account = Some(super::AccountRequest { id: destination_id }); let transaction = transaction.into_domain(Uuid::nil()).unwrap(); let source_account = Some(domain::Account { id: source_id, name: "Checking".to_owned(), }); let destination_account = Some(domain::Account { id: destination_id, name: "Savings".to_owned(), }); let response = RecurringTransactionResponse::new( transaction, source_account, destination_account, None, ); let response = serde_json::to_value(response).unwrap(); assert_eq!(response["source_account"]["id"], source_id.to_string()); assert_eq!(response["source_account"]["name"], "Checking"); assert_eq!( response["destination_account"]["id"], destination_id.to_string() ); assert_eq!(response["destination_account"]["name"], "Savings"); } #[test] fn converts_to_domain() { let id = Uuid::new_v4(); let transaction = request(1234).into_domain(id).unwrap(); let recurrence = transaction.schedule.recurrence(); assert_eq!(transaction.id, id); assert_eq!(transaction.amount.get(), 1234); assert_eq!(transaction.direction, domain::Direction::Out); assert_eq!(recurrence.every.get(), 2); assert_eq!(recurrence.unit, domain::RecurrenceUnit::Month); assert_eq!( transaction.schedule.weekend_adjustment(), Some(domain::WeekendAdjustment::NextBusinessDay) ); } #[test] fn rejects_invalid_requests() { assert!(matches!( request(i64::MAX as u64 + 1).into_domain(Uuid::nil()), Err(domain::DomainError::Amount(_)) )); let mut every = request(100); every.schedule.recurrence.every = 0; assert!(matches!( every.into_domain(Uuid::nil()), Err(domain::DomainError::Schedule( ScheduleError::RecurrenceInterval(_) )) )); let mut end = request(100); end.schedule.end = Some(end.schedule.start - TimeDelta::seconds(1)); assert!(matches!( end.into_domain(Uuid::nil()), Err(domain::DomainError::Schedule(ScheduleError::EndBeforeStart)) )); } }