Running cargo fmt on server code.

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

24 files changed, 1688 insertions, 1574 deletions

diff --git a/server/.rustfmt.toml b/server/.rustfmt.toml
new file mode 100644
index 00000000..b196eaa2
--- /dev/null
+++ b/server/.rustfmt.toml
@@ -0,0 +1 @@
+tab_spaces = 2
diff --git a/server/src/api/comment.rs b/server/src/api/comment.rs
index 3d18c72a..ec010d2f 100644
--- a/server/src/api/comment.rs
+++ b/server/src/api/comment.rs
@@ -6,7 +6,7 @@ pub struct CreateComment {
   parent_id: Option<i32>,
   edit_id: Option<i32>,
   pub post_id: i32,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -20,20 +20,20 @@ pub struct EditComment {
   deleted: Option<bool>,
   reason: Option<String>,
   read: Option<bool>,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct SaveComment {
   comment_id: i32,
   save: bool,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct CommentResponse {
   op: String,
-  pub comment: CommentView
+  pub comment: CommentView,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -41,10 +41,9 @@ pub struct CreateCommentLike {
   comment_id: i32,
   pub post_id: i32,
   score: i16,
-  auth: String
+  auth: String,
 }
 
-
 impl Perform<CommentResponse> for Oper<CreateComment> {
   fn perform(&self) -> Result<CommentResponse, Error> {
     let data: &CreateComment = &self.data;
@@ -52,9 +51,7 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
 
     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;
@@ -62,12 +59,12 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
     // 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 content_slurs_removed = remove_slurs(&data.content.to_owned());
@@ -80,14 +77,12 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
       removed: None,
       deleted: None,
       read: None,
-      updated: None
+      updated: None,
     };
 
     let inserted_comment = match Comment::create(&conn, &comment_form) {
       Ok(comment) => comment,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_create_comment"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_create_comment"))?,
     };
 
     // You like your own comment by default
@@ -95,24 +90,20 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
       comment_id: inserted_comment.id,
       post_id: data.post_id,
       user_id: user_id,
-      score: 1
+      score: 1,
     };
 
     let _inserted_like = match CommentLike::like(&conn, &like_form) {
       Ok(like) => like,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_like_comment"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_like_comment"))?,
     };
 
     let comment_view = CommentView::read(&conn, inserted_comment.id, Some(user_id))?;
 
-    Ok(
-      CommentResponse {
-        op: self.op.to_string(), 
-        comment: comment_view
-      }
-      )
+    Ok(CommentResponse {
+      op: self.op.to_string(),
+      comment: comment_view,
+    })
   }
 }
 
@@ -123,9 +114,7 @@ impl Perform<CommentResponse> for Oper<EditComment> {
 
     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;
@@ -134,38 +123,29 @@ impl Perform<CommentResponse> for Oper<EditComment> {
 
     // You are allowed to mark the comment as read even if you're banned.
     if data.read.is_none() {
-
       // Verify its the creator or a mod, or an admin
       let mut editors: Vec<i32> = vec![data.creator_id];
       editors.append(
-        &mut CommunityModeratorView::for_community(&conn, orig_comment.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, orig_comment.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_comment_edit_allowed"))?
+        return Err(APIError::err(&self.op, "no_comment_edit_allowed"))?;
       }
 
       // Check for a community ban
       if CommunityUserBanView::get(&conn, user_id, orig_comment.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 content_slurs_removed = remove_slurs(&data.content.to_owned());
@@ -178,14 +158,16 @@ impl Perform<CommentResponse> for Oper<EditComment> {
       removed: data.removed.to_owned(),
       deleted: data.deleted.to_owned(),
       read: data.read.to_owned(),
-      updated: if data.read.is_some() { orig_comment.updated } else {Some(naive_now())}
+      updated: if data.read.is_some() {
+        orig_comment.updated
+      } else {
+        Some(naive_now())
+      },
     };
 
     let _updated_comment = match Comment::update(&conn, data.edit_id, &comment_form) {
       Ok(comment) => comment,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_update_comment"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_comment"))?,
     };
 
     // Mod tables
@@ -199,16 +181,12 @@ impl Perform<CommentResponse> for Oper<EditComment> {
       ModRemoveComment::create(&conn, &form)?;
     }
 
-
     let comment_view = CommentView::read(&conn, data.edit_id, Some(user_id))?;
 
-    Ok(
-      CommentResponse {
-        op: self.op.to_string(), 
-        comment: comment_view
-      }
-      )
-
+    Ok(CommentResponse {
+      op: self.op.to_string(),
+      comment: comment_view,
+    })
   }
 }
 
@@ -219,9 +197,7 @@ impl Perform<CommentResponse> for Oper<SaveComment> {
 
     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;
@@ -234,27 +210,21 @@ impl Perform<CommentResponse> for Oper<SaveComment> {
     if data.save {
       match CommentSaved::save(&conn, &comment_saved_form) {
         Ok(comment) => comment,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_save_comment"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_save_comment"))?,
       };
     } else {
       match CommentSaved::unsave(&conn, &comment_saved_form) {
         Ok(comment) => comment,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_save_comment"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_save_comment"))?,
       };
     }
 
     let comment_view = CommentView::read(&conn, data.comment_id, Some(user_id))?;
 
