2021-04-09 00:22:17 +00:00
|
|
|
use chrono::{DateTime, Utc};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use serde_json::{json, Value};
|
|
|
|
use uuid::Uuid;
|
|
|
|
|
2021-12-12 19:11:04 +00:00
|
|
|
use crate::frontend::get_tag_page_url;
|
2022-01-07 22:28:23 +00:00
|
|
|
use crate::models::posts::types::{Post, Visibility};
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::models::profiles::types::DbActorProfile;
|
2021-11-12 21:33:19 +00:00
|
|
|
use crate::models::users::types::User;
|
2021-04-09 00:22:17 +00:00
|
|
|
use crate::utils::files::get_file_url;
|
2021-12-01 23:26:59 +00:00
|
|
|
use crate::utils::id::new_uuid;
|
2021-11-12 21:33:19 +00:00
|
|
|
use super::actor::{get_local_actor, ActorKeyError};
|
2021-04-09 00:22:17 +00:00
|
|
|
use super::constants::{AP_CONTEXT, AP_PUBLIC};
|
2022-01-15 23:21:13 +00:00
|
|
|
use super::views::{
|
|
|
|
get_actor_url,
|
|
|
|
get_followers_url,
|
|
|
|
get_subscribers_url,
|
|
|
|
get_object_url,
|
|
|
|
};
|
2021-04-09 00:22:17 +00:00
|
|
|
use super::vocabulary::*;
|
|
|
|
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct Attachment {
|
2021-11-18 16:50:42 +00:00
|
|
|
pub name: Option<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
|
|
|
|
#[serde(rename = "type")]
|
|
|
|
pub attachment_type: String,
|
|
|
|
|
2021-12-29 13:57:57 +00:00
|
|
|
pub media_type: Option<String>,
|
2022-01-08 21:16:12 +00:00
|
|
|
pub url: Option<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
2022-02-15 23:14:39 +00:00
|
|
|
fn default_tag_type() -> String { HASHTAG.to_string() }
|
|
|
|
|
2021-11-11 21:51:47 +00:00
|
|
|
#[derive(Deserialize, Serialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct Tag {
|
2022-04-27 09:53:52 +00:00
|
|
|
pub name: Option<String>,
|
2021-11-11 21:51:47 +00:00
|
|
|
|
2022-02-15 23:14:39 +00:00
|
|
|
#[serde(rename = "type", default = "default_tag_type")]
|
2021-11-11 21:51:47 +00:00
|
|
|
pub tag_type: String,
|
|
|
|
|
2021-11-24 19:00:36 +00:00
|
|
|
pub href: Option<String>,
|
2021-11-11 21:51:47 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 16:33:50 +00:00
|
|
|
#[derive(Default, Deserialize, Serialize)]
|
2021-04-09 00:22:17 +00:00
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct Object {
|
|
|
|
#[serde(rename = "@context")]
|
|
|
|
pub context: Option<Value>,
|
|
|
|
|
|
|
|
pub id: String,
|
|
|
|
|
|
|
|
#[serde(rename = "type")]
|
|
|
|
pub object_type: String,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
2022-04-29 13:15:16 +00:00
|
|
|
pub name: Option<String>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
2021-04-09 00:22:17 +00:00
|
|
|
pub actor: Option<String>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
2022-04-13 22:30:41 +00:00
|
|
|
pub attachment: Option<Value>,
|
2021-04-09 00:22:17 +00:00
|
|
|
|
2022-01-04 20:52:41 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub cc: Option<Value>,
|
|
|
|
|
2021-12-18 23:20:25 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub former_type: Option<String>,
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub object: Option<String>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub published: Option<DateTime<Utc>>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
2021-12-24 15:13:25 +00:00
|
|
|
pub attributed_to: Option<Value>,
|
2021-04-09 00:22:17 +00:00
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub in_reply_to: Option<String>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub content: Option<String>,
|
|
|
|
|
2021-11-11 21:51:47 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub tag: Option<Vec<Tag>>,
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub to: Option<Value>,
|
|
|
|
}
|
|
|
|
|
2021-12-05 16:25:28 +00:00
|
|
|
#[derive(Serialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct Note {
|
|
|
|
#[serde(rename = "@context")]
|
|
|
|
context: String,
|
|
|
|
|
|
|
|
id: String,
|
|
|
|
|
|
|
|
#[serde(rename = "type")]
|
|
|
|
object_type: String,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
|
|
attachment: Vec<Attachment>,
|
|
|
|
|
|
|
|
attributed_to: String,
|
|
|
|
|
|
|
|
content: String,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
in_reply_to: Option<String>,
|
|
|
|
|
|
|
|
published: DateTime<Utc>,
|
|
|
|
|
|
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
|
|
tag: Vec<Tag>,
|
|
|
|
|
|
|
|
to: Vec<String>,
|
2022-01-04 20:52:41 +00:00
|
|
|
cc: Vec<String>,
|
2021-12-05 16:25:28 +00:00
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[derive(Deserialize, Serialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct Activity {
|
|
|
|
#[serde(rename = "@context")]
|
|
|
|
pub context: Value,
|
|
|
|
|
|
|
|
pub id: String,
|
|
|
|
|
|
|
|
#[serde(rename = "type")]
|
|
|
|
pub activity_type: String,
|
|
|
|
|
|
|
|
pub actor: String,
|
|
|
|
pub object: Value,
|
2021-11-20 21:15:56 +00:00
|
|
|
pub to: Option<Value>,
|
2022-01-04 20:52:41 +00:00
|
|
|
pub cc: Option<Value>,
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn create_activity(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_name: &str,
|
|
|
|
activity_type: &str,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id: String,
|
2021-11-12 21:33:19 +00:00
|
|
|
object: impl Serialize,
|
2022-01-04 20:52:41 +00:00
|
|
|
primary_audience: Vec<String>,
|
|
|
|
secondary_audience: Vec<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Activity {
|
|
|
|
let actor_id = get_actor_url(
|
|
|
|
instance_url,
|
2021-11-13 17:37:31 +00:00
|
|
|
actor_name,
|
2021-04-09 00:22:17 +00:00
|
|
|
);
|
2021-11-13 17:37:31 +00:00
|
|
|
Activity {
|
2021-04-09 00:22:17 +00:00
|
|
|
context: json!(AP_CONTEXT),
|
|
|
|
id: activity_id,
|
|
|
|
activity_type: activity_type.to_string(),
|
|
|
|
actor: actor_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
object: serde_json::to_value(object).unwrap(),
|
2022-01-04 20:52:41 +00:00
|
|
|
to: Some(json!(primary_audience)),
|
|
|
|
cc: Some(json!(secondary_audience)),
|
2021-11-13 17:37:31 +00:00
|
|
|
}
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
2021-10-08 13:56:45 +00:00
|
|
|
pub fn create_note(
|
2021-11-11 21:51:47 +00:00
|
|
|
instance_host: &str,
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
post: &Post,
|
2021-12-05 16:25:28 +00:00
|
|
|
) -> Note {
|
2021-04-09 00:22:17 +00:00
|
|
|
let object_id = get_object_url(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&post.id,
|
|
|
|
);
|
|
|
|
let actor_id = get_actor_url(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&post.author.username,
|
|
|
|
);
|
|
|
|
let attachments: Vec<Attachment> = post.attachments.iter().map(|db_item| {
|
2021-10-09 12:53:53 +00:00
|
|
|
let url = get_file_url(instance_url, &db_item.file_name);
|
2021-12-29 13:57:57 +00:00
|
|
|
let media_type = db_item.media_type.clone();
|
2021-04-09 00:22:17 +00:00
|
|
|
Attachment {
|
2021-11-18 16:50:42 +00:00
|
|
|
name: None,
|
2021-04-09 00:22:17 +00:00
|
|
|
attachment_type: DOCUMENT.to_string(),
|
|
|
|
media_type,
|
2022-01-08 21:16:12 +00:00
|
|
|
url: Some(url),
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
}).collect();
|
2022-01-07 22:28:23 +00:00
|
|
|
let mut primary_audience = vec![];
|
|
|
|
let mut secondary_audience = vec![];
|
2022-01-05 18:47:02 +00:00
|
|
|
let followers_collection_url =
|
|
|
|
get_followers_url(instance_url, &post.author.username);
|
2022-01-15 23:21:13 +00:00
|
|
|
let subscribers_collection_url =
|
|
|
|
get_subscribers_url(instance_url, &post.author.username);
|
|
|
|
match post.visibility {
|
|
|
|
Visibility::Public => {
|
|
|
|
primary_audience.push(AP_PUBLIC.to_string());
|
|
|
|
secondary_audience.push(followers_collection_url);
|
|
|
|
},
|
|
|
|
Visibility::Followers => {
|
|
|
|
primary_audience.push(followers_collection_url);
|
|
|
|
},
|
|
|
|
Visibility::Subscribers => {
|
|
|
|
primary_audience.push(subscribers_collection_url);
|
|
|
|
},
|
|
|
|
Visibility::Direct => (),
|
2022-01-07 22:28:23 +00:00
|
|
|
};
|
2022-01-15 23:21:13 +00:00
|
|
|
let mut tags = vec![];
|
2021-12-07 23:28:58 +00:00
|
|
|
for profile in &post.mentions {
|
2022-04-27 09:53:52 +00:00
|
|
|
let tag_name = format!("@{}", profile.actor_address(instance_host));
|
2021-12-31 15:29:44 +00:00
|
|
|
let actor_id = profile.actor_id(instance_url);
|
2022-04-27 09:53:52 +00:00
|
|
|
primary_audience.push(actor_id.clone());
|
2021-12-07 23:28:58 +00:00
|
|
|
let tag = Tag {
|
2022-04-27 09:53:52 +00:00
|
|
|
name: Some(tag_name),
|
2021-11-11 21:51:47 +00:00
|
|
|
tag_type: MENTION.to_string(),
|
2022-04-20 11:20:59 +00:00
|
|
|
href: Some(actor_id),
|
2021-12-07 23:28:58 +00:00
|
|
|
};
|
|
|
|
tags.push(tag);
|
|
|
|
};
|
|
|
|
for tag_name in &post.tags {
|
2021-12-12 19:11:04 +00:00
|
|
|
let tag_page_url = get_tag_page_url(instance_url, tag_name);
|
2021-12-07 23:28:58 +00:00
|
|
|
let tag = Tag {
|
2022-04-27 09:53:52 +00:00
|
|
|
name: Some(format!("#{}", tag_name)),
|
2021-12-07 23:28:58 +00:00
|
|
|
tag_type: HASHTAG.to_string(),
|
2021-12-12 19:11:04 +00:00
|
|
|
href: Some(tag_page_url),
|
2021-12-07 23:28:58 +00:00
|
|
|
};
|
|
|
|
tags.push(tag);
|
|
|
|
};
|
2021-10-08 13:56:45 +00:00
|
|
|
let in_reply_to_object_id = match post.in_reply_to_id {
|
|
|
|
Some(in_reply_to_id) => {
|
2022-01-04 20:52:41 +00:00
|
|
|
let in_reply_to = post.in_reply_to.as_ref().unwrap();
|
|
|
|
assert_eq!(in_reply_to.id, in_reply_to_id);
|
|
|
|
let in_reply_to_actor_id = in_reply_to.author.actor_id(instance_url);
|
|
|
|
if !primary_audience.contains(&in_reply_to_actor_id) {
|
|
|
|
primary_audience.push(in_reply_to_actor_id);
|
|
|
|
};
|
|
|
|
Some(in_reply_to.get_object_id(instance_url))
|
2021-10-08 13:56:45 +00:00
|
|
|
},
|
|
|
|
None => None,
|
|
|
|
};
|
2021-12-05 16:25:28 +00:00
|
|
|
Note {
|
|
|
|
context: AP_CONTEXT.to_string(),
|
2021-04-09 00:22:17 +00:00
|
|
|
id: object_id,
|
|
|
|
object_type: NOTE.to_string(),
|
2021-12-05 16:25:28 +00:00
|
|
|
attachment: attachments,
|
|
|
|
published: post.created_at,
|
|
|
|
attributed_to: actor_id,
|
2021-10-08 13:56:45 +00:00
|
|
|
in_reply_to: in_reply_to_object_id,
|
2021-12-05 16:25:28 +00:00
|
|
|
content: post.content.clone(),
|
2021-12-07 23:28:58 +00:00
|
|
|
tag: tags,
|
2022-01-04 20:52:41 +00:00
|
|
|
to: primary_audience,
|
|
|
|
cc: secondary_audience,
|
2021-10-08 13:56:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_activity_note(
|
2021-11-11 21:51:47 +00:00
|
|
|
instance_host: &str,
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url: &str,
|
2021-10-08 13:56:45 +00:00
|
|
|
post: &Post,
|
|
|
|
) -> Activity {
|
2021-12-31 17:15:00 +00:00
|
|
|
let object = create_note(instance_host, instance_url, post);
|
2022-01-04 20:52:41 +00:00
|
|
|
let primary_audience = object.to.clone();
|
|
|
|
let secondary_audience = object.cc.clone();
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, &post.id) + "/create";
|
2021-04-09 00:22:17 +00:00
|
|
|
let activity = create_activity(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&post.author.username,
|
|
|
|
CREATE,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
object,
|
2022-01-04 20:52:41 +00:00
|
|
|
primary_audience,
|
|
|
|
secondary_audience,
|
2021-04-09 00:22:17 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
2021-10-29 19:21:26 +00:00
|
|
|
pub fn create_activity_like(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_profile: &DbActorProfile,
|
2021-12-15 01:00:42 +00:00
|
|
|
note_id: &str,
|
|
|
|
reaction_id: &Uuid,
|
2021-12-25 00:05:17 +00:00
|
|
|
recipient_id: &str,
|
2021-10-29 19:21:26 +00:00
|
|
|
) -> Activity {
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, reaction_id);
|
2021-10-29 19:21:26 +00:00
|
|
|
let activity = create_activity(
|
|
|
|
instance_url,
|
|
|
|
&actor_profile.username,
|
|
|
|
LIKE,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-12-15 01:00:42 +00:00
|
|
|
note_id,
|
2021-12-25 00:05:17 +00:00
|
|
|
vec![AP_PUBLIC.to_string(), recipient_id.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-10-29 19:21:26 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
2021-12-15 01:00:42 +00:00
|
|
|
pub fn create_activity_undo_like(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_profile: &DbActorProfile,
|
|
|
|
reaction_id: &Uuid,
|
2021-12-25 00:05:17 +00:00
|
|
|
recipient_id: &str,
|
2021-12-15 01:00:42 +00:00
|
|
|
) -> Activity {
|
|
|
|
let object_id = get_object_url(
|
|
|
|
instance_url,
|
|
|
|
reaction_id,
|
|
|
|
);
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, reaction_id) + "/undo";
|
2021-12-15 01:00:42 +00:00
|
|
|
create_activity(
|
|
|
|
instance_url,
|
|
|
|
&actor_profile.username,
|
|
|
|
UNDO,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-12-15 01:00:42 +00:00
|
|
|
object_id,
|
2021-12-25 00:05:17 +00:00
|
|
|
vec![AP_PUBLIC.to_string(), recipient_id.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-12-15 01:00:42 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-11-25 21:28:06 +00:00
|
|
|
pub fn create_activity_announce(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_profile: &DbActorProfile,
|
2021-11-26 22:53:40 +00:00
|
|
|
post: &Post,
|
2021-12-16 17:32:49 +00:00
|
|
|
repost_id: &Uuid,
|
2021-11-25 21:28:06 +00:00
|
|
|
) -> Activity {
|
2021-11-26 22:53:40 +00:00
|
|
|
let object_id = post.get_object_id(instance_url);
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, repost_id);
|
2021-12-31 15:29:44 +00:00
|
|
|
let recipient_id = post.author.actor_id(instance_url);
|
2021-11-25 21:28:06 +00:00
|
|
|
let activity = create_activity(
|
|
|
|
instance_url,
|
|
|
|
&actor_profile.username,
|
|
|
|
ANNOUNCE,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-12-12 22:36:20 +00:00
|
|
|
object_id,
|
2021-12-25 00:05:17 +00:00
|
|
|
vec![AP_PUBLIC.to_string(), recipient_id],
|
2022-01-04 21:36:45 +00:00
|
|
|
vec![get_followers_url(instance_url, &actor_profile.username)],
|
2021-11-25 21:28:06 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
2021-12-16 17:32:49 +00:00
|
|
|
pub fn create_activity_undo_announce(
|
|
|
|
instance_url: &str,
|
|
|
|
actor_profile: &DbActorProfile,
|
|
|
|
repost_id: &Uuid,
|
2022-01-04 21:36:45 +00:00
|
|
|
recipient_id: &str,
|
2021-12-16 17:32:49 +00:00
|
|
|
) -> Activity {
|
|
|
|
let object_id = get_object_url(
|
|
|
|
instance_url,
|
|
|
|
repost_id,
|
|
|
|
);
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, repost_id) + "/undo";
|
2022-01-04 21:36:45 +00:00
|
|
|
let primary_audience = vec![
|
|
|
|
AP_PUBLIC.to_string(),
|
|
|
|
recipient_id.to_string(),
|
|
|
|
];
|
2021-12-16 17:32:49 +00:00
|
|
|
create_activity(
|
|
|
|
instance_url,
|
|
|
|
&actor_profile.username,
|
|
|
|
UNDO,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-12-16 17:32:49 +00:00
|
|
|
object_id,
|
2022-01-04 21:36:45 +00:00
|
|
|
primary_audience,
|
|
|
|
vec![get_followers_url(instance_url, &actor_profile.username)],
|
2021-12-16 17:32:49 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2021-12-04 00:42:36 +00:00
|
|
|
pub fn create_activity_delete_note(
|
|
|
|
instance_url: &str,
|
|
|
|
post: &Post,
|
|
|
|
) -> Activity {
|
|
|
|
let object_id = post.get_object_id(instance_url);
|
|
|
|
let object = Object {
|
|
|
|
context: Some(json!(AP_CONTEXT)),
|
|
|
|
id: object_id,
|
|
|
|
object_type: TOMBSTONE.to_string(),
|
2021-12-18 23:20:25 +00:00
|
|
|
former_type: Some(NOTE.to_string()),
|
2021-12-04 00:42:36 +00:00
|
|
|
..Default::default()
|
|
|
|
};
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, &post.id) + "/delete";
|
2021-12-04 00:42:36 +00:00
|
|
|
let activity = create_activity(
|
|
|
|
instance_url,
|
2022-01-04 21:50:18 +00:00
|
|
|
&post.author.username,
|
2021-12-04 00:42:36 +00:00
|
|
|
DELETE,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-12-04 00:42:36 +00:00
|
|
|
object,
|
2022-01-04 21:50:18 +00:00
|
|
|
vec![AP_PUBLIC.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-12-04 00:42:36 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
pub fn create_activity_follow(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
actor_profile: &DbActorProfile,
|
|
|
|
follow_request_id: &Uuid,
|
2021-10-29 16:33:50 +00:00
|
|
|
target_actor_id: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Activity {
|
|
|
|
let object = Object {
|
|
|
|
context: Some(json!(AP_CONTEXT)),
|
2021-10-29 16:33:50 +00:00
|
|
|
id: target_actor_id.to_owned(),
|
2021-04-09 00:22:17 +00:00
|
|
|
object_type: PERSON.to_string(),
|
2021-10-29 16:33:50 +00:00
|
|
|
..Default::default()
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = get_object_url(instance_url, follow_request_id);
|
2021-04-09 00:22:17 +00:00
|
|
|
let activity = create_activity(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&actor_profile.username,
|
|
|
|
FOLLOW,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
object,
|
2021-12-05 18:08:06 +00:00
|
|
|
vec![target_actor_id.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-04-09 00:22:17 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_activity_accept_follow(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
actor_profile: &DbActorProfile,
|
|
|
|
follow_activity_id: &str,
|
2021-11-18 21:28:50 +00:00
|
|
|
source_actor_id: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Activity {
|
|
|
|
let object = Object {
|
|
|
|
context: Some(json!(AP_CONTEXT)),
|
|
|
|
id: follow_activity_id.to_string(),
|
|
|
|
object_type: FOLLOW.to_string(),
|
2021-10-29 16:33:50 +00:00
|
|
|
..Default::default()
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = follow_activity_id.to_string() + "/accept";
|
2021-04-09 00:22:17 +00:00
|
|
|
let activity = create_activity(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&actor_profile.username,
|
|
|
|
ACCEPT,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
object,
|
2021-12-05 18:08:06 +00:00
|
|
|
vec![source_actor_id.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-04-09 00:22:17 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_activity_undo_follow(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
actor_profile: &DbActorProfile,
|
|
|
|
follow_request_id: &Uuid,
|
2021-10-29 16:33:50 +00:00
|
|
|
target_actor_id: &str,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Activity {
|
|
|
|
let follow_activity_id = get_object_url(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
follow_request_id,
|
|
|
|
);
|
|
|
|
let follow_actor_id = get_actor_url(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&actor_profile.username,
|
|
|
|
);
|
|
|
|
let object = Object {
|
|
|
|
context: Some(json!(AP_CONTEXT)),
|
2022-04-14 18:05:10 +00:00
|
|
|
id: follow_activity_id.clone(),
|
2021-04-09 00:22:17 +00:00
|
|
|
object_type: FOLLOW.to_string(),
|
|
|
|
actor: Some(follow_actor_id),
|
2021-10-29 16:33:50 +00:00
|
|
|
object: Some(target_actor_id.to_owned()),
|
|
|
|
..Default::default()
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
2022-04-14 18:05:10 +00:00
|
|
|
let activity_id = follow_activity_id + "/undo";
|
2021-04-09 00:22:17 +00:00
|
|
|
let activity = create_activity(
|
2021-10-09 12:53:53 +00:00
|
|
|
instance_url,
|
2021-04-09 00:22:17 +00:00
|
|
|
&actor_profile.username,
|
|
|
|
UNDO,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
object,
|
2021-12-05 18:08:06 +00:00
|
|
|
vec![target_actor_id.to_string()],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-04-09 00:22:17 +00:00
|
|
|
);
|
|
|
|
activity
|
|
|
|
}
|
|
|
|
|
2021-11-12 21:33:19 +00:00
|
|
|
pub fn create_activity_update_person(
|
|
|
|
user: &User,
|
|
|
|
instance_url: &str,
|
|
|
|
) -> Result<Activity, ActorKeyError> {
|
|
|
|
let actor = get_local_actor(user, instance_url)?;
|
2022-04-14 18:05:10 +00:00
|
|
|
// Update(Person) is idempotent so its ID can be random
|
|
|
|
let activity_id = get_object_url(instance_url, &new_uuid());
|
2021-11-12 21:33:19 +00:00
|
|
|
let activity = create_activity(
|
|
|
|
instance_url,
|
|
|
|
&user.profile.username,
|
|
|
|
UPDATE,
|
2022-04-14 18:05:10 +00:00
|
|
|
activity_id,
|
2021-11-12 21:33:19 +00:00
|
|
|
actor,
|
2022-01-04 21:54:41 +00:00
|
|
|
vec![
|
|
|
|
AP_PUBLIC.to_string(),
|
|
|
|
get_followers_url(instance_url, &user.profile.username),
|
|
|
|
],
|
2022-01-04 20:52:41 +00:00
|
|
|
vec![],
|
2021-11-12 21:33:19 +00:00
|
|
|
);
|
|
|
|
Ok(activity)
|
|
|
|
}
|
|
|
|
|
2021-10-09 12:53:53 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2021-12-31 15:29:44 +00:00
|
|
|
use crate::activitypub::actor::Actor;
|
2021-10-09 12:53:53 +00:00
|
|
|
use super::*;
|
|
|
|
|
2021-11-11 21:51:47 +00:00
|
|
|
const INSTANCE_HOST: &str = "example.com";
|
2021-10-09 12:53:53 +00:00
|
|
|
const INSTANCE_URL: &str = "https://example.com";
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_create_note() {
|
|
|
|
let author = DbActorProfile {
|
|
|
|
username: "author".to_string(),
|
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
let post = Post { author, ..Default::default() };
|
2021-12-31 17:15:00 +00:00
|
|
|
let note = create_note(INSTANCE_HOST, INSTANCE_URL, &post);
|
2021-10-09 12:53:53 +00:00
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
note.id,
|
|
|
|
format!("{}/objects/{}", INSTANCE_URL, post.id),
|
|
|
|
);
|
2021-12-05 16:25:28 +00:00
|
|
|
assert_eq!(note.attachment.len(), 0);
|
2021-10-09 12:53:53 +00:00
|
|
|
assert_eq!(
|
2021-12-05 16:25:28 +00:00
|
|
|
note.attributed_to,
|
2021-10-09 12:53:53 +00:00
|
|
|
format!("{}/users/{}", INSTANCE_URL, post.author.username),
|
|
|
|
);
|
|
|
|
assert_eq!(note.in_reply_to.is_none(), true);
|
2021-12-05 16:25:28 +00:00
|
|
|
assert_eq!(note.content, post.content);
|
2022-01-04 20:52:41 +00:00
|
|
|
assert_eq!(note.to, vec![AP_PUBLIC]);
|
|
|
|
assert_eq!(note.cc, vec![
|
|
|
|
get_followers_url(INSTANCE_URL, "author"),
|
|
|
|
]);
|
2021-10-09 12:53:53 +00:00
|
|
|
}
|
|
|
|
|
2022-01-05 18:47:02 +00:00
|
|
|
#[test]
|
|
|
|
fn test_create_note_followers_only() {
|
|
|
|
let post = Post {
|
|
|
|
visibility: Visibility::Followers,
|
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
let note = create_note(INSTANCE_HOST, INSTANCE_URL, &post);
|
|
|
|
|
|
|
|
assert_eq!(note.to, vec![
|
|
|
|
get_followers_url(INSTANCE_URL, &post.author.username),
|
|
|
|
]);
|
|
|
|
assert_eq!(note.cc.is_empty(), true);
|
|
|
|
}
|
|
|
|
|
2021-10-09 12:53:53 +00:00
|
|
|
#[test]
|
|
|
|
fn test_create_note_with_local_parent() {
|
|
|
|
let parent = Post::default();
|
|
|
|
let post = Post {
|
|
|
|
in_reply_to_id: Some(parent.id),
|
2021-12-31 17:15:00 +00:00
|
|
|
in_reply_to: Some(Box::new(parent.clone())),
|
2021-10-09 12:53:53 +00:00
|
|
|
..Default::default()
|
|
|
|
};
|
2021-12-31 17:15:00 +00:00
|
|
|
let note = create_note(INSTANCE_HOST, INSTANCE_URL, &post);
|
2021-10-09 12:53:53 +00:00
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
note.in_reply_to.unwrap(),
|
|
|
|
format!("{}/objects/{}", INSTANCE_URL, parent.id),
|
|
|
|
);
|
2022-01-04 20:52:41 +00:00
|
|
|
assert_eq!(note.to, vec![
|
|
|
|
AP_PUBLIC.to_string(),
|
|
|
|
get_actor_url(INSTANCE_URL, &parent.author.username),
|
|
|
|
]);
|
2021-10-09 12:53:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_create_note_with_remote_parent() {
|
2021-11-11 21:51:47 +00:00
|
|
|
let parent_author_acct = "test@test.net";
|
2021-11-01 00:23:02 +00:00
|
|
|
let parent_author_actor_id = "https://test.net/user/test";
|
2021-12-11 23:25:00 +00:00
|
|
|
let parent_author_actor_url = "https://test.net/@test";
|
2021-10-09 12:53:53 +00:00
|
|
|
let parent_author = DbActorProfile {
|
2021-11-11 21:51:47 +00:00
|
|
|
acct: parent_author_acct.to_string(),
|
2021-12-31 15:29:44 +00:00
|
|
|
actor_json: Some(Actor {
|
|
|
|
id: parent_author_actor_id.to_string(),
|
|
|
|
url: Some(parent_author_actor_url.to_string()),
|
|
|
|
..Default::default()
|
|
|
|
}),
|
2022-04-20 13:47:04 +00:00
|
|
|
actor_id: Some(parent_author_actor_id.to_string()),
|
2021-10-09 12:53:53 +00:00
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
let parent = Post {
|
2021-11-11 21:51:47 +00:00
|
|
|
author: parent_author.clone(),
|
2021-10-09 12:53:53 +00:00
|
|
|
object_id: Some("https://test.net/obj/123".to_string()),
|
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
let post = Post {
|
|
|
|
in_reply_to_id: Some(parent.id),
|
2021-12-31 17:15:00 +00:00
|
|
|
in_reply_to: Some(Box::new(parent.clone())),
|
2021-11-11 21:51:47 +00:00
|
|
|
mentions: vec![parent_author],
|
2021-10-09 12:53:53 +00:00
|
|
|
..Default::default()
|
|
|
|
};
|
2021-12-31 17:15:00 +00:00
|
|
|
let note = create_note(INSTANCE_HOST, INSTANCE_URL, &post);
|
2021-10-09 12:53:53 +00:00
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
note.in_reply_to.unwrap(),
|
|
|
|
parent.object_id.unwrap(),
|
|
|
|
);
|
2021-12-05 16:25:28 +00:00
|
|
|
let tags = note.tag;
|
2021-11-11 21:51:47 +00:00
|
|
|
assert_eq!(tags.len(), 1);
|
2022-04-27 09:53:52 +00:00
|
|
|
assert_eq!(tags[0].name.as_deref().unwrap(), format!("@{}", parent_author_acct));
|
2022-04-20 11:20:59 +00:00
|
|
|
assert_eq!(tags[0].href.as_ref().unwrap(), parent_author_actor_id);
|
2021-12-05 16:25:28 +00:00
|
|
|
assert_eq!(note.to, vec![AP_PUBLIC, parent_author_actor_id]);
|
2021-10-09 12:53:53 +00:00
|
|
|
}
|
2021-10-29 16:33:50 +00:00
|
|
|
|
2022-04-14 18:05:10 +00:00
|
|
|
#[test]
|
|
|
|
fn test_create_activity_create_note() {
|
|
|
|
let author_username = "author";
|
|
|
|
let author = DbActorProfile {
|
|
|
|
username: author_username.to_string(),
|
|
|
|
..Default::default()
|
|
|
|
};
|
|
|
|
let post = Post { author, ..Default::default() };
|
|
|
|
let activity = create_activity_note(INSTANCE_HOST, INSTANCE_URL, &post);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
activity.id,
|
|
|
|
format!("{}/objects/{}/create", INSTANCE_URL, post.id),
|
|
|
|
);
|
|
|
|
assert_eq!(activity.activity_type, CREATE);
|
|
|
|
assert_eq!(
|
|
|
|
activity.actor,
|
|
|
|
format!("{}/users/{}", INSTANCE_URL, author_username),
|
|
|
|
);
|
|
|
|
assert_eq!(activity.to.unwrap(), json!([AP_PUBLIC]));
|
|
|
|
}
|
|
|
|
|
2021-10-29 16:33:50 +00:00
|
|
|
#[test]
|
|
|
|
fn test_create_activity_follow() {
|
|
|
|
let follower = DbActorProfile {
|
|
|
|
username: "follower".to_string(),
|
|
|
|
..Default::default()
|
|
|
|
};
|
2021-12-01 23:26:59 +00:00
|
|
|
let follow_request_id = new_uuid();
|
2021-10-29 16:33:50 +00:00
|
|
|
let target_actor_id = "https://example.com/actor/test";
|
|
|
|
let activity = create_activity_follow(
|
|
|
|
INSTANCE_URL,
|
|
|
|
&follower,
|
|
|
|
&follow_request_id,
|
|
|
|
target_actor_id,
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
activity.id,
|
|
|
|
format!("{}/objects/{}", INSTANCE_URL, follow_request_id),
|
|
|
|
);
|
|
|
|
assert_eq!(activity.activity_type, "Follow");
|
|
|
|
assert_eq!(
|
|
|
|
activity.actor,
|
|
|
|
format!("{}/users/{}", INSTANCE_URL, follower.username),
|
|
|
|
);
|
|
|
|
assert_eq!(activity.object["id"], target_actor_id);
|
|
|
|
assert_eq!(activity.object["type"], "Person");
|
|
|
|
assert_eq!(activity.object["actor"], Value::Null);
|
|
|
|
assert_eq!(activity.object["object"], Value::Null);
|
|
|
|
assert_eq!(activity.object["content"], Value::Null);
|
2021-11-20 21:15:56 +00:00
|
|
|
assert_eq!(activity.to.unwrap(), json!([target_actor_id]));
|
2022-01-04 21:54:41 +00:00
|
|
|
assert_eq!(activity.cc.unwrap(), json!([]));
|
2021-10-29 16:33:50 +00:00
|
|
|
}
|
2021-10-09 12:53:53 +00:00
|
|
|
}
|