X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Fobjects%2Fcomment.rs;h=3b05ed3946e0bb6bc00f4959d70905e6155bcbf8;hb=3471f3533cb724b2cf6953d563aadfcc9f66c1d2;hp=40aef9197f38dbd7bb7aa27af1025cefa5a5f6ee;hpb=ae84258c41248fc090834df613a9ac8327cd4e72;p=lemmy.git diff --git a/crates/apub/src/objects/comment.rs b/crates/apub/src/objects/comment.rs index 40aef919..3b05ed39 100644 --- a/crates/apub/src/objects/comment.rs +++ b/crates/apub/src/objects/comment.rs @@ -1,42 +1,44 @@ use crate::{ activities::{verify_is_public, verify_person_in_community}, - check_is_apub_id_valid, + check_apub_id_valid_with_strictness, mentions::collect_non_local_mentions, objects::{read_from_string_or_source, verify_is_remote_object}, protocol::{ - objects::{note::Note, tombstone::Tombstone}, + objects::{note::Note, LanguageTag}, + InCommunity, Source, }, - PostOrComment, }; -use activitystreams_kinds::{object::NoteType, public}; +use activitypub_federation::{ + config::Data, + kinds::{object::NoteType, public}, + protocol::{values::MediaTypeMarkdownOrHtml, verification::verify_domains_match}, + traits::Object, +}; use chrono::NaiveDateTime; -use lemmy_api_common::blocking; -use lemmy_apub_lib::{ - object_id::ObjectId, - traits::ApubObject, - values::MediaTypeHtml, - verify::verify_domains_match, +use lemmy_api_common::{ + context::LemmyContext, + utils::{local_site_opt_to_slur_regex, sanitize_html}, }; use lemmy_db_schema::{ source::{ - comment::{Comment, CommentForm}, + comment::{Comment, CommentInsertForm, CommentUpdateForm}, community::Community, + local_site::LocalSite, person::Person, post::Post, }, traits::Crud, }; use lemmy_utils::{ - utils::{convert_datetime, markdown_to_html, remove_slurs}, - LemmyError, + error::{LemmyError, LemmyErrorType}, + utils::{markdown::markdown_to_html, slurs::remove_slurs, time::convert_datetime}, }; -use lemmy_websocket::LemmyContext; use std::ops::Deref; use url::Url; #[derive(Clone, Debug)] -pub struct ApubComment(Comment); +pub struct ApubComment(pub(crate) Comment); impl Deref for ApubComment { type Target = Comment; @@ -51,114 +53,94 @@ impl From for ApubComment { } } -#[async_trait::async_trait(?Send)] -impl ApubObject for ApubComment { +#[async_trait::async_trait] +impl Object for ApubComment { type DataType = LemmyContext; - type ApubType = Note; - type DbType = Comment; - type TombstoneType = Tombstone; + type Kind = Note; + type Error = LemmyError; fn last_refreshed_at(&self) -> Option { None } #[tracing::instrument(skip_all)] - async fn read_from_apub_id( + async fn read_from_id( object_id: Url, - context: &LemmyContext, + context: &Data, ) -> Result, LemmyError> { Ok( - blocking(context.pool(), move |conn| { - Comment::read_from_apub_id(conn, object_id) - }) - .await?? - .map(Into::into), + Comment::read_from_apub_id(&mut context.pool(), object_id) + .await? + .map(Into::into), ) } #[tracing::instrument(skip_all)] - async fn delete(self, context: &LemmyContext) -> Result<(), LemmyError> { + async fn delete(self, context: &Data) -> Result<(), LemmyError> { if !self.deleted { - blocking(context.pool(), move |conn| { - Comment::update_deleted(conn, self.id, true) - }) - .await??; + let form = CommentUpdateForm::builder().deleted(Some(true)).build(); + Comment::update(&mut context.pool(), self.id, &form).await?; } Ok(()) } #[tracing::instrument(skip_all)] - async fn into_apub(self, context: &LemmyContext) -> Result { + async fn into_json(self, context: &Data) -> Result { let creator_id = self.creator_id; - let creator = blocking(context.pool(), move |conn| Person::read(conn, creator_id)).await??; + let creator = Person::read(&mut context.pool(), creator_id).await?; let post_id = self.post_id; - let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??; + let post = Post::read(&mut context.pool(), post_id).await?; let community_id = post.community_id; - let community = blocking(context.pool(), move |conn| { - Community::read(conn, community_id) - }) - .await??; - - let in_reply_to = if let Some(comment_id) = self.parent_id { - let parent_comment = - blocking(context.pool(), move |conn| Comment::read(conn, comment_id)).await??; - ObjectId::::new(parent_comment.ap_id) + let community = Community::read(&mut context.pool(), community_id).await?; + + let in_reply_to = if let Some(comment_id) = self.parent_comment_id() { + let parent_comment = Comment::read(&mut context.pool(), comment_id).await?; + parent_comment.ap_id.into() } else { - ObjectId::::new(post.ap_id) + post.ap_id.into() }; - let maa = - collect_non_local_mentions(&self, ObjectId::new(community.actor_id), context, &mut 0).await?; + let language = LanguageTag::new_single(self.language_id, &mut context.pool()).await?; + let maa = collect_non_local_mentions(&self, community.actor_id.clone().into(), context).await?; let note = Note { r#type: NoteType::Note, - id: ObjectId::new(self.ap_id.clone()), - attributed_to: ObjectId::new(creator.actor_id), + id: self.ap_id.clone().into(), + attributed_to: creator.actor_id.into(), to: vec![public()], cc: maa.ccs, content: markdown_to_html(&self.content), - media_type: Some(MediaTypeHtml::Html), + media_type: Some(MediaTypeMarkdownOrHtml::Html), source: Some(Source::new(self.content.clone())), in_reply_to, published: Some(convert_datetime(self.published)), updated: self.updated.map(convert_datetime), tag: maa.tags, + distinguished: Some(self.distinguished), + language, + audience: Some(community.actor_id.into()), }; Ok(note) } - fn to_tombstone(&self) -> Result { - Ok(Tombstone::new(self.ap_id.clone().into())) - } - #[tracing::instrument(skip_all)] async fn verify( note: &Note, expected_domain: &Url, - context: &LemmyContext, - request_counter: &mut i32, + context: &Data, ) -> Result<(), LemmyError> { verify_domains_match(note.id.inner(), expected_domain)?; verify_domains_match(note.attributed_to.inner(), note.id.inner())?; verify_is_public(¬e.to, ¬e.cc)?; - let (post, _) = note.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??; - check_is_apub_id_valid(note.id.inner(), community.local, &context.settings())?; - verify_is_remote_object(note.id.inner())?; - verify_person_in_community( - ¬e.attributed_to, - &community.into(), - context, - request_counter, - ) - .await?; + let community = note.community(context).await?; + + check_apub_id_valid_with_strictness(note.id.inner(), community.local, context).await?; + verify_is_remote_object(note.id.inner(), context.settings())?; + verify_person_in_community(¬e.attributed_to, &community, context).await?; + let (post, _) = note.get_parents(context).await?; if post.locked { - return Err(LemmyError::from_message("Post is locked")); + return Err(LemmyErrorType::PostIsLocked)?; } Ok(()) } @@ -167,40 +149,43 @@ impl ApubObject for ApubComment { /// /// If the parent community, post and comment(s) are not known locally, these are also fetched. #[tracing::instrument(skip_all)] - async fn from_apub( - note: Note, - context: &LemmyContext, - request_counter: &mut i32, - ) -> Result { - let creator = note - .attributed_to - .dereference(context, context.client(), request_counter) - .await?; - let (post, parent_comment_id) = note.get_parents(context, request_counter).await?; - - let content = read_from_string_or_source(¬e.content, ¬e.source); - let content_slurs_removed = remove_slurs(&content, &context.settings().slur_regex()); - - let form = CommentForm { + async fn from_json(note: Note, context: &Data) -> Result { + let creator = note.attributed_to.dereference(context).await?; + let (post, parent_comment) = note.get_parents(context).await?; + + let content = read_from_string_or_source(¬e.content, ¬e.media_type, ¬e.source); + + let local_site = LocalSite::read(&mut context.pool()).await.ok(); + let slur_regex = &local_site_opt_to_slur_regex(&local_site); + let content = remove_slurs(&content, slur_regex); + let content = sanitize_html(&content); + let language_id = + LanguageTag::to_language_id_single(note.language, &mut context.pool()).await?; + + let form = CommentInsertForm { creator_id: creator.id, post_id: post.id, - parent_id: parent_comment_id, - content: content_slurs_removed, + content, removed: None, - read: None, published: note.published.map(|u| u.naive_local()), updated: note.updated.map(|u| u.naive_local()), - deleted: None, + deleted: Some(false), ap_id: Some(note.id.into()), + distinguished: note.distinguished, local: Some(false), + language_id, }; - let comment = blocking(context.pool(), move |conn| Comment::upsert(conn, &form)).await??; + let parent_comment_path = parent_comment.map(|t| t.0.path); + let comment = Comment::create(&mut context.pool(), &form, parent_comment_path.as_ref()).await?; Ok(comment.into()) } } #[cfg(test)] pub(crate) mod tests { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use super::*; use crate::{ objects::{ @@ -219,60 +204,62 @@ pub(crate) mod tests { async fn prepare_comment_test( url: &Url, - context: &LemmyContext, + context: &Data, ) -> (ApubPerson, ApubCommunity, ApubPost, ApubSite) { - let (person, site) = parse_lemmy_person(context).await; - let community = parse_lemmy_community(context).await; + // use separate counter so this doesnt affect tests + let context2 = context.reset_request_count(); + let (person, site) = parse_lemmy_person(&context2).await; + let community = parse_lemmy_community(&context2).await; let post_json = file_to_json_object("assets/lemmy/objects/page.json").unwrap(); - ApubPost::verify(&post_json, url, context, &mut 0) + ApubPost::verify(&post_json, url, &context2).await.unwrap(); + let post = ApubPost::from_json(post_json, &context2).await.unwrap(); + (person, community, post, site) + } + + async fn cleanup(data: (ApubPerson, ApubCommunity, ApubPost, ApubSite), context: &LemmyContext) { + Post::delete(&mut context.pool(), data.2.id).await.unwrap(); + Community::delete(&mut context.pool(), data.1.id) .await .unwrap(); - let post = ApubPost::from_apub(post_json, context, &mut 0) + Person::delete(&mut context.pool(), data.0.id) .await .unwrap(); - (person, community, post, site) - } - - fn cleanup(data: (ApubPerson, ApubCommunity, ApubPost, ApubSite), context: &LemmyContext) { - Post::delete(&*context.pool().get().unwrap(), data.2.id).unwrap(); - Community::delete(&*context.pool().get().unwrap(), data.1.id).unwrap(); - Person::delete(&*context.pool().get().unwrap(), data.0.id).unwrap(); - Site::delete(&*context.pool().get().unwrap(), data.3.id).unwrap(); + Site::delete(&mut context.pool(), data.3.id).await.unwrap(); + LocalSite::delete(&mut context.pool()).await.unwrap(); } - #[actix_rt::test] + #[tokio::test] #[serial] pub(crate) async fn test_parse_lemmy_comment() { - let context = init_context(); + let context = init_context().await; let url = Url::parse("https://enterprise.lemmy.ml/comment/38741").unwrap(); let data = prepare_comment_test(&url, &context).await; let json: Note = file_to_json_object("assets/lemmy/objects/note.json").unwrap(); - let mut request_counter = 0; - ApubComment::verify(&json, &url, &context, &mut request_counter) - .await - .unwrap(); - let comment = ApubComment::from_apub(json.clone(), &context, &mut request_counter) + ApubComment::verify(&json, &url, &context).await.unwrap(); + let comment = ApubComment::from_json(json.clone(), &context) .await .unwrap(); assert_eq!(comment.ap_id, url.into()); assert_eq!(comment.content.len(), 14); assert!(!comment.local); - assert_eq!(request_counter, 0); + assert_eq!(context.request_count(), 0); let comment_id = comment.id; - let to_apub = comment.into_apub(&context).await.unwrap(); + let to_apub = comment.into_json(&context).await.unwrap(); assert_json_include!(actual: json, expected: to_apub); - Comment::delete(&*context.pool().get().unwrap(), comment_id).unwrap(); - cleanup(data, &context); + Comment::delete(&mut context.pool(), comment_id) + .await + .unwrap(); + cleanup(data, &context).await; } - #[actix_rt::test] + #[tokio::test] #[serial] async fn test_parse_pleroma_comment() { - let context = init_context(); + let context = init_context().await; let url = Url::parse("https://enterprise.lemmy.ml/comment/38741").unwrap(); let data = prepare_comment_test(&url, &context).await; @@ -280,31 +267,28 @@ pub(crate) mod tests { Url::parse("https://queer.hacktivis.me/objects/8d4973f4-53de-49cd-8c27-df160e16a9c2") .unwrap(); let person_json = file_to_json_object("assets/pleroma/objects/person.json").unwrap(); - ApubPerson::verify(&person_json, &pleroma_url, &context, &mut 0) - .await - .unwrap(); - ApubPerson::from_apub(person_json, &context, &mut 0) + ApubPerson::verify(&person_json, &pleroma_url, &context) .await .unwrap(); + ApubPerson::from_json(person_json, &context).await.unwrap(); let json = file_to_json_object("assets/pleroma/objects/note.json").unwrap(); - let mut request_counter = 0; - ApubComment::verify(&json, &pleroma_url, &context, &mut request_counter) - .await - .unwrap(); - let comment = ApubComment::from_apub(json, &context, &mut request_counter) + ApubComment::verify(&json, &pleroma_url, &context) .await .unwrap(); + let comment = ApubComment::from_json(json, &context).await.unwrap(); assert_eq!(comment.ap_id, pleroma_url.into()); assert_eq!(comment.content.len(), 64); assert!(!comment.local); - assert_eq!(request_counter, 0); + assert_eq!(context.request_count(), 1); - Comment::delete(&*context.pool().get().unwrap(), comment.id).unwrap(); - cleanup(data, &context); + Comment::delete(&mut context.pool(), comment.id) + .await + .unwrap(); + cleanup(data, &context).await; } - #[actix_rt::test] + #[tokio::test] #[serial] async fn test_html_to_markdown_sanitize() { let parsed = parse_html("hello");