355 lines
11 KiB
Rust
355 lines
11 KiB
Rust
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<RecurringTransactionResponse> 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<AccountRequest>,
|
|
pub destination_account: Option<AccountRequest>,
|
|
pub schedule: ScheduleRequest,
|
|
}
|
|
|
|
impl RecurringTransactionRequest {
|
|
pub fn into_domain(
|
|
self,
|
|
id: Uuid,
|
|
) -> Result<domain::RecurringTransaction, domain::DomainError> {
|
|
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<AccountResponse>,
|
|
pub destination_account: Option<AccountResponse>,
|
|
pub schedule: ScheduleResponse,
|
|
}
|
|
|
|
impl RecurringTransactionResponse {
|
|
pub fn new(
|
|
transaction: domain::RecurringTransaction,
|
|
source_account: Option<domain::Account>,
|
|
destination_account: Option<domain::Account>,
|
|
schedule_next: Option<DateTime<Utc>>,
|
|
) -> 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<Utc>,
|
|
pub end: Option<DateTime<Utc>>,
|
|
pub recurrence: Recurrence,
|
|
pub weekend_adjustment: Option<WeekendAdjustment>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize)]
|
|
pub struct ScheduleResponse {
|
|
pub start: DateTime<Utc>,
|
|
pub end: Option<DateTime<Utc>>,
|
|
pub recurrence: Recurrence,
|
|
pub weekend_adjustment: Option<WeekendAdjustment>,
|
|
pub next: Option<DateTime<Utc>>,
|
|
}
|
|
|
|
impl ScheduleResponse {
|
|
fn new(schedule: domain::Schedule, next: Option<DateTime<Utc>>) -> 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<domain::Recurrence> 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<RecurrenceUnit> 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<domain::RecurrenceUnit> 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<WeekendAdjustment> for domain::WeekendAdjustment {
|
|
fn from(adjustment: WeekendAdjustment) -> Self {
|
|
match adjustment {
|
|
WeekendAdjustment::PreviousBusinessDay => Self::PreviousBusinessDay,
|
|
WeekendAdjustment::NextBusinessDay => Self::NextBusinessDay,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<domain::WeekendAdjustment> 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))
|
|
));
|
|
}
|
|
}
|