Condensed classifiers in one place

webserver/src/main.rs

@@ -42,12 +42,26 @@ async fn main() {
                     "/accounts/id/:id/transactions/add",
                     post(routes::ui::account::add_transactions_action),
                 )
-                .route("/rules", get(routes::ui::rules::list))
-                .route("/rules/new", get(routes::ui::rules::new_view))
-                .route("/rules/new", post(routes::ui::rules::new_action))
-                .route("/categories", get(routes::ui::categories::list))
-                .route("/categories/new", get(routes::ui::categories::new_view))
-                .route("/categories/new", post(routes::ui::categories::new_action))
+                .route(
+                    "/classifiers",
+                    get(routes::ui::classifier::view_classifiers),
+                )
+                .route(
+                    "/classifiers/new_rule",
+                    get(routes::ui::classifier::rules_new_view),
+                )
+                .route(
+                    "/classifiers/new_rule",
+                    post(routes::ui::classifier::rules_new_action),
+                )
+                .route(
+                    "/classifiers/new_category",
+                    get(routes::ui::classifier::category_new_view),
+                )
+                .route(
+                    "/classifiers/new_category",
+                    post(routes::ui::classifier::category_new_action),
+                )
                 .nest(
                     "/static",
                     Router::new()

webserver/src/routes/ui.rs

@@ -6,10 +6,11 @@ use sqlx::SqlitePool;
 use tera::{Context, Tera};
 
 use crate::users::UserToken;
-use accounters::models::Account;
+use accounters::models::{Account, Transaction};
 
 pub mod account;
 pub mod categories;
+pub mod classifier;
 pub mod rules;
 
 pub async fn index(
@@ -22,6 +23,11 @@ pub async fn index(
     let accounts = Account::list(db.as_ref(), uid.user_id).await.unwrap();
     ctx.insert("accounts", &accounts);
 
+    let transactions = Transaction::list_by_user(db.as_ref(), uid.user_id, 10, 0, false)
+        .await
+        .unwrap();
+    ctx.insert("transactions", &transactions);
+
     match tmpls.render("index.html", &ctx) {
         Ok(out) => (
             StatusCode::OK,

webserver/src/routes/ui/classifier.rs

@@ -0,0 +1,155 @@
+use std::sync::Arc;
+
+use accounters::models::{categories::Category, rules::Rule};
+use axum::{
+    extract::{Form, State},
+    response::IntoResponse,
+};
+use hyper::{header::CONTENT_TYPE, StatusCode};
+use serde::Deserialize;
+use sqlx::SqlitePool;
+use tera::{Context, Tera};
+
+use crate::users::UserToken;
+
+pub async fn view_classifiers(
+    State(db): State<Arc<SqlitePool>>,
+    State(tmpls): State<Arc<Tera>>,
+    uid: UserToken,
+) -> impl IntoResponse {
+    let rules = match Rule::list_by_user(db.as_ref(), uid.user_id).await {
+        Ok(r) => r,
+        Err(e) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                [(CONTENT_TYPE, "text/plain")],
+                format!("{e:?}"),
+            );
+        }
+    };
+
+    let categories = match Category::list(db.as_ref()).await {
+        Ok(categories) => categories,
+        Err(e) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                [(CONTENT_TYPE, "text/plain;charset=utf-8")],
+                format!("{e}"),
+            )
+        }
+    };
+
+    let mut ctx = Context::new();
+
+    ctx.insert("rules", &rules);
+    ctx.insert("categories", &categories);
+
+    (
+        StatusCode::OK,
+        [(CONTENT_TYPE, "text/html;charset=utf-8")],
+        tmpls.render("classifiers.html", &ctx).unwrap(),
+    )
+}
+
+pub async fn rules_new_view(
+    State(db): State<Arc<SqlitePool>>,
+    State(tmpls): State<Arc<Tera>>,
+    uid: UserToken,
+) -> impl IntoResponse {
+    let categories = Category::list(db.as_ref()).await.unwrap();
+    let mut ctx = Context::new();
+    ctx.insert("categories", &categories);
+    (
+        StatusCode::OK,
+        [(CONTENT_TYPE, "text/html;charset=utf-8")],
+        tmpls.render("rules_new.html", &ctx).unwrap(),
+    )
+}
+
+#[derive(Deserialize)]
+pub struct NewRuleParams {
+    pub description: String,
+    pub regex: String,
+    pub category: i32,
+}
+
+pub async fn rules_new_action(
+    State(db): State<Arc<SqlitePool>>,
+    State(tmpls): State<Arc<Tera>>,
+    uid: UserToken,
+    Form(params): Form<NewRuleParams>,
+) -> impl IntoResponse {
+    match Rule::new(db.as_ref(), uid.user_id, params.regex, params.category).await {
+        Ok(_) => (
+            StatusCode::OK,
+            [(CONTENT_TYPE, "text/html;charset=utf-8")],
+            tmpls
+                .render("rules_new_success.html", &Context::new())
+                .unwrap(),
+        ),
+        Err(e) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            [(CONTENT_TYPE, "text/plain;charset=utf-8")],
+            format!("{e}"),
+        ),
+    }
+}
+
+pub async fn category_list(
+    State(db): State<Arc<SqlitePool>>,
+    State(tmpl): State<Arc<Tera>>,
+    uid: UserToken,
+) -> impl IntoResponse {
+    match Category::list(db.as_ref()).await {
+        Ok(categories) => {
+            let mut ctx = Context::new();
+            ctx.insert("categories", &categories);
+            (
+                StatusCode::OK,
+                [(CONTENT_TYPE, "text/html;charset=utf-8")],
+                tmpl.render("categories_list.html", &ctx).unwrap(),
+            )
+        }
+        Err(e) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            [(CONTENT_TYPE, "text/plain;charset=utf-8")],
+            format!("{e}"),
+        ),
+    }
+}
+
+pub async fn category_new_view(State(tmpl): State<Arc<Tera>>, uid: UserToken) -> impl IntoResponse {
+    (
+        StatusCode::OK,
+        [(CONTENT_TYPE, "text/html;charset=utf-8")],
+        tmpl.render("categories_new.html", &Context::new()).unwrap(),
+    )
+}
+
+#[derive(Deserialize)]
+pub struct CategoryNewRuleParams {
+    pub name: String,
+    pub description: String,
+}
+
+pub async fn category_new_action(
+    State(db): State<Arc<SqlitePool>>,
+    State(tmpls): State<Arc<Tera>>,
+    uid: UserToken,
+    Form(params): Form<CategoryNewRuleParams>,
+) -> impl IntoResponse {
+    match Category::new(db.as_ref(), &params.name, &params.description).await {
+        Ok(_) => (
+            StatusCode::OK,
+            [(CONTENT_TYPE, "text/html;charset=utf-8")],
+            tmpls
+                .render("rules_new_success.html", &Context::new())
+                .unwrap(),
+        ),
+        Err(e) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            [(CONTENT_TYPE, "text/plain;charset=utf-8")],
+            format!("{e}"),
+        ),
+    }
+}