1 use activitystreams::{activity::kind::UndoType, public};
5 use lemmy_api_common::blocking;
8 traits::{ActivityHandler, ActorType},
10 use lemmy_db_schema::source::{comment::Comment, community::Community, post::Post};
11 use lemmy_utils::LemmyError;
12 use lemmy_websocket::{
13 send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
20 community::{announce::GetCommunity, send_to_community},
22 receive_delete_action,
23 verify_delete_activity,
31 activity_lists::AnnouncableActivities,
32 fetcher::object_id::ObjectId,
33 objects::{community::ApubCommunity, person::ApubPerson},
34 protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete},
37 #[async_trait::async_trait(?Send)]
38 impl ActivityHandler for UndoDelete {
39 type DataType = LemmyContext;
42 context: &Data<LemmyContext>,
43 request_counter: &mut i32,
44 ) -> Result<(), LemmyError> {
45 verify_is_public(&self.to)?;
46 verify_activity(self, &context.settings())?;
47 self.object.verify(context, request_counter).await?;
48 let community = self.get_community(context, request_counter).await?;
49 verify_delete_activity(
53 self.object.summary.is_some(),
63 context: &Data<LemmyContext>,
64 request_counter: &mut i32,
65 ) -> Result<(), LemmyError> {
66 if self.object.summary.is_some() {
67 UndoDelete::receive_undo_remove_action(&self.object.object, context).await
69 receive_delete_action(
73 community: UserOperationCrud::EditCommunity,
74 post: UserOperationCrud::EditPost,
75 comment: UserOperationCrud::EditComment,
87 pub(in crate::activities::deletion) async fn send(
89 community: &ApubCommunity,
91 summary: Option<String>,
92 context: &LemmyContext,
93 ) -> Result<(), LemmyError> {
94 let object = Delete::new(actor, community, object_id, summary, context)?;
96 let id = generate_activity_id(
98 &context.settings().get_protocol_and_hostname(),
100 let undo = UndoDelete {
101 actor: ObjectId::new(actor.actor_id()),
104 cc: vec![community.actor_id()],
105 kind: UndoType::Undo,
107 unparsed: Default::default(),
110 let activity = AnnouncableActivities::UndoDelete(undo);
111 send_to_community(activity, &id, actor, community, vec![], context).await
114 pub(in crate::activities) async fn receive_undo_remove_action(
116 context: &LemmyContext,
117 ) -> Result<(), LemmyError> {
118 use UserOperationCrud::*;
119 match DeletableObjects::read_from_db(object, context).await? {
120 DeletableObjects::Community(community) => {
122 return Err(anyhow!("Only local admin can restore community").into());
124 let deleted_community = blocking(context.pool(), move |conn| {
125 Community::update_removed(conn, community.id, false)
128 send_community_ws_message(deleted_community.id, EditCommunity, None, None, context).await?;
130 DeletableObjects::Post(post) => {
131 let removed_post = blocking(context.pool(), move |conn| {
132 Post::update_removed(conn, post.id, false)
135 send_post_ws_message(removed_post.id, EditPost, None, None, context).await?;
137 DeletableObjects::Comment(comment) => {
138 let removed_comment = blocking(context.pool(), move |conn| {
139 Comment::update_removed(conn, comment.id, false)
142 send_comment_ws_message_simple(removed_comment.id, EditComment, context).await?;
149 #[async_trait::async_trait(?Send)]
150 impl GetCommunity for UndoDelete {
151 async fn get_community(
153 context: &LemmyContext,
154 request_counter: &mut i32,
155 ) -> Result<ApubCommunity, LemmyError> {
156 self.object.get_community(context, request_counter).await