2021-11-13 17:37:31 +00:00
|
|
|
use std::path::Path;
|
2021-04-09 00:22:17 +00:00
|
|
|
|
2021-11-15 19:25:43 +00:00
|
|
|
use reqwest::Method;
|
2021-04-09 00:22:17 +00:00
|
|
|
use serde_json::Value;
|
|
|
|
|
2021-12-28 18:34:13 +00:00
|
|
|
use crate::activitypub::activity::Object;
|
|
|
|
use crate::activitypub::actor::Actor;
|
|
|
|
use crate::activitypub::constants::ACTIVITY_CONTENT_TYPE;
|
2021-11-15 19:25:43 +00:00
|
|
|
use crate::config::Instance;
|
|
|
|
use crate::http_signatures::create::{create_http_signature, SignatureError};
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::models::profiles::types::ProfileCreateData;
|
|
|
|
use crate::utils::files::{save_file, FileError};
|
|
|
|
use crate::webfinger::types::JsonResourceDescriptor;
|
|
|
|
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
|
|
pub enum FetchError {
|
|
|
|
#[error("invalid URL")]
|
|
|
|
UrlError(#[from] url::ParseError),
|
|
|
|
|
2021-11-15 19:25:43 +00:00
|
|
|
#[error(transparent)]
|
|
|
|
SignatureError(#[from] SignatureError),
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[error(transparent)]
|
|
|
|
RequestError(#[from] reqwest::Error),
|
|
|
|
|
|
|
|
#[error("json parse error")]
|
|
|
|
JsonParseError(#[from] serde_json::Error),
|
|
|
|
|
|
|
|
#[error("file error")]
|
|
|
|
FileError(#[from] FileError),
|
|
|
|
|
|
|
|
#[error("{0}")]
|
|
|
|
OtherError(&'static str),
|
|
|
|
}
|
|
|
|
|
2021-11-15 19:25:43 +00:00
|
|
|
/// Sends GET request to fetch AP object
|
|
|
|
async fn send_request(
|
|
|
|
instance: &Instance,
|
|
|
|
url: &str,
|
|
|
|
query_params: &[(&str, &str)],
|
|
|
|
) -> Result<String, FetchError> {
|
|
|
|
let client = reqwest::Client::new();
|
|
|
|
let mut request_builder = client.get(url);
|
|
|
|
if !query_params.is_empty() {
|
|
|
|
request_builder = request_builder.query(query_params);
|
|
|
|
};
|
|
|
|
|
2021-11-18 14:56:52 +00:00
|
|
|
if !instance.is_private {
|
|
|
|
// Only public instance can send signed request
|
|
|
|
let headers = create_http_signature(
|
|
|
|
Method::GET,
|
|
|
|
url,
|
|
|
|
"",
|
|
|
|
&instance.actor_key,
|
|
|
|
&instance.actor_key_id(),
|
|
|
|
)?;
|
|
|
|
request_builder = request_builder
|
|
|
|
.header("Host", headers.host)
|
|
|
|
.header("Date", headers.date)
|
|
|
|
.header("Signature", headers.signature);
|
|
|
|
};
|
2022-02-08 19:51:40 +00:00
|
|
|
if !instance.is_private {
|
|
|
|
// Public instance should set User-Agent header
|
|
|
|
request_builder = request_builder
|
|
|
|
.header(reqwest::header::USER_AGENT, instance.agent());
|
|
|
|
};
|
2021-11-15 19:25:43 +00:00
|
|
|
|
|
|
|
let data = request_builder
|
|
|
|
.header(reqwest::header::ACCEPT, ACTIVITY_CONTENT_TYPE)
|
|
|
|
.send().await?
|
|
|
|
.error_for_status()?
|
|
|
|
.text().await?;
|
|
|
|
Ok(data)
|
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
pub async fn fetch_avatar_and_banner(
|
|
|
|
actor: &Actor,
|
2021-11-13 17:37:31 +00:00
|
|
|
media_dir: &Path,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<(Option<String>, Option<String>), FetchError> {
|
|
|
|
let avatar = match &actor.icon {
|
|
|
|
Some(icon) => {
|
2021-12-29 13:57:57 +00:00
|
|
|
let (file_name, _) = fetch_attachment(
|
2021-04-09 00:22:17 +00:00
|
|
|
&icon.url,
|
|
|
|
media_dir,
|
|
|
|
).await?;
|
|
|
|
Some(file_name)
|
|
|
|
},
|
|
|
|
None => None,
|
|
|
|
};
|
|
|
|
let banner = match &actor.image {
|
|
|
|
Some(image) => {
|
2021-12-29 13:57:57 +00:00
|
|
|
let (file_name, _) = fetch_attachment(
|
2021-04-09 00:22:17 +00:00
|
|
|
&image.url,
|
|
|
|
media_dir,
|
|
|
|
).await?;
|
|
|
|
Some(file_name)
|
|
|
|
},
|
|
|
|
None => None,
|
|
|
|
};
|
|
|
|
Ok((avatar, banner))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn fetch_profile(
|
2021-11-15 19:25:43 +00:00
|
|
|
instance: &Instance,
|
2021-04-09 00:22:17 +00:00
|
|
|
username: &str,
|
2021-11-15 19:25:43 +00:00
|
|
|
actor_host: &str,
|
2021-11-13 17:37:31 +00:00
|
|
|
media_dir: &Path,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<ProfileCreateData, FetchError> {
|
2021-11-15 19:25:43 +00:00
|
|
|
let actor_address = format!("{}@{}", &username, &actor_host);
|
2021-04-09 00:22:17 +00:00
|
|
|
let webfinger_account_uri = format!("acct:{}", actor_address);
|
|
|
|
// TOOD: support http
|
2021-11-15 19:25:43 +00:00
|
|
|
let webfinger_url = format!("https://{}/.well-known/webfinger", actor_host);
|
2021-04-09 00:22:17 +00:00
|
|
|
let client = reqwest::Client::new();
|
2022-02-08 19:51:40 +00:00
|
|
|
let mut request_builder = client.get(&webfinger_url);
|
|
|
|
if !instance.is_private {
|
|
|
|
// Public instance should set User-Agent header
|
|
|
|
request_builder = request_builder
|
|
|
|
.header(reqwest::header::USER_AGENT, instance.agent());
|
|
|
|
};
|
|
|
|
let webfinger_data = request_builder
|
2021-04-09 00:22:17 +00:00
|
|
|
.query(&[("resource", webfinger_account_uri)])
|
|
|
|
.send().await?
|
2021-11-07 13:43:20 +00:00
|
|
|
.error_for_status()?
|
2021-04-09 00:22:17 +00:00
|
|
|
.text().await?;
|
|
|
|
let jrd: JsonResourceDescriptor = serde_json::from_str(&webfinger_data)?;
|
|
|
|
let link = jrd.links.iter()
|
|
|
|
.find(|link| link.rel == "self")
|
|
|
|
.ok_or(FetchError::OtherError("self link not found"))?;
|
|
|
|
let actor_url = link.href.as_ref()
|
|
|
|
.ok_or(FetchError::OtherError("account href not found"))?;
|
2021-11-15 19:25:43 +00:00
|
|
|
fetch_profile_by_actor_id(instance, actor_url, media_dir).await
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn fetch_profile_by_actor_id(
|
2021-11-15 19:25:43 +00:00
|
|
|
instance: &Instance,
|
2021-04-09 00:22:17 +00:00
|
|
|
actor_url: &str,
|
2021-11-13 17:37:31 +00:00
|
|
|
media_dir: &Path,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<ProfileCreateData, FetchError> {
|
|
|
|
let actor_host = url::Url::parse(actor_url)?
|
|
|
|
.host_str()
|
|
|
|
.ok_or(FetchError::OtherError("invalid URL"))?
|
|
|
|
.to_owned();
|
2021-11-21 01:05:32 +00:00
|
|
|
if actor_host == instance.host() {
|
|
|
|
return Err(FetchError::OtherError("trying to fetch local profile"));
|
|
|
|
};
|
2021-11-15 19:25:43 +00:00
|
|
|
let actor_json = send_request(instance, actor_url, &[]).await?;
|
2022-04-21 22:52:28 +00:00
|
|
|
let actor: Actor = serde_json::from_str(&actor_json)?;
|
2021-04-09 00:22:17 +00:00
|
|
|
let (avatar, banner) = fetch_avatar_and_banner(&actor, media_dir).await?;
|
2021-09-17 12:36:24 +00:00
|
|
|
let extra_fields = actor.extra_fields();
|
2021-04-09 00:22:17 +00:00
|
|
|
let actor_address = format!(
|
|
|
|
"{}@{}",
|
|
|
|
actor.preferred_username,
|
|
|
|
actor_host,
|
|
|
|
);
|
|
|
|
let profile_data = ProfileCreateData {
|
2022-04-21 22:52:28 +00:00
|
|
|
username: actor.preferred_username.clone(),
|
|
|
|
display_name: actor.name.clone(),
|
2021-04-09 00:22:17 +00:00
|
|
|
acct: actor_address,
|
2022-04-21 22:52:28 +00:00
|
|
|
bio: actor.summary.clone(),
|
2021-09-17 12:36:24 +00:00
|
|
|
avatar,
|
|
|
|
banner,
|
2022-04-26 14:12:26 +00:00
|
|
|
identity_proofs: vec![],
|
2021-09-17 12:36:24 +00:00
|
|
|
extra_fields,
|
2022-04-21 22:52:28 +00:00
|
|
|
actor_json: Some(actor),
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
Ok(profile_data)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn fetch_attachment(
|
|
|
|
url: &str,
|
2021-11-13 17:37:31 +00:00
|
|
|
output_dir: &Path,
|
2021-12-29 13:57:57 +00:00
|
|
|
) -> Result<(String, Option<String>), FetchError> {
|
2021-04-09 00:22:17 +00:00
|
|
|
let response = reqwest::get(url).await?;
|
|
|
|
let file_data = response.bytes().await?;
|
2021-12-29 13:57:57 +00:00
|
|
|
let (file_name, media_type) = save_file(file_data.to_vec(), output_dir)?;
|
|
|
|
Ok((file_name, media_type))
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
2021-10-09 23:59:45 +00:00
|
|
|
|
|
|
|
pub async fn fetch_object(
|
2021-11-18 14:37:48 +00:00
|
|
|
instance: &Instance,
|
2021-10-09 23:59:45 +00:00
|
|
|
object_url: &str,
|
|
|
|
) -> Result<Object, FetchError> {
|
2021-11-18 14:37:48 +00:00
|
|
|
let object_json = send_request(instance, object_url, &[]).await?;
|
2021-10-09 23:59:45 +00:00
|
|
|
let object_value: Value = serde_json::from_str(&object_json)?;
|
|
|
|
let object: Object = serde_json::from_value(object_value)?;
|
|
|
|
Ok(object)
|
|
|
|
}
|