use crate::{
activities::{
- comment::send_websocket_message as send_comment_message,
- community::send_websocket_message as send_community_message,
- post::send_websocket_message as send_post_message,
+ community::announce::AnnouncableActivities,
+ deletion::{
+ receive_delete_action,
+ verify_delete_activity,
+ DeletableObjects,
+ WebsocketMessages,
+ },
+ generate_activity_id,
verify_activity,
- verify_mod_action,
- verify_person_in_community,
- },
- fetcher::{
- community::get_or_fetch_and_upsert_community,
- objects::get_or_fetch_and_insert_post_or_comment,
- person::get_or_fetch_and_upsert_person,
},
+ activity_queue::send_to_community_new,
+ extensions::context::lemmy_context,
+ fetcher::object_id::ObjectId,
ActorType,
- CommunityType,
- PostOrComment,
};
-use activitystreams::activity::kind::DeleteType;
+use activitystreams::{
+ activity::kind::DeleteType,
+ base::AnyBase,
+ primitives::OneOrMany,
+ unparsed::Unparsed,
+};
+use anyhow::anyhow;
use lemmy_api_common::blocking;
-use lemmy_apub_lib::{verify_urls_match, ActivityCommonFields, ActivityHandler, PublicUrl};
+use lemmy_apub_lib::{values::PublicUrl, ActivityFields, ActivityHandler};
use lemmy_db_queries::{
source::{comment::Comment_, community::Community_, post::Post_},
Crud,
};
-use lemmy_db_schema::source::{comment::Comment, community::Community, person::Person, post::Post};
+use lemmy_db_schema::source::{
+ comment::Comment,
+ community::Community,
+ moderator::{
+ ModRemoveComment,
+ ModRemoveCommentForm,
+ ModRemoveCommunity,
+ ModRemoveCommunityForm,
+ ModRemovePost,
+ ModRemovePostForm,
+ },
+ person::Person,
+ post::Post,
+};
use lemmy_utils::LemmyError;
-use lemmy_websocket::{LemmyContext, UserOperationCrud};
+use lemmy_websocket::{
+ send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
+ LemmyContext,
+ UserOperationCrud,
+};
+use serde::{Deserialize, Serialize};
+use serde_with::skip_serializing_none;
use url::Url;
/// This is very confusing, because there are four distinct cases to handle:
///
/// TODO: we should probably change how community deletions work to simplify this. Probably by
/// wrapping it in an announce just like other activities, instead of having the community send it.
-#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
+#[skip_serializing_none]
+#[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
#[serde(rename_all = "camelCase")]
-pub struct DeletePostCommentOrCommunity {
- to: PublicUrl,
+pub struct Delete {
+ actor: ObjectId<Person>,
+ to: [PublicUrl; 1],
pub(in crate::activities::deletion) object: Url,
- cc: [Url; 1],
+ pub(in crate::activities::deletion) cc: [ObjectId<Community>; 1],
#[serde(rename = "type")]
kind: DeleteType,
+ /// If summary is present, this is a mod action (Remove in Lemmy terms). Otherwise, its a user
+ /// deleting their own content.
+ pub(in crate::activities::deletion) summary: Option<String>,
+ id: Url,
+ #[serde(rename = "@context")]
+ context: OneOrMany<AnyBase>,
#[serde(flatten)]
- common: ActivityCommonFields,
+ unparsed: Unparsed,
}
#[async_trait::async_trait(?Send)]
-impl ActivityHandler for DeletePostCommentOrCommunity {
+impl ActivityHandler for Delete {
async fn verify(
&self,
context: &LemmyContext,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
- verify_activity(self.common())?;
- let object_community =
- get_or_fetch_and_upsert_community(&self.object, context, request_counter).await;
- // deleting a community (set counter 0 to only fetch from local db)
- if object_community.is_ok() {
- verify_mod_action(&self.common.actor, self.object.clone(), context).await?;
- }
- // deleting a post or comment
- else {
- verify_person_in_community(&self.common().actor, &self.cc[0], context, request_counter)
- .await?;
- let object_creator =
- get_post_or_comment_actor_id(&self.object, context, request_counter).await?;
- verify_urls_match(&self.common.actor, &object_creator)?;
- }
+ verify_activity(self)?;
+ verify_delete_activity(
+ &self.object,
+ self,
+ &self.cc[0],
+ self.summary.is_some(),
+ context,
+ request_counter,
+ )
+ .await?;
Ok(())
}
async fn receive(
- &self,
+ self,
context: &LemmyContext,
request_counter: &mut i32,
) -> Result<(), LemmyError> {
- let object_community =
- get_or_fetch_and_upsert_community(&self.object, context, request_counter).await;
- // deleting a community
- if let Ok(community) = object_community {
- if community.local {
- // repeat these checks just to be sure
- verify_person_in_community(&self.common().actor, &self.cc[0], context, request_counter)
- .await?;
- verify_mod_action(&self.common.actor, self.object.clone(), context).await?;
- let mod_ =
- get_or_fetch_and_upsert_person(&self.common.actor, context, request_counter).await?;
- community.send_delete(mod_, context).await?;
- }
- let deleted_community = blocking(context.pool(), move |conn| {
- Community::update_deleted(conn, community.id, true)
- })
- .await??;
-
- send_community_message(
- deleted_community.id,
- UserOperationCrud::DeleteCommunity,
+ if let Some(reason) = self.summary {
+ // We set reason to empty string if it doesn't exist, to distinguish between delete and
+ // remove. Here we change it back to option, so we don't write it to db.
+ let reason = if reason.is_empty() {
+ None
+ } else {
+ Some(reason)
+ };
+ receive_remove_action(&self.actor, &self.object, reason, context, request_counter).await
+ } else {
+ receive_delete_action(
+ &self.object,
+ &self.actor,
+ WebsocketMessages {
+ community: UserOperationCrud::DeleteCommunity,
+ post: UserOperationCrud::DeletePost,
+ comment: UserOperationCrud::DeleteComment,
+ },
+ true,
context,
+ request_counter,
)
.await
}
- // deleting a post or comment
- else {
- match get_or_fetch_and_insert_post_or_comment(&self.object, context, request_counter).await? {
- PostOrComment::Post(post) => {
- let deleted_post = blocking(context.pool(), move |conn| {
- Post::update_deleted(conn, post.id, true)
- })
- .await??;
- send_post_message(deleted_post.id, UserOperationCrud::EditPost, context).await
- }
- PostOrComment::Comment(comment) => {
- let deleted_comment = blocking(context.pool(), move |conn| {
- Comment::update_deleted(conn, comment.id, true)
- })
- .await??;
- send_comment_message(
- deleted_comment.id,
- vec![],
- UserOperationCrud::EditComment,
- context,
- )
- .await
- }
- }
- }
}
+}
- fn common(&self) -> &ActivityCommonFields {
- &self.common
+impl Delete {
+ pub(in crate::activities::deletion) fn new(
+ actor: &Person,
+ community: &Community,
+ object_id: Url,
+ summary: Option<String>,
+ ) -> Result<Delete, LemmyError> {
+ Ok(Delete {
+ actor: ObjectId::new(actor.actor_id()),
+ to: [PublicUrl::Public],
+ object: object_id,
+ cc: [ObjectId::new(community.actor_id())],
+ kind: DeleteType::Delete,
+ summary,
+ id: generate_activity_id(DeleteType::Delete)?,
+ context: lemmy_context(),
+ unparsed: Default::default(),
+ })
+ }
+ pub(in crate::activities::deletion) async fn send(
+ actor: &Person,
+ community: &Community,
+ object_id: Url,
+ summary: Option<String>,
+ context: &LemmyContext,
+ ) -> Result<(), LemmyError> {
+ let delete = Delete::new(actor, community, object_id, summary)?;
+ let delete_id = delete.id.clone();
+
+ let activity = AnnouncableActivities::Delete(delete);
+ send_to_community_new(activity, &delete_id, actor, community, vec![], context).await
}
}
-async fn get_post_or_comment_actor_id(
+pub(in crate::activities) async fn receive_remove_action(
+ actor: &ObjectId<Person>,
object: &Url,
+ reason: Option<String>,
context: &LemmyContext,
request_counter: &mut i32,
-) -> Result<Url, LemmyError> {
- let actor_id =
- match get_or_fetch_and_insert_post_or_comment(object, context, request_counter).await? {
- PostOrComment::Post(post) => {
- let creator_id = post.creator_id;
- blocking(context.pool(), move |conn| Person::read(conn, creator_id))
- .await??
- .actor_id()
- }
- PostOrComment::Comment(comment) => {
- let creator_id = comment.creator_id;
- blocking(context.pool(), move |conn| Person::read(conn, creator_id))
- .await??
- .actor_id()
+) -> Result<(), LemmyError> {
+ let actor = actor.dereference(context, request_counter).await?;
+ use UserOperationCrud::*;
+ match DeletableObjects::read_from_db(object, context).await? {
+ DeletableObjects::Community(community) => {
+ if community.local {
+ return Err(anyhow!("Only local admin can remove community").into());
}
- };
- Ok(actor_id)
+ let form = ModRemoveCommunityForm {
+ mod_person_id: actor.id,
+ community_id: community.id,
+ removed: Some(true),
+ reason,
+ expires: None,
+ };
+ blocking(context.pool(), move |conn| {
+ ModRemoveCommunity::create(conn, &form)
+ })
+ .await??;
+ let deleted_community = blocking(context.pool(), move |conn| {
+ Community::update_removed(conn, community.id, true)
+ })
+ .await??;
+
+ send_community_ws_message(deleted_community.id, RemoveCommunity, None, None, context).await?;
+ }
+ DeletableObjects::Post(post) => {
+ let form = ModRemovePostForm {
+ mod_person_id: actor.id,
+ post_id: post.id,
+ removed: Some(true),
+ reason,
+ };
+ blocking(context.pool(), move |conn| {
+ ModRemovePost::create(conn, &form)
+ })
+ .await??;
+ let removed_post = blocking(context.pool(), move |conn| {
+ Post::update_removed(conn, post.id, true)
+ })
+ .await??;
+
+ send_post_ws_message(removed_post.id, RemovePost, None, None, context).await?;
+ }
+ DeletableObjects::Comment(comment) => {
+ let form = ModRemoveCommentForm {
+ mod_person_id: actor.id,
+ comment_id: comment.id,
+ removed: Some(true),
+ reason,
+ };
+ blocking(context.pool(), move |conn| {
+ ModRemoveComment::create(conn, &form)
+ })
+ .await??;
+ let removed_comment = blocking(context.pool(), move |conn| {
+ Comment::update_removed(conn, comment.id, true)
+ })
+ .await??;
+
+ send_comment_ws_message_simple(removed_comment.id, RemoveComment, context).await?;
+ }
+ }
+ Ok(())
}
projects / lemmy.git / blobdiff