Running cargo fmt on server code.

- Adding a .rustfmt.toml for the 2 space indent.

1 files changed, 109 insertions, 157 deletions

diff --git a/server/src/api/post.rs b/server/src/api/post.rs
index 8fc24ac1..5345b0e4 100644
--- a/server/src/api/post.rs
+++ b/server/src/api/post.rs
@@ -8,20 +8,19 @@ pub struct CreatePost {
   body: Option<String>,
   nsfw: bool,
   community_id: i32,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct PostResponse {
   op: String,
-  pub post: PostView
+  pub post: PostView,
 }
 
-
 #[derive(Serialize, Deserialize)]
 pub struct GetPost {
   pub id: i32,
-  auth: Option<String>
+  auth: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -41,7 +40,7 @@ pub struct GetPosts {
   page: Option<i64>,
   limit: Option<i64>,
   community_id: Option<i32>,
-  auth: Option<String>
+  auth: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -54,16 +53,15 @@ pub struct GetPostsResponse {
 pub struct CreatePostLike {
   post_id: i32,
   score: i16,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct CreatePostLikeResponse {
   op: String,
-  post: PostView
+  post: PostView,
 }
 
-
 #[derive(Serialize, Deserialize)]
 pub struct EditPost {
   pub edit_id: i32,
@@ -77,14 +75,14 @@ pub struct EditPost {
   nsfw: bool,
   locked: Option<bool>,
   reason: Option<String>,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct SavePost {
   post_id: i32,
   save: bool,
-  auth: String
+  auth: String,
 }
 
 impl Perform<PostResponse> for Oper<CreatePost> {
@@ -92,29 +90,25 @@ impl Perform<PostResponse> for Oper<CreatePost> {
     let data: &CreatePost = &self.data;
     let conn = establish_connection();
 
-
     let claims = match Claims::decode(&data.auth) {
       Ok(claims) => claims.claims,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "not_logged_in"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "not_logged_in"))?,
     };
 
-    if has_slurs(&data.name) || 
-      (data.body.is_some() && has_slurs(&data.body.to_owned().unwrap())) {
-        return Err(APIError::err(&self.op, "no_slurs"))?
-      }
+    if has_slurs(&data.name) || (data.body.is_some() && has_slurs(&data.body.to_owned().unwrap())) {
+      return Err(APIError::err(&self.op, "no_slurs"))?;
+    }
 
     let user_id = claims.id;
 
     // Check for a community ban
     if CommunityUserBanView::get(&conn, user_id, data.community_id).is_ok() {
-      return Err(APIError::err(&self.op, "community_ban"))?
+      return Err(APIError::err(&self.op, "community_ban"))?;
     }
 
     // Check for a site ban
     if UserView::read(&conn, user_id)?.banned {
-      return Err(APIError::err(&self.op, "site_ban"))?
+      return Err(APIError::err(&self.op, "site_ban"))?;
     }
 
     let post_form = PostForm {
@@ -127,45 +121,37 @@ impl Perform<PostResponse> for Oper<CreatePost> {
       deleted: None,
       nsfw: data.nsfw,
       locked: None,
-      updated: None
+      updated: None,
     };
 
     let inserted_post = match Post::create(&conn, &post_form) {
       Ok(post) => post,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_create_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_create_post"))?,
     };
 
     // They like their own post by default
     let like_form = PostLikeForm {
       post_id: inserted_post.id,
       user_id: user_id,
-      score: 1
+      score: 1,
     };
 
     // Only add the like if the score isnt 0
     let _inserted_like = match PostLike::like(&conn, &like_form) {
       Ok(like) => like,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_like_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_like_post"))?,
     };
 
     // Refetch the view
     let post_view = match PostView::read(&conn, inserted_post.id, Some(user_id)) {
       Ok(post) => post,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_find_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_post"))?,
     };
 
-    Ok(
-      PostResponse {
-        op: self.op.to_string(), 
-        post: post_view
-      }
-      )
+    Ok(PostResponse {
+      op: self.op.to_string(),
+      post: post_view,
+    })
   }
 }
 
@@ -175,26 +161,32 @@ impl Perform<GetPostResponse> for Oper<GetPost> {
     let conn = establish_connection();
 
     let user_id: Option<i32> = match &data.auth {
-      Some(auth) => {
-        match Claims::decode(&auth) {
-          Ok(claims) => {
-            let user_id = claims.claims.id;
-            Some(user_id)
-          }
-          Err(_e) => None
+      Some(auth) => match Claims::decode(&auth) {
+        Ok(claims) => {
+          let user_id = claims.claims.id;
+          Some(user_id)
         }
-      }
-      None => None
+        Err(_e) => None,
+      },
+      None => None,
     };
 
     let post_view = match PostView::read(&conn, data.id, user_id) {
       Ok(post) => post,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_find_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_post"))?,
     };
 
-    let comments = CommentView::list(&conn, &SortType::New, Some(data.id), None, None, user_id, false, None, Some(9999))?;
+    let comments = CommentView::list(
+      &conn,
+      &SortType::New,
+      Some(data.id),
+      None,
+      None,
+      user_id,
+      false,
+      None,
+      Some(9999),
+    )?;
 
     let community = CommunityView::read(&conn, post_view.community_id, user_id)?;
 
@@ -207,76 +199,66 @@ impl Perform<GetPostResponse> for Oper<GetPost> {
     admins.insert(0, creator_user);
 
     // Return the jwt
-    Ok(
-      GetPostResponse {
-        op: self.op.to_string(),
-        post: post_view,
-        comments: comments,
-        community: community,
-        moderators: moderators,
-        admins: admins,
-      }
-      )
+    Ok(GetPostResponse {
+      op: self.op.to_string(),
+      post: post_view,
+      comments: comments,
+      community: community,
+      moderators: moderators,
+      admins: admins,
+    })
   }
 }
 
-
 impl Perform<GetPostsResponse> for Oper<GetPosts> {
   fn perform(&self) -> Result<GetPostsResponse, Error> {
     let data: &GetPosts = &self.data;
     let conn = establish_connection();
 
     let user_claims: Option<Claims> = match &data.auth {
-      Some(auth) => {
-        match Claims::decode(&auth) {
-          Ok(claims) => {
-            Some(claims.claims)
-          }
-          Err(_e) => None
-        }
-      }
-      None => None
+      Some(auth) => match Claims::decode(&auth) {
+        Ok(claims) => Some(claims.claims),
+        Err(_e) => None,
+      },
+      None => None,
     };
-    
+
     let user_id = match &user_claims {
       Some(claims) => Some(claims.id),
-      None => None
+      None => None,
     };
 
     let show_nsfw = match &user_claims {
       Some(claims) => claims.show_nsfw,
-      None => false
+      None => false,
     };
 
     let type_ = PostListingType::from_str(&data.type_)?;
     let sort = SortType::from_str(&data.sort)?;
 
     let posts = match PostView::list(
-      &conn, 
-      type_, 
-      &sort, 
-      data.community_id, 
+      &conn,
+      type_,
+      &sort,
+      data.community_id,
       None,
       None,
       None,
-      user_id, 
+      user_id,
       show_nsfw,
-      false, 
-      false, 
-      data.page, 
-      data.limit) {
+      false,
+      false,
+      data.page,
+      data.limit,
+    ) {
       Ok(posts) => posts,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_get_posts"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_get_posts"))?,
     };
 
-    Ok(
-      GetPostsResponse {
-        op: self.op.to_string(),
-        posts: posts
-      }
-      )
+    Ok(GetPostsResponse {
+      op: self.op.to_string(),
+      posts: posts,
+    })
   }
 }
 
@@ -287,9 +269,7 @@ impl Perform<CreatePostLikeResponse> for Oper<CreatePostLike> {
 
     let claims = match Claims::decode(&data.auth) {
       Ok(claims) => claims.claims,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "not_logged_in"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "not_logged_in"))?,
     };
 
     let user_id = claims.id;
@@ -297,18 +277,18 @@ impl Perform<CreatePostLikeResponse> for Oper<CreatePostLike> {
     // Check for a community ban
     let post = Post::read(&conn, data.post_id)?;
     if CommunityUserBanView::get(&conn, user_id, post.community_id).is_ok() {
-      return Err(APIError::err(&self.op, "community_ban"))?
+      return Err(APIError::err(&self.op, "community_ban"))?;
     }
 
     // Check for a site ban
     if UserView::read(&conn, user_id)?.banned {
-      return Err(APIError::err(&self.op, "site_ban"))?
+      return Err(APIError::err(&self.op, "site_ban"))?;
     }
 
     let like_form = PostLikeForm {
       post_id: data.post_id,
       user_id: user_id,
-      score: data.score
+      score: data.score,
     };
 
     // Remove any likes first
@@ -319,44 +299,35 @@ impl Perform<CreatePostLikeResponse> for Oper<CreatePostLike> {
     if do_add {
       let _inserted_like = match PostLike::like(&conn, &like_form) {
         Ok(like) => like,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_like_post"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_like_post"))?,
       };
     }
 
     let post_view = match PostView::read(&conn, data.post_id, Some(user_id)) {
       Ok(post) => post,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_find_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_post"))?,
     };
 
     // just output the score
-    Ok(
-      CreatePostLikeResponse {
-        op: self.op.to_string(), 
-        post: post_view
-      }
-      )
+    Ok(CreatePostLikeResponse {
+      op: self.op.to_string(),
+      post: post_view,
+    })
   }
 }
 
 impl Perform<PostResponse> for Oper<EditPost> {
   fn perform(&self) -> Result<PostResponse, Error> {
     let data: &EditPost = &self.data;
-    if has_slurs(&data.name) || 
-      (data.body.is_some() && has_slurs(&data.body.to_owned().unwrap())) {
-        return Err(APIError::err(&self.op, "no_slurs"))?
-      }
+    if has_slurs(&data.name) || (data.body.is_some() && has_slurs(&data.body.to_owned().unwrap())) {
+      return Err(APIError::err(&self.op, "no_slurs"))?;
+    }
 
     let conn = establish_connection();
 
     let claims = match Claims::decode(&data.auth) {
       Ok(claims) => claims.claims,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "not_logged_in"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "not_logged_in"))?,
     };
 
     let user_id = claims.id;
@@ -364,31 +335,24 @@ impl Perform<PostResponse> for Oper<EditPost> {
     // Verify its the creator or a mod or admin
     let mut editors: Vec<i32> = vec![data.creator_id];
     editors.append(
-      &mut CommunityModeratorView::for_community(&conn, data.community_id)
-      ?
-      .into_iter()
-      .map(|m| m.user_id)
-      .collect()
-      );
-    editors.append(
-      &mut UserView::admins(&conn)
-      ?
-      .into_iter()
-      .map(|a| a.id)
-      .collect()
-      );
+      &mut CommunityModeratorView::for_community(&conn, data.community_id)?
+        .into_iter()
+        .map(|m| m.user_id)
+        .collect(),
+    );
+    editors.append(&mut UserView::admins(&conn)?.into_iter().map(|a| a.id).collect());
     if !editors.contains(&user_id) {
-      return Err(APIError::err(&self.op, "no_post_edit_allowed"))?
+      return Err(APIError::err(&self.op, "no_post_edit_allowed"))?;
     }
 
     // Check for a community ban
     if CommunityUserBanView::get(&conn, user_id, data.community_id).is_ok() {
-      return Err(APIError::err(&self.op, "community_ban"))?
+      return Err(APIError::err(&self.op, "community_ban"))?;
     }
 
     // Check for a site ban
     if UserView::read(&conn, user_id)?.banned {
-      return Err(APIError::err(&self.op, "site_ban"))?
+      return Err(APIError::err(&self.op, "site_ban"))?;
     }
 
     let post_form = PostForm {
@@ -401,14 +365,12 @@ impl Perform<PostResponse> for Oper<EditPost> {
       deleted: data.deleted.to_owned(),
       nsfw: data.nsfw,
       locked: data.locked.to_owned(),
-      updated: Some(naive_now())
+      updated: Some(naive_now()),
     };
 
     let _updated_post = match Post::update(&conn, data.edit_id, &post_form) {
       Ok(post) => post,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_update_post"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_post"))?,
     };
 
     // Mod tables
@@ -433,12 +395,10 @@ impl Perform<PostResponse> for Oper<EditPost> {
 
     let post_view = PostView::read(&conn, data.edit_id, Some(user_id))?;
 
-    Ok(
-      PostResponse {
-        op: self.op.to_string(), 
-        post: post_view
-      }
-      )
+    Ok(PostResponse {
+      op: self.op.to_string(),
+      post: post_view,
+    })
   }
 }
 
@@ -449,9 +409,7 @@ impl Perform<PostResponse> for Oper<SavePost> {
 
     let claims = match Claims::decode(&data.auth) {
       Ok(claims) => claims.claims,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "not_logged_in"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "not_logged_in"))?,
     };
 
     let user_id = claims.id;
@@ -464,26 +422,20 @@ impl Perform<PostResponse> for Oper<SavePost> {
     if data.save {
       match PostSaved::save(&conn, &post_saved_form) {
         Ok(post) => post,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_save_post"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_save_post"))?,
       };
     } else {
       match PostSaved::unsave(&conn, &post_saved_form) {
         Ok(post) => post,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_save_post"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_save_post"))?,
       };
     }
 
     let post_view = PostView::read(&conn, data.post_id, Some(user_id))?;
 
-    Ok(
-      PostResponse {
-        op: self.op.to_string(), 
-        post: post_view
-      }
-      )
+    Ok(PostResponse {
+      op: self.op.to_string(),
+      post: post_view,
+    })
   }
 }