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, get_or_fetch_and_insert_post_or_comment, }, migrations::CommentInReplyToMigration, objects::{create_tombstone, get_or_fetch_and_upsert_person, FromApub, Source, ToApub}, ActorType, PostOrComment, }; use activitystreams::{ base::AnyBase, object::{kind::NoteType, Tombstone}, primitives::OneOrMany, unparsed::Unparsed, }; use anyhow::{anyhow, Context}; use chrono::{DateTime, FixedOffset}; use lemmy_api_common::blocking; use lemmy_apub_lib::{ values::{MediaTypeHtml, MediaTypeMarkdown, PublicUrl}, verify_domains_match, }; use lemmy_db_queries::{ApubObject, Crud, DbPool}; use lemmy_db_schema::{ source::{ comment::{Comment, CommentForm}, community::Community, person::Person, post::Post, }, CommentId, }; use lemmy_utils::{ location_info, utils::{convert_datetime, remove_slurs}, LemmyError, }; use lemmy_websocket::LemmyContext; use serde::{Deserialize, Serialize}; use std::ops::Deref; use url::Url; #[derive(Clone, Debug, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Note { #[serde(rename = "@context")] context: OneOrMany, r#type: NoteType, pub(crate) id: Url, pub(crate) attributed_to: Url, /// 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, updated: Option>, #[serde(flatten)] unparsed: Unparsed, } impl Note { async fn get_parents( &self, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(Post, Option), 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 = Box::pin(get_or_fetch_and_insert_post( post_id, 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 = match in_reply_to.get(1) { Some(parent_comment_uri) => { let parent_comment = Box::pin(get_or_fetch_and_insert_comment( parent_comment_uri, context, request_counter, )) .await?; Some(parent_comment.id) } None => None, }; Ok((post, parent_id)) } CommentInReplyToMigration::New(in_reply_to) => { let parent = Box::pin( get_or_fetch_and_insert_post_or_comment(in_reply_to, 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, &self.id)?; verify_person_in_community( &self.attributed_to, &community.actor_id(), context, request_counter, ) .await?; Ok(()) } } #[async_trait::async_trait(?Send)] impl ToApub for Comment { type ApubType = Note; async fn to_apub(&self, pool: &DbPool) -> Result { let creator_id = self.creator_id; 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??; // Add a vector containing some important info to the "in_reply_to" field // [post_ap_id, Option(parent_comment_ap_id)] let mut in_reply_to_vec = vec![post.ap_id.into_inner()]; if let Some(parent_id) = self.parent_id { let parent_comment = blocking(pool, move |conn| Comment::read(conn, parent_id)).await??; in_reply_to_vec.push(parent_comment.ap_id.into_inner()); } let note = Note { context: lemmy_context(), r#type: NoteType::Note, id: self.ap_id.to_owned().into_inner(), attributed_to: creator.actor_id.into_inner(), 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(note) } fn to_tombstone(&self) -> Result { create_tombstone( self.deleted, self.ap_id.to_owned().into(), self.updated, NoteType::Note, ) } } #[async_trait::async_trait(?Send)] impl FromApub for Comment { 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: &Note, context: &LemmyContext, _expected_domain: Url, request_counter: &mut i32, _mod_action_allowed: bool, ) -> Result { let creator = get_or_fetch_and_upsert_person(¬e.attributed_to, context, request_counter).await?; let (post, parent_comment_id) = note.get_parents(context, request_counter).await?; let content = ¬e.source.content; let content_slurs_removed = remove_slurs(content); let form = CommentForm { creator_id: creator.id, post_id: post.id, parent_id: parent_comment_id, content: content_slurs_removed, removed: None, read: None, published: Some(note.published.naive_local()), updated: note.updated.map(|u| u.to_owned().naive_local()), deleted: None, ap_id: Some(note.id.clone().into()), local: Some(false), }; Ok(blocking(context.pool(), move |conn| Comment::upsert(conn, &form)).await??) } }