3 deletion::{delete::Delete, undo_delete::UndoDelete},
5 verify_person_in_community,
7 fetcher::object_id::ObjectId,
8 objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson, post::ApubPost},
10 use lemmy_api_common::blocking;
12 traits::{ActivityFields, ActorType, ApubObject},
13 verify::verify_domains_match,
15 use lemmy_db_schema::source::{comment::Comment, community::Community, post::Post};
16 use lemmy_utils::LemmyError;
17 use lemmy_websocket::{
18 send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
27 pub async fn send_apub_delete(
29 community: &ApubCommunity,
32 context: &LemmyContext,
33 ) -> Result<(), LemmyError> {
35 Delete::send(actor, community, object_id, None, context).await
37 UndoDelete::send(actor, community, object_id, None, context).await
41 // TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
43 pub async fn send_apub_remove(
45 community: &ApubCommunity,
49 context: &LemmyContext,
50 ) -> Result<(), LemmyError> {
52 Delete::send(actor, community, object_id, Some(reason), context).await
54 UndoDelete::send(actor, community, object_id, Some(reason), context).await
58 pub enum DeletableObjects {
59 Community(Box<ApubCommunity>),
60 Comment(Box<ApubComment>),
64 impl DeletableObjects {
65 pub(crate) async fn read_from_db(
67 context: &LemmyContext,
68 ) -> Result<DeletableObjects, LemmyError> {
69 if let Some(c) = ApubCommunity::read_from_apub_id(ap_id.clone(), context).await? {
70 return Ok(DeletableObjects::Community(Box::new(c)));
72 if let Some(p) = ApubPost::read_from_apub_id(ap_id.clone(), context).await? {
73 return Ok(DeletableObjects::Post(Box::new(p)));
75 if let Some(c) = ApubComment::read_from_apub_id(ap_id.clone(), context).await? {
76 return Ok(DeletableObjects::Comment(Box::new(c)));
78 Err(diesel::NotFound.into())
82 pub(in crate::activities) async fn verify_delete_activity(
84 activity: &dyn ActivityFields,
85 community_id: &ObjectId<ApubCommunity>,
87 context: &LemmyContext,
88 request_counter: &mut i32,
89 ) -> Result<(), LemmyError> {
90 let object = DeletableObjects::read_from_db(object, context).await?;
91 let actor = ObjectId::new(activity.actor().clone());
93 DeletableObjects::Community(c) => {
95 // can only do this check for local community, in remote case it would try to fetch the
96 // deleted community (which fails)
97 verify_person_in_community(&actor, community_id, context, request_counter).await?;
99 // community deletion is always a mod (or admin) action
102 &ObjectId::new(c.actor_id()),
108 DeletableObjects::Post(p) => {
109 verify_delete_activity_post_or_comment(
111 &p.ap_id.clone().into(),
119 DeletableObjects::Comment(c) => {
120 verify_delete_activity_post_or_comment(
122 &c.ap_id.clone().into(),
134 async fn verify_delete_activity_post_or_comment(
135 activity: &dyn ActivityFields,
137 community_id: &ObjectId<ApubCommunity>,
139 context: &LemmyContext,
140 request_counter: &mut i32,
141 ) -> Result<(), LemmyError> {
142 let actor = ObjectId::new(activity.actor().clone());
143 verify_person_in_community(&actor, community_id, context, request_counter).await?;
145 verify_mod_action(&actor, community_id, context, request_counter).await?;
147 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
148 verify_domains_match(activity.actor(), object_id)?;
153 struct WebsocketMessages {
154 community: UserOperationCrud,
155 post: UserOperationCrud,
156 comment: UserOperationCrud,
159 /// Write deletion or restoring of an object to the database, and send websocket message.
160 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
161 /// because of the mod log
162 async fn receive_delete_action(
164 actor: &ObjectId<ApubPerson>,
165 ws_messages: WebsocketMessages,
167 context: &LemmyContext,
168 request_counter: &mut i32,
169 ) -> Result<(), LemmyError> {
170 match DeletableObjects::read_from_db(object, context).await? {
171 DeletableObjects::Community(community) => {
173 let mod_ = actor.dereference(context, request_counter).await?;
174 let object = community.actor_id();
175 send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
178 let community = blocking(context.pool(), move |conn| {
179 Community::update_deleted(conn, community.id, deleted)
182 send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
184 DeletableObjects::Post(post) => {
185 let deleted_post = blocking(context.pool(), move |conn| {
186 Post::update_deleted(conn, post.id, deleted)
189 send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
191 DeletableObjects::Comment(comment) => {
192 let deleted_comment = blocking(context.pool(), move |conn| {
193 Comment::update_deleted(conn, comment.id, deleted)
196 send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;