3 community::send_activity_in_community,
8 verify_person_in_community,
10 activity_lists::AnnouncableActivities,
13 community::ApubCommunity,
16 private_message::ApubPrivateMessage,
19 activities::deletion::{delete::Delete, undo_delete::UndoDelete},
24 use activitypub_federation::{
26 fetch::object_id::ObjectId,
28 protocol::verification::verify_domains_match,
29 traits::{Actor, Object},
31 use lemmy_api_common::{
32 community::{CommunityResponse, DeleteCommunity, RemoveCommunity},
33 context::LemmyContext,
34 post::{DeletePost, PostResponse, RemovePost},
35 private_message::{DeletePrivateMessage, PrivateMessageResponse},
36 utils::local_user_view_from_jwt,
38 use lemmy_db_schema::{
40 comment::{Comment, CommentUpdateForm},
41 community::{Community, CommunityUpdateForm},
43 post::{Post, PostUpdateForm},
44 private_message::{PrivateMessage, PrivateMessageUpdateForm},
48 use lemmy_utils::error::LemmyError;
56 #[async_trait::async_trait]
57 impl SendActivity for DeletePost {
58 type Response = PostResponse;
60 async fn send_activity(
62 response: &Self::Response,
63 context: &Data<LemmyContext>,
64 ) -> Result<(), LemmyError> {
65 let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
66 let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
67 let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
68 send_apub_delete_in_community(
69 local_user_view.person,
80 #[async_trait::async_trait]
81 impl SendActivity for RemovePost {
82 type Response = PostResponse;
84 async fn send_activity(
86 response: &Self::Response,
87 context: &Data<LemmyContext>,
88 ) -> Result<(), LemmyError> {
89 let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
90 let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
91 let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
92 send_apub_delete_in_community(
93 local_user_view.person,
96 request.reason.clone().or_else(|| Some(String::new())),
104 #[async_trait::async_trait]
105 impl SendActivity for DeletePrivateMessage {
106 type Response = PrivateMessageResponse;
108 async fn send_activity(
110 response: &Self::Response,
111 context: &Data<LemmyContext>,
112 ) -> Result<(), LemmyError> {
113 let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
114 send_apub_delete_private_message(
115 &local_user_view.person.into(),
116 response.private_message_view.private_message.clone(),
124 #[async_trait::async_trait]
125 impl SendActivity for DeleteCommunity {
126 type Response = CommunityResponse;
128 async fn send_activity(
130 _response: &Self::Response,
131 context: &Data<LemmyContext>,
132 ) -> Result<(), LemmyError> {
133 let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
134 let community = Community::read(&mut context.pool(), request.community_id).await?;
135 let deletable = DeletableObjects::Community(community.clone().into());
136 send_apub_delete_in_community(
137 local_user_view.person,
148 #[async_trait::async_trait]
149 impl SendActivity for RemoveCommunity {
150 type Response = CommunityResponse;
152 async fn send_activity(
154 _response: &Self::Response,
155 context: &Data<LemmyContext>,
156 ) -> Result<(), LemmyError> {
157 let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
158 let community = Community::read(&mut context.pool(), request.community_id).await?;
159 let deletable = DeletableObjects::Community(community.clone().into());
160 send_apub_delete_in_community(
161 local_user_view.person,
164 request.reason.clone().or_else(|| Some(String::new())),
172 /// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
173 /// action was done by a normal user.
174 #[tracing::instrument(skip_all)]
175 pub(crate) async fn send_apub_delete_in_community(
177 community: Community,
178 object: DeletableObjects,
179 reason: Option<String>,
181 context: &Data<LemmyContext>,
182 ) -> Result<(), LemmyError> {
183 let actor = ApubPerson::from(actor);
184 let is_mod_action = reason.is_some();
185 let activity = if deleted {
186 let delete = Delete::new(&actor, object, public(), Some(&community), reason, context)?;
187 AnnouncableActivities::Delete(delete)
189 let undo = UndoDelete::new(&actor, object, public(), Some(&community), reason, context)?;
190 AnnouncableActivities::UndoDelete(undo)
192 send_activity_in_community(
203 #[tracing::instrument(skip_all)]
204 async fn send_apub_delete_private_message(
208 context: &Data<LemmyContext>,
209 ) -> Result<(), LemmyError> {
210 let recipient_id = pm.recipient_id;
211 let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
215 let deletable = DeletableObjects::PrivateMessage(pm.into());
216 let inbox = vec![recipient.shared_inbox_or_inbox()];
218 let delete = Delete::new(actor, deletable, recipient.id(), None, None, context)?;
219 send_lemmy_activity(context, delete, actor, inbox, true).await?;
221 let undo = UndoDelete::new(actor, deletable, recipient.id(), None, None, context)?;
222 send_lemmy_activity(context, undo, actor, inbox, true).await?;
227 pub enum DeletableObjects {
228 Community(ApubCommunity),
229 Comment(ApubComment),
231 PrivateMessage(ApubPrivateMessage),
234 impl DeletableObjects {
235 #[tracing::instrument(skip_all)]
236 pub(crate) async fn read_from_db(
238 context: &Data<LemmyContext>,
239 ) -> Result<DeletableObjects, LemmyError> {
240 if let Some(c) = ApubCommunity::read_from_id(ap_id.clone(), context).await? {
241 return Ok(DeletableObjects::Community(c));
243 if let Some(p) = ApubPost::read_from_id(ap_id.clone(), context).await? {
244 return Ok(DeletableObjects::Post(p));
246 if let Some(c) = ApubComment::read_from_id(ap_id.clone(), context).await? {
247 return Ok(DeletableObjects::Comment(c));
249 if let Some(p) = ApubPrivateMessage::read_from_id(ap_id.clone(), context).await? {
250 return Ok(DeletableObjects::PrivateMessage(p));
252 Err(diesel::NotFound.into())
255 pub(crate) fn id(&self) -> Url {
257 DeletableObjects::Community(c) => c.id(),
258 DeletableObjects::Comment(c) => c.ap_id.clone().into(),
259 DeletableObjects::Post(p) => p.ap_id.clone().into(),
260 DeletableObjects::PrivateMessage(p) => p.ap_id.clone().into(),
265 #[tracing::instrument(skip_all)]
266 pub(in crate::activities) async fn verify_delete_activity(
269 context: &Data<LemmyContext>,
270 ) -> Result<(), LemmyError> {
271 let object = DeletableObjects::read_from_db(activity.object.id(), context).await?;
273 DeletableObjects::Community(community) => {
274 verify_is_public(&activity.to, &[])?;
276 // can only do this check for local community, in remote case it would try to fetch the
277 // deleted community (which fails)
278 verify_person_in_community(&activity.actor, &community, context).await?;
280 // community deletion is always a mod (or admin) action
281 verify_mod_action(&activity.actor, activity.object.id(), community.id, context).await?;
283 DeletableObjects::Post(p) => {
284 verify_is_public(&activity.to, &[])?;
285 verify_delete_post_or_comment(
287 &p.ap_id.clone().into(),
288 &activity.community(context).await?,
294 DeletableObjects::Comment(c) => {
295 verify_is_public(&activity.to, &[])?;
296 verify_delete_post_or_comment(
298 &c.ap_id.clone().into(),
299 &activity.community(context).await?,
305 DeletableObjects::PrivateMessage(_) => {
306 verify_person(&activity.actor, context).await?;
307 verify_domains_match(activity.actor.inner(), activity.object.id())?;
313 #[tracing::instrument(skip_all)]
314 async fn verify_delete_post_or_comment(
315 actor: &ObjectId<ApubPerson>,
317 community: &ApubCommunity,
319 context: &Data<LemmyContext>,
320 ) -> Result<(), LemmyError> {
321 verify_person_in_community(actor, community, context).await?;
323 verify_mod_action(actor, object_id, community.id, context).await?;
325 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
326 verify_domains_match(actor.inner(), object_id)?;
331 /// Write deletion or restoring of an object to the database, and send websocket message.
332 #[tracing::instrument(skip_all)]
333 async fn receive_delete_action(
335 actor: &ObjectId<ApubPerson>,
337 context: &Data<LemmyContext>,
338 ) -> Result<(), LemmyError> {
339 match DeletableObjects::read_from_db(object, context).await? {
340 DeletableObjects::Community(community) => {
342 let mod_: Person = actor.dereference(context).await?.deref().clone();
343 let object = DeletableObjects::Community(community.clone());
344 let c: Community = community.deref().deref().clone();
345 send_apub_delete_in_community(mod_, c, object, None, true, context).await?;
351 &CommunityUpdateForm::builder()
352 .deleted(Some(deleted))
357 DeletableObjects::Post(post) => {
358 if deleted != post.deleted {
362 &PostUpdateForm::builder().deleted(Some(deleted)).build(),
367 DeletableObjects::Comment(comment) => {
368 if deleted != comment.deleted {
372 &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
377 DeletableObjects::PrivateMessage(pm) => {
378 PrivateMessage::update(
381 &PrivateMessageUpdateForm::builder()
382 .deleted(Some(deleted))