2 objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson, post::ApubPost},
3 protocol::objects::{group::Group, note::Note, page::Page, person::Person},
5 use activitypub_federation::{
7 fetch::{object_id::ObjectId, webfinger::webfinger_resolve_actor},
10 use chrono::NaiveDateTime;
11 use lemmy_api_common::context::LemmyContext;
12 use lemmy_utils::error::{LemmyError, LemmyErrorType};
13 use serde::Deserialize;
16 /// Converts search query to object id. The query can either be an URL, which will be treated as
17 /// ObjectId directly, or a webfinger identifier (@user@example.com or !community@example.com)
18 /// which gets resolved to an URL.
19 #[tracing::instrument(skip_all)]
20 pub(crate) async fn search_query_to_object_id(
22 context: &Data<LemmyContext>,
23 ) -> Result<SearchableObjects, LemmyError> {
24 Ok(match Url::parse(query) {
26 // its already an url, just go with it
27 ObjectId::from(url).dereference(context).await?
30 // not an url, try to resolve via webfinger
31 let mut chars = query.chars();
32 let kind = chars.next();
33 let identifier = chars.as_str();
35 Some('@') => SearchableObjects::Person(
36 webfinger_resolve_actor::<LemmyContext, ApubPerson>(identifier, context).await?,
38 Some('!') => SearchableObjects::Community(
39 webfinger_resolve_actor::<LemmyContext, ApubCommunity>(identifier, context).await?,
41 _ => return Err(LemmyErrorType::InvalidQuery)?,
47 /// Converts a search query to an object id. The query MUST bbe a URL which will bbe treated
48 /// as the ObjectId directly. If the query is a webfinger identifier (@user@example.com or
49 /// !community@example.com) this method will return an error.
50 #[tracing::instrument(skip_all)]
51 pub(crate) async fn search_query_to_object_id_local(
53 context: &Data<LemmyContext>,
54 ) -> Result<SearchableObjects, LemmyError> {
55 let url = Url::parse(query)?;
56 ObjectId::from(url).dereference_local(context).await
59 /// The types of ActivityPub objects that can be fetched directly by searching for their ID.
61 pub(crate) enum SearchableObjects {
63 Community(ApubCommunity),
68 #[derive(Deserialize)]
70 pub(crate) enum SearchableKinds {
77 #[async_trait::async_trait]
78 impl Object for SearchableObjects {
79 type DataType = LemmyContext;
80 type Kind = SearchableKinds;
81 type Error = LemmyError;
83 fn last_refreshed_at(&self) -> Option<NaiveDateTime> {
85 SearchableObjects::Person(p) => p.last_refreshed_at(),
86 SearchableObjects::Community(c) => c.last_refreshed_at(),
87 SearchableObjects::Post(p) => p.last_refreshed_at(),
88 SearchableObjects::Comment(c) => c.last_refreshed_at(),
92 // TODO: this is inefficient, because if the object is not in local db, it will run 4 db queries
93 // before finally returning an error. it would be nice if we could check all 4 tables in
95 // we could skip this and always return an error, but then it would always fetch objects
96 // over http, and not be able to mark objects as deleted that were deleted by remote server.
97 #[tracing::instrument(skip_all)]
98 async fn read_from_id(
100 context: &Data<Self::DataType>,
101 ) -> Result<Option<Self>, LemmyError> {
102 let c = ApubCommunity::read_from_id(object_id.clone(), context).await?;
104 return Ok(Some(SearchableObjects::Community(c)));
106 let p = ApubPerson::read_from_id(object_id.clone(), context).await?;
108 return Ok(Some(SearchableObjects::Person(p)));
110 let p = ApubPost::read_from_id(object_id.clone(), context).await?;
112 return Ok(Some(SearchableObjects::Post(p)));
114 let c = ApubComment::read_from_id(object_id, context).await?;
116 return Ok(Some(SearchableObjects::Comment(c)));
121 #[tracing::instrument(skip_all)]
122 async fn delete(self, data: &Data<Self::DataType>) -> Result<(), LemmyError> {
124 SearchableObjects::Person(p) => p.delete(data).await,
125 SearchableObjects::Community(c) => c.delete(data).await,
126 SearchableObjects::Post(p) => p.delete(data).await,
127 SearchableObjects::Comment(c) => c.delete(data).await,
131 async fn into_json(self, _data: &Data<Self::DataType>) -> Result<Self::Kind, LemmyError> {
135 #[tracing::instrument(skip_all)]
138 expected_domain: &Url,
139 data: &Data<Self::DataType>,
140 ) -> Result<(), LemmyError> {
142 SearchableKinds::Group(a) => ApubCommunity::verify(a, expected_domain, data).await,
143 SearchableKinds::Person(a) => ApubPerson::verify(a, expected_domain, data).await,
144 SearchableKinds::Page(a) => ApubPost::verify(a, expected_domain, data).await,
145 SearchableKinds::Note(a) => ApubComment::verify(a, expected_domain, data).await,
149 #[tracing::instrument(skip_all)]
150 async fn from_json(apub: Self::Kind, context: &Data<LemmyContext>) -> Result<Self, LemmyError> {
151 use SearchableKinds as SAT;
152 use SearchableObjects as SO;
154 SAT::Group(g) => SO::Community(ApubCommunity::from_json(g, context).await?),
155 SAT::Person(p) => SO::Person(ApubPerson::from_json(p, context).await?),
156 SAT::Page(p) => SO::Post(ApubPost::from_json(p, context).await?),
157 SAT::Note(n) => SO::Comment(ApubComment::from_json(n, context).await?),