Application able to CRUD

src/lib.rs

@@ -0,0 +1,20 @@
+use sqlx::{migrate::MigrateDatabase, Sqlite, SqlitePool};
+
+pub mod models;
+
+pub async fn create_db(db_url: &str) -> sqlx::Result<SqlitePool> {
+    if !Sqlite::database_exists(db_url).await.unwrap_or(false) {
+        println!("Creating database {}", db_url);
+        match Sqlite::create_database(db_url).await {
+            Ok(_) => println!("create db success"),
+            Err(e) => panic!("Cannot create db: {e:?}"),
+        };
+    } else {
+        println!("Database already exists")
+    }
+
+    let db = SqlitePool::connect(db_url).await?;
+    sqlx::migrate!().run(&db).await?;
+
+    Ok(db)
+}

src/models.rs

@@ -0,0 +1,8 @@
+mod account;
+pub mod categories;
+pub mod rules;
+pub mod transaction;
+pub mod users;
+
+pub use account::{Account, AccountSnapshot};
+pub use transaction::Transaction;

src/models/account.rs

@@ -0,0 +1,360 @@
+use chrono::{prelude::*, Duration, DurationRound};
+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()),
+        }))
+    }
+}
+
+#[derive(FromRow, Serialize, Deserialize)]
+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 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,
+        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;
+    }
+}

src/models/categories.rs

@@ -0,0 +1,41 @@
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, SqlitePool};
+
+#[derive(FromRow, Serialize, Deserialize)]
+pub struct Category {
+    pub category_id: i32,
+    pub name: String,
+    pub description: String,
+}
+
+impl Category {
+    pub async fn get_by_id(pool: &SqlitePool, id: i32) -> sqlx::Result<Self> {
+        sqlx::query("SELECT * FROM categories WHERE category_id=?")
+            .bind(id)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| Category::from_row(&r))
+    }
+
+    pub async fn list(pool: &SqlitePool) -> sqlx::Result<Vec<Category>> {
+        let mut res = Vec::new();
+        for r in sqlx::query("SELECT * FROM categories")
+            .fetch_all(pool)
+            .await?
+            .iter()
+        {
+            res.push(Category::from_row(r)?)
+        }
+
+        Ok(res)
+    }
+
+    pub async fn new(pool: &SqlitePool, name: &str, description: &str) -> sqlx::Result<Category> {
+        sqlx::query("INSERT INTO categories(name, description) VALUES (?,?) RETURNING *")
+            .bind(name)
+            .bind(description)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| Category::from_row(&r))
+    }
+}

src/models/rules.rs

@@ -0,0 +1,54 @@
+use regex::Regex;
+use serde::Serialize;
+use sqlx::{FromRow, SqlitePool};
+
+#[derive(FromRow, Serialize)]
+pub struct Rule {
+    pub rule_id: i32,
+    pub user: i32,
+    pub regex: String,
+    pub category: i32,
+}
+
+impl Rule {
+    pub async fn get_by_id(pool: &SqlitePool, rule_id: i32) -> sqlx::Result<Self> {
+        sqlx::query("SELECT * FROM rules WHERE rule_id=?")
+            .bind(rule_id)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| Rule::from_row(&r))
+    }
+
+    pub async fn list_by_user(pool: &SqlitePool, user: i32) -> sqlx::Result<Vec<Self>> {
+        let mut res = Vec::new();
+        for r in sqlx::query("SELECT * FROM rules WHERE user=?")
+            .bind(user)
+            .fetch_all(pool)
+            .await?
+            .iter()
+        {
+            res.push(Rule::from_row(r)?);
+        }
+        Ok(res)
+    }
+
+    pub async fn new(
+        pool: &SqlitePool,
+        user: i32,
+        regex: String,
+        category: i32,
+    ) -> sqlx::Result<Self> {
+        sqlx::query("INSERT INTO rules(user, regex, category) VALUES (?,?,?) RETURNING *")
+            .bind(user)
+            .bind(regex)
+            .bind(category)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| Rule::from_row(&r))
+    }
+
+    pub fn matches(&self, description: &str) -> Result<bool, regex::Error> {
+        let re = Regex::new(&self.regex)?;
+        Ok(re.is_match(description))
+    }
+}

