From b634061b879f3cbd36bb0dccf63e329462c90fb7 Mon Sep 17 00:00:00 2001 From: Dessalines Date: Sat, 7 Sep 2019 08:35:05 -0700 Subject: [PATCH] Running cargo fmt on server code. - Adding a .rustfmt.toml for the 2 space indent. --- server/.rustfmt.toml | 1 + server/src/api/comment.rs | 140 ++++------- server/src/api/community.rs | 393 +++++++++++++------------------ server/src/api/mod.rs | 78 ++++-- server/src/api/post.rs | 266 +++++++++------------ server/src/api/site.rs | 345 +++++++++++++-------------- server/src/api/user.rs | 319 ++++++++++++------------- server/src/apub.rs | 53 +++-- server/src/db/category.rs | 32 +-- server/src/db/comment.rs | 79 ++++--- server/src/db/comment_view.rs | 175 +++++++------- server/src/db/community.rs | 144 ++++++----- server/src/db/community_view.rs | 114 ++++++--- server/src/db/mod.rs | 120 +++++++--- server/src/db/moderator.rs | 205 ++++++++-------- server/src/db/moderator_views.rs | 196 +++++++++------ server/src/db/post.rs | 81 +++---- server/src/db/post_view.rs | 127 +++++----- server/src/db/user.rs | 74 +++--- server/src/db/user_view.rs | 57 +++-- server/src/lib.rs | 61 +++-- server/src/main.rs | 22 +- server/src/schema.rs | 46 ++-- server/src/websocket/server.rs | 152 ++++++------ 24 files changed, 1697 insertions(+), 1583 deletions(-) create mode 100644 server/.rustfmt.toml diff --git a/server/.rustfmt.toml b/server/.rustfmt.toml new file mode 100644 index 000000000..b196eaa2d --- /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 3d18c72a7..ec010d2f5 100644 --- a/server/src/api/comment.rs +++ b/server/src/api/comment.rs @@ -6,7 +6,7 @@ pub struct CreateComment { parent_id: Option, edit_id: Option, pub post_id: i32, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] @@ -20,20 +20,20 @@ pub struct EditComment { deleted: Option, reason: Option, read: Option, - 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 for Oper { fn perform(&self) -> Result { let data: &CreateComment = &self.data; @@ -52,9 +51,7 @@ impl Perform for Oper { 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 for Oper { // 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { // 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 = 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { // 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 for Oper { 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 a278aa14d..87654e649 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, name: Option, - auth: Option + auth: Option, } #[derive(Serialize, Deserialize)] @@ -16,7 +16,6 @@ pub struct GetCommunityResponse { admins: Vec, } - #[derive(Serialize, Deserialize)] pub struct CreateCommunity { name: String, @@ -24,13 +23,13 @@ pub struct CreateCommunity { description: Option, 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, limit: Option, - auth: Option + auth: Option, } #[derive(Serialize, Deserialize)] pub struct ListCommunitiesResponse { op: String, - communities: Vec + communities: Vec, } #[derive(Serialize, Deserialize, Clone)] @@ -54,7 +53,7 @@ pub struct BanFromCommunity { ban: bool, reason: Option, expires: Option, - 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, expires: Option, - 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 + communities: Vec, } #[derive(Serialize, Deserialize)] pub struct TransferCommunity { community_id: i32, user_id: i32, - auth: String + auth: String, } impl Perform for Oper { @@ -124,35 +123,31 @@ impl Perform for Oper { let conn = establish_connection(); let user_id: Option = 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { 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 = 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 for Oper { 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 for Oper { let conn = establish_connection(); let user_claims: Option = 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::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 for Oper { fn perform(&self) -> Result { let data: &FollowCommunity = &self.data; @@ -399,46 +365,37 @@ impl Perform for Oper { 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 for Oper { fn perform(&self) -> Result { let data: &GetFollowedCommunities = &self.data; @@ -446,31 +403,25 @@ impl Perform for Oper { 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 = match CommunityFollowerView::for_user(&conn, user_id) { - Ok(communities) => communities, - Err(_e) => { - return Err(APIError::err(&self.op, "system_err_login"))? - } - }; + let communities: Vec = + 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 for Oper { fn perform(&self) -> Result { let data: &BanFromCommunity = &self.data; @@ -478,9 +429,7 @@ impl Perform for Oper { 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 for Oper { 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 for Oper { 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 for Oper { 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_moderator_form = CommunityModeratorForm { community_id: data.community_id, - user_id: data.user_id + user_id: data.user_id, }; if data.added { match CommunityModerator::join(&conn, &community_moderator_form) { Ok(user) => user, Err(_e) => { - return Err(APIError::err(&self.op, "community_moderator_already_exists"))? + return Err(APIError::err( + &self.op, + "community_moderator_already_exists", + ))? } }; } else { match CommunityModerator::leave(&conn, &community_moderator_form) { Ok(user) => user, Err(_e) => { - return Err(APIError::err(&self.op, "community_moderator_already_exists"))? + return Err(APIError::err( + &self.op, + "community_moderator_already_exists", + ))? } }; } @@ -580,15 +527,13 @@ impl Perform for Oper { let moderators = CommunityModeratorView::for_community(&conn, data.community_id)?; - Ok( - AddModToCommunityResponse { - op: self.op.to_string(), - moderators: moderators, - } - ) + Ok(AddModToCommunityResponse { + op: self.op.to_string(), + moderators: moderators, + }) } } - + impl Perform for Oper { fn perform(&self) -> Result { let data: &TransferCommunity = &self.data; @@ -596,9 +541,7 @@ impl Perform for Oper { 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; @@ -611,12 +554,17 @@ impl Perform for Oper { let creator_user = admins.remove(creator_index); admins.insert(0, creator_user); - // Make sure user is the creator, or an admin - if user_id != read_community.creator_id && !admins.iter().map(|a| a.id).collect::>().contains(&user_id) { - return Err(APIError::err(&self.op, "not_an_admin"))? + if user_id != read_community.creator_id + && !admins + .iter() + .map(|a| a.id) + .collect::>() + .contains(&user_id) + { + return Err(APIError::err(&self.op, "not_an_admin"))?; } - + let community_form = CommunityForm { name: read_community.name, title: read_community.title, @@ -626,37 +574,41 @@ impl Perform for Oper { removed: None, deleted: None, nsfw: read_community.nsfw, - updated: Some(naive_now()) + updated: Some(naive_now()), }; let _updated_community = match Community::update(&conn, data.community_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"))?, }; // You also have to re-do the community_moderator table, reordering it. let mut community_mods = CommunityModeratorView::for_community(&conn, data.community_id)?; - let creator_index = community_mods.iter().position(|r| r.user_id == data.user_id).unwrap(); + let creator_index = community_mods + .iter() + .position(|r| r.user_id == data.user_id) + .unwrap(); let creator_user = community_mods.remove(creator_index); community_mods.insert(0, creator_user); CommunityModerator::delete_for_community(&conn, data.community_id)?; for cmod in &community_mods { - let community_moderator_form = CommunityModeratorForm { community_id: cmod.community_id, - user_id: cmod.user_id + user_id: cmod.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", + ))? + } + }; } // Mod tables @@ -670,27 +622,20 @@ impl Perform for Oper { let community_view = match CommunityView::read(&conn, data.community_id, Some(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, data.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"))?, }; - // 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, + }) } } diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs index ac11d30cc..8872cd213 100644 --- a/server/src/api/mod.rs +++ b/server/src/api/mod.rs @@ -1,28 +1,61 @@ -use serde::{Deserialize, Serialize}; -use failure::Error; -use crate::db::*; -use crate::db::community::*; -use crate::db::user::*; -use crate::db::post::*; -use crate::db::comment::*; -use crate::db::post_view::*; -use crate::db::comment_view::*; use crate::db::category::*; +use crate::db::comment::*; +use crate::db::comment_view::*; +use crate::db::community::*; use crate::db::community_view::*; -use crate::db::user_view::*; -use crate::db::moderator_views::*; use crate::db::moderator::*; -use crate::{has_slurs, remove_slurs, Settings, naive_now, naive_from_unix}; +use crate::db::moderator_views::*; +use crate::db::post::*; +use crate::db::post_view::*; +use crate::db::user::*; +use crate::db::user_view::*; +use crate::db::*; +use crate::{has_slurs, naive_from_unix, naive_now, remove_slurs, Settings}; +use failure::Error; +use serde::{Deserialize, Serialize}; -pub mod user; +pub mod comment; pub mod community; pub mod post; -pub mod comment; pub mod site; +pub mod user; -#[derive(EnumString,ToString,Debug)] +#[derive(EnumString, ToString, Debug)] pub enum UserOperation { - Login, Register, CreateCommunity, CreatePost, ListCommunities, ListCategories, GetPost, GetCommunity, CreateComment, EditComment, SaveComment, CreateCommentLike, GetPosts, CreatePostLike, EditPost, SavePost, EditCommunity, FollowCommunity, GetFollowedCommunities, GetUserDetails, GetReplies, GetModlog, BanFromCommunity, AddModToCommunity, CreateSite, EditSite, GetSite, AddAdmin, BanUser, Search, MarkAllAsRead, SaveUserSettings, TransferCommunity, TransferSite + Login, + Register, + CreateCommunity, + CreatePost, + ListCommunities, + ListCategories, + GetPost, + GetCommunity, + CreateComment, + EditComment, + SaveComment, + CreateCommentLike, + GetPosts, + CreatePostLike, + EditPost, + SavePost, + EditCommunity, + FollowCommunity, + GetFollowedCommunities, + GetUserDetails, + GetReplies, + GetModlog, + BanFromCommunity, + AddModToCommunity, + CreateSite, + EditSite, + GetSite, + AddAdmin, + BanUser, + Search, + MarkAllAsRead, + SaveUserSettings, + TransferCommunity, + TransferSite, } #[derive(Fail, Debug)] @@ -43,18 +76,17 @@ impl APIError { pub struct Oper { op: UserOperation, - data: T + data: T, } -impl Oper { +impl Oper { pub fn new(op: UserOperation, data: T) -> Oper { - Oper { - op: op, - data: data - } + Oper { op: op, data: data } } } pub trait Perform { - fn perform(&self) -> Result where T: Sized; + fn perform(&self) -> Result + where + T: Sized; } diff --git a/server/src/api/post.rs b/server/src/api/post.rs index 8fc24ac18..5345b0e4e 100644 --- a/server/src/api/post.rs +++ b/server/src/api/post.rs @@ -8,20 +8,19 @@ pub struct CreatePost { body: Option, 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 + auth: Option, } #[derive(Serialize, Deserialize)] @@ -41,7 +40,7 @@ pub struct GetPosts { page: Option, limit: Option, community_id: Option, - auth: Option + auth: Option, } #[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, reason: Option, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] pub struct SavePost { post_id: i32, save: bool, - auth: String + auth: String, } impl Perform for Oper { @@ -92,29 +90,25 @@ impl Perform for Oper { 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 for Oper { 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 for Oper { let conn = establish_connection(); let user_id: Option = 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 for Oper { 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 for Oper { fn perform(&self) -> Result { let data: &GetPosts = &self.data; let conn = establish_connection(); let user_claims: Option = 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 for Oper { 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 for Oper { // 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 for Oper { 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 for Oper { fn perform(&self) -> Result { 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 for Oper { // Verify its the creator or a mod or admin let mut editors: Vec = 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 for Oper { 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 for Oper { 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 for Oper { 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 for Oper { 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, + }) } } diff --git a/server/src/api/site.rs b/server/src/api/site.rs index 7827913b9..bbc26dab3 100644 --- a/server/src/api/site.rs +++ b/server/src/api/site.rs @@ -7,7 +7,7 @@ pub struct ListCategories; #[derive(Serialize, Deserialize)] pub struct ListCategoriesResponse { op: String, - categories: Vec + categories: Vec, } #[derive(Serialize, Deserialize)] @@ -51,19 +51,18 @@ pub struct GetModlogResponse { added: Vec, } - #[derive(Serialize, Deserialize)] pub struct CreateSite { name: String, description: Option, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] pub struct EditSite { name: String, description: Option, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] @@ -86,7 +85,7 @@ pub struct GetSiteResponse { #[derive(Serialize, Deserialize)] pub struct TransferSite { user_id: i32, - auth: String + auth: String, } impl Perform for Oper { @@ -97,12 +96,10 @@ impl Perform for Oper { let categories: Vec = Category::list_all(&conn)?; // Return the jwt - Ok( - ListCategoriesResponse { - op: self.op.to_string(), - categories: categories - } - ) + Ok(ListCategoriesResponse { + op: self.op.to_string(), + categories: categories, + }) } } @@ -111,11 +108,41 @@ impl Perform for Oper { let data: &GetModlog = &self.data; let conn = establish_connection(); - let removed_posts = ModRemovePostView::list(&conn, data.community_id, data.mod_user_id, data.page, data.limit)?; - let locked_posts = ModLockPostView::list(&conn, data.community_id, data.mod_user_id, data.page, data.limit)?; - let removed_comments = ModRemoveCommentView::list(&conn, data.community_id, data.mod_user_id, data.page, data.limit)?; - let banned_from_community = ModBanFromCommunityView::list(&conn, data.community_id, data.mod_user_id, data.page, data.limit)?; - let added_to_community = ModAddCommunityView::list(&conn, data.community_id, data.mod_user_id, data.page, data.limit)?; + let removed_posts = ModRemovePostView::list( + &conn, + data.community_id, + data.mod_user_id, + data.page, + data.limit, + )?; + let locked_posts = ModLockPostView::list( + &conn, + data.community_id, + data.mod_user_id, + data.page, + data.limit, + )?; + let removed_comments = ModRemoveCommentView::list( + &conn, + data.community_id, + data.mod_user_id, + data.page, + data.limit, + )?; + let banned_from_community = ModBanFromCommunityView::list( + &conn, + data.community_id, + data.mod_user_id, + data.page, + data.limit, + )?; + let added_to_community = ModAddCommunityView::list( + &conn, + data.community_id, + data.mod_user_id, + data.page, + data.limit, + )?; // These arrays are only for the full modlog, when a community isn't given let mut removed_communities = Vec::new(); @@ -123,25 +150,24 @@ impl Perform for Oper { let mut added = Vec::new(); if data.community_id.is_none() { - removed_communities = ModRemoveCommunityView::list(&conn, data.mod_user_id, data.page, data.limit)?; + removed_communities = + ModRemoveCommunityView::list(&conn, data.mod_user_id, data.page, data.limit)?; banned = ModBanView::list(&conn, data.mod_user_id, data.page, data.limit)?; added = ModAddView::list(&conn, data.mod_user_id, data.page, data.limit)?; } // Return the jwt - Ok( - GetModlogResponse { - op: self.op.to_string(), - removed_posts: removed_posts, - locked_posts: locked_posts, - removed_comments: removed_comments, - removed_communities: removed_communities, - banned_from_community: banned_from_community, - banned: banned, - added_to_community: added_to_community, - added: added, - } - ) + Ok(GetModlogResponse { + op: self.op.to_string(), + removed_posts: removed_posts, + locked_posts: locked_posts, + removed_comments: removed_comments, + removed_communities: removed_communities, + banned_from_community: banned_from_community, + banned: banned, + added_to_community: added_to_community, + added: added, + }) } } @@ -152,21 +178,20 @@ impl Perform for Oper { 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.description.is_some() && has_slurs(&data.description.to_owned().unwrap())) { - return Err(APIError::err(&self.op, "no_slurs"))? - } + if has_slurs(&data.name) + || (data.description.is_some() && has_slurs(&data.description.to_owned().unwrap())) + { + return Err(APIError::err(&self.op, "no_slurs"))?; + } let user_id = claims.id; // Make sure user is an admin if !UserView::read(&conn, user_id)?.admin { - return Err(APIError::err(&self.op, "not_an_admin"))? + return Err(APIError::err(&self.op, "not_an_admin"))?; } let site_form = SiteForm { @@ -178,23 +203,18 @@ impl Perform for Oper { match Site::create(&conn, &site_form) { Ok(site) => site, - Err(_e) => { - return Err(APIError::err(&self.op, "site_already_exists"))? - } + Err(_e) => return Err(APIError::err(&self.op, "site_already_exists"))?, }; let site_view = SiteView::read(&conn)?; - Ok( - SiteResponse { - op: self.op.to_string(), - site: site_view, - } - ) + Ok(SiteResponse { + op: self.op.to_string(), + site: site_view, + }) } } - impl Perform for Oper { fn perform(&self) -> Result { let data: &EditSite = &self.data; @@ -202,21 +222,20 @@ impl Perform for Oper { 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.description.is_some() && has_slurs(&data.description.to_owned().unwrap())) { - return Err(APIError::err(&self.op, "no_slurs"))? - } + if has_slurs(&data.name) + || (data.description.is_some() && has_slurs(&data.description.to_owned().unwrap())) + { + return Err(APIError::err(&self.op, "no_slurs"))?; + } let user_id = claims.id; // Make sure user is an admin if UserView::read(&conn, user_id)?.admin == false { - return Err(APIError::err(&self.op, "not_an_admin"))? + return Err(APIError::err(&self.op, "not_an_admin"))?; } let found_site = Site::read(&conn, 1)?; @@ -230,19 +249,15 @@ impl Perform for Oper { match Site::update(&conn, 1, &site_form) { Ok(site) => site, - Err(_e) => { - return Err(APIError::err(&self.op, "couldnt_update_site"))? - } + Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_site"))?, }; let site_view = SiteView::read(&conn)?; - Ok( - SiteResponse { - op: self.op.to_string(), - site: site_view, - } - ) + Ok(SiteResponse { + op: self.op.to_string(), + site: site_view, + }) } } @@ -254,7 +269,7 @@ impl Perform for Oper { // It can return a null site in order to redirect let site_view = match Site::read(&conn, 1) { Ok(_site) => Some(SiteView::read(&conn)?), - Err(_e) => None + Err(_e) => None, }; let mut admins = UserView::admins(&conn)?; @@ -267,14 +282,12 @@ impl Perform for Oper { let banned = UserView::banned(&conn)?; - Ok( - GetSiteResponse { - op: self.op.to_string(), - site: site_view, - admins: admins, - banned: banned, - } - ) + Ok(GetSiteResponse { + op: self.op.to_string(), + site: site_view, + admins: admins, + banned: banned, + }) } } @@ -296,120 +309,114 @@ impl Perform for Oper { match type_ { SearchType::Posts => { posts = PostView::list( - &conn, - PostListingType::All, - &sort, - data.community_id, + &conn, + PostListingType::All, + &sort, + data.community_id, None, Some(data.q.to_owned()), None, - None, + None, true, - false, - false, - data.page, - data.limit)?; - }, + false, + false, + data.page, + data.limit, + )?; + } SearchType::Comments => { comments = CommentView::list( - &conn, - &sort, - None, - None, + &conn, + &sort, + None, + None, Some(data.q.to_owned()), None, - false, + false, data.page, - data.limit)?; - }, + data.limit, + )?; + } SearchType::Communities => { communities = CommunityView::list( - &conn, - &sort, - None, + &conn, + &sort, + None, true, Some(data.q.to_owned()), - data.page, - data.limit)?; - }, + data.page, + data.limit, + )?; + } SearchType::Users => { - users = UserView::list( - &conn, - &sort, - Some(data.q.to_owned()), - data.page, - data.limit)?; - }, + users = UserView::list(&conn, &sort, Some(data.q.to_owned()), data.page, data.limit)?; + } SearchType::All => { posts = PostView::list( - &conn, - PostListingType::All, - &sort, - data.community_id, + &conn, + PostListingType::All, + &sort, + data.community_id, None, Some(data.q.to_owned()), None, - None, + None, true, - false, - false, - data.page, - data.limit)?; - comments = CommentView::list( - &conn, - &sort, - None, - None, - Some(data.q.to_owned()), - None, - false, + false, + false, data.page, - data.limit)?; + data.limit, + )?; + comments = CommentView::list( + &conn, + &sort, + None, + None, + Some(data.q.to_owned()), + None, + false, + data.page, + data.limit, + )?; communities = CommunityView::list( - &conn, - &sort, - None, + &conn, + &sort, + None, true, Some(data.q.to_owned()), - data.page, - data.limit)?; - users = UserView::list( - &conn, - &sort, - Some(data.q.to_owned()), - data.page, - data.limit)?; - }, + data.page, + data.limit, + )?; + users = UserView::list(&conn, &sort, Some(data.q.to_owned()), data.page, data.limit)?; + } SearchType::Url => { posts = PostView::list( - &conn, - PostListingType::All, - &sort, - data.community_id, + &conn, + PostListingType::All, + &sort, + data.community_id, None, None, Some(data.q.to_owned()), - None, + None, true, - false, - false, - data.page, - data.limit)?; + false, + false, + data.page, + data.limit, + )?; } }; - // Return the jwt - Ok( - SearchResponse { - op: self.op.to_string(), - type_: data.type_.to_owned(), - comments: comments, - posts: posts, - communities: communities, - users: users, - } - ) + Ok(SearchResponse { + op: self.op.to_string(), + type_: data.type_.to_owned(), + comments: comments, + posts: posts, + communities: communities, + users: users, + }) } } @@ -420,9 +427,7 @@ impl Perform for Oper { 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; @@ -431,7 +436,7 @@ impl Perform for Oper { // Make sure user is the creator if read_site.creator_id != user_id { - return Err(APIError::err(&self.op, "not_an_admin"))? + return Err(APIError::err(&self.op, "not_an_admin"))?; } let site_form = SiteForm { @@ -443,9 +448,7 @@ impl Perform for Oper { match Site::update(&conn, 1, &site_form) { Ok(site) => site, - Err(_e) => { - return Err(APIError::err(&self.op, "couldnt_update_site"))? - } + Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_site"))?, }; // Mod tables @@ -460,20 +463,20 @@ impl Perform for Oper { let site_view = SiteView::read(&conn)?; let mut admins = UserView::admins(&conn)?; - let creator_index = admins.iter().position(|r| r.id == site_view.creator_id).unwrap(); + let creator_index = admins + .iter() + .position(|r| r.id == site_view.creator_id) + .unwrap(); let creator_user = admins.remove(creator_index); admins.insert(0, creator_user); let banned = UserView::banned(&conn)?; - Ok( - GetSiteResponse { - op: self.op.to_string(), - site: Some(site_view), - admins: admins, - banned: banned, - } - ) + Ok(GetSiteResponse { + op: self.op.to_string(), + site: Some(site_view), + admins: admins, + banned: banned, + }) } } - diff --git a/server/src/api/user.rs b/server/src/api/user.rs index d8610fa9a..222b64083 100644 --- a/server/src/api/user.rs +++ b/server/src/api/user.rs @@ -1,11 +1,11 @@ use super::*; +use bcrypt::verify; use std::str::FromStr; -use bcrypt::{verify}; #[derive(Serialize, Deserialize, Debug)] pub struct Login { username_or_email: String, - password: String + password: String, } #[derive(Serialize, Deserialize)] @@ -27,7 +27,7 @@ pub struct SaveUserSettings { #[derive(Serialize, Deserialize)] pub struct LoginResponse { op: String, - jwt: String + jwt: String, } #[derive(Serialize, Deserialize)] @@ -60,14 +60,14 @@ pub struct GetRepliesResponse { #[derive(Serialize, Deserialize)] pub struct MarkAllAsRead { - auth: String + auth: String, } #[derive(Serialize, Deserialize)] pub struct AddAdmin { user_id: i32, added: bool, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] @@ -82,7 +82,7 @@ pub struct BanUser { ban: bool, reason: Option, expires: Option, - auth: String + auth: String, } #[derive(Serialize, Deserialize)] @@ -98,7 +98,7 @@ pub struct GetReplies { page: Option, limit: Option, unread_only: bool, - auth: String + auth: String, } impl Perform for Oper { @@ -109,26 +109,28 @@ impl Perform for Oper { // Fetch that username / email let user: User_ = match User_::find_by_email_or_username(&conn, &data.username_or_email) { Ok(user) => user, - Err(_e) => return Err(APIError::err(&self.op, "couldnt_find_that_username_or_email"))? + Err(_e) => { + return Err(APIError::err( + &self.op, + "couldnt_find_that_username_or_email", + ))? + } }; // Verify the password let valid: bool = verify(&data.password, &user.password_encrypted).unwrap_or(false); if !valid { - return Err(APIError::err(&self.op, "password_incorrect"))? + return Err(APIError::err(&self.op, "password_incorrect"))?; } // Return the jwt - Ok( - LoginResponse { - op: self.op.to_string(), - jwt: user.jwt() - } - ) + Ok(LoginResponse { + op: self.op.to_string(), + jwt: user.jwt(), + }) } } - impl Perform for Oper { fn perform(&self) -> Result { let data: &Register = &self.data; @@ -136,16 +138,16 @@ impl Perform for Oper { // Make sure passwords match if &data.password != &data.password_verify { - return Err(APIError::err(&self.op, "passwords_dont_match"))? + return Err(APIError::err(&self.op, "passwords_dont_match"))?; } if has_slurs(&data.username) { - return Err(APIError::err(&self.op, "no_slurs"))? + return Err(APIError::err(&self.op, "no_slurs"))?; } // Make sure there are no admins if data.admin && UserView::admins(&conn)?.len() > 0 { - return Err(APIError::err(&self.op, "admin_already_created"))? + return Err(APIError::err(&self.op, "admin_already_created"))?; } // Register the new user @@ -164,9 +166,7 @@ impl Perform for Oper { // Create the user let inserted_user = match User_::register(&conn, &user_form) { Ok(user) => user, - Err(_e) => { - return Err(APIError::err(&self.op, "user_already_exists"))? - } + Err(_e) => return Err(APIError::err(&self.op, "user_already_exists"))?, }; // Create the main community if it doesn't exist @@ -194,12 +194,11 @@ impl Perform for Oper { user_id: inserted_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"))?, + }; // If its an admin, add them as a mod and follower to main if data.admin { @@ -208,22 +207,23 @@ impl Perform for Oper { user_id: inserted_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", + ))? + } + }; } // Return the jwt - Ok( - LoginResponse { - op: self.op.to_string(), - jwt: inserted_user.jwt() - } - ) + Ok(LoginResponse { + op: self.op.to_string(), + jwt: inserted_user.jwt(), + }) } } @@ -234,13 +234,11 @@ impl Perform for Oper { 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 read_user = User_::read(&conn, user_id)?; let user_form = UserForm { @@ -257,18 +255,14 @@ impl Perform for Oper { let updated_user = match User_::update(&conn, user_id, &user_form) { Ok(user) => user, - Err(_e) => { - return Err(APIError::err(&self.op, "couldnt_update_user"))? - } + Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_user"))?, }; // Return the jwt - Ok( - LoginResponse { - op: self.op.to_string(), - jwt: updated_user.jwt() - } - ) + Ok(LoginResponse { + op: self.op.to_string(), + jwt: updated_user.jwt(), + }) } } @@ -278,25 +272,21 @@ impl Perform for Oper { let conn = establish_connection(); let user_claims: Option = 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, }; //TODO add save @@ -304,7 +294,13 @@ impl Perform for Oper { let user_details_id = match data.user_id { Some(id) => id, - None => User_::read_from_name(&conn, data.username.to_owned().unwrap_or("admin".to_string()))?.id + None => { + User_::read_from_name( + &conn, + data.username.to_owned().unwrap_or("admin".to_string()), + )? + .id + } }; let user_view = UserView::read(&conn, user_details_id)?; @@ -312,77 +308,78 @@ impl Perform for Oper { // If its saved only, you don't care what creator it was let posts = if data.saved_only { PostView::list( - &conn, - PostListingType::All, - &sort, - data.community_id, - None, + &conn, + PostListingType::All, + &sort, + data.community_id, None, None, - Some(user_details_id), + None, + Some(user_details_id), show_nsfw, - data.saved_only, - false, - data.page, - data.limit)? + data.saved_only, + false, + data.page, + data.limit, + )? } else { PostView::list( - &conn, - PostListingType::All, - &sort, - data.community_id, - Some(user_details_id), - None, + &conn, + PostListingType::All, + &sort, + data.community_id, + Some(user_details_id), None, - user_id, + None, + user_id, show_nsfw, - data.saved_only, - false, - data.page, - data.limit)? + data.saved_only, + false, + data.page, + data.limit, + )? }; let comments = if data.saved_only { CommentView::list( - &conn, - &sort, - None, - None, - None, - Some(user_details_id), - data.saved_only, - data.page, - data.limit)? + &conn, + &sort, + None, + None, + None, + Some(user_details_id), + data.saved_only, + data.page, + data.limit, + )? } else { CommentView::list( - &conn, - &sort, - None, - Some(user_details_id), - None, - user_id, - data.saved_only, - data.page, - data.limit)? + &conn, + &sort, + None, + Some(user_details_id), + None, + user_id, + data.saved_only, + data.page, + data.limit, + )? }; let follows = CommunityFollowerView::for_user(&conn, user_details_id)?; let moderates = CommunityModeratorView::for_user(&conn, user_details_id)?; // Return the jwt - Ok( - GetUserDetailsResponse { - op: self.op.to_string(), - user: user_view, - follows: follows, - moderates: moderates, - comments: comments, - posts: posts, - } - ) + Ok(GetUserDetailsResponse { + op: self.op.to_string(), + user: user_view, + follows: follows, + moderates: moderates, + comments: comments, + posts: posts, + }) } } - impl Perform for Oper { fn perform(&self) -> Result { let data: &AddAdmin = &self.data; @@ -390,16 +387,14 @@ impl Perform for Oper { 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; // Make sure user is an admin if UserView::read(&conn, user_id)?.admin == false { - return Err(APIError::err(&self.op, "not_an_admin"))? + return Err(APIError::err(&self.op, "not_an_admin"))?; } let read_user = User_::read(&conn, data.user_id)?; @@ -418,9 +413,7 @@ impl Perform for Oper { match User_::update(&conn, data.user_id, &user_form) { Ok(user) => user, - Err(_e) => { - return Err(APIError::err(&self.op, "couldnt_update_user"))? - } + Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_user"))?, }; // Mod tables @@ -438,12 +431,10 @@ impl Perform for Oper { let creator_user = admins.remove(creator_index); admins.insert(0, creator_user); - Ok( - AddAdminResponse { - op: self.op.to_string(), - admins: admins, - } - ) + Ok(AddAdminResponse { + op: self.op.to_string(), + admins: admins, + }) } } @@ -454,16 +445,14 @@ impl Perform for Oper { 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; // Make sure user is an admin if UserView::read(&conn, user_id)?.admin == false { - return Err(APIError::err(&self.op, "not_an_admin"))? + return Err(APIError::err(&self.op, "not_an_admin"))?; } let read_user = User_::read(&conn, data.user_id)?; @@ -482,15 +471,13 @@ impl Perform for Oper { match User_::update(&conn, data.user_id, &user_form) { Ok(user) => user, - Err(_e) => { - return Err(APIError::err(&self.op, "couldnt_update_user"))? - } + Err(_e) => return Err(APIError::err(&self.op, "couldnt_update_user"))?, }; // Mod tables let expires = match data.expires { Some(time) => Some(naive_from_unix(time)), - None => None + None => None, }; let form = ModBanForm { @@ -505,14 +492,11 @@ impl Perform for Oper { let user_view = UserView::read(&conn, data.user_id)?; - Ok( - BanUserResponse { - op: self.op.to_string(), - user: user_view, - banned: data.ban - } - ) - + Ok(BanUserResponse { + op: self.op.to_string(), + user: user_view, + banned: data.ban, + }) } } @@ -523,24 +507,27 @@ impl Perform for Oper { 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 sort = SortType::from_str(&data.sort)?; - let replies = ReplyView::get_replies(&conn, user_id, &sort, data.unread_only, data.page, data.limit)?; + let replies = ReplyView::get_replies( + &conn, + user_id, + &sort, + data.unread_only, + data.page, + data.limit, + )?; // Return the jwt - Ok( - GetRepliesResponse { - op: self.op.to_string(), - replies: replies, - } - ) + Ok(GetRepliesResponse { + op: self.op.to_string(), + replies: replies, + }) } } @@ -551,9 +538,7 @@ impl Perform for Oper { 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; @@ -569,24 +554,20 @@ impl Perform for Oper { removed: None, deleted: None, read: Some(true), - updated: reply.to_owned().updated + updated: reply.to_owned().updated, }; let _updated_comment = match Comment::update(&conn, reply.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"))?, }; } let replies = ReplyView::get_replies(&conn, user_id, &SortType::New, true, Some(1), Some(999))?; - Ok( - GetRepliesResponse { - op: self.op.to_string(), - replies: replies, - } - ) + Ok(GetRepliesResponse { + op: self.op.to_string(), + replies: replies, + }) } } diff --git a/server/src/apub.rs b/server/src/apub.rs index 9de32401d..e0469d1a7 100644 --- a/server/src/apub.rs +++ b/server/src/apub.rs @@ -1,27 +1,51 @@ extern crate activitypub; -use self::activitypub::{context, actor::Person}; +use self::activitypub::{actor::Person, context}; use crate::db::user::User_; impl User_ { pub fn person(&self) -> Person { - use crate::{Settings, to_datetime_utc}; + use crate::{to_datetime_utc, Settings}; let base_url = &format!("{}/user/{}", Settings::get().api_endpoint(), self.name); - let mut person = Person::default(); + let mut person = Person::default(); person.object_props.set_context_object(context()).ok(); person.object_props.set_id_string(base_url.to_string()).ok(); - person.object_props.set_name_string(self.name.to_owned()).ok(); - person.object_props.set_published_utctime(to_datetime_utc(self.published)).ok(); + person + .object_props + .set_name_string(self.name.to_owned()) + .ok(); + person + .object_props + .set_published_utctime(to_datetime_utc(self.published)) + .ok(); if let Some(i) = self.updated { - person.object_props.set_updated_utctime(to_datetime_utc(i)).ok(); + person + .object_props + .set_updated_utctime(to_datetime_utc(i)) + .ok(); } // person.object_props.summary = self.summary; - person.ap_actor_props.set_inbox_string(format!("{}/inbox", &base_url)).ok(); - person.ap_actor_props.set_outbox_string(format!("{}/outbox", &base_url)).ok(); - person.ap_actor_props.set_following_string(format!("{}/following", &base_url)).ok(); - person.ap_actor_props.set_liked_string(format!("{}/liked", &base_url)).ok(); + person + .ap_actor_props + .set_inbox_string(format!("{}/inbox", &base_url)) + .ok(); + person + .ap_actor_props + .set_outbox_string(format!("{}/outbox", &base_url)) + .ok(); + person + .ap_actor_props + .set_following_string(format!("{}/following", &base_url)) + .ok(); + person + .ap_actor_props + .set_liked_string(format!("{}/liked", &base_url)) + .ok(); if let Some(i) = &self.preferred_username { - person.ap_actor_props.set_preferred_username_string(i.to_string()).ok(); + person + .ap_actor_props + .set_preferred_username_string(i.to_string()) + .ok(); } person @@ -51,10 +75,11 @@ mod tests { }; let person = expected_user.person(); - assert_eq!("rrr/api/v1/user/thom", person.object_props.id_string().unwrap()); + assert_eq!( + "rrr/api/v1/user/thom", + person.object_props.id_string().unwrap() + ); let json = serde_json::to_string_pretty(&person).unwrap(); println!("{}", json); - } } - diff --git a/server/src/db/category.rs b/server/src/db/category.rs index eb8225801..6e483ce08 100644 --- a/server/src/db/category.rs +++ b/server/src/db/category.rs @@ -1,38 +1,40 @@ -use crate::schema::{category}; -use crate::schema::category::dsl::*; use super::*; +use crate::schema::category; +use crate::schema::category::dsl::*; #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="category"] +#[table_name = "category"] pub struct Category { pub id: i32, - pub name: String + pub name: String, } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="category"] +#[table_name = "category"] pub struct CategoryForm { pub name: String, } impl Crud for Category { fn read(conn: &PgConnection, category_id: i32) -> Result { - category.find(category_id) - .first::(conn) + category.find(category_id).first::(conn) } fn delete(conn: &PgConnection, category_id: i32) -> Result { - diesel::delete(category.find(category_id)) - .execute(conn) + diesel::delete(category.find(category_id)).execute(conn) } fn create(conn: &PgConnection, new_category: &CategoryForm) -> Result { - insert_into(category) - .values(new_category) - .get_result::(conn) + insert_into(category) + .values(new_category) + .get_result::(conn) } - fn update(conn: &PgConnection, category_id: i32, new_category: &CategoryForm) -> Result { + fn update( + conn: &PgConnection, + category_id: i32, + new_category: &CategoryForm, + ) -> Result { diesel::update(category.find(category_id)) .set(new_category) .get_result::(conn) @@ -48,14 +50,14 @@ impl Category { #[cfg(test)] mod tests { use super::*; - #[test] + #[test] fn test_crud() { let conn = establish_connection(); let categories = Category::list_all(&conn).unwrap(); let expected_first_category = Category { id: 1, - name: "Discussion".into() + name: "Discussion".into(), }; assert_eq!(expected_first_category, categories[0]); diff --git a/server/src/db/comment.rs b/server/src/db/comment.rs index 7901357f0..ec00fab79 100644 --- a/server/src/db/comment.rs +++ b/server/src/db/comment.rs @@ -1,6 +1,6 @@ -use crate::schema::{comment, comment_like, comment_saved}; -use super::*; use super::post::Post; +use super::*; +use crate::schema::{comment, comment_like, comment_saved}; // WITH RECURSIVE MyTree AS ( // SELECT * FROM comment WHERE parent_id IS NULL @@ -11,7 +11,7 @@ use super::post::Post; #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Deserialize)] #[belongs_to(Post)] -#[table_name="comment"] +#[table_name = "comment"] pub struct Comment { pub id: i32, pub creator_id: i32, @@ -26,7 +26,7 @@ pub struct Comment { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="comment"] +#[table_name = "comment"] pub struct CommentForm { pub creator_id: i32, pub post_id: i32, @@ -41,14 +41,12 @@ pub struct CommentForm { impl Crud for Comment { fn read(conn: &PgConnection, comment_id: i32) -> Result { use crate::schema::comment::dsl::*; - comment.find(comment_id) - .first::(conn) + comment.find(comment_id).first::(conn) } fn delete(conn: &PgConnection, comment_id: i32) -> Result { use crate::schema::comment::dsl::*; - diesel::delete(comment.find(comment_id)) - .execute(conn) + diesel::delete(comment.find(comment_id)).execute(conn) } fn create(conn: &PgConnection, comment_form: &CommentForm) -> Result { @@ -58,7 +56,11 @@ impl Crud for Comment { .get_result::(conn) } - fn update(conn: &PgConnection, comment_id: i32, comment_form: &CommentForm) -> Result { + fn update( + conn: &PgConnection, + comment_id: i32, + comment_form: &CommentForm, + ) -> Result { use crate::schema::comment::dsl::*; diesel::update(comment.find(comment_id)) .set(comment_form) @@ -79,20 +81,20 @@ pub struct CommentLike { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="comment_like"] +#[table_name = "comment_like"] pub struct CommentLikeForm { pub user_id: i32, pub comment_id: i32, pub post_id: i32, - pub score: i16 + pub score: i16, } -impl Likeable for CommentLike { +impl Likeable for CommentLike { fn read(conn: &PgConnection, comment_id_from: i32) -> Result, Error> { use crate::schema::comment_like::dsl::*; comment_like .filter(comment_id.eq(comment_id_from)) - .load::(conn) + .load::(conn) } fn like(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result { @@ -105,9 +107,10 @@ impl Likeable for CommentLike { use crate::schema::comment_like::dsl::*; diesel::delete( comment_like - .filter(comment_id.eq(comment_like_form.comment_id)) - .filter(user_id.eq(comment_like_form.user_id))) - .execute(conn) + .filter(comment_id.eq(comment_like_form.comment_id)) + .filter(user_id.eq(comment_like_form.user_id)), + ) + .execute(conn) } } @@ -116,7 +119,7 @@ impl CommentLike { use crate::schema::comment_like::dsl::*; comment_like .filter(post_id.eq(post_id_from)) - .load::(conn) + .load::(conn) } } @@ -131,13 +134,13 @@ pub struct CommentSaved { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="comment_saved"] +#[table_name = "comment_saved"] pub struct CommentSavedForm { pub comment_id: i32, pub user_id: i32, } -impl Saveable for CommentSaved { +impl Saveable for CommentSaved { fn save(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result { use crate::schema::comment_saved::dsl::*; insert_into(comment_saved) @@ -146,20 +149,22 @@ impl Saveable for CommentSaved { } fn unsave(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result { use crate::schema::comment_saved::dsl::*; - diesel::delete(comment_saved - .filter(comment_id.eq(comment_saved_form.comment_id)) - .filter(user_id.eq(comment_saved_form.user_id))) - .execute(conn) + diesel::delete( + comment_saved + .filter(comment_id.eq(comment_saved_form.comment_id)) + .filter(user_id.eq(comment_saved_form.user_id)), + ) + .execute(conn) } } #[cfg(test)] mod tests { - use super::*; - use super::super::post::*; use super::super::community::*; + use super::super::post::*; use super::super::user::*; - #[test] + use super::*; + #[test] fn test_crud() { let conn = establish_connection(); @@ -190,7 +195,7 @@ mod tests { }; let inserted_community = Community::create(&conn, &new_community).unwrap(); - + let new_post = PostForm { name: "A test post".into(), creator_id: inserted_user.id, @@ -214,7 +219,7 @@ mod tests { deleted: None, read: None, parent_id: None, - updated: None + updated: None, }; let inserted_comment = Comment::create(&conn, &comment_form).unwrap(); @@ -229,9 +234,9 @@ mod tests { read: false, parent_id: None, published: inserted_comment.published, - updated: None + updated: None, }; - + let child_comment_form = CommentForm { content: "A child comment".into(), creator_id: inserted_user.id, @@ -240,7 +245,7 @@ mod tests { removed: None, deleted: None, read: None, - updated: None + updated: None, }; let inserted_child_comment = Comment::create(&conn, &child_comment_form).unwrap(); @@ -250,7 +255,7 @@ mod tests { comment_id: inserted_comment.id, post_id: inserted_post.id, user_id: inserted_user.id, - score: 1 + score: 1, }; let inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap(); @@ -261,9 +266,9 @@ mod tests { post_id: inserted_post.id, user_id: inserted_user.id, published: inserted_comment_like.published, - score: 1 + score: 1, }; - + // Comment Saved let comment_saved_form = CommentSavedForm { comment_id: inserted_comment.id, @@ -294,10 +299,12 @@ mod tests { assert_eq!(expected_comment, updated_comment); assert_eq!(expected_comment_like, inserted_comment_like); assert_eq!(expected_comment_saved, inserted_comment_saved); - assert_eq!(expected_comment.id, inserted_child_comment.parent_id.unwrap()); + assert_eq!( + expected_comment.id, + inserted_child_comment.parent_id.unwrap() + ); assert_eq!(1, like_removed); assert_eq!(1, saved_removed); assert_eq!(1, num_deleted); - } } diff --git a/server/src/db/comment_view.rs b/server/src/db/comment_view.rs index 8a6545ba2..81f7a6721 100644 --- a/server/src/db/comment_view.rs +++ b/server/src/db/comment_view.rs @@ -26,8 +26,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="comment_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "comment_view"] pub struct CommentView { pub id: i32, pub creator_id: i32, @@ -52,17 +54,17 @@ pub struct CommentView { } impl CommentView { - - pub fn list(conn: &PgConnection, - sort: &SortType, - for_post_id: Option, - for_creator_id: Option, - search_term: Option, - my_user_id: Option, - saved_only: bool, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + sort: &SortType, + for_post_id: Option, + for_creator_id: Option, + search_term: Option, + my_user_id: Option, + saved_only: bool, + page: Option, + limit: Option, + ) -> Result, Error> { use super::comment_view::comment_view::dsl::*; let (limit, offset) = limit_and_offset(page, limit); @@ -88,7 +90,7 @@ impl CommentView { if let Some(search_term) = search_term { query = query.filter(content.ilike(fuzzy_search(&search_term))); }; - + if saved_only { query = query.filter(saved.eq(true)); } @@ -100,26 +102,27 @@ impl CommentView { SortType::TopYear => query .filter(published.gt(now - 1.years())) .order_by(score.desc()), - SortType::TopMonth => query - .filter(published.gt(now - 1.months())) - .order_by(score.desc()), - SortType::TopWeek => query - .filter(published.gt(now - 1.weeks())) - .order_by(score.desc()), - SortType::TopDay => query - .filter(published.gt(now - 1.days())) - .order_by(score.desc()), - _ => query.order_by(published.desc()) + SortType::TopMonth => query + .filter(published.gt(now - 1.months())) + .order_by(score.desc()), + SortType::TopWeek => query + .filter(published.gt(now - 1.weeks())) + .order_by(score.desc()), + SortType::TopDay => query + .filter(published.gt(now - 1.days())) + .order_by(score.desc()), + _ => query.order_by(published.desc()), }; // Note: deleted and removed comments are done on the front side - query - .limit(limit) - .offset(offset) - .load::(conn) + query.limit(limit).offset(offset).load::(conn) } - pub fn read(conn: &PgConnection, from_comment_id: i32, my_user_id: Option) -> Result { + pub fn read( + conn: &PgConnection, + from_comment_id: i32, + my_user_id: Option, + ) -> Result { use super::comment_view::comment_view::dsl::*; let mut query = comment_view.into_boxed(); @@ -131,14 +134,14 @@ impl CommentView { query = query.filter(user_id.is_null()); } - query = query.filter(id.eq(from_comment_id)).order_by(published.desc()); + query = query + .filter(id.eq(from_comment_id)) + .order_by(published.desc()); - query.first::(conn) + query.first::(conn) } - } - // The faked schema since diesel doesn't do views table! { reply_view (id) { @@ -166,8 +169,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="reply_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "reply_view"] pub struct ReplyView { pub id: i32, pub creator_id: i32, @@ -193,14 +198,14 @@ pub struct ReplyView { } impl ReplyView { - - pub fn get_replies(conn: &PgConnection, - for_user_id: i32, - sort: &SortType, - unread_only: bool, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn get_replies( + conn: &PgConnection, + for_user_id: i32, + sort: &SortType, + unread_only: bool, + page: Option, + limit: Option, + ) -> Result, Error> { use super::comment_view::reply_view::dsl::*; let (limit, offset) = limit_and_offset(page, limit); @@ -222,34 +227,30 @@ impl ReplyView { SortType::TopYear => query .filter(published.gt(now - 1.years())) .order_by(score.desc()), - SortType::TopMonth => query - .filter(published.gt(now - 1.months())) - .order_by(score.desc()), - SortType::TopWeek => query - .filter(published.gt(now - 1.weeks())) - .order_by(score.desc()), - SortType::TopDay => query - .filter(published.gt(now - 1.days())) - .order_by(score.desc()), - _ => query.order_by(published.desc()) + SortType::TopMonth => query + .filter(published.gt(now - 1.months())) + .order_by(score.desc()), + SortType::TopWeek => query + .filter(published.gt(now - 1.weeks())) + .order_by(score.desc()), + SortType::TopDay => query + .filter(published.gt(now - 1.days())) + .order_by(score.desc()), + _ => query.order_by(published.desc()), }; - query - .limit(limit) - .offset(offset) - .load::(conn) + query.limit(limit).offset(offset).load::(conn) } - } #[cfg(test)] mod tests { - use super::*; - use super::super::post::*; - use super::super::community::*; - use super::super::user::*; use super::super::comment::*; - #[test] + use super::super::community::*; + use super::super::post::*; + use super::super::user::*; + use super::*; + #[test] fn test_crud() { let conn = establish_connection(); @@ -280,7 +281,7 @@ mod tests { }; let inserted_community = Community::create(&conn, &new_community).unwrap(); - + let new_post = PostForm { name: "A test post 2".into(), creator_id: inserted_user.id, @@ -304,7 +305,7 @@ mod tests { removed: None, deleted: None, read: None, - updated: None + updated: None, }; let inserted_comment = Comment::create(&conn, &comment_form).unwrap(); @@ -313,7 +314,7 @@ mod tests { comment_id: inserted_comment.id, post_id: inserted_post.id, user_id: inserted_user.id, - score: 1 + score: 1, }; let _inserted_comment_like = CommentLike::like(&conn, &comment_like_form).unwrap(); @@ -365,25 +366,29 @@ mod tests { }; let read_comment_views_no_user = CommentView::list( - &conn, - &SortType::New, - Some(inserted_post.id), - None, - None, + &conn, + &SortType::New, + Some(inserted_post.id), None, - false, - None, - None).unwrap(); + None, + None, + false, + None, + None, + ) + .unwrap(); let read_comment_views_with_user = CommentView::list( - &conn, - &SortType::New, - Some(inserted_post.id), - None, + &conn, + &SortType::New, + Some(inserted_post.id), None, - Some(inserted_user.id), - false, - None, - None).unwrap(); + None, + Some(inserted_user.id), + false, + None, + None, + ) + .unwrap(); let like_removed = CommentLike::remove(&conn, &comment_like_form).unwrap(); let num_deleted = Comment::delete(&conn, inserted_comment.id).unwrap(); Post::delete(&conn, inserted_post.id).unwrap(); @@ -391,9 +396,11 @@ mod tests { User_::delete(&conn, inserted_user.id).unwrap(); assert_eq!(expected_comment_view_no_user, read_comment_views_no_user[0]); - assert_eq!(expected_comment_view_with_user, read_comment_views_with_user[0]); + assert_eq!( + expected_comment_view_with_user, + read_comment_views_with_user[0] + ); assert_eq!(1, num_deleted); assert_eq!(1, like_removed); } } - diff --git a/server/src/db/community.rs b/server/src/db/community.rs index e07b5c003..856b5f674 100644 --- a/server/src/db/community.rs +++ b/server/src/db/community.rs @@ -1,8 +1,8 @@ -use crate::schema::{community, community_moderator, community_follower, community_user_ban, site}; use super::*; +use crate::schema::{community, community_follower, community_moderator, community_user_ban, site}; #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="community"] +#[table_name = "community"] pub struct Community { pub id: i32, pub name: String, @@ -18,7 +18,7 @@ pub struct Community { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="community"] +#[table_name = "community"] pub struct CommunityForm { pub name: String, pub title: String, @@ -34,24 +34,26 @@ pub struct CommunityForm { impl Crud for Community { fn read(conn: &PgConnection, community_id: i32) -> Result { use crate::schema::community::dsl::*; - community.find(community_id) - .first::(conn) + community.find(community_id).first::(conn) } fn delete(conn: &PgConnection, community_id: i32) -> Result { use crate::schema::community::dsl::*; - diesel::delete(community.find(community_id)) - .execute(conn) + diesel::delete(community.find(community_id)).execute(conn) } fn create(conn: &PgConnection, new_community: &CommunityForm) -> Result { use crate::schema::community::dsl::*; - insert_into(community) - .values(new_community) - .get_result::(conn) + insert_into(community) + .values(new_community) + .get_result::(conn) } - fn update(conn: &PgConnection, community_id: i32, new_community: &CommunityForm) -> Result { + fn update( + conn: &PgConnection, + community_id: i32, + new_community: &CommunityForm, + ) -> Result { use crate::schema::community::dsl::*; diesel::update(community.find(community_id)) .set(new_community) @@ -62,7 +64,8 @@ impl Crud for Community { impl Community { pub fn read_from_name(conn: &PgConnection, community_name: String) -> Result { use crate::schema::community::dsl::*; - community.filter(name.eq(community_name)) + community + .filter(name.eq(community_name)) .first::(conn) } } @@ -78,36 +81,41 @@ pub struct CommunityModerator { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="community_moderator"] +#[table_name = "community_moderator"] pub struct CommunityModeratorForm { pub community_id: i32, pub user_id: i32, } impl Joinable for CommunityModerator { - fn join(conn: &PgConnection, community_user_form: &CommunityModeratorForm) -> Result { + fn join( + conn: &PgConnection, + community_user_form: &CommunityModeratorForm, + ) -> Result { use crate::schema::community_moderator::dsl::*; insert_into(community_moderator) .values(community_user_form) .get_result::(conn) } - fn leave(conn: &PgConnection, community_user_form: &CommunityModeratorForm) -> Result { + fn leave( + conn: &PgConnection, + community_user_form: &CommunityModeratorForm, + ) -> Result { use crate::schema::community_moderator::dsl::*; - diesel::delete(community_moderator - .filter(community_id.eq(community_user_form.community_id)) - .filter(user_id.eq(community_user_form.user_id))) - .execute(conn) + diesel::delete( + community_moderator + .filter(community_id.eq(community_user_form.community_id)) + .filter(user_id.eq(community_user_form.user_id)), + ) + .execute(conn) } } impl CommunityModerator { pub fn delete_for_community(conn: &PgConnection, for_community_id: i32) -> Result { use crate::schema::community_moderator::dsl::*; - diesel::delete( - community_moderator - .filter(community_id.eq(for_community_id))) - .execute(conn) + diesel::delete(community_moderator.filter(community_id.eq(for_community_id))).execute(conn) } } @@ -122,26 +130,34 @@ pub struct CommunityUserBan { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="community_user_ban"] +#[table_name = "community_user_ban"] pub struct CommunityUserBanForm { pub community_id: i32, pub user_id: i32, } impl Bannable for CommunityUserBan { - fn ban(conn: &PgConnection, community_user_ban_form: &CommunityUserBanForm) -> Result { + fn ban( + conn: &PgConnection, + community_user_ban_form: &CommunityUserBanForm, + ) -> Result { use crate::schema::community_user_ban::dsl::*; insert_into(community_user_ban) .values(community_user_ban_form) .get_result::(conn) } - fn unban(conn: &PgConnection, community_user_ban_form: &CommunityUserBanForm) -> Result { + fn unban( + conn: &PgConnection, + community_user_ban_form: &CommunityUserBanForm, + ) -> Result { use crate::schema::community_user_ban::dsl::*; - diesel::delete(community_user_ban - .filter(community_id.eq(community_user_ban_form.community_id)) - .filter(user_id.eq(community_user_ban_form.user_id))) - .execute(conn) + diesel::delete( + community_user_ban + .filter(community_id.eq(community_user_ban_form.community_id)) + .filter(user_id.eq(community_user_ban_form.user_id)), + ) + .execute(conn) } } @@ -156,46 +172,54 @@ pub struct CommunityFollower { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="community_follower"] +#[table_name = "community_follower"] pub struct CommunityFollowerForm { pub community_id: i32, pub user_id: i32, } impl Followable for CommunityFollower { - fn follow(conn: &PgConnection, community_follower_form: &CommunityFollowerForm) -> Result { + fn follow( + conn: &PgConnection, + community_follower_form: &CommunityFollowerForm, + ) -> Result { use crate::schema::community_follower::dsl::*; insert_into(community_follower) .values(community_follower_form) .get_result::(conn) } - fn ignore(conn: &PgConnection, community_follower_form: &CommunityFollowerForm) -> Result { + fn ignore( + conn: &PgConnection, + community_follower_form: &CommunityFollowerForm, + ) -> Result { use crate::schema::community_follower::dsl::*; - diesel::delete(community_follower - .filter(community_id.eq(&community_follower_form.community_id)) - .filter(user_id.eq(&community_follower_form.user_id))) - .execute(conn) + diesel::delete( + community_follower + .filter(community_id.eq(&community_follower_form.community_id)) + .filter(user_id.eq(&community_follower_form.user_id)), + ) + .execute(conn) } } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="site"] +#[table_name = "site"] pub struct Site { pub id: i32, pub name: String, pub description: Option, pub creator_id: i32, pub published: chrono::NaiveDateTime, - pub updated: Option + pub updated: Option, } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="site"] +#[table_name = "site"] pub struct SiteForm { pub name: String, pub description: Option, pub creator_id: i32, - pub updated: Option + pub updated: Option, } impl Crud for Site { @@ -206,15 +230,12 @@ impl Crud for Site { fn delete(conn: &PgConnection, site_id: i32) -> Result { use crate::schema::site::dsl::*; - diesel::delete(site.find(site_id)) - .execute(conn) + diesel::delete(site.find(site_id)).execute(conn) } fn create(conn: &PgConnection, new_site: &SiteForm) -> Result { use crate::schema::site::dsl::*; - insert_into(site) - .values(new_site) - .get_result::(conn) + insert_into(site).values(new_site).get_result::(conn) } fn update(conn: &PgConnection, site_id: i32, new_site: &SiteForm) -> Result { @@ -227,9 +248,9 @@ impl Crud for Site { #[cfg(test)] mod tests { - use super::*; use super::super::user::*; - #[test] + use super::*; + #[test] fn test_crud() { let conn = establish_connection(); @@ -272,27 +293,27 @@ mod tests { removed: false, deleted: false, published: inserted_community.published, - updated: None + updated: None, }; let community_follower_form = CommunityFollowerForm { community_id: inserted_community.id, - user_id: inserted_user.id + user_id: inserted_user.id, }; - let inserted_community_follower = CommunityFollower::follow(&conn, &community_follower_form).unwrap(); - + let inserted_community_follower = + CommunityFollower::follow(&conn, &community_follower_form).unwrap(); let expected_community_follower = CommunityFollower { id: inserted_community_follower.id, community_id: inserted_community.id, user_id: inserted_user.id, - published: inserted_community_follower.published + published: inserted_community_follower.published, }; - + let community_user_form = CommunityModeratorForm { community_id: inserted_community.id, - user_id: inserted_user.id + user_id: inserted_user.id, }; let inserted_community_user = CommunityModerator::join(&conn, &community_user_form).unwrap(); @@ -301,25 +322,27 @@ mod tests { id: inserted_community_user.id, community_id: inserted_community.id, user_id: inserted_user.id, - published: inserted_community_user.published + published: inserted_community_user.published, }; let community_user_ban_form = CommunityUserBanForm { community_id: inserted_community.id, - user_id: inserted_user.id + user_id: inserted_user.id, }; - let inserted_community_user_ban = CommunityUserBan::ban(&conn, &community_user_ban_form).unwrap(); + let inserted_community_user_ban = + CommunityUserBan::ban(&conn, &community_user_ban_form).unwrap(); let expected_community_user_ban = CommunityUserBan { id: inserted_community_user_ban.id, community_id: inserted_community.id, user_id: inserted_user.id, - published: inserted_community_user_ban.published + published: inserted_community_user_ban.published, }; let read_community = Community::read(&conn, inserted_community.id).unwrap(); - let updated_community = Community::update(&conn, inserted_community.id, &new_community).unwrap(); + let updated_community = + Community::update(&conn, inserted_community.id, &new_community).unwrap(); let ignored_community = CommunityFollower::ignore(&conn, &community_follower_form).unwrap(); let left_community = CommunityModerator::leave(&conn, &community_user_form).unwrap(); let unban = CommunityUserBan::unban(&conn, &community_user_ban_form).unwrap(); @@ -337,6 +360,5 @@ mod tests { assert_eq!(1, unban); // assert_eq!(2, loaded_count); assert_eq!(1, num_deleted); - } } diff --git a/server/src/db/community_view.rs b/server/src/db/community_view.rs index a12d6bf96..dabf01bcb 100644 --- a/server/src/db/community_view.rs +++ b/server/src/db/community_view.rs @@ -73,8 +73,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="community_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "community_view"] pub struct CommunityView { pub id: i32, pub name: String, @@ -98,7 +100,11 @@ pub struct CommunityView { } impl CommunityView { - pub fn read(conn: &PgConnection, from_community_id: i32, from_user_id: Option) -> Result { + pub fn read( + conn: &PgConnection, + from_community_id: i32, + from_user_id: Option, + ) -> Result { use super::community_view::community_view::dsl::*; let mut query = community_view.into_boxed(); @@ -116,14 +122,14 @@ impl CommunityView { } pub fn list( - conn: &PgConnection, - sort: &SortType, - from_user_id: Option, + conn: &PgConnection, + sort: &SortType, + from_user_id: Option, show_nsfw: bool, search_term: Option, page: Option, limit: Option, - ) -> Result, Error> { + ) -> Result, Error> { use super::community_view::community_view::dsl::*; let mut query = community_view.into_boxed(); @@ -135,17 +141,26 @@ impl CommunityView { // The view lets you pass a null user_id, if you're not logged in match sort { - SortType::Hot => query = query.order_by(hot_rank.desc()) - .then_order_by(number_of_subscribers.desc()) - .filter(user_id.is_null()), - SortType::New => query = query.order_by(published.desc()).filter(user_id.is_null()), - SortType::TopAll => { - match from_user_id { - Some(from_user_id) => query = query.filter(user_id.eq(from_user_id)).order_by((subscribed.asc(), number_of_subscribers.desc())), - None => query = query.order_by(number_of_subscribers.desc()).filter(user_id.is_null()) - } + SortType::Hot => { + query = query + .order_by(hot_rank.desc()) + .then_order_by(number_of_subscribers.desc()) + .filter(user_id.is_null()) + } + SortType::New => query = query.order_by(published.desc()).filter(user_id.is_null()), + SortType::TopAll => match from_user_id { + Some(from_user_id) => { + query = query + .filter(user_id.eq(from_user_id)) + .order_by((subscribed.asc(), number_of_subscribers.desc())) } - _ => () + None => { + query = query + .order_by(number_of_subscribers.desc()) + .filter(user_id.is_null()) + } + }, + _ => (), }; if !show_nsfw { @@ -157,81 +172,101 @@ impl CommunityView { .offset(offset) .filter(removed.eq(false)) .filter(deleted.eq(false)) - .load::(conn) + .load::(conn) } } - -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="community_moderator_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "community_moderator_view"] pub struct CommunityModeratorView { pub id: i32, pub community_id: i32, pub user_id: i32, pub published: chrono::NaiveDateTime, - pub user_name : String, + pub user_name: String, pub community_name: String, } impl CommunityModeratorView { pub fn for_community(conn: &PgConnection, from_community_id: i32) -> Result, Error> { use super::community_view::community_moderator_view::dsl::*; - community_moderator_view.filter(community_id.eq(from_community_id)).load::(conn) + community_moderator_view + .filter(community_id.eq(from_community_id)) + .load::(conn) } pub fn for_user(conn: &PgConnection, from_user_id: i32) -> Result, Error> { use super::community_view::community_moderator_view::dsl::*; - community_moderator_view.filter(user_id.eq(from_user_id)).load::(conn) + community_moderator_view + .filter(user_id.eq(from_user_id)) + .load::(conn) } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="community_follower_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "community_follower_view"] pub struct CommunityFollowerView { pub id: i32, pub community_id: i32, pub user_id: i32, pub published: chrono::NaiveDateTime, - pub user_name : String, + pub user_name: String, pub community_name: String, } impl CommunityFollowerView { pub fn for_community(conn: &PgConnection, from_community_id: i32) -> Result, Error> { use super::community_view::community_follower_view::dsl::*; - community_follower_view.filter(community_id.eq(from_community_id)).load::(conn) + community_follower_view + .filter(community_id.eq(from_community_id)) + .load::(conn) } pub fn for_user(conn: &PgConnection, from_user_id: i32) -> Result, Error> { use super::community_view::community_follower_view::dsl::*; - community_follower_view.filter(user_id.eq(from_user_id)).load::(conn) + community_follower_view + .filter(user_id.eq(from_user_id)) + .load::(conn) } } - -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="community_user_ban_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "community_user_ban_view"] pub struct CommunityUserBanView { pub id: i32, pub community_id: i32, pub user_id: i32, pub published: chrono::NaiveDateTime, - pub user_name : String, + pub user_name: String, pub community_name: String, } impl CommunityUserBanView { pub fn for_community(conn: &PgConnection, from_community_id: i32) -> Result, Error> { use super::community_view::community_user_ban_view::dsl::*; - community_user_ban_view.filter(community_id.eq(from_community_id)).load::(conn) + community_user_ban_view + .filter(community_id.eq(from_community_id)) + .load::(conn) } pub fn for_user(conn: &PgConnection, from_user_id: i32) -> Result, Error> { use super::community_view::community_user_ban_view::dsl::*; - community_user_ban_view.filter(user_id.eq(from_user_id)).load::(conn) + community_user_ban_view + .filter(user_id.eq(from_user_id)) + .load::(conn) } - pub fn get(conn: &PgConnection, from_user_id: i32, from_community_id: i32) -> Result { + pub fn get( + conn: &PgConnection, + from_user_id: i32, + from_community_id: i32, + ) -> Result { use super::community_view::community_user_ban_view::dsl::*; community_user_ban_view .filter(user_id.eq(from_user_id)) @@ -240,9 +275,10 @@ impl CommunityUserBanView { } } - -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="site_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "site_view"] pub struct SiteView { pub id: i32, pub name: String, diff --git a/server/src/db/mod.rs b/server/src/db/mod.rs index 3de0abb46..51a591394 100644 --- a/server/src/db/mod.rs +++ b/server/src/db/mod.rs @@ -1,73 +1,117 @@ -use diesel::*; +use crate::Settings; use diesel::dsl::*; use diesel::result::Error; -use crate::{Settings}; +use diesel::*; use serde::{Deserialize, Serialize}; -pub mod user; -pub mod community; -pub mod post; -pub mod comment; -pub mod post_view; -pub mod comment_view; pub mod category; +pub mod comment; +pub mod comment_view; +pub mod community; pub mod community_view; -pub mod user_view; pub mod moderator; pub mod moderator_views; +pub mod post; +pub mod post_view; +pub mod user; +pub mod user_view; pub trait Crud { - fn create(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn read(conn: &PgConnection, id: i32) -> Result where Self: Sized; - fn update(conn: &PgConnection, id: i32, form: &T) -> Result where Self: Sized; - fn delete(conn: &PgConnection, id: i32) -> Result where Self: Sized; + fn create(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn read(conn: &PgConnection, id: i32) -> Result + where + Self: Sized; + fn update(conn: &PgConnection, id: i32, form: &T) -> Result + where + Self: Sized; + fn delete(conn: &PgConnection, id: i32) -> Result + where + Self: Sized; } pub trait Followable { - fn follow(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn ignore(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn follow(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn ignore(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub trait Joinable { - fn join(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn leave(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn join(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn leave(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub trait Likeable { - fn read(conn: &PgConnection, id: i32) -> Result, Error> where Self: Sized; - fn like(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn remove(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn read(conn: &PgConnection, id: i32) -> Result, Error> + where + Self: Sized; + fn like(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn remove(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub trait Bannable { - fn ban(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn unban(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn ban(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn unban(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub trait Saveable { - fn save(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn unsave(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn save(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn unsave(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub trait Readable { - fn mark_as_read(conn: &PgConnection, form: &T) -> Result where Self: Sized; - fn mark_as_unread(conn: &PgConnection, form: &T) -> Result where Self: Sized; + fn mark_as_read(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; + fn mark_as_unread(conn: &PgConnection, form: &T) -> Result + where + Self: Sized; } pub fn establish_connection() -> PgConnection { let db_url = Settings::get().db_url; - PgConnection::establish(&db_url) - .expect(&format!("Error connecting to {}", db_url)) + PgConnection::establish(&db_url).expect(&format!("Error connecting to {}", db_url)) } -#[derive(EnumString,ToString,Debug, Serialize, Deserialize)] +#[derive(EnumString, ToString, Debug, Serialize, Deserialize)] pub enum SortType { - Hot, New, TopDay, TopWeek, TopMonth, TopYear, TopAll + Hot, + New, + TopDay, + TopWeek, + TopMonth, + TopYear, + TopAll, } -#[derive(EnumString,ToString,Debug, Serialize, Deserialize)] +#[derive(EnumString, ToString, Debug, Serialize, Deserialize)] pub enum SearchType { - All, Comments, Posts, Communities, Users, Url + All, + Comments, + Posts, + Communities, + Users, + Url, } pub fn fuzzy_search(q: &str) -> String { @@ -76,17 +120,17 @@ pub fn fuzzy_search(q: &str) -> String { } pub fn limit_and_offset(page: Option, limit: Option) -> (i64, i64) { - let page = page.unwrap_or(1); - let limit = limit.unwrap_or(10); - let offset = limit * (page - 1); - (limit, offset) + let page = page.unwrap_or(1); + let limit = limit.unwrap_or(10); + let offset = limit * (page - 1); + (limit, offset) } #[cfg(test)] mod tests { use super::fuzzy_search; - #[test] fn test_fuzzy_search() { + #[test] + fn test_fuzzy_search() { let test = "This is a fuzzy search"; assert_eq!(fuzzy_search(test), "%This%is%a%fuzzy%search%".to_string()); } } - diff --git a/server/src/db/moderator.rs b/server/src/db/moderator.rs index fec46aa18..d1e5cb725 100644 --- a/server/src/db/moderator.rs +++ b/server/src/db/moderator.rs @@ -1,8 +1,11 @@ -use crate::schema::{mod_remove_post, mod_lock_post, mod_remove_comment, mod_remove_community, mod_ban_from_community, mod_ban, mod_add_community, mod_add}; use super::*; +use crate::schema::{ + mod_add, mod_add_community, mod_ban, mod_ban_from_community, mod_lock_post, mod_remove_comment, + mod_remove_community, mod_remove_post, +}; #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_remove_post"] +#[table_name = "mod_remove_post"] pub struct ModRemovePost { pub id: i32, pub mod_user_id: i32, @@ -13,7 +16,7 @@ pub struct ModRemovePost { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_remove_post"] +#[table_name = "mod_remove_post"] pub struct ModRemovePostForm { pub mod_user_id: i32, pub post_id: i32, @@ -24,21 +27,19 @@ pub struct ModRemovePostForm { impl Crud for ModRemovePost { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_post::dsl::*; - mod_remove_post.find(from_id) - .first::(conn) + mod_remove_post.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_post::dsl::*; - diesel::delete(mod_remove_post.find(from_id)) - .execute(conn) + diesel::delete(mod_remove_post.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModRemovePostForm) -> Result { use crate::schema::mod_remove_post::dsl::*; - insert_into(mod_remove_post) - .values(form) - .get_result::(conn) + insert_into(mod_remove_post) + .values(form) + .get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModRemovePostForm) -> Result { @@ -49,10 +50,8 @@ impl Crud for ModRemovePost { } } - - #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_lock_post"] +#[table_name = "mod_lock_post"] pub struct ModLockPost { pub id: i32, pub mod_user_id: i32, @@ -62,7 +61,7 @@ pub struct ModLockPost { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_lock_post"] +#[table_name = "mod_lock_post"] pub struct ModLockPostForm { pub mod_user_id: i32, pub post_id: i32, @@ -72,21 +71,19 @@ pub struct ModLockPostForm { impl Crud for ModLockPost { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_lock_post::dsl::*; - mod_lock_post.find(from_id) - .first::(conn) + mod_lock_post.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_lock_post::dsl::*; - diesel::delete(mod_lock_post.find(from_id)) - .execute(conn) + diesel::delete(mod_lock_post.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModLockPostForm) -> Result { use crate::schema::mod_lock_post::dsl::*; - insert_into(mod_lock_post) - .values(form) - .get_result::(conn) + insert_into(mod_lock_post) + .values(form) + .get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModLockPostForm) -> Result { @@ -98,7 +95,7 @@ impl Crud for ModLockPost { } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_remove_comment"] +#[table_name = "mod_remove_comment"] pub struct ModRemoveComment { pub id: i32, pub mod_user_id: i32, @@ -109,7 +106,7 @@ pub struct ModRemoveComment { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_remove_comment"] +#[table_name = "mod_remove_comment"] pub struct ModRemoveCommentForm { pub mod_user_id: i32, pub comment_id: i32, @@ -120,21 +117,19 @@ pub struct ModRemoveCommentForm { impl Crud for ModRemoveComment { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_comment::dsl::*; - mod_remove_comment.find(from_id) - .first::(conn) + mod_remove_comment.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_comment::dsl::*; - diesel::delete(mod_remove_comment.find(from_id)) - .execute(conn) + diesel::delete(mod_remove_comment.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModRemoveCommentForm) -> Result { use crate::schema::mod_remove_comment::dsl::*; - insert_into(mod_remove_comment) - .values(form) - .get_result::(conn) + insert_into(mod_remove_comment) + .values(form) + .get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommentForm) -> Result { @@ -146,7 +141,7 @@ impl Crud for ModRemoveComment { } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_remove_community"] +#[table_name = "mod_remove_community"] pub struct ModRemoveCommunity { pub id: i32, pub mod_user_id: i32, @@ -158,7 +153,7 @@ pub struct ModRemoveCommunity { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_remove_community"] +#[table_name = "mod_remove_community"] pub struct ModRemoveCommunityForm { pub mod_user_id: i32, pub community_id: i32, @@ -170,24 +165,26 @@ pub struct ModRemoveCommunityForm { impl Crud for ModRemoveCommunity { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_community::dsl::*; - mod_remove_community.find(from_id) - .first::(conn) + mod_remove_community.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_remove_community::dsl::*; - diesel::delete(mod_remove_community.find(from_id)) - .execute(conn) + diesel::delete(mod_remove_community.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModRemoveCommunityForm) -> Result { use crate::schema::mod_remove_community::dsl::*; - insert_into(mod_remove_community) - .values(form) - .get_result::(conn) + insert_into(mod_remove_community) + .values(form) + .get_result::(conn) } - fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommunityForm) -> Result { + fn update( + conn: &PgConnection, + from_id: i32, + form: &ModRemoveCommunityForm, + ) -> Result { use crate::schema::mod_remove_community::dsl::*; diesel::update(mod_remove_community.find(from_id)) .set(form) @@ -196,7 +193,7 @@ impl Crud for ModRemoveCommunity { } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_ban_from_community"] +#[table_name = "mod_ban_from_community"] pub struct ModBanFromCommunity { pub id: i32, pub mod_user_id: i32, @@ -209,7 +206,7 @@ pub struct ModBanFromCommunity { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_ban_from_community"] +#[table_name = "mod_ban_from_community"] pub struct ModBanFromCommunityForm { pub mod_user_id: i32, pub other_user_id: i32, @@ -222,24 +219,26 @@ pub struct ModBanFromCommunityForm { impl Crud for ModBanFromCommunity { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_ban_from_community::dsl::*; - mod_ban_from_community.find(from_id) - .first::(conn) + mod_ban_from_community.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_ban_from_community::dsl::*; - diesel::delete(mod_ban_from_community.find(from_id)) - .execute(conn) + diesel::delete(mod_ban_from_community.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModBanFromCommunityForm) -> Result { use crate::schema::mod_ban_from_community::dsl::*; - insert_into(mod_ban_from_community) - .values(form) - .get_result::(conn) + insert_into(mod_ban_from_community) + .values(form) + .get_result::(conn) } - fn update(conn: &PgConnection, from_id: i32, form: &ModBanFromCommunityForm) -> Result { + fn update( + conn: &PgConnection, + from_id: i32, + form: &ModBanFromCommunityForm, + ) -> Result { use crate::schema::mod_ban_from_community::dsl::*; diesel::update(mod_ban_from_community.find(from_id)) .set(form) @@ -247,9 +246,8 @@ impl Crud for ModBanFromCommunity { } } - #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_ban"] +#[table_name = "mod_ban"] pub struct ModBan { pub id: i32, pub mod_user_id: i32, @@ -261,7 +259,7 @@ pub struct ModBan { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_ban"] +#[table_name = "mod_ban"] pub struct ModBanForm { pub mod_user_id: i32, pub other_user_id: i32, @@ -273,21 +271,17 @@ pub struct ModBanForm { impl Crud for ModBan { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_ban::dsl::*; - mod_ban.find(from_id) - .first::(conn) + mod_ban.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_ban::dsl::*; - diesel::delete(mod_ban.find(from_id)) - .execute(conn) + diesel::delete(mod_ban.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModBanForm) -> Result { use crate::schema::mod_ban::dsl::*; - insert_into(mod_ban) - .values(form) - .get_result::(conn) + insert_into(mod_ban).values(form).get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModBanForm) -> Result { @@ -299,7 +293,7 @@ impl Crud for ModBan { } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_add_community"] +#[table_name = "mod_add_community"] pub struct ModAddCommunity { pub id: i32, pub mod_user_id: i32, @@ -310,7 +304,7 @@ pub struct ModAddCommunity { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_add_community"] +#[table_name = "mod_add_community"] pub struct ModAddCommunityForm { pub mod_user_id: i32, pub other_user_id: i32, @@ -321,21 +315,19 @@ pub struct ModAddCommunityForm { impl Crud for ModAddCommunity { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_add_community::dsl::*; - mod_add_community.find(from_id) - .first::(conn) + mod_add_community.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_add_community::dsl::*; - diesel::delete(mod_add_community.find(from_id)) - .execute(conn) + diesel::delete(mod_add_community.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModAddCommunityForm) -> Result { use crate::schema::mod_add_community::dsl::*; - insert_into(mod_add_community) - .values(form) - .get_result::(conn) + insert_into(mod_add_community) + .values(form) + .get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModAddCommunityForm) -> Result { @@ -347,7 +339,7 @@ impl Crud for ModAddCommunity { } #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="mod_add"] +#[table_name = "mod_add"] pub struct ModAdd { pub id: i32, pub mod_user_id: i32, @@ -357,7 +349,7 @@ pub struct ModAdd { } #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)] -#[table_name="mod_add"] +#[table_name = "mod_add"] pub struct ModAddForm { pub mod_user_id: i32, pub other_user_id: i32, @@ -367,21 +359,17 @@ pub struct ModAddForm { impl Crud for ModAdd { fn read(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_add::dsl::*; - mod_add.find(from_id) - .first::(conn) + mod_add.find(from_id).first::(conn) } fn delete(conn: &PgConnection, from_id: i32) -> Result { use crate::schema::mod_add::dsl::*; - diesel::delete(mod_add.find(from_id)) - .execute(conn) + diesel::delete(mod_add.find(from_id)).execute(conn) } fn create(conn: &PgConnection, form: &ModAddForm) -> Result { use crate::schema::mod_add::dsl::*; - insert_into(mod_add) - .values(form) - .get_result::(conn) + insert_into(mod_add).values(form).get_result::(conn) } fn update(conn: &PgConnection, from_id: i32, form: &ModAddForm) -> Result { @@ -394,13 +382,13 @@ impl Crud for ModAdd { #[cfg(test)] mod tests { - use super::*; - use super::super::user::*; - use super::super::post::*; - use super::super::community::*; use super::super::comment::*; + use super::super::community::*; + use super::super::post::*; + use super::super::user::*; + use super::*; // use Crud; - #[test] + #[test] fn test_crud() { let conn = establish_connection(); @@ -445,7 +433,7 @@ mod tests { }; let inserted_community = Community::create(&conn, &new_community).unwrap(); - + let new_post = PostForm { name: "A test post thweep".into(), url: None, @@ -469,7 +457,7 @@ mod tests { deleted: None, read: None, parent_id: None, - updated: None + updated: None, }; let inserted_comment = Comment::create(&conn, &comment_form).unwrap(); @@ -484,7 +472,8 @@ mod tests { removed: None, }; let inserted_mod_remove_post = ModRemovePost::create(&conn, &mod_remove_post_form).unwrap(); - let read_moderator_remove_post = ModRemovePost::read(&conn, inserted_mod_remove_post.id).unwrap(); + let read_moderator_remove_post = + ModRemovePost::read(&conn, inserted_mod_remove_post.id).unwrap(); let expected_moderator_remove_post = ModRemovePost { id: inserted_mod_remove_post.id, post_id: inserted_post.id, @@ -519,8 +508,10 @@ mod tests { reason: None, removed: None, }; - let inserted_mod_remove_comment = ModRemoveComment::create(&conn, &mod_remove_comment_form).unwrap(); - let read_moderator_remove_comment = ModRemoveComment::read(&conn, inserted_mod_remove_comment.id).unwrap(); + let inserted_mod_remove_comment = + ModRemoveComment::create(&conn, &mod_remove_comment_form).unwrap(); + let read_moderator_remove_comment = + ModRemoveComment::read(&conn, inserted_mod_remove_comment.id).unwrap(); let expected_moderator_remove_comment = ModRemoveComment { id: inserted_mod_remove_comment.id, comment_id: inserted_comment.id, @@ -539,8 +530,10 @@ mod tests { removed: None, expires: None, }; - let inserted_mod_remove_community = ModRemoveCommunity::create(&conn, &mod_remove_community_form).unwrap(); - let read_moderator_remove_community = ModRemoveCommunity::read(&conn, inserted_mod_remove_community.id).unwrap(); + let inserted_mod_remove_community = + ModRemoveCommunity::create(&conn, &mod_remove_community_form).unwrap(); + let read_moderator_remove_community = + ModRemoveCommunity::read(&conn, inserted_mod_remove_community.id).unwrap(); let expected_moderator_remove_community = ModRemoveCommunity { id: inserted_mod_remove_community.id, community_id: inserted_community.id, @@ -561,8 +554,10 @@ mod tests { banned: None, expires: None, }; - let inserted_mod_ban_from_community = ModBanFromCommunity::create(&conn, &mod_ban_from_community_form).unwrap(); - let read_moderator_ban_from_community = ModBanFromCommunity::read(&conn, inserted_mod_ban_from_community.id).unwrap(); + let inserted_mod_ban_from_community = + ModBanFromCommunity::create(&conn, &mod_ban_from_community_form).unwrap(); + let read_moderator_ban_from_community = + ModBanFromCommunity::read(&conn, inserted_mod_ban_from_community.id).unwrap(); let expected_moderator_ban_from_community = ModBanFromCommunity { id: inserted_mod_ban_from_community.id, community_id: inserted_community.id, @@ -603,8 +598,10 @@ mod tests { community_id: inserted_community.id, removed: None, }; - let inserted_mod_add_community = ModAddCommunity::create(&conn, &mod_add_community_form).unwrap(); - let read_moderator_add_community = ModAddCommunity::read(&conn, inserted_mod_add_community.id).unwrap(); + let inserted_mod_add_community = + ModAddCommunity::create(&conn, &mod_add_community_form).unwrap(); + let read_moderator_add_community = + ModAddCommunity::read(&conn, inserted_mod_add_community.id).unwrap(); let expected_moderator_add_community = ModAddCommunity { id: inserted_mod_add_community.id, community_id: inserted_community.id, @@ -648,11 +645,23 @@ mod tests { assert_eq!(expected_moderator_remove_post, read_moderator_remove_post); assert_eq!(expected_moderator_lock_post, read_moderator_lock_post); - assert_eq!(expected_moderator_remove_comment, read_moderator_remove_comment); - assert_eq!(expected_moderator_remove_community, read_moderator_remove_community); - assert_eq!(expected_moderator_ban_from_community, read_moderator_ban_from_community); + assert_eq!( + expected_moderator_remove_comment, + read_moderator_remove_comment + ); + assert_eq!( + expected_moderator_remove_community, + read_moderator_remove_community + ); + assert_eq!( + expected_moderator_ban_from_community, + read_moderator_ban_from_community + ); assert_eq!(expected_moderator_ban, read_moderator_ban); - assert_eq!(expected_moderator_add_community, read_moderator_add_community); + assert_eq!( + expected_moderator_add_community, + read_moderator_add_community + ); assert_eq!(expected_moderator_add, read_moderator_add); } } diff --git a/server/src/db/moderator_views.rs b/server/src/db/moderator_views.rs index 3c8e2e9a6..b8143b504 100644 --- a/server/src/db/moderator_views.rs +++ b/server/src/db/moderator_views.rs @@ -15,8 +15,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_remove_post_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_remove_post_view"] pub struct ModRemovePostView { pub id: i32, pub mod_user_id: i32, @@ -31,12 +33,13 @@ pub struct ModRemovePostView { } impl ModRemovePostView { - pub fn list(conn: &PgConnection, - from_community_id: Option, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_community_id: Option, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_remove_post_view::dsl::*; let mut query = mod_remove_post_view.into_boxed(); @@ -50,7 +53,11 @@ impl ModRemovePostView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -68,9 +75,10 @@ table! { } } - -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_lock_post_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_lock_post_view"] pub struct ModLockPostView { pub id: i32, pub mod_user_id: i32, @@ -84,12 +92,13 @@ pub struct ModLockPostView { } impl ModLockPostView { - pub fn list(conn: &PgConnection, - from_community_id: Option, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_community_id: Option, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_lock_post_view::dsl::*; let mut query = mod_lock_post_view.into_boxed(); @@ -103,7 +112,11 @@ impl ModLockPostView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -126,8 +139,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_remove_comment_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_remove_comment_view"] pub struct ModRemoveCommentView { pub id: i32, pub mod_user_id: i32, @@ -146,12 +161,13 @@ pub struct ModRemoveCommentView { } impl ModRemoveCommentView { - pub fn list(conn: &PgConnection, - from_community_id: Option, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_community_id: Option, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_remove_comment_view::dsl::*; let mut query = mod_remove_comment_view.into_boxed(); @@ -165,7 +181,11 @@ impl ModRemoveCommentView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -183,8 +203,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_remove_community_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_remove_community_view"] pub struct ModRemoveCommunityView { pub id: i32, pub mod_user_id: i32, @@ -198,11 +220,12 @@ pub struct ModRemoveCommunityView { } impl ModRemoveCommunityView { - pub fn list(conn: &PgConnection, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_remove_community_view::dsl::*; let mut query = mod_remove_community_view.into_boxed(); @@ -212,11 +235,14 @@ impl ModRemoveCommunityView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } - table! { mod_ban_from_community_view (id) { id -> Int4, @@ -233,8 +259,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_ban_from_community_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_ban_from_community_view"] pub struct ModBanFromCommunityView { pub id: i32, pub mod_user_id: i32, @@ -250,12 +278,13 @@ pub struct ModBanFromCommunityView { } impl ModBanFromCommunityView { - pub fn list(conn: &PgConnection, - from_community_id: Option, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_community_id: Option, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_ban_from_community_view::dsl::*; let mut query = mod_ban_from_community_view.into_boxed(); @@ -269,7 +298,11 @@ impl ModBanFromCommunityView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -287,8 +320,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_ban_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_ban_view"] pub struct ModBanView { pub id: i32, pub mod_user_id: i32, @@ -302,11 +337,12 @@ pub struct ModBanView { } impl ModBanView { - pub fn list(conn: &PgConnection, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_ban_view::dsl::*; let mut query = mod_ban_view.into_boxed(); @@ -316,7 +352,11 @@ impl ModBanView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -334,8 +374,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_add_community_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_add_community_view"] pub struct ModAddCommunityView { pub id: i32, pub mod_user_id: i32, @@ -349,12 +391,13 @@ pub struct ModAddCommunityView { } impl ModAddCommunityView { - pub fn list(conn: &PgConnection, - from_community_id: Option, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_community_id: Option, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_add_community_view::dsl::*; let mut query = mod_add_community_view.into_boxed(); @@ -368,7 +411,11 @@ impl ModAddCommunityView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } @@ -384,8 +431,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="mod_add_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "mod_add_view"] pub struct ModAddView { pub id: i32, pub mod_user_id: i32, @@ -397,11 +446,12 @@ pub struct ModAddView { } impl ModAddView { - pub fn list(conn: &PgConnection, - from_mod_user_id: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + from_mod_user_id: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::moderator_views::mod_add_view::dsl::*; let mut query = mod_add_view.into_boxed(); @@ -411,6 +461,10 @@ impl ModAddView { query = query.filter(mod_user_id.eq(from_mod_user_id)); }; - query.limit(limit).offset(offset).order_by(when_.desc()).load::(conn) + query + .limit(limit) + .offset(offset) + .order_by(when_.desc()) + .load::(conn) } } diff --git a/server/src/db/post.rs b/server/src/db/post.rs index 12ea10818..54cc236b5 100644 --- a/server/src/db/post.rs +++ b/server/src/db/post.rs @@ -1,8 +1,8 @@ -use crate::schema::{post, post_like, post_saved, post_read}; use super::*; +use crate::schema::{post, post_like, post_read, post_saved}; #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)] -#[table_name="post"] +#[table_name = "post"] pub struct Post { pub id: i32, pub name: String, @@ -19,7 +19,7 @@ pub struct Post { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="post"] +#[table_name = "post"] pub struct PostForm { pub name: String, pub url: Option, @@ -36,21 +36,17 @@ pub struct PostForm { impl Crud for Post { fn read(conn: &PgConnection, post_id: i32) -> Result { use crate::schema::post::dsl::*; - post.find(post_id) - .first::(conn) + post.find(post_id).first::(conn) } fn delete(conn: &PgConnection, post_id: i32) -> Result { use crate::schema::post::dsl::*; - diesel::delete(post.find(post_id)) - .execute(conn) + diesel::delete(post.find(post_id)).execute(conn) } fn create(conn: &PgConnection, new_post: &PostForm) -> Result { use crate::schema::post::dsl::*; - insert_into(post) - .values(new_post) - .get_result::(conn) + insert_into(post).values(new_post).get_result::(conn) } fn update(conn: &PgConnection, post_id: i32, new_post: &PostForm) -> Result { @@ -73,19 +69,19 @@ pub struct PostLike { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="post_like"] +#[table_name = "post_like"] pub struct PostLikeForm { pub post_id: i32, pub user_id: i32, - pub score: i16 + pub score: i16, } -impl Likeable for PostLike { +impl Likeable for PostLike { fn read(conn: &PgConnection, post_id_from: i32) -> Result, Error> { use crate::schema::post_like::dsl::*; post_like .filter(post_id.eq(post_id_from)) - .load::(conn) + .load::(conn) } fn like(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result { use crate::schema::post_like::dsl::*; @@ -95,10 +91,12 @@ impl Likeable for PostLike { } fn remove(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result { use crate::schema::post_like::dsl::*; - diesel::delete(post_like - .filter(post_id.eq(post_like_form.post_id)) - .filter(user_id.eq(post_like_form.user_id))) - .execute(conn) + diesel::delete( + post_like + .filter(post_id.eq(post_like_form.post_id)) + .filter(user_id.eq(post_like_form.user_id)), + ) + .execute(conn) } } @@ -113,13 +111,13 @@ pub struct PostSaved { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="post_saved"] +#[table_name = "post_saved"] pub struct PostSavedForm { pub post_id: i32, pub user_id: i32, } -impl Saveable for PostSaved { +impl Saveable for PostSaved { fn save(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result { use crate::schema::post_saved::dsl::*; insert_into(post_saved) @@ -128,10 +126,12 @@ impl Saveable for PostSaved { } fn unsave(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result { use crate::schema::post_saved::dsl::*; - diesel::delete(post_saved - .filter(post_id.eq(post_saved_form.post_id)) - .filter(user_id.eq(post_saved_form.user_id))) - .execute(conn) + diesel::delete( + post_saved + .filter(post_id.eq(post_saved_form.post_id)) + .filter(user_id.eq(post_saved_form.user_id)), + ) + .execute(conn) } } @@ -146,13 +146,13 @@ pub struct PostRead { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="post_read"] +#[table_name = "post_read"] pub struct PostReadForm { pub post_id: i32, pub user_id: i32, } -impl Readable for PostRead { +impl Readable for PostRead { fn mark_as_read(conn: &PgConnection, post_read_form: &PostReadForm) -> Result { use crate::schema::post_read::dsl::*; insert_into(post_read) @@ -161,19 +161,21 @@ impl Readable for PostRead { } fn mark_as_unread(conn: &PgConnection, post_read_form: &PostReadForm) -> Result { use crate::schema::post_read::dsl::*; - diesel::delete(post_read - .filter(post_id.eq(post_read_form.post_id)) - .filter(user_id.eq(post_read_form.user_id))) - .execute(conn) + diesel::delete( + post_read + .filter(post_id.eq(post_read_form.post_id)) + .filter(user_id.eq(post_read_form.user_id)), + ) + .execute(conn) } } #[cfg(test)] mod tests { - use super::*; use super::super::community::*; use super::super::user::*; - #[test] + use super::*; + #[test] fn test_crud() { let conn = establish_connection(); @@ -204,7 +206,7 @@ mod tests { }; let inserted_community = Community::create(&conn, &new_community).unwrap(); - + let new_post = PostForm { name: "A test post".into(), url: None, @@ -215,7 +217,7 @@ mod tests { deleted: None, locked: None, nsfw: false, - updated: None + updated: None, }; let inserted_post = Post::create(&conn, &new_post).unwrap(); @@ -232,14 +234,14 @@ mod tests { locked: false, nsfw: false, deleted: false, - updated: None + updated: None, }; // Post Like let post_like_form = PostLikeForm { post_id: inserted_post.id, user_id: inserted_user.id, - score: 1 + score: 1, }; let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap(); @@ -249,7 +251,7 @@ mod tests { post_id: inserted_post.id, user_id: inserted_user.id, published: inserted_post_like.published, - score: 1 + score: 1, }; // Post Save @@ -266,7 +268,7 @@ mod tests { user_id: inserted_user.id, published: inserted_post_saved.published, }; - + // Post Read let post_read_form = PostReadForm { post_id: inserted_post.id, @@ -281,7 +283,7 @@ mod tests { user_id: inserted_user.id, published: inserted_post_read.published, }; - + let read_post = Post::read(&conn, inserted_post.id).unwrap(); let updated_post = Post::update(&conn, inserted_post.id, &new_post).unwrap(); let like_removed = PostLike::remove(&conn, &post_like_form).unwrap(); @@ -301,6 +303,5 @@ mod tests { assert_eq!(1, saved_removed); assert_eq!(1, read_removed); assert_eq!(1, num_deleted); - } } diff --git a/server/src/db/post_view.rs b/server/src/db/post_view.rs index a3d327dc7..2008d16f1 100644 --- a/server/src/db/post_view.rs +++ b/server/src/db/post_view.rs @@ -1,8 +1,10 @@ use super::*; -#[derive(EnumString,ToString,Debug, Serialize, Deserialize)] +#[derive(EnumString, ToString, Debug, Serialize, Deserialize)] pub enum PostListingType { - All, Subscribed, Community + All, + Subscribed, + Community, } // The faked schema since diesel doesn't do views @@ -40,9 +42,10 @@ table! { } } - -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="post_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "post_view"] pub struct PostView { pub id: i32, pub name: String, @@ -77,20 +80,20 @@ pub struct PostView { impl PostView { pub fn list( - conn: &PgConnection, - type_: PostListingType, - sort: &SortType, - for_community_id: Option, - for_creator_id: Option, + conn: &PgConnection, + type_: PostListingType, + sort: &SortType, + for_community_id: Option, + for_creator_id: Option, search_term: Option, url_search: Option, - my_user_id: Option, + my_user_id: Option, show_nsfw: bool, saved_only: bool, unread_only: bool, page: Option, limit: Option, - ) -> Result, Error> { + ) -> Result, Error> { use super::post_view::post_view::dsl::*; let (limit, offset) = limit_and_offset(page, limit); @@ -123,9 +126,9 @@ impl PostView { }; match type_ { - PostListingType::Subscribed => { + PostListingType::Subscribed => { query = query.filter(subscribed.eq(true)); - }, + } _ => {} }; @@ -143,22 +146,23 @@ impl PostView { }; query = match sort { - SortType::Hot => query.order_by(hot_rank.desc()) + SortType::Hot => query + .order_by(hot_rank.desc()) .then_order_by(published.desc()), SortType::New => query.order_by(published.desc()), SortType::TopAll => query.order_by(score.desc()), SortType::TopYear => query .filter(published.gt(now - 1.years())) .order_by(score.desc()), - SortType::TopMonth => query - .filter(published.gt(now - 1.months())) - .order_by(score.desc()), - SortType::TopWeek => query - .filter(published.gt(now - 1.weeks())) - .order_by(score.desc()), - SortType::TopDay => query - .filter(published.gt(now - 1.days())) - .order_by(score.desc()) + SortType::TopMonth => query + .filter(published.gt(now - 1.months())) + .order_by(score.desc()), + SortType::TopWeek => query + .filter(published.gt(now - 1.weeks())) + .order_by(score.desc()), + SortType::TopDay => query + .filter(published.gt(now - 1.days())) + .order_by(score.desc()), }; query = query @@ -169,12 +173,14 @@ impl PostView { .filter(community_removed.eq(false)) .filter(community_deleted.eq(false)); - query.load::(conn) + query.load::(conn) } - - pub fn read(conn: &PgConnection, from_post_id: i32, my_user_id: Option) -> Result { - + pub fn read( + conn: &PgConnection, + from_post_id: i32, + my_user_id: Option, + ) -> Result { use super::post_view::post_view::dsl::*; use diesel::prelude::*; @@ -192,14 +198,12 @@ impl PostView { } } - - #[cfg(test)] mod tests { - use super::*; use super::super::community::*; - use super::super::user::*; use super::super::post::*; + use super::super::user::*; + use super::*; #[test] fn test_crud() { let conn = establish_connection(); @@ -254,7 +258,7 @@ mod tests { let post_like_form = PostLikeForm { post_id: inserted_post.id, user_id: inserted_user.id, - score: 1 + score: 1, }; let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap(); @@ -264,13 +268,13 @@ mod tests { post_id: inserted_post.id, user_id: inserted_user.id, published: inserted_post_like.published, - score: 1 + score: 1, }; let post_like_form = PostLikeForm { post_id: inserted_post.id, user_id: inserted_user.id, - score: 1 + score: 1, }; // the non user version @@ -338,37 +342,41 @@ mod tests { nsfw: false, }; - let read_post_listings_with_user = PostView::list( - &conn, - PostListingType::Community, - &SortType::New, - Some(inserted_community.id), - None, + &conn, + PostListingType::Community, + &SortType::New, + Some(inserted_community.id), None, None, - Some(inserted_user.id), + None, + Some(inserted_user.id), false, - false, - false, - None, - None).unwrap(); + false, + false, + None, + None, + ) + .unwrap(); let read_post_listings_no_user = PostView::list( - &conn, - PostListingType::Community, - &SortType::New, - Some(inserted_community.id), - None, - None, + &conn, + PostListingType::Community, + &SortType::New, + Some(inserted_community.id), + None, + None, None, None, false, - false, - false, - None, - None).unwrap(); + false, + false, + None, + None, + ) + .unwrap(); let read_post_listing_no_user = PostView::read(&conn, inserted_post.id, None).unwrap(); - let read_post_listing_with_user = PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap(); + let read_post_listing_with_user = + PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap(); let like_removed = PostLike::remove(&conn, &post_like_form).unwrap(); let num_deleted = Post::delete(&conn, inserted_post.id).unwrap(); @@ -376,7 +384,10 @@ mod tests { User_::delete(&conn, inserted_user.id).unwrap(); // The with user - assert_eq!(expected_post_listing_with_user, read_post_listings_with_user[0]); + assert_eq!( + expected_post_listing_with_user, + read_post_listings_with_user[0] + ); assert_eq!(expected_post_listing_with_user, read_post_listing_with_user); assert_eq!(1, read_post_listings_with_user.len()); diff --git a/server/src/db/user.rs b/server/src/db/user.rs index b794524cb..0c083296f 100644 --- a/server/src/db/user.rs +++ b/server/src/db/user.rs @@ -1,12 +1,12 @@ +use super::*; use crate::schema::user_; use crate::schema::user_::dsl::*; -use super::*; -use crate::{Settings, is_email_regex}; -use jsonwebtoken::{encode, decode, Header, Validation, TokenData}; -use bcrypt::{DEFAULT_COST, hash}; +use crate::{is_email_regex, Settings}; +use bcrypt::{hash, DEFAULT_COST}; +use jsonwebtoken::{decode, encode, Header, TokenData, Validation}; #[derive(Queryable, Identifiable, PartialEq, Debug)] -#[table_name="user_"] +#[table_name = "user_"] pub struct User_ { pub id: i32, pub name: String, @@ -23,33 +23,29 @@ pub struct User_ { } #[derive(Insertable, AsChangeset, Clone)] -#[table_name="user_"] +#[table_name = "user_"] pub struct UserForm { - pub name: String, - pub fedi_name: String, - pub preferred_username: Option, - pub password_encrypted: String, - pub admin: bool, - pub banned: bool, - pub email: Option, - pub updated: Option, - pub show_nsfw: bool, + pub name: String, + pub fedi_name: String, + pub preferred_username: Option, + pub password_encrypted: String, + pub admin: bool, + pub banned: bool, + pub email: Option, + pub updated: Option, + pub show_nsfw: bool, } impl Crud for User_ { fn read(conn: &PgConnection, user_id: i32) -> Result { use crate::schema::user_::dsl::*; - user_.find(user_id) - .first::(conn) + user_.find(user_id).first::(conn) } fn delete(conn: &PgConnection, user_id: i32) -> Result { - diesel::delete(user_.find(user_id)) - .execute(conn) + diesel::delete(user_.find(user_id)).execute(conn) } fn create(conn: &PgConnection, form: &UserForm) -> Result { - insert_into(user_) - .values(form) - .get_result::(conn) + insert_into(user_).values(form).get_result::(conn) } fn update(conn: &PgConnection, user_id: i32, form: &UserForm) -> Result { diesel::update(user_.find(user_id)) @@ -61,16 +57,14 @@ impl Crud for User_ { impl User_ { pub fn register(conn: &PgConnection, form: &UserForm) -> Result { let mut edited_user = form.clone(); - let password_hash = hash(&form.password_encrypted, DEFAULT_COST) - .expect("Couldn't hash password"); + let password_hash = + hash(&form.password_encrypted, DEFAULT_COST).expect("Couldn't hash password"); edited_user.password_encrypted = password_hash; Self::create(&conn, &edited_user) - } pub fn read_from_name(conn: &PgConnection, from_user_name: String) -> Result { - user_.filter(name.eq(from_user_name)) - .first::(conn) + user_.filter(name.eq(from_user_name)).first::(conn) } } @@ -101,15 +95,25 @@ impl User_ { iss: self.fedi_name.to_owned(), show_nsfw: self.show_nsfw, }; - encode(&Header::default(), &my_claims, Settings::get().jwt_secret.as_ref()).unwrap() + encode( + &Header::default(), + &my_claims, + Settings::get().jwt_secret.as_ref(), + ) + .unwrap() } - pub fn find_by_email_or_username(conn: &PgConnection, username_or_email: &str) -> Result { + pub fn find_by_email_or_username( + conn: &PgConnection, + username_or_email: &str, + ) -> Result { if is_email_regex(username_or_email) { - user_.filter(email.eq(username_or_email)) + user_ + .filter(email.eq(username_or_email)) .first::(conn) } else { - user_.filter(name.eq(username_or_email)) + user_ + .filter(name.eq(username_or_email)) .first::(conn) } } @@ -118,17 +122,15 @@ impl User_ { let claims: Claims = Claims::decode(&jwt).expect("Invalid token").claims; Self::read(&conn, claims.id) } - } - #[cfg(test)] mod tests { use super::*; - #[test] + #[test] fn test_crud() { let conn = establish_connection(); - + let new_user = UserForm { name: "thommy".into(), fedi_name: "rrf".into(), @@ -157,7 +159,7 @@ mod tests { updated: None, show_nsfw: false, }; - + let read_user = User_::read(&conn, inserted_user.id).unwrap(); let updated_user = User_::update(&conn, inserted_user.id, &new_user).unwrap(); let num_deleted = User_::delete(&conn, inserted_user.id).unwrap(); diff --git a/server/src/db/user_view.rs b/server/src/db/user_view.rs index 897ee23ad..028cd07c1 100644 --- a/server/src/db/user_view.rs +++ b/server/src/db/user_view.rs @@ -15,8 +15,10 @@ table! { } } -#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize,QueryableByName,Clone)] -#[table_name="user_view"] +#[derive( + Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize, QueryableByName, Clone, +)] +#[table_name = "user_view"] pub struct UserView { pub id: i32, pub name: String, @@ -31,13 +33,13 @@ pub struct UserView { } impl UserView { - - pub fn list(conn: &PgConnection, - sort: &SortType, - search_term: Option, - page: Option, - limit: Option, - ) -> Result, Error> { + pub fn list( + conn: &PgConnection, + sort: &SortType, + search_term: Option, + page: Option, + limit: Option, + ) -> Result, Error> { use super::user_view::user_view::dsl::*; let (limit, offset) = limit_and_offset(page, limit); @@ -49,48 +51,43 @@ impl UserView { }; query = match sort { - SortType::Hot => query.order_by(comment_score.desc()) + SortType::Hot => query + .order_by(comment_score.desc()) .then_order_by(published.desc()), SortType::New => query.order_by(published.desc()), SortType::TopAll => query.order_by(comment_score.desc()), SortType::TopYear => query .filter(published.gt(now - 1.years())) .order_by(comment_score.desc()), - SortType::TopMonth => query - .filter(published.gt(now - 1.months())) - .order_by(comment_score.desc()), - SortType::TopWeek => query - .filter(published.gt(now - 1.weeks())) - .order_by(comment_score.desc()), - SortType::TopDay => query - .filter(published.gt(now - 1.days())) - .order_by(comment_score.desc()) + SortType::TopMonth => query + .filter(published.gt(now - 1.months())) + .order_by(comment_score.desc()), + SortType::TopWeek => query + .filter(published.gt(now - 1.weeks())) + .order_by(comment_score.desc()), + SortType::TopDay => query + .filter(published.gt(now - 1.days())) + .order_by(comment_score.desc()), }; - query = query - .limit(limit) - .offset(offset); + query = query.limit(limit).offset(offset); - query.load::(conn) + query.load::(conn) } pub fn read(conn: &PgConnection, from_user_id: i32) -> Result { use super::user_view::user_view::dsl::*; - user_view.find(from_user_id) - .first::(conn) + user_view.find(from_user_id).first::(conn) } pub fn admins(conn: &PgConnection) -> Result, Error> { use super::user_view::user_view::dsl::*; - user_view.filter(admin.eq(true)) - .load::(conn) + user_view.filter(admin.eq(true)).load::(conn) } pub fn banned(conn: &PgConnection) -> Result, Error> { use super::user_view::user_view::dsl::*; - user_view.filter(banned.eq(true)) - .load::(conn) + user_view.filter(banned.eq(true)).load::(conn) } } - diff --git a/server/src/lib.rs b/server/src/lib.rs index 04076771b..7cd20bf82 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -1,30 +1,34 @@ #![recursion_limit = "512"] -#[macro_use] pub extern crate strum_macros; -#[macro_use] pub extern crate lazy_static; -#[macro_use] pub extern crate failure; -#[macro_use] pub extern crate diesel; -pub extern crate dotenv; -pub extern crate chrono; -pub extern crate serde; -pub extern crate serde_json; +#[macro_use] +pub extern crate strum_macros; +#[macro_use] +pub extern crate lazy_static; +#[macro_use] +pub extern crate failure; +#[macro_use] +pub extern crate diesel; pub extern crate actix; pub extern crate actix_web; -pub extern crate rand; -pub extern crate strum; -pub extern crate jsonwebtoken; pub extern crate bcrypt; +pub extern crate chrono; +pub extern crate dotenv; +pub extern crate jsonwebtoken; +pub extern crate rand; pub extern crate regex; +pub extern crate serde; +pub extern crate serde_json; +pub extern crate strum; -pub mod schema; pub mod api; pub mod apub; pub mod db; +pub mod schema; pub mod websocket; -use dotenv::dotenv; -use std::env; -use regex::Regex; use chrono::{DateTime, NaiveDateTime, Utc}; +use dotenv::dotenv; +use regex::Regex; +use std::env; pub struct Settings { db_url: String, @@ -36,10 +40,9 @@ impl Settings { fn get() -> Self { dotenv().ok(); Settings { - db_url: env::var("DATABASE_URL") - .expect("DATABASE_URL must be set"), - hostname: env::var("HOSTNAME").unwrap_or("rrr".to_string()), - jwt_secret: env::var("JWT_SECRET").unwrap_or("changeme".to_string()), + db_url: env::var("DATABASE_URL").expect("DATABASE_URL must be set"), + hostname: env::var("HOSTNAME").unwrap_or("rrr".to_string()), + jwt_secret: env::var("JWT_SECRET").unwrap_or("changeme".to_string()), } } fn api_endpoint(&self) -> String { @@ -55,7 +58,7 @@ pub fn naive_now() -> NaiveDateTime { chrono::prelude::Utc::now().naive_utc() } -pub fn naive_from_unix(time: i64) -> NaiveDateTime { +pub fn naive_from_unix(time: i64) -> NaiveDateTime { NaiveDateTime::from_timestamp(time, 0) } @@ -73,24 +76,30 @@ pub fn has_slurs(test: &str) -> bool { #[cfg(test)] mod tests { - use crate::{Settings, is_email_regex, remove_slurs, has_slurs}; + use crate::{has_slurs, is_email_regex, remove_slurs, Settings}; #[test] fn test_api() { assert_eq!(Settings::get().api_endpoint(), "rrr/api/v1"); } - #[test] fn test_email() { + #[test] + fn test_email() { assert!(is_email_regex("gush@gmail.com")); assert!(!is_email_regex("nada_neutho")); - } + } - #[test] fn test_slur_filter() { + #[test] + fn test_slur_filter() { let test = "coons test dindu ladyboy tranny. This is a bunch of other safe text.".to_string(); let slur_free = "No slurs here"; - assert_eq!(remove_slurs(&test), "*removed* test *removed* *removed* *removed*. This is a bunch of other safe text.".to_string()); + assert_eq!( + remove_slurs(&test), + "*removed* test *removed* *removed* *removed*. This is a bunch of other safe text." + .to_string() + ); assert!(has_slurs(&test)); assert!(!has_slurs(slur_free)); - } + } } diff --git a/server/src/main.rs b/server/src/main.rs index 5e9a1dae8..10f6026bb 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -23,7 +23,7 @@ fn chat_route( req: HttpRequest, stream: web::Payload, chat_server: web::Data>, - ) -> Result { +) -> Result { ws::start( WSSession { cs_addr: chat_server.get_ref().to_owned(), @@ -40,7 +40,7 @@ fn chat_route( }, &req, stream, - ) + ) } struct WSSession { @@ -67,12 +67,13 @@ impl Actor for WSSession { // before processing any other events. // across all routes within application let addr = ctx.address(); - self.cs_addr + self + .cs_addr .send(Connect { addr: addr.recipient(), ip: self.ip.to_owned(), }) - .into_actor(self) + .into_actor(self) .then(|res, act, ctx| { match res { Ok(res) => act.id = res, @@ -81,7 +82,7 @@ impl Actor for WSSession { } fut::ok(()) }) - .wait(ctx); + .wait(ctx); } fn stopping(&mut self, _ctx: &mut Self::Context) -> Running { @@ -121,12 +122,13 @@ impl StreamHandler for WSSession { let m = text.trim().to_owned(); println!("WEBSOCKET MESSAGE: {:?} from id: {}", &m, self.id); - self.cs_addr + self + .cs_addr .send(StandardMessage { id: self.id, msg: m, }) - .into_actor(self) + .into_actor(self) .then(|res, _, ctx| { match res { Ok(res) => ctx.text(res), @@ -136,7 +138,7 @@ impl StreamHandler for WSSession { } fut::ok(()) }) - .wait(ctx); + .wait(ctx); } ws::Message::Binary(_bin) => println!("Unexpected binary"), ws::Message::Close(_) => { @@ -197,8 +199,8 @@ fn main() { .service(actix_files::Files::new("/static", front_end_dir())) }) .bind("0.0.0.0:8536") - .unwrap() - .start(); + .unwrap() + .start(); println!("Started http server: 0.0.0.0:8536"); let _ = sys.run(); diff --git a/server/src/schema.rs b/server/src/schema.rs index 635c8c467..2ea774ca0 100644 --- a/server/src/schema.rs +++ b/server/src/schema.rs @@ -291,27 +291,27 @@ joinable!(site -> user_ (creator_id)); joinable!(user_ban -> user_ (user_id)); allow_tables_to_appear_in_same_query!( - category, - comment, - comment_like, - comment_saved, - community, - community_follower, - community_moderator, - community_user_ban, - mod_add, - mod_add_community, - mod_ban, - mod_ban_from_community, - mod_lock_post, - mod_remove_comment, - mod_remove_community, - mod_remove_post, - post, - post_like, - post_read, - post_saved, - site, - user_, - user_ban, + category, + comment, + comment_like, + comment_saved, + community, + community_follower, + community_moderator, + community_user_ban, + mod_add, + mod_add_community, + mod_ban, + mod_ban_from_community, + mod_lock_post, + mod_remove_comment, + mod_remove_community, + mod_remove_post, + post, + post_like, + post_read, + post_saved, + site, + user_, + user_ban, ); diff --git a/server/src/websocket/server.rs b/server/src/websocket/server.rs index ad070e53a..32094843d 100644 --- a/server/src/websocket/server.rs +++ b/server/src/websocket/server.rs @@ -3,28 +3,27 @@ //! room through `ChatServer`. use actix::prelude::*; -use rand::{rngs::ThreadRng, Rng}; -use std::collections::{HashMap, HashSet}; -use serde::{Deserialize, Serialize}; -use serde_json::{Value}; -use std::str::FromStr; use failure::Error; -use std::time::{SystemTime}; +use rand::{rngs::ThreadRng, Rng}; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::collections::{HashMap, HashSet}; +use std::str::FromStr; +use std::time::SystemTime; -use crate::api::*; -use crate::api::user::*; +use crate::api::comment::*; use crate::api::community::*; use crate::api::post::*; -use crate::api::comment::*; use crate::api::site::*; +use crate::api::user::*; +use crate::api::*; const RATE_LIMIT_MESSAGE: i32 = 30; const RATE_LIMIT_MESSAGES_PER_SECOND: i32 = 60; const RATE_LIMIT_POST: i32 = 1; -const RATE_LIMIT_POSTS_PER_SECOND: i32 = 60*10; +const RATE_LIMIT_POSTS_PER_SECOND: i32 = 60 * 10; const RATE_LIMIT_REGISTER: i32 = 1; -const RATE_LIMIT_REGISTER_PER_SECOND: i32 = 60*60; - +const RATE_LIMIT_REGISTER_PER_SECOND: i32 = 60 * 60; /// Chat server sends this messages to session #[derive(Message)] @@ -73,7 +72,7 @@ impl actix::Message for StandardMessage { #[derive(Debug)] pub struct RateLimitBucket { last_checked: SystemTime, - allowance: f64 + allowance: f64, } pub struct SessionInfo { @@ -132,24 +131,30 @@ impl ChatServer { &self.rooms.get_mut(&room_id).unwrap().insert(id); } - fn send_community_message(&self, community_id: &i32, message: &str, skip_id: usize) -> Result<(), Error> { - use crate::db::*; + fn send_community_message( + &self, + community_id: &i32, + message: &str, + skip_id: usize, + ) -> Result<(), Error> { use crate::db::post_view::*; + use crate::db::*; let conn = establish_connection(); let posts = PostView::list( &conn, - PostListingType::Community, - &SortType::New, - Some(*community_id), + PostListingType::Community, + &SortType::New, + Some(*community_id), + None, None, - None, None, None, false, false, false, None, - Some(9999))?; + Some(9999), + )?; for post in posts { self.send_room_message(&post.id, message, skip_id); } @@ -186,9 +191,12 @@ impl ChatServer { } if rate_limit.allowance < 1.0 { - println!("Rate limited IP: {}, time_passed: {}, allowance: {}", &info.ip, time_passed, rate_limit.allowance); + println!( + "Rate limited IP: {}, time_passed: {}, allowance: {}", + &info.ip, time_passed, rate_limit.allowance + ); Err(APIError { - op: "Rate Limit".to_string(), + op: "Rate Limit".to_string(), message: format!("Too many requests. {} per {} seconds", rate, per), })? } else { @@ -204,7 +212,6 @@ impl ChatServer { } } - /// Make actor from `ChatServer` impl Actor for ChatServer { /// We are going to use simple Context, we just need ability to communicate @@ -219,7 +226,6 @@ impl Handler for ChatServer { type Result = usize; fn handle(&mut self, msg: Connect, _ctx: &mut Context) -> Self::Result { - // notify all users in same room // self.send_room_message(&"Main".to_owned(), "Someone joined", 0); @@ -227,16 +233,22 @@ impl Handler for ChatServer { let id = self.rng.gen::(); println!("{} joined", &msg.ip); - self.sessions.insert(id, SessionInfo { - addr: msg.addr, - ip: msg.ip.to_owned(), - }); + self.sessions.insert( + id, + SessionInfo { + addr: msg.addr, + ip: msg.ip.to_owned(), + }, + ); if self.rate_limits.get(&msg.ip).is_none() { - self.rate_limits.insert(msg.ip, RateLimitBucket { - last_checked: SystemTime::now(), - allowance: -2f64, - }); + self.rate_limits.insert( + msg.ip, + RateLimitBucket { + last_checked: SystemTime::now(), + allowance: -2f64, + }, + ); } id @@ -248,7 +260,6 @@ impl Handler for ChatServer { type Result = (); fn handle(&mut self, msg: Disconnect, _: &mut Context) { - // let mut rooms: Vec = Vec::new(); // remove address @@ -267,12 +278,10 @@ impl Handler for ChatServer { impl Handler for ChatServer { type Result = MessageResult; - fn handle(&mut self, msg: StandardMessage, _: &mut Context) -> Self::Result { - let msg_out = match parse_json_message(self, msg) { Ok(m) => m, - Err(e) => e.to_string() + Err(e) => e.to_string(), }; MessageResult(msg_out) @@ -280,11 +289,10 @@ impl Handler for ChatServer { } fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { - let json: Value = serde_json::from_str(&msg.msg)?; let data = &json["data"].to_string(); let op = &json["op"].as_str().ok_or(APIError { - op: "Unknown op type".to_string(), + op: "Unknown op type".to_string(), message: format!("Unknown op type"), })?; @@ -295,59 +303,59 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { chat.check_rate_limit_register(msg.id)?; let register: Register = serde_json::from_str(data)?; let res = Oper::new(user_operation, register).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetUserDetails => { let get_user_details: GetUserDetails = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_user_details).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::SaveUserSettings => { let save_user_settings: SaveUserSettings = serde_json::from_str(data)?; let res = Oper::new(user_operation, save_user_settings).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::AddAdmin => { let add_admin: AddAdmin = serde_json::from_str(data)?; let res = Oper::new(user_operation, add_admin).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::BanUser => { let ban_user: BanUser = serde_json::from_str(data)?; let res = Oper::new(user_operation, ban_user).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetReplies => { let get_replies: GetReplies = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_replies).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::MarkAllAsRead => { let mark_all_as_read: MarkAllAsRead = serde_json::from_str(data)?; let res = Oper::new(user_operation, mark_all_as_read).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetCommunity => { let get_community: GetCommunity = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_community).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::ListCommunities => { let list_communities: ListCommunities = serde_json::from_str(data)?; let res = Oper::new(user_operation, list_communities).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreateCommunity => { chat.check_rate_limit_register(msg.id)?; let create_community: CreateCommunity = serde_json::from_str(data)?; let res = Oper::new(user_operation, create_community).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::EditCommunity => { let edit_community: EditCommunity = serde_json::from_str(data)?; let res = Oper::new(user_operation, edit_community).perform()?; @@ -357,17 +365,17 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let follow_community: FollowCommunity = serde_json::from_str(data)?; let res = Oper::new(user_operation, follow_community).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetFollowedCommunities => { let followed_communities: GetFollowedCommunities = serde_json::from_str(data)?; let res = Oper::new(user_operation, followed_communities).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::BanFromCommunity => { let ban_from_community: BanFromCommunity = serde_json::from_str(data)?; let community_id = ban_from_community.community_id; @@ -375,7 +383,7 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let mod_add_to_community: AddModToCommunity = serde_json::from_str(data)?; let community_id = mod_add_to_community.community_id; @@ -383,35 +391,35 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let list_categories: ListCategories = ListCategories; let res = Oper::new(user_operation, list_categories).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreatePost => { chat.check_rate_limit_post(msg.id)?; let create_post: CreatePost = serde_json::from_str(data)?; let res = Oper::new(user_operation, create_post).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetPost => { let get_post: GetPost = serde_json::from_str(data)?; chat.join_room(get_post.id, msg.id); let res = Oper::new(user_operation, get_post).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetPosts => { let get_posts: GetPosts = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_posts).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreatePostLike => { chat.check_rate_limit_message(msg.id)?; let create_post_like: CreatePostLike = serde_json::from_str(data)?; let res = Oper::new(user_operation, create_post_like).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::EditPost => { let edit_post: EditPost = serde_json::from_str(data)?; let res = Oper::new(user_operation, edit_post).perform()?; @@ -420,12 +428,12 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let save_post: SavePost = serde_json::from_str(data)?; let res = Oper::new(user_operation, save_post).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreateComment => { chat.check_rate_limit_message(msg.id)?; let create_comment: CreateComment = serde_json::from_str(data)?; @@ -437,7 +445,7 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let edit_comment: EditComment = serde_json::from_str(data)?; let post_id = edit_comment.post_id; @@ -448,12 +456,12 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let save_comment: SaveComment = serde_json::from_str(data)?; let res = Oper::new(user_operation, save_comment).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreateCommentLike => { chat.check_rate_limit_message(msg.id)?; let create_comment_like: CreateCommentLike = serde_json::from_str(data)?; @@ -465,41 +473,41 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result { let get_modlog: GetModlog = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_modlog).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::CreateSite => { let create_site: CreateSite = serde_json::from_str(data)?; let res = Oper::new(user_operation, create_site).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::EditSite => { let edit_site: EditSite = serde_json::from_str(data)?; let res = Oper::new(user_operation, edit_site).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::GetSite => { let get_site: GetSite = serde_json::from_str(data)?; let res = Oper::new(user_operation, get_site).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::Search => { let search: Search = serde_json::from_str(data)?; let res = Oper::new(user_operation, search).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::TransferCommunity => { let transfer_community: TransferCommunity = serde_json::from_str(data)?; let res = Oper::new(user_operation, transfer_community).perform()?; Ok(serde_json::to_string(&res)?) - }, + } UserOperation::TransferSite => { let transfer_site: TransferSite = serde_json::from_str(data)?; let res = Oper::new(user_operation, transfer_site).perform()?; Ok(serde_json::to_string(&res)?) - }, + } } }