forcen/accounters
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved accumulation calculations into DB triggers

Browse source
This commit is contained in:
Manuel Forcén Muñoz 2024-03-21 23:34:43 +01:00
parent e336292db4
commit 79ef859fbe
9 changed files with 50 additions and 281 deletions
Download patch file Download diff file Expand all files Collapse all files

244
src/models/account.rs
View file

@ -1,199 +1,8 @@
use chrono::{prelude::*, Duration, DurationRound};
use chrono::prelude::*;
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, Result, SqlitePool};
use super::{rules::Rule, Transaction};
#[derive(FromRow, Serialize, Deserialize, Clone, Debug)]
pub struct AccountSnapshot {
account: i32,
datestamp: DateTime<Utc>,
amount: i32,
}
impl AccountSnapshot {
pub async fn get(
pool: &SqlitePool,
account: i32,
date: DateTime<Utc>,
) -> Result<AccountSnapshot> {
sqlx::query("SELECT * FROM account_snapshot WHERE account=? AND datestamp=?")
.bind(account)
.bind(date)
.fetch_one(pool)
.await
.and_then(|r| AccountSnapshot::from_row(&r))
}
pub async fn get_last(
pool: &SqlitePool,
account: i32,
date: DateTime<Utc>,
) -> Result<AccountSnapshot> {
sqlx::query("SELECT * FROM account_snapshot WHERE account=? AND datestamp<=? LIMIT 1")
.bind(account)
.bind(date)
.fetch_one(pool)
.await
.and_then(|r| AccountSnapshot::from_row(&r))
}
pub async fn list(
pool: &SqlitePool,
account: i32,
limit: Option<i32>,
offset: Option<i32>,
asc: bool,
) -> sqlx::Result<Vec<AccountSnapshot>> {
let mut query = sqlx::QueryBuilder::new("SELECT * FROM account_snapshot WHERE account=");
query.push_bind(account);
if let Some(limit) = limit {
query.push(" LIMIT ");
query.push_bind(limit);
}
if let Some(offset) = offset {
query.push(" OFFSET ");
query.push_bind(offset);
}
if asc {
query.push(" ORDER BY datestamp ASC");
} else {
query.push(" ORDER BY datestamp DESC");
}
let rows = query.build().fetch_all(pool).await?;
let mut res = Vec::new();
for r in rows.iter() {
res.push(AccountSnapshot::from_row(r)?);
}
Ok(res)
}
pub async fn list_by_date(
pool: &SqlitePool,
account: i32,
after: Option<DateTime<Utc>>,
before: Option<DateTime<Utc>>,
limit: Option<i32>,
asc: bool,
) -> sqlx::Result<Vec<AccountSnapshot>> {
let mut query = sqlx::QueryBuilder::new("SELECT * FROM account_snapshot WHERE account=");
query.push_bind(account);
if let Some(after) = after {
query.push(" AND datestamp >= ");
query.push_bind(after);
}
if let Some(before) = before {
query.push(" AND datestamp < ");
query.push_bind(before);
}
if let Some(limit) = limit {
query.push(" LIMIT ");
query.push_bind(limit);
}
if asc {
query.push(" ORDER BY datestamp ASC");
} else {
query.push(" ORDER BY datestamp DESC");
}
let rows = query.build().fetch_all(pool).await?;
let mut res = Vec::new();
for r in rows.iter() {
res.push(AccountSnapshot::from_row(r)?);
}
Ok(res)
}
pub async fn delete_by_dates(
pool: &SqlitePool,
account: i32,
after: Option<DateTime<Utc>>,
before: Option<DateTime<Utc>>,
) -> sqlx::Result<()> {
if after.is_none() && before.is_none() {
return Err(sqlx::Error::RowNotFound);
}
let mut query = sqlx::QueryBuilder::new("DELETE FROM account_snapshot WHERE account=");
query.push_bind(account);
if let Some(after) = after {
query.push(" AND datestamp >= ");
query.push_bind(after);
}
if let Some(before) = before {
query.push(" AND datestamp < ");
query.push_bind(before);
}
query.build().execute(pool).await?;
Ok(())
}
pub async fn insert(&self, pool: &SqlitePool) -> sqlx::Result<()> {
sqlx::query("INSERT INTO account_snapshot(account, datestamp, amount) VALUES(?,?,?)")
.bind(self.account)
.bind(self.datestamp)
.bind(self.amount)
.execute(pool)
.await
.map(|_| ())
}
pub async fn get_next(&self, pool: &SqlitePool) -> sqlx::Result<Option<AccountSnapshot>> {
let date_next = match Transaction::list_by_date(
pool,
self.account,
Some(self.datestamp + Duration::days(1)),
None,
Some(1),
true,
)
.await?
.first()
{
Some(tx) => tx.get_timestamp(),
None => {
return Ok(None);
}
}
.duration_trunc(chrono::Duration::days(1))
.unwrap();
println!(
"Starting date: {:?}, ending date: {:?}",
self.datestamp, date_next
);
let tx_list = Transaction::list_by_date(
pool,
self.account,
Some(self.datestamp),
Some(date_next),
None,
true,
)
.await?;
Ok(Some(AccountSnapshot {
datestamp: date_next,
account: self.account,
amount: self.amount + tx_list.iter().fold(0, |acc, tx| acc + tx.get_amount()),
}))
}
}
use super::{rules::Rule, transaction::Transaction};
#[derive(FromRow, Serialize, Deserialize, Debug)]
pub struct Account {
@ -254,55 +63,6 @@ impl Account {
Ok(res)
}
pub async fn recalculate_snapshots(
&self,
pool: &SqlitePool,
from: Option<DateTime<Utc>>,
) -> Result<()> {
let mut snap = match from {
Some(f) => {
let snapshot = AccountSnapshot::list_by_date(
pool,
self.get_id(),
None,
Some(f),
Some(1),
true,
)
.await?;
if snapshot.is_empty() {
AccountSnapshot {
account: self.account_id,
datestamp: Utc.timestamp_opt(0, 0).unwrap(),
amount: 0,
}
} else {
snapshot.first().unwrap().clone()
}
}
None => AccountSnapshot {
account: self.account_id,
datestamp: Utc.timestamp_opt(0, 0).unwrap(),
amount: 0,
},
};
AccountSnapshot::delete_by_dates(
pool,
self.get_id(),
Some(snap.datestamp + Duration::hours(12)),
None,
)
.await?;
while let Some(next) = snap.get_next(pool).await? {
next.insert(pool).await?;
snap = next;
}
Ok(())
}
pub async fn recategorize_transactions(
&self,
pool: &SqlitePool,

1
src/models/transaction.rs
View file

@ -20,6 +20,7 @@ pub struct Transaction {
transaction_timestamp: DateTime<Utc>,
category: Option<i32>,
amount: i32,
accumulated: i32,
#[serde(default, skip_serializing)]
hash: Option<String>,
}