2 fetcher::object_id::ObjectId,
3 objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
7 link::{LinkExt, Mention},
10 use itertools::Itertools;
11 use lemmy_api_common::blocking;
12 use lemmy_apub_lib::{traits::ActorType, webfinger::WebfingerResponse};
13 use lemmy_db_schema::{
14 newtypes::LocalUserId,
15 source::{comment::Comment, person::Person, post::Post},
20 request::{retry, RecvError},
21 utils::{scrape_text_for_mentions, MentionData},
24 use lemmy_websocket::{send::send_local_notifs, LemmyContext};
28 pub mod create_or_update;
30 async fn get_notif_recipients(
31 actor: &ObjectId<ApubPerson>,
33 context: &LemmyContext,
34 request_counter: &mut i32,
35 ) -> Result<Vec<LocalUserId>, LemmyError> {
36 let post_id = comment.post_id;
37 let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
38 let actor = actor.dereference(context, request_counter).await?;
41 // Although mentions could be gotten from the post tags (they are included there), or the ccs,
42 // Its much easier to scrape them from the comment body, since the API has to do that
44 // TODO: for compatibility with other projects, it would be much better to read this from cc or tags
45 let mentions = scrape_text_for_mentions(&comment.content);
46 send_local_notifs(mentions, comment, &*actor, &post, true, context).await
49 pub struct MentionsAndAddresses {
51 pub inboxes: Vec<Url>,
52 pub tags: Vec<Mention>,
55 /// This takes a comment, and builds a list of to_addresses, inboxes,
56 /// and mention tags, so they know where to be sent to.
57 /// Addresses are the persons / addresses that go in the cc field.
58 pub async fn collect_non_local_mentions(
59 comment: &ApubComment,
60 community: &ApubCommunity,
61 context: &LemmyContext,
62 ) -> Result<MentionsAndAddresses, LemmyError> {
63 let parent_creator = get_comment_parent_creator(context.pool(), comment).await?;
64 let mut addressed_ccs: Vec<Url> = vec![community.actor_id(), parent_creator.actor_id()];
65 // Note: dont include community inbox here, as we send to it separately with `send_to_community()`
66 let mut inboxes = vec![parent_creator.shared_inbox_or_inbox_url()];
68 // Add the mention tag
69 let mut tags = Vec::new();
71 // Get the person IDs for any mentions
72 let mentions = scrape_text_for_mentions(&comment.content)
74 // Filter only the non-local ones
75 .filter(|m| !m.is_local(&context.settings().hostname))
76 .collect::<Vec<MentionData>>();
78 for mention in &mentions {
79 // TODO should it be fetching it every time?
80 if let Ok(actor_id) = fetch_webfinger_url(mention, context).await {
81 let actor_id: ObjectId<ApubPerson> = ObjectId::new(actor_id);
82 debug!("mention actor_id: {}", actor_id);
83 addressed_ccs.push(actor_id.to_string().parse()?);
85 let mention_person = actor_id.dereference(context, &mut 0).await?;
86 inboxes.push(mention_person.shared_inbox_or_inbox_url());
88 let mut mention_tag = Mention::new();
90 .set_href(actor_id.into())
91 .set_name(mention.full_name());
92 tags.push(mention_tag);
96 let inboxes = inboxes.into_iter().unique().collect();
98 Ok(MentionsAndAddresses {
105 /// Returns the apub ID of the person this comment is responding to. Meaning, in case this is a
106 /// top-level comment, the creator of the post, otherwise the creator of the parent comment.
107 async fn get_comment_parent_creator(
110 ) -> Result<ApubPerson, LemmyError> {
111 let parent_creator_id = if let Some(parent_comment_id) = comment.parent_id {
113 blocking(pool, move |conn| Comment::read(conn, parent_comment_id)).await??;
114 parent_comment.creator_id
116 let parent_post_id = comment.post_id;
117 let parent_post = blocking(pool, move |conn| Post::read(conn, parent_post_id)).await??;
118 parent_post.creator_id
121 blocking(pool, move |conn| Person::read(conn, parent_creator_id))
127 /// Turns a person id like `@name@example.com` into an apub ID, like `https://example.com/user/name`,
129 async fn fetch_webfinger_url(
130 mention: &MentionData,
131 context: &LemmyContext,
132 ) -> Result<Url, LemmyError> {
133 let fetch_url = format!(
134 "{}://{}/.well-known/webfinger?resource=acct:{}@{}",
135 context.settings().get_protocol_string(),
140 debug!("Fetching webfinger url: {}", &fetch_url);
142 let response = retry(|| context.client().get(&fetch_url).send()).await?;
144 let res: WebfingerResponse = response
147 .map_err(|e| RecvError(e.to_string()))?;
152 .find(|l| l.type_.eq(&Some("application/activity+json".to_string())))
153 .ok_or_else(|| anyhow!("No application/activity+json link found."))?;
157 .ok_or_else(|| anyhow!("No href found.").into())