crates/apub/src/objects/private_message.rs

   1 use crate::{
   2   check_is_apub_id_valid,
   3   extensions::context::lemmy_context,
   4   fetcher::person::get_or_fetch_and_upsert_person,
   5   objects::{
   6     check_object_domain,
   7     create_tombstone,
   8     get_object_from_apub,
   9     get_source_markdown_value,
  10     set_content_and_source,
  11     FromApub,
  12     FromApubToForm,
  13     ToApub,
  14   },
  15   NoteExt,
  16 };
  17 use activitystreams::{
  18   object::{kind::NoteType, ApObject, Note, Tombstone},
  19   prelude::*,
  20 };
  21 use anyhow::Context;
  22 use lemmy_api_common::blocking;
  23 use lemmy_db_queries::{Crud, DbPool};
  24 use lemmy_db_schema::source::{
  25   person::Person,
  26   private_message::{PrivateMessage, PrivateMessageForm},
  27 };
  28 use lemmy_utils::{location_info, utils::convert_datetime, LemmyError};
  29 use lemmy_websocket::LemmyContext;
  30 use url::Url;
  31
  32 #[async_trait::async_trait(?Send)]
  33 impl ToApub for PrivateMessage {
  34   type ApubType = NoteExt;
  35
  36   async fn to_apub(&self, pool: &DbPool) -> Result<NoteExt, LemmyError> {
  37     let mut private_message = ApObject::new(Note::new());
  38
  39     let creator_id = self.creator_id;
  40     let creator = blocking(pool, move |conn| Person::read(conn, creator_id)).await??;
  41
  42     let recipient_id = self.recipient_id;
  43     let recipient = blocking(pool, move |conn| Person::read(conn, recipient_id)).await??;
  44
  45     private_message
  46       .set_many_contexts(lemmy_context()?)
  47       .set_id(self.ap_id.to_owned().into_inner())
  48       .set_published(convert_datetime(self.published))
  49       .set_to(recipient.actor_id.into_inner())
  50       .set_attributed_to(creator.actor_id.into_inner());
  51
  52     set_content_and_source(&mut private_message, &self.content)?;
  53
  54     if let Some(u) = self.updated {
  55       private_message.set_updated(convert_datetime(u));
  56     }
  57
  58     Ok(private_message)
  59   }
  60
  61   fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
  62     create_tombstone(
  63       self.deleted,
  64       self.ap_id.to_owned().into(),
  65       self.updated,
  66       NoteType::Note,
  67     )
  68   }
  69 }
  70
  71 #[async_trait::async_trait(?Send)]
  72 impl FromApub for PrivateMessage {
  73   type ApubType = NoteExt;
  74
  75   async fn from_apub(
  76     note: &NoteExt,
  77     context: &LemmyContext,
  78     expected_domain: Url,
  79     request_counter: &mut i32,
  80     mod_action_allowed: bool,
  81   ) -> Result<PrivateMessage, LemmyError> {
  82     get_object_from_apub(
  83       note,
  84       context,
  85       expected_domain,
  86       request_counter,
  87       mod_action_allowed,
  88     )
  89     .await
  90   }
  91 }
  92
  93 #[async_trait::async_trait(?Send)]
  94 impl FromApubToForm<NoteExt> for PrivateMessageForm {
  95   async fn from_apub(
  96     note: &NoteExt,
  97     context: &LemmyContext,
  98     expected_domain: Url,
  99     request_counter: &mut i32,
 100     _mod_action_allowed: bool,
 101   ) -> Result<PrivateMessageForm, LemmyError> {
 102     let creator_actor_id = note
 103       .attributed_to()
 104       .context(location_info!())?
 105       .clone()
 106       .single_xsd_any_uri()
 107       .context(location_info!())?;
 108
 109     let creator =
 110       get_or_fetch_and_upsert_person(&creator_actor_id, context, request_counter).await?;
 111     let recipient_actor_id = note
 112       .to()
 113       .context(location_info!())?
 114       .clone()
 115       .single_xsd_any_uri()
 116       .context(location_info!())?;
 117     let recipient =
 118       get_or_fetch_and_upsert_person(&recipient_actor_id, context, request_counter).await?;
 119     let ap_id = note.id_unchecked().context(location_info!())?.to_string();
 120     check_is_apub_id_valid(&Url::parse(&ap_id)?)?;
 121
 122     let content = get_source_markdown_value(note)?.context(location_info!())?;
 123
 124     Ok(PrivateMessageForm {
 125       creator_id: creator.id,
 126       recipient_id: recipient.id,
 127       content,
 128       published: note.published().map(|u| u.to_owned().naive_local()),
 129       updated: note.updated().map(|u| u.to_owned().naive_local()),
 130       deleted: None,
 131       read: None,
 132       ap_id: Some(check_object_domain(note, expected_domain)?),
 133       local: Some(false),
 134     })
 135   }
 136 }