3 community::announce::AnnouncableActivities,
7 verify_delete_activity,
14 activity_queue::send_to_community_new,
15 extensions::context::lemmy_context,
16 fetcher::object_id::ObjectId,
19 use activitystreams::{
20 activity::kind::UndoType,
22 primitives::OneOrMany,
26 use lemmy_api_common::blocking;
27 use lemmy_apub_lib::{values::PublicUrl, ActivityFields, ActivityHandler};
28 use lemmy_db_queries::source::{comment::Comment_, community::Community_, post::Post_};
29 use lemmy_db_schema::source::{comment::Comment, community::Community, person::Person, post::Post};
30 use lemmy_utils::LemmyError;
31 use lemmy_websocket::{
32 send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
36 use serde::{Deserialize, Serialize};
39 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
40 #[serde(rename_all = "camelCase")]
41 pub struct UndoDelete {
42 actor: ObjectId<Person>,
45 cc: [ObjectId<Community>; 1],
46 #[serde(rename = "type")]
49 #[serde(rename = "@context")]
50 context: OneOrMany<AnyBase>,
55 #[async_trait::async_trait(?Send)]
56 impl ActivityHandler for UndoDelete {
59 context: &LemmyContext,
60 request_counter: &mut i32,
61 ) -> Result<(), LemmyError> {
62 verify_activity(self)?;
63 self.object.verify(context, request_counter).await?;
64 verify_delete_activity(
68 self.object.summary.is_some(),
78 context: &LemmyContext,
79 request_counter: &mut i32,
80 ) -> Result<(), LemmyError> {
81 if self.object.summary.is_some() {
82 UndoDelete::receive_undo_remove_action(&self.object.object, context).await
84 receive_delete_action(
88 community: UserOperationCrud::EditCommunity,
89 post: UserOperationCrud::EditPost,
90 comment: UserOperationCrud::EditComment,
102 pub(in crate::activities::deletion) async fn send(
104 community: &Community,
106 summary: Option<String>,
107 context: &LemmyContext,
108 ) -> Result<(), LemmyError> {
109 let object = Delete::new(actor, community, object_id, summary)?;
111 let id = generate_activity_id(UndoType::Undo)?;
112 let undo = UndoDelete {
113 actor: ObjectId::new(actor.actor_id()),
114 to: [PublicUrl::Public],
116 cc: [ObjectId::new(community.actor_id())],
117 kind: UndoType::Undo,
119 context: lemmy_context(),
120 unparsed: Default::default(),
123 let activity = AnnouncableActivities::UndoDelete(undo);
124 send_to_community_new(activity, &id, actor, community, vec![], context).await
127 pub(in crate::activities) async fn receive_undo_remove_action(
129 context: &LemmyContext,
130 ) -> Result<(), LemmyError> {
131 use UserOperationCrud::*;
132 match DeletableObjects::read_from_db(object, context).await? {
133 DeletableObjects::Community(community) => {
135 return Err(anyhow!("Only local admin can restore community").into());
137 let deleted_community = blocking(context.pool(), move |conn| {
138 Community::update_removed(conn, community.id, false)
141 send_community_ws_message(deleted_community.id, EditCommunity, None, None, context).await?;
143 DeletableObjects::Post(post) => {
144 let removed_post = blocking(context.pool(), move |conn| {
145 Post::update_removed(conn, post.id, false)
148 send_post_ws_message(removed_post.id, EditPost, None, None, context).await?;
150 DeletableObjects::Comment(comment) => {
151 let removed_comment = blocking(context.pool(), move |conn| {
152 Comment::update_removed(conn, comment.id, false)
155 send_comment_ws_message_simple(removed_comment.id, EditComment, context).await?;