-    Ok(
-      CommentResponse {
-        op: self.op.to_string(), 
-        comment: comment_view
-      }
-      )
+    Ok(CommentResponse {
+      op: self.op.to_string(),
+      comment: comment_view,
+    })
   }
 }
 
@@ -265,9 +235,7 @@ impl Perform<CommentResponse> for Oper<CreateCommentLike> {
 
     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;
@@ -275,19 +243,19 @@ impl Perform<CommentResponse> for Oper<CreateCommentLike> {
     // 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 = CommentLikeForm {
       comment_id: data.comment_id,
       post_id: data.post_id,
       user_id: user_id,
-      score: data.score
+      score: data.score,
     };
 
     // Remove any likes first
@@ -298,20 +266,16 @@ impl Perform<CommentResponse> for Oper<CreateCommentLike> {
     if do_add {
       let _inserted_like = match CommentLike::like(&conn, &like_form) {
         Ok(like) => like,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "couldnt_like_comment"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "couldnt_like_comment"))?,
       };
     }
 
     // Have to refetch the comment to get the current state
     let liked_comment = CommentView::read(&conn, data.comment_id, Some(user_id))?;
 
-    Ok(
-      CommentResponse {
-        op: self.op.to_string(), 
-        comment: liked_comment
-      }
-      )
+    Ok(CommentResponse {
+      op: self.op.to_string(),
+      comment: liked_comment,
+    })
   }
 }
