2021-11-13 17:37:31 +00:00
|
|
|
use std::path::Path;
|
2021-10-09 22:58:21 +00:00
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
use regex::Regex;
|
|
|
|
use serde_json::Value;
|
2021-10-09 22:58:21 +00:00
|
|
|
use tokio_postgres::GenericClient;
|
2021-04-09 00:22:17 +00:00
|
|
|
use uuid::Uuid;
|
|
|
|
|
2021-11-15 19:25:43 +00:00
|
|
|
use crate::config::{Config, Instance};
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::database::{Pool, get_database_client};
|
2021-10-09 22:58:21 +00:00
|
|
|
use crate::errors::{DatabaseError, HttpError, ValidationError};
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::models::attachments::queries::create_attachment;
|
2021-11-18 21:48:49 +00:00
|
|
|
use crate::models::posts::types::{Post, PostCreateData, Visibility};
|
2021-10-09 23:59:45 +00:00
|
|
|
use crate::models::posts::queries::{
|
|
|
|
create_post,
|
|
|
|
get_post_by_id,
|
|
|
|
get_post_by_object_id,
|
2021-11-12 14:51:03 +00:00
|
|
|
delete_post,
|
2021-10-09 23:59:45 +00:00
|
|
|
};
|
2021-12-07 23:28:58 +00:00
|
|
|
use crate::models::posts::tags::normalize_tag;
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::models::profiles::queries::{
|
|
|
|
get_profile_by_actor_id,
|
|
|
|
get_profile_by_acct,
|
2021-10-09 22:58:21 +00:00
|
|
|
create_profile,
|
2021-04-09 00:22:17 +00:00
|
|
|
update_profile,
|
|
|
|
};
|
2021-10-09 22:58:21 +00:00
|
|
|
use crate::models::profiles::types::{DbActorProfile, ProfileUpdateData};
|
2021-12-15 01:00:42 +00:00
|
|
|
use crate::models::reactions::queries::{
|
|
|
|
create_reaction,
|
|
|
|
get_reaction_by_activity_id,
|
|
|
|
delete_reaction,
|
|
|
|
};
|
2021-09-20 21:06:48 +00:00
|
|
|
use crate::models::relationships::queries::{
|
|
|
|
follow_request_accepted,
|
|
|
|
follow_request_rejected,
|
2021-09-20 21:45:33 +00:00
|
|
|
follow,
|
|
|
|
unfollow,
|
2021-09-20 21:06:48 +00:00
|
|
|
};
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::models::users::queries::get_user_by_id;
|
|
|
|
use super::activity::{Object, Activity, create_activity_accept_follow};
|
|
|
|
use super::actor::Actor;
|
|
|
|
use super::deliverer::deliver_activity;
|
2021-10-09 22:58:21 +00:00
|
|
|
use super::fetcher::{
|
|
|
|
fetch_avatar_and_banner,
|
|
|
|
fetch_profile_by_actor_id,
|
|
|
|
fetch_attachment,
|
2021-10-09 23:59:45 +00:00
|
|
|
fetch_object,
|
2021-10-09 22:58:21 +00:00
|
|
|
};
|
2021-04-09 00:22:17 +00:00
|
|
|
use super::vocabulary::*;
|
|
|
|
|
2021-09-20 21:45:33 +00:00
|
|
|
fn parse_actor_id(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_id: &str,
|
|
|
|
) -> Result<String, ValidationError> {
|
|
|
|
let url_regexp_str = format!(
|
|
|
|
"^{}/users/(?P<username>[0-9a-z_]+)$",
|
|
|
|
instance_url.replace(".", r"\."),
|
|
|
|
);
|
|
|
|
let url_regexp = Regex::new(&url_regexp_str)
|
|
|
|
.map_err(|_| ValidationError("error"))?;
|
2021-11-13 17:37:31 +00:00
|
|
|
let url_caps = url_regexp.captures(actor_id)
|
2021-04-09 00:22:17 +00:00
|
|
|
.ok_or(ValidationError("invalid actor ID"))?;
|
|
|
|
let username = url_caps.name("username")
|
|
|
|
.ok_or(ValidationError("invalid actor ID"))?
|
|
|
|
.as_str()
|
|
|
|
.to_owned();
|
|
|
|
Ok(username)
|
|
|
|
}
|
|
|
|
|
2021-09-20 21:45:33 +00:00
|
|
|
fn parse_object_id(
|
|
|
|
instance_url: &str,
|
|
|
|
object_id: &str,
|
|
|
|
) -> Result<Uuid, ValidationError> {
|
|
|
|
let url_regexp_str = format!(
|
|
|
|
"^{}/objects/(?P<uuid>[0-9a-f-]+)$",
|
|
|
|
instance_url.replace(".", r"\."),
|
|
|
|
);
|
|
|
|
let url_regexp = Regex::new(&url_regexp_str)
|
|
|
|
.map_err(|_| ValidationError("error"))?;
|
2021-11-13 17:37:31 +00:00
|
|
|
let url_caps = url_regexp.captures(object_id)
|
2021-04-09 00:22:17 +00:00
|
|
|
.ok_or(ValidationError("invalid object ID"))?;
|
2021-11-29 20:45:36 +00:00
|
|
|
let internal_object_id: Uuid = url_caps.name("uuid")
|
2021-04-09 00:22:17 +00:00
|
|
|
.ok_or(ValidationError("invalid object ID"))?
|
|
|
|
.as_str().parse()
|
|
|
|
.map_err(|_| ValidationError("invalid object ID"))?;
|
2021-11-29 20:45:36 +00:00
|
|
|
Ok(internal_object_id)
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
2021-11-18 23:24:13 +00:00
|
|
|
fn parse_array(value: &Value) -> Result<Vec<String>, ValidationError> {
|
|
|
|
let result = match value {
|
|
|
|
Value::String(string) => vec![string.to_string()],
|
|
|
|
Value::Array(array) => {
|
2021-11-20 21:15:56 +00:00
|
|
|
array.iter()
|
2021-11-18 23:24:13 +00:00
|
|
|
.filter_map(|val| val.as_str().map(|s| s.to_string()))
|
|
|
|
.collect()
|
|
|
|
},
|
|
|
|
_ => return Err(ValidationError("invalid attribute value")),
|
|
|
|
};
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2021-11-29 20:45:36 +00:00
|
|
|
/// Parses object json value and returns its ID as string
|
|
|
|
fn get_object_id(object: Value) -> Result<String, ValidationError> {
|
|
|
|
let object_id = match object.as_str() {
|
|
|
|
Some(object_id) => object_id.to_owned(),
|
|
|
|
None => {
|
|
|
|
let object: Object = serde_json::from_value(object)
|
|
|
|
.map_err(|_| ValidationError("invalid object"))?;
|
|
|
|
object.id
|
|
|
|
},
|
|
|
|
};
|
|
|
|
Ok(object_id)
|
|
|
|
}
|
|
|
|
|
2021-10-09 22:58:21 +00:00
|
|
|
async fn get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client: &impl GenericClient,
|
2021-11-15 19:25:43 +00:00
|
|
|
instance: &Instance,
|
2021-10-09 22:58:21 +00:00
|
|
|
actor_id: &str,
|
2021-11-13 17:37:31 +00:00
|
|
|
media_dir: &Path,
|
2021-10-09 22:58:21 +00:00
|
|
|
) -> Result<DbActorProfile, HttpError> {
|
|
|
|
let profile = match get_profile_by_actor_id(db_client, actor_id).await {
|
|
|
|
Ok(profile) => profile,
|
|
|
|
Err(DatabaseError::NotFound(_)) => {
|
2021-11-15 19:25:43 +00:00
|
|
|
let profile_data = fetch_profile_by_actor_id(
|
|
|
|
instance, actor_id, media_dir,
|
|
|
|
)
|
|
|
|
.await
|
2021-10-09 22:58:21 +00:00
|
|
|
.map_err(|_| ValidationError("failed to fetch actor"))?;
|
|
|
|
let profile = create_profile(db_client, &profile_data).await?;
|
|
|
|
profile
|
|
|
|
},
|
|
|
|
Err(other_error) => return Err(other_error.into()),
|
|
|
|
};
|
|
|
|
Ok(profile)
|
|
|
|
}
|
|
|
|
|
2021-11-07 16:48:47 +00:00
|
|
|
pub async fn process_note(
|
|
|
|
config: &Config,
|
|
|
|
db_client: &mut impl GenericClient,
|
2021-12-05 22:10:35 +00:00
|
|
|
object_id: String,
|
|
|
|
object_received: Option<Object>,
|
2021-11-07 21:07:38 +00:00
|
|
|
) -> Result<Post, HttpError> {
|
2021-11-18 14:37:48 +00:00
|
|
|
let instance = config.instance();
|
2021-12-05 22:10:35 +00:00
|
|
|
let mut maybe_object_id_to_fetch = Some(object_id);
|
|
|
|
let mut maybe_object = object_received;
|
|
|
|
let mut objects = vec![];
|
2021-11-07 21:07:38 +00:00
|
|
|
let mut posts = vec![];
|
|
|
|
|
2021-11-07 16:48:47 +00:00
|
|
|
// Fetch ancestors by going through inReplyTo references
|
|
|
|
// TODO: fetch replies too
|
2021-11-13 17:37:31 +00:00
|
|
|
#[allow(clippy::while_let_loop)]
|
2021-11-07 16:48:47 +00:00
|
|
|
loop {
|
2021-12-05 22:10:35 +00:00
|
|
|
let object_id = match maybe_object_id_to_fetch {
|
|
|
|
Some(object_id) => {
|
|
|
|
if parse_object_id(&instance.url(), &object_id).is_ok() {
|
|
|
|
// Object is a local post
|
|
|
|
assert!(objects.len() > 0);
|
2021-11-07 16:48:47 +00:00
|
|
|
break;
|
|
|
|
}
|
2021-12-05 22:10:35 +00:00
|
|
|
match get_post_by_object_id(db_client, &object_id).await {
|
|
|
|
Ok(post) => {
|
|
|
|
// Object already fetched
|
|
|
|
if objects.len() == 0 {
|
|
|
|
// Return post corresponding to initial object ID
|
|
|
|
return Ok(post);
|
|
|
|
};
|
2021-11-07 16:48:47 +00:00
|
|
|
break;
|
|
|
|
},
|
|
|
|
Err(DatabaseError::NotFound(_)) => (),
|
|
|
|
Err(other_error) => return Err(other_error.into()),
|
|
|
|
};
|
2021-12-05 22:10:35 +00:00
|
|
|
object_id
|
2021-11-07 16:48:47 +00:00
|
|
|
},
|
|
|
|
None => {
|
2021-12-05 22:10:35 +00:00
|
|
|
// No object to fetch
|
2021-11-07 16:48:47 +00:00
|
|
|
break;
|
|
|
|
},
|
|
|
|
};
|
2021-12-05 22:10:35 +00:00
|
|
|
let object = match maybe_object {
|
|
|
|
Some(object) => object,
|
|
|
|
None => {
|
|
|
|
let object = fetch_object(&instance, &object_id).await
|
|
|
|
.map_err(|_| ValidationError("failed to fetch object"))?;
|
|
|
|
log::info!("fetched object {}", object.id);
|
|
|
|
object
|
|
|
|
},
|
|
|
|
};
|
|
|
|
if object.id != object_id {
|
|
|
|
// ID of fetched object doesn't match requested ID
|
|
|
|
maybe_object_id_to_fetch = Some(object.id.clone());
|
|
|
|
// Don't re-fetch object
|
|
|
|
maybe_object = Some(object);
|
|
|
|
} else {
|
|
|
|
maybe_object_id_to_fetch = object.in_reply_to.clone();
|
|
|
|
maybe_object = None;
|
|
|
|
objects.push(object);
|
|
|
|
};
|
2021-11-07 16:48:47 +00:00
|
|
|
}
|
2021-12-05 22:10:35 +00:00
|
|
|
let initial_object_id = objects[0].id.clone();
|
2021-11-07 21:07:38 +00:00
|
|
|
|
2021-11-07 16:48:47 +00:00
|
|
|
// Objects are ordered according to their place in reply tree,
|
|
|
|
// starting with the root
|
|
|
|
objects.reverse();
|
|
|
|
for object in objects {
|
|
|
|
let attributed_to = object.attributed_to
|
|
|
|
.ok_or(ValidationError("unattributed note"))?;
|
|
|
|
let author = get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client,
|
2021-11-18 14:37:48 +00:00
|
|
|
&instance,
|
2021-11-07 16:48:47 +00:00
|
|
|
&attributed_to,
|
|
|
|
&config.media_dir(),
|
|
|
|
).await?;
|
|
|
|
let content = object.content
|
|
|
|
.ok_or(ValidationError("no content"))?;
|
|
|
|
let mut attachments: Vec<Uuid> = Vec::new();
|
|
|
|
if let Some(list) = object.attachment {
|
|
|
|
let mut downloaded: Vec<(String, String)> = Vec::new();
|
|
|
|
let output_dir = config.media_dir();
|
|
|
|
for attachment in list {
|
|
|
|
let file_name = fetch_attachment(&attachment.url, &output_dir).await
|
|
|
|
.map_err(|_| ValidationError("failed to fetch attachment"))?;
|
|
|
|
log::info!("downloaded attachment {}", attachment.url);
|
|
|
|
downloaded.push((file_name, attachment.media_type));
|
|
|
|
}
|
|
|
|
for (file_name, media_type) in downloaded {
|
|
|
|
let db_attachment = create_attachment(
|
|
|
|
db_client,
|
|
|
|
&author.id,
|
|
|
|
Some(media_type),
|
|
|
|
file_name,
|
|
|
|
).await?;
|
|
|
|
attachments.push(db_attachment.id);
|
|
|
|
}
|
|
|
|
}
|
2021-11-11 21:51:47 +00:00
|
|
|
let mut mentions: Vec<Uuid> = Vec::new();
|
2021-12-07 23:28:58 +00:00
|
|
|
let mut tags = vec![];
|
2021-11-11 21:51:47 +00:00
|
|
|
if let Some(list) = object.tag {
|
|
|
|
for tag in list {
|
2021-12-07 23:28:58 +00:00
|
|
|
if tag.tag_type == HASHTAG {
|
|
|
|
// Ignore invalid tags
|
|
|
|
if let Ok(tag_name) = normalize_tag(&tag.name) {
|
|
|
|
tags.push(tag_name);
|
|
|
|
};
|
|
|
|
} else if tag.tag_type == MENTION {
|
2021-12-08 00:03:12 +00:00
|
|
|
if let Some(href) = tag.href {
|
|
|
|
let profile = get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client,
|
|
|
|
&instance,
|
|
|
|
&href,
|
|
|
|
&config.media_dir(),
|
|
|
|
).await?;
|
|
|
|
if !mentions.contains(&profile.id) {
|
|
|
|
mentions.push(profile.id);
|
|
|
|
};
|
|
|
|
};
|
2021-11-11 21:51:47 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2021-11-07 16:48:47 +00:00
|
|
|
let in_reply_to_id = match object.in_reply_to {
|
|
|
|
Some(object_id) => {
|
2021-11-18 14:37:48 +00:00
|
|
|
match parse_object_id(&instance.url(), &object_id) {
|
2021-11-07 16:48:47 +00:00
|
|
|
Ok(post_id) => {
|
|
|
|
// Local post
|
|
|
|
let post = get_post_by_id(db_client, &post_id).await?;
|
|
|
|
Some(post.id)
|
|
|
|
},
|
|
|
|
Err(_) => {
|
|
|
|
let post = get_post_by_object_id(db_client, &object_id).await?;
|
|
|
|
Some(post.id)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => None,
|
|
|
|
};
|
2021-11-18 23:24:13 +00:00
|
|
|
let visibility = match object.to {
|
|
|
|
Some(value) => {
|
|
|
|
let recipients = parse_array(&value)?;
|
|
|
|
if recipients.len() == 1 &&
|
|
|
|
parse_actor_id(&instance.url(), &recipients[0]).is_ok()
|
|
|
|
{
|
|
|
|
// Single local recipient
|
|
|
|
Visibility::Direct
|
|
|
|
} else {
|
|
|
|
Visibility::Public
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => Visibility::Public,
|
|
|
|
};
|
2021-11-07 16:48:47 +00:00
|
|
|
let post_data = PostCreateData {
|
|
|
|
content,
|
|
|
|
in_reply_to_id,
|
2021-11-24 16:39:30 +00:00
|
|
|
repost_of_id: None,
|
2021-11-18 23:24:13 +00:00
|
|
|
visibility,
|
2021-11-07 16:48:47 +00:00
|
|
|
attachments: attachments,
|
2021-11-11 21:51:47 +00:00
|
|
|
mentions: mentions,
|
2021-12-07 23:28:58 +00:00
|
|
|
tags: tags,
|
2021-11-07 16:48:47 +00:00
|
|
|
object_id: Some(object.id),
|
|
|
|
created_at: object.published,
|
|
|
|
};
|
2021-11-07 21:07:38 +00:00
|
|
|
let post = create_post(db_client, &author.id, post_data).await?;
|
|
|
|
posts.push(post);
|
2021-11-07 16:48:47 +00:00
|
|
|
}
|
2021-11-07 21:07:38 +00:00
|
|
|
|
|
|
|
let initial_post = posts.into_iter()
|
|
|
|
.find(|post| post.object_id.as_ref() == Some(&initial_object_id))
|
|
|
|
.unwrap();
|
|
|
|
Ok(initial_post)
|
2021-11-07 16:48:47 +00:00
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
pub async fn receive_activity(
|
|
|
|
config: &Config,
|
|
|
|
db_pool: &Pool,
|
|
|
|
activity_raw: Value,
|
|
|
|
) -> Result<(), HttpError> {
|
|
|
|
let activity: Activity = serde_json::from_value(activity_raw)
|
|
|
|
.map_err(|_| ValidationError("invalid activity"))?;
|
|
|
|
let activity_type = activity.activity_type;
|
|
|
|
let object_type = activity.object.get("type")
|
|
|
|
.and_then(|val| val.as_str())
|
|
|
|
.unwrap_or("Unknown")
|
|
|
|
.to_owned();
|
2021-11-13 17:37:31 +00:00
|
|
|
let db_client = &mut **get_database_client(db_pool).await?;
|
2021-04-09 00:22:17 +00:00
|
|
|
match (activity_type.as_str(), object_type.as_str()) {
|
|
|
|
(ACCEPT, FOLLOW) => {
|
2021-11-29 20:45:36 +00:00
|
|
|
let object_id = get_object_id(activity.object)?;
|
|
|
|
let follow_request_id = parse_object_id(&config.instance_url(), &object_id)?;
|
2021-09-20 21:06:48 +00:00
|
|
|
follow_request_accepted(db_client, &follow_request_id).await?;
|
|
|
|
},
|
|
|
|
(REJECT, FOLLOW) => {
|
2021-11-29 20:45:36 +00:00
|
|
|
let object_id = get_object_id(activity.object)?;
|
|
|
|
let follow_request_id = parse_object_id(&config.instance_url(), &object_id)?;
|
2021-09-20 21:06:48 +00:00
|
|
|
follow_request_rejected(db_client, &follow_request_id).await?;
|
2021-04-09 00:22:17 +00:00
|
|
|
},
|
|
|
|
(CREATE, NOTE) => {
|
|
|
|
let object: Object = serde_json::from_value(activity.object)
|
|
|
|
.map_err(|_| ValidationError("invalid object"))?;
|
2021-12-05 22:10:35 +00:00
|
|
|
process_note(config, db_client, object.id.clone(), Some(object)).await?;
|
2021-04-09 00:22:17 +00:00
|
|
|
},
|
2021-11-25 21:28:06 +00:00
|
|
|
(ANNOUNCE, _) => {
|
2021-12-11 21:21:52 +00:00
|
|
|
let repost_object_id = activity.id;
|
|
|
|
match get_post_by_object_id(db_client, &repost_object_id).await {
|
|
|
|
Ok(_) => return Ok(()), // Ignore if repost already exists
|
|
|
|
Err(DatabaseError::NotFound(_)) => (),
|
|
|
|
Err(other_error) => return Err(other_error.into()),
|
|
|
|
};
|
2021-11-25 21:28:06 +00:00
|
|
|
let author = get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client,
|
|
|
|
&config.instance(),
|
|
|
|
&activity.actor,
|
|
|
|
&config.media_dir(),
|
|
|
|
).await?;
|
2021-11-29 20:45:36 +00:00
|
|
|
let object_id = get_object_id(activity.object)?;
|
2021-11-25 21:28:06 +00:00
|
|
|
let post_id = match parse_object_id(&config.instance_url(), &object_id) {
|
|
|
|
Ok(post_id) => post_id,
|
|
|
|
Err(_) => {
|
2021-12-06 15:28:41 +00:00
|
|
|
// Try to get remote post
|
2021-12-07 11:45:13 +00:00
|
|
|
let post = process_note(config, db_client, object_id, None).await?;
|
2021-11-25 21:28:06 +00:00
|
|
|
post.id
|
|
|
|
},
|
|
|
|
};
|
|
|
|
let repost_data = PostCreateData {
|
|
|
|
repost_of_id: Some(post_id),
|
2021-12-11 21:21:52 +00:00
|
|
|
object_id: Some(repost_object_id),
|
2021-11-25 21:28:06 +00:00
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
create_post(db_client, &author.id, repost_data).await?;
|
|
|
|
},
|
2021-11-19 00:05:39 +00:00
|
|
|
(DELETE, _) => {
|
2021-11-29 20:45:36 +00:00
|
|
|
let object_id = get_object_id(activity.object)?;
|
2021-11-19 00:05:39 +00:00
|
|
|
let post = get_post_by_object_id(db_client, &object_id).await?;
|
2021-11-12 14:51:03 +00:00
|
|
|
let deletion_queue = delete_post(db_client, &post.id).await?;
|
|
|
|
let config = config.clone();
|
|
|
|
actix_rt::spawn(async move {
|
|
|
|
deletion_queue.process(&config).await;
|
|
|
|
});
|
|
|
|
},
|
2021-11-30 20:06:13 +00:00
|
|
|
(LIKE, _) | (EMOJI_REACT, _) => {
|
2021-10-29 19:21:26 +00:00
|
|
|
let author = get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client,
|
2021-11-15 19:25:43 +00:00
|
|
|
&config.instance(),
|
2021-10-29 19:21:26 +00:00
|
|
|
&activity.actor,
|
|
|
|
&config.media_dir(),
|
|
|
|
).await?;
|
2021-11-29 20:45:36 +00:00
|
|
|
let object_id = get_object_id(activity.object)?;
|
2021-11-14 22:57:18 +00:00
|
|
|
let post_id = match parse_object_id(&config.instance_url(), &object_id) {
|
|
|
|
Ok(post_id) => post_id,
|
|
|
|
Err(_) => {
|
|
|
|
let post = match get_post_by_object_id(db_client, &object_id).await {
|
|
|
|
Ok(post) => post,
|
|
|
|
// Ignore like if post is not found locally
|
|
|
|
Err(DatabaseError::NotFound(_)) => return Ok(()),
|
|
|
|
Err(other_error) => return Err(other_error.into()),
|
|
|
|
};
|
|
|
|
post.id
|
|
|
|
},
|
|
|
|
};
|
2021-12-14 22:59:15 +00:00
|
|
|
create_reaction(
|
|
|
|
db_client,
|
|
|
|
&author.id,
|
|
|
|
&post_id,
|
|
|
|
Some(&activity.id),
|
|
|
|
).await?;
|
2021-10-29 19:21:26 +00:00
|
|
|
},
|
2021-04-09 00:22:17 +00:00
|
|
|
(FOLLOW, _) => {
|
2021-10-09 22:58:21 +00:00
|
|
|
let source_profile = get_or_fetch_profile_by_actor_id(
|
|
|
|
db_client,
|
2021-11-15 19:25:43 +00:00
|
|
|
&config.instance(),
|
2021-10-09 22:58:21 +00:00
|
|
|
&activity.actor,
|
|
|
|
&config.media_dir(),
|
|
|
|
).await?;
|
2021-11-12 23:41:03 +00:00
|
|
|
let source_actor = source_profile.remote_actor().ok().flatten()
|
2021-10-31 20:46:29 +00:00
|
|
|
.ok_or(HttpError::InternalError)?;
|
2021-11-29 20:45:36 +00:00
|
|
|
let target_actor_id = get_object_id(activity.object)?;
|
2021-09-20 21:45:33 +00:00
|
|
|
let target_username = parse_actor_id(&config.instance_url(), &target_actor_id)?;
|
2021-04-09 00:22:17 +00:00
|
|
|
let target_profile = get_profile_by_acct(db_client, &target_username).await?;
|
|
|
|
// Create and send 'Accept' activity
|
|
|
|
let target_user = get_user_by_id(db_client, &target_profile.id).await?;
|
2021-10-09 12:53:53 +00:00
|
|
|
let new_activity = create_activity_accept_follow(
|
|
|
|
&config.instance_url(),
|
|
|
|
&target_profile,
|
|
|
|
&activity.id,
|
2021-11-18 21:28:50 +00:00
|
|
|
&source_actor.id,
|
2021-10-09 12:53:53 +00:00
|
|
|
);
|
2021-04-09 00:22:17 +00:00
|
|
|
// Save relationship
|
|
|
|
follow(db_client, &source_profile.id, &target_profile.id).await?;
|
|
|
|
|
|
|
|
// Send activity
|
|
|
|
let recipients = vec![source_actor];
|
2021-11-13 17:37:31 +00:00
|
|
|
deliver_activity(config, &target_user, new_activity, recipients);
|
2021-04-09 00:22:17 +00:00
|
|
|
},
|
|
|
|
(UNDO, FOLLOW) => {
|
|
|
|
let object: Object = serde_json::from_value(activity.object)
|
|
|
|
.map_err(|_| ValidationError("invalid object"))?;
|
|
|
|
let source_profile = get_profile_by_actor_id(db_client, &activity.actor).await?;
|
|
|
|
let target_actor_id = object.object
|
|
|
|
.ok_or(ValidationError("invalid object"))?;
|
2021-09-20 21:45:33 +00:00
|
|
|
let target_username = parse_actor_id(&config.instance_url(), &target_actor_id)?;
|
2021-04-09 00:22:17 +00:00
|
|
|
let target_profile = get_profile_by_acct(db_client, &target_username).await?;
|
|
|
|
unfollow(db_client, &source_profile.id, &target_profile.id).await?;
|
|
|
|
},
|
2021-12-15 01:00:42 +00:00
|
|
|
(UNDO, _) => {
|
|
|
|
let object_id = get_object_id(activity.object)?;
|
2021-12-16 17:32:49 +00:00
|
|
|
match get_reaction_by_activity_id(db_client, &object_id).await {
|
|
|
|
Ok(reaction) => {
|
|
|
|
// Undo(Like)
|
|
|
|
delete_reaction(
|
|
|
|
db_client,
|
|
|
|
&reaction.author_id,
|
|
|
|
&reaction.post_id,
|
|
|
|
).await?;
|
|
|
|
},
|
|
|
|
Err(DatabaseError::NotFound(_)) => {
|
|
|
|
// Undo(Announce)
|
|
|
|
let post = get_post_by_object_id(db_client, &object_id).await?;
|
|
|
|
match post.repost_of_id {
|
|
|
|
Some(_) => delete_post(db_client, &post.id).await?,
|
|
|
|
None => return Err(HttpError::NotFoundError("object")),
|
|
|
|
};
|
|
|
|
},
|
|
|
|
Err(other_error) => return Err(other_error.into()),
|
|
|
|
};
|
2021-12-15 01:00:42 +00:00
|
|
|
},
|
2021-04-09 00:22:17 +00:00
|
|
|
(UPDATE, PERSON) => {
|
|
|
|
let actor: Actor = serde_json::from_value(activity.object)
|
|
|
|
.map_err(|_| ValidationError("invalid actor data"))?;
|
|
|
|
let profile = get_profile_by_actor_id(db_client, &actor.id).await?;
|
|
|
|
let (avatar, banner) = fetch_avatar_and_banner(&actor, &config.media_dir()).await
|
|
|
|
.map_err(|_| ValidationError("failed to fetch image"))?;
|
2021-09-17 12:36:24 +00:00
|
|
|
let extra_fields = actor.extra_fields();
|
2021-04-09 00:22:17 +00:00
|
|
|
let mut profile_data = ProfileUpdateData {
|
|
|
|
display_name: Some(actor.name),
|
|
|
|
bio: actor.summary.clone(),
|
|
|
|
bio_source: actor.summary,
|
|
|
|
avatar,
|
|
|
|
banner,
|
2021-09-17 12:36:24 +00:00
|
|
|
extra_fields,
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
profile_data.clean()?;
|
|
|
|
update_profile(db_client, &profile.id, profile_data).await?;
|
|
|
|
},
|
|
|
|
_ => {
|
|
|
|
return Err(HttpError::ValidationError("activity type is not supported".into()));
|
|
|
|
},
|
|
|
|
};
|
|
|
|
log::info!(
|
|
|
|
"processed {}({}) from {}",
|
|
|
|
activity_type,
|
|
|
|
object_type,
|
|
|
|
activity.actor,
|
|
|
|
);
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2021-11-18 23:24:13 +00:00
|
|
|
use serde_json::json;
|
2021-12-01 23:26:59 +00:00
|
|
|
use crate::utils::id::new_uuid;
|
2021-04-09 00:22:17 +00:00
|
|
|
use super::*;
|
|
|
|
|
2021-09-20 21:45:33 +00:00
|
|
|
const INSTANCE_URL: &str = "https://example.org";
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[test]
|
|
|
|
fn test_parse_actor_id() {
|
2021-09-20 21:45:33 +00:00
|
|
|
let username = parse_actor_id(INSTANCE_URL, "https://example.org/users/test").unwrap();
|
2021-04-09 00:22:17 +00:00
|
|
|
assert_eq!(username, "test".to_string());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_actor_id_wrong_path() {
|
2021-09-20 21:45:33 +00:00
|
|
|
let error = parse_actor_id(INSTANCE_URL, "https://example.org/user/test").unwrap_err();
|
2021-04-09 00:22:17 +00:00
|
|
|
assert_eq!(error.to_string(), "invalid actor ID");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_actor_id_invalid_username() {
|
2021-09-20 21:45:33 +00:00
|
|
|
let error = parse_actor_id(INSTANCE_URL, "https://example.org/users/tes-t").unwrap_err();
|
|
|
|
assert_eq!(error.to_string(), "invalid actor ID");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_actor_id_invalid_instance_url() {
|
|
|
|
let error = parse_actor_id(INSTANCE_URL, "https://example.gov/users/test").unwrap_err();
|
2021-04-09 00:22:17 +00:00
|
|
|
assert_eq!(error.to_string(), "invalid actor ID");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_object_id() {
|
2021-12-01 23:26:59 +00:00
|
|
|
let expected_uuid = new_uuid();
|
2021-04-09 00:22:17 +00:00
|
|
|
let object_id = format!(
|
|
|
|
"https://example.org/objects/{}",
|
|
|
|
expected_uuid,
|
|
|
|
);
|
2021-11-29 20:45:36 +00:00
|
|
|
let internal_object_id = parse_object_id(INSTANCE_URL, &object_id).unwrap();
|
|
|
|
assert_eq!(internal_object_id, expected_uuid);
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_object_id_invalid_uuid() {
|
2021-09-20 21:45:33 +00:00
|
|
|
let object_id = "https://example.org/objects/1234";
|
|
|
|
let error = parse_object_id(INSTANCE_URL, object_id).unwrap_err();
|
2021-04-09 00:22:17 +00:00
|
|
|
assert_eq!(error.to_string(), "invalid object ID");
|
|
|
|
}
|
2021-11-18 23:24:13 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_array_with_string() {
|
|
|
|
let value = json!("test");
|
|
|
|
assert_eq!(
|
|
|
|
parse_array(&value).unwrap(),
|
|
|
|
vec!["test".to_string()],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_array_with_array() {
|
|
|
|
let value = json!(["test1", "test2"]);
|
|
|
|
assert_eq!(
|
|
|
|
parse_array(&value).unwrap(),
|
|
|
|
vec!["test1".to_string(), "test2".to_string()],
|
|
|
|
);
|
|
|
|
}
|
2021-11-29 20:45:36 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_object_id_from_string() {
|
|
|
|
let value = json!("test_id");
|
|
|
|
assert_eq!(get_object_id(value).unwrap(), "test_id");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_object_id_from_object() {
|
|
|
|
let value = json!({"id": "test_id", "type": "Note"});
|
|
|
|
assert_eq!(get_object_id(value).unwrap(), "test_id");
|
|
|
|
}
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|