120 lines
3.2 KiB
Rust
120 lines
3.2 KiB
Rust
use chrono::prelude::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::{FromRow, Result, SqlitePool};
|
|
|
|
use super::{rules::Rule, transaction::Transaction};
|
|
|
|
#[derive(FromRow, Serialize, Deserialize, Debug)]
|
|
pub struct Account {
|
|
account_id: i32,
|
|
user: i32,
|
|
account_name: String,
|
|
}
|
|
|
|
impl Account {
|
|
pub fn get_id(&self) -> i32 {
|
|
self.account_id
|
|
}
|
|
|
|
pub fn get_user(&self) -> i32 {
|
|
self.user
|
|
}
|
|
|
|
pub fn get_account_name(&self) -> &str {
|
|
self.account_name.as_str()
|
|
}
|
|
|
|
pub async fn set_account_name(&mut self, pool: &SqlitePool, name: &str) -> Result<()> {
|
|
sqlx::query("UPDATE accounts SET account_name=? WHERE account_id=?")
|
|
.bind(name)
|
|
.bind(self.account_id)
|
|
.execute(pool)
|
|
.await?;
|
|
self.account_name = name.to_string();
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn get_by_id(pool: &SqlitePool, id: i32) -> Result<Self> {
|
|
sqlx::query("SELECT * FROM accounts WHERE account_id=?")
|
|
.bind(id)
|
|
.fetch_one(pool)
|
|
.await
|
|
.and_then(|r| Account::from_row(&r))
|
|
}
|
|
|
|
pub async fn new(pool: &SqlitePool, user: i32, name: &str) -> Result<Self> {
|
|
let row = sqlx::query("INSERT INTO accounts(user, account_name) VALUES (?,?) RETURNING *")
|
|
.bind(user)
|
|
.bind(name)
|
|
.fetch_one(pool)
|
|
.await?;
|
|
Self::from_row(&row)
|
|
}
|
|
|
|
pub async fn list(pool: &SqlitePool, user: i32) -> Result<Vec<Self>> {
|
|
let rows = sqlx::query("SELECT * FROM accounts WHERE user=?")
|
|
.bind(user)
|
|
.fetch_all(pool)
|
|
.await?;
|
|
let mut res = Vec::new();
|
|
for r in &rows {
|
|
res.push(Account::from_row(r)?)
|
|
}
|
|
Ok(res)
|
|
}
|
|
|
|
pub async fn recategorize_transactions(
|
|
&self,
|
|
pool: &SqlitePool,
|
|
from: Option<DateTime<Utc>>,
|
|
to: Option<DateTime<Utc>>,
|
|
) -> Result<()> {
|
|
let rules = Rule::list_by_user(pool, self.user).await?;
|
|
let mut tx_list =
|
|
Transaction::list_by_date(pool, self.account_id, from, to, None, true).await?;
|
|
for tx in tx_list.iter_mut() {
|
|
println!("Checking {}", tx.get_description());
|
|
if tx.recategorize(pool, &rules).await? {
|
|
println!(
|
|
"Tx {} updated with category {}",
|
|
tx.get_id(),
|
|
tx.get_category().unwrap_or(0)
|
|
);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::Account;
|
|
use crate::models::users::User;
|
|
use sqlx::SqlitePool;
|
|
|
|
async fn get_db() -> SqlitePool {
|
|
crate::create_db("sqlite://account_test.db").await.unwrap()
|
|
}
|
|
|
|
async fn remove_db(pool: SqlitePool) {
|
|
pool.close().await;
|
|
std::fs::remove_file("account_test.db").unwrap();
|
|
}
|
|
|
|
async fn new_user(pool: &SqlitePool) -> User {
|
|
User::create_user(pool, "account_test", "pass")
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn create_test() {
|
|
let pool = get_db().await;
|
|
let user = new_user(&pool).await;
|
|
Account::new(&pool, user.get_id(), "account_test")
|
|
.await
|
|
.unwrap();
|
|
remove_db(pool).await;
|
|
}
|
|
}
|