"background-jobs",
"base64 0.13.0",
"bcrypt",
- "captcha",
"chrono",
"diesel",
"futures",
"uuid",
]
+[[package]]
+name = "lemmy_apub_receive"
+version = "0.1.0"
+dependencies = [
+ "activitystreams",
+ "activitystreams-ext",
+ "actix",
+ "actix-rt",
+ "actix-web",
+ "anyhow",
+ "async-trait",
+ "awc",
+ "backtrace",
+ "base64 0.13.0",
+ "bcrypt",
+ "chrono",
+ "diesel",
+ "futures",
+ "http",
+ "http-signature-normalization-actix",
+ "http-signature-normalization-reqwest",
+ "itertools",
+ "lemmy_api_common",
+ "lemmy_apub",
+ "lemmy_db_queries",
+ "lemmy_db_schema",
+ "lemmy_db_views",
+ "lemmy_db_views_actor",
+ "lemmy_utils",
+ "lemmy_websocket",
+ "log",
+ "openssl",
+ "percent-encoding",
+ "rand 0.8.3",
+ "serde",
+ "serde_json",
+ "sha2",
+ "strum",
+ "strum_macros",
+ "thiserror",
+ "tokio 0.3.7",
+ "url",
+]
+
[[package]]
name = "lemmy_db_queries"
version = "0.1.0"
"lemmy_api_common",
"lemmy_api_crud",
"lemmy_apub",
+ "lemmy_apub_receive",
"lemmy_db_queries",
"lemmy_db_schema",
"lemmy_db_views",
"crates/api_crud",
"crates/api_common",
"crates/apub",
+ "crates/apub_receive",
"crates/utils",
"crates/db_queries",
"crates/db_schema",
lemmy_api = { path = "./crates/api" }
lemmy_api_crud = { path = "./crates/api_crud" }
lemmy_apub = { path = "./crates/apub" }
+lemmy_apub_receive = { path = "./crates/apub_receive" }
lemmy_utils = { path = "./crates/utils" }
lemmy_db_schema = { path = "./crates/db_schema" }
lemmy_db_queries = { path = "./crates/db_queries" }
uuid = { version = "0.8.2", features = ["serde", "v4"] }
sha2 = "0.9.3"
async-trait = "0.1.42"
-captcha = "0.0.8"
anyhow = "1.0.38"
thiserror = "1.0.23"
background-jobs = "0.8.0"
-pub(crate) mod receive;
pub mod send;
use serde_json::json;
use url::Url;
-pub
(crate) fn lemmy_context() -> Result<Vec<AnyBase>, LemmyError> {
+pub fn lemmy_context() -> Result<Vec<AnyBase>, LemmyError> {
let context_ext = AnyBase::from_arbitrary_json(json!(
{
"sc": "http://schema.org#",
-pub(crate) mod context;
+pub mod context;
pub(crate) mod group_extension;
pub(crate) mod page_extension;
pub(crate) mod person_extension;
-pub(crate) mod signatures;
+pub mod signatures;
/// Creates an HTTP post request to `inbox_url`, with the given `client` and `headers`, and
/// `activity` as request body. The request is signed with `private_key` and then sent.
-pub async fn sign_and_send(
+pub(crate) async fn sign_and_send(
client: &Client,
headers: BTreeMap<String, String>,
inbox_url: &Url,
}
/// Verifies the HTTP signature on an incoming inbox request.
-pub(crate) fn verify_signature(
- request: &HttpRequest,
- actor: &dyn ActorType,
-) -> Result<(), LemmyError> {
+pub fn verify_signature(request: &HttpRequest, actor: &dyn ActorType) -> Result<(), LemmyError> {
let public_key = actor.public_key().context(location_info!())?;
let verified = CONFIG2
.begin_verify(
person::get_or_fetch_and_upsert_person,
should_refetch_actor,
},
- inbox::person_inbox::receive_announce,
objects::FromApub,
GroupExt,
};
///
/// If it exists locally and `!should_refetch_actor()`, it is returned directly from the database.
/// Otherwise it is fetched from the remote instance, stored and returned.
-pub(crate) async fn get_or_fetch_and_upsert_community(
+pub async fn get_or_fetch_and_upsert_community(
apub_id: &Url,
context: &LemmyContext,
recursion_counter: &mut i32,
}
for activity in outbox_activities {
- receive_announce(context, activity, community, recursion_counter).await?;
+ todo!("{:?} {:?} {:?}", activity, community, recursion_counter);
+ //receive_announce(context, activity, community, recursion_counter).await?;
}
Ok(())
-pub(crate) mod community;
+pub mod community;
mod fetch;
-pub(crate) mod objects;
-pub(crate) mod person;
+pub mod objects;
+pub mod person;
pub mod search;
use crate::{
///
/// If it exists locally and `!should_refetch_actor()`, it is returned directly from the database.
/// Otherwise it is fetched from the remote instance, stored and returned.
-pub(crate) async fn get_or_fetch_and_upsert_actor(
+pub async fn get_or_fetch_and_upsert_actor(
apub_id: &Url,
context: &LemmyContext,
recursion_counter: &mut i32,
/// pulled from its apub ID, inserted and returned.
///
/// The parent community is also pulled if necessary. Comments are not pulled.
-pub(crate) async fn get_or_fetch_and_insert_post(
+pub async fn get_or_fetch_and_insert_post(
post_ap_id: &Url,
context: &LemmyContext,
recursion_counter: &mut i32,
/// pulled from its apub ID, inserted and returned.
///
/// The parent community, post and comment are also pulled if necessary.
-pub(crate) async fn get_or_fetch_and_insert_comment(
+pub async fn get_or_fetch_and_insert_comment(
comment_ap_id: &Url,
context: &LemmyContext,
recursion_counter: &mut i32,
///
/// If it exists locally and `!should_refetch_actor()`, it is returned directly from the database.
/// Otherwise it is fetched from the remote instance, stored and returned.
-pub(crate) async fn get_or_fetch_and_upsert_person(
+pub async fn get_or_fetch_and_upsert_person(
apub_id: &Url,
context: &LemmyContext,
recursion_counter: &mut i32,
pub mod activity_queue;
pub mod extensions;
pub mod fetcher;
-pub mod http;
-pub mod inbox;
pub mod objects;
-pub mod routes;
use crate::extensions::{
group_extension::GroupExtension,
activity::Follow,
actor,
base::AnyBase,
- object::{ApObject, Note, Page},
+ object::{ApObject, AsObject, Note, ObjectExt, Page},
};
use activitystreams_ext::{Ext1, Ext2};
use anyhow::{anyhow, Context};
post::Post,
private_message::PrivateMessage,
},
+ CommunityId,
DbUrl,
};
+use lemmy_db_views_actor::community_person_ban_view::CommunityPersonBanView;
use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
use lemmy_websocket::LemmyContext;
use serde::Serialize;
/// Activitystreams type for person
type PersonExt = Ext2<actor::ApActor<ApObject<actor::Person>>, PersonExtension, PublicKeyExtension>;
/// Activitystreams type for post
-type PageExt = Ext1<ApObject<Page>, PageExtension>;
-type NoteExt = ApObject<Note>;
+
pub type PageExt = Ext1<ApObject<Page>, PageExtension>;
+pub type NoteExt = ApObject<Note>;
pub static APUB_JSON_CONTENT_TYPE: &str = "application/activity+json";
/// - URL not being in the blocklist (if it is active)
///
/// Note that only one of allowlist and blacklist can be enabled, not both.
-fn check_is_apub_id_valid(apub_id: &Url) -> Result<(), LemmyError> {
+pub fn check_is_apub_id_valid(apub_id: &Url) -> Result<(), LemmyError> {
let settings = Settings::get();
let domain = apub_id.domain().context(location_info!())?.to_string();
let local_instance = settings.get_hostname_without_port()?;
Ok(Url::parse(&url)?.into())
}
-pub(crate) fn generate_moderators_url(community_id: &DbUrl) -> Result<DbUrl, LemmyError> {
+pub fn generate_moderators_url(community_id: &DbUrl) -> Result<DbUrl, LemmyError> {
Ok(Url::parse(&format!("{}/moderators", community_id))?.into())
}
/// Store a sent or received activity in the database, for logging purposes. These records are not
/// persistent.
-pub(crate) async fn insert_activity<T>(
+pub async fn insert_activity<T>(
ap_id: &Url,
activity: T,
local: bool,
Ok(())
}
-pub(crate) enum PostOrComment {
+pub enum PostOrComment {
Comment(Box<Comment>),
Post(Box<Post>),
}
/// 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(
+pub async fn find_post_or_comment_by_id(
context: &LemmyContext,
apub_id: Url,
) -> Result<PostOrComment, LemmyError> {
Err(NotFound.into())
}
+
+pub async fn check_community_or_site_ban(
+ person: &Person,
+ community_id: CommunityId,
+ pool: &DbPool,
+) -> Result<(), LemmyError> {
+ if person.banned {
+ return Err(anyhow!("Person is banned from site").into());
+ }
+ let person_id = person.id;
+ let is_banned =
+ move |conn: &'_ _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
+ if blocking(pool, is_banned).await? {
+ return Err(anyhow!("Person is banned from community").into());
+ }
+
+ Ok(())
+}
+
+pub fn get_activity_to_and_cc<T, Kind>(activity: &T) -> Vec<Url>
+where
+ T: AsObject<Kind>,
+{
+ let mut to_and_cc = vec![];
+ if let Some(to) = activity.to() {
+ let to = to.to_owned().unwrap_to_vec();
+ let mut to = to
+ .iter()
+ .map(|t| t.as_xsd_any_uri())
+ .flatten()
+ .map(|t| t.to_owned())
+ .collect();
+ to_and_cc.append(&mut to);
+ }
+ if let Some(cc) = activity.cc() {
+ let cc = cc.to_owned().unwrap_to_vec();
+ let mut cc = cc
+ .iter()
+ .map(|c| c.as_xsd_any_uri())
+ .flatten()
+ .map(|c| c.to_owned())
+ .collect();
+ to_and_cc.append(&mut cc);
+ }
+ to_and_cc
+}
use crate::{
+ check_community_or_site_ban,
check_is_apub_id_valid,
fetcher::{community::get_or_fetch_and_upsert_community, person::get_or_fetch_and_upsert_person},
- inbox::{community_inbox::check_community_or_site_ban, get_activity_to_and_cc},
+ get_activity_to_and_cc,
PageExt,
};
use activitystreams::{
/// Trait for converting an object or actor into the respective ActivityPub type.
#[async_trait::async_trait(?Send)]
-pub(crate) trait ToApub {
+pub trait ToApub {
type ApubType;
async fn to_apub(&self, pool: &DbPool) -> Result<Self::ApubType, LemmyError>;
fn to_tombstone(&self) -> Result<Tombstone, LemmyError>;
}
#[async_trait::async_trait(?Send)]
-pub(crate) trait FromApub {
+pub trait FromApub {
type ApubType;
/// Converts an object from ActivityPub type to Lemmy internal type.
///
--- /dev/null
+[package]
+name = "lemmy_apub_receive"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+lemmy_utils = { path = "../utils" }
+lemmy_apub = { path = "../apub" }
+lemmy_db_queries = { path = "../db_queries" }
+lemmy_db_schema = { path = "../db_schema" }
+lemmy_db_views = { path = "../db_views" }
+lemmy_db_views_actor = { path = "../db_views_actor" }
+lemmy_api_common = { path = "../api_common" }
+lemmy_websocket = { path = "../websocket" }
+diesel = "1.4.5"
+activitystreams = "0.7.0-alpha.11"
+activitystreams-ext = "0.1.0-alpha.2"
+bcrypt = "0.9.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+serde_json = { version = "1.0.61", features = ["preserve_order"] }
+serde = { version = "1.0.123", features = ["derive"] }
+actix = "0.10.0"
+actix-web = { version = "3.3.2", default-features = false }
+actix-rt = { version = "1.1.1", default-features = false }
+awc = { version = "2.0.3", default-features = false }
+log = "0.4.14"
+rand = "0.8.3"
+strum = "0.20.0"
+strum_macros = "0.20.1"
+url = { version = "2.2.1", features = ["serde"] }
+percent-encoding = "2.1.0"
+openssl = "0.10.32"
+http = "0.2.3"
+http-signature-normalization-actix = { version = "0.4.1", default-features = false, features = ["sha-2"] }
+http-signature-normalization-reqwest = { version = "0.1.3", default-features = false, features = ["sha-2"] }
+base64 = "0.13.0"
+tokio = "0.3.6"
+futures = "0.3.12"
+itertools = "0.10.0"
+sha2 = "0.9.3"
+async-trait = "0.1.42"
+anyhow = "1.0.38"
+thiserror = "1.0.23"
+backtrace = "0.3.56"
+
--- /dev/null
+pub(crate) mod receive;
-use crate::{activities::receive::get_actor_as_person, objects::FromApub, ActorType, NoteExt};
+use crate::activities::receive::get_actor_as_person;
use activitystreams::{
activity::{ActorAndObjectRefExt, Create, Dislike, Like, Update},
base::ExtendsExt,
};
use anyhow::Context;
use lemmy_api_common::{blocking, comment::CommentResponse, send_local_notifs};
+use lemmy_apub::{objects::FromApub, ActorType, NoteExt};
use lemmy_db_queries::{source::comment::Comment_, Crud, Likeable};
use lemmy_db_schema::source::{
comment::{Comment, CommentLike, CommentLikeForm},
-use crate::fetcher::person::get_or_fetch_and_upsert_person;
use activitystreams::{
activity::{ActorAndObjectRef, ActorAndObjectRefExt},
base::{AsBase, BaseExt},
error::DomainError,
};
use anyhow::{anyhow, Context};
+use lemmy_apub::fetcher::person::get_or_fetch_and_upsert_person;
use lemmy_db_schema::source::person::Person;
use lemmy_utils::{location_info, LemmyError};
use lemmy_websocket::LemmyContext;
use crate::{
activities::receive::get_actor_as_person,
inbox::receive_for_community::verify_mod_activity,
- objects::FromApub,
- ActorType,
- PageExt,
};
use activitystreams::{
activity::{Announce, Create, Dislike, Like, Update},
};
use anyhow::Context;
use lemmy_api_common::{blocking, post::PostResponse};
+use lemmy_apub::{objects::FromApub, ActorType, PageExt};
use lemmy_db_queries::{source::post::Post_, ApubObject, Crud, Likeable};
use lemmy_db_schema::{
source::{
-use crate::{
- activities::receive::verify_activity_domains_valid,
- check_is_apub_id_valid,
- fetcher::person::get_or_fetch_and_upsert_person,
- inbox::get_activity_to_and_cc,
- objects::FromApub,
- NoteExt,
-};
+use crate::activities::receive::verify_activity_domains_valid;
use activitystreams::{
activity::{ActorAndObjectRefExt, Create, Delete, Undo, Update},
base::{AsBase, ExtendsExt},
};
use anyhow::{anyhow, Context};
use lemmy_api_common::{blocking, person::PrivateMessageResponse};
+use lemmy_apub::{
+ check_is_apub_id_valid,
+ fetcher::person::get_or_fetch_and_upsert_person,
+ get_activity_to_and_cc,
+ objects::FromApub,
+ NoteExt,
+};
use lemmy_db_queries::source::private_message::PrivateMessage_;
use lemmy_db_schema::source::private_message::PrivateMessage;
use lemmy_db_views::{local_user_view::LocalUserView, private_message_view::PrivateMessageView};
-use crate::{
- http::{create_apub_response, create_apub_tombstone_response},
- objects::ToApub,
-};
+use crate::http::{create_apub_response, create_apub_tombstone_response};
use actix_web::{body::Body, web, web::Path, HttpResponse};
use diesel::result::Error::NotFound;
use lemmy_api_common::blocking;
+use lemmy_apub::objects::ToApub;
use lemmy_db_queries::Crud;
use lemmy_db_schema::{source::comment::Comment, CommentId};
use lemmy_utils::LemmyError;
-use crate::{
- extensions::context::lemmy_context,
- generate_moderators_url,
- http::{create_apub_response, create_apub_tombstone_response},
- objects::ToApub,
- ActorType,
-};
+use crate::http::{create_apub_response, create_apub_tombstone_response};
use activitystreams::{
base::{AnyBase, BaseExt},
collection::{CollectionExt, OrderedCollection, UnorderedCollection},
};
use actix_web::{body::Body, web, HttpResponse};
use lemmy_api_common::blocking;
+use lemmy_apub::{
+ extensions::context::lemmy_context,
+ generate_moderators_url,
+ objects::ToApub,
+ ActorType,
+};
use lemmy_db_queries::source::{activity::Activity_, community::Community_};
use lemmy_db_schema::source::{activity::Activity, community::Community};
use lemmy_db_views_actor::{
-use crate::APUB_JSON_CONTENT_TYPE;
use actix_web::{body::Body, web, HttpResponse};
use http::StatusCode;
use lemmy_api_common::blocking;
+use lemmy_apub::APUB_JSON_CONTENT_TYPE;
use lemmy_db_queries::source::activity::Activity_;
use lemmy_db_schema::source::activity::Activity;
use lemmy_utils::{settings::structs::Settings, LemmyError};
-use crate::{
- extensions::context::lemmy_context,
- http::{create_apub_response, create_apub_tombstone_response},
- objects::ToApub,
- ActorType,
-};
+use crate::http::{create_apub_response, create_apub_tombstone_response};
use activitystreams::{
base::BaseExt,
collection::{CollectionExt, OrderedCollection},
};
use actix_web::{body::Body, web, HttpResponse};
use lemmy_api_common::blocking;
+use lemmy_apub::{extensions::context::lemmy_context, objects::ToApub, ActorType};
use lemmy_db_queries::source::person::Person_;
use lemmy_db_schema::source::person::Person;
use lemmy_utils::LemmyError;
-use crate::{
- http::{create_apub_response, create_apub_tombstone_response},
- objects::ToApub,
-};
+use crate::http::{create_apub_response, create_apub_tombstone_response};
use actix_web::{body::Body, web, HttpResponse};
use diesel::result::Error::NotFound;
use lemmy_api_common::blocking;
+use lemmy_apub::objects::ToApub;
use lemmy_db_queries::Crud;
use lemmy_db_schema::{source::post::Post, PostId};
use lemmy_utils::LemmyError;
inbox::{
assert_activity_not_local,
get_activity_id,
- get_activity_to_and_cc,
inbox_verify_http_signature,
is_activity_already_known,
receive_for_community::{
},
verify_is_addressed_to_public,
},
- insert_activity,
- ActorType,
- CommunityType,
};
use activitystreams::{
activity::{kind::FollowType, ActorAndObject, Follow, Undo},
use actix_web::{web, HttpRequest, HttpResponse};
use anyhow::{anyhow, Context};
use lemmy_api_common::blocking;
-use lemmy_db_queries::{source::community::Community_, ApubObject, DbPool, Followable};
-use lemmy_db_schema::{
- source::{
- community::{Community, CommunityFollower, CommunityFollowerForm},
- person::Person,
- },
- CommunityId,
+use lemmy_apub::{
+ check_community_or_site_ban,
+ get_activity_to_and_cc,
+ insert_activity,
+ ActorType,
+ CommunityType,
+};
+use lemmy_db_queries::{source::community::Community_, ApubObject, Followable};
+use lemmy_db_schema::source::{
+ community::{Community, CommunityFollower, CommunityFollowerForm},
+ person::Person,
};
-use lemmy_db_views_actor::community_person_ban_view::CommunityPersonBanView;
use lemmy_utils::{location_info, LemmyError};
use lemmy_websocket::LemmyContext;
use log::info;
Ok(())
}
-
-pub(crate) async fn check_community_or_site_ban(
- person: &Person,
- community_id: CommunityId,
- pool: &DbPool,
-) -> Result<(), LemmyError> {
- if person.banned {
- return Err(anyhow!("Person is banned from site").into());
- }
- let person_id = person.id;
- let is_banned =
- move |conn: &'_ _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
- if blocking(pool, is_banned).await? {
- return Err(anyhow!("Person is banned from community").into());
- }
-
- Ok(())
-}
-use crate::{
- check_is_apub_id_valid,
- extensions::signatures::verify_signature,
- fetcher::get_or_fetch_and_upsert_actor,
- ActorType,
-};
use activitystreams::{
activity::ActorAndObjectRefExt,
base::{AsBase, BaseExt, Extends},
- object::{AsObject, ObjectExt},
+ object::AsObject,
public,
};
use actix_web::HttpRequest;
use anyhow::{anyhow, Context};
use lemmy_api_common::blocking;
+use lemmy_apub::{
+ check_is_apub_id_valid,
+ extensions::signatures::verify_signature,
+ fetcher::get_or_fetch_and_upsert_actor,
+ get_activity_to_and_cc,
+ ActorType,
+};
use lemmy_db_queries::{
source::{activity::Activity_, community::Community_},
ApubObject,
}
}
-pub(crate) fn get_activity_to_and_cc<T, Kind>(activity: &T) -> Vec<Url>
-where
- T: AsObject<Kind>,
-{
- let mut to_and_cc = vec![];
- if let Some(to) = activity.to() {
- let to = to.to_owned().unwrap_to_vec();
- let mut to = to
- .iter()
- .map(|t| t.as_xsd_any_uri())
- .flatten()
- .map(|t| t.to_owned())
- .collect();
- to_and_cc.append(&mut to);
- }
- if let Some(cc) = activity.cc() {
- let cc = cc.to_owned().unwrap_to_vec();
- let mut cc = cc
- .iter()
- .map(|c| c.as_xsd_any_uri())
- .flatten()
- .map(|c| c.to_owned())
- .collect();
- to_and_cc.append(&mut cc);
- }
- to_and_cc
-}
-
pub(crate) fn verify_is_addressed_to_public<T, Kind>(activity: &T) -> Result<(), LemmyError>
where
T: AsBase<Kind> + AsObject<Kind> + ActorAndObjectRefExt,
receive_unhandled_activity,
verify_activity_domains_valid,
},
- check_is_apub_id_valid,
- fetcher::community::get_or_fetch_and_upsert_community,
inbox::{
assert_activity_not_local,
get_activity_id,
- get_activity_to_and_cc,
inbox_verify_http_signature,
is_activity_already_known,
is_addressed_to_community_followers,
},
verify_is_addressed_to_public,
},
- insert_activity,
- ActorType,
};
use activitystreams::{
activity::{Accept, ActorAndObject, Announce, Create, Delete, Follow, Remove, Undo, Update},
use anyhow::{anyhow, Context};
use diesel::NotFound;
use lemmy_api_common::blocking;
+use lemmy_apub::{
+ check_is_apub_id_valid,
+ fetcher::community::get_or_fetch_and_upsert_community,
+ get_activity_to_and_cc,
+ insert_activity,
+ ActorType,
+};
use lemmy_db_queries::{source::person::Person_, ApubObject, Followable};
use lemmy_db_schema::source::{
community::{Community, CommunityFollower},
receive_unhandled_activity,
verify_activity_domains_valid,
},
- fetcher::{
- objects::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
- person::get_or_fetch_and_upsert_person,
- },
- find_post_or_comment_by_id,
- generate_moderators_url,
inbox::verify_is_addressed_to_public,
- CommunityType,
- PostOrComment,
};
use activitystreams::{
activity::{
use anyhow::{anyhow, Context};
use diesel::result::Error::NotFound;
use lemmy_api_common::blocking;
+use lemmy_apub::{
+ fetcher::{
+ objects::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
+ person::get_or_fetch_and_upsert_person,
+ },
+ find_post_or_comment_by_id,
+ generate_moderators_url,
+ CommunityType,
+ PostOrComment,
+};
use lemmy_db_queries::{source::community::CommunityModerator_, ApubObject, Crud, Joinable};
use lemmy_db_schema::{
source::{
-use crate::{
- inbox::{
- assert_activity_not_local,
- community_inbox::{community_receive_message, CommunityAcceptedActivities},
- get_activity_id,
- get_activity_to_and_cc,
- inbox_verify_http_signature,
- is_activity_already_known,
- is_addressed_to_community_followers,
- is_addressed_to_local_person,
- person_inbox::{person_receive_message, PersonAcceptedActivities},
- },
- insert_activity,
+use crate::inbox::{
+ assert_activity_not_local,
+ community_inbox::{community_receive_message, CommunityAcceptedActivities},
+ get_activity_id,
+ inbox_verify_http_signature,
+ is_activity_already_known,
+ is_addressed_to_community_followers,
+ is_addressed_to_local_person,
+ person_inbox::{person_receive_message, PersonAcceptedActivities},
};
use activitystreams::{activity::ActorAndObject, prelude::*};
use actix_web::{web, HttpRequest, HttpResponse};
use anyhow::Context;
use lemmy_api_common::blocking;
+use lemmy_apub::{get_activity_to_and_cc, insert_activity};
use lemmy_db_queries::{ApubObject, DbPool};
use lemmy_db_schema::source::community::Community;
use lemmy_utils::{location_info, LemmyError};
--- /dev/null
+mod activities;
+mod http;
+mod inbox;
+pub mod routes;
person_inbox::person_inbox,
shared_inbox::shared_inbox,
},
- APUB_JSON_CONTENT_TYPE,
};
use actix_web::*;
use http_signature_normalization_actix::digest::middleware::VerifyDigest;
+use lemmy_apub::APUB_JSON_CONTENT_TYPE;
use lemmy_utils::settings::structs::Settings;
use sha2::{Digest, Sha256};
.data(context)
// The routes
.configure(|cfg| api_routes::config(cfg, &rate_limiter))
- .configure(lemmy_apub::routes::config)
+ .configure(lemmy_apub_receive::routes::config)
.configure(feeds::config)
.configure(|cfg| images::config(cfg, &rate_limiter))
.configure(nodeinfo::config)
projects / lemmy.git / commitdiff