mirror of
https://github.com/LemmyNet/lemmy.git
synced 2024-09-28 22:31:57 +00:00
Remove Perform traits for apub code, remove api_routes_websocket
This commit is contained in:
parent
82d93da26b
commit
a9a09c2104
14 changed files with 487 additions and 1317 deletions
20
Cargo.lock
generated
20
Cargo.lock
generated
|
@ -305,23 +305,6 @@ dependencies = [
|
|||
"url",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "actix-web-actors"
|
||||
version = "4.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "31efe7896f3933ce03dd4710be560254272334bb321a18fd8ff62b1a557d9d19"
|
||||
dependencies = [
|
||||
"actix",
|
||||
"actix-codec",
|
||||
"actix-http",
|
||||
"actix-web",
|
||||
"bytes",
|
||||
"bytestring",
|
||||
"futures-core",
|
||||
"pin-project-lite",
|
||||
"tokio",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "actix-web-codegen"
|
||||
version = "4.1.0"
|
||||
|
@ -2559,7 +2542,6 @@ version = "0.17.1"
|
|||
dependencies = [
|
||||
"actix",
|
||||
"actix-rt",
|
||||
"actix-web",
|
||||
"anyhow",
|
||||
"chrono",
|
||||
"encoding",
|
||||
|
@ -2750,9 +2732,7 @@ version = "0.17.1"
|
|||
dependencies = [
|
||||
"activitypub_federation",
|
||||
"actix",
|
||||
"actix-rt",
|
||||
"actix-web",
|
||||
"actix-web-actors",
|
||||
"clokwerk",
|
||||
"console-subscriber",
|
||||
"diesel",
|
||||
|
|
|
@ -138,8 +138,6 @@ futures = { workspace = true }
|
|||
actix = { workspace = true }
|
||||
tracing-opentelemetry = { workspace = true, optional = true }
|
||||
opentelemetry = { workspace = true, optional = true }
|
||||
actix-web-actors = { version = "4.1.0", default-features = false }
|
||||
actix-rt = "2.6"
|
||||
console-subscriber = { version = "0.1.8", optional = true }
|
||||
opentelemetry-otlp = { version = "0.10.0", optional = true }
|
||||
pict-rs = { version = "0.4.0-beta.9", optional = true }
|
||||
|
|
|
@ -14,9 +14,9 @@ path = "src/lib.rs"
|
|||
doctest = false
|
||||
|
||||
[features]
|
||||
full = ["tracing", "rosetta-i18n", "chrono", "actix-web", "lemmy_utils",
|
||||
"lemmy_db_views/full", "lemmy_db_views_actor/full", "lemmy_db_views_moderator/full",
|
||||
"percent-encoding", "encoding", "reqwest-middleware", "webpage", "ts-rs"]
|
||||
full = ["tracing", "rosetta-i18n", "chrono", "lemmy_utils", "lemmy_db_views/full",
|
||||
"lemmy_db_views_actor/full", "lemmy_db_views_moderator/full", "percent-encoding",
|
||||
"encoding", "reqwest-middleware", "webpage", "ts-rs"]
|
||||
|
||||
[dependencies]
|
||||
lemmy_db_views = { workspace = true }
|
||||
|
@ -27,7 +27,6 @@ lemmy_utils = { workspace = true, optional = true }
|
|||
serde = { workspace = true }
|
||||
serde_with = { workspace = true }
|
||||
url = { workspace = true }
|
||||
actix-web = { workspace = true, features = ["cookies"], optional = true }
|
||||
chrono = { workspace = true, optional = true }
|
||||
tracing = { workspace = true, optional = true }
|
||||
reqwest-middleware = { workspace = true, optional = true }
|
||||
|
|
|
@ -1,9 +1,10 @@
|
|||
use crate::{
|
||||
api::{listing_type_with_default, PerformApub},
|
||||
api::listing_type_with_default,
|
||||
fetcher::resolve_actor_identifier,
|
||||
objects::community::ApubCommunity,
|
||||
};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use lemmy_api_common::{
|
||||
comment::{GetComments, GetCommentsResponse},
|
||||
context::LemmyContext,
|
||||
|
@ -14,69 +15,61 @@ use lemmy_db_schema::{
|
|||
traits::Crud,
|
||||
};
|
||||
use lemmy_db_views::comment_view::CommentQuery;
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for GetComments {
|
||||
type Response = GetCommentsResponse;
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn list_comments(
|
||||
data: Json<GetComments>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<GetCommentsResponse>, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
#[tracing::instrument(skip(context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<GetCommentsResponse, LemmyError> {
|
||||
let data: &GetComments = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
|
||||
.await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, context, &None, true)
|
||||
.await
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let sort = data.sort;
|
||||
let max_depth = data.max_depth;
|
||||
let saved_only = data.saved_only;
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let parent_id = data.parent_id;
|
||||
|
||||
let listing_type = listing_type_with_default(data.type_, &local_site, community_id)?;
|
||||
|
||||
// If a parent_id is given, fetch the comment to get the path
|
||||
let parent_path = if let Some(parent_id) = parent_id {
|
||||
Some(Comment::read(context.pool(), parent_id).await?.path)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let parent_path_cloned = parent_path.clone();
|
||||
let post_id = data.post_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
let comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.listing_type(Some(listing_type))
|
||||
.sort(sort)
|
||||
.max_depth(max_depth)
|
||||
.saved_only(saved_only)
|
||||
.community_id(community_id)
|
||||
.parent_path(parent_path_cloned)
|
||||
.post_id(post_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, &context, &None, true)
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_get_comments"))?;
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let sort = data.sort;
|
||||
let max_depth = data.max_depth;
|
||||
let saved_only = data.saved_only;
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let parent_id = data.parent_id;
|
||||
|
||||
Ok(GetCommentsResponse { comments })
|
||||
}
|
||||
let listing_type = listing_type_with_default(data.type_, &local_site, community_id)?;
|
||||
|
||||
// If a parent_id is given, fetch the comment to get the path
|
||||
let parent_path = if let Some(parent_id) = parent_id {
|
||||
Some(Comment::read(context.pool(), parent_id).await?.path)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let parent_path_cloned = parent_path.clone();
|
||||
let post_id = data.post_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
let comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.listing_type(Some(listing_type))
|
||||
.sort(sort)
|
||||
.max_depth(max_depth)
|
||||
.saved_only(saved_only)
|
||||
.community_id(community_id)
|
||||
.parent_path(parent_path_cloned)
|
||||
.post_id(post_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_get_comments"))?;
|
||||
|
||||
Ok(Json(GetCommentsResponse { comments }))
|
||||
}
|
||||
|
|
|
@ -1,9 +1,10 @@
|
|||
use crate::{
|
||||
api::{listing_type_with_default, PerformApub},
|
||||
api::listing_type_with_default,
|
||||
fetcher::resolve_actor_identifier,
|
||||
objects::community::ApubCommunity,
|
||||
};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use lemmy_api_common::{
|
||||
context::LemmyContext,
|
||||
post::{GetPosts, GetPostsResponse},
|
||||
|
@ -11,62 +12,53 @@ use lemmy_api_common::{
|
|||
};
|
||||
use lemmy_db_schema::source::{community::Community, local_site::LocalSite};
|
||||
use lemmy_db_views::post_view::PostQuery;
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for GetPosts {
|
||||
type Response = GetPostsResponse;
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn list_posts(
|
||||
data: Json<GetPosts>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<GetPostsResponse>, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
|
||||
#[tracing::instrument(skip(context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<GetPostsResponse, LemmyError> {
|
||||
let data: &GetPosts = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
|
||||
.await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
let sort = data.sort;
|
||||
|
||||
let sort = data.sort;
|
||||
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, context, &None, true)
|
||||
.await
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let saved_only = data.saved_only;
|
||||
|
||||
let listing_type = listing_type_with_default(data.type_, &local_site, community_id)?;
|
||||
|
||||
let is_mod_or_admin =
|
||||
is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), community_id)
|
||||
.await
|
||||
.is_ok();
|
||||
|
||||
let posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.local_user(local_user_view.map(|l| l.local_user).as_ref())
|
||||
.listing_type(Some(listing_type))
|
||||
.sort(sort)
|
||||
.community_id(community_id)
|
||||
.saved_only(saved_only)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.is_mod_or_admin(Some(is_mod_or_admin))
|
||||
.build()
|
||||
.list()
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, &context, &None, true)
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_get_posts"))?;
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let saved_only = data.saved_only;
|
||||
|
||||
Ok(GetPostsResponse { posts })
|
||||
}
|
||||
let listing_type = listing_type_with_default(data.type_, &local_site, community_id)?;
|
||||
|
||||
let is_mod_or_admin = is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), community_id)
|
||||
.await
|
||||
.is_ok();
|
||||
|
||||
let posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.local_user(local_user_view.map(|l| l.local_user).as_ref())
|
||||
.listing_type(Some(listing_type))
|
||||
.sort(sort)
|
||||
.community_id(community_id)
|
||||
.saved_only(saved_only)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.is_mod_or_admin(Some(is_mod_or_admin))
|
||||
.build()
|
||||
.list()
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_get_posts"))?;
|
||||
|
||||
Ok(Json(GetPostsResponse { posts }))
|
||||
}
|
||||
|
|
|
@ -1,25 +1,12 @@
|
|||
use activitypub_federation::config::Data;
|
||||
use lemmy_api_common::context::LemmyContext;
|
||||
use lemmy_db_schema::{newtypes::CommunityId, source::local_site::LocalSite, ListingType};
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
mod list_comments;
|
||||
mod list_posts;
|
||||
mod read_community;
|
||||
mod read_person;
|
||||
mod resolve_object;
|
||||
mod search;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
pub trait PerformApub {
|
||||
type Response: serde::ser::Serialize + Send;
|
||||
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
websocket_id: Option<ConnectionId>,
|
||||
) -> Result<Self::Response, LemmyError>;
|
||||
}
|
||||
pub mod list_comments;
|
||||
pub mod list_posts;
|
||||
pub mod read_community;
|
||||
pub mod read_person;
|
||||
pub mod resolve_object;
|
||||
pub mod search;
|
||||
|
||||
/// Returns default listing type, depending if the query is for frontpage or community.
|
||||
fn listing_type_with_default(
|
||||
|
|
|
@ -1,9 +1,6 @@
|
|||
use crate::{
|
||||
api::PerformApub,
|
||||
fetcher::resolve_actor_identifier,
|
||||
objects::community::ApubCommunity,
|
||||
};
|
||||
use crate::{fetcher::resolve_actor_identifier, objects::community::ApubCommunity};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use lemmy_api_common::{
|
||||
community::{GetCommunity, GetCommunityResponse},
|
||||
context::LemmyContext,
|
||||
|
@ -17,89 +14,80 @@ use lemmy_db_schema::source::{
|
|||
site::Site,
|
||||
};
|
||||
use lemmy_db_views_actor::structs::{CommunityModeratorView, CommunityView};
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for GetCommunity {
|
||||
type Response = GetCommunityResponse;
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn read_community(
|
||||
data: Json<GetCommunity>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<GetCommunityResponse>, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
|
||||
#[tracing::instrument(skip(context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<GetCommunityResponse, LemmyError> {
|
||||
let data: &GetCommunity = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
|
||||
.await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
if data.name.is_none() && data.id.is_none() {
|
||||
return Err(LemmyError::from_message("no_id_given"));
|
||||
}
|
||||
|
||||
if data.name.is_none() && data.id.is_none() {
|
||||
return Err(LemmyError::from_message("no_id_given"));
|
||||
}
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
let person_id = local_user_view.as_ref().map(|u| u.person.id);
|
||||
|
||||
let person_id = local_user_view.as_ref().map(|u| u.person.id);
|
||||
|
||||
let community_id = match data.id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
let name = data.name.clone().unwrap_or_else(|| "main".to_string());
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(&name, context, &local_user_view, true)
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_community"))?
|
||||
.id
|
||||
}
|
||||
};
|
||||
|
||||
let is_mod_or_admin =
|
||||
is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), Some(community_id))
|
||||
let community_id = match data.id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
let name = data.name.clone().unwrap_or_else(|| "main".to_string());
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(&name, &context, &local_user_view, true)
|
||||
.await
|
||||
.is_ok();
|
||||
.map_err(|e| e.with_message("couldnt_find_community"))?
|
||||
.id
|
||||
}
|
||||
};
|
||||
|
||||
let community_view = CommunityView::read(
|
||||
context.pool(),
|
||||
community_id,
|
||||
person_id,
|
||||
Some(is_mod_or_admin),
|
||||
)
|
||||
let is_mod_or_admin =
|
||||
is_mod_or_admin_opt(context.pool(), local_user_view.as_ref(), Some(community_id))
|
||||
.await
|
||||
.is_ok();
|
||||
|
||||
let community_view = CommunityView::read(
|
||||
context.pool(),
|
||||
community_id,
|
||||
person_id,
|
||||
Some(is_mod_or_admin),
|
||||
)
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
|
||||
|
||||
let moderators = CommunityModeratorView::for_community(context.pool(), community_id)
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
|
||||
|
||||
let moderators = CommunityModeratorView::for_community(context.pool(), community_id)
|
||||
.await
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
|
||||
let online = context
|
||||
.chat_server()
|
||||
.send(GetCommunityUsersOnline { community_id })
|
||||
.await?;
|
||||
|
||||
let online = context
|
||||
.chat_server()
|
||||
.send(GetCommunityUsersOnline { community_id })
|
||||
.await?;
|
||||
|
||||
let site_id =
|
||||
Site::instance_actor_id_from_url(community_view.community.actor_id.clone().into());
|
||||
let mut site = Site::read_from_apub_id(context.pool(), &site_id.into()).await?;
|
||||
// no need to include metadata for local site (its already available through other endpoints).
|
||||
// this also prevents us from leaking the federation private key.
|
||||
if let Some(s) = &site {
|
||||
if s.actor_id.domain() == Some(context.settings().hostname.as_ref()) {
|
||||
site = None;
|
||||
}
|
||||
let site_id = Site::instance_actor_id_from_url(community_view.community.actor_id.clone().into());
|
||||
let mut site = Site::read_from_apub_id(context.pool(), &site_id.into()).await?;
|
||||
// no need to include metadata for local site (its already available through other endpoints).
|
||||
// this also prevents us from leaking the federation private key.
|
||||
if let Some(s) = &site {
|
||||
if s.actor_id.domain() == Some(context.settings().hostname.as_ref()) {
|
||||
site = None;
|
||||
}
|
||||
|
||||
let community_id = community_view.community.id;
|
||||
let discussion_languages = CommunityLanguage::read(context.pool(), community_id).await?;
|
||||
|
||||
let res = GetCommunityResponse {
|
||||
community_view,
|
||||
site,
|
||||
moderators,
|
||||
online,
|
||||
discussion_languages,
|
||||
};
|
||||
|
||||
// Return the jwt
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
let community_id = community_view.community.id;
|
||||
let discussion_languages = CommunityLanguage::read(context.pool(), community_id).await?;
|
||||
|
||||
let res = GetCommunityResponse {
|
||||
community_view,
|
||||
site,
|
||||
moderators,
|
||||
online,
|
||||
discussion_languages,
|
||||
};
|
||||
|
||||
// Return the jwt
|
||||
Ok(Json(res))
|
||||
}
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
use crate::{api::PerformApub, fetcher::resolve_actor_identifier, objects::person::ApubPerson};
|
||||
use crate::{fetcher::resolve_actor_identifier, objects::person::ApubPerson};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use lemmy_api_common::{
|
||||
context::LemmyContext,
|
||||
person::{GetPersonDetails, GetPersonDetailsResponse},
|
||||
|
@ -11,113 +12,104 @@ use lemmy_db_schema::{
|
|||
};
|
||||
use lemmy_db_views::{comment_view::CommentQuery, post_view::PostQuery};
|
||||
use lemmy_db_views_actor::structs::{CommunityModeratorView, PersonView};
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for GetPersonDetails {
|
||||
type Response = GetPersonDetailsResponse;
|
||||
|
||||
#[tracing::instrument(skip(self, context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<GetPersonDetailsResponse, LemmyError> {
|
||||
let data: &GetPersonDetails = self;
|
||||
|
||||
// Check to make sure a person name or an id is given
|
||||
if data.username.is_none() && data.person_id.is_none() {
|
||||
return Err(LemmyError::from_message("no_id_given"));
|
||||
}
|
||||
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
|
||||
.await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
|
||||
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
let person_details_id = match data.person_id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
if let Some(username) = &data.username {
|
||||
resolve_actor_identifier::<ApubPerson, Person>(username, context, &local_user_view, true)
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_that_username_or_email"))?
|
||||
.id
|
||||
} else {
|
||||
return Err(LemmyError::from_message(
|
||||
"couldnt_find_that_username_or_email",
|
||||
));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// You don't need to return settings for the user, since this comes back with GetSite
|
||||
// `my_user`
|
||||
let person_view = PersonView::read(context.pool(), person_details_id).await?;
|
||||
|
||||
let sort = data.sort;
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let saved_only = data.saved_only;
|
||||
let community_id = data.community_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
let local_user_clone = local_user.clone();
|
||||
|
||||
let posts_query = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.saved_only(saved_only)
|
||||
.local_user(local_user.as_ref())
|
||||
.community_id(community_id)
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit);
|
||||
|
||||
// If its saved only, you don't care what creator it was
|
||||
// Or, if its not saved, then you only want it for that specific creator
|
||||
let posts = if !saved_only.unwrap_or(false) {
|
||||
posts_query
|
||||
.creator_id(Some(person_details_id))
|
||||
.build()
|
||||
.list()
|
||||
} else {
|
||||
posts_query.build().list()
|
||||
}
|
||||
.await?;
|
||||
|
||||
let comments_query = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.local_user(local_user_clone.as_ref())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.saved_only(saved_only)
|
||||
.show_deleted_and_removed(Some(false))
|
||||
.community_id(community_id)
|
||||
.page(page)
|
||||
.limit(limit);
|
||||
|
||||
// If its saved only, you don't care what creator it was
|
||||
// Or, if its not saved, then you only want it for that specific creator
|
||||
let comments = if !saved_only.unwrap_or(false) {
|
||||
comments_query
|
||||
.creator_id(Some(person_details_id))
|
||||
.build()
|
||||
.list()
|
||||
} else {
|
||||
comments_query.build().list()
|
||||
}
|
||||
.await?;
|
||||
|
||||
let moderates = CommunityModeratorView::for_person(context.pool(), person_details_id).await?;
|
||||
|
||||
// Return the jwt
|
||||
Ok(GetPersonDetailsResponse {
|
||||
person_view,
|
||||
moderates,
|
||||
comments,
|
||||
posts,
|
||||
})
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn read_person(
|
||||
data: Json<GetPersonDetails>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<GetPersonDetailsResponse>, LemmyError> {
|
||||
// Check to make sure a person name or an id is given
|
||||
if data.username.is_none() && data.person_id.is_none() {
|
||||
return Err(LemmyError::from_message("no_id_given"));
|
||||
}
|
||||
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
|
||||
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
let person_details_id = match data.person_id {
|
||||
Some(id) => id,
|
||||
None => {
|
||||
if let Some(username) = &data.username {
|
||||
resolve_actor_identifier::<ApubPerson, Person>(username, &context, &local_user_view, true)
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_that_username_or_email"))?
|
||||
.id
|
||||
} else {
|
||||
return Err(LemmyError::from_message(
|
||||
"couldnt_find_that_username_or_email",
|
||||
));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// You don't need to return settings for the user, since this comes back with GetSite
|
||||
// `my_user`
|
||||
let person_view = PersonView::read(context.pool(), person_details_id).await?;
|
||||
|
||||
let sort = data.sort;
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let saved_only = data.saved_only;
|
||||
let community_id = data.community_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
let local_user_clone = local_user.clone();
|
||||
|
||||
let posts_query = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.saved_only(saved_only)
|
||||
.local_user(local_user.as_ref())
|
||||
.community_id(community_id)
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit);
|
||||
|
||||
// If its saved only, you don't care what creator it was
|
||||
// Or, if its not saved, then you only want it for that specific creator
|
||||
let posts = if !saved_only.unwrap_or(false) {
|
||||
posts_query
|
||||
.creator_id(Some(person_details_id))
|
||||
.build()
|
||||
.list()
|
||||
} else {
|
||||
posts_query.build().list()
|
||||
}
|
||||
.await?;
|
||||
|
||||
let comments_query = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.local_user(local_user_clone.as_ref())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.saved_only(saved_only)
|
||||
.show_deleted_and_removed(Some(false))
|
||||
.community_id(community_id)
|
||||
.page(page)
|
||||
.limit(limit);
|
||||
|
||||
// If its saved only, you don't care what creator it was
|
||||
// Or, if its not saved, then you only want it for that specific creator
|
||||
let comments = if !saved_only.unwrap_or(false) {
|
||||
comments_query
|
||||
.creator_id(Some(person_details_id))
|
||||
.build()
|
||||
.list()
|
||||
} else {
|
||||
comments_query.build().list()
|
||||
}
|
||||
.await?;
|
||||
|
||||
let moderates = CommunityModeratorView::for_person(context.pool(), person_details_id).await?;
|
||||
|
||||
// Return the jwt
|
||||
Ok(Json(GetPersonDetailsResponse {
|
||||
person_view,
|
||||
moderates,
|
||||
comments,
|
||||
posts,
|
||||
}))
|
||||
}
|
||||
|
|
|
@ -1,8 +1,6 @@
|
|||
use crate::{
|
||||
api::PerformApub,
|
||||
fetcher::search::{search_query_to_object_id, SearchableObjects},
|
||||
};
|
||||
use crate::fetcher::search::{search_query_to_object_id, SearchableObjects};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use diesel::NotFound;
|
||||
use lemmy_api_common::{
|
||||
context::LemmyContext,
|
||||
|
@ -12,38 +10,32 @@ use lemmy_api_common::{
|
|||
use lemmy_db_schema::{newtypes::PersonId, source::local_site::LocalSite, utils::DbPool};
|
||||
use lemmy_db_views::structs::{CommentView, PostView};
|
||||
use lemmy_db_views_actor::structs::{CommunityView, PersonView};
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for ResolveObject {
|
||||
type Response = ResolveObjectResponse;
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn resolve_object(
|
||||
data: Json<ResolveObject>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<ResolveObjectResponse>, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
let person_id = local_user_view.person.id;
|
||||
check_private_instance(&Some(local_user_view), &local_site)?;
|
||||
|
||||
#[tracing::instrument(skip(context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<ResolveObjectResponse, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt(&self.auth, context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
let person_id = local_user_view.person.id;
|
||||
check_private_instance(&Some(local_user_view), &local_site)?;
|
||||
|
||||
let res = search_query_to_object_id(&self.q, context)
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_object"))?;
|
||||
convert_response(res, person_id, context.pool())
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_object"))
|
||||
}
|
||||
let res = search_query_to_object_id(&data.q, &context)
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_object"))?;
|
||||
convert_response(res, person_id, context.pool())
|
||||
.await
|
||||
.map_err(|e| e.with_message("couldnt_find_object"))
|
||||
}
|
||||
|
||||
async fn convert_response(
|
||||
object: SearchableObjects,
|
||||
user_id: PersonId,
|
||||
pool: &DbPool,
|
||||
) -> Result<ResolveObjectResponse, LemmyError> {
|
||||
) -> Result<Json<ResolveObjectResponse>, LemmyError> {
|
||||
use SearchableObjects::*;
|
||||
let removed_or_deleted;
|
||||
let mut res = ResolveObjectResponse::default();
|
||||
|
@ -69,5 +61,5 @@ async fn convert_response(
|
|||
if removed_or_deleted {
|
||||
return Err(NotFound {}.into());
|
||||
}
|
||||
Ok(res)
|
||||
Ok(Json(res))
|
||||
}
|
||||
|
|
|
@ -1,9 +1,6 @@
|
|||
use crate::{
|
||||
api::PerformApub,
|
||||
fetcher::resolve_actor_identifier,
|
||||
objects::community::ApubCommunity,
|
||||
};
|
||||
use crate::{fetcher::resolve_actor_identifier, objects::community::ApubCommunity};
|
||||
use activitypub_federation::config::Data;
|
||||
use actix_web::web::Json;
|
||||
use lemmy_api_common::{
|
||||
context::LemmyContext,
|
||||
site::{Search, SearchResponse},
|
||||
|
@ -16,86 +13,145 @@ use lemmy_db_schema::{
|
|||
};
|
||||
use lemmy_db_views::{comment_view::CommentQuery, post_view::PostQuery};
|
||||
use lemmy_db_views_actor::{community_view::CommunityQuery, person_view::PersonQuery};
|
||||
use lemmy_utils::{error::LemmyError, ConnectionId};
|
||||
use lemmy_utils::error::LemmyError;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PerformApub for Search {
|
||||
type Response = SearchResponse;
|
||||
#[tracing::instrument(skip(context))]
|
||||
pub async fn search(
|
||||
data: Json<Search>,
|
||||
context: Data<LemmyContext>,
|
||||
) -> Result<Json<SearchResponse>, LemmyError> {
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret()).await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
|
||||
#[tracing::instrument(skip(context, _websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
_websocket_id: Option<ConnectionId>,
|
||||
) -> Result<SearchResponse, LemmyError> {
|
||||
let data: &Search = self;
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt_opt(data.auth.as_ref(), context.pool(), context.secret())
|
||||
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
|
||||
|
||||
let mut posts = Vec::new();
|
||||
let mut comments = Vec::new();
|
||||
let mut communities = Vec::new();
|
||||
let mut users = Vec::new();
|
||||
|
||||
// TODO no clean / non-nsfw searching rn
|
||||
|
||||
let q = data.q.clone();
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let sort = data.sort;
|
||||
let listing_type = data.listing_type;
|
||||
let search_type = data.type_.unwrap_or(SearchType::All);
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, &context, &local_user_view, false)
|
||||
.await
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let creator_id = data.creator_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
match search_type {
|
||||
SearchType::Posts => {
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.search_term(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
let local_site = LocalSite::read(context.pool()).await?;
|
||||
}
|
||||
SearchType::Comments => {
|
||||
comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::Communities => {
|
||||
communities = CommunityQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.local_user(local_user.as_ref())
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::Users => {
|
||||
users = PersonQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.search_term(Some(q))
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::All => {
|
||||
// If the community or creator is included, dont search communities or users
|
||||
let community_or_creator_included =
|
||||
data.community_id.is_some() || data.community_name.is_some() || data.creator_id.is_some();
|
||||
|
||||
check_private_instance(&local_user_view, &local_site)?;
|
||||
let local_user_ = local_user.clone();
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user_.as_ref())
|
||||
.search_term(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
|
||||
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
|
||||
let q = data.q.clone();
|
||||
|
||||
let mut posts = Vec::new();
|
||||
let mut comments = Vec::new();
|
||||
let mut communities = Vec::new();
|
||||
let mut users = Vec::new();
|
||||
let local_user_ = local_user.clone();
|
||||
comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user_.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
|
||||
// TODO no clean / non-nsfw searching rn
|
||||
let q = data.q.clone();
|
||||
|
||||
let q = data.q.clone();
|
||||
let page = data.page;
|
||||
let limit = data.limit;
|
||||
let sort = data.sort;
|
||||
let listing_type = data.listing_type;
|
||||
let search_type = data.type_.unwrap_or(SearchType::All);
|
||||
let community_id = if let Some(name) = &data.community_name {
|
||||
resolve_actor_identifier::<ApubCommunity, Community>(name, context, &local_user_view, false)
|
||||
.await
|
||||
.ok()
|
||||
.map(|c| c.id)
|
||||
} else {
|
||||
data.community_id
|
||||
};
|
||||
let creator_id = data.creator_id;
|
||||
let local_user = local_user_view.map(|l| l.local_user);
|
||||
match search_type {
|
||||
SearchType::Posts => {
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.search_term(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::Comments => {
|
||||
comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::Communities => {
|
||||
communities = CommunityQuery::builder()
|
||||
communities = if community_or_creator_included {
|
||||
vec![]
|
||||
} else {
|
||||
CommunityQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
|
@ -106,10 +162,15 @@ impl PerformApub for Search {
|
|||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::Users => {
|
||||
users = PersonQuery::builder()
|
||||
.await?
|
||||
};
|
||||
|
||||
let q = data.q.clone();
|
||||
|
||||
users = if community_or_creator_included {
|
||||
vec![]
|
||||
} else {
|
||||
PersonQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.search_term(Some(q))
|
||||
|
@ -117,105 +178,32 @@ impl PerformApub for Search {
|
|||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
SearchType::All => {
|
||||
// If the community or creator is included, dont search communities or users
|
||||
let community_or_creator_included =
|
||||
data.community_id.is_some() || data.community_name.is_some() || data.creator_id.is_some();
|
||||
.await?
|
||||
};
|
||||
}
|
||||
SearchType::Url => {
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.url_search(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
};
|
||||
|
||||
let local_user_ = local_user.clone();
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user_.as_ref())
|
||||
.search_term(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
|
||||
let q = data.q.clone();
|
||||
|
||||
let local_user_ = local_user.clone();
|
||||
comments = CommentQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort.map(post_to_comment_sort_type))
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.local_user(local_user_.as_ref())
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
|
||||
let q = data.q.clone();
|
||||
|
||||
communities = if community_or_creator_included {
|
||||
vec![]
|
||||
} else {
|
||||
CommunityQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.search_term(Some(q))
|
||||
.local_user(local_user.as_ref())
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?
|
||||
};
|
||||
|
||||
let q = data.q.clone();
|
||||
|
||||
users = if community_or_creator_included {
|
||||
vec![]
|
||||
} else {
|
||||
PersonQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.search_term(Some(q))
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?
|
||||
};
|
||||
}
|
||||
SearchType::Url => {
|
||||
posts = PostQuery::builder()
|
||||
.pool(context.pool())
|
||||
.sort(sort)
|
||||
.listing_type(listing_type)
|
||||
.community_id(community_id)
|
||||
.creator_id(creator_id)
|
||||
.url_search(Some(q))
|
||||
.is_mod_or_admin(is_admin)
|
||||
.page(page)
|
||||
.limit(limit)
|
||||
.build()
|
||||
.list()
|
||||
.await?;
|
||||
}
|
||||
};
|
||||
|
||||
// Return the jwt
|
||||
Ok(SearchResponse {
|
||||
type_: search_type,
|
||||
comments,
|
||||
posts,
|
||||
communities,
|
||||
users,
|
||||
})
|
||||
}
|
||||
// Return the jwt
|
||||
Ok(Json(SearchResponse {
|
||||
type_: search_type,
|
||||
comments,
|
||||
posts,
|
||||
communities,
|
||||
users,
|
||||
}))
|
||||
}
|
||||
|
|
|
@ -18,7 +18,7 @@ lemmy_db_views_actor = { workspace = true }
|
|||
lemmy_db_schema = { workspace = true }
|
||||
lemmy_api_common = { workspace = true, features = ["full"] }
|
||||
activitypub_federation = { workspace = true }
|
||||
actix-web = { workspace = true }
|
||||
actix-web = { workspace = true, features = ["cookies"] }
|
||||
anyhow = { workspace = true }
|
||||
chrono = { workspace = true }
|
||||
futures = { workspace = true }
|
||||
|
|
|
@ -1,4 +1,3 @@
|
|||
use crate::api_routes_websocket::websocket;
|
||||
use actix_web::{guard, web, Error, HttpResponse, Result};
|
||||
use lemmy_api::Perform;
|
||||
use lemmy_api_common::{
|
||||
|
@ -10,7 +9,6 @@ use lemmy_api_common::{
|
|||
DistinguishComment,
|
||||
EditComment,
|
||||
GetComment,
|
||||
GetComments,
|
||||
ListCommentReports,
|
||||
RemoveComment,
|
||||
ResolveCommentReport,
|
||||
|
@ -24,7 +22,6 @@ use lemmy_api_common::{
|
|||
DeleteCommunity,
|
||||
EditCommunity,
|
||||
FollowCommunity,
|
||||
GetCommunity,
|
||||
HideCommunity,
|
||||
ListCommunities,
|
||||
RemoveCommunity,
|
||||
|
@ -40,7 +37,6 @@ use lemmy_api_common::{
|
|||
DeleteAccount,
|
||||
GetBannedPersons,
|
||||
GetCaptcha,
|
||||
GetPersonDetails,
|
||||
GetPersonMentions,
|
||||
GetReplies,
|
||||
GetReportCount,
|
||||
|
@ -63,7 +59,6 @@ use lemmy_api_common::{
|
|||
EditPost,
|
||||
FeaturePost,
|
||||
GetPost,
|
||||
GetPosts,
|
||||
GetSiteMetadata,
|
||||
ListPostReports,
|
||||
LockPost,
|
||||
|
@ -96,21 +91,30 @@ use lemmy_api_common::{
|
|||
PurgeCommunity,
|
||||
PurgePerson,
|
||||
PurgePost,
|
||||
ResolveObject,
|
||||
Search,
|
||||
},
|
||||
websocket::structs::{CommunityJoin, ModJoin, PostJoin, UserJoin},
|
||||
};
|
||||
use lemmy_api_crud::PerformCrud;
|
||||
use lemmy_apub::{api::PerformApub, SendActivity};
|
||||
use lemmy_apub::{
|
||||
api::{
|
||||
list_comments::list_comments,
|
||||
list_posts::list_posts,
|
||||
read_community::read_community,
|
||||
read_person::read_person,
|
||||
resolve_object::resolve_object,
|
||||
search::search,
|
||||
},
|
||||
SendActivity,
|
||||
};
|
||||
use lemmy_utils::rate_limit::RateLimitCell;
|
||||
use serde::Deserialize;
|
||||
|
||||
pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
||||
//todo!();
|
||||
// TODO: still need to SendActivity::send_activity for api handlers in some way
|
||||
|
||||
cfg.service(
|
||||
web::scope("/api/v3")
|
||||
// Websocket
|
||||
.service(web::resource("/ws").to(websocket))
|
||||
// Site
|
||||
.service(
|
||||
web::scope("/site")
|
||||
|
@ -128,12 +132,12 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
|||
.service(
|
||||
web::resource("/search")
|
||||
.wrap(rate_limit.search())
|
||||
.route(web::get().to(route_get_apub::<Search>)),
|
||||
.route(web::get().to(search)),
|
||||
)
|
||||
.service(
|
||||
web::resource("/resolve_object")
|
||||
.wrap(rate_limit.message())
|
||||
.route(web::get().to(route_get_apub::<ResolveObject>)),
|
||||
.route(web::get().to(resolve_object)),
|
||||
)
|
||||
// Community
|
||||
.service(
|
||||
|
@ -145,7 +149,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
|||
.service(
|
||||
web::scope("/community")
|
||||
.wrap(rate_limit.message())
|
||||
.route("", web::get().to(route_get_apub::<GetCommunity>))
|
||||
.route("", web::get().to(read_community))
|
||||
.route("", web::put().to(route_post_crud::<EditCommunity>))
|
||||
.route("/hide", web::put().to(route_post::<HideCommunity>))
|
||||
.route("/list", web::get().to(route_get_crud::<ListCommunities>))
|
||||
|
@ -192,7 +196,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
|||
)
|
||||
.route("/lock", web::post().to(route_post::<LockPost>))
|
||||
.route("/feature", web::post().to(route_post::<FeaturePost>))
|
||||
.route("/list", web::get().to(route_get_apub::<GetPosts>))
|
||||
.route("/list", web::get().to(list_posts))
|
||||
.route("/like", web::post().to(route_post::<CreatePostLike>))
|
||||
.route("/save", web::put().to(route_post::<SavePost>))
|
||||
.route("/join", web::post().to(route_post::<PostJoin>))
|
||||
|
@ -232,7 +236,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
|||
)
|
||||
.route("/like", web::post().to(route_post::<CreateCommentLike>))
|
||||
.route("/save", web::put().to(route_post::<SaveComment>))
|
||||
.route("/list", web::get().to(route_get_apub::<GetComments>))
|
||||
.route("/list", web::get().to(list_comments))
|
||||
.route("/report", web::post().to(route_post::<CreateCommentReport>))
|
||||
.route(
|
||||
"/report/resolve",
|
||||
|
@ -290,7 +294,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
|
|||
.service(
|
||||
web::scope("/user")
|
||||
.wrap(rate_limit.message())
|
||||
.route("", web::get().to(route_get_apub::<GetPersonDetails>))
|
||||
.route("", web::get().to(read_person))
|
||||
.route("/mention", web::get().to(route_get::<GetPersonMentions>))
|
||||
.route(
|
||||
"/mention/mark_as_read",
|
||||
|
@ -407,23 +411,6 @@ where
|
|||
perform::<Data>(data.0, context, apub_data).await
|
||||
}
|
||||
|
||||
async fn route_get_apub<'a, Data>(
|
||||
data: web::Query<Data>,
|
||||
context: activitypub_federation::config::Data<LemmyContext>,
|
||||
) -> Result<HttpResponse, Error>
|
||||
where
|
||||
Data: PerformApub
|
||||
+ SendActivity<Response = <Data as PerformApub>::Response>
|
||||
+ Clone
|
||||
+ Deserialize<'a>
|
||||
+ Send
|
||||
+ 'static,
|
||||
{
|
||||
let res = data.perform(&context, None).await?;
|
||||
SendActivity::send_activity(&data.0, &res, &context).await?;
|
||||
Ok(HttpResponse::Ok().json(res))
|
||||
}
|
||||
|
||||
async fn route_post<'a, Data>(
|
||||
data: web::Json<Data>,
|
||||
context: web::Data<LemmyContext>,
|
|
@ -1,725 +0,0 @@
|
|||
use activitypub_federation::config::Data as ContextData;
|
||||
use actix::{
|
||||
fut,
|
||||
Actor,
|
||||
ActorContext,
|
||||
ActorFutureExt,
|
||||
AsyncContext,
|
||||
ContextFutureSpawner,
|
||||
Handler,
|
||||
Running,
|
||||
StreamHandler,
|
||||
WrapFuture,
|
||||
};
|
||||
use actix_web::{web, Error, HttpRequest, HttpResponse};
|
||||
use actix_web_actors::ws;
|
||||
use lemmy_api::Perform;
|
||||
use lemmy_api_common::{
|
||||
comment::{
|
||||
CreateComment,
|
||||
CreateCommentLike,
|
||||
CreateCommentReport,
|
||||
DeleteComment,
|
||||
DistinguishComment,
|
||||
EditComment,
|
||||
GetComment,
|
||||
GetComments,
|
||||
ListCommentReports,
|
||||
RemoveComment,
|
||||
ResolveCommentReport,
|
||||
SaveComment,
|
||||
},
|
||||
community::{
|
||||
AddModToCommunity,
|
||||
BanFromCommunity,
|
||||
BlockCommunity,
|
||||
CreateCommunity,
|
||||
DeleteCommunity,
|
||||
EditCommunity,
|
||||
FollowCommunity,
|
||||
GetCommunity,
|
||||
ListCommunities,
|
||||
RemoveCommunity,
|
||||
TransferCommunity,
|
||||
},
|
||||
context::LemmyContext,
|
||||
custom_emoji::{CreateCustomEmoji, DeleteCustomEmoji, EditCustomEmoji},
|
||||
person::{
|
||||
AddAdmin,
|
||||
BanPerson,
|
||||
BlockPerson,
|
||||
ChangePassword,
|
||||
DeleteAccount,
|
||||
GetBannedPersons,
|
||||
GetCaptcha,
|
||||
GetPersonDetails,
|
||||
GetPersonMentions,
|
||||
GetReplies,
|
||||
GetReportCount,
|
||||
GetUnreadCount,
|
||||
Login,
|
||||
MarkAllAsRead,
|
||||
MarkCommentReplyAsRead,
|
||||
MarkPersonMentionAsRead,
|
||||
PasswordChangeAfterReset,
|
||||
PasswordReset,
|
||||
Register,
|
||||
SaveUserSettings,
|
||||
VerifyEmail,
|
||||
},
|
||||
post::{
|
||||
CreatePost,
|
||||
CreatePostLike,
|
||||
CreatePostReport,
|
||||
DeletePost,
|
||||
EditPost,
|
||||
FeaturePost,
|
||||
GetPost,
|
||||
GetPosts,
|
||||
GetSiteMetadata,
|
||||
ListPostReports,
|
||||
LockPost,
|
||||
MarkPostAsRead,
|
||||
RemovePost,
|
||||
ResolvePostReport,
|
||||
SavePost,
|
||||
},
|
||||
private_message::{
|
||||
CreatePrivateMessage,
|
||||
CreatePrivateMessageReport,
|
||||
DeletePrivateMessage,
|
||||
EditPrivateMessage,
|
||||
GetPrivateMessages,
|
||||
ListPrivateMessageReports,
|
||||
MarkPrivateMessageAsRead,
|
||||
ResolvePrivateMessageReport,
|
||||
},
|
||||
site::{
|
||||
ApproveRegistrationApplication,
|
||||
CreateSite,
|
||||
EditSite,
|
||||
GetFederatedInstances,
|
||||
GetModlog,
|
||||
GetSite,
|
||||
GetUnreadRegistrationApplicationCount,
|
||||
LeaveAdmin,
|
||||
ListRegistrationApplications,
|
||||
PurgeComment,
|
||||
PurgeCommunity,
|
||||
PurgePerson,
|
||||
PurgePost,
|
||||
ResolveObject,
|
||||
Search,
|
||||
},
|
||||
websocket::{
|
||||
handlers::{
|
||||
connect::{Connect, Disconnect},
|
||||
WsMessage,
|
||||
},
|
||||
serialize_websocket_message,
|
||||
structs::{CommunityJoin, ModJoin, PostJoin, UserJoin},
|
||||
UserOperation,
|
||||
UserOperationApub,
|
||||
UserOperationCrud,
|
||||
},
|
||||
};
|
||||
use lemmy_api_crud::PerformCrud;
|
||||
use lemmy_apub::{api::PerformApub, SendActivity};
|
||||
use lemmy_utils::{error::LemmyError, rate_limit::RateLimitCell, ConnectionId, IpAddr};
|
||||
use serde::Deserialize;
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
ops::Deref,
|
||||
result,
|
||||
str::FromStr,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use tracing::{debug, error};
|
||||
|
||||
/// How often heartbeat pings are sent
|
||||
const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(25);
|
||||
|
||||
/// How long before lack of client response causes a timeout
|
||||
const CLIENT_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
|
||||
pub struct WsChatSession {
|
||||
/// unique session id
|
||||
pub id: ConnectionId,
|
||||
|
||||
pub ip: IpAddr,
|
||||
|
||||
/// Client must send ping at least once per 10 seconds (CLIENT_TIMEOUT),
|
||||
/// otherwise we drop connection.
|
||||
pub hb: Instant,
|
||||
|
||||
/// The context data
|
||||
apub_data: ContextData<LemmyContext>,
|
||||
}
|
||||
|
||||
pub async fn websocket(
|
||||
req: HttpRequest,
|
||||
body: web::Payload,
|
||||
rate_limiter: web::Data<RateLimitCell>,
|
||||
apub_data: ContextData<LemmyContext>,
|
||||
) -> Result<HttpResponse, Error> {
|
||||
let client_ip = IpAddr(
|
||||
req
|
||||
.connection_info()
|
||||
.realip_remote_addr()
|
||||
.unwrap_or("blank_ip")
|
||||
.to_string(),
|
||||
);
|
||||
|
||||
let check = rate_limiter.message().check(client_ip.clone());
|
||||
if !check {
|
||||
debug!(
|
||||
"Websocket join with IP: {} has been rate limited.",
|
||||
&client_ip
|
||||
);
|
||||
return Ok(HttpResponse::TooManyRequests().finish());
|
||||
}
|
||||
|
||||
ws::start(
|
||||
WsChatSession {
|
||||
id: 0,
|
||||
ip: client_ip,
|
||||
hb: Instant::now(),
|
||||
apub_data,
|
||||
},
|
||||
&req,
|
||||
body,
|
||||
)
|
||||
}
|
||||
|
||||
/// helper method that sends ping to client every few seconds (HEARTBEAT_INTERVAL).
|
||||
///
|
||||
/// also this method checks heartbeats from client
|
||||
fn hb(ctx: &mut ws::WebsocketContext<WsChatSession>) {
|
||||
ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
|
||||
// check client heartbeats
|
||||
if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
|
||||
// heartbeat timed out
|
||||
|
||||
// notify chat server
|
||||
act
|
||||
.apub_data
|
||||
.chat_server()
|
||||
.do_send(Disconnect { id: act.id });
|
||||
|
||||
// stop actor
|
||||
ctx.stop();
|
||||
|
||||
// don't try to send a ping
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.ping(b"");
|
||||
});
|
||||
}
|
||||
|
||||
impl Actor for WsChatSession {
|
||||
type Context = ws::WebsocketContext<Self>;
|
||||
|
||||
/// Method is called on actor start.
|
||||
/// We register ws session with ChatServer
|
||||
fn started(&mut self, ctx: &mut Self::Context) {
|
||||
// we'll start heartbeat process on session start.
|
||||
hb(ctx);
|
||||
|
||||
// register self in chat server. `AsyncContext::wait` register
|
||||
// future within context, but context waits until this future resolves
|
||||
// before processing any other events.
|
||||
// HttpContext::state() is instance of WsChatSessionState, state is shared
|
||||
// across all routes within application
|
||||
let addr = ctx.address();
|
||||
self
|
||||
.apub_data
|
||||
.chat_server()
|
||||
.send(Connect {
|
||||
addr: addr.recipient(),
|
||||
})
|
||||
.into_actor(self)
|
||||
.then(|res, act, ctx| {
|
||||
match res {
|
||||
Ok(res) => act.id = res,
|
||||
// something is wrong with chat server
|
||||
_ => ctx.stop(),
|
||||
}
|
||||
fut::ready(())
|
||||
})
|
||||
.wait(ctx);
|
||||
}
|
||||
fn stopping(&mut self, _: &mut Self::Context) -> Running {
|
||||
// notify chat server
|
||||
self
|
||||
.apub_data
|
||||
.chat_server()
|
||||
.do_send(Disconnect { id: self.id });
|
||||
Running::Stop
|
||||
}
|
||||
}
|
||||
|
||||
/// Handle messages from chat server, we simply send it to peer websocket
|
||||
impl Handler<WsMessage> for WsChatSession {
|
||||
type Result = ();
|
||||
|
||||
fn handle(&mut self, msg: WsMessage, ctx: &mut Self::Context) {
|
||||
ctx.text(msg.0);
|
||||
}
|
||||
}
|
||||
|
||||
/// WebSocket message handler
|
||||
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WsChatSession {
|
||||
fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
|
||||
let msg = match msg {
|
||||
Err(_) => {
|
||||
ctx.stop();
|
||||
return;
|
||||
}
|
||||
Ok(msg) => msg,
|
||||
};
|
||||
|
||||
match msg {
|
||||
ws::Message::Ping(msg) => {
|
||||
self.hb = Instant::now();
|
||||
ctx.pong(&msg);
|
||||
}
|
||||
ws::Message::Pong(_) => {
|
||||
self.hb = Instant::now();
|
||||
}
|
||||
ws::Message::Text(text) => {
|
||||
let ip_clone = self.ip.clone();
|
||||
let id_clone = self.id.to_owned();
|
||||
let context_clone = self.apub_data.reset_request_count();
|
||||
|
||||
let fut = Box::pin(async move {
|
||||
let msg = text.trim().to_string();
|
||||
parse_json_message(msg, ip_clone, id_clone, context_clone).await
|
||||
});
|
||||
fut
|
||||
.into_actor(self)
|
||||
.then(|res, _, ctx| {
|
||||
match res {
|
||||
Ok(res) => ctx.text(res),
|
||||
Err(e) => error!("{}", &e),
|
||||
}
|
||||
actix::fut::ready(())
|
||||
})
|
||||
.spawn(ctx);
|
||||
}
|
||||
ws::Message::Binary(_) => println!("Unexpected binary"),
|
||||
ws::Message::Close(reason) => {
|
||||
ctx.close(reason);
|
||||
ctx.stop();
|
||||
}
|
||||
ws::Message::Continuation(_) => {
|
||||
ctx.stop();
|
||||
}
|
||||
ws::Message::Nop => (),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Entry point for our websocket route
|
||||
async fn parse_json_message(
|
||||
msg: String,
|
||||
ip: IpAddr,
|
||||
connection_id: ConnectionId,
|
||||
context: ContextData<LemmyContext>,
|
||||
) -> Result<String, LemmyError> {
|
||||
let rate_limiter = context.settings_updated_channel();
|
||||
let json: Value = serde_json::from_str(&msg)?;
|
||||
let data = json
|
||||
.get("data")
|
||||
.cloned()
|
||||
.ok_or_else(|| LemmyError::from_message("missing data"))?;
|
||||
|
||||
let missing_op_err = || LemmyError::from_message("missing op");
|
||||
|
||||
let op = json
|
||||
.get("op")
|
||||
.ok_or_else(missing_op_err)?
|
||||
.as_str()
|
||||
.ok_or_else(missing_op_err)?;
|
||||
|
||||
// check if api call passes the rate limit, and generate future for later execution
|
||||
if let Ok(user_operation_crud) = UserOperationCrud::from_str(op) {
|
||||
let passed = match user_operation_crud {
|
||||
UserOperationCrud::Register => rate_limiter.register().check(ip),
|
||||
UserOperationCrud::CreatePost => rate_limiter.post().check(ip),
|
||||
UserOperationCrud::CreateCommunity => rate_limiter.register().check(ip),
|
||||
UserOperationCrud::CreateComment => rate_limiter.comment().check(ip),
|
||||
_ => rate_limiter.message().check(ip),
|
||||
};
|
||||
check_rate_limit_passed(passed)?;
|
||||
match_websocket_operation_crud(context, connection_id, user_operation_crud, data).await
|
||||
} else if let Ok(user_operation) = UserOperation::from_str(op) {
|
||||
let passed = match user_operation {
|
||||
UserOperation::GetCaptcha => rate_limiter.post().check(ip),
|
||||
_ => rate_limiter.message().check(ip),
|
||||
};
|
||||
check_rate_limit_passed(passed)?;
|
||||
match_websocket_operation(context, connection_id, user_operation, data).await
|
||||
} else {
|
||||
let user_operation = UserOperationApub::from_str(op)?;
|
||||
let passed = match user_operation {
|
||||
UserOperationApub::Search => rate_limiter.search().check(ip),
|
||||
_ => rate_limiter.message().check(ip),
|
||||
};
|
||||
check_rate_limit_passed(passed)?;
|
||||
match_websocket_operation_apub(context, connection_id, user_operation, data).await
|
||||
}
|
||||
}
|
||||
|
||||
fn check_rate_limit_passed(passed: bool) -> Result<(), LemmyError> {
|
||||
if passed {
|
||||
Ok(())
|
||||
} else {
|
||||
// if rate limit was hit, respond with message
|
||||
Err(LemmyError::from_message("rate_limit_error"))
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn match_websocket_operation_crud(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperationCrud,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError> {
|
||||
match op {
|
||||
// User ops
|
||||
UserOperationCrud::Register => {
|
||||
do_websocket_operation_crud::<Register>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeleteAccount => {
|
||||
do_websocket_operation_crud::<DeleteAccount>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Private Message ops
|
||||
UserOperationCrud::CreatePrivateMessage => {
|
||||
do_websocket_operation_crud::<CreatePrivateMessage>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditPrivateMessage => {
|
||||
do_websocket_operation_crud::<EditPrivateMessage>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeletePrivateMessage => {
|
||||
do_websocket_operation_crud::<DeletePrivateMessage>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::GetPrivateMessages => {
|
||||
do_websocket_operation_crud::<GetPrivateMessages>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Site ops
|
||||
UserOperationCrud::CreateSite => {
|
||||
do_websocket_operation_crud::<CreateSite>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditSite => {
|
||||
do_websocket_operation_crud::<EditSite>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::GetSite => {
|
||||
do_websocket_operation_crud::<GetSite>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Community ops
|
||||
UserOperationCrud::ListCommunities => {
|
||||
do_websocket_operation_crud::<ListCommunities>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::CreateCommunity => {
|
||||
do_websocket_operation_crud::<CreateCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditCommunity => {
|
||||
do_websocket_operation_crud::<EditCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeleteCommunity => {
|
||||
do_websocket_operation_crud::<DeleteCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::RemoveCommunity => {
|
||||
do_websocket_operation_crud::<RemoveCommunity>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Post ops
|
||||
UserOperationCrud::CreatePost => {
|
||||
do_websocket_operation_crud::<CreatePost>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::GetPost => {
|
||||
do_websocket_operation_crud::<GetPost>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditPost => {
|
||||
do_websocket_operation_crud::<EditPost>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeletePost => {
|
||||
do_websocket_operation_crud::<DeletePost>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::RemovePost => {
|
||||
do_websocket_operation_crud::<RemovePost>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Comment ops
|
||||
UserOperationCrud::CreateComment => {
|
||||
do_websocket_operation_crud::<CreateComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditComment => {
|
||||
do_websocket_operation_crud::<EditComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeleteComment => {
|
||||
do_websocket_operation_crud::<DeleteComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::RemoveComment => {
|
||||
do_websocket_operation_crud::<RemoveComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::GetComment => {
|
||||
do_websocket_operation_crud::<GetComment>(context, id, op, data).await
|
||||
}
|
||||
// Emojis
|
||||
UserOperationCrud::CreateCustomEmoji => {
|
||||
do_websocket_operation_crud::<CreateCustomEmoji>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::EditCustomEmoji => {
|
||||
do_websocket_operation_crud::<EditCustomEmoji>(context, id, op, data).await
|
||||
}
|
||||
UserOperationCrud::DeleteCustomEmoji => {
|
||||
do_websocket_operation_crud::<DeleteCustomEmoji>(context, id, op, data).await
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_websocket_operation_crud<'a, 'b, Data>(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperationCrud,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError>
|
||||
where
|
||||
Data: PerformCrud + SendActivity<Response = <Data as PerformCrud>::Response> + Send,
|
||||
for<'de> Data: Deserialize<'de>,
|
||||
{
|
||||
let parsed_data: Data = serde_json::from_value(data)?;
|
||||
let res = parsed_data
|
||||
.perform(&web::Data::new(context.deref().clone()), Some(id))
|
||||
.await?;
|
||||
SendActivity::send_activity(&parsed_data, &res, &context).await?;
|
||||
serialize_websocket_message(&op, &res)
|
||||
}
|
||||
|
||||
pub async fn match_websocket_operation_apub(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperationApub,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError> {
|
||||
match op {
|
||||
UserOperationApub::GetPersonDetails => {
|
||||
do_websocket_operation_apub::<GetPersonDetails>(context, id, op, data).await
|
||||
}
|
||||
UserOperationApub::GetCommunity => {
|
||||
do_websocket_operation_apub::<GetCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperationApub::GetComments => {
|
||||
do_websocket_operation_apub::<GetComments>(context, id, op, data).await
|
||||
}
|
||||
UserOperationApub::GetPosts => {
|
||||
do_websocket_operation_apub::<GetPosts>(context, id, op, data).await
|
||||
}
|
||||
UserOperationApub::ResolveObject => {
|
||||
do_websocket_operation_apub::<ResolveObject>(context, id, op, data).await
|
||||
}
|
||||
UserOperationApub::Search => do_websocket_operation_apub::<Search>(context, id, op, data).await,
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_websocket_operation_apub<'a, 'b, Data>(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperationApub,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError>
|
||||
where
|
||||
Data: PerformApub + SendActivity<Response = <Data as PerformApub>::Response> + Send,
|
||||
for<'de> Data: Deserialize<'de>,
|
||||
{
|
||||
let parsed_data: Data = serde_json::from_value(data)?;
|
||||
let res = parsed_data.perform(&context, Some(id)).await?;
|
||||
SendActivity::send_activity(&parsed_data, &res, &context).await?;
|
||||
serialize_websocket_message(&op, &res)
|
||||
}
|
||||
|
||||
pub async fn match_websocket_operation(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperation,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError> {
|
||||
match op {
|
||||
// User ops
|
||||
UserOperation::Login => do_websocket_operation::<Login>(context, id, op, data).await,
|
||||
UserOperation::GetCaptcha => do_websocket_operation::<GetCaptcha>(context, id, op, data).await,
|
||||
UserOperation::GetReplies => do_websocket_operation::<GetReplies>(context, id, op, data).await,
|
||||
UserOperation::AddAdmin => do_websocket_operation::<AddAdmin>(context, id, op, data).await,
|
||||
UserOperation::GetUnreadRegistrationApplicationCount => {
|
||||
do_websocket_operation::<GetUnreadRegistrationApplicationCount>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ListRegistrationApplications => {
|
||||
do_websocket_operation::<ListRegistrationApplications>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ApproveRegistrationApplication => {
|
||||
do_websocket_operation::<ApproveRegistrationApplication>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::BanPerson => do_websocket_operation::<BanPerson>(context, id, op, data).await,
|
||||
UserOperation::GetBannedPersons => {
|
||||
do_websocket_operation::<GetBannedPersons>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::BlockPerson => {
|
||||
do_websocket_operation::<BlockPerson>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::GetPersonMentions => {
|
||||
do_websocket_operation::<GetPersonMentions>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::MarkPersonMentionAsRead => {
|
||||
do_websocket_operation::<MarkPersonMentionAsRead>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::MarkCommentReplyAsRead => {
|
||||
do_websocket_operation::<MarkCommentReplyAsRead>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::MarkAllAsRead => {
|
||||
do_websocket_operation::<MarkAllAsRead>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::PasswordReset => {
|
||||
do_websocket_operation::<PasswordReset>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::PasswordChange => {
|
||||
do_websocket_operation::<PasswordChangeAfterReset>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::UserJoin => do_websocket_operation::<UserJoin>(context, id, op, data).await,
|
||||
UserOperation::PostJoin => do_websocket_operation::<PostJoin>(context, id, op, data).await,
|
||||
UserOperation::CommunityJoin => {
|
||||
do_websocket_operation::<CommunityJoin>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ModJoin => do_websocket_operation::<ModJoin>(context, id, op, data).await,
|
||||
UserOperation::SaveUserSettings => {
|
||||
do_websocket_operation::<SaveUserSettings>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ChangePassword => {
|
||||
do_websocket_operation::<ChangePassword>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::GetReportCount => {
|
||||
do_websocket_operation::<GetReportCount>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::GetUnreadCount => {
|
||||
do_websocket_operation::<GetUnreadCount>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::VerifyEmail => {
|
||||
do_websocket_operation::<VerifyEmail>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Private Message ops
|
||||
UserOperation::MarkPrivateMessageAsRead => {
|
||||
do_websocket_operation::<MarkPrivateMessageAsRead>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::CreatePrivateMessageReport => {
|
||||
do_websocket_operation::<CreatePrivateMessageReport>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ResolvePrivateMessageReport => {
|
||||
do_websocket_operation::<ResolvePrivateMessageReport>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ListPrivateMessageReports => {
|
||||
do_websocket_operation::<ListPrivateMessageReports>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Site ops
|
||||
UserOperation::GetModlog => do_websocket_operation::<GetModlog>(context, id, op, data).await,
|
||||
UserOperation::PurgePerson => {
|
||||
do_websocket_operation::<PurgePerson>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::PurgeCommunity => {
|
||||
do_websocket_operation::<PurgeCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::PurgePost => do_websocket_operation::<PurgePost>(context, id, op, data).await,
|
||||
UserOperation::PurgeComment => {
|
||||
do_websocket_operation::<PurgeComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::TransferCommunity => {
|
||||
do_websocket_operation::<TransferCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::LeaveAdmin => do_websocket_operation::<LeaveAdmin>(context, id, op, data).await,
|
||||
UserOperation::GetFederatedInstances => {
|
||||
do_websocket_operation::<GetFederatedInstances>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Community ops
|
||||
UserOperation::FollowCommunity => {
|
||||
do_websocket_operation::<FollowCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::BlockCommunity => {
|
||||
do_websocket_operation::<BlockCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::BanFromCommunity => {
|
||||
do_websocket_operation::<BanFromCommunity>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::AddModToCommunity => {
|
||||
do_websocket_operation::<AddModToCommunity>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Post ops
|
||||
UserOperation::LockPost => do_websocket_operation::<LockPost>(context, id, op, data).await,
|
||||
UserOperation::FeaturePost => {
|
||||
do_websocket_operation::<FeaturePost>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::CreatePostLike => {
|
||||
do_websocket_operation::<CreatePostLike>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::MarkPostAsRead => {
|
||||
do_websocket_operation::<MarkPostAsRead>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::SavePost => do_websocket_operation::<SavePost>(context, id, op, data).await,
|
||||
UserOperation::CreatePostReport => {
|
||||
do_websocket_operation::<CreatePostReport>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ListPostReports => {
|
||||
do_websocket_operation::<ListPostReports>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ResolvePostReport => {
|
||||
do_websocket_operation::<ResolvePostReport>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::GetSiteMetadata => {
|
||||
do_websocket_operation::<GetSiteMetadata>(context, id, op, data).await
|
||||
}
|
||||
|
||||
// Comment ops
|
||||
UserOperation::SaveComment => {
|
||||
do_websocket_operation::<SaveComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::CreateCommentLike => {
|
||||
do_websocket_operation::<CreateCommentLike>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::DistinguishComment => {
|
||||
do_websocket_operation::<DistinguishComment>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::CreateCommentReport => {
|
||||
do_websocket_operation::<CreateCommentReport>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ListCommentReports => {
|
||||
do_websocket_operation::<ListCommentReports>(context, id, op, data).await
|
||||
}
|
||||
UserOperation::ResolveCommentReport => {
|
||||
do_websocket_operation::<ResolveCommentReport>(context, id, op, data).await
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn do_websocket_operation<'a, 'b, Data>(
|
||||
context: ContextData<LemmyContext>,
|
||||
id: ConnectionId,
|
||||
op: UserOperation,
|
||||
data: Value,
|
||||
) -> result::Result<String, LemmyError>
|
||||
where
|
||||
Data: Perform + SendActivity<Response = <Data as Perform>::Response> + Send,
|
||||
for<'de> Data: Deserialize<'de>,
|
||||
{
|
||||
let parsed_data: Data = serde_json::from_value(data)?;
|
||||
let res = parsed_data
|
||||
.perform(&web::Data::new(context.deref().clone()), Some(id))
|
||||
.await?;
|
||||
SendActivity::send_activity(&parsed_data, &res, &context).await?;
|
||||
serialize_websocket_message(&op, &res)
|
||||
}
|
|
@ -1,5 +1,4 @@
|
|||
pub mod api_routes_http;
|
||||
pub mod api_routes_websocket;
|
||||
pub mod api_routes;
|
||||
pub mod code_migrations;
|
||||
pub mod root_span_builder;
|
||||
pub mod scheduled_tasks;
|
||||
|
@ -158,7 +157,7 @@ pub async fn start_lemmy_server() -> Result<(), LemmyError> {
|
|||
.app_data(Data::new(rate_limit_cell.clone()))
|
||||
.wrap(FederationMiddleware::new(federation_config))
|
||||
// The routes
|
||||
.configure(|cfg| api_routes_http::config(cfg, rate_limit_cell))
|
||||
.configure(|cfg| api_routes::config(cfg, rate_limit_cell))
|
||||
.configure(|cfg| {
|
||||
if federation_enabled {
|
||||
lemmy_apub::http::routes::config(cfg);
|
||||
|
|
Loading…
Reference in a new issue