Fixed code styling.

src/db/_accounts.rs

@@ -1,9 +1,9 @@
 use fraction::Fraction;
-use rusqlite::{params, Connection, OptionalExtension, Result, Row, Transaction};
+use rusqlite::{params, Connection, OptionalExtension, Result, Row};
 
 use crate::db::_external_id::{AccountId, Id, UserId};
 use crate::db::_securities::Security;
-use crate::db::_users::User;
+
 use crate::db::external_id::SecurityId;
 use crate::util::{CustomResult, Error};
 
@@ -267,9 +267,10 @@ pub fn add_to_account(
 
 #[cfg(test)]
 mod test_accounts {
-    use rusqlite::Connection;
+    use rusqlite::{Connection, Transaction};
 
     use crate::db::_test_utils::setup_users_and_securities;
+    use crate::db::users::User;
     use crate::migration;
 
     use super::*;

src/db/_securities.rs

@@ -2,7 +2,7 @@ use rusqlite::{params, Connection, Result, Row, ToSql, Transaction};
 use serde::Serialize;
 
 use crate::db::_external_id::{Id, SecurityId};
-use crate::db::users::User;
+
 
 #[derive(Debug, Serialize, PartialEq)]
 pub enum SecurityType {
@@ -98,6 +98,7 @@ mod test_securities {
     use rusqlite::{params, Connection};
 
     use crate::db::_test_utils::*;
+    use crate::db::users::User;
     use crate::migration;
 
     use super::*;

src/event_processor.rs

@@ -1,17 +1,15 @@
 use std::borrow::Borrow;
-use std::f32::consts::E;
-use std::fs;
+
+
 use std::fs::File;
-use std::io::{BufReader, Read, Write};
+
 use std::path::PathBuf;
 
 use crate::util::{CustomResult, Error};
-use apache_avro::types::Value;
-use apache_avro::Schema::Union;
-use apache_avro::{
-    from_value, types::Record, Codec, GenericSingleObjectReader, Reader, Schema, Writer,
-};
-use resource::resource_str;
+
+
+
+
 use rusqlite::Connection;
 use serde::{Deserialize, Serialize};
 
@@ -25,7 +23,7 @@ enum Event {
     CacheCheque(CacheChequeEvent),
 }
 
-fn process_event_file(conn: &mut Connection, file: File) -> CustomResult<()> {
+fn process_event_file(_conn: &mut Connection, _file: File) -> CustomResult<()> {
     return Ok(());
 }
 
@@ -42,12 +40,10 @@ where
 }
 
 mod test {
-    use std::fs::File;
-
-    use apache_avro::Schema;
+    use rusqlite::Connection;
     use tempfile::tempfile;
-
-    use super::*;
+    use crate::event_processor::process_event_file;
+    use crate::util::CustomResult;
 
     #[test]
     fn test_basic() -> CustomResult<()> {

src/main.rs

@@ -241,7 +241,7 @@ fn process_run_wui_command_line(
     logic: &mut dyn CommandLineUserLogic,
 ) {
     debug!("Processing run wui command line {:?}.", m);
-    let mut port = m.get_one::<u16>("port").unwrap_or(&2222);
+    let port = m.get_one::<u16>("port").unwrap_or(&2222);
     let enable_template_autoreload = m.get_flag("enable-template-autoreload");
     logic.run_webui(conn, *port, enable_template_autoreload);
 }
@@ -351,15 +351,15 @@ mod cli_test {
             self.list_securities_count += 1;
         }
 
-        fn process_events(&mut self, conn: &mut Connection, _files: ValuesRef<PathBuf>) {
+        fn process_events(&mut self, _conn: &mut Connection, _files: ValuesRef<PathBuf>) {
             self.process_events_count += 1;
         }
 
         fn run_webui(
             &mut self,
-            conn: &mut Connection,
-            port: u16,
-            enable_template_autoreload: bool,
+            _conn: &mut Connection,
+            _port: u16,
+            _enable_template_autoreload: bool,
         ) {
             self.run_webui_count += 1;
         }
@@ -503,10 +503,9 @@ impl CommandLineUserLogic for ProCommandLineLogic {
         println!("fuck me");
     }
 
-    fn run_webui(&mut self, conn: &mut Connection, port: u16, enable_template_autoreload: bool) {
+    fn run_webui(&mut self, _conn: &mut Connection, port: u16, enable_template_autoreload: bool) {
         info!("Serving web-ui on port {:?}", port);
-        web_ui_main(port,
-                    enable_template_autoreload).unwrap();
+        web_ui_main(port, enable_template_autoreload).unwrap();
     }
 }
 

src/services/_transactions.rs

@@ -1,7 +1,7 @@
 use rusqlite::{ffi, params, Connection, Savepoint, Transaction};
 
 use crate::db::accounts;
-use crate::db::accounts::get_account_by_id;
+
 use crate::db::cheques::Cheque;
 use crate::db::external_id::AccountId;
 use crate::util::*;
@@ -124,7 +124,7 @@ fn cash_cheque(tx: &mut Transaction, cheque: &Cheque, account_id: &AccountId) ->
 mod test_caching_cheques {
     use rusqlite::Connection;
 
-    use crate::db::accounts::{create_checking_account, create_security_emitter_account};
+    use crate::db::accounts::{create_checking_account, create_security_emitter_account, get_account_by_id};
     use crate::db::cheques::{Drawer, Payee};
     use crate::db::external_id::{Id, UserId};
     use crate::db::test_utils;
@@ -141,7 +141,7 @@ mod test_caching_cheques {
     fn setup_security_emitter() -> (Connection, Drawer, Payee, AccountId) {
         let mut conn = setup_conn();
         let tx = conn.transaction().unwrap();
-        let (users, securities, accounts) = test_utils::setup_basic_environment(&tx).unwrap();
+        let (users, securities, _accounts) = test_utils::setup_basic_environment(&tx).unwrap();
         let sec = securities.get(0).unwrap();
         let drawer = users.get(0).unwrap();
         let payee = users.get(1).unwrap();
@@ -319,11 +319,11 @@ mod test_caching_cheques {
     }
 
     fn test_invalid_payee(
-        conn: &mut Connection,
-        security_emitter: Drawer,
-        payee: Payee,
+        _conn: &mut Connection,
+        _security_emitter: Drawer,
+        _payee: Payee,
     ) -> CustomResult<()> {
-        let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
+        let (mut conn, security_emitter, payee, _payee_account) = setup_security_emitter();
         let mut tx = conn.transaction().unwrap();
         let wrong_payee_account = &security_emitter.1;
 
@@ -338,13 +338,13 @@ mod test_caching_cheques {
 
     #[test]
     fn test_invalid_payee_security_emitter_cheque() -> CustomResult<()> {
-        let (mut conn, security_emitter, payee, payee_account) = setup_security_emitter();
+        let (mut conn, security_emitter, payee, _payee_account) = setup_security_emitter();
         test_invalid_payee(&mut conn, security_emitter, payee)
     }
 
     #[test]
     fn test_invalid_payee_regular_cheque() -> CustomResult<()> {
-        let (mut conn, drawer, payee, payee_account) = setup_basic();
+        let (mut conn, drawer, payee, _payee_account) = setup_basic();
         test_invalid_payee(&mut conn, drawer, payee)
     }
 }

src/util.rs

@@ -40,8 +40,7 @@ impl SQLiteConnectionFactory for PathSQLiteConnectionFactory {
     }
 }
 
-
-pub struct InMemorySQLiteConnectionFactory{}
+pub struct InMemorySQLiteConnectionFactory {}
 
 impl SQLiteConnectionFactory for InMemorySQLiteConnectionFactory {
     fn connection(&self) -> Connection {
@@ -51,4 +50,4 @@ impl SQLiteConnectionFactory for InMemorySQLiteConnectionFactory {
     fn readonly(&self) -> Connection {
         Connection::open_in_memory_with_flags(OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap()
     }
-}
+}

src/webui/config.rs

@@ -1,3 +0,0 @@
-struct Config {
-    path: str,
-}

src/webui/mod.rs

@@ -1,38 +1,35 @@
 #![feature(future_join)]
 
-use std::{collections::HashMap, env, fs, io, path::PathBuf};
-use std::io::{Error, ErrorKind};
-use std::path::Path;
 
+
+use std::{env, path::PathBuf};
+
+use crate::webui::worker::worker_loop;
 use actix_files;
-use actix_utils::future::{ready, Ready};
+
 use actix_web::{
-    App,
     dev::ServiceResponse,
     error,
-    FromRequest,
-    http::{header::ContentType, StatusCode}, HttpRequest, HttpResponse, HttpServer, middleware::{ErrorHandlerResponse, ErrorHandlers, Logger}, Responder, Result, web,
+    http::{header::ContentType, StatusCode},
+    middleware::{ErrorHandlerResponse, ErrorHandlers, Logger},
+    web, App, FromRequest, HttpRequest, HttpResponse, HttpServer, Responder, Result,
 };
 use actix_web_lab::respond::Html;
 use async_channel;
-use futures::{FutureExt, pin_mut, select};
+use futures::{pin_mut, select, FutureExt};
 use minijinja;
 use minijinja_autoreload::AutoReloader;
-use tokio::time::{Duration, sleep};
+
 
 mod views;
-mod config;
+mod worker;
 
 struct MiniJinjaRenderer {
     tmpl_env: web::Data<minijinja_autoreload::AutoReloader>,
 }
 
 impl MiniJinjaRenderer {
-    fn render(
-        &self,
-        tmpl: &str,
-        ctx: impl Into<minijinja::value::Value>,
-    ) -> Result<Html> {
+    fn render(&self, tmpl: &str, ctx: impl Into<minijinja::value::Value>) -> Result<Html> {
         log::info!("Rendering template {:?}", tmpl);
         self.tmpl_env
             .acquire_env()
@@ -61,19 +58,6 @@ impl FromRequest for MiniJinjaRenderer {
     }
 }
 
-async fn worker_loop(r: async_channel::Receiver<i32>) -> io::Result<()> {
-    loop {
-        let x = r.recv().await;
-        match x {
-            Ok(v) => println!("Processed value: {:?}", v),
-            Err(e) => {
-                println!("Error: {:?}", e);
-                return Ok(())
-            }
-        }
-    }
-}
-
 #[tokio::main]
 pub async fn web_ui_main(port: u16, enable_template_autoreload: bool) -> std::io::Result<()> {
     // The closure is invoked every time the environment is outdated to recreate it.
@@ -99,8 +83,9 @@ pub async fn web_ui_main(port: u16, enable_template_autoreload: bool) -> std::io
         App::new()
             .app_data(tmpl_reloader.clone())
             .app_data(web::Data::new(s.clone()))
-            .service(actix_files::Files::new("/static", "./resources/static/")
-                .use_last_modified(true))
+            .service(
+                actix_files::Files::new("/static", "./resources/static/").use_last_modified(true),
+            )
             .service(views::index)
             .service(views::actions)
             .service(views::overview)
@@ -117,7 +102,7 @@ pub async fn web_ui_main(port: u16, enable_template_autoreload: bool) -> std::io
     let t2 = worker_loop(r).fuse();
     pin_mut!(t1, t2);
 
-    select!{
+    select! {
         x = t1 => x,
         y = t2 => y,
     }

src/webui/views.rs

@@ -1,38 +1,32 @@
-use actix_web::{HttpRequest, Responder, web};
-use actix_web::http::header::q;
+
+use actix_web::{web, HttpRequest, Responder};
 use clap::builder::TypedValueParser;
+use log::info;
 use minijinja::context;
+
 use serde::Deserialize;
 use std::collections::HashMap;
-use log::info;
-use resource::resource_str;
 
 use crate::webui::MiniJinjaRenderer;
 
 #[actix_web::get("/")]
-pub async fn index(
-    tmpl_env: MiniJinjaRenderer,
-) -> actix_web::Result<impl Responder> {
+pub async fn index(tmpl_env: MiniJinjaRenderer) -> actix_web::Result<impl Responder> {
     tmpl_env.render("index.html", ())
 }
 
 #[actix_web::get("/actions")]
-pub async fn actions(
-    tmpl_env: MiniJinjaRenderer,
-) -> actix_web::Result<impl Responder> {
+pub async fn actions(tmpl_env: MiniJinjaRenderer) -> actix_web::Result<impl Responder> {
     tmpl_env.render("actions.html", ())
 }
 
 #[actix_web::get("/overview")]
-pub async fn overview(
-    tmpl_env: MiniJinjaRenderer,
-) -> actix_web::Result<impl Responder> {
+pub async fn overview(tmpl_env: MiniJinjaRenderer) -> actix_web::Result<impl Responder> {
     tmpl_env.render("overview.html", ())
 }
 
 #[actix_web::get("/partials/overview/submit_button")]
 pub async fn overview_submit_button(
-    req: HttpRequest,
+    _req: HttpRequest,
     tmpl_env: MiniJinjaRenderer,
     query: web::Query<HashMap<String, String>>,
 ) -> actix_web::Result<impl Responder> {
@@ -44,32 +38,34 @@ pub async fn overview_submit_button(
 
 #[actix_web::get("/partials/actions/action-form")]
 pub async fn actions_partials(
-    req: HttpRequest,
+    _req: HttpRequest,
     tmpl_env: MiniJinjaRenderer,
     query: web::Query<HashMap<String, String>>,
 ) -> actix_web::Result<impl Responder> {
-    let event_type = query.get("event_type").unwrap_or(&"404".to_string()).to_string();
-    let ctx = context!{event_type => event_type};
+    let event_type = query
+        .get("event_type")
+        .unwrap_or(&"404".to_string())
+        .to_string();
+    let ctx = context! {event_type => event_type};
     let template_location = format!("partials/actions/{:}.html", event_type);
     info!("Getting template at: {:?}", template_location);
     tmpl_env.render(template_location.as_str(), ctx)
 }
 
-
 #[derive(Deserialize, Debug)]
-struct Event1{
+struct Event1 {
     name: String,
     age: i64,
 }
 
 #[derive(Deserialize, Debug)]
-struct Event2{
+struct Event2 {
     name: String,
     score: i64,
 }
 
 #[derive(Deserialize, Debug)]
-enum Event{
+enum Event {
     Event1(Event1),
     Event2(Event2),
 }

src/webui/worker.rs

@@ -0,0 +1,14 @@
+use std::{io};
+
+pub async fn worker_loop(r: async_channel::Receiver<i32>) -> io::Result<()> {
+    loop {
+        let x = r.recv().await;
+        match x {
+            Ok(v) => println!("Processed value: {:?}", v),
+            Err(e) => {
+                println!("Error: {:?}", e);
+                return Ok(());
+            }
+        }
+    }
+}