Removing PostLikeResponse in favor of PostResponse. Consolidating comment and post_sends.

3 files changed, 77 insertions, 102 deletions

diff --git a/server/src/api/post.rs b/server/src/api/post.rs
index 642521eb..086705bc 100644
--- a/server/src/api/post.rs
+++ b/server/src/api/post.rs
@@ -55,11 +55,6 @@ pub struct CreatePostLike {
   auth: String,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
-pub struct CreatePostLikeResponse {
-  pub post: PostView,
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct EditPost {
   pub edit_id: i32,
@@ -242,8 +237,8 @@ impl Perform<GetPostsResponse> for Oper<GetPosts> {
   }
 }
 
-impl Perform<CreatePostLikeResponse> for Oper<CreatePostLike> {
-  fn perform(&self, conn: &PgConnection) -> Result<CreatePostLikeResponse, Error> {
+impl Perform<PostResponse> for Oper<CreatePostLike> {
+  fn perform(&self, conn: &PgConnection) -> Result<PostResponse, Error> {
     let data: &CreatePostLike = &self.data;
 
     let claims = match Claims::decode(&data.auth) {
@@ -296,7 +291,7 @@ impl Perform<CreatePostLikeResponse> for Oper<CreatePostLike> {
     };
 
     // just output the score
-    Ok(CreatePostLikeResponse { post: post_view })
+    Ok(PostResponse { post: post_view })
   }
 }
 
diff --git a/server/src/routes/api.rs b/server/src/routes/api.rs
index 5121d240..29a360e4 100644
--- a/server/src/routes/api.rs
+++ b/server/src/routes/api.rs
@@ -31,7 +31,7 @@ pub fn config(cfg: &mut web::ServiceConfig) {
     .route("/api/v1/post", web::put().to(route_post::<EditPost, PostResponse>))
     .route("/api/v1/post", web::get().to(route_get::<GetPost, GetPostResponse>))
     .route("/api/v1/post/list", web::get().to(route_get::<GetPosts, GetPostsResponse>))
-    .route("/api/v1/post/like", web::post().to(route_post::<CreatePostLike, CreatePostLikeResponse>))
+    .route("/api/v1/post/like", web::post().to(route_post::<CreatePostLike, PostResponse>))
     .route("/api/v1/post/save", web::put().to(route_post::<SavePost, PostResponse>))
     // Comment
     .route("/api/v1/comment", web::post().to(route_post::<CreateComment, CommentResponse>))
diff --git a/server/src/websocket/server.rs b/server/src/websocket/server.rs
index 369f50f7..a26c8144 100644
--- a/server/src/websocket/server.rs
+++ b/server/src/websocket/server.rs
@@ -204,6 +204,61 @@ impl ChatServer {
     }
   }
 
+  fn comment_sends(
+    &self,
+    user_operation: UserOperation,
+    comment: CommentResponse,
+    id: ConnectionId,
+  ) -> Result<String, Error> {
+    let mut comment_reply_sent = comment.clone();
+    comment_reply_sent.comment.my_vote = None;
+    comment_reply_sent.comment.user_id = None;
+
+    // For the post room ones, and the directs back to the user
+    // strip out the recipient_ids, so that
+    // users don't get double notifs
+    let mut comment_user_sent = comment.clone();
+    comment_user_sent.recipient_ids = Vec::new();
+
+    let mut comment_post_sent = comment_reply_sent.clone();
+    comment_post_sent.recipient_ids = Vec::new();
+
+    let comment_reply_sent_str = to_json_string(&user_operation, &comment_reply_sent)?;
+    let comment_post_sent_str = to_json_string(&user_operation, &comment_post_sent)?;
+    let comment_user_sent_str = to_json_string(&user_operation, &comment_user_sent)?;
+
+    // Send it to the post room
+    self.send_post_room_message(comment.comment.post_id, &comment_post_sent_str, id);
+
+    // Send it to the recipient(s) including the mentioned users
+    for recipient_id in comment_reply_sent.recipient_ids {
+      self.send_user_room_message(recipient_id, &comment_reply_sent_str, id);
+    }
+
+    Ok(comment_user_sent_str)
+  }
+
+  fn post_sends(
+    &self,
+    user_operation: UserOperation,
+    post: PostResponse,
+    id: ConnectionId,
+  ) -> Result<String, Error> {
+    let community_id = post.post.community_id;
+
+    // Don't send my data with it
+    let mut post_sent = post.clone();
+    post_sent.post.my_vote = None;
+    post_sent.post.user_id = None;
+    let post_sent_str = to_json_string(&user_operation, &post_sent)?;
+
+    // Send it to /c/all and that community
+    self.send_community_room_message(0, &post_sent_str, id);
+    self.send_community_room_message(community_id, &post_sent_str, id);
+
+    to_json_string(&user_operation, post)
+  }
+
   fn check_rate_limit_register(&mut self, id: usize) -> Result<(), Error> {
     self.check_rate_limit_full(
       id,
@@ -487,25 +542,6 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<Str
     UserOperation::ListCategories => {
       do_user_operation::<ListCategories, ListCategoriesResponse>(user_operation, data, &conn)
     }
-    UserOperation::CreatePost => {
-      chat.check_rate_limit_post(msg.id)?;
-      let create_post: CreatePost = serde_json::from_str(data)?;
-      let community_id = create_post.community_id;
-      let res = Oper::new(create_post).perform(&conn)?;
-      let res_str = to_json_string(&user_operation, &res)?;
-
-      // Don't send my data with it
-      let mut post_sent = res;
-      post_sent.post.my_vote = None;
-      post_sent.post.user_id = None;
-      let post_sent_str = to_json_string(&user_operation, &post_sent)?;
-
-      // Send it to /c/all and that community
-      chat.send_community_room_message(0, &post_sent_str, msg.id);
-      chat.send_community_room_message(community_id, &post_sent_str, msg.id);
-
-      Ok(res_str)
-    }
     UserOperation::GetPost => {
       let get_post: GetPost = serde_json::from_str(data)?;
       let post_id = get_post.id;
@@ -529,43 +565,25 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<Str
       let res = Oper::new(get_posts).perform(&conn)?;
       to_json_string(&user_operation, &res)
     }
-    UserOperation::UserJoin => {
-      let user_join: UserJoin = serde_json::from_str(data)?;
-      let res = Oper::new(user_join).perform(&conn)?;
-      chat.join_user_room(res.user_id, msg.id);
-      to_json_string(&user_operation, &res)
+    UserOperation::CreatePost => {
+      chat.check_rate_limit_post(msg.id)?;
+      let create_post: CreatePost = serde_json::from_str(data)?;
+      let res = Oper::new(create_post).perform(&conn)?;
+
+      chat.post_sends(UserOperation::CreatePost, res, msg.id)
     }
     UserOperation::CreatePostLike => {
       chat.check_rate_limit_message(msg.id)?;
       let create_post_like: CreatePostLike = serde_json::from_str(data)?;
       let res = Oper::new(create_post_like).perform(&conn)?;
-      let community_id = res.post.community_id;
-      let res_str = to_json_string(&user_operation, &res)?;
 
-      // Don't send my data with it
-      let mut post_sent = res;
-      post_sent.post.my_vote = None;
-      post_sent.post.user_id = None;
-      let post_sent_str = to_json_string(&user_operation, &post_sent)?;
-
-      // Send it to /c/all and that community
-      chat.send_community_room_message(0, &post_sent_str, msg.id);
-      chat.send_community_room_message(community_id, &post_sent_str, msg.id);
-
-      Ok(res_str)
+      chat.post_sends(UserOperation::CreatePostLike, res, msg.id)
     }
     UserOperation::EditPost => {
       let edit_post: EditPost = serde_json::from_str(data)?;
       let res = Oper::new(edit_post).perform(&conn)?;
-      let mut post_sent = res.clone();
-      post_sent.post.my_vote = None;
-      post_sent.post.user_id = None;
-      let post_sent_str = to_json_string(&user_operation, &post_sent)?;
-
-      // Send it to /c/all and that community
-      chat.send_community_room_message(0, &post_sent_str, msg.id);
-      chat.send_community_room_message(post_sent.post.community_id, &post_sent_str, msg.id);
-      to_json_string(&user_operation, &res)
+
+      chat.post_sends(UserOperation::EditPost, res, msg.id)
     }
     UserOperation::SavePost => {
       do_user_operation::<SavePost, PostResponse>(user_operation, data, &conn)
@@ -573,48 +591,15 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<Str
     UserOperation::CreateComment => {
       chat.check_rate_limit_message(msg.id)?;
       let create_comment: CreateComment = serde_json::from_str(data)?;
-      let post_id = create_comment.post_id;
       let res = Oper::new(create_comment).perform(&conn)?;
 
-      let mut comment_user_sent = res.clone();
-      comment_user_sent.comment.my_vote = None;
-      comment_user_sent.comment.user_id = None;
-
-      // For the post room ones, strip out the recipient_ids, so that
-      // users don't get double notifs
-      let mut comment_post_sent = comment_user_sent.clone();
-      comment_post_sent.recipient_ids = Vec::new();
-
-      let comment_user_sent_str = to_json_string(&user_operation, &comment_user_sent)?;
-      let comment_post_sent_str = to_json_string(&user_operation, &comment_post_sent)?;
-
-      // Send it to the post room
-      chat.send_post_room_message(post_id, &comment_post_sent_str, msg.id);
-
-      // Send it to the recipient(s) including the mentioned users
-      for recipient_id in comment_user_sent.recipient_ids {
-        chat.send_user_room_message(recipient_id, &comment_user_sent_str, msg.id);
-      }
-
-      to_json_string(&user_operation, &res)
+      chat.comment_sends(UserOperation::CreateComment, res, msg.id)
     }
     UserOperation::EditComment => {
       let edit_comment: EditComment = serde_json::from_str(data)?;
-      let post_id = edit_comment.post_id;
       let res = Oper::new(edit_comment).perform(&conn)?;
-      let mut comment_sent = res.clone();
-      comment_sent.comment.my_vote = None;
-      comment_sent.comment.user_id = None;
-      let comment_sent_str = to_json_string(&user_operation, &comment_sent)?;
-
-      chat.send_post_room_message(post_id, &comment_sent_str, msg.id);
-
-      // Send it to the recipient(s) including the mentioned users
-      for recipient_id in comment_sent.recipient_ids {
-        chat.send_user_room_message(recipient_id, &comment_sent_str, msg.id);
-      }
 
-      to_json_string(&user_operation, &res)
+      chat.comment_sends(UserOperation::EditComment, res, msg.id)
     }
     UserOperation::SaveComment => {
       do_user_operation::<SaveComment, CommentResponse>(user_operation, data, &conn)
@@ -622,20 +607,9 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<Str
     UserOperation::CreateCommentLike => {
       chat.check_rate_limit_message(msg.id)?;
       let create_comment_like: CreateCommentLike = serde_json::from_str(data)?;
-      let post_id = create_comment_like.post_id;
       let res = Oper::new(create_comment_like).perform(&conn)?;
-      let mut comment_sent = res.clone();
-      comment_sent.comment.my_vote = None;
-      comment_sent.comment.user_id = None;
-      let comment_sent_str = to_json_string(&user_operation, &comment_sent)?;
-
-      chat.send_post_room_message(post_id, &comment_sent_str, msg.id);
 
-      // Send it to the recipient(s) including the mentioned users
-      for recipient_id in comment_sent.recipient_ids {
-        chat.send_user_room_message(recipient_id, &comment_sent_str, msg.id);
-      }
-      to_json_string(&user_operation, &res)
+      chat.comment_sends(UserOperation::CreateCommentLike, res, msg.id)
     }
     UserOperation::GetModlog => {
       do_user_operation::<GetModlog, GetModlogResponse>(user_operation, data, &conn)
@@ -690,5 +664,11 @@ fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<Str
     UserOperation::GetPrivateMessages => {
       do_user_operation::<GetPrivateMessages, PrivateMessagesResponse>(user_operation, data, &conn)
     }
+    UserOperation::UserJoin => {
+      let user_join: UserJoin = serde_json::from_str(data)?;
+      let res = Oper::new(user_join).perform(&conn)?;
+      chat.join_user_room(res.user_id, msg.id);
+      to_json_string(&user_operation, &res)
+    }
   }
 }