1 files changed, 45 insertions, 10 deletions

diff --git a/src/types/extract.rs b/src/types/extract.rs
index 1379828..399fe67 100644
--- a/src/types/extract.rs
+++ b/src/types/extract.rs
@@ -15,25 +15,60 @@ impl<S> FromRequestParts<S> for AuthorizedUser where S: Send + Sync {
 	async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
         
         let Ok(Some(cookies)) = Option::<TypedHeader<Cookie>>::from_request_parts(parts, state).await else {
-            return Err(ResponseCode::Forbidden.msg("No cookies provided"))
+            return Err(ResponseCode::Forbidden.text("No cookies provided"))
         };
     
         let Some(token) = cookies.get("auth") else {
-            return Err(ResponseCode::Forbidden.msg("No auth token provided"))
+            return Err(ResponseCode::Forbidden.text("No auth token provided"))
         };
     
         let Ok(session) = Session::from_token(&token) else {
-            return Err(ResponseCode::Unauthorized.msg("Auth token invalid"))
+            return Err(ResponseCode::Unauthorized.text("Auth token invalid"))
         };
     
         let Ok(user) = User::from_user_id(session.user_id, true)  else {
-            return Err(ResponseCode::InternalServerError.msg("Valid token but no valid user"))
+            return Err(ResponseCode::InternalServerError.text("Valid token but no valid user"))
         };
 
         Ok(AuthorizedUser(user))
 	}
 }
 
+pub struct Log;
+#[async_trait]
+impl<S, B> FromRequest<S, B> for Log where 
+    B: HttpBody + Sync + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<BoxError>,
+    S: Send + Sync,
+{
+    type Rejection = Response;
+
+    async fn from_request(mut req: Request<B>, state: &S) ->  Result<Self> {
+
+        let Ok(ConnectInfo(info)) = req.extract_parts::<ConnectInfo<SocketAddr>>().await else {
+            return Ok(Log)
+        };
+        let method = req.method().clone();
+        let path = req.extensions().get::<RouterURI>().unwrap().0;
+        let uri = req.uri().clone();
+        
+        let Ok(bytes) = Bytes::from_request(req, state).await else {
+            console::log(info.ip().clone(), method.clone(), uri.clone(), Some(path.to_string()), None).await;
+            return Ok(Log)
+        };
+        
+        let Ok(body) = String::from_utf8(bytes.bytes().flatten().collect()) else {
+            console::log(info.ip().clone(), method.clone(), uri.clone(), Some(path.to_string()), None).await;
+            return Ok(Log)
+        };
+        
+        console::log(info.ip().clone(), method.clone(), uri.clone(), Some(path.to_string()), Some(body.to_string())).await;
+
+        Ok(Log)
+    }
+}
+
 pub struct Json<T>(pub T);
 
 #[async_trait]
@@ -49,28 +84,28 @@ impl<T, S, B> FromRequest<S, B> for Json<T> where
     async fn from_request(mut req: Request<B>, state: &S) ->  Result<Self> {
 
         let Ok(ConnectInfo(info)) = req.extract_parts::<ConnectInfo<SocketAddr>>().await else {
-            return Err(ResponseCode::InternalServerError.msg("Failed to read connection info"));
+            return Err(ResponseCode::InternalServerError.text("Failed to read connection info"));
         };
         let method = req.method().clone();
         let path = req.extensions().get::<RouterURI>().unwrap().0;
         let uri = req.uri().clone();
         
         let Ok(bytes) = Bytes::from_request(req, state).await else {
-            return Err(ResponseCode::InternalServerError.msg("Failed to read request body"));
+            return Err(ResponseCode::InternalServerError.text("Failed to read request body"));
         };
         
         let Ok(body) = String::from_utf8(bytes.bytes().flatten().collect()) else {
-            return Err(ResponseCode::BadRequest.msg("Invalid utf8 body"))
+            return Err(ResponseCode::BadRequest.text("Invalid utf8 body"))
         };
         
-        console::log(&info.ip(), &method, &uri, Some(path), Some(&body)).await;
+        console::log(info.ip().clone(), method.clone(), uri.clone(), Some(path.to_string()), Some(body.to_string())).await;
 
         let Ok(value) = serde_json::from_str::<T>(&body) else {
-            return Err(ResponseCode::BadRequest.msg("Invalid request body"))
+            return Err(ResponseCode::BadRequest.text("Invalid request body"))
         };
 
         if let Err(msg) = value.check() {
-            return Err(ResponseCode::BadRequest.msg(&msg));
+            return Err(ResponseCode::BadRequest.text(&msg));
         }
 
         Ok(Json(value))