3 deletion::{delete::Delete, undo_delete::UndoDelete},
5 verify_person_in_community,
7 fetcher::object_id::ObjectId,
9 use diesel::PgConnection;
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, person::Person, 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: &Community,
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: &Community,
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<Community>),
60 Comment(Box<Comment>),
64 impl DeletableObjects {
65 pub(crate) async fn read_from_db(
67 context: &LemmyContext,
68 ) -> Result<DeletableObjects, LemmyError> {
70 DeletableObjects::read_type_from_db::<Community>(ap_id.clone(), context).await?
72 return Ok(DeletableObjects::Community(Box::new(c)));
74 if let Some(p) = DeletableObjects::read_type_from_db::<Post>(ap_id.clone(), context).await? {
75 return Ok(DeletableObjects::Post(Box::new(p)));
77 if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(ap_id.clone(), context).await? {
78 return Ok(DeletableObjects::Comment(Box::new(c)));
80 Err(diesel::NotFound.into())
83 // TODO: a method like this should be provided by fetcher module
84 async fn read_type_from_db<Type>(
86 context: &LemmyContext,
87 ) -> Result<Option<Type>, LemmyError>
89 Type: ApubObject<DataType = PgConnection> + Send + 'static,
91 blocking(context.pool(), move |conn| {
92 Type::read_from_apub_id(conn, ap_id)
98 pub(in crate::activities) async fn verify_delete_activity(
100 activity: &dyn ActivityFields,
101 community_id: &ObjectId<Community>,
103 context: &LemmyContext,
104 request_counter: &mut i32,
105 ) -> Result<(), LemmyError> {
106 let object = DeletableObjects::read_from_db(object, context).await?;
107 let actor = ObjectId::new(activity.actor().clone());
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(&actor, community_id, context, request_counter).await?;
115 // community deletion is always a mod (or admin) action
118 ObjectId::new(c.actor_id()),
124 DeletableObjects::Post(p) => {
125 verify_delete_activity_post_or_comment(
135 DeletableObjects::Comment(c) => {
136 verify_delete_activity_post_or_comment(
150 async fn verify_delete_activity_post_or_comment(
151 activity: &dyn ActivityFields,
153 community_id: &ObjectId<Community>,
155 context: &LemmyContext,
156 request_counter: &mut i32,
157 ) -> Result<(), LemmyError> {
158 let actor = ObjectId::new(activity.actor().clone());
159 verify_person_in_community(&actor, community_id, context, request_counter).await?;
161 verify_mod_action(&actor, community_id.clone(), context, request_counter).await?;
163 // domain of post ap_id and post.creator ap_id are identical, so we just check the former
164 verify_domains_match(activity.actor(), object_id)?;
169 struct WebsocketMessages {
170 community: UserOperationCrud,
171 post: UserOperationCrud,
172 comment: UserOperationCrud,
175 /// Write deletion or restoring of an object to the database, and send websocket message.
176 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
177 /// because of the mod log
178 async fn receive_delete_action(
180 actor: &ObjectId<Person>,
181 ws_messages: WebsocketMessages,
183 context: &LemmyContext,
184 request_counter: &mut i32,
185 ) -> Result<(), LemmyError> {
186 match DeletableObjects::read_from_db(object, context).await? {
187 DeletableObjects::Community(community) => {
189 let mod_ = actor.dereference(context, request_counter).await?;
190 let object = community.actor_id();
191 send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
194 let community = blocking(context.pool(), move |conn| {
195 Community::update_deleted(conn, community.id, deleted)
198 send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
200 DeletableObjects::Post(post) => {
201 let deleted_post = blocking(context.pool(), move |conn| {
202 Post::update_deleted(conn, post.id, deleted)
205 send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
207 DeletableObjects::Comment(comment) => {
208 let deleted_comment = blocking(context.pool(), move |conn| {
209 Comment::update_deleted(conn, comment.id, deleted)
212 send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;