diff --git a/server/src/api/community.rs b/server/src/api/community.rs
index a278aa14..87654e64 100644
--- a/server/src/api/community.rs
+++ b/server/src/api/community.rs
@@ -5,7 +5,7 @@ use std::str::FromStr;
 pub struct GetCommunity {
   id: Option<i32>,
   name: Option<String>,
-  auth: Option<String>
+  auth: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -16,7 +16,6 @@ pub struct GetCommunityResponse {
   admins: Vec<UserView>,
 }
 
-
 #[derive(Serialize, Deserialize)]
 pub struct CreateCommunity {
   name: String,
@@ -24,13 +23,13 @@ pub struct CreateCommunity {
   description: Option<String>,
   category_id: i32,
   nsfw: bool,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct CommunityResponse {
   op: String,
-  pub community: CommunityView
+  pub community: CommunityView,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -38,13 +37,13 @@ pub struct ListCommunities {
   sort: String,
   page: Option<i64>,
   limit: Option<i64>,
-  auth: Option<String>
+  auth: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct ListCommunitiesResponse {
   op: String,
-  communities: Vec<CommunityView>
+  communities: Vec<CommunityView>,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -54,7 +53,7 @@ pub struct BanFromCommunity {
   ban: bool,
   reason: Option<String>,
   expires: Option<i64>,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -69,7 +68,7 @@ pub struct AddModToCommunity {
   pub community_id: i32,
   user_id: i32,
   added: bool,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -90,32 +89,32 @@ pub struct EditCommunity {
   nsfw: bool,
   reason: Option<String>,
   expires: Option<i64>,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct FollowCommunity {
   community_id: i32,
   follow: bool,
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct GetFollowedCommunities {
-  auth: String
+  auth: String,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct GetFollowedCommunitiesResponse {
   op: String,
-  communities: Vec<CommunityFollowerView>
+  communities: Vec<CommunityFollowerView>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct TransferCommunity {
   community_id: i32,
   user_id: i32,
-  auth: String
+  auth: String,
 }
 
 impl Perform<GetCommunityResponse> for Oper<GetCommunity> {
@@ -124,35 +123,31 @@ impl Perform<GetCommunityResponse> for Oper<GetCommunity> {
     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 community_id = match data.id {
       Some(id) => id,
-      None => Community::read_from_name(&conn, data.name.to_owned().unwrap_or("main".to_string()))?.id
+      None => {
+        Community::read_from_name(&conn, data.name.to_owned().unwrap_or("main".to_string()))?.id
+      }
     };
 
     let community_view = match CommunityView::read(&conn, community_id, user_id) {
       Ok(community) => community,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_find_community"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_community"))?,
     };
 
     let moderators = match CommunityModeratorView::for_community(&conn, community_id) {
       Ok(moderators) => moderators,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_find_community"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_community"))?,
     };
 
     let site_creator_id = Site::read(&conn, 1)?.creator_id;
@@ -162,14 +157,12 @@ impl Perform<GetCommunityResponse> for Oper<GetCommunity> {
     admins.insert(0, creator_user);
 
     // Return the jwt
-    Ok(
-      GetCommunityResponse {
-        op: self.op.to_string(),
-        community: community_view,
-        moderators: moderators,
-        admins: admins,
-      }
-      )
+    Ok(GetCommunityResponse {
+      op: self.op.to_string(),
+      community: community_view,
+      moderators: moderators,
+      admins: admins,
+    })
   }
 }
 
@@ -180,22 +173,21 @@ impl Perform<CommunityResponse> for Oper<CreateCommunity> {
 
     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) || 
-      has_slurs(&data.title) || 
-        (data.description.is_some() && has_slurs(&data.description.to_owned().unwrap())) {
-          return Err(APIError::err(&self.op, "no_slurs"))?
-        }
+    if has_slurs(&data.name)
+      || has_slurs(&data.title)
+      || (data.description.is_some() && has_slurs(&data.description.to_owned().unwrap()))
+    {
+      return Err(APIError::err(&self.op, "no_slurs"))?;
+    }
 
     let user_id = claims.id;
 
     // 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"))?;
     }
 
     // When you create a community, make sure the user becomes a moderator and a follower
@@ -213,43 +205,42 @@ impl Perform<CommunityResponse> for Oper<CreateCommunity> {
 
     let inserted_community = match Community::create(&conn, &community_form) {
       Ok(community) => community,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "community_already_exists"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "community_already_exists"))?,
     };
 
     let community_moderator_form = CommunityModeratorForm {
       community_id: inserted_community.id,
-      user_id: user_id
+      user_id: user_id,
     };
 
-    let _inserted_community_moderator = match CommunityModerator::join(&conn, &community_moderator_form) {
-      Ok(user) => user,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "community_moderator_already_exists"))?
-      }
-    };
+    let _inserted_community_moderator =
+      match CommunityModerator::join(&conn, &community_moderator_form) {
+        Ok(user) => user,
+        Err(_e) => {
+          return Err(APIError::err(
+            &self.op,
+            "community_moderator_already_exists",
+          ))?
+        }
+      };
 
     let community_follower_form = CommunityFollowerForm {
       community_id: inserted_community.id,
-      user_id: user_id
+      user_id: user_id,
     };
 
-    let _inserted_community_follower = match CommunityFollower::follow(&conn, &community_follower_form) {
-      Ok(user) => user,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "community_follower_already_exists"))?
-      }
-    };
+    let _inserted_community_follower =
+      match CommunityFollower::follow(&conn, &community_follower_form) {
+        Ok(user) => user,
+        Err(_e) => return Err(APIError::err(&self.op, "community_follower_already_exists"))?,
+      };
 
     let community_view = CommunityView::read(&conn, inserted_community.id, Some(user_id))?;
 
-    Ok(
-      CommunityResponse {
-        op: self.op.to_string(),
-        community: community_view
-      }
-      )
+    Ok(CommunityResponse {
+      op: self.op.to_string(),
+      community: community_view,
+    })
   }
 }
 
