fmt

5 files changed, 150 insertions, 76 deletions

diff --git a/src/api/auth.rs b/src/api/auth.rs
index 4656ca8..7f7cf9e 100644
--- a/src/api/auth.rs
+++ b/src/api/auth.rs
@@ -1,9 +1,14 @@
-use axum::{Router, routing::post, response::Response};
+use axum::{response::Response, routing::post, Router};
 use serde::Deserialize;
-use time::{OffsetDateTime, Duration};
-use tower_cookies::{Cookies, Cookie};
+use time::{Duration, OffsetDateTime};
+use tower_cookies::{Cookie, Cookies};
 
-use crate::types::{user::User, http::ResponseCode, session::Session, extract::{Json, AuthorizedUser, Check, CheckResult, Log}};
+use crate::types::{
+    extract::{AuthorizedUser, Check, CheckResult, Json, Log},
+    http::ResponseCode,
+    session::Session,
+    user::User,
+};
 
 #[derive(Deserialize, Debug)]
 pub struct RegistrationRequet {
@@ -14,36 +19,69 @@ pub struct RegistrationRequet {
     pub gender: String,
     pub day: u8,
     pub month: u8,
-    pub year: u32
+    pub year: u32,
 }
 
 impl Check for RegistrationRequet {
     fn check(&self) -> CheckResult {
-        Self::assert_length(&self.firstname, 1, 20, "First name can only by 1-20 characters long")?;
-        Self::assert_length(&self.lastname, 1, 20, "Last name can only by 1-20 characters long")?;
+        Self::assert_length(
+            &self.firstname,
+            1,
+            20,
+            "First name can only by 1-20 characters long",
+        )?;
+        Self::assert_length(
+            &self.lastname,
+            1,
+            20,
+            "Last name can only by 1-20 characters long",
+        )?;
         Self::assert_length(&self.email, 1, 50, "Email can only by 1-50 characters long")?;
-        Self::assert_length(&self.password, 1, 50, "Password can only by 1-50 characters long")?;
-        Self::assert_length(&self.gender, 1, 100, "Gender can only by 1-100 characters long")?;
-        Self::assert_range(u64::from(self.day), 1, 255, "Birthday day can only be between 1-255")?;
-        Self::assert_range(u64::from(self.month), 1, 255, "Birthday month can only be between 1-255")?;
-        Self::assert_range(u64::from(self.year), 1, 4_294_967_295, "Birthday year can only be between 1-4294967295")?;
+        Self::assert_length(
+            &self.password,
+            1,
+            50,
+            "Password can only by 1-50 characters long",
+        )?;
+        Self::assert_length(
+            &self.gender,
+            1,
+            100,
+            "Gender can only by 1-100 characters long",
+        )?;
+        Self::assert_range(
+            u64::from(self.day),
+            1,
+            255,
+            "Birthday day can only be between 1-255",
+        )?;
+        Self::assert_range(
+            u64::from(self.month),
+            1,
+            255,
+            "Birthday month can only be between 1-255",
+        )?;
+        Self::assert_range(
+            u64::from(self.year),
+            1,
+            4_294_967_295,
+            "Birthday year can only be between 1-4294967295",
+        )?;
         Ok(())
     }
 }
 
-
 async fn register(cookies: Cookies, Json(body): Json<RegistrationRequet>) -> Response {
-
     let user = match User::new(body) {
         Ok(user) => user,
-        Err(err) => return err
+        Err(err) => return err,
     };
 
     let session = match Session::new(user.user_id) {
         Ok(session) => session,
-        Err(err) => return err
+        Err(err) => return err,
     };
-    
+
     let mut now = OffsetDateTime::now_utc();
     now += Duration::weeks(52);
 
@@ -71,20 +109,19 @@ impl Check for LoginRequest {
 }
 
 async fn login(cookies: Cookies, Json(body): Json<LoginRequest>) -> Response {
-    
     let Ok(user) = User::from_email(&body.email) else {
         return ResponseCode::BadRequest.text("Email is not registered")
     };
 
     if user.password != body.password {
-        return ResponseCode::BadRequest.text("Password is not correct")
+        return ResponseCode::BadRequest.text("Password is not correct");
     }
 
     let session = match Session::new(user.user_id) {
         Ok(session) => session,
-        Err(err) => return err
+        Err(err) => return err,
     };
-    
+
     let mut now = OffsetDateTime::now_utc();
     now += Duration::weeks(52);
 
@@ -100,11 +137,10 @@ async fn login(cookies: Cookies, Json(body): Json<LoginRequest>) -> Response {
 }
 
 async fn logout(cookies: Cookies, AuthorizedUser(user): AuthorizedUser, _: Log) -> Response {
-
     cookies.remove(Cookie::new("auth", ""));
 
     if let Err(err) = Session::delete(user.user_id) {
-        return err
+        return err;
     }
 
     ResponseCode::Success.text("Successfully logged out")
@@ -112,7 +148,7 @@ async fn logout(cookies: Cookies, AuthorizedUser(user): AuthorizedUser, _: Log)
 
 pub fn router() -> Router {
     Router::new()
-    .route("/register", post(register))
-    .route("/login", post(login))
-    .route("/logout", post(logout))
-}
\ No newline at end of file
+        .route("/register", post(register))
+        .route("/login", post(login))
+        .route("/logout", post(logout))
+}
diff --git a/src/api/mod.rs b/src/api/mod.rs
index ba38aeb..a2083fe 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -1,4 +1,4 @@
 pub mod auth;
 pub mod pages;
 pub mod posts;
-pub mod users;
\ No newline at end of file
+pub mod users;
diff --git a/src/api/pages.rs b/src/api/pages.rs
index 41a63a8..4661b91 100644
--- a/src/api/pages.rs
+++ b/src/api/pages.rs
@@ -1,6 +1,13 @@
-use axum::{Router, response::{Response, Redirect, IntoResponse}, routing::get};
+use axum::{
+    response::{IntoResponse, Redirect, Response},
+    routing::get,
+    Router,
+};
 
-use crate::{types::{extract::AuthorizedUser, http::ResponseCode}, console};
+use crate::{
+    console,
+    types::{extract::AuthorizedUser, http::ResponseCode},
+};
 
 async fn root(user: Option<AuthorizedUser>) -> Response {
     if user.is_some() {
@@ -52,11 +59,11 @@ async fn wordpress() -> Response {
 
 pub fn router() -> Router {
     Router::new()
-    .route("/", get(root))
-    .route("/login", get(login))
-    .route("/home", get(home))
-    .route("/people", get(people))
-    .route("/profile", get(profile))
-    .route("/console", get(console))
-    .route("/wp-admin", get(wordpress))
-}
\ No newline at end of file
+        .route("/", get(root))
+        .route("/login", get(login))
+        .route("/home", get(home))
+        .route("/people", get(people))
+        .route("/profile", get(profile))
+        .route("/console", get(console))
+        .route("/wp-admin", get(wordpress))
+}
diff --git a/src/api/posts.rs b/src/api/posts.rs
index e2e64b2..3a2e507 100644
--- a/src/api/posts.rs
+++ b/src/api/posts.rs
@@ -1,23 +1,37 @@
-use axum::{response::Response, Router, routing::{post, patch}};
+use axum::{
+    response::Response,
+    routing::{patch, post},
+    Router,
+};
 use serde::Deserialize;
 
-use crate::types::{extract::{AuthorizedUser, Json, Check, CheckResult}, post::Post, http::ResponseCode};
-
+use crate::types::{
+    extract::{AuthorizedUser, Check, CheckResult, Json},
+    http::ResponseCode,
+    post::Post,
+};
 
 #[derive(Deserialize)]
 struct PostCreateRequest {
-    content: String
+    content: String,
 }
 
 impl Check for PostCreateRequest {
     fn check(&self) -> CheckResult {
-        Self::assert_length(&self.content, 1, 500, "Comments must be between 1-500 characters long")?;
+        Self::assert_length(
+            &self.content,
+            1,
+            500,
+            "Comments must be between 1-500 characters long",
+        )?;
         Ok(())
     }
 }
 
-async fn create(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostCreateRequest>) -> Response {
-
+async fn create(
+    AuthorizedUser(user): AuthorizedUser,
+    Json(body): Json<PostCreateRequest>,
+) -> Response {
     let Ok(post) = Post::new(user.user_id, body.content) else {
         return ResponseCode::InternalServerError.text("Failed to create post")
     };
@@ -31,7 +45,7 @@ async fn create(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostCreat
 
 #[derive(Deserialize)]
 struct PostPageRequest {
-    page: u64
+    page: u64,
 }
 
 impl Check for PostPageRequest {
@@ -40,8 +54,10 @@ impl Check for PostPageRequest {
     }
 }
 
-async fn page(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<PostPageRequest>) -> Response {
-    
+async fn page(
+    AuthorizedUser(_user): AuthorizedUser,
+    Json(body): Json<PostPageRequest>,
+) -> Response {
     let Ok(posts) = Post::from_post_page(body.page) else {
         return ResponseCode::InternalServerError.text("Failed to fetch posts")
     };
@@ -55,7 +71,7 @@ async fn page(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<PostPageRe
 
 #[derive(Deserialize)]
 struct UsersPostsRequest {
-    user_id: u64
+    user_id: u64,
 }
 
 impl Check for UsersPostsRequest {
@@ -64,8 +80,10 @@ impl Check for UsersPostsRequest {
     }
 }
 
-async fn user(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<UsersPostsRequest>) -> Response {
-    
+async fn user(
+    AuthorizedUser(_user): AuthorizedUser,
+    Json(body): Json<UsersPostsRequest>,
+) -> Response {
     let Ok(posts) = Post::from_user_id(body.user_id) else {
         return ResponseCode::InternalServerError.text("Failed to fetch posts")
     };
@@ -80,18 +98,25 @@ async fn user(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<UsersPosts
 #[derive(Deserialize)]
 struct PostCommentRequest {
     content: String,
-    post_id: u64
+    post_id: u64,
 }
 
 impl Check for PostCommentRequest {
     fn check(&self) -> CheckResult {
-        Self::assert_length(&self.content, 1, 255, "Comments must be between 1-255 characters long")?;
+        Self::assert_length(
+            &self.content,
+            1,
+            255,
+            "Comments must be between 1-255 characters long",
+        )?;
         Ok(())
     }
 }
 
-async fn comment(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostCommentRequest>) -> Response {
-    
+async fn comment(
+    AuthorizedUser(user): AuthorizedUser,
+    Json(body): Json<PostCommentRequest>,
+) -> Response {
     let Ok(mut post) = Post::from_post_id(body.post_id) else {
         return ResponseCode::InternalServerError.text("Failed to fetch posts")
     };
@@ -106,7 +131,7 @@ async fn comment(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostComm
 #[derive(Deserialize)]
 struct PostLikeRequest {
     state: bool,
-    post_id: u64
+    post_id: u64,
 }
 
 impl Check for PostLikeRequest {
@@ -116,7 +141,6 @@ impl Check for PostLikeRequest {
 }
 
 async fn like(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostLikeRequest>) -> Response {
-    
     let Ok(mut post) = Post::from_post_id(body.post_id) else {
         return ResponseCode::InternalServerError.text("Failed to fetch posts")
     };
@@ -130,9 +154,9 @@ async fn like(AuthorizedUser(user): AuthorizedUser, Json(body): Json<PostLikeReq
 
 pub fn router() -> Router {
     Router::new()
-    .route("/create", post(create))
-    .route("/page", post(page))
-    .route("/user", post(user))
-    .route("/comment", patch(comment))
-    .route("/like", patch(like))
-}
\ No newline at end of file
+        .route("/create", post(create))
+        .route("/page", post(page))
+        .route("/user", post(user))
+        .route("/comment", patch(comment))
+        .route("/like", patch(like))
+}
diff --git a/src/api/users.rs b/src/api/users.rs
index 97a9e6e..afcdddd 100644
--- a/src/api/users.rs
+++ b/src/api/users.rs
@@ -1,10 +1,14 @@
-use axum::{Router, response::Response, routing::post};
+use crate::types::{
+    extract::{AuthorizedUser, Check, CheckResult, Json},
+    http::ResponseCode,
+    user::User,
+};
+use axum::{response::Response, routing::post, Router};
 use serde::Deserialize;
-use crate::types::{extract::{AuthorizedUser, Json, Check, CheckResult}, http::ResponseCode, user::User};
 
 #[derive(Deserialize)]
 struct UserLoadRequest {
-    ids: Vec<u64>
+    ids: Vec<u64>,
 }
 
 impl Check for UserLoadRequest {
@@ -13,8 +17,10 @@ impl Check for UserLoadRequest {
     }
 }
 
-async fn load_batch(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<UserLoadRequest>) -> Response {
-    
+async fn load_batch(
+    AuthorizedUser(_user): AuthorizedUser,
+    Json(body): Json<UserLoadRequest>,
+) -> Response {
     let users = User::from_user_ids(body.ids);
     let Ok(json) = serde_json::to_string(&users) else {
         return ResponseCode::InternalServerError.text("Failed to fetch users")
@@ -25,7 +31,7 @@ async fn load_batch(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<User
 
 #[derive(Deserialize)]
 struct UserPageReqiest {
-    page: u64
+    page: u64,
 }
 
 impl Check for UserPageReqiest {
@@ -34,8 +40,10 @@ impl Check for UserPageReqiest {
     }
 }
 
-async fn load_page(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<UserPageReqiest>) -> Response {
-    
+async fn load_page(
+    AuthorizedUser(_user): AuthorizedUser,
+    Json(body): Json<UserPageReqiest>,
+) -> Response {
     let Ok(users) = User::from_user_page(body.page) else {
         return ResponseCode::InternalServerError.text("Failed to fetch users")
     };
@@ -48,7 +56,6 @@ async fn load_page(AuthorizedUser(_user): AuthorizedUser, Json(body): Json<UserP
 }
 
 async fn load_self(AuthorizedUser(user): AuthorizedUser) -> Response {
-    
     let Ok(json) = serde_json::to_string(&user) else {
         return ResponseCode::InternalServerError.text("Failed to fetch user")
     };
@@ -58,7 +65,7 @@ async fn load_self(AuthorizedUser(user): AuthorizedUser) -> Response {
 
 pub fn router() -> Router {
     Router::new()
-    .route("/load", post(load_batch))
-    .route("/self", post(load_self))
-    .route("/page", post(load_page))
-}
\ No newline at end of file
+        .route("/load", post(load_batch))
+        .route("/self", post(load_self))
+        .route("/page", post(load_page))
+}