2020-04-09 19:04:31 +00:00
|
|
|
pub mod activities;
|
2020-04-27 16:57:00 +00:00
|
|
|
pub mod comment;
|
2019-12-19 21:59:13 +00:00
|
|
|
pub mod community;
|
2020-05-05 14:30:13 +00:00
|
|
|
pub mod extensions;
|
2020-04-10 11:37:35 +00:00
|
|
|
pub mod fetcher;
|
2020-07-23 14:36:45 +00:00
|
|
|
pub mod inbox;
|
2019-12-19 21:59:13 +00:00
|
|
|
pub mod post;
|
2020-05-06 02:06:24 +00:00
|
|
|
pub mod private_message;
|
2019-12-19 21:59:13 +00:00
|
|
|
pub mod user;
|
2020-04-24 14:04:36 +00:00
|
|
|
|
2020-05-16 14:04:08 +00:00
|
|
|
use crate::{
|
|
|
|
|
apub::extensions::{
|
|
|
|
|
group_extensions::GroupExtension,
|
|
|
|
|
page_extension::PageExtension,
|
|
|
|
|
signatures::{PublicKey, PublicKeyExtension},
|
|
|
|
|
},
|
2020-07-10 18:15:41 +00:00
|
|
|
blocking,
|
2020-07-01 12:54:29 +00:00
|
|
|
request::{retry, RecvError},
|
2020-05-17 01:09:26 +00:00
|
|
|
routes::webfinger::WebFingerResponse,
|
2020-07-29 11:46:11 +00:00
|
|
|
DbPool,
|
|
|
|
|
LemmyError,
|
2020-05-16 14:04:08 +00:00
|
|
|
};
|
2020-08-01 13:25:17 +00:00
|
|
|
use activitystreams::{
|
2020-07-03 12:20:28 +00:00
|
|
|
activity::Follow,
|
|
|
|
|
actor::{ApActor, Group, Person},
|
2020-08-06 12:53:58 +00:00
|
|
|
base::AsBase,
|
|
|
|
|
markers::Base,
|
2020-07-14 12:19:33 +00:00
|
|
|
object::{Page, Tombstone},
|
2020-07-03 12:20:28 +00:00
|
|
|
prelude::*,
|
2020-04-24 14:04:36 +00:00
|
|
|
};
|
2020-08-01 13:25:17 +00:00
|
|
|
use activitystreams_ext::{Ext1, Ext2};
|
2020-07-01 12:54:29 +00:00
|
|
|
use actix_web::{body::Body, client::Client, HttpResponse};
|
2020-08-11 14:31:05 +00:00
|
|
|
use anyhow::{anyhow, Context};
|
2020-05-16 14:04:08 +00:00
|
|
|
use chrono::NaiveDateTime;
|
2020-07-10 18:15:41 +00:00
|
|
|
use lemmy_db::{activity::do_insert_activity, user::User_};
|
2020-08-11 14:31:05 +00:00
|
|
|
use lemmy_utils::{
|
|
|
|
|
convert_datetime,
|
|
|
|
|
get_apub_protocol_string,
|
|
|
|
|
location_info,
|
|
|
|
|
settings::Settings,
|
|
|
|
|
MentionData,
|
|
|
|
|
};
|
2020-04-24 19:55:54 +00:00
|
|
|
use log::debug;
|
2020-05-16 14:04:08 +00:00
|
|
|
use serde::Serialize;
|
2020-07-17 21:11:07 +00:00
|
|
|
use url::{ParseError, Url};
|
2020-04-24 14:04:36 +00:00
|
|
|
|
2020-07-03 12:20:28 +00:00
|
|
|
type GroupExt = Ext2<ApActor<Group>, GroupExtension, PublicKeyExtension>;
|
|
|
|
|
type PersonExt = Ext1<ApActor<Person>, PublicKeyExtension>;
|
2020-05-18 16:15:26 +00:00
|
|
|
type PageExt = Ext1<Page, PageExtension>;
|
2020-04-03 05:02:43 +00:00
|
|
|
|
2020-04-21 20:45:01 +00:00
|
|
|
pub static APUB_JSON_CONTENT_TYPE: &str = "application/activity+json";
|
2020-04-07 15:29:23 +00:00
|
|
|
|
2020-04-17 15:33:55 +00:00
|
|
|
/// Convert the data to json and turn it into an HTTP Response with the correct ActivityPub
|
|
|
|
|
/// headers.
|
|
|
|
|
fn create_apub_response<T>(data: &T) -> HttpResponse<Body>
|
2020-03-19 01:16:17 +00:00
|
|
|
where
|
2020-04-17 15:33:55 +00:00
|
|
|
T: Serialize,
|
2020-03-19 01:16:17 +00:00
|
|
|
{
|
2020-03-16 17:30:25 +00:00
|
|
|
HttpResponse::Ok()
|
2020-04-07 15:29:23 +00:00
|
|
|
.content_type(APUB_JSON_CONTENT_TYPE)
|
2020-04-17 15:33:55 +00:00
|
|
|
.json(data)
|
2019-12-19 21:59:13 +00:00
|
|
|
}
|
2020-04-29 19:10:50 +00:00
|
|
|
|
2020-04-29 14:51:25 +00:00
|
|
|
fn create_apub_tombstone_response<T>(data: &T) -> HttpResponse<Body>
|
|
|
|
|
where
|
|
|
|
|
T: Serialize,
|
|
|
|
|
{
|
|
|
|
|
HttpResponse::Gone()
|
|
|
|
|
.content_type(APUB_JSON_CONTENT_TYPE)
|
|
|
|
|
.json(data)
|
|
|
|
|
}
|
2019-12-19 21:59:13 +00:00
|
|
|
|
2020-06-16 10:49:51 +00:00
|
|
|
// Checks if the ID has a valid format, correct scheme, and is in the allowed instance list.
|
2020-08-04 14:39:55 +00:00
|
|
|
fn check_is_apub_id_valid(apub_id: &Url) -> Result<(), LemmyError> {
|
2020-04-18 18:54:20 +00:00
|
|
|
if apub_id.scheme() != get_apub_protocol_string() {
|
2020-08-04 14:39:55 +00:00
|
|
|
return Err(anyhow!("invalid apub id scheme: {:?}", apub_id.scheme()).into());
|
2020-04-17 17:34:18 +00:00
|
|
|
}
|
|
|
|
|
|
2020-08-13 20:26:49 +00:00
|
|
|
let mut allowed_instances = Settings::get().get_allowed_instances();
|
|
|
|
|
let blocked_instances = Settings::get().get_blocked_instances();
|
2020-08-11 14:58:32 +00:00
|
|
|
|
2020-08-13 20:26:49 +00:00
|
|
|
let domain = apub_id.domain().context(location_info!())?.to_string();
|
|
|
|
|
if !allowed_instances.is_empty() {
|
|
|
|
|
// need to allow this explicitly because apub activities might contain objects from our local
|
|
|
|
|
// instance. split is needed to remove the port in our federation test setup.
|
|
|
|
|
let settings = Settings::get();
|
|
|
|
|
let local_instance = settings.hostname.split(':').collect::<Vec<&str>>();
|
|
|
|
|
allowed_instances.push(
|
|
|
|
|
local_instance
|
|
|
|
|
.first()
|
|
|
|
|
.context(location_info!())?
|
|
|
|
|
.to_string(),
|
|
|
|
|
);
|
2020-07-01 12:54:29 +00:00
|
|
|
|
2020-08-13 20:26:49 +00:00
|
|
|
if allowed_instances.contains(&domain) {
|
|
|
|
|
Ok(())
|
|
|
|
|
} else {
|
|
|
|
|
Err(anyhow!("{} not in federation allowlist", domain).into())
|
|
|
|
|
}
|
|
|
|
|
} else if !blocked_instances.is_empty() {
|
|
|
|
|
if blocked_instances.contains(&domain) {
|
|
|
|
|
Err(anyhow!("{} is in federation blocklist", domain).into())
|
|
|
|
|
} else {
|
2020-08-04 14:39:55 +00:00
|
|
|
Ok(())
|
2020-07-01 12:54:29 +00:00
|
|
|
}
|
2020-08-13 20:26:49 +00:00
|
|
|
} else {
|
|
|
|
|
panic!("Invalid config, both allowed_instances and blocked_instances are specified");
|
2020-04-17 17:34:18 +00:00
|
|
|
}
|
|
|
|
|
}
|
2020-04-24 19:55:54 +00:00
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-29 14:51:25 +00:00
|
|
|
pub trait ToApub {
|
|
|
|
|
type Response;
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn to_apub(&self, pool: &DbPool) -> Result<Self::Response, LemmyError>;
|
|
|
|
|
fn to_tombstone(&self) -> Result<Tombstone, LemmyError>;
|
2020-04-28 17:46:25 +00:00
|
|
|
}
|
|
|
|
|
|
2020-05-03 14:22:25 +00:00
|
|
|
/// Updated is actually the deletion time
|
2020-07-28 16:47:26 +00:00
|
|
|
fn create_tombstone<T>(
|
2020-04-29 14:51:25 +00:00
|
|
|
deleted: bool,
|
|
|
|
|
object_id: &str,
|
|
|
|
|
updated: Option<NaiveDateTime>,
|
2020-07-28 16:47:26 +00:00
|
|
|
former_type: T,
|
|
|
|
|
) -> Result<Tombstone, LemmyError>
|
|
|
|
|
where
|
|
|
|
|
T: ToString,
|
|
|
|
|
{
|
2020-04-29 14:51:25 +00:00
|
|
|
if deleted {
|
|
|
|
|
if let Some(updated) = updated {
|
2020-06-03 15:10:16 +00:00
|
|
|
let mut tombstone = Tombstone::new();
|
|
|
|
|
tombstone.set_id(object_id.parse()?);
|
2020-07-28 16:47:26 +00:00
|
|
|
tombstone.set_former_type(former_type.to_string());
|
2020-07-17 21:11:07 +00:00
|
|
|
tombstone.set_deleted(convert_datetime(updated));
|
2020-05-01 14:07:38 +00:00
|
|
|
Ok(tombstone)
|
|
|
|
|
} else {
|
2020-08-01 14:04:42 +00:00
|
|
|
Err(anyhow!("Cant convert to tombstone because updated time was None.").into())
|
2020-04-28 17:46:25 +00:00
|
|
|
}
|
2020-04-29 14:51:25 +00:00
|
|
|
} else {
|
2020-08-01 14:04:42 +00:00
|
|
|
Err(anyhow!("Cant convert object to tombstone if it wasnt deleted").into())
|
2020-04-28 17:46:25 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-24 21:30:27 +00:00
|
|
|
pub trait FromApub {
|
|
|
|
|
type ApubType;
|
2020-08-06 12:53:58 +00:00
|
|
|
/// Converts an object from ActivityPub type to Lemmy internal type.
|
|
|
|
|
///
|
|
|
|
|
/// * `apub` The object to read from
|
|
|
|
|
/// * `client` Web client to fetch remote actors with
|
|
|
|
|
/// * `pool` Database connection
|
|
|
|
|
/// * `expected_domain` If present, ensure that the apub object comes from the same domain as
|
|
|
|
|
/// this URL
|
|
|
|
|
///
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn from_apub(
|
2020-07-13 13:56:58 +00:00
|
|
|
apub: &Self::ApubType,
|
2020-07-01 12:54:29 +00:00
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
2020-08-06 12:53:58 +00:00
|
|
|
expected_domain: Option<Url>,
|
2020-07-01 12:54:29 +00:00
|
|
|
) -> Result<Self, LemmyError>
|
2020-04-24 19:55:54 +00:00
|
|
|
where
|
|
|
|
|
Self: Sized;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-27 16:57:00 +00:00
|
|
|
pub trait ApubObjectType {
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn send_create(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_update(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_delete(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_undo_delete(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_remove(
|
|
|
|
|
&self,
|
|
|
|
|
mod_: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_undo_remove(
|
|
|
|
|
&self,
|
|
|
|
|
mod_: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
2020-04-27 16:57:00 +00:00
|
|
|
}
|
|
|
|
|
|
2020-08-06 12:53:58 +00:00
|
|
|
pub(in crate::apub) fn check_actor_domain<T, Kind>(
|
|
|
|
|
apub: &T,
|
|
|
|
|
expected_domain: Option<Url>,
|
|
|
|
|
) -> Result<String, LemmyError>
|
|
|
|
|
where
|
|
|
|
|
T: Base + AsBase<Kind>,
|
|
|
|
|
{
|
|
|
|
|
let actor_id = if let Some(url) = expected_domain {
|
2020-08-11 14:31:05 +00:00
|
|
|
let domain = url.domain().context(location_info!())?;
|
|
|
|
|
apub.id(domain)?.context(location_info!())?
|
2020-08-06 12:53:58 +00:00
|
|
|
} else {
|
2020-08-11 14:31:05 +00:00
|
|
|
let actor_id = apub.id_unchecked().context(location_info!())?;
|
2020-08-06 12:53:58 +00:00
|
|
|
check_is_apub_id_valid(&actor_id)?;
|
|
|
|
|
actor_id
|
|
|
|
|
};
|
|
|
|
|
Ok(actor_id.to_string())
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-28 02:46:09 +00:00
|
|
|
pub trait ApubLikeableType {
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn send_like(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_dislike(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_undo_like(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
2020-04-28 02:46:09 +00:00
|
|
|
}
|
|
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
#[async_trait::async_trait(?Send)]
|
2020-04-24 19:55:54 +00:00
|
|
|
pub trait ActorType {
|
2020-07-17 21:11:07 +00:00
|
|
|
fn actor_id_str(&self) -> String;
|
2020-04-24 19:55:54 +00:00
|
|
|
|
2020-08-11 14:31:05 +00: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-25 02:34:51 +00:00
|
|
|
|
2020-07-23 14:36:45 +00:00
|
|
|
/// numeric id in the database, used for insert_activity
|
|
|
|
|
fn user_id(&self) -> i32;
|
|
|
|
|
|
2020-04-26 17:20:42 +00:00
|
|
|
// These two have default impls, since currently a community can't follow anything,
|
|
|
|
|
// and a user can't be followed (yet)
|
|
|
|
|
#[allow(unused_variables)]
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn send_follow(
|
|
|
|
|
&self,
|
2020-08-11 14:31:05 +00:00
|
|
|
follow_actor_id: &Url,
|
2020-07-01 12:54:29 +00:00
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_unfollow(
|
|
|
|
|
&self,
|
2020-08-11 14:31:05 +00:00
|
|
|
follow_actor_id: &Url,
|
2020-07-01 12:54:29 +00:00
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
2020-04-26 17:20:42 +00:00
|
|
|
|
|
|
|
|
#[allow(unused_variables)]
|
2020-07-01 12:54:29 +00:00
|
|
|
async fn send_accept_follow(
|
|
|
|
|
&self,
|
2020-07-17 21:11:07 +00:00
|
|
|
follow: Follow,
|
2020-07-01 12:54:29 +00:00
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
|
|
async fn send_delete(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_undo_delete(
|
|
|
|
|
&self,
|
|
|
|
|
creator: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
|
|
|
|
|
async fn send_remove(
|
|
|
|
|
&self,
|
|
|
|
|
mod_: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
|
|
|
|
async fn send_undo_remove(
|
|
|
|
|
&self,
|
|
|
|
|
mod_: &User_,
|
|
|
|
|
client: &Client,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>;
|
2020-05-03 14:00:59 +00:00
|
|
|
|
2020-04-27 16:57:00 +00:00
|
|
|
/// For a given community, returns the inboxes of all followers.
|
2020-08-11 14:31:05 +00:00
|
|
|
async fn get_follower_inboxes(&self, pool: &DbPool) -> Result<Vec<Url>, LemmyError>;
|
2020-04-27 16:57:00 +00:00
|
|
|
|
2020-07-17 21:11:07 +00:00
|
|
|
fn actor_id(&self) -> Result<Url, ParseError> {
|
|
|
|
|
Url::parse(&self.actor_id_str())
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-26 17:20:42 +00:00
|
|
|
// TODO move these to the db rows
|
2020-07-24 15:07:33 +00:00
|
|
|
fn get_inbox_url(&self) -> Result<Url, ParseError> {
|
|
|
|
|
Url::parse(&format!("{}/inbox", &self.actor_id_str()))
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
2020-04-26 17:20:42 +00:00
|
|
|
|
2020-08-11 14:31:05 +00:00
|
|
|
fn get_shared_inbox_url(&self) -> Result<Url, LemmyError> {
|
|
|
|
|
let actor_id = self.actor_id()?;
|
|
|
|
|
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)?)
|
2020-04-26 17:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2020-07-24 15:07:33 +00:00
|
|
|
fn get_outbox_url(&self) -> Result<Url, ParseError> {
|
|
|
|
|
Url::parse(&format!("{}/outbox", &self.actor_id_str()))
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
|
|
|
|
|
2020-08-12 14:43:45 +00:00
|
|
|
fn get_followers_url(&self) -> Result<Url, ParseError> {
|
|
|
|
|
Url::parse(&format!("{}/followers", &self.actor_id_str()))
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
2020-04-26 17:20:42 +00:00
|
|
|
|
2020-04-24 19:55:54 +00:00
|
|
|
fn get_following_url(&self) -> String {
|
2020-07-17 21:11:07 +00:00
|
|
|
format!("{}/following", &self.actor_id_str())
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
2020-04-26 17:20:42 +00:00
|
|
|
|
2020-04-24 19:55:54 +00:00
|
|
|
fn get_liked_url(&self) -> String {
|
2020-07-17 21:11:07 +00:00
|
|
|
format!("{}/liked", &self.actor_id_str())
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
2020-04-25 02:34:51 +00:00
|
|
|
|
2020-08-11 14:31:05 +00:00
|
|
|
fn get_public_key_ext(&self) -> Result<PublicKeyExtension, LemmyError> {
|
|
|
|
|
Ok(
|
|
|
|
|
PublicKey {
|
|
|
|
|
id: format!("{}#main-key", self.actor_id_str()),
|
|
|
|
|
owner: self.actor_id_str(),
|
|
|
|
|
public_key_pem: self.public_key().context(location_info!())?,
|
|
|
|
|
}
|
|
|
|
|
.to_ext(),
|
|
|
|
|
)
|
2020-04-25 02:34:51 +00:00
|
|
|
}
|
2020-04-24 19:55:54 +00:00
|
|
|
}
|
2020-05-15 16:36:11 +00:00
|
|
|
|
2020-07-01 12:54:29 +00:00
|
|
|
pub async fn fetch_webfinger_url(
|
|
|
|
|
mention: &MentionData,
|
|
|
|
|
client: &Client,
|
2020-07-17 21:11:07 +00:00
|
|
|
) -> Result<Url, LemmyError> {
|
2020-05-15 16:36:11 +00:00
|
|
|
let fetch_url = format!(
|
|
|
|
|
"{}://{}/.well-known/webfinger?resource=acct:{}@{}",
|
|
|
|
|
get_apub_protocol_string(),
|
|
|
|
|
mention.domain,
|
|
|
|
|
mention.name,
|
|
|
|
|
mention.domain
|
|
|
|
|
);
|
|
|
|
|
debug!("Fetching webfinger url: {}", &fetch_url);
|
2020-07-01 12:54:29 +00:00
|
|
|
|
|
|
|
|
let mut response = retry(|| client.get(&fetch_url).send()).await?;
|
|
|
|
|
|
|
|
|
|
let res: WebFingerResponse = response
|
|
|
|
|
.json()
|
|
|
|
|
.await
|
|
|
|
|
.map_err(|e| RecvError(e.to_string()))?;
|
|
|
|
|
|
2020-05-15 16:36:11 +00:00
|
|
|
let link = res
|
|
|
|
|
.links
|
|
|
|
|
.iter()
|
|
|
|
|
.find(|l| l.type_.eq(&Some("application/activity+json".to_string())))
|
2020-08-01 14:04:42 +00:00
|
|
|
.ok_or_else(|| anyhow!("No application/activity+json link found."))?;
|
2020-05-15 16:36:11 +00:00
|
|
|
link
|
|
|
|
|
.href
|
|
|
|
|
.to_owned()
|
2020-07-17 21:11:07 +00:00
|
|
|
.map(|u| Url::parse(&u))
|
2020-07-14 14:09:13 +00:00
|
|
|
.transpose()?
|
2020-08-01 14:04:42 +00:00
|
|
|
.ok_or_else(|| anyhow!("No href found.").into())
|
2020-05-15 16:36:11 +00:00
|
|
|
}
|
2020-07-10 18:15:41 +00:00
|
|
|
|
|
|
|
|
pub async fn insert_activity<T>(
|
|
|
|
|
user_id: i32,
|
|
|
|
|
data: T,
|
|
|
|
|
local: bool,
|
|
|
|
|
pool: &DbPool,
|
|
|
|
|
) -> Result<(), LemmyError>
|
|
|
|
|
where
|
2020-08-01 14:04:42 +00:00
|
|
|
T: Serialize + std::fmt::Debug + Send + 'static,
|
2020-07-10 18:15:41 +00:00
|
|
|
{
|
|
|
|
|
blocking(pool, move |conn| {
|
|
|
|
|
do_insert_activity(conn, user_id, &data, local)
|
|
|
|
|
})
|
|
|
|
|
.await??;
|
|
|
|
|
Ok(())
|
|
|
|
|
}
|