@@ -258,43 +249,34 @@ impl Perform<CommunityResponse> for Oper<EditCommunity> {
     let data: &EditCommunity = &self.data;
 
     if has_slurs(&data.name) || has_slurs(&data.title) {
-      return Err(APIError::err(&self.op, "no_slurs"))?
+      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;
 
     // 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"))?;
     }
 
     // Verify its a mod
     let mut editors: Vec<i32> = Vec::new();
     editors.append(
-      &mut CommunityModeratorView::for_community(&conn, data.edit_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.edit_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_community_edit_allowed"))?
+      return Err(APIError::err(&self.op, "no_community_edit_allowed"))?;
     }
 
     let community_form = CommunityForm {
@@ -306,40 +288,36 @@ impl Perform<CommunityResponse> for Oper<EditCommunity> {
       removed: data.removed.to_owned(),
       deleted: data.deleted.to_owned(),
       nsfw: data.nsfw,
-      updated: Some(naive_now())
+      updated: Some(naive_now()),
     };
 
     let _updated_community = match Community::update(&conn, data.edit_id, &community_form) {
       Ok(community) => community,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "couldnt_update_community"))?
-      }
+      Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_community"))?,
     };
 
     // Mod tables
     if let Some(removed) = data.removed.to_owned() {
       let expires = match data.expires {
         Some(time) => Some(naive_from_unix(time)),
-        None => None
+        None => None,
       };
       let form = ModRemoveCommunityForm {
         mod_user_id: user_id,
         community_id: data.edit_id,
         removed: Some(removed),
         reason: data.reason.to_owned(),
-        expires: expires
+        expires: expires,
       };
       ModRemoveCommunity::create(&conn, &form)?;
     }
 
     let community_view = CommunityView::read(&conn, data.edit_id, Some(user_id))?;
 
-    Ok(
-      CommunityResponse {
-        op: self.op.to_string(), 
-        community: community_view
-      }
-      )
+    Ok(CommunityResponse {
+      op: self.op.to_string(),
+      community: community_view,
+    })
   }
 }
 
@@ -349,49 +327,37 @@ impl Perform<ListCommunitiesResponse> for Oper<ListCommunities> {
     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 sort = SortType::from_str(&data.sort)?;
 
     let communities: Vec<CommunityView> = CommunityView::list(
-      &conn, 
-      &sort, 
-      user_id, 
-      show_nsfw, 
-      None, 
-      data.page, 
-      data.limit)?;
+      &conn, &sort, user_id, show_nsfw, None, data.page, data.limit,
+    )?;
 
     // Return the jwt
-    Ok(
-      ListCommunitiesResponse {
-        op: self.op.to_string(),
-        communities: communities
-      }
-      )
+    Ok(ListCommunitiesResponse {
+      op: self.op.to_string(),
+      communities: communities,
+    })
   }
 }
 
