3 deletion::{delete::Delete, undo_delete::UndoDelete},
5 verify_person_in_community,
7 fetcher::person::get_or_fetch_and_upsert_person,
10 use lemmy_api_common::blocking;
11 use lemmy_apub_lib::{verify_domains_match, ActivityFields};
12 use lemmy_db_queries::{
13 source::{comment::Comment_, community::Community_, post::Post_},
16 use lemmy_db_schema::{
17 source::{comment::Comment, community::Community, person::Person, post::Post},
20 use lemmy_utils::LemmyError;
21 use lemmy_websocket::{
22 send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
31 pub async fn send_apub_delete(
33 community: &Community,
36 context: &LemmyContext,
37 ) -> Result<(), LemmyError> {
39 Delete::send(actor, community, object_id, None, context).await
41 UndoDelete::send(actor, community, object_id, None, context).await
45 // TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
47 pub async fn send_apub_remove(
49 community: &Community,
53 context: &LemmyContext,
54 ) -> Result<(), LemmyError> {
56 Delete::send(actor, community, object_id, Some(reason), context).await
58 UndoDelete::send(actor, community, object_id, Some(reason), context).await
62 pub enum DeletableObjects {
63 Community(Box<Community>),
64 Comment(Box<Comment>),
68 impl DeletableObjects {
69 pub(crate) async fn read_from_db(
71 context: &LemmyContext,
72 ) -> Result<DeletableObjects, LemmyError> {
73 let id: DbUrl = ap_id.clone().into();
75 if let Some(c) = DeletableObjects::read_type_from_db::<Community>(id.clone(), context).await? {
76 return Ok(DeletableObjects::Community(Box::new(c)));
78 if let Some(p) = DeletableObjects::read_type_from_db::<Post>(id.clone(), context).await? {
79 return Ok(DeletableObjects::Post(Box::new(p)));
81 if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(id.clone(), context).await? {
82 return Ok(DeletableObjects::Comment(Box::new(c)));
84 Err(diesel::NotFound.into())
87 // TODO: a method like this should be provided by fetcher module
88 async fn read_type_from_db<Type: ApubObject + Send + 'static>(
90 context: &LemmyContext,
91 ) -> Result<Option<Type>, LemmyError> {
92 blocking(context.pool(), move |conn| {
93 Type::read_from_apub_id(conn, &ap_id).ok()
99 pub(in crate::activities) async fn verify_delete_activity(
101 activity: &dyn ActivityFields,
104 context: &LemmyContext,
105 request_counter: &mut i32,
106 ) -> Result<(), LemmyError> {
107 let object = DeletableObjects::read_from_db(object, context).await?;
109 DeletableObjects::Community(c) => {
111 // can only do this check for local community, in remote case it would try to fetch the
112 // deleted community (which fails)
113 verify_person_in_community(activity.actor(), community_id, context, request_counter)
116 // community deletion is always a mod (or admin) action
117 verify_mod_action(activity.actor(), c.actor_id(), context).await?;
119 DeletableObjects::Post(p) => {
120 verify_delete_activity_post_or_comment(
130 DeletableObjects::Comment(c) => {
131 verify_delete_activity_post_or_comment(
145 async fn verify_delete_activity_post_or_comment(
146 activity: &dyn ActivityFields,
150 context: &LemmyContext,
151 request_counter: &mut i32,
152 ) -> Result<(), LemmyError> {
153 verify_person_in_community(activity.actor(), community_id, context, request_counter).await?;
155 verify_mod_action(activity.actor(), community_id.clone(), context).await?;
157 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
158 verify_domains_match(activity.actor(), object_id)?;
163 struct WebsocketMessages {
164 community: UserOperationCrud,
165 post: UserOperationCrud,
166 comment: UserOperationCrud,
169 /// Write deletion or restoring of an object to the database, and send websocket message.
170 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
171 /// because of the mod log
172 async fn receive_delete_action(
175 ws_messages: WebsocketMessages,
177 context: &LemmyContext,
178 request_counter: &mut i32,
179 ) -> Result<(), LemmyError> {
180 match DeletableObjects::read_from_db(object, context).await? {
181 DeletableObjects::Community(community) => {
183 let mod_ = get_or_fetch_and_upsert_person(actor, context, request_counter).await?;
184 let object = community.actor_id();
185 send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
188 let community = blocking(context.pool(), move |conn| {
189 Community::update_deleted(conn, community.id, deleted)
192 send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
194 DeletableObjects::Post(post) => {
195 let deleted_post = blocking(context.pool(), move |conn| {
196 Post::update_deleted(conn, post.id, deleted)
199 send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
201 DeletableObjects::Comment(comment) => {
202 let deleted_comment = blocking(context.pool(), move |conn| {
203 Comment::update_deleted(conn, comment.id, deleted)
206 send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;