2 extensions::context::lemmy_context,
3 fetcher::person::get_or_fetch_and_upsert_person,
4 objects::{create_tombstone, FromApub, Source, ToApub},
8 object::{kind::NoteType, Tombstone},
13 use chrono::{DateTime, FixedOffset};
14 use lemmy_api_common::blocking;
16 values::{MediaTypeHtml, MediaTypeMarkdown},
19 use lemmy_db_queries::{ApubObject, Crud, DbPool};
20 use lemmy_db_schema::source::{
22 private_message::{PrivateMessage, PrivateMessageForm},
24 use lemmy_utils::{utils::convert_datetime, LemmyError};
25 use lemmy_websocket::LemmyContext;
26 use serde::{Deserialize, Serialize};
29 #[derive(Clone, Debug, Deserialize, Serialize)]
30 #[serde(rename_all = "camelCase")]
32 #[serde(rename = "@context")]
33 context: OneOrMany<AnyBase>,
36 pub(crate) attributed_to: Url,
39 media_type: MediaTypeHtml,
41 published: DateTime<FixedOffset>,
42 updated: Option<DateTime<FixedOffset>>,
48 pub(crate) async fn verify(
50 context: &LemmyContext,
51 request_counter: &mut i32,
52 ) -> Result<(), LemmyError> {
53 verify_domains_match(&self.attributed_to, &self.id)?;
55 get_or_fetch_and_upsert_person(&self.attributed_to, context, request_counter).await?;
57 return Err(anyhow!("Person is banned from site").into());
63 #[async_trait::async_trait(?Send)]
64 impl ToApub for PrivateMessage {
67 async fn to_apub(&self, pool: &DbPool) -> Result<Note, LemmyError> {
68 let creator_id = self.creator_id;
69 let creator = blocking(pool, move |conn| Person::read(conn, creator_id)).await??;
71 let recipient_id = self.recipient_id;
72 let recipient = blocking(pool, move |conn| Person::read(conn, recipient_id)).await??;
75 context: lemmy_context(),
76 r#type: NoteType::Note,
77 id: self.ap_id.clone().into(),
78 attributed_to: creator.actor_id.into_inner(),
79 to: recipient.actor_id.into(),
80 content: self.content.clone(),
81 media_type: MediaTypeHtml::Html,
83 content: self.content.clone(),
84 media_type: MediaTypeMarkdown::Markdown,
86 published: convert_datetime(self.published),
87 updated: self.updated.map(convert_datetime),
88 unparsed: Default::default(),
93 fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
96 self.ap_id.to_owned().into(),
103 #[async_trait::async_trait(?Send)]
104 impl FromApub for PrivateMessage {
105 type ApubType = Note;
109 context: &LemmyContext,
110 _expected_domain: Url,
111 request_counter: &mut i32,
112 _mod_action_allowed: bool,
113 ) -> Result<PrivateMessage, LemmyError> {
115 get_or_fetch_and_upsert_person(¬e.attributed_to, context, request_counter).await?;
116 let recipient = get_or_fetch_and_upsert_person(¬e.to, context, request_counter).await?;
118 let form = PrivateMessageForm {
119 creator_id: creator.id,
120 recipient_id: recipient.id,
121 content: note.source.content.clone(),
122 published: Some(note.published.naive_local()),
123 updated: note.updated.map(|u| u.to_owned().naive_local()),
126 ap_id: Some(note.id.clone().into()),
130 blocking(context.pool(), move |conn| {
131 PrivateMessage::upsert(conn, &form)