use crate::fetcher::object_id::ObjectId; use activitystreams::{ base::BaseExt, link::{LinkExt, Mention}, }; use anyhow::anyhow; use itertools::Itertools; use lemmy_api_common::{blocking, send_local_notifs}; use lemmy_apub_lib::{traits::ActorType, webfinger::WebfingerResponse}; use lemmy_db_schema::{ newtypes::LocalUserId, source::{comment::Comment, community::Community, person::Person, post::Post}, traits::Crud, DbPool, }; use lemmy_utils::{ request::{retry, RecvError}, utils::{scrape_text_for_mentions, MentionData}, LemmyError, }; use lemmy_websocket::LemmyContext; use log::debug; use url::Url; pub mod create_or_update; async fn get_notif_recipients( actor: &ObjectId, comment: &Comment, context: &LemmyContext, request_counter: &mut i32, ) -> Result, LemmyError> { let post_id = comment.post_id; let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??; let actor = actor.dereference(context, request_counter).await?; // Note: // Although mentions could be gotten from the post tags (they are included there), or the ccs, // Its much easier to scrape them from the comment body, since the API has to do that // anyway. // TODO: for compatibility with other projects, it would be much better to read this from cc or tags let mentions = scrape_text_for_mentions(&comment.content); send_local_notifs( mentions, comment.clone(), actor, post, context.pool(), true, &context.settings(), ) .await } pub struct MentionsAndAddresses { pub ccs: Vec, pub inboxes: Vec, pub tags: Vec, } /// This takes a comment, and builds a list of to_addresses, inboxes, /// and mention tags, so they know where to be sent to. /// Addresses are the persons / addresses that go in the cc field. pub async fn collect_non_local_mentions( comment: &Comment, community: &Community, context: &LemmyContext, ) -> Result { let parent_creator = get_comment_parent_creator(context.pool(), comment).await?; let mut addressed_ccs = vec![community.actor_id(), parent_creator.actor_id()]; // Note: dont include community inbox here, as we send to it separately with `send_to_community()` let mut inboxes = vec![parent_creator.shared_inbox_or_inbox_url()]; // Add the mention tag let mut tags = Vec::new(); // Get the person IDs for any mentions let mentions = scrape_text_for_mentions(&comment.content) .into_iter() // Filter only the non-local ones .filter(|m| !m.is_local(&context.settings().hostname)) .collect::>(); for mention in &mentions { // TODO should it be fetching it every time? if let Ok(actor_id) = fetch_webfinger_url(mention, context).await { let actor_id: ObjectId = ObjectId::new(actor_id); debug!("mention actor_id: {}", actor_id); addressed_ccs.push(actor_id.to_owned().to_string().parse()?); let mention_person = actor_id.dereference(context, &mut 0).await?; inboxes.push(mention_person.shared_inbox_or_inbox_url()); let mut mention_tag = Mention::new(); mention_tag .set_href(actor_id.into()) .set_name(mention.full_name()); tags.push(mention_tag); } } let inboxes = inboxes.into_iter().unique().collect(); Ok(MentionsAndAddresses { ccs: addressed_ccs, inboxes, tags, }) } /// Returns the apub ID of the person this comment is responding to. Meaning, in case this is a /// top-level comment, the creator of the post, otherwise the creator of the parent comment. async fn get_comment_parent_creator( pool: &DbPool, comment: &Comment, ) -> Result { let parent_creator_id = if let Some(parent_comment_id) = comment.parent_id { let parent_comment = blocking(pool, move |conn| Comment::read(conn, parent_comment_id)).await??; parent_comment.creator_id } else { let parent_post_id = comment.post_id; let parent_post = blocking(pool, move |conn| Post::read(conn, parent_post_id)).await??; parent_post.creator_id }; Ok(blocking(pool, move |conn| Person::read(conn, parent_creator_id)).await??) } /// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`, /// using webfinger. async fn fetch_webfinger_url( mention: &MentionData, context: &LemmyContext, ) -> Result { let fetch_url = format!( "{}://{}/.well-known/webfinger?resource=acct:{}@{}", context.settings().get_protocol_string(), mention.domain, mention.name, mention.domain ); debug!("Fetching webfinger url: {}", &fetch_url); let response = retry(|| context.client().get(&fetch_url).send()).await?; let res: WebfingerResponse = response .json() .await .map_err(|e| RecvError(e.to_string()))?; let link = res .links .iter() .find(|l| l.type_.eq(&Some("application/activity+json".to_string()))) .ok_or_else(|| anyhow!("No application/activity+json link found."))?; link .href .to_owned() .ok_or_else(|| anyhow!("No href found.").into()) }