2020-09-24 07:53:21 -06:00
|
|
|
#[macro_use]
|
|
|
|
extern crate lazy_static;
|
|
|
|
|
2020-10-12 08:10:09 -06:00
|
|
|
pub mod activities;
|
2020-08-31 07:48:02 -06:00
|
|
|
pub mod activity_queue;
|
2020-05-05 08:30:13 -06:00
|
|
|
pub mod extensions;
|
2020-04-10 05:37:35 -06:00
|
|
|
pub mod fetcher;
|
2020-10-12 08:10:09 -06:00
|
|
|
pub mod http;
|
2020-07-23 08:36:45 -06:00
|
|
|
pub mod inbox;
|
2020-10-12 08:10:09 -06:00
|
|
|
pub mod objects;
|
2021-02-09 11:26:06 -07:00
|
|
|
pub mod routes;
|
2020-04-24 08:04:36 -06:00
|
|
|
|
2020-09-24 07:53:21 -06:00
|
|
|
use crate::extensions::{
|
2021-03-24 10:43:18 -06:00
|
|
|
group_extension::GroupExtension,
|
2020-09-24 07:53:21 -06:00
|
|
|
page_extension::PageExtension,
|
2021-03-24 10:43:18 -06:00
|
|
|
person_extension::PersonExtension,
|
2020-09-24 07:53:21 -06:00
|
|
|
signatures::{PublicKey, PublicKeyExtension},
|
2020-05-16 08:04:08 -06:00
|
|
|
};
|
2020-08-01 07:25:17 -06:00
|
|
|
use activitystreams::{
|
2020-07-03 06:20:28 -06:00
|
|
|
activity::Follow,
|
2021-03-19 10:11:34 -06:00
|
|
|
actor,
|
2020-10-14 09:34:11 -06:00
|
|
|
base::AnyBase,
|
2020-12-08 10:38:48 -07:00
|
|
|
object::{ApObject, Note, Page},
|
2020-04-24 08:04:36 -06:00
|
|
|
};
|
2020-08-01 07:25:17 -06:00
|
|
|
use activitystreams_ext::{Ext1, Ext2};
|
2020-08-11 08:31:05 -06:00
|
|
|
use anyhow::{anyhow, Context};
|
2021-01-12 09:12:41 -07:00
|
|
|
use diesel::NotFound;
|
2021-03-01 06:08:41 -07:00
|
|
|
use lemmy_api_structs::blocking;
|
2021-01-12 09:12:41 -07:00
|
|
|
use lemmy_db_queries::{source::activity::Activity_, ApubObject, DbPool};
|
2021-03-02 05:41:48 -07:00
|
|
|
use lemmy_db_schema::{
|
|
|
|
source::{
|
|
|
|
activity::Activity,
|
|
|
|
comment::Comment,
|
|
|
|
community::Community,
|
2021-03-19 10:11:34 -06:00
|
|
|
person::{Person as DbPerson, Person},
|
2021-03-02 05:41:48 -07:00
|
|
|
post::Post,
|
|
|
|
private_message::PrivateMessage,
|
|
|
|
},
|
|
|
|
DbUrl,
|
2021-01-12 09:12:41 -07:00
|
|
|
};
|
2021-03-01 10:24:11 -07:00
|
|
|
use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
|
2020-09-24 07:53:21 -06:00
|
|
|
use lemmy_websocket::LemmyContext;
|
2020-05-16 08:04:08 -06:00
|
|
|
use serde::Serialize;
|
2020-10-22 10:12:43 -06:00
|
|
|
use std::net::IpAddr;
|
2020-07-17 15:11:07 -06:00
|
|
|
use url::{ParseError, Url};
|
2020-04-24 08:04:36 -06:00
|
|
|
|
2020-10-19 08:29:35 -06:00
|
|
|
/// Activitystreams type for community
|
2021-03-19 10:11:34 -06:00
|
|
|
type GroupExt = Ext2<actor::ApActor<ApObject<actor::Group>>, GroupExtension, PublicKeyExtension>;
|
2021-03-10 15:33:55 -07:00
|
|
|
/// Activitystreams type for person
|
2021-03-24 10:43:18 -06:00
|
|
|
type PersonExt = Ext2<actor::ApActor<ApObject<actor::Person>>, PersonExtension, PublicKeyExtension>;
|
2020-10-19 08:29:35 -06:00
|
|
|
/// Activitystreams type for post
|
2020-11-24 10:53:43 -07:00
|
|
|
type PageExt = Ext1<ApObject<Page>, PageExtension>;
|
|
|
|
type NoteExt = ApObject<Note>;
|
2020-04-02 23:02:43 -06:00
|
|
|
|
2020-04-21 14:45:01 -06:00
|
|
|
pub static APUB_JSON_CONTENT_TYPE: &str = "application/activity+json";
|
2020-04-07 09:29:23 -06:00
|
|
|
|
2020-10-19 08:29:35 -06:00
|
|
|
/// Checks if the ID is allowed for sending or receiving.
|
|
|
|
///
|
|
|
|
/// In particular, it checks for:
|
|
|
|
/// - federation being enabled (if its disabled, only local URLs are allowed)
|
|
|
|
/// - the correct scheme (either http or https)
|
|
|
|
/// - URL being in the allowlist (if it is active)
|
|
|
|
/// - URL not being in the blocklist (if it is active)
|
|
|
|
///
|
|
|
|
/// Note that only one of allowlist and blacklist can be enabled, not both.
|
2020-08-04 08:39:55 -06:00
|
|
|
fn check_is_apub_id_valid(apub_id: &Url) -> Result<(), LemmyError> {
|
2020-08-18 07:12:03 -06:00
|
|
|
let settings = Settings::get();
|
|
|
|
let domain = apub_id.domain().context(location_info!())?.to_string();
|
2021-01-14 18:18:18 -07:00
|
|
|
let local_instance = settings.get_hostname_without_port()?;
|
2020-08-18 07:12:03 -06:00
|
|
|
|
2021-03-01 10:24:11 -07:00
|
|
|
if !settings.federation().enabled {
|
2020-08-18 07:12:03 -06:00
|
|
|
return if domain == local_instance {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(
|
|
|
|
anyhow!(
|
|
|
|
"Trying to connect with {}, but federation is disabled",
|
|
|
|
domain
|
|
|
|
)
|
|
|
|
.into(),
|
|
|
|
)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-10-22 10:12:43 -06:00
|
|
|
let host = apub_id.host_str().context(location_info!())?;
|
|
|
|
let host_as_ip = host.parse::<IpAddr>();
|
|
|
|
if host == "localhost" || host_as_ip.is_ok() {
|
2021-02-05 09:15:29 -07:00
|
|
|
return Err(anyhow!("invalid hostname {}: {}", host, apub_id).into());
|
2020-10-22 10:12:43 -06:00
|
|
|
}
|
|
|
|
|
2020-09-25 09:33:00 -06:00
|
|
|
if apub_id.scheme() != Settings::get().get_protocol_string() {
|
2021-02-05 09:15:29 -07:00
|
|
|
return Err(anyhow!("invalid apub id scheme {}: {}", apub_id.scheme(), apub_id).into());
|
2020-04-17 11:34:18 -06:00
|
|
|
}
|
|
|
|
|
2021-03-01 10:24:11 -07:00
|
|
|
let allowed_instances = Settings::get().get_allowed_instances();
|
2020-08-13 14:26:49 -06:00
|
|
|
let blocked_instances = Settings::get().get_blocked_instances();
|
2021-03-01 10:24:11 -07:00
|
|
|
|
|
|
|
if allowed_instances.is_none() && blocked_instances.is_none() {
|
2020-10-02 08:21:14 -06:00
|
|
|
Ok(())
|
2021-03-01 10:24:11 -07:00
|
|
|
} else if let Some(mut allowed) = allowed_instances {
|
2020-10-12 08:10:09 -06:00
|
|
|
// need to allow this explicitly because apub receive might contain objects from our local
|
2020-08-13 14:26:49 -06:00
|
|
|
// instance. split is needed to remove the port in our federation test setup.
|
2021-03-01 10:24:11 -07:00
|
|
|
allowed.push(local_instance);
|
2020-07-01 06:54:29 -06:00
|
|
|
|
2021-03-01 10:24:11 -07:00
|
|
|
if allowed.contains(&domain) {
|
2020-08-13 14:26:49 -06:00
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(anyhow!("{} not in federation allowlist", domain).into())
|
|
|
|
}
|
2021-03-01 10:24:11 -07:00
|
|
|
} else if let Some(blocked) = blocked_instances {
|
|
|
|
if blocked.contains(&domain) {
|
2020-08-13 14:26:49 -06:00
|
|
|
Err(anyhow!("{} is in federation blocklist", domain).into())
|
|
|
|
} else {
|
2020-08-04 08:39:55 -06:00
|
|
|
Ok(())
|
2020-07-01 06:54:29 -06:00
|
|
|
}
|
2020-08-13 14:26:49 -06:00
|
|
|
} else {
|
|
|
|
panic!("Invalid config, both allowed_instances and blocked_instances are specified");
|
2020-04-17 11:34:18 -06:00
|
|
|
}
|
|
|
|
}
|
2020-04-24 13:55:54 -06:00
|
|
|
|
2020-10-19 08:29:35 -06:00
|
|
|
/// Common functions for ActivityPub objects, which are implemented by most (but not all) objects
|
|
|
|
/// and actors in Lemmy.
|
2020-07-01 06:54:29 -06:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-27 10:57:00 -06:00
|
|
|
pub trait ApubObjectType {
|
2021-03-10 21:43:11 -07:00
|
|
|
async fn send_create(&self, creator: &DbPerson, context: &LemmyContext)
|
|
|
|
-> Result<(), LemmyError>;
|
|
|
|
async fn send_update(&self, creator: &DbPerson, context: &LemmyContext)
|
|
|
|
-> Result<(), LemmyError>;
|
|
|
|
async fn send_delete(&self, creator: &DbPerson, context: &LemmyContext)
|
|
|
|
-> Result<(), LemmyError>;
|
2020-07-01 06:54:29 -06:00
|
|
|
async fn send_undo_delete(
|
|
|
|
&self,
|
2021-03-10 15:33:55 -07:00
|
|
|
creator: &DbPerson,
|
2020-08-18 07:43:50 -06:00
|
|
|
context: &LemmyContext,
|
2020-07-01 06:54:29 -06:00
|
|
|
) -> Result<(), LemmyError>;
|
2021-03-10 15:33:55 -07:00
|
|
|
async fn send_remove(&self, mod_: &DbPerson, context: &LemmyContext) -> Result<(), LemmyError>;
|
2021-03-10 21:43:11 -07:00
|
|
|
async fn send_undo_remove(
|
|
|
|
&self,
|
|
|
|
mod_: &DbPerson,
|
2020-08-18 07:43:50 -06:00
|
|
|
context: &LemmyContext,
|
2020-07-01 06:54:29 -06:00
|
|
|
) -> Result<(), LemmyError>;
|
2020-04-27 10:57:00 -06:00
|
|
|
}
|
|
|
|
|
2020-07-01 06:54:29 -06:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-27 20:46:09 -06:00
|
|
|
pub trait ApubLikeableType {
|
2021-03-10 15:33:55 -07:00
|
|
|
async fn send_like(&self, creator: &DbPerson, context: &LemmyContext) -> Result<(), LemmyError>;
|
2021-03-10 21:43:11 -07:00
|
|
|
async fn send_dislike(
|
|
|
|
&self,
|
|
|
|
creator: &DbPerson,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
async fn send_undo_like(
|
|
|
|
&self,
|
|
|
|
creator: &DbPerson,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
2020-04-27 20:46:09 -06:00
|
|
|
}
|
|
|
|
|
2021-03-10 15:33:55 -07:00
|
|
|
/// Common methods provided by ActivityPub actors (community and person). Not all methods are
|
2020-10-19 08:29:35 -06:00
|
|
|
/// implemented by all actors.
|
2020-07-01 06:54:29 -06:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-24 13:55:54 -06:00
|
|
|
pub trait ActorType {
|
2021-02-04 09:34:58 -07:00
|
|
|
fn is_local(&self) -> bool;
|
2021-01-27 09:42:23 -07:00
|
|
|
fn actor_id(&self) -> Url;
|
2020-04-24 13:55:54 -06:00
|
|
|
|
2020-08-11 08:31:05 -06:00
|
|
|
// TODO: every actor should have a public key, so this shouldnt be an option (needs to be fixed in db)
|
|
|
|
fn public_key(&self) -> Option<String>;
|
|
|
|
fn private_key(&self) -> Option<String>;
|
2020-04-24 20:34:51 -06:00
|
|
|
|
2021-02-04 09:34:58 -07:00
|
|
|
fn get_shared_inbox_or_inbox_url(&self) -> Url;
|
2020-04-24 13:55:54 -06:00
|
|
|
|
2021-02-04 09:34:58 -07:00
|
|
|
/// Outbox URL is not generally used by Lemmy, so it can be generated on the fly (but only for
|
|
|
|
/// local actors).
|
|
|
|
fn get_outbox_url(&self) -> Result<Url, LemmyError> {
|
|
|
|
if !self.is_local() {
|
|
|
|
return Err(anyhow!("get_outbox_url() called for remote actor").into());
|
|
|
|
}
|
|
|
|
Ok(Url::parse(&format!("{}/outbox", &self.actor_id()))?)
|
2020-04-24 13:55:54 -06:00
|
|
|
}
|
2020-04-26 11:20:42 -06:00
|
|
|
|
2020-08-11 08:31:05 -06:00
|
|
|
fn get_public_key_ext(&self) -> Result<PublicKeyExtension, LemmyError> {
|
|
|
|
Ok(
|
|
|
|
PublicKey {
|
2021-01-27 09:42:23 -07:00
|
|
|
id: format!("{}#main-key", self.actor_id()),
|
|
|
|
owner: self.actor_id(),
|
2020-08-11 08:31:05 -06:00
|
|
|
public_key_pem: self.public_key().context(location_info!())?,
|
|
|
|
}
|
|
|
|
.to_ext(),
|
|
|
|
)
|
2020-04-24 20:34:51 -06:00
|
|
|
}
|
2020-04-24 13:55:54 -06:00
|
|
|
}
|
2020-05-15 10:36:11 -06:00
|
|
|
|
2021-03-17 11:12:37 -06:00
|
|
|
#[async_trait::async_trait(?Send)]
|
|
|
|
pub trait CommunityType {
|
|
|
|
async fn get_follower_inboxes(&self, pool: &DbPool) -> Result<Vec<Url>, LemmyError>;
|
|
|
|
async fn send_accept_follow(
|
|
|
|
&self,
|
|
|
|
follow: Follow,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
async fn send_delete(&self, context: &LemmyContext) -> Result<(), LemmyError>;
|
|
|
|
async fn send_undo_delete(&self, context: &LemmyContext) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
async fn send_remove(&self, context: &LemmyContext) -> Result<(), LemmyError>;
|
|
|
|
async fn send_undo_remove(&self, context: &LemmyContext) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
async fn send_announce(
|
|
|
|
&self,
|
|
|
|
activity: AnyBase,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
async fn send_add_mod(
|
|
|
|
&self,
|
2021-03-19 10:11:34 -06:00
|
|
|
actor: &Person,
|
|
|
|
added_mod: Person,
|
2021-03-17 11:12:37 -06:00
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
async fn send_remove_mod(
|
|
|
|
&self,
|
2021-03-19 10:11:34 -06:00
|
|
|
actor: &Person,
|
|
|
|
removed_mod: Person,
|
2021-03-17 11:12:37 -06:00
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[async_trait::async_trait(?Send)]
|
|
|
|
pub trait UserType {
|
|
|
|
async fn send_follow(
|
|
|
|
&self,
|
|
|
|
follow_actor_id: &Url,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
async fn send_unfollow(
|
|
|
|
&self,
|
|
|
|
follow_actor_id: &Url,
|
|
|
|
context: &LemmyContext,
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
}
|
|
|
|
|
2021-02-04 09:34:58 -07:00
|
|
|
pub enum EndpointType {
|
|
|
|
Community,
|
2021-03-10 15:33:55 -07:00
|
|
|
Person,
|
2021-02-04 09:34:58 -07:00
|
|
|
Post,
|
|
|
|
Comment,
|
|
|
|
PrivateMessage,
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generates the ActivityPub ID for a given object type and ID.
|
|
|
|
pub fn generate_apub_endpoint(
|
|
|
|
endpoint_type: EndpointType,
|
|
|
|
name: &str,
|
2021-03-02 05:41:48 -07:00
|
|
|
) -> Result<DbUrl, ParseError> {
|
2021-02-04 09:34:58 -07:00
|
|
|
let point = match endpoint_type {
|
|
|
|
EndpointType::Community => "c",
|
2021-03-10 15:33:55 -07:00
|
|
|
EndpointType::Person => "u",
|
2021-02-04 09:34:58 -07:00
|
|
|
EndpointType::Post => "post",
|
|
|
|
EndpointType::Comment => "comment",
|
|
|
|
EndpointType::PrivateMessage => "private_message",
|
|
|
|
};
|
|
|
|
|
|
|
|
Ok(
|
|
|
|
Url::parse(&format!(
|
|
|
|
"{}/{}/{}",
|
|
|
|
Settings::get().get_protocol_and_hostname(),
|
|
|
|
point,
|
|
|
|
name
|
|
|
|
))?
|
|
|
|
.into(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-03-02 05:41:48 -07:00
|
|
|
pub fn generate_followers_url(actor_id: &DbUrl) -> Result<DbUrl, ParseError> {
|
2021-02-04 09:34:58 -07:00
|
|
|
Ok(Url::parse(&format!("{}/followers", actor_id))?.into())
|
|
|
|
}
|
|
|
|
|
2021-03-02 05:41:48 -07:00
|
|
|
pub fn generate_inbox_url(actor_id: &DbUrl) -> Result<DbUrl, ParseError> {
|
2021-02-04 09:34:58 -07:00
|
|
|
Ok(Url::parse(&format!("{}/inbox", actor_id))?.into())
|
|
|
|
}
|
|
|
|
|
2021-03-02 05:41:48 -07:00
|
|
|
pub fn generate_shared_inbox_url(actor_id: &DbUrl) -> Result<DbUrl, LemmyError> {
|
2021-02-04 09:34:58 -07:00
|
|
|
let actor_id = actor_id.clone().into_inner();
|
|
|
|
let url = format!(
|
|
|
|
"{}://{}{}/inbox",
|
|
|
|
&actor_id.scheme(),
|
|
|
|
&actor_id.host_str().context(location_info!())?,
|
|
|
|
if let Some(port) = actor_id.port() {
|
|
|
|
format!(":{}", port)
|
|
|
|
} else {
|
|
|
|
"".to_string()
|
|
|
|
},
|
|
|
|
);
|
|
|
|
Ok(Url::parse(&url)?.into())
|
|
|
|
}
|
|
|
|
|
2021-03-08 06:40:28 -07:00
|
|
|
pub(crate) fn generate_moderators_url(community_id: &DbUrl) -> Result<DbUrl, LemmyError> {
|
|
|
|
Ok(Url::parse(&format!("{}/moderators", community_id))?.into())
|
|
|
|
}
|
|
|
|
|
2020-10-19 08:29:35 -06:00
|
|
|
/// Store a sent or received activity in the database, for logging purposes. These records are not
|
|
|
|
/// persistent.
|
2020-12-08 10:38:48 -07:00
|
|
|
pub(crate) async fn insert_activity<T>(
|
2020-10-23 06:29:56 -06:00
|
|
|
ap_id: &Url,
|
|
|
|
activity: T,
|
2020-07-10 12:15:41 -06:00
|
|
|
local: bool,
|
2020-11-06 06:06:47 -07:00
|
|
|
sensitive: bool,
|
2020-07-10 12:15:41 -06:00
|
|
|
pool: &DbPool,
|
|
|
|
) -> Result<(), LemmyError>
|
|
|
|
where
|
2020-08-01 08:04:42 -06:00
|
|
|
T: Serialize + std::fmt::Debug + Send + 'static,
|
2020-07-10 12:15:41 -06:00
|
|
|
{
|
2021-03-02 05:41:48 -07:00
|
|
|
let ap_id = ap_id.to_owned().into();
|
2020-07-10 12:15:41 -06:00
|
|
|
blocking(pool, move |conn| {
|
2020-11-06 06:06:47 -07:00
|
|
|
Activity::insert(conn, ap_id, &activity, local, sensitive)
|
2020-07-10 12:15:41 -06:00
|
|
|
})
|
|
|
|
.await??;
|
|
|
|
Ok(())
|
|
|
|
}
|
2021-01-12 09:12:41 -07:00
|
|
|
|
|
|
|
pub(crate) enum PostOrComment {
|
2021-03-02 05:41:48 -07:00
|
|
|
Comment(Box<Comment>),
|
|
|
|
Post(Box<Post>),
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Tries to find a post or comment in the local database, without any network requests.
|
|
|
|
/// This is used to handle deletions and removals, because in case we dont have the object, we can
|
|
|
|
/// simply ignore the activity.
|
|
|
|
pub(crate) async fn find_post_or_comment_by_id(
|
|
|
|
context: &LemmyContext,
|
|
|
|
apub_id: Url,
|
|
|
|
) -> Result<PostOrComment, LemmyError> {
|
2021-01-27 09:42:23 -07:00
|
|
|
let ap_id = apub_id.clone();
|
2021-01-12 09:12:41 -07:00
|
|
|
let post = blocking(context.pool(), move |conn| {
|
2021-01-27 09:42:23 -07:00
|
|
|
Post::read_from_apub_id(conn, &ap_id.into())
|
2021-01-12 09:12:41 -07:00
|
|
|
})
|
|
|
|
.await?;
|
|
|
|
if let Ok(p) = post {
|
2021-03-02 05:41:48 -07:00
|
|
|
return Ok(PostOrComment::Post(Box::new(p)));
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
2021-01-27 09:42:23 -07:00
|
|
|
let ap_id = apub_id.clone();
|
2021-01-12 09:12:41 -07:00
|
|
|
let comment = blocking(context.pool(), move |conn| {
|
2021-01-27 09:42:23 -07:00
|
|
|
Comment::read_from_apub_id(conn, &ap_id.into())
|
2021-01-12 09:12:41 -07:00
|
|
|
})
|
|
|
|
.await?;
|
|
|
|
if let Ok(c) = comment {
|
2021-03-02 05:41:48 -07:00
|
|
|
return Ok(PostOrComment::Comment(Box::new(c)));
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Err(NotFound.into())
|
|
|
|
}
|
|
|
|
|
2021-03-17 11:12:37 -06:00
|
|
|
#[derive(Debug)]
|
2021-01-12 09:12:41 -07:00
|
|
|
pub(crate) enum Object {
|
2021-03-10 21:43:11 -07:00
|
|
|
Comment(Box<Comment>),
|
|
|
|
Post(Box<Post>),
|
|
|
|
Community(Box<Community>),
|
|
|
|
Person(Box<DbPerson>),
|
|
|
|
PrivateMessage(Box<PrivateMessage>),
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) async fn find_object_by_id(
|
|
|
|
context: &LemmyContext,
|
|
|
|
apub_id: Url,
|
|
|
|
) -> Result<Object, LemmyError> {
|
2021-01-27 09:42:23 -07:00
|
|
|
let ap_id = apub_id.clone();
|
|
|
|
if let Ok(pc) = find_post_or_comment_by_id(context, ap_id.to_owned()).await {
|
2021-01-12 09:12:41 -07:00
|
|
|
return Ok(match pc {
|
2021-03-10 21:43:11 -07:00
|
|
|
PostOrComment::Post(p) => Object::Post(Box::new(*p)),
|
|
|
|
PostOrComment::Comment(c) => Object::Comment(Box::new(*c)),
|
2021-01-12 09:12:41 -07:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-01-27 09:42:23 -07:00
|
|
|
let ap_id = apub_id.clone();
|
2021-03-10 15:33:55 -07:00
|
|
|
let person = blocking(context.pool(), move |conn| {
|
|
|
|
DbPerson::read_from_apub_id(conn, &ap_id.into())
|
2021-01-12 09:12:41 -07:00
|
|
|
})
|
|
|
|
.await?;
|
2021-03-10 15:33:55 -07:00
|
|
|
if let Ok(u) = person {
|
2021-03-10 21:43:11 -07:00
|
|
|
return Ok(Object::Person(Box::new(u)));
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
2021-01-27 09:42:23 -07:00
|
|
|
let ap_id = apub_id.clone();
|
2021-01-12 09:12:41 -07:00
|
|
|
let community = blocking(context.pool(), move |conn| {
|
2021-01-27 09:42:23 -07:00
|
|
|
Community::read_from_apub_id(conn, &ap_id.into())
|
2021-01-12 09:12:41 -07:00
|
|
|
})
|
|
|
|
.await?;
|
|
|
|
if let Ok(c) = community {
|
2021-03-10 21:43:11 -07:00
|
|
|
return Ok(Object::Community(Box::new(c)));
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
let private_message = blocking(context.pool(), move |conn| {
|
2021-01-27 09:42:23 -07:00
|
|
|
PrivateMessage::read_from_apub_id(conn, &apub_id.into())
|
2021-01-12 09:12:41 -07:00
|
|
|
})
|
|
|
|
.await?;
|
|
|
|
if let Ok(pm) = private_message {
|
2021-03-10 21:43:11 -07:00
|
|
|
return Ok(Object::PrivateMessage(Box::new(pm)));
|
2021-01-12 09:12:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
Err(NotFound.into())
|
|
|
|
}
|