From fa7778218f1600a7def32197d3d7ab334975b076 Mon Sep 17 00:00:00 2001 From: Felix Ableitner Date: Wed, 30 Jun 2021 04:47:02 +0200 Subject: [PATCH] also use actor type for routing, VerifyActivity and SendActivity traits --- crates/apub/src/extensions/signatures.rs | 8 +++--- crates/apub/src/fetcher/mod.rs | 26 +++++++++++++++++- crates/apub_lib/src/lib.rs | 16 +++++------ .../src/activities/comment/create.rs | 16 +++++------ .../src/activities/comment/delete.rs | 12 ++++----- .../src/activities/comment/dislike.rs | 20 +++++--------- .../src/activities/comment/like.rs | 20 +++++--------- .../src/activities/comment/mod.rs | 13 +++++---- .../src/activities/comment/remove.rs | 12 ++++----- .../src/activities/comment/undo_delete.rs | 12 ++++----- .../src/activities/comment/undo_dislike.rs | 13 ++++----- .../src/activities/comment/undo_like.rs | 13 ++++----- .../src/activities/comment/undo_remove.rs | 12 ++++----- .../src/activities/comment/update.rs | 17 ++++++------ .../src/activities/community/add_mod.rs | 17 +++++++----- .../src/activities/community/announce.rs | 27 ++++++++++--------- .../src/activities/community/block_user.rs | 23 +++++++++------- .../src/activities/community/delete.rs | 11 ++++---- .../src/activities/community/remove.rs | 10 +++---- .../src/activities/community/remove_mod.rs | 17 +++++++----- .../activities/community/undo_block_user.rs | 15 ++++++----- .../src/activities/community/undo_delete.rs | 14 +++++----- .../src/activities/community/undo_remove.rs | 10 +++---- .../src/activities/community/update.rs | 15 ++++++----- .../src/activities/follow/accept.rs | 23 +++++++--------- .../src/activities/follow/follow.rs | 20 +++++++------- .../src/activities/follow/undo.rs | 23 ++++++++-------- .../src/activities/post/create.rs | 24 ++++++----------- .../src/activities/post/delete.rs | 12 ++++----- .../src/activities/post/dislike.rs | 20 +++++--------- .../apub_receive/src/activities/post/like.rs | 13 ++++----- .../apub_receive/src/activities/post/mod.rs | 22 +++++++-------- .../src/activities/post/remove.rs | 12 ++++----- .../src/activities/post/undo_delete.rs | 12 ++++----- .../src/activities/post/undo_dislike.rs | 13 ++++----- .../src/activities/post/undo_like.rs | 14 +++++----- .../src/activities/post/undo_remove.rs | 12 ++++----- .../src/activities/post/update.rs | 17 ++++++------ .../src/activities/private_message/create.rs | 16 +++++------ .../src/activities/private_message/delete.rs | 12 ++++----- .../activities/private_message/undo_delete.rs | 12 ++++----- .../src/activities/private_message/update.rs | 16 +++++------ .../src/inbox/new_inbox_routing.rs | 17 +++++++----- crates/apub_receive/src/inbox/shared_inbox.rs | 21 ++++++++++----- 44 files changed, 360 insertions(+), 340 deletions(-) diff --git a/crates/apub/src/extensions/signatures.rs b/crates/apub/src/extensions/signatures.rs index 92e2a306d..7224a0e33 100644 --- a/crates/apub/src/extensions/signatures.rs +++ b/crates/apub/src/extensions/signatures.rs @@ -1,12 +1,11 @@ -use crate::ActorType; use activitystreams::unparsed::UnparsedMutExt; use activitystreams_ext::UnparsedExtension; use actix_web::HttpRequest; -use anyhow::{anyhow, Context}; +use anyhow::anyhow; use http::{header::HeaderName, HeaderMap, HeaderValue}; use http_signature_normalization_actix::Config as ConfigActix; use http_signature_normalization_reqwest::prelude::{Config, SignExt}; -use lemmy_utils::{location_info, LemmyError}; +use lemmy_utils::LemmyError; use log::debug; use openssl::{ hash::MessageDigest, @@ -65,8 +64,7 @@ pub(crate) async fn sign_and_send( } /// Verifies the HTTP signature on an incoming inbox request. -pub fn verify_signature(request: &HttpRequest, actor: &dyn ActorType) -> Result<(), LemmyError> { - let public_key = actor.public_key().context(location_info!())?; +pub fn verify_signature(request: &HttpRequest, public_key: &str) -> Result<(), LemmyError> { let verified = CONFIG2 .begin_verify( request.method(), diff --git a/crates/apub/src/fetcher/mod.rs b/crates/apub/src/fetcher/mod.rs index 477cecc87..a4a6a145d 100644 --- a/crates/apub/src/fetcher/mod.rs +++ b/crates/apub/src/fetcher/mod.rs @@ -14,7 +14,10 @@ use crate::{ }; use chrono::NaiveDateTime; use http::StatusCode; -use lemmy_db_schema::naive_now; +use lemmy_db_schema::{ + naive_now, + source::{community::Community, person::Person}, +}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use serde::Deserialize; @@ -55,6 +58,27 @@ pub async fn get_or_fetch_and_upsert_actor( Ok(actor) } +pub enum Actor { + Person(Person), + Community(Community), +} + +// TODO: use this and get rid of ActorType +pub async fn get_or_fetch_and_upsert_actor2( + apub_id: &Url, + context: &LemmyContext, + recursion_counter: &mut i32, +) -> Result { + let community = get_or_fetch_and_upsert_community(apub_id, context, recursion_counter).await; + let actor: Actor = match community { + Ok(c) => Actor::Community(c), + Err(_) => { + Actor::Person(get_or_fetch_and_upsert_person(apub_id, context, recursion_counter).await?) + } + }; + Ok(actor) +} + /// Determines when a remote actor should be refetched from its instance. In release builds, this is /// `ACTOR_REFETCH_INTERVAL_SECONDS` after the last refetch, in debug builds /// `ACTOR_REFETCH_INTERVAL_SECONDS_DEBUG`. diff --git a/crates/apub_lib/src/lib.rs b/crates/apub_lib/src/lib.rs index 990854c92..34a93f15e 100644 --- a/crates/apub_lib/src/lib.rs +++ b/crates/apub_lib/src/lib.rs @@ -31,13 +31,17 @@ pub enum PublicUrl { Public, } -// todo: later add a similar trait SendActivity -// todo: maybe add a separate method verify() #[async_trait::async_trait(?Send)] -pub trait ReceiveActivity { +pub trait ActivityHandler { + type Actor; + + // TODO: also need to check for instance/community blocks in here + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError>; + // todo: later handle request_counter completely inside library async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError>; @@ -50,12 +54,6 @@ pub fn verify_domains_match(a: &Url, b: &Url) -> Result<(), LemmyError> { Ok(()) } -#[async_trait::async_trait(?Send)] -pub trait VerifyActivity { - // TODO: also need to check for instance/actor blocks in here i think - async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError>; -} - // todo: instead of phantomdata, might use option to cache the fetched object (or just fetch on construction) pub struct ObjectId<'a, Kind>(Url, &'a PhantomData); diff --git a/crates/apub_receive/src/activities/comment/create.rs b/crates/apub_receive/src/activities/comment/create.rs index c50fd50fd..198501628 100644 --- a/crates/apub_receive/src/activities/comment/create.rs +++ b/crates/apub_receive/src/activities/comment/create.rs @@ -3,9 +3,9 @@ use crate::{ inbox::new_inbox_routing::Activity, }; use activitystreams::{activity::kind::CreateType, base::BaseExt}; -use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, NoteExt}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; -use lemmy_db_schema::source::comment::Comment; +use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, ActorType, NoteExt}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -21,25 +21,25 @@ pub struct CreateComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { let comment = Comment::from_apub( &self.inner.object, context, - self.actor.clone(), + actor.actor_id(), request_counter, false, ) diff --git a/crates/apub_receive/src/activities/comment/delete.rs b/crates/apub_receive/src/activities/comment/delete.rs index d82ee501c..dcba11b80 100644 --- a/crates/apub_receive/src/activities/comment/delete.rs +++ b/crates/apub_receive/src/activities/comment/delete.rs @@ -2,9 +2,9 @@ use crate::{activities::comment::send_websocket_message, inbox::new_inbox_routin use activitystreams::activity::kind::DeleteType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_comment}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::comment::Comment_; -use lemmy_db_schema::source::comment::Comment; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -20,18 +20,18 @@ pub struct DeleteComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object)?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/comment/dislike.rs b/crates/apub_receive/src/activities/comment/dislike.rs index 5a0cb1cec..31738460a 100644 --- a/crates/apub_receive/src/activities/comment/dislike.rs +++ b/crates/apub_receive/src/activities/comment/dislike.rs @@ -1,7 +1,8 @@ use crate::{activities::comment::like_or_dislike_comment, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::DislikeType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -17,27 +18,20 @@ pub struct DislikeComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - like_or_dislike_comment( - -1, - &self.actor, - &self.inner.object, - context, - request_counter, - ) - .await + like_or_dislike_comment(-1, &actor, &self.inner.object, context, request_counter).await } } diff --git a/crates/apub_receive/src/activities/comment/like.rs b/crates/apub_receive/src/activities/comment/like.rs index ea1bad49b..aed8c7ff0 100644 --- a/crates/apub_receive/src/activities/comment/like.rs +++ b/crates/apub_receive/src/activities/comment/like.rs @@ -1,7 +1,8 @@ use crate::{activities::comment::like_or_dislike_comment, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::LikeType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -17,27 +18,20 @@ pub struct LikeComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - like_or_dislike_comment( - -1, - &self.actor, - &self.inner.object, - context, - request_counter, - ) - .await + like_or_dislike_comment(-1, &actor, &self.inner.object, context, request_counter).await } } diff --git a/crates/apub_receive/src/activities/comment/mod.rs b/crates/apub_receive/src/activities/comment/mod.rs index d433f0356..80338b15a 100644 --- a/crates/apub_receive/src/activities/comment/mod.rs +++ b/crates/apub_receive/src/activities/comment/mod.rs @@ -7,6 +7,7 @@ use lemmy_db_queries::{Crud, Likeable}; use lemmy_db_schema::{ source::{ comment::{Comment, CommentLike, CommentLikeForm}, + person::Person, post::Post, }, CommentId, @@ -78,22 +79,21 @@ async fn send_websocket_message Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(actor, context, request_counter).await?; let comment = get_or_fetch_and_insert_comment(object, context, request_counter).await?; let comment_id = comment.id; let like_form = CommentLikeForm { comment_id, post_id: comment.post_id, - person_id: person.id, + person_id: actor.id, score, }; - let person_id = person.id; + let person_id = actor.id; blocking(context.pool(), move |conn| { CommentLike::remove(conn, person_id, comment_id)?; CommentLike::like(conn, &like_form) @@ -110,16 +110,15 @@ async fn like_or_dislike_comment( } async fn undo_like_or_dislike_comment( - actor: &Url, + actor: &Person, object: &Url, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(actor, context, request_counter).await?; let comment = get_or_fetch_and_insert_comment(object, context, request_counter).await?; let comment_id = comment.id; - let person_id = person.id; + let person_id = actor.id; blocking(context.pool(), move |conn| { CommentLike::remove(conn, person_id, comment_id) }) diff --git a/crates/apub_receive/src/activities/comment/remove.rs b/crates/apub_receive/src/activities/comment/remove.rs index d8f64154e..108cae649 100644 --- a/crates/apub_receive/src/activities/comment/remove.rs +++ b/crates/apub_receive/src/activities/comment/remove.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::RemoveType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_comment}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::comment::Comment_; -use lemmy_db_schema::source::comment::Comment; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -23,18 +23,18 @@ pub struct RemoveComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/comment/undo_delete.rs b/crates/apub_receive/src/activities/comment/undo_delete.rs index 7eaa76f0d..123984d3d 100644 --- a/crates/apub_receive/src/activities/comment/undo_delete.rs +++ b/crates/apub_receive/src/activities/comment/undo_delete.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_comment}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::comment::Comment_; -use lemmy_db_schema::source::comment::Comment; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -23,19 +23,19 @@ pub struct UndoDeleteComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.actor)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/comment/undo_dislike.rs b/crates/apub_receive/src/activities/comment/undo_dislike.rs index d03db3160..1f916ea5a 100644 --- a/crates/apub_receive/src/activities/comment/undo_dislike.rs +++ b/crates/apub_receive/src/activities/comment/undo_dislike.rs @@ -4,7 +4,8 @@ use crate::{ }; use activitystreams::activity::kind::UndoType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -20,24 +21,24 @@ pub struct UndoDislikeComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.inner.object)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { undo_like_or_dislike_comment( - &self.actor, + &actor, &self.inner.object.inner.object, context, request_counter, diff --git a/crates/apub_receive/src/activities/comment/undo_like.rs b/crates/apub_receive/src/activities/comment/undo_like.rs index f0467f4f9..045dcaf38 100644 --- a/crates/apub_receive/src/activities/comment/undo_like.rs +++ b/crates/apub_receive/src/activities/comment/undo_like.rs @@ -4,7 +4,8 @@ use crate::{ }; use activitystreams::activity::kind::UndoType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -20,24 +21,24 @@ pub struct UndoLikeComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.inner.object)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { undo_like_or_dislike_comment( - &self.actor, + &actor, &self.inner.object.inner.object, context, request_counter, diff --git a/crates/apub_receive/src/activities/comment/undo_remove.rs b/crates/apub_receive/src/activities/comment/undo_remove.rs index 88e377fbf..5303d9a99 100644 --- a/crates/apub_receive/src/activities/comment/undo_remove.rs +++ b/crates/apub_receive/src/activities/comment/undo_remove.rs @@ -8,9 +8,9 @@ use crate::{ use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_comment}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::comment::Comment_; -use lemmy_db_schema::source::comment::Comment; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -26,19 +26,19 @@ pub struct UndoRemoveComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/comment/update.rs b/crates/apub_receive/src/activities/comment/update.rs index 191d720a7..1e1cc0ade 100644 --- a/crates/apub_receive/src/activities/comment/update.rs +++ b/crates/apub_receive/src/activities/comment/update.rs @@ -3,9 +3,9 @@ use crate::{ inbox::new_inbox_routing::Activity, }; use activitystreams::{activity::kind::UpdateType, base::BaseExt}; -use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, NoteExt}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; -use lemmy_db_schema::source::comment::Comment; +use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, ActorType, NoteExt}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::{comment::Comment, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -21,18 +21,18 @@ pub struct UpdateComment { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { @@ -45,7 +45,8 @@ impl ReceiveActivity for Activity { ) .await?; - let recipients = get_notif_recipients(&self.actor, &comment, context, request_counter).await?; + let recipients = + get_notif_recipients(&actor.actor_id(), &comment, context, request_counter).await?; send_websocket_message( comment.id, recipients, diff --git a/crates/apub_receive/src/activities/community/add_mod.rs b/crates/apub_receive/src/activities/community/add_mod.rs index 86aeafee4..ebdaeddf8 100644 --- a/crates/apub_receive/src/activities/community/add_mod.rs +++ b/crates/apub_receive/src/activities/community/add_mod.rs @@ -9,16 +9,19 @@ use lemmy_apub::{ fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, CommunityType, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{source::community::CommunityModerator_, Joinable}; -use lemmy_db_schema::source::community::{CommunityModerator, CommunityModeratorForm}; +use lemmy_db_schema::source::{ + community::{CommunityModerator, CommunityModeratorForm}, + person::Person, +}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)] #[serde(rename_all = "camelCase")] -pub struct AddModToCommunity { +pub struct AddMod { to: PublicUrl, object: Url, target: Url, @@ -28,7 +31,9 @@ pub struct AddModToCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.inner.target, &self.inner.cc[0])?; @@ -36,12 +41,10 @@ impl VerifyActivity for Activity { verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await?; verify_add_remove_moderator_target(&self.inner.target, self.inner.cc[0].clone()) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/announce.rs b/crates/apub_receive/src/activities/community/announce.rs index 1b4d14ff0..569b88e4a 100644 --- a/crates/apub_receive/src/activities/community/announce.rs +++ b/crates/apub_receive/src/activities/community/announce.rs @@ -37,8 +37,9 @@ use crate::{ inbox::{is_activity_already_known, new_inbox_routing::Activity}, }; use activitystreams::activity::kind::RemoveType; -use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub::{check_is_apub_id_valid, fetcher::person::get_or_fetch_and_upsert_person}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::{community::Community, person::Person}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -76,20 +77,20 @@ pub enum AnnouncableActivities { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for AnnouncableActivities { +impl ActivityHandler for AnnouncableActivities { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { self.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for AnnouncableActivities { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - self.receive(context, request_counter).await + self.receive(actor, context, request_counter).await } } @@ -104,30 +105,32 @@ pub struct AnnounceActivity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Community; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.cc[0])?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.inner.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { if is_activity_already_known(context.pool(), &self.inner.object.id_unchecked()).await? { return Ok(()); } + let inner_actor = + get_or_fetch_and_upsert_person(&self.inner.object.actor, context, request_counter).await?; self .inner .object .inner - .receive(context, request_counter) + .receive(inner_actor, context, request_counter) .await } } diff --git a/crates/apub_receive/src/activities/community/block_user.rs b/crates/apub_receive/src/activities/community/block_user.rs index 9c2158e70..1e5b14c89 100644 --- a/crates/apub_receive/src/activities/community/block_user.rs +++ b/crates/apub_receive/src/activities/community/block_user.rs @@ -5,13 +5,16 @@ use lemmy_apub::{ check_is_apub_id_valid, fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{Bannable, Followable}; -use lemmy_db_schema::source::community::{ - CommunityFollower, - CommunityFollowerForm, - CommunityPersonBan, - CommunityPersonBanForm, +use lemmy_db_schema::source::{ + community::{ + CommunityFollower, + CommunityFollowerForm, + CommunityPersonBan, + CommunityPersonBanForm, + }, + person::Person, }; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; @@ -28,18 +31,18 @@ pub struct BlockUserFromCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/delete.rs b/crates/apub_receive/src/activities/community/delete.rs index 71722e9ed..43900dcd1 100644 --- a/crates/apub_receive/src/activities/community/delete.rs +++ b/crates/apub_receive/src/activities/community/delete.rs @@ -10,7 +10,7 @@ use lemmy_apub::{ ActorType, CommunityType, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{source::community::Community_, ApubObject}; use lemmy_db_schema::source::community::Community; use lemmy_utils::LemmyError; @@ -31,7 +31,9 @@ pub struct DeleteCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = lemmy_apub::fetcher::Actor; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; let object = self.inner.object.clone(); @@ -51,15 +53,14 @@ impl VerifyActivity for Activity { verify_domains_match(&self.actor, &self.inner.cc[0]) } } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { + // TODO: match on actor to decide what to do let actor = self.inner.object.clone(); let community = blocking(context.pool(), move |conn| { Community::read_from_apub_id(conn, &actor.into()) diff --git a/crates/apub_receive/src/activities/community/remove.rs b/crates/apub_receive/src/activities/community/remove.rs index 7d08523cb..f429014e0 100644 --- a/crates/apub_receive/src/activities/community/remove.rs +++ b/crates/apub_receive/src/activities/community/remove.rs @@ -2,7 +2,7 @@ use crate::{activities::community::send_websocket_message, inbox::new_inbox_rout use activitystreams::activity::kind::RemoveType; use lemmy_api_common::blocking; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{source::community::Community_, ApubObject}; use lemmy_db_schema::source::community::Community; use lemmy_utils::LemmyError; @@ -20,19 +20,19 @@ pub struct RemoveCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = lemmy_apub::fetcher::Actor; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_domains_match(&self.actor, &self.inner.object)?; verify_domains_match(&self.actor, &self.inner.cc[0]) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, _request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/remove_mod.rs b/crates/apub_receive/src/activities/community/remove_mod.rs index 8a9cd4713..4c047faf6 100644 --- a/crates/apub_receive/src/activities/community/remove_mod.rs +++ b/crates/apub_receive/src/activities/community/remove_mod.rs @@ -9,16 +9,19 @@ use lemmy_apub::{ fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, CommunityType, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::Joinable; -use lemmy_db_schema::source::community::{CommunityModerator, CommunityModeratorForm}; +use lemmy_db_schema::source::{ + community::{CommunityModerator, CommunityModeratorForm}, + person::Person, +}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)] #[serde(rename_all = "camelCase")] -pub struct RemoveModToCommunity { +pub struct RemoveMod { to: PublicUrl, object: Url, target: Url, @@ -28,7 +31,9 @@ pub struct RemoveModToCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.inner.target, &self.inner.cc[0])?; @@ -36,12 +41,10 @@ impl VerifyActivity for Activity { verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await?; verify_add_remove_moderator_target(&self.inner.target, self.inner.cc[0].clone()) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/undo_block_user.rs b/crates/apub_receive/src/activities/community/undo_block_user.rs index caa4218a8..7ace537c8 100644 --- a/crates/apub_receive/src/activities/community/undo_block_user.rs +++ b/crates/apub_receive/src/activities/community/undo_block_user.rs @@ -8,9 +8,12 @@ use lemmy_apub::{ check_is_apub_id_valid, fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::Bannable; -use lemmy_db_schema::source::community::{CommunityPersonBan, CommunityPersonBanForm}; +use lemmy_db_schema::source::{ + community::{CommunityPersonBan, CommunityPersonBanForm}, + person::Person, +}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -26,19 +29,19 @@ pub struct UndoBlockUserFromCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/undo_delete.rs b/crates/apub_receive/src/activities/community/undo_delete.rs index 80fb2695d..717647c71 100644 --- a/crates/apub_receive/src/activities/community/undo_delete.rs +++ b/crates/apub_receive/src/activities/community/undo_delete.rs @@ -14,7 +14,7 @@ use lemmy_apub::{ ActorType, CommunityType, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{source::community::Community_, ApubObject}; use lemmy_db_schema::source::community::Community; use lemmy_utils::LemmyError; @@ -35,7 +35,9 @@ pub struct UndoDeleteCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = lemmy_apub::fetcher::Actor; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; let object = self.inner.object.inner.object.clone(); @@ -56,18 +58,16 @@ impl VerifyActivity for Activity { } self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let actor = self.inner.object.inner.object.clone(); + let object = self.inner.object.inner.object.clone(); let community = blocking(context.pool(), move |conn| { - Community::read_from_apub_id(conn, &actor.into()) + Community::read_from_apub_id(conn, &object.into()) }) .await?; let community_id = match community { diff --git a/crates/apub_receive/src/activities/community/undo_remove.rs b/crates/apub_receive/src/activities/community/undo_remove.rs index 843db5bb6..a251eea0c 100644 --- a/crates/apub_receive/src/activities/community/undo_remove.rs +++ b/crates/apub_receive/src/activities/community/undo_remove.rs @@ -5,7 +5,7 @@ use crate::{ use activitystreams::activity::kind::RemoveType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::community::get_or_fetch_and_upsert_community}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::community::Community_; use lemmy_db_schema::source::community::Community; use lemmy_utils::LemmyError; @@ -23,7 +23,9 @@ pub struct UndoRemoveCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = lemmy_apub::fetcher::Actor; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; @@ -31,12 +33,10 @@ impl VerifyActivity for Activity { verify_domains_match(&self.actor, &self.inner.cc[0])?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/community/update.rs b/crates/apub_receive/src/activities/community/update.rs index 552150f05..6d5773743 100644 --- a/crates/apub_receive/src/activities/community/update.rs +++ b/crates/apub_receive/src/activities/community/update.rs @@ -5,9 +5,12 @@ use crate::{ use activitystreams::{activity::kind::UpdateType, base::BaseExt}; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, objects::FromApubToForm, GroupExt}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{ApubObject, Crud}; -use lemmy_db_schema::source::community::{Community, CommunityForm}; +use lemmy_db_schema::source::{ + community::{Community, CommunityForm}, + person::Person, +}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -25,19 +28,19 @@ pub struct UpdateCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; self.inner.object.id(self.inner.cc[0].as_str())?; check_is_apub_id_valid(&self.actor, false)?; verify_is_community_mod(self.actor.clone(), self.inner.cc[0].clone(), context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/follow/accept.rs b/crates/apub_receive/src/activities/follow/accept.rs index b758b209e..dde9b951c 100644 --- a/crates/apub_receive/src/activities/follow/accept.rs +++ b/crates/apub_receive/src/activities/follow/accept.rs @@ -1,13 +1,10 @@ use crate::{activities::follow::follow::FollowCommunity, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::AcceptType; use lemmy_api_common::blocking; -use lemmy_apub::{ - check_is_apub_id_valid, - fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, -}; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; +use lemmy_apub::{check_is_apub_id_valid, fetcher::person::get_or_fetch_and_upsert_person}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; use lemmy_db_queries::Followable; -use lemmy_db_schema::source::community::CommunityFollower; +use lemmy_db_schema::source::community::{Community, CommunityFollower}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -21,29 +18,27 @@ pub struct AcceptFollowCommunity { kind: AcceptType, } +/// Handle accepted follows #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Community; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -/// Handle accepted follows -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let community = - get_or_fetch_and_upsert_community(&self.actor, context, request_counter).await?; let person = get_or_fetch_and_upsert_person(&self.inner.to, context, request_counter).await?; // This will throw an error if no follow was requested blocking(&context.pool(), move |conn| { - CommunityFollower::follow_accepted(conn, community.id, person.id) + CommunityFollower::follow_accepted(conn, actor.id, person.id) }) .await??; diff --git a/crates/apub_receive/src/activities/follow/follow.rs b/crates/apub_receive/src/activities/follow/follow.rs index 8da7136d2..2d82bed40 100644 --- a/crates/apub_receive/src/activities/follow/follow.rs +++ b/crates/apub_receive/src/activities/follow/follow.rs @@ -7,12 +7,15 @@ use anyhow::Context; use lemmy_api_common::blocking; use lemmy_apub::{ check_is_apub_id_valid, - fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, + fetcher::community::get_or_fetch_and_upsert_community, CommunityType, }; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; use lemmy_db_queries::Followable; -use lemmy_db_schema::source::community::{CommunityFollower, CommunityFollowerForm}; +use lemmy_db_schema::source::{ + community::{CommunityFollower, CommunityFollowerForm}, + person::Person, +}; use lemmy_utils::{location_info, LemmyError}; use lemmy_websocket::LemmyContext; use url::Url; @@ -27,27 +30,26 @@ pub struct FollowCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.inner.to, &self.inner.object)?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { let community = get_or_fetch_and_upsert_community(&self.inner.object, context, request_counter).await?; - let person = get_or_fetch_and_upsert_person(&self.actor, context, request_counter).await?; let community_follower_form = CommunityFollowerForm { community_id: community.id, - person_id: person.id, + person_id: actor.id, pending: false, }; diff --git a/crates/apub_receive/src/activities/follow/undo.rs b/crates/apub_receive/src/activities/follow/undo.rs index 030fdebcd..e70ddd0aa 100644 --- a/crates/apub_receive/src/activities/follow/undo.rs +++ b/crates/apub_receive/src/activities/follow/undo.rs @@ -1,13 +1,13 @@ use crate::{activities::follow::follow::FollowCommunity, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; -use lemmy_apub::{ - check_is_apub_id_valid, - fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person}, -}; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; +use lemmy_apub::{check_is_apub_id_valid, fetcher::community::get_or_fetch_and_upsert_community}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; use lemmy_db_queries::Followable; -use lemmy_db_schema::source::community::{CommunityFollower, CommunityFollowerForm}; +use lemmy_db_schema::source::{ + community::{CommunityFollower, CommunityFollowerForm}, + person::Person, +}; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -22,29 +22,28 @@ pub struct UndoFollowCommunity { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.inner.to, &self.inner.object.inner.object)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { let community = get_or_fetch_and_upsert_community(&self.inner.to, context, request_counter).await?; - let person = get_or_fetch_and_upsert_person(&self.actor, context, request_counter).await?; let community_follower_form = CommunityFollowerForm { community_id: community.id, - person_id: person.id, + person_id: actor.id, pending: false, }; diff --git a/crates/apub_receive/src/activities/post/create.rs b/crates/apub_receive/src/activities/post/create.rs index 87324eb10..0b6080ffc 100644 --- a/crates/apub_receive/src/activities/post/create.rs +++ b/crates/apub_receive/src/activities/post/create.rs @@ -1,14 +1,8 @@ use crate::{activities::post::send_websocket_message, inbox::new_inbox_routing::Activity}; use activitystreams::{activity::kind::CreateType, base::BaseExt}; -use lemmy_apub::{ - check_is_apub_id_valid, - fetcher::person::get_or_fetch_and_upsert_person, - objects::FromApub, - ActorType, - PageExt, -}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; -use lemmy_db_schema::source::post::Post; +use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, ActorType, PageExt}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::{person::Person, post::Post}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -24,27 +18,25 @@ pub struct CreatePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(self.id_unchecked(), &self.actor)?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(&self.actor, context, request_counter).await?; - let post = Post::from_apub( &self.inner.object, context, - person.actor_id(), + actor.actor_id(), request_counter, false, ) diff --git a/crates/apub_receive/src/activities/post/delete.rs b/crates/apub_receive/src/activities/post/delete.rs index 270ec028d..17c5a4d3a 100644 --- a/crates/apub_receive/src/activities/post/delete.rs +++ b/crates/apub_receive/src/activities/post/delete.rs @@ -2,9 +2,9 @@ use crate::{activities::post::send_websocket_message, inbox::new_inbox_routing:: use activitystreams::activity::kind::DeleteType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_post}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::post::Post_; -use lemmy_db_schema::source::post::Post; +use lemmy_db_schema::source::{person::Person, post::Post}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -20,18 +20,18 @@ pub struct DeletePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object)?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/post/dislike.rs b/crates/apub_receive/src/activities/post/dislike.rs index e53254d1c..11e0c75f7 100644 --- a/crates/apub_receive/src/activities/post/dislike.rs +++ b/crates/apub_receive/src/activities/post/dislike.rs @@ -1,7 +1,8 @@ use crate::{activities::post::like_or_dislike_post, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::DislikeType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -17,27 +18,20 @@ pub struct DislikePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - like_or_dislike_post( - -1, - &self.actor, - &self.inner.object, - context, - request_counter, - ) - .await + like_or_dislike_post(-1, &actor, &self.inner.object, context, request_counter).await } } diff --git a/crates/apub_receive/src/activities/post/like.rs b/crates/apub_receive/src/activities/post/like.rs index 2dbf4e63c..714627911 100644 --- a/crates/apub_receive/src/activities/post/like.rs +++ b/crates/apub_receive/src/activities/post/like.rs @@ -1,7 +1,8 @@ use crate::{activities::post::like_or_dislike_post, inbox::new_inbox_routing::Activity}; use activitystreams::activity::kind::LikeType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -17,20 +18,20 @@ pub struct LikePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - like_or_dislike_post(1, &self.actor, &self.inner.object, context, request_counter).await + like_or_dislike_post(1, &actor, &self.inner.object, context, request_counter).await } } diff --git a/crates/apub_receive/src/activities/post/mod.rs b/crates/apub_receive/src/activities/post/mod.rs index 7004c0cb1..3969f30cc 100644 --- a/crates/apub_receive/src/activities/post/mod.rs +++ b/crates/apub_receive/src/activities/post/mod.rs @@ -1,11 +1,11 @@ use lemmy_api_common::{blocking, post::PostResponse}; -use lemmy_apub::fetcher::{ - objects::get_or_fetch_and_insert_post, - person::get_or_fetch_and_upsert_person, -}; +use lemmy_apub::fetcher::objects::get_or_fetch_and_insert_post; use lemmy_db_queries::Likeable; use lemmy_db_schema::{ - source::post::{PostLike, PostLikeForm}, + source::{ + person::Person, + post::{PostLike, PostLikeForm}, + }, PostId, }; use lemmy_db_views::post_view::PostView; @@ -47,21 +47,20 @@ async fn send_websocket_message Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(actor, context, request_counter).await?; let post = get_or_fetch_and_insert_post(object, context, request_counter).await?; let post_id = post.id; let like_form = PostLikeForm { post_id: post.id, - person_id: person.id, + person_id: actor.id, score, }; - let person_id = person.id; + let person_id = actor.id; blocking(context.pool(), move |conn| { PostLike::remove(conn, person_id, post_id)?; PostLike::like(conn, &like_form) @@ -72,16 +71,15 @@ async fn like_or_dislike_post( } async fn undo_like_or_dislike_post( - actor: &Url, + actor: &Person, object: &Url, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(actor, context, request_counter).await?; let post = get_or_fetch_and_insert_post(object, context, request_counter).await?; let post_id = post.id; - let person_id = person.id; + let person_id = actor.id; blocking(context.pool(), move |conn| { PostLike::remove(conn, person_id, post_id) }) diff --git a/crates/apub_receive/src/activities/post/remove.rs b/crates/apub_receive/src/activities/post/remove.rs index 756ddca4c..c0b20e17c 100644 --- a/crates/apub_receive/src/activities/post/remove.rs +++ b/crates/apub_receive/src/activities/post/remove.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::RemoveType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_post}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::post::Post_; -use lemmy_db_schema::source::post::Post; +use lemmy_db_schema::source::{person::Person, post::Post}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -23,18 +23,18 @@ pub struct RemovePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/post/undo_delete.rs b/crates/apub_receive/src/activities/post/undo_delete.rs index b845c82b4..d50d0d743 100644 --- a/crates/apub_receive/src/activities/post/undo_delete.rs +++ b/crates/apub_receive/src/activities/post/undo_delete.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_post}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::post::Post_; -use lemmy_db_schema::source::post::Post; +use lemmy_db_schema::source::{person::Person, post::Post}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -23,19 +23,19 @@ pub struct UndoDeletePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.actor)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/post/undo_dislike.rs b/crates/apub_receive/src/activities/post/undo_dislike.rs index dbc29d777..2c6144f22 100644 --- a/crates/apub_receive/src/activities/post/undo_dislike.rs +++ b/crates/apub_receive/src/activities/post/undo_dislike.rs @@ -4,7 +4,8 @@ use crate::{ }; use activitystreams::activity::kind::UndoType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -20,24 +21,24 @@ pub struct UndoDislikePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.inner.object)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { undo_like_or_dislike_post( - &self.actor, + &actor, &self.inner.object.inner.object, context, request_counter, diff --git a/crates/apub_receive/src/activities/post/undo_like.rs b/crates/apub_receive/src/activities/post/undo_like.rs index 7a9b33af4..94ab36c9b 100644 --- a/crates/apub_receive/src/activities/post/undo_like.rs +++ b/crates/apub_receive/src/activities/post/undo_like.rs @@ -4,7 +4,8 @@ use crate::{ }; use activitystreams::activity::kind::UndoType; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; +use lemmy_db_schema::source::person::Person; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -18,26 +19,25 @@ pub struct UndoLikePost { #[serde(rename = "type")] kind: UndoType, } - #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.inner.object)?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { undo_like_or_dislike_post( - &self.actor, + &actor, &self.inner.object.inner.object, context, request_counter, diff --git a/crates/apub_receive/src/activities/post/undo_remove.rs b/crates/apub_receive/src/activities/post/undo_remove.rs index 6b9e9c6e0..248202d72 100644 --- a/crates/apub_receive/src/activities/post/undo_remove.rs +++ b/crates/apub_receive/src/activities/post/undo_remove.rs @@ -8,9 +8,9 @@ use crate::{ use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; use lemmy_apub::{check_is_apub_id_valid, fetcher::objects::get_or_fetch_and_insert_post}; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::source::post::Post_; -use lemmy_db_schema::source::post::Post; +use lemmy_db_schema::source::{person::Person, post::Post}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -26,19 +26,19 @@ pub struct UndoRemovePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; verify_mod_action(self.actor.clone(), self.inner.cc[0].clone(), context).await?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/post/update.rs b/crates/apub_receive/src/activities/post/update.rs index 1a420b5a8..198b29b32 100644 --- a/crates/apub_receive/src/activities/post/update.rs +++ b/crates/apub_receive/src/activities/post/update.rs @@ -4,16 +4,16 @@ use anyhow::Context; use lemmy_api_common::blocking; use lemmy_apub::{ check_is_apub_id_valid, - fetcher::person::get_or_fetch_and_upsert_person, objects::{FromApub, FromApubToForm}, ActorType, PageExt, }; -use lemmy_apub_lib::{verify_domains_match, PublicUrl, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler, PublicUrl}; use lemmy_db_queries::{ApubObject, Crud}; use lemmy_db_schema::{ source::{ community::Community, + person::Person, post::{Post, PostForm}, }, DbUrl, @@ -33,26 +33,25 @@ pub struct UpdatePost { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - let person = get_or_fetch_and_upsert_person(&self.actor, context, request_counter).await?; let temp_post = PostForm::from_apub( &self.inner.object, context, - person.actor_id(), + actor.actor_id(), request_counter, false, ) @@ -84,7 +83,7 @@ impl ReceiveActivity for Activity { let post = Post::from_apub( &self.inner.object, context, - person.actor_id(), + actor.actor_id(), request_counter, mod_action_allowed, ) diff --git a/crates/apub_receive/src/activities/private_message/create.rs b/crates/apub_receive/src/activities/private_message/create.rs index e1a01237b..8e70b256a 100644 --- a/crates/apub_receive/src/activities/private_message/create.rs +++ b/crates/apub_receive/src/activities/private_message/create.rs @@ -3,9 +3,9 @@ use crate::{ inbox::new_inbox_routing::Activity, }; use activitystreams::{activity::kind::CreateType, base::BaseExt}; -use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, NoteExt}; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; -use lemmy_db_schema::source::private_message::PrivateMessage; +use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, ActorType, NoteExt}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; +use lemmy_db_schema::source::{person::Person, private_message::PrivateMessage}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -20,25 +20,25 @@ pub struct CreatePrivateMessage { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(self.id_unchecked(), &self.actor)?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { let private_message = PrivateMessage::from_apub( &self.inner.object, context, - self.actor.clone(), + actor.actor_id(), request_counter, false, ) diff --git a/crates/apub_receive/src/activities/private_message/delete.rs b/crates/apub_receive/src/activities/private_message/delete.rs index 4c4e8b04d..abad6d707 100644 --- a/crates/apub_receive/src/activities/private_message/delete.rs +++ b/crates/apub_receive/src/activities/private_message/delete.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::DeleteType; use lemmy_api_common::blocking; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; use lemmy_db_queries::{source::private_message::PrivateMessage_, ApubObject}; -use lemmy_db_schema::source::private_message::PrivateMessage; +use lemmy_db_schema::source::{person::Person, private_message::PrivateMessage}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -22,18 +22,18 @@ pub struct DeletePrivateMessage { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object)?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, _request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/private_message/undo_delete.rs b/crates/apub_receive/src/activities/private_message/undo_delete.rs index 691f911db..7f5f923e9 100644 --- a/crates/apub_receive/src/activities/private_message/undo_delete.rs +++ b/crates/apub_receive/src/activities/private_message/undo_delete.rs @@ -5,9 +5,9 @@ use crate::{ use activitystreams::activity::kind::UndoType; use lemmy_api_common::blocking; use lemmy_apub::check_is_apub_id_valid; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; use lemmy_db_queries::{source::private_message::PrivateMessage_, ApubObject}; -use lemmy_db_schema::source::private_message::PrivateMessage; +use lemmy_db_schema::source::{person::Person, private_message::PrivateMessage}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -22,19 +22,19 @@ pub struct UndoDeletePrivateMessage { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(&self.actor, self.id_unchecked())?; verify_domains_match(&self.actor, &self.inner.object.id_unchecked())?; check_is_apub_id_valid(&self.actor, false)?; self.inner.object.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + _actor: Self::Actor, context: &LemmyContext, _request_counter: &mut i32, ) -> Result<(), LemmyError> { diff --git a/crates/apub_receive/src/activities/private_message/update.rs b/crates/apub_receive/src/activities/private_message/update.rs index 4124a6c84..790a317a9 100644 --- a/crates/apub_receive/src/activities/private_message/update.rs +++ b/crates/apub_receive/src/activities/private_message/update.rs @@ -3,9 +3,9 @@ use crate::{ inbox::new_inbox_routing::Activity, }; use activitystreams::{activity::kind::UpdateType, base::BaseExt}; -use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, NoteExt}; -use lemmy_apub_lib::{verify_domains_match, ReceiveActivity, VerifyActivity}; -use lemmy_db_schema::source::private_message::PrivateMessage; +use lemmy_apub::{check_is_apub_id_valid, objects::FromApub, ActorType, NoteExt}; +use lemmy_apub_lib::{verify_domains_match, ActivityHandler}; +use lemmy_db_schema::source::{person::Person, private_message::PrivateMessage}; use lemmy_utils::LemmyError; use lemmy_websocket::{LemmyContext, UserOperationCrud}; use url::Url; @@ -20,25 +20,25 @@ pub struct UpdatePrivateMessage { } #[async_trait::async_trait(?Send)] -impl VerifyActivity for Activity { +impl ActivityHandler for Activity { + type Actor = Person; + async fn verify(&self, _context: &LemmyContext) -> Result<(), LemmyError> { verify_domains_match(self.id_unchecked(), &self.actor)?; self.inner.object.id(self.actor.as_str())?; check_is_apub_id_valid(&self.actor, false) } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for Activity { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { let private_message = PrivateMessage::from_apub( &self.inner.object, context, - self.actor.clone(), + actor.actor_id(), request_counter, false, ) diff --git a/crates/apub_receive/src/inbox/new_inbox_routing.rs b/crates/apub_receive/src/inbox/new_inbox_routing.rs index ff0bb5a0f..7670f8d2b 100644 --- a/crates/apub_receive/src/inbox/new_inbox_routing.rs +++ b/crates/apub_receive/src/inbox/new_inbox_routing.rs @@ -12,10 +12,12 @@ use crate::activities::{ update::UpdateComment, }, community::{ + add_mod::AddMod, announce::AnnounceActivity, block_user::BlockUserFromCommunity, delete::DeleteCommunity, remove::RemoveCommunity, + remove_mod::RemoveMod, undo_block_user::UndoBlockUserFromCommunity, undo_delete::UndoDeleteCommunity, undo_remove::UndoRemoveCommunity, @@ -42,7 +44,7 @@ use crate::activities::{ }, }; use activitystreams::{base::AnyBase, primitives::OneOrMany, unparsed::Unparsed}; -use lemmy_apub_lib::{ReceiveActivity, VerifyActivity}; +use lemmy_apub_lib::ActivityHandler; use lemmy_utils::LemmyError; use lemmy_websocket::LemmyContext; use url::Url; @@ -105,27 +107,28 @@ pub enum SharedInboxActivities { UpdateCommunity(UpdateCommunity), DeleteCommunity(DeleteCommunity), RemoveCommunity(RemoveCommunity), + AddMod(AddMod), + RemoveMod(RemoveMod), UndoDeleteCommunity(UndoDeleteCommunity), UndoRemoveCommunity(UndoRemoveCommunity), BlockUserFromCommunity(BlockUserFromCommunity), UndoBlockUserFromCommunity(UndoBlockUserFromCommunity), } -// todo: can probably get rid of these? #[async_trait::async_trait(?Send)] -impl VerifyActivity for SharedInboxActivities { +impl ActivityHandler for SharedInboxActivities { + type Actor = lemmy_apub::fetcher::Actor; + async fn verify(&self, context: &LemmyContext) -> Result<(), LemmyError> { self.verify(context).await } -} -#[async_trait::async_trait(?Send)] -impl ReceiveActivity for SharedInboxActivities { async fn receive( &self, + actor: Self::Actor, context: &LemmyContext, request_counter: &mut i32, ) -> Result<(), LemmyError> { - self.receive(context, request_counter).await + self.receive(actor, context, request_counter).await } } diff --git a/crates/apub_receive/src/inbox/shared_inbox.rs b/crates/apub_receive/src/inbox/shared_inbox.rs index 1fb986d0e..971b29d14 100644 --- a/crates/apub_receive/src/inbox/shared_inbox.rs +++ b/crates/apub_receive/src/inbox/shared_inbox.rs @@ -4,14 +4,15 @@ use crate::inbox::{ new_inbox_routing::{Activity, SharedInboxActivities}, }; use actix_web::{web, HttpRequest, HttpResponse}; +use anyhow::Context; use lemmy_apub::{ check_is_apub_id_valid, extensions::signatures::verify_signature, - fetcher::get_or_fetch_and_upsert_actor, + fetcher::{get_or_fetch_and_upsert_actor2, Actor}, insert_activity, }; -use lemmy_apub_lib::{ReceiveActivity, VerifyActivity}; -use lemmy_utils::LemmyError; +use lemmy_apub_lib::ActivityHandler; +use lemmy_utils::{location_info, LemmyError}; use lemmy_websocket::LemmyContext; pub async fn shared_inbox( @@ -30,8 +31,12 @@ pub async fn shared_inbox( activity.inner.verify(&context).await?; let request_counter = &mut 0; - let actor = get_or_fetch_and_upsert_actor(&activity.actor, &context, request_counter).await?; - verify_signature(&request, actor.as_ref())?; + let actor = get_or_fetch_and_upsert_actor2(&activity.actor, &context, request_counter).await?; + let public_key = match &actor { + Actor::Person(p) => p.public_key.as_ref().context(location_info!())?, + Actor::Community(c) => c.public_key.as_ref().context(location_info!())?, + }; + verify_signature(&request, &public_key)?; // Log the activity, so we avoid receiving and parsing it twice. Note that this could still happen // if we receive the same activity twice in very quick succession. @@ -44,7 +49,9 @@ pub async fn shared_inbox( ) .await?; - // TODO: pass the actor in somehow - activity.inner.receive(&context, request_counter).await?; + activity + .inner + .receive(actor, &context, request_counter) + .await?; return Ok(HttpResponse::Ok().finish()); }