3 community::send_activity_in_community,
8 verify_person_in_community,
10 activity_lists::AnnouncableActivities,
14 community::ApubCommunity,
17 private_message::ApubPrivateMessage,
20 activities::deletion::{delete::Delete, undo_delete::UndoDelete},
26 use activitypub_federation::{
27 core::object_id::ObjectId,
28 traits::{Actor, ApubObject},
29 utils::verify_domains_match,
31 use activitystreams_kinds::public;
32 use lemmy_api_common::{
33 comment::{CommentResponse, DeleteComment, RemoveComment},
34 community::{CommunityResponse, DeleteCommunity, RemoveCommunity},
35 context::LemmyContext,
36 post::{DeletePost, PostResponse, RemovePost},
37 private_message::{DeletePrivateMessage, PrivateMessageResponse},
38 utils::get_local_user_view_from_jwt,
41 send_comment_ws_message_simple,
42 send_community_ws_message,
49 use lemmy_db_schema::{
51 comment::{Comment, CommentUpdateForm},
52 community::{Community, CommunityUpdateForm},
54 post::{Post, PostUpdateForm},
55 private_message::{PrivateMessage, PrivateMessageUpdateForm},
59 use lemmy_utils::error::LemmyError;
67 #[async_trait::async_trait(?Send)]
68 impl SendActivity for DeletePost {
69 type Response = PostResponse;
71 async fn send_activity(
73 response: &Self::Response,
74 context: &LemmyContext,
75 ) -> Result<(), LemmyError> {
77 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
78 let community = Community::read(context.pool(), response.post_view.community.id).await?;
79 let deletable = DeletableObjects::Post(Box::new(response.post_view.post.clone().into()));
80 send_apub_delete_in_community(
81 local_user_view.person,
92 #[async_trait::async_trait(?Send)]
93 impl SendActivity for RemovePost {
94 type Response = PostResponse;
96 async fn send_activity(
98 response: &Self::Response,
99 context: &LemmyContext,
100 ) -> Result<(), LemmyError> {
101 let local_user_view =
102 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
103 let community = Community::read(context.pool(), response.post_view.community.id).await?;
104 let deletable = DeletableObjects::Post(Box::new(response.post_view.post.clone().into()));
105 send_apub_delete_in_community(
106 local_user_view.person,
109 request.reason.clone().or_else(|| Some(String::new())),
117 #[async_trait::async_trait(?Send)]
118 impl SendActivity for DeleteComment {
119 type Response = CommentResponse;
121 async fn send_activity(
123 response: &Self::Response,
124 context: &LemmyContext,
125 ) -> Result<(), LemmyError> {
126 let community_id = response.comment_view.community.id;
127 let community = Community::read(context.pool(), community_id).await?;
128 let person = Person::read(context.pool(), response.comment_view.creator.id).await?;
130 DeletableObjects::Comment(Box::new(response.comment_view.comment.clone().into()));
131 send_apub_delete_in_community(person, community, deletable, None, request.deleted, context)
136 #[async_trait::async_trait(?Send)]
137 impl SendActivity for RemoveComment {
138 type Response = CommentResponse;
140 async fn send_activity(
142 response: &Self::Response,
143 context: &LemmyContext,
144 ) -> Result<(), LemmyError> {
145 let local_user_view =
146 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
147 let comment = Comment::read(context.pool(), request.comment_id).await?;
148 let community = Community::read(context.pool(), response.comment_view.community.id).await?;
149 let deletable = DeletableObjects::Comment(Box::new(comment.into()));
150 send_apub_delete_in_community(
151 local_user_view.person,
154 request.reason.clone().or_else(|| Some(String::new())),
162 #[async_trait::async_trait(?Send)]
163 impl SendActivity for DeletePrivateMessage {
164 type Response = PrivateMessageResponse;
166 async fn send_activity(
168 response: &Self::Response,
169 context: &LemmyContext,
170 ) -> Result<(), LemmyError> {
171 let local_user_view =
172 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
173 send_apub_delete_private_message(
174 &local_user_view.person.into(),
175 response.private_message_view.private_message.clone(),
183 #[async_trait::async_trait(?Send)]
184 impl SendActivity for DeleteCommunity {
185 type Response = CommunityResponse;
187 async fn send_activity(
189 _response: &Self::Response,
190 context: &LemmyContext,
191 ) -> Result<(), LemmyError> {
192 let local_user_view =
193 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
194 let community = Community::read(context.pool(), request.community_id).await?;
195 let deletable = DeletableObjects::Community(Box::new(community.clone().into()));
196 send_apub_delete_in_community(
197 local_user_view.person,
208 #[async_trait::async_trait(?Send)]
209 impl SendActivity for RemoveCommunity {
210 type Response = CommunityResponse;
212 async fn send_activity(
214 _response: &Self::Response,
215 context: &LemmyContext,
216 ) -> Result<(), LemmyError> {
217 let local_user_view =
218 get_local_user_view_from_jwt(&request.auth, context.pool(), context.secret()).await?;
219 let community = Community::read(context.pool(), request.community_id).await?;
220 let deletable = DeletableObjects::Community(Box::new(community.clone().into()));
221 send_apub_delete_in_community(
222 local_user_view.person,
225 request.reason.clone().or_else(|| Some(String::new())),
233 /// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
234 /// action was done by a normal user.
235 #[tracing::instrument(skip_all)]
236 async fn send_apub_delete_in_community(
238 community: Community,
239 object: DeletableObjects,
240 reason: Option<String>,
242 context: &LemmyContext,
243 ) -> Result<(), LemmyError> {
244 let actor = ApubPerson::from(actor);
245 let is_mod_action = reason.is_some();
246 let activity = if deleted {
247 let delete = Delete::new(&actor, object, public(), Some(&community), reason, context)?;
248 AnnouncableActivities::Delete(delete)
250 let undo = UndoDelete::new(&actor, object, public(), Some(&community), reason, context)?;
251 AnnouncableActivities::UndoDelete(undo)
253 send_activity_in_community(
264 #[tracing::instrument(skip_all)]
265 async fn send_apub_delete_private_message(
269 context: &LemmyContext,
270 ) -> Result<(), LemmyError> {
271 let recipient_id = pm.recipient_id;
272 let recipient: ApubPerson = Person::read(context.pool(), recipient_id).await?.into();
274 let deletable = DeletableObjects::PrivateMessage(Box::new(pm.into()));
275 let inbox = vec![recipient.shared_inbox_or_inbox()];
277 let delete = Delete::new(actor, deletable, recipient.actor_id(), None, None, context)?;
278 send_lemmy_activity(context, delete, actor, inbox, true).await?;
280 let undo = UndoDelete::new(actor, deletable, recipient.actor_id(), None, None, context)?;
281 send_lemmy_activity(context, undo, actor, inbox, true).await?;
286 pub enum DeletableObjects {
287 Community(Box<ApubCommunity>),
288 Comment(Box<ApubComment>),
290 PrivateMessage(Box<ApubPrivateMessage>),
293 impl DeletableObjects {
294 #[tracing::instrument(skip_all)]
295 pub(crate) async fn read_from_db(
297 context: &LemmyContext,
298 ) -> Result<DeletableObjects, LemmyError> {
299 if let Some(c) = ApubCommunity::read_from_apub_id(ap_id.clone(), context).await? {
300 return Ok(DeletableObjects::Community(Box::new(c)));
302 if let Some(p) = ApubPost::read_from_apub_id(ap_id.clone(), context).await? {
303 return Ok(DeletableObjects::Post(Box::new(p)));
305 if let Some(c) = ApubComment::read_from_apub_id(ap_id.clone(), context).await? {
306 return Ok(DeletableObjects::Comment(Box::new(c)));
308 if let Some(p) = ApubPrivateMessage::read_from_apub_id(ap_id.clone(), context).await? {
309 return Ok(DeletableObjects::PrivateMessage(Box::new(p)));
311 Err(diesel::NotFound.into())
314 pub(crate) fn id(&self) -> Url {
316 DeletableObjects::Community(c) => c.actor_id(),
317 DeletableObjects::Comment(c) => c.ap_id.clone().into(),
318 DeletableObjects::Post(p) => p.ap_id.clone().into(),
319 DeletableObjects::PrivateMessage(p) => p.ap_id.clone().into(),
324 #[tracing::instrument(skip_all)]
325 pub(in crate::activities) async fn verify_delete_activity(
328 context: &LemmyContext,
329 request_counter: &mut i32,
330 ) -> Result<(), LemmyError> {
331 let object = DeletableObjects::read_from_db(activity.object.id(), context).await?;
333 DeletableObjects::Community(community) => {
334 verify_is_public(&activity.to, &[])?;
336 // can only do this check for local community, in remote case it would try to fetch the
337 // deleted community (which fails)
338 verify_person_in_community(&activity.actor, &community, context, request_counter).await?;
340 // community deletion is always a mod (or admin) action
343 activity.object.id(),
350 DeletableObjects::Post(p) => {
351 verify_is_public(&activity.to, &[])?;
352 verify_delete_post_or_comment(
354 &p.ap_id.clone().into(),
355 &activity.community(context, request_counter).await?,
362 DeletableObjects::Comment(c) => {
363 verify_is_public(&activity.to, &[])?;
364 verify_delete_post_or_comment(
366 &c.ap_id.clone().into(),
367 &activity.community(context, request_counter).await?,
374 DeletableObjects::PrivateMessage(_) => {
375 verify_person(&activity.actor, context, request_counter).await?;
376 verify_domains_match(activity.actor.inner(), activity.object.id())?;
382 #[tracing::instrument(skip_all)]
383 async fn verify_delete_post_or_comment(
384 actor: &ObjectId<ApubPerson>,
386 community: &ApubCommunity,
388 context: &LemmyContext,
389 request_counter: &mut i32,
390 ) -> Result<(), LemmyError> {
391 verify_person_in_community(actor, community, context, request_counter).await?;
393 verify_mod_action(actor, object_id, community.id, context, request_counter).await?;
395 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
396 verify_domains_match(actor.inner(), object_id)?;
401 /// Write deletion or restoring of an object to the database, and send websocket message.
402 #[tracing::instrument(skip_all)]
403 async fn receive_delete_action(
405 actor: &ObjectId<ApubPerson>,
407 context: &LemmyContext,
408 request_counter: &mut i32,
409 ) -> Result<(), LemmyError> {
410 match DeletableObjects::read_from_db(object, context).await? {
411 DeletableObjects::Community(community) => {
413 let mod_: Person = actor
414 .dereference(context, local_instance(context).await, request_counter)
418 let object = DeletableObjects::Community(community.clone());
419 let c: Community = community.deref().deref().clone();
420 send_apub_delete_in_community(mod_, c, object, None, true, context).await?;
423 let community = Community::update(
426 &CommunityUpdateForm::builder()
427 .deleted(Some(deleted))
431 send_community_ws_message(
433 UserOperationCrud::DeleteCommunity,
440 DeletableObjects::Post(post) => {
441 if deleted != post.deleted {
442 let deleted_post = Post::update(
445 &PostUpdateForm::builder().deleted(Some(deleted)).build(),
448 send_post_ws_message(
450 UserOperationCrud::DeletePost,
458 DeletableObjects::Comment(comment) => {
459 if deleted != comment.deleted {
460 let deleted_comment = Comment::update(
463 &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
466 send_comment_ws_message_simple(
468 UserOperationCrud::DeleteComment,
474 DeletableObjects::PrivateMessage(pm) => {
475 let deleted_private_message = PrivateMessage::update(
478 &PrivateMessageUpdateForm::builder()
479 .deleted(Some(deleted))
485 deleted_private_message.id,
486 UserOperationCrud::DeletePrivateMessage,