src/models/transaction.rs

@@ -0,0 +1,217 @@
+use chrono::prelude::*;
+use serde::{Deserialize, Serialize};
+use sqlx::{FromRow, Result, Sqlite, SqlitePool};
+
+use crate::models::rules::Rule;
+
+#[derive(FromRow, Serialize, Deserialize, Debug)]
+pub struct Transaction {
+    transaction_id: i32,
+    account: i32,
+    description: String,
+    transaction_timestamp: DateTime<Utc>,
+    category: Option<i32>,
+    amount: i32,
+}
+
+impl Transaction {
+    pub async fn new(
+        pool: &SqlitePool,
+        account: i32,
+        desc: &str,
+        ts: &DateTime<Utc>,
+        category: Option<i32>,
+        amount: i32,
+    ) -> Result<Self> {
+        let res = sqlx::query(concat!(
+            "INSERT INTO transactions(",
+            "account, description, transaction_timestamp, category, amount",
+            ") VALUES (?,?,?,?,?) RETURNING *"
+        ))
+        .bind(account)
+        .bind(desc)
+        .bind(ts)
+        .bind(category)
+        .bind(amount)
+        .fetch_one(pool)
+        .await?;
+
+        Transaction::from_row(&res)
+    }
+
+    pub async fn list(
+        pool: &SqlitePool,
+        account: i32,
+        limit: i32,
+        offset: i32,
+        asc: bool,
+    ) -> Result<Vec<Self>> {
+        let rows = sqlx::query(
+			if asc {
+				"SELECT * FROM transactions WHERE account=? ORDER BY transaction_timestamp ASC LIMIT ? OFFSET ?"
+			} else {
+				"SELECT * FROM transactions WHERE account=? ORDER BY transaction_timestamp DESC LIMIT ? OFFSET ?"
+			}
+		).bind(account)
+         .bind(limit)
+         .bind(offset)
+         .fetch_all(pool)
+         .await?;
+
+        let mut res = Vec::new();
+        for r in &rows {
+            res.push(Transaction::from_row(r)?);
+        }
+        Ok(res)
+    }
+
+    pub fn query_by_date<'a>(
+        account: i32,
+        after: Option<DateTime<Utc>>,
+        before: Option<DateTime<Utc>>,
+        limit: Option<i32>,
+        asc: bool,
+    ) -> sqlx::QueryBuilder<'a, Sqlite> {
+        let mut query = sqlx::QueryBuilder::new("SELECT * FROM TRANSACTIONS WHERE account=");
+        query.push_bind(account);
+
+        if let Some(after) = after {
+            query.push(" AND transaction_timestamp >= ");
+            query.push_bind(after);
+        }
+
+        if let Some(before) = before {
+            query.push(" AND transaction_timestamp < ");
+            query.push_bind(before);
+        }
+
+        if asc {
+            query.push(" ORDER BY transaction_timestamp ASC");
+        } else {
+            query.push(" ORDER BY transaction_timestamp DESC");
+        }
+
+        if let Some(lim) = limit {
+            query.push(" LIMIT ");
+            query.push_bind(lim);
+        }
+
+        query
+    }
+
+    pub async fn list_by_date(
+        pool: &SqlitePool,
+        account: i32,
+        after: Option<DateTime<Utc>>,
+        before: Option<DateTime<Utc>>,
+        limit: Option<i32>,
+        asc: bool,
+    ) -> Result<Vec<Self>> {
+        let mut query = Self::query_by_date(account, after, before, limit, asc);
+
+        let rows = query.build().fetch_all(pool).await?;
+
+        let mut res = Vec::new();
+        for r in &rows {
+            res.push(Transaction::from_row(r)?);
+        }
+        Ok(res)
+    }
+
+    pub fn get_id(&self) -> i32 {
+        self.transaction_id
+    }
+
+    pub fn get_account(&self) -> i32 {
+        self.account
+    }
+
+    pub fn get_description(&self) -> &str {
+        &self.description
+    }
+
+    pub fn get_timestamp(&self) -> &DateTime<Utc> {
+        &self.transaction_timestamp
+    }
+
+    pub fn get_category(&self) -> Option<i32> {
+        self.category
+    }
+
+    pub async fn set_category(&mut self, pool: &SqlitePool, new_category: i32) -> Result<()> {
+        sqlx::query("UPDATE transactions SET category=? WHERE transaction_id=?")
+            .bind(new_category)
+            .bind(self.transaction_id)
+            .execute(pool)
+            .await?;
+        self.category = Some(new_category);
+        Ok(())
+    }
+
+    pub async fn recategorize(&mut self, pool: &SqlitePool, rules: &Vec<Rule>) -> Result<bool> {
+        for r in rules.iter() {
+            if r.matches(&self.description)
+                .map_err(|_| sqlx::Error::Protocol("RegexError".to_string()))?
+            {
+                self.set_category(pool, r.category).await?;
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    pub fn get_amount(&self) -> i32 {
+        self.amount
+    }
+
+    pub async fn set_description(&mut self, pool: &SqlitePool, desc: &str) -> Result<()> {
+        sqlx::query("UPDATE transactions SET description=? WHERE transaction_id=?")
+            .bind(desc)
+            .bind(self.transaction_id)
+            .execute(pool)
+            .await?;
+        self.description = desc.to_string();
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Transaction;
+    use crate::models::{account::Account, users::User};
+    use sqlx::SqlitePool;
+
+    async fn get_db() -> SqlitePool {
+        crate::create_db("sqlite://tx_test.db").await.unwrap()
+    }
+
+    async fn remove_db(pool: SqlitePool) {
+        pool.close().await;
+        std::fs::remove_file("tx_test.db").unwrap();
+    }
+
+    async fn new_user(pool: &SqlitePool) -> User {
+        User::create_user(pool, "testuser", "pass").await.unwrap()
+    }
+
+    #[tokio::test]
+    async fn create_test() {
+        let pool = get_db().await;
+        let user = new_user(&pool).await;
+        let acc = Account::new(&pool, user.get_id(), "tx_test").await.unwrap();
+        let tx = Transaction::new(
+            &pool,
+            acc.get_id(),
+            "Test transaction",
+            &chrono::Utc::now(),
+            None,
+            100,
+        )
+        .await
+        .unwrap();
+
+        println!("{tx:?}");
+
+        remove_db(pool).await;
+    }
+}

src/models/users.rs

@@ -0,0 +1,35 @@
+use sqlx::{FromRow, SqlitePool};
+
+#[derive(Debug, FromRow)]
+pub struct User {
+    user_id: i32,
+    username: String,
+    pass: String,
+}
+
+impl User {
+    pub fn get_id(&self) -> i32 {
+        self.user_id
+    }
+
+    pub fn check_pass(&self, pass: &str) -> bool {
+        &self.pass == pass
+    }
+
+    pub async fn create_user(pool: &SqlitePool, user: &str, pass: &str) -> sqlx::Result<Self> {
+        sqlx::query("INSERT INTO users(username, pass) VALUES (?, ?) RETURNING *")
+            .bind(user)
+            .bind(pass)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| User::from_row(&r))
+    }
+
+    pub async fn get_user(pool: &SqlitePool, user: &str) -> sqlx::Result<Self> {
+        sqlx::query("SELECT * FROM users WHERE username = ?")
+            .bind(user)
+            .fetch_one(pool)
+            .await
+            .and_then(|r| User::from_row(&r))
+    }
+}