crates/apub/src/objects/private_message.rs

   1 use crate::{
   2   check_apub_id_valid_with_strictness,
   3   fetch_local_site_data,
   4   objects::read_from_string_or_source,
   5   protocol::{
   6     objects::chat_message::{ChatMessage, ChatMessageType},
   7     Source,
   8   },
   9 };
  10 use activitypub_federation::{
  11   config::Data,
  12   protocol::{values::MediaTypeHtml, verification::verify_domains_match},
  13   traits::Object,
  14 };
  15 use chrono::NaiveDateTime;
  16 use lemmy_api_common::{context::LemmyContext, utils::check_person_block};
  17 use lemmy_db_schema::{
  18   source::{
  19     person::Person,
  20     private_message::{PrivateMessage, PrivateMessageInsertForm},
  21   },
  22   traits::Crud,
  23 };
  24 use lemmy_utils::{
  25   error::LemmyError,
  26   utils::{markdown::markdown_to_html, time::convert_datetime},
  27 };
  28 use std::ops::Deref;
  29 use url::Url;
  30
  31 #[derive(Clone, Debug)]
  32 pub struct ApubPrivateMessage(pub(crate) PrivateMessage);
  33
  34 impl Deref for ApubPrivateMessage {
  35   type Target = PrivateMessage;
  36   fn deref(&self) -> &Self::Target {
  37     &self.0
  38   }
  39 }
  40
  41 impl From<PrivateMessage> for ApubPrivateMessage {
  42   fn from(pm: PrivateMessage) -> Self {
  43     ApubPrivateMessage(pm)
  44   }
  45 }
  46
  47 #[async_trait::async_trait]
  48 impl Object for ApubPrivateMessage {
  49   type DataType = LemmyContext;
  50   type Kind = ChatMessage;
  51   type Error = LemmyError;
  52
  53   fn last_refreshed_at(&self) -> Option<NaiveDateTime> {
  54     None
  55   }
  56
  57   #[tracing::instrument(skip_all)]
  58   async fn read_from_id(
  59     object_id: Url,
  60     context: &Data<Self::DataType>,
  61   ) -> Result<Option<Self>, LemmyError> {
  62     Ok(
  63       PrivateMessage::read_from_apub_id(context.pool(), object_id)
  64         .await?
  65         .map(Into::into),
  66     )
  67   }
  68
  69   async fn delete(self, _context: &Data<Self::DataType>) -> Result<(), LemmyError> {
  70     // do nothing, because pm can't be fetched over http
  71     unimplemented!()
  72   }
  73
  74   #[tracing::instrument(skip_all)]
  75   async fn into_json(self, context: &Data<Self::DataType>) -> Result<ChatMessage, LemmyError> {
  76     let creator_id = self.creator_id;
  77     let creator = Person::read(context.pool(), creator_id).await?;
  78
  79     let recipient_id = self.recipient_id;
  80     let recipient = Person::read(context.pool(), recipient_id).await?;
  81
  82     let note = ChatMessage {
  83       r#type: ChatMessageType::ChatMessage,
  84       id: self.ap_id.clone().into(),
  85       attributed_to: creator.actor_id.into(),
  86       to: [recipient.actor_id.into()],
  87       content: markdown_to_html(&self.content),
  88       media_type: Some(MediaTypeHtml::Html),
  89       source: Some(Source::new(self.content.clone())),
  90       published: Some(convert_datetime(self.published)),
  91       updated: self.updated.map(convert_datetime),
  92     };
  93     Ok(note)
  94   }
  95
  96   #[tracing::instrument(skip_all)]
  97   async fn verify(
  98     note: &ChatMessage,
  99     expected_domain: &Url,
 100     context: &Data<Self::DataType>,
 101   ) -> Result<(), LemmyError> {
 102     verify_domains_match(note.id.inner(), expected_domain)?;
 103     verify_domains_match(note.attributed_to.inner(), note.id.inner())?;
 104
 105     let local_site_data = fetch_local_site_data(context.pool()).await?;
 106
 107     check_apub_id_valid_with_strictness(
 108       note.id.inner(),
 109       false,
 110       &local_site_data,
 111       context.settings(),
 112     )?;
 113     let person = note.attributed_to.dereference(context).await?;
 114     if person.banned {
 115       return Err(LemmyError::from_message("Person is banned from site"));
 116     }
 117     Ok(())
 118   }
 119
 120   #[tracing::instrument(skip_all)]
 121   async fn from_json(
 122     note: ChatMessage,
 123     context: &Data<Self::DataType>,
 124   ) -> Result<ApubPrivateMessage, LemmyError> {
 125     let creator = note.attributed_to.dereference(context).await?;
 126     let recipient = note.to[0].dereference(context).await?;
 127     check_person_block(creator.id, recipient.id, context.pool()).await?;
 128
 129     let form = PrivateMessageInsertForm {
 130       creator_id: creator.id,
 131       recipient_id: recipient.id,
 132       content: read_from_string_or_source(&note.content, &None, &note.source),
 133       published: note.published.map(|u| u.naive_local()),
 134       updated: note.updated.map(|u| u.naive_local()),
 135       deleted: Some(false),
 136       read: None,
 137       ap_id: Some(note.id.into()),
 138       local: Some(false),
 139     };
 140     let pm = PrivateMessage::create(context.pool(), &form).await?;
 141     Ok(pm.into())
 142   }
 143 }
 144
 145 #[cfg(test)]
 146 mod tests {
 147   use super::*;
 148   use crate::{
 149     objects::{
 150       instance::{tests::parse_lemmy_instance, ApubSite},
 151       person::ApubPerson,
 152       tests::init_context,
 153     },
 154     protocol::tests::file_to_json_object,
 155   };
 156   use assert_json_diff::assert_json_include;
 157   use lemmy_db_schema::source::site::Site;
 158   use serial_test::serial;
 159
 160   async fn prepare_comment_test(
 161     url: &Url,
 162     context: &Data<LemmyContext>,
 163   ) -> (ApubPerson, ApubPerson, ApubSite) {
 164     let context2 = context.reset_request_count();
 165     let lemmy_person = file_to_json_object("assets/lemmy/objects/person.json").unwrap();
 166     let site = parse_lemmy_instance(&context2).await;
 167     ApubPerson::verify(&lemmy_person, url, &context2)
 168       .await
 169       .unwrap();
 170     let person1 = ApubPerson::from_json(lemmy_person, &context2)
 171       .await
 172       .unwrap();
 173     let pleroma_person = file_to_json_object("assets/pleroma/objects/person.json").unwrap();
 174     let pleroma_url = Url::parse("https://queer.hacktivis.me/users/lanodan").unwrap();
 175     ApubPerson::verify(&pleroma_person, &pleroma_url, &context2)
 176       .await
 177       .unwrap();
 178     let person2 = ApubPerson::from_json(pleroma_person, &context2)
 179       .await
 180       .unwrap();
 181     (person1, person2, site)
 182   }
 183
 184   async fn cleanup(data: (ApubPerson, ApubPerson, ApubSite), context: &Data<LemmyContext>) {
 185     Person::delete(context.pool(), data.0.id).await.unwrap();
 186     Person::delete(context.pool(), data.1.id).await.unwrap();
 187     Site::delete(context.pool(), data.2.id).await.unwrap();
 188   }
 189
 190   #[tokio::test]
 191   #[serial]
 192   async fn test_parse_lemmy_pm() {
 193     let context = init_context().await;
 194     let url = Url::parse("https://enterprise.lemmy.ml/private_message/1621").unwrap();
 195     let data = prepare_comment_test(&url, &context).await;
 196     let json: ChatMessage = file_to_json_object("assets/lemmy/objects/chat_message.json").unwrap();
 197     ApubPrivateMessage::verify(&json, &url, &context)
 198       .await
 199       .unwrap();
 200     let pm = ApubPrivateMessage::from_json(json.clone(), &context)
 201       .await
 202       .unwrap();
 203
 204     assert_eq!(pm.ap_id.clone(), url.into());
 205     assert_eq!(pm.content.len(), 20);
 206     assert_eq!(context.request_count(), 0);
 207
 208     let pm_id = pm.id;
 209     let to_apub = pm.into_json(&context).await.unwrap();
 210     assert_json_include!(actual: json, expected: to_apub);
 211
 212     PrivateMessage::delete(context.pool(), pm_id).await.unwrap();
 213     cleanup(data, &context).await;
 214   }
 215
 216   #[tokio::test]
 217   #[serial]
 218   async fn test_parse_pleroma_pm() {
 219     let context = init_context().await;
 220     let url = Url::parse("https://enterprise.lemmy.ml/private_message/1621").unwrap();
 221     let data = prepare_comment_test(&url, &context).await;
 222     let pleroma_url = Url::parse("https://queer.hacktivis.me/objects/2").unwrap();
 223     let json = file_to_json_object("assets/pleroma/objects/chat_message.json").unwrap();
 224     ApubPrivateMessage::verify(&json, &pleroma_url, &context)
 225       .await
 226       .unwrap();
 227     let pm = ApubPrivateMessage::from_json(json, &context).await.unwrap();
 228
 229     assert_eq!(pm.ap_id, pleroma_url.into());
 230     assert_eq!(pm.content.len(), 3);
 231     assert_eq!(context.request_count(), 0);
 232
 233     PrivateMessage::delete(context.pool(), pm.id).await.unwrap();
 234     cleanup(data, &context).await;
 235   }
 236 }