+use crate::{
+ activities::{
+ deletion::{delete::Delete, undo_delete::UndoDelete},
+ verify_mod_action,
+ verify_person_in_community,
+ },
+ fetcher::object_id::ObjectId,
+ ActorType,
+};
+use lemmy_api_common::blocking;
+use lemmy_apub_lib::{verify_domains_match, ActivityFields};
+use lemmy_db_queries::{
+ source::{comment::Comment_, community::Community_, post::Post_},
+ ApubObject,
+};
+use lemmy_db_schema::{
+ source::{comment::Comment, community::Community, person::Person, post::Post},
+ DbUrl,
+};
+use lemmy_utils::LemmyError;
+use lemmy_websocket::{
+ send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
+ LemmyContext,
+ UserOperationCrud,
+};
+use url::Url;
+
pub mod delete;
pub mod undo_delete;
+
+pub async fn send_apub_delete(
+ actor: &Person,
+ community: &Community,
+ object_id: Url,
+ deleted: bool,
+ context: &LemmyContext,
+) -> Result<(), LemmyError> {
+ if deleted {
+ Delete::send(actor, community, object_id, None, context).await
+ } else {
+ UndoDelete::send(actor, community, object_id, None, context).await
+ }
+}
+
+// TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
+// ugly
+pub async fn send_apub_remove(
+ actor: &Person,
+ community: &Community,
+ object_id: Url,
+ reason: String,
+ removed: bool,
+ context: &LemmyContext,
+) -> Result<(), LemmyError> {
+ if removed {
+ Delete::send(actor, community, object_id, Some(reason), context).await
+ } else {
+ UndoDelete::send(actor, community, object_id, Some(reason), context).await
+ }
+}
+
+pub enum DeletableObjects {
+ Community(Box<Community>),
+ Comment(Box<Comment>),
+ Post(Box<Post>),
+}
+
+impl DeletableObjects {
+ pub(crate) async fn read_from_db(
+ ap_id: &Url,
+ context: &LemmyContext,
+ ) -> Result<DeletableObjects, LemmyError> {
+ let id: DbUrl = ap_id.clone().into();
+
+ if let Some(c) = DeletableObjects::read_type_from_db::<Community>(id.clone(), context).await? {
+ return Ok(DeletableObjects::Community(Box::new(c)));
+ }
+ if let Some(p) = DeletableObjects::read_type_from_db::<Post>(id.clone(), context).await? {
+ return Ok(DeletableObjects::Post(Box::new(p)));
+ }
+ if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(id.clone(), context).await? {
+ return Ok(DeletableObjects::Comment(Box::new(c)));
+ }
+ Err(diesel::NotFound.into())
+ }
+
+ // TODO: a method like this should be provided by fetcher module
+ async fn read_type_from_db<Type: ApubObject + Send + 'static>(
+ ap_id: DbUrl,
+ context: &LemmyContext,
+ ) -> Result<Option<Type>, LemmyError> {
+ blocking(context.pool(), move |conn| {
+ Type::read_from_apub_id(conn, &ap_id).ok()
+ })
+ .await
+ }
+}
+
+pub(in crate::activities) async fn verify_delete_activity(
+ object: &Url,
+ activity: &dyn ActivityFields,
+ community_id: &ObjectId<Community>,
+ is_mod_action: bool,
+ context: &LemmyContext,
+ request_counter: &mut i32,
+) -> Result<(), LemmyError> {
+ let object = DeletableObjects::read_from_db(object, context).await?;
+ let actor = ObjectId::new(activity.actor().clone());
+ match object {
+ DeletableObjects::Community(c) => {
+ if c.local {
+ // can only do this check for local community, in remote case it would try to fetch the
+ // deleted community (which fails)
+ verify_person_in_community(&actor, community_id, context, request_counter).await?;
+ }
+ // community deletion is always a mod (or admin) action
+ verify_mod_action(&actor, ObjectId::new(c.actor_id()), context).await?;
+ }
+ DeletableObjects::Post(p) => {
+ verify_delete_activity_post_or_comment(
+ activity,
+ &p.ap_id.into(),
+ community_id,
+ is_mod_action,
+ context,
+ request_counter,
+ )
+ .await?;
+ }
+ DeletableObjects::Comment(c) => {
+ verify_delete_activity_post_or_comment(
+ activity,
+ &c.ap_id.into(),
+ community_id,
+ is_mod_action,
+ context,
+ request_counter,
+ )
+ .await?;
+ }
+ }
+ Ok(())
+}
+
+async fn verify_delete_activity_post_or_comment(
+ activity: &dyn ActivityFields,
+ object_id: &Url,
+ community_id: &ObjectId<Community>,
+ is_mod_action: bool,
+ context: &LemmyContext,
+ request_counter: &mut i32,
+) -> Result<(), LemmyError> {
+ let actor = ObjectId::new(activity.actor().clone());
+ verify_person_in_community(&actor, community_id, context, request_counter).await?;
+ if is_mod_action {
+ verify_mod_action(&actor, community_id.clone(), context).await?;
+ } else {
+ // domain of post ap_id and post.creator ap_id are identical, so we just check the former
+ verify_domains_match(activity.actor(), object_id)?;
+ }
+ Ok(())
+}
+
+struct WebsocketMessages {
+ community: UserOperationCrud,
+ post: UserOperationCrud,
+ comment: UserOperationCrud,
+}
+
+/// Write deletion or restoring of an object to the database, and send websocket message.
+/// TODO: we should do something similar for receive_remove_action(), but its much more complicated
+/// because of the mod log
+async fn receive_delete_action(
+ object: &Url,
+ actor: &ObjectId<Person>,
+ ws_messages: WebsocketMessages,
+ deleted: bool,
+ context: &LemmyContext,
+ request_counter: &mut i32,
+) -> Result<(), LemmyError> {
+ match DeletableObjects::read_from_db(object, context).await? {
+ DeletableObjects::Community(community) => {
+ if community.local {
+ let mod_ = actor.dereference(context, request_counter).await?;
+ let object = community.actor_id();
+ send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
+ }
+
+ let community = blocking(context.pool(), move |conn| {
+ Community::update_deleted(conn, community.id, deleted)
+ })
+ .await??;
+ send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
+ }
+ DeletableObjects::Post(post) => {
+ let deleted_post = blocking(context.pool(), move |conn| {
+ Post::update_deleted(conn, post.id, deleted)
+ })
+ .await??;
+ send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
+ }
+ DeletableObjects::Comment(comment) => {
+ let deleted_comment = blocking(context.pool(), move |conn| {
+ Comment::update_deleted(conn, comment.id, deleted)
+ })
+ .await??;
+ send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;
+ }
+ }
+ Ok(())
+}
projects / lemmy.git / blobdiff