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, &c, 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 let community = community_id.dereference(context, request_counter).await?;
144 verify_person_in_community(&actor, &community, context, request_counter).await?;
146 verify_mod_action(&actor, community_id, context, request_counter).await?;
148 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
149 verify_domains_match(activity.actor(), object_id)?;
154 struct WebsocketMessages {
155 community: UserOperationCrud,
156 post: UserOperationCrud,
157 comment: UserOperationCrud,
160 /// Write deletion or restoring of an object to the database, and send websocket message.
161 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
162 /// because of the mod log
163 async fn receive_delete_action(
165 actor: &ObjectId<ApubPerson>,
166 ws_messages: WebsocketMessages,
168 context: &LemmyContext,
169 request_counter: &mut i32,
170 ) -> Result<(), LemmyError> {
171 match DeletableObjects::read_from_db(object, context).await? {
172 DeletableObjects::Community(community) => {
174 let mod_ = actor.dereference(context, request_counter).await?;
175 let object = community.actor_id();
176 send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
179 let community = blocking(context.pool(), move |conn| {
180 Community::update_deleted(conn, community.id, deleted)
183 send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
185 DeletableObjects::Post(post) => {
186 let deleted_post = blocking(context.pool(), move |conn| {
187 Post::update_deleted(conn, post.id, deleted)
190 send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
192 DeletableObjects::Comment(comment) => {
193 let deleted_comment = blocking(context.pool(), move |conn| {
194 Comment::update_deleted(conn, comment.id, deleted)
197 send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;