-
 impl Perform<CommunityResponse> for Oper<FollowCommunity> {
   fn perform(&self) -> Result<CommunityResponse, Error> {
     let data: &FollowCommunity = &self.data;
@@ -399,46 +365,37 @@ impl Perform<CommunityResponse> for Oper<FollowCommunity> {
 
     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;
 
     let community_follower_form = CommunityFollowerForm {
       community_id: data.community_id,
-      user_id: user_id
+      user_id: user_id,
     };
 
     if data.follow {
       match CommunityFollower::follow(&conn, &community_follower_form) {
         Ok(user) => user,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "community_follower_already_exists"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "community_follower_already_exists"))?,
       };
     } else {
       match CommunityFollower::ignore(&conn, &community_follower_form) {
         Ok(user) => user,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "community_follower_already_exists"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "community_follower_already_exists"))?,
       };
     }
 
     let community_view = CommunityView::read(&conn, data.community_id, Some(user_id))?;
 
-    Ok(
-      CommunityResponse {
-        op: self.op.to_string(), 
-        community: community_view
-      }
-      )
+    Ok(CommunityResponse {
+      op: self.op.to_string(),
+      community: community_view,
+    })
   }
 }
 
-
 impl Perform<GetFollowedCommunitiesResponse> for Oper<GetFollowedCommunities> {
   fn perform(&self) -> Result<GetFollowedCommunitiesResponse, Error> {
     let data: &GetFollowedCommunities = &self.data;
@@ -446,31 +403,25 @@ impl Perform<GetFollowedCommunitiesResponse> for Oper<GetFollowedCommunities> {
 
     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;
 
-    let communities: Vec<CommunityFollowerView> = match CommunityFollowerView::for_user(&conn, user_id) {
-      Ok(communities) => communities,
-      Err(_e) => {
-        return Err(APIError::err(&self.op, "system_err_login"))?
-      }
-    };
+    let communities: Vec<CommunityFollowerView> =
+      match CommunityFollowerView::for_user(&conn, user_id) {
+        Ok(communities) => communities,
+        Err(_e) => return Err(APIError::err(&self.op, "system_err_login"))?,
+      };
 
     // Return the jwt
-    Ok(
-      GetFollowedCommunitiesResponse {
-        op: self.op.to_string(),
-        communities: communities
-      }
-      )
+    Ok(GetFollowedCommunitiesResponse {
+      op: self.op.to_string(),
+      communities: communities,
+    })
   }
 }
 
-
 impl Perform<BanFromCommunityResponse> for Oper<BanFromCommunity> {
   fn perform(&self) -> Result<BanFromCommunityResponse, Error> {
     let data: &BanFromCommunity = &self.data;
@@ -478,9 +429,7 @@ impl Perform<BanFromCommunityResponse> for Oper<BanFromCommunity> {
 
     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;
@@ -493,23 +442,19 @@ impl Perform<BanFromCommunityResponse> for Oper<BanFromCommunity> {
     if data.ban {
       match CommunityUserBan::ban(&conn, &community_user_ban_form) {
         Ok(user) => user,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "community_user_already_banned"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "community_user_already_banned"))?,
       };
     } else {
       match CommunityUserBan::unban(&conn, &community_user_ban_form) {
         Ok(user) => user,
-        Err(_e) => {
-          return Err(APIError::err(&self.op, "community_user_already_banned"))?
-        }
+        Err(_e) => return Err(APIError::err(&self.op, "community_user_already_banned"))?,
       };
     }
 
     // Mod tables
     let expires = match data.expires {
       Some(time) => Some(naive_from_unix(time)),
-      None => None
+      None => None,
     };
 
     let form = ModBanFromCommunityForm {
@@ -524,13 +469,11 @@ impl Perform<BanFromCommunityResponse> for Oper<BanFromCommunity> {
 
     let user_view = UserView::read(&conn, data.user_id)?;
 
-    Ok(
-      BanFromCommunityResponse {
-        op: self.op.to_string(), 
-        user: user_view,
-        banned: data.ban
-      }
-      )
+    Ok(BanFromCommunityResponse {
+      op: self.op.to_string(),
+      user: user_view,
+      banned: data.ban,
+    })
   }
 }
 
@@ -541,30 +484,34 @@ impl Perform<AddModToCommunityResponse> for Oper<AddModToCommunity> {