crates/apub/src/activities/create_or_update/comment.rs

   1 use crate::{
   2   activities::{
   3     check_community_deleted_or_removed,
   4     community::{announce::GetCommunity, send_activity_in_community},
   5     create_or_update::get_comment_notif_recipients,
   6     generate_activity_id,
   7     verify_is_public,
   8     verify_person_in_community,
   9   },
  10   activity_lists::AnnouncableActivities,
  11   local_instance,
  12   mentions::MentionOrValue,
  13   objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
  14   protocol::activities::{create_or_update::comment::CreateOrUpdateComment, CreateOrUpdateType},
  15   ActorType,
  16 };
  17 use activitypub_federation::{
  18   core::object_id::ObjectId,
  19   data::Data,
  20   traits::{ActivityHandler, Actor, ApubObject},
  21   utils::verify_domains_match,
  22 };
  23 use activitystreams_kinds::public;
  24 use lemmy_api_common::utils::check_post_deleted_or_removed;
  25 use lemmy_db_schema::{
  26   source::{
  27     comment::{CommentLike, CommentLikeForm},
  28     community::Community,
  29     post::Post,
  30   },
  31   traits::{Crud, Likeable},
  32 };
  33 use lemmy_utils::error::LemmyError;
  34 use lemmy_websocket::{send::send_comment_ws_message, LemmyContext, UserOperationCrud};
  35 use url::Url;
  36
  37 impl CreateOrUpdateComment {
  38   #[tracing::instrument(skip(comment, actor, kind, context))]
  39   pub async fn send(
  40     comment: ApubComment,
  41     actor: &ApubPerson,
  42     kind: CreateOrUpdateType,
  43     context: &LemmyContext,
  44     request_counter: &mut i32,
  45   ) -> Result<(), LemmyError> {
  46     // TODO: might be helpful to add a comment method to retrieve community directly
  47     let post_id = comment.post_id;
  48     let post = Post::read(context.pool(), post_id).await?;
  49     let community_id = post.community_id;
  50     let community: ApubCommunity = Community::read(context.pool(), community_id).await?.into();
  51
  52     let id = generate_activity_id(
  53       kind.clone(),
  54       &context.settings().get_protocol_and_hostname(),
  55     )?;
  56     let note = comment.into_apub(context).await?;
  57
  58     let create_or_update = CreateOrUpdateComment {
  59       actor: ObjectId::new(actor.actor_id()),
  60       to: vec![public()],
  61       cc: note.cc.clone(),
  62       tag: note.tag.clone(),
  63       object: note,
  64       kind,
  65       id: id.clone(),
  66     };
  67
  68     let tagged_users: Vec<ObjectId<ApubPerson>> = create_or_update
  69       .tag
  70       .iter()
  71       .filter_map(|t| {
  72         if let MentionOrValue::Mention(t) = t {
  73           Some(t)
  74         } else {
  75           None
  76         }
  77       })
  78       .map(|t| t.href.clone())
  79       .map(ObjectId::new)
  80       .collect();
  81     let mut inboxes = vec![];
  82     for t in tagged_users {
  83       let person = t
  84         .dereference(context, local_instance(context).await, request_counter)
  85         .await?;
  86       inboxes.push(person.shared_inbox_or_inbox());
  87     }
  88
  89     let activity = AnnouncableActivities::CreateOrUpdateComment(create_or_update);
  90     send_activity_in_community(activity, actor, &community, inboxes, false, context).await
  91   }
  92 }
  93
  94 #[async_trait::async_trait(?Send)]
  95 impl ActivityHandler for CreateOrUpdateComment {
  96   type DataType = LemmyContext;
  97   type Error = LemmyError;
  98
  99   fn id(&self) -> &Url {
 100     &self.id
 101   }
 102
 103   fn actor(&self) -> &Url {
 104     self.actor.inner()
 105   }
 106
 107   #[tracing::instrument(skip_all)]
 108   async fn verify(
 109     &self,
 110     context: &Data<LemmyContext>,
 111     request_counter: &mut i32,
 112   ) -> Result<(), LemmyError> {
 113     verify_is_public(&self.to, &self.cc)?;
 114     let post = self.object.get_parents(context, request_counter).await?.0;
 115     let community = self.get_community(context, request_counter).await?;
 116
 117     verify_person_in_community(&self.actor, &community, context, request_counter).await?;
 118     verify_domains_match(self.actor.inner(), self.object.id.inner())?;
 119     check_community_deleted_or_removed(&community)?;
 120     check_post_deleted_or_removed(&post)?;
 121
 122     ApubComment::verify(&self.object, self.actor.inner(), context, request_counter).await?;
 123     Ok(())
 124   }
 125
 126   #[tracing::instrument(skip_all)]
 127   async fn receive(
 128     self,
 129     context: &Data<LemmyContext>,
 130     request_counter: &mut i32,
 131   ) -> Result<(), LemmyError> {
 132     let comment = ApubComment::from_apub(self.object, context, request_counter).await?;
 133
 134     // author likes their own comment by default
 135     let like_form = CommentLikeForm {
 136       comment_id: comment.id,
 137       post_id: comment.post_id,
 138       person_id: comment.creator_id,
 139       score: 1,
 140     };
 141     CommentLike::like(context.pool(), &like_form).await?;
 142
 143     let do_send_email = self.kind == CreateOrUpdateType::Create;
 144     let recipients = get_comment_notif_recipients(
 145       &self.actor,
 146       &comment,
 147       do_send_email,
 148       context,
 149       request_counter,
 150     )
 151     .await?;
 152     let notif_type = match self.kind {
 153       CreateOrUpdateType::Create => UserOperationCrud::CreateComment,
 154       CreateOrUpdateType::Update => UserOperationCrud::EditComment,
 155     };
 156     send_comment_ws_message(
 157       comment.id, notif_type, None, None, None, recipients, context,
 158     )
 159     .await?;
 160     Ok(())
 161   }
 162 }
 163
 164 #[async_trait::async_trait(?Send)]
 165 impl GetCommunity for CreateOrUpdateComment {
 166   #[tracing::instrument(skip_all)]
 167   async fn get_community(
 168     &self,
 169     context: &LemmyContext,
 170     request_counter: &mut i32,
 171   ) -> Result<ApubCommunity, LemmyError> {
 172     let post = self.object.get_parents(context, request_counter).await?.0;
 173     let community = Community::read(context.pool(), post.community_id).await?;
 174     Ok(community.into())
 175   }
 176 }