crates/apub/src/activities/receive/post.rs

   1 use crate::{activities::receive::get_actor_as_user, objects::FromApub, ActorType, PageExt};
   2 use activitystreams::{
   3   activity::{Create, Dislike, Like, Remove, Update},
   4   prelude::*,
   5 };
   6 use anyhow::Context;
   7 use lemmy_db_queries::{source::post::Post_, Likeable};
   8 use lemmy_db_schema::source::post::{Post, PostLike, PostLikeForm};
   9 use lemmy_db_views::post_view::PostView;
  10 use lemmy_structs::{blocking, post::PostResponse};
  11 use lemmy_utils::{location_info, LemmyError};
  12 use lemmy_websocket::{messages::SendPost, LemmyContext, UserOperation};
  13
  14 pub(crate) async fn receive_create_post(
  15   create: Create,
  16   context: &LemmyContext,
  17   request_counter: &mut i32,
  18 ) -> Result<(), LemmyError> {
  19   let user = get_actor_as_user(&create, context, request_counter).await?;
  20   let page = PageExt::from_any_base(create.object().to_owned().one().context(location_info!())?)?
  21     .context(location_info!())?;
  22
  23   let post = Post::from_apub(&page, context, user.actor_id(), request_counter).await?;
  24
  25   // Refetch the view
  26   let post_id = post.id;
  27   let post_view = blocking(context.pool(), move |conn| {
  28     PostView::read(conn, post_id, None)
  29   })
  30   .await??;
  31
  32   let res = PostResponse { post_view };
  33
  34   context.chat_server().do_send(SendPost {
  35     op: UserOperation::CreatePost,
  36     post: res,
  37     websocket_id: None,
  38   });
  39
  40   Ok(())
  41 }
  42
  43 pub(crate) async fn receive_update_post(
  44   update: Update,
  45   context: &LemmyContext,
  46   request_counter: &mut i32,
  47 ) -> Result<(), LemmyError> {
  48   let user = get_actor_as_user(&update, context, request_counter).await?;
  49   let page = PageExt::from_any_base(update.object().to_owned().one().context(location_info!())?)?
  50     .context(location_info!())?;
  51
  52   let post = Post::from_apub(&page, context, user.actor_id(), request_counter).await?;
  53
  54   let post_id = post.id;
  55   // Refetch the view
  56   let post_view = blocking(context.pool(), move |conn| {
  57     PostView::read(conn, post_id, None)
  58   })
  59   .await??;
  60
  61   let res = PostResponse { post_view };
  62
  63   context.chat_server().do_send(SendPost {
  64     op: UserOperation::EditPost,
  65     post: res,
  66     websocket_id: None,
  67   });
  68
  69   Ok(())
  70 }
  71
  72 pub(crate) async fn receive_like_post(
  73   like: Like,
  74   post: Post,
  75   context: &LemmyContext,
  76   request_counter: &mut i32,
  77 ) -> Result<(), LemmyError> {
  78   let user = get_actor_as_user(&like, context, request_counter).await?;
  79
  80   let post_id = post.id;
  81   let like_form = PostLikeForm {
  82     post_id,
  83     user_id: user.id,
  84     score: 1,
  85   };
  86   let user_id = user.id;
  87   blocking(context.pool(), move |conn| {
  88     PostLike::remove(conn, user_id, post_id)?;
  89     PostLike::like(conn, &like_form)
  90   })
  91   .await??;
  92
  93   // Refetch the view
  94   let post_view = blocking(context.pool(), move |conn| {
  95     PostView::read(conn, post_id, None)
  96   })
  97   .await??;
  98
  99   let res = PostResponse { post_view };
 100
 101   context.chat_server().do_send(SendPost {
 102     op: UserOperation::CreatePostLike,
 103     post: res,
 104     websocket_id: None,
 105   });
 106
 107   Ok(())
 108 }
 109
 110 pub(crate) async fn receive_dislike_post(
 111   dislike: Dislike,
 112   post: Post,
 113   context: &LemmyContext,
 114   request_counter: &mut i32,
 115 ) -> Result<(), LemmyError> {
 116   let user = get_actor_as_user(&dislike, context, request_counter).await?;
 117
 118   let post_id = post.id;
 119   let like_form = PostLikeForm {
 120     post_id,
 121     user_id: user.id,
 122     score: -1,
 123   };
 124   let user_id = user.id;
 125   blocking(context.pool(), move |conn| {
 126     PostLike::remove(conn, user_id, post_id)?;
 127     PostLike::like(conn, &like_form)
 128   })
 129   .await??;
 130
 131   // Refetch the view
 132   let post_view = blocking(context.pool(), move |conn| {
 133     PostView::read(conn, post_id, None)
 134   })
 135   .await??;
 136
 137   let res = PostResponse { post_view };
 138
 139   context.chat_server().do_send(SendPost {
 140     op: UserOperation::CreatePostLike,
 141     post: res,
 142     websocket_id: None,
 143   });
 144
 145   Ok(())
 146 }
 147
 148 pub(crate) async fn receive_delete_post(
 149   context: &LemmyContext,
 150   post: Post,
 151 ) -> Result<(), LemmyError> {
 152   let deleted_post = blocking(context.pool(), move |conn| {
 153     Post::update_deleted(conn, post.id, true)
 154   })
 155   .await??;
 156
 157   // Refetch the view
 158   let post_id = deleted_post.id;
 159   let post_view = blocking(context.pool(), move |conn| {
 160     PostView::read(conn, post_id, None)
 161   })
 162   .await??;
 163
 164   let res = PostResponse { post_view };
 165   context.chat_server().do_send(SendPost {
 166     op: UserOperation::EditPost,
 167     post: res,
 168     websocket_id: None,
 169   });
 170
 171   Ok(())
 172 }
 173
 174 pub(crate) async fn receive_remove_post(
 175   context: &LemmyContext,
 176   _remove: Remove,
 177   post: Post,
 178 ) -> Result<(), LemmyError> {
 179   let removed_post = blocking(context.pool(), move |conn| {
 180     Post::update_removed(conn, post.id, true)
 181   })
 182   .await??;
 183
 184   // Refetch the view
 185   let post_id = removed_post.id;
 186   let post_view = blocking(context.pool(), move |conn| {
 187     PostView::read(conn, post_id, None)
 188   })
 189   .await??;
 190
 191   let res = PostResponse { post_view };
 192   context.chat_server().do_send(SendPost {
 193     op: UserOperation::EditPost,
 194     post: res,
 195     websocket_id: None,
 196   });
 197
 198   Ok(())
 199 }