use crate::{
+ activities::verify_person_in_community,
extensions::context::lemmy_context,
- fetcher::objects::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
- objects::{
- check_object_domain,
- check_object_for_community_or_site_ban,
- create_tombstone,
- get_object_from_apub,
- get_or_fetch_and_upsert_user,
- get_source_markdown_value,
- set_content_and_source,
- FromApub,
- FromApubToForm,
- ToApub,
- },
- NoteExt,
+ fetcher::object_id::ObjectId,
+ migrations::CommentInReplyToMigration,
+ objects::{create_tombstone, FromApub, Source, ToApub},
+ ActorType,
+ PostOrComment,
};
use activitystreams::{
- object::{kind::NoteType, ApObject, Note, Tombstone},
- prelude::*,
- public,
+ base::AnyBase,
+ object::{kind::NoteType, Tombstone},
+ primitives::OneOrMany,
+ unparsed::Unparsed,
};
use anyhow::{anyhow, Context};
-use lemmy_api_structs::blocking;
-use lemmy_db_queries::{Crud, DbPool};
-use lemmy_db_schema::source::{
- comment::{Comment, CommentForm},
- post::Post,
- user::User_,
+use chrono::{DateTime, FixedOffset};
+use lemmy_api_common::blocking;
+use lemmy_apub_lib::{
+ values::{MediaTypeHtml, MediaTypeMarkdown, PublicUrl},
+ verify_domains_match,
+};
+use lemmy_db_queries::{source::comment::Comment_, Crud, DbPool};
+use lemmy_db_schema::{
+ source::{
+ comment::{Comment, CommentForm},
+ community::Community,
+ person::Person,
+ post::Post,
+ },
+ CommentId,
};
use lemmy_utils::{
location_info,
LemmyError,
};
use lemmy_websocket::LemmyContext;
+use serde::{Deserialize, Serialize};
+use serde_with::skip_serializing_none;
+use std::ops::Deref;
use url::Url;
+#[skip_serializing_none]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Note {
+ #[serde(rename = "@context")]
+ context: OneOrMany<AnyBase>,
+ r#type: NoteType,
+ id: Url,
+ pub(crate) attributed_to: ObjectId<Person>,
+ /// Indicates that the object is publicly readable. Unlike [`Post.to`], this one doesn't contain
+ /// the community ID, as it would be incompatible with Pleroma (and we can get the community from
+ /// the post in [`in_reply_to`]).
+ to: PublicUrl,
+ content: String,
+ media_type: MediaTypeHtml,
+ source: Source,
+ in_reply_to: CommentInReplyToMigration,
+ published: DateTime<FixedOffset>,
+ updated: Option<DateTime<FixedOffset>>,
+ #[serde(flatten)]
+ unparsed: Unparsed,
+}
+
+impl Note {
+ pub(crate) fn id_unchecked(&self) -> &Url {
+ &self.id
+ }
+ pub(crate) fn id(&self, expected_domain: &Url) -> Result<&Url, LemmyError> {
+ verify_domains_match(&self.id, expected_domain)?;
+ Ok(&self.id)
+ }
+
+ async fn get_parents(
+ &self,
+ context: &LemmyContext,
+ request_counter: &mut i32,
+ ) -> Result<(Post, Option<CommentId>), LemmyError> {
+ match &self.in_reply_to {
+ CommentInReplyToMigration::Old(in_reply_to) => {
+ // This post, or the parent comment might not yet exist on this server yet, fetch them.
+ let post_id = in_reply_to.get(0).context(location_info!())?;
+ let post_id = ObjectId::new(post_id.clone());
+ let post = Box::pin(post_id.dereference(context, request_counter)).await?;
+
+ // The 2nd item, if it exists, is the parent comment apub_id
+ // Nested comments will automatically get fetched recursively
+ let parent_id: Option<CommentId> = match in_reply_to.get(1) {
+ Some(comment_id) => {
+ let comment_id = ObjectId::<Comment>::new(comment_id.clone());
+ let parent_comment = Box::pin(comment_id.dereference(context, request_counter)).await?;
+
+ Some(parent_comment.id)
+ }
+ None => None,
+ };
+
+ Ok((post, parent_id))
+ }
+ CommentInReplyToMigration::New(in_reply_to) => {
+ let parent = Box::pin(in_reply_to.dereference(context, request_counter).await?);
+ match parent.deref() {
+ PostOrComment::Post(p) => {
+ // Workaround because I cant figure ut how to get the post out of the box (and we dont
+ // want to stackoverflow in a deep comment hierarchy).
+ let post_id = p.id;
+ let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+ Ok((post, None))
+ }
+ PostOrComment::Comment(c) => {
+ let post_id = c.post_id;
+ let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
+ Ok((post, Some(c.id)))
+ }
+ }
+ }
+ }
+ }
+
+ pub(crate) async fn verify(
+ &self,
+ context: &LemmyContext,
+ request_counter: &mut i32,
+ ) -> Result<(), LemmyError> {
+ let (post, _parent_comment_id) = self.get_parents(context, request_counter).await?;
+ let community_id = post.community_id;
+ let community = blocking(context.pool(), move |conn| {
+ Community::read(conn, community_id)
+ })
+ .await??;
+
+ if post.locked {
+ return Err(anyhow!("Post is locked").into());
+ }
+ verify_domains_match(self.attributed_to.inner(), &self.id)?;
+ verify_person_in_community(
+ &self.attributed_to,
+ &ObjectId::new(community.actor_id()),
+ context,
+ request_counter,
+ )
+ .await?;
+ Ok(())
+ }
+}
+
#[async_trait::async_trait(?Send)]
impl ToApub for Comment {
- type ApubType = NoteExt;
-
- async fn to_apub(&self, pool: &DbPool) -> Result<NoteExt, LemmyError> {
- let mut comment = ApObject::new(Note::new());
+ type ApubType = Note;
+ async fn to_apub(&self, pool: &DbPool) -> Result<Note, LemmyError> {
let creator_id = self.creator_id;
- let creator = blocking(pool, move |conn| User_::read(conn, creator_id)).await??;
+ let creator = blocking(pool, move |conn| Person::read(conn, creator_id)).await??;
let post_id = self.post_id;
let post = blocking(pool, move |conn| Post::read(conn, post_id)).await??;
in_reply_to_vec.push(parent_comment.ap_id.into_inner());
}
- comment
- // Not needed when the Post is embedded in a collection (like for community outbox)
- .set_many_contexts(lemmy_context()?)
- .set_id(self.ap_id.to_owned().into_inner())
- .set_published(convert_datetime(self.published))
- .set_to(public())
- .set_many_in_reply_tos(in_reply_to_vec)
- .set_attributed_to(creator.actor_id.into_inner());
-
- set_content_and_source(&mut comment, &self.content)?;
-
- if let Some(u) = self.updated {
- comment.set_updated(convert_datetime(u));
- }
+ let note = Note {
+ context: lemmy_context(),
+ r#type: NoteType::Note,
+ id: self.ap_id.to_owned().into_inner(),
+ attributed_to: ObjectId::new(creator.actor_id),
+ to: PublicUrl::Public,
+ content: self.content.clone(),
+ media_type: MediaTypeHtml::Html,
+ source: Source {
+ content: self.content.clone(),
+ media_type: MediaTypeMarkdown::Markdown,
+ },
+ in_reply_to: CommentInReplyToMigration::Old(in_reply_to_vec),
+ published: convert_datetime(self.published),
+ updated: self.updated.map(convert_datetime),
+ unparsed: Default::default(),
+ };
- Ok(comment)
+ Ok(note)
}
fn to_tombstone(&self) -> Result<Tombstone, LemmyError> {
#[async_trait::async_trait(?Send)]
impl FromApub for Comment {
- type ApubType = NoteExt;
+ type ApubType = Note;
/// Converts a `Note` to `Comment`.
///
/// If the parent community, post and comment(s) are not known locally, these are also fetched.
async fn from_apub(
- note: &NoteExt,
+ note: &Note,
context: &LemmyContext,
- expected_domain: Url,
+ expected_domain: &Url,
request_counter: &mut i32,
) -> Result<Comment, LemmyError> {
- let comment: Comment =
- get_object_from_apub(note, context, expected_domain, request_counter).await?;
-
- let post_id = comment.post_id;
- let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
- check_object_for_community_or_site_ban(note, post.community_id, context, request_counter)
+ let ap_id = Some(note.id(expected_domain)?.clone().into());
+ let creator = note
+ .attributed_to
+ .dereference(context, request_counter)
.await?;
+ let (post, parent_comment_id) = note.get_parents(context, request_counter).await?;
if post.locked {
- // This is not very efficient because a comment gets inserted just to be deleted right
- // afterwards, but it seems to be the easiest way to implement it.
- blocking(context.pool(), move |conn| {
- Comment::delete(conn, comment.id)
- })
- .await??;
- Err(anyhow!("Post is locked").into())
- } else {
- Ok(comment)
+ return Err(anyhow!("Post is locked").into());
}
- }
-}
-
-#[async_trait::async_trait(?Send)]
-impl FromApubToForm<NoteExt> for CommentForm {
- async fn from_apub(
- note: &NoteExt,
- context: &LemmyContext,
- expected_domain: Url,
- request_counter: &mut i32,
- ) -> Result<CommentForm, LemmyError> {
- let creator_actor_id = ¬e
- .attributed_to()
- .context(location_info!())?
- .as_single_xsd_any_uri()
- .context(location_info!())?;
-
- let creator = get_or_fetch_and_upsert_user(creator_actor_id, context, request_counter).await?;
-
- let mut in_reply_tos = note
- .in_reply_to()
- .as_ref()
- .context(location_info!())?
- .as_many()
- .context(location_info!())?
- .iter()
- .map(|i| i.as_xsd_any_uri().context(""));
- let post_ap_id = in_reply_tos.next().context(location_info!())??;
-
- // This post, or the parent comment might not yet exist on this server yet, fetch them.
- let post = get_or_fetch_and_insert_post(&post_ap_id, context, request_counter).await?;
-
- // The 2nd item, if it exists, is the parent comment apub_id
- // For deeply nested comments, FromApub automatically gets called recursively
- let parent_id: Option<i32> = match in_reply_tos.next() {
- Some(parent_comment_uri) => {
- let parent_comment_ap_id = &parent_comment_uri?;
- let parent_comment =
- get_or_fetch_and_insert_comment(&parent_comment_ap_id, context, request_counter).await?;
-
- Some(parent_comment.id)
- }
- None => None,
- };
- let content = get_source_markdown_value(note)?.context(location_info!())?;
- let content_slurs_removed = remove_slurs(&content);
+ let content = ¬e.source.content;
+ let content_slurs_removed = remove_slurs(content);
- Ok(CommentForm {
+ let form = CommentForm {
creator_id: creator.id,
post_id: post.id,
- parent_id,
+ parent_id: parent_comment_id,
content: content_slurs_removed,
removed: None,
read: None,
- published: note.published().map(|u| u.to_owned().naive_local()),
- updated: note.updated().map(|u| u.to_owned().naive_local()),
+ published: Some(note.published.naive_local()),
+ updated: note.updated.map(|u| u.to_owned().naive_local()),
deleted: None,
- ap_id: Some(check_object_domain(note, expected_domain)?),
- local: false,
- })
+ ap_id,
+ local: Some(false),
+ };
+ Ok(blocking(context.pool(), move |conn| Comment::upsert(conn, &form)).await??)
}
}
projects / lemmy.git / blobdiff