feat: Start Logger implementation

Author: angrynode

src/database/mod.rs

@@ -1,2 +1,3 @@
 // sea_orm example: https://github.com/SeaQL/sea-orm/blob/master/examples/axum_example/
 pub mod category;
+pub mod operation;

src/database/operation.rs

@@ -1,3 +1,8 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+use crate::extractors::user::User;
+use crate::routes::category::CategoryForm;
 
 /// Type of operation applied to the database.
 #[derive(Clone, Debug, Serialize, Deserialize)]

src/extractors/user.rs

@@ -3,11 +3,13 @@ use axum::{
     http::{StatusCode, request::Parts},
 };
 use derive_more::Display;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, Display)]
 /// A logged-in user, as expressed by the Remote-User header.
 ///
 /// Cannot be produced outside of header extraction.
+#[derive(Clone, Debug, Display, Deserialize, Serialize)]
+#[serde(transparent)]
 pub struct User(String);
 
 impl<S> OptionalFromRequestParts<S> for User

src/routes/category.rs

@@ -2,14 +2,13 @@ use askama::Template;
 use askama_web::WebTemplate;
 use axum::Form;
 use axum::extract::State;
-// use sea_orm::entity::*;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use crate::database::{category, category::CategoryOperator};
 use crate::extractors::user::User;
 use crate::state::{AppState, AppStateContext, error::*};
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct CategoryForm {
     pub name: String,
     pub path: String,

src/state/logger.rs

@@ -1,31 +1,46 @@
 use camino::Utf8PathBuf;
 use snafu::prelude::*;
 use tokio::fs::{File, OpenOptions};
+use tokio::io::AsyncWriteExt;
 use tokio::sync::RwLock;
 
 use std::sync::Arc;
 
+use crate::database::operation::Operation;
+
 #[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
 pub enum LoggerError {
     /// Failed to create the log file, which did not previously exist.
     #[snafu(display("Failed to create the operations log {path}"))]
-    Create { path: Utf8PathBuf, source: std::io::Error },
+    Create {
+        path: Utf8PathBuf,
+        source: std::io::Error,
+    },
     /// Failed to read the log file
     #[snafu(display("Failed to read the operations log {path}"))]
-    Read { path: Utf8PathBuf, source: std::io::Error } ,
+    Read {
+        path: Utf8PathBuf,
+        source: std::io::Error,
+    },
     /// Failed to append a line to the log file
     #[snafu(display("Failed to append to the operations log {path}"))]
-    Append { path: Utf8PathBuf, source: std::io::Error },
+    Append {
+        path: Utf8PathBuf,
+        source: std::io::Error,
+    },
     #[snafu(display("Failed to parse JSON from operations log {path}"))]
-    Parse { path: Utf8PathBuf, source: serde_json::Error },
+    Parse {
+        path: Utf8PathBuf,
+        source: serde_json::Error,
+    },
 }
 
 #[derive(Clone, Debug)]
 pub struct Logger {
     /// Log file storage
     pub path: Utf8PathBuf,
-    
+
     /// Handle to the log file in append-mode
     pub handle: Arc<RwLock<File>>,
 }
@@ -34,16 +49,37 @@ impl Logger {
     pub async fn new(path: Utf8PathBuf) -> Result<Self, LoggerError> {
         let mut handle = OpenOptions::new();
         let mut handle = handle.append(true).read(true);
-        let handle = if !tokio::fs::try_exists(&path).await.context(ReadSnafu { path: path.to_path_buf() })? {
+        let handle = if !tokio::fs::try_exists(&path).await.context(ReadSnafu {
+            path: path.to_path_buf(),
+        })? {
             handle = handle.create(true);
-            handle.open(&path).await.context(CreateSnafu { path: path.to_path_buf() })?
+            handle.open(&path).await.context(CreateSnafu {
+                path: path.to_path_buf(),
+            })?
         } else {
-            handle.open(&path).await.context(ReadSnafu { path: path.to_path_buf() })?
+            handle.open(&path).await.context(ReadSnafu {
+                path: path.to_path_buf(),
+            })?
         };
 
         Ok(Self {
             path: path.to_path_buf(),
             handle: Arc::new(RwLock::new(handle)),
         })
     }
+
+    pub async fn write(&self, operation: Operation) -> Result<(), LoggerError> {
+        // This should never fail
+        let operation = serde_json::to_string(&operation).unwrap();
+
+        let mut handle = self.handle.write().await;
+        handle
+            .write(operation.as_bytes())
+            .await
+            .context(AppendSnafu {
+                path: self.path.to_path_buf(),
+            })?;
+
+        Ok(())
+    }
 }

src/state/mod.rs

@@ -74,7 +74,9 @@ impl AppState {
             .context(SqliteSnafu)?;
         Migrator::up(&database, None).await.unwrap();
 
-        let logger = Logger::new(config.log_path.clone()).await.context(LoggerSnafu)?;
+        let logger = Logger::new(config.log_path.clone())
+            .await
+            .context(LoggerSnafu)?;
 
         Ok(Self {
             config,