gf4
/
lemmy
mirror of https://github.com/LemmyNet/lemmy
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rewrite remaining federation actions, get rid of PerformCrud trait (#3794) 

* Rewrite ban actions

* Rewrite delete/remove actions

* Rewrite remove/delete community

* Rewrite report actions

* Rewrite feature/lock post

* Rewrite update community actions

* Rewrite remaining federation actions

* Get rid of PerformCrud trait

* clippy
pull/3799/head^2
Nutomic 2023-08-02 18:52:41 +02:00 committed by GitHub
parent be1389420b
commit 27be1efb74
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
46 changed files with 1699 additions and 1927 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
api_tests/prepare-drone-federation-test.sh
View File

@ -30,9 +30,6 @@ else
done
fi
echo "killall existing lemmy_server processes"
killall -s1 lemmy_server || true
echo "$PWD"
echo "start alpha"

2
api_tests/run-federation-test.sh
View File

@ -7,12 +7,14 @@ pushd ..
cargo build
rm target/lemmy_server || true
cp target/debug/lemmy_server target/lemmy_server
killall -s1 lemmy_server || true
./api_tests/prepare-drone-federation-test.sh
popd
yarn
yarn api-test || true
killall -s1 lemmy_server || true
for INSTANCE in lemmy_alpha lemmy_beta lemmy_gamma lemmy_delta lemmy_epsilon; do
psql "$LEMMY_DATABASE_URL" -c "DROP DATABASE $INSTANCE"
done

41
crates/api/src/comment_report/create.rs
View File

@ -1,8 +1,10 @@
use crate::{check_report_reason, Perform};
use actix_web::web::Data;
use crate::check_report_reason;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
comment::{CommentReportResponse, CreateCommentReport},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{
check_community_ban,
local_user_view_from_jwt,
@ -21,20 +23,15 @@ use lemmy_db_views::structs::{CommentReportView, CommentView};
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
/// Creates a comment report and notifies the moderators of the community
#[async_trait::async_trait(?Send)]
impl Perform for CreateCommentReport {
type Response = CommentReportResponse;
#[tracing::instrument(skip(context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<CommentReportResponse, LemmyError> {
let data: &CreateCommentReport = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn create_comment_report(
data: Json<CreateCommentReport>,
context: Data<LemmyContext>,
) -> Result<Json<CommentReportResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
let reason = sanitize_html(self.reason.trim());
let reason = sanitize_html(data.reason.trim());
check_report_reason(&reason, &local_site)?;
let person_id = local_user_view.person.id;
@ -68,8 +65,18 @@ impl Perform for CreateCommentReport {
.await?;
}
Ok(CommentReportResponse {
ActivityChannel::submit_activity(
SendActivityData::CreateReport(
comment_view.comment.ap_id.inner().clone(),
local_user_view.person,
comment_view.community,
data.reason.clone(),
),
&context,
)
.await?;
Ok(Json(CommentReportResponse {
comment_report_view,
})
}
}))
}

39
crates/api/src/community/add_mod.rs
View File

@ -1,8 +1,9 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
community::{AddModToCommunity, AddModToCommunityResponse},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{is_mod_or_admin, local_user_view_from_jwt},
};
use lemmy_db_schema::{
@ -15,17 +16,12 @@ use lemmy_db_schema::{
use lemmy_db_views_actor::structs::CommunityModeratorView;
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl Perform for AddModToCommunity {
type Response = AddModToCommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<AddModToCommunityResponse, LemmyError> {
let data: &AddModToCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn add_mod_to_community(
data: Json<AddModToCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<AddModToCommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let community_id = data.community_id;
@ -64,9 +60,18 @@ impl Perform for AddModToCommunity {
// Note: in case a remote mod is added, this returns the old moderators list, it will only get
// updated once we receive an activity from the community (like `Announce/Add/Moderator`)
let community_id = data.community_id;
let moderators =
CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
let moderators = CommunityModeratorView::for_community(&mut context.pool(), community_id).await?;
Ok(AddModToCommunityResponse { moderators })
}
ActivityChannel::submit_activity(
SendActivityData::AddModToCommunity(
local_user_view.person,
data.community_id,
data.person_id,
data.added,
),
&context,
)
.await?;
Ok(Json(AddModToCommunityResponse { moderators }))
}

51
crates/api/src/community/ban.rs
View File

@ -1,8 +1,9 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
community::{BanFromCommunity, BanFromCommunityResponse},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{
is_mod_or_admin,
local_user_view_from_jwt,
@ -28,25 +29,24 @@ use lemmy_utils::{
utils::{time::naive_from_unix, validation::is_valid_body_field},
};
#[async_trait::async_trait(?Send)]
impl Perform for BanFromCommunity {
type Response = BanFromCommunityResponse;
#[tracing::instrument(skip(context))]
pub async fn ban_from_community(
data: Json<BanFromCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<BanFromCommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
#[tracing::instrument(skip(context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<BanFromCommunityResponse, LemmyError> {
let data: &BanFromCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let community_id = data.community_id;
let banned_person_id = data.person_id;
let remove_data = data.remove_data.unwrap_or(false);
let expires = data.expires.map(naive_from_unix);
// Verify that only mods or admins can ban
is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id).await?;
is_mod_or_admin(
&mut context.pool(),
local_user_view.person.id,
data.community_id,
)
.await?;
is_valid_body_field(&data.reason, false)?;
let community_user_ban_form = CommunityPersonBanForm {
@ -78,7 +78,7 @@ impl Perform for BanFromCommunity {
// Remove/Restore their data if that's desired
if remove_data {
remove_user_data_in_community(community_id, banned_person_id, &mut context.pool()).await?;
remove_user_data_in_community(data.community_id, banned_person_id, &mut context.pool()).await?;
}
// Mod tables
@ -93,12 +93,21 @@ impl Perform for BanFromCommunity {
ModBanFromCommunity::create(&mut context.pool(), &form).await?;
let person_id = data.person_id;
let person_view = PersonView::read(&mut context.pool(), person_id).await?;
let person_view = PersonView::read(&mut context.pool(), data.person_id).await?;
Ok(BanFromCommunityResponse {
ActivityChannel::submit_activity(
SendActivityData::BanFromCommunity(
local_user_view.person,
data.community_id,
person_view.person.clone(),
data.0.clone(),
),
&context,
)
.await?;
Ok(Json(BanFromCommunityResponse {
person_view,
banned: data.ban,
})
}
}))
}

37
crates/api/src/community/block.rs
View File

@ -1,8 +1,9 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
community::{BlockCommunity, BlockCommunityResponse},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::local_user_view_from_jwt,
};
use lemmy_db_schema::{
@ -15,17 +16,12 @@ use lemmy_db_schema::{
use lemmy_db_views_actor::structs::CommunityView;
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl Perform for BlockCommunity {
type Response = BlockCommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<BlockCommunityResponse, LemmyError> {
let data: &BlockCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn block_community(
data: Json<BlockCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<BlockCommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let community_id = data.community_id;
let person_id = local_user_view.person.id;
@ -58,9 +54,18 @@ impl Perform for BlockCommunity {
let community_view =
CommunityView::read(&mut context.pool(), community_id, Some(person_id), None).await?;
Ok(BlockCommunityResponse {
ActivityChannel::submit_activity(
SendActivityData::FollowCommunity(
community_view.community.clone(),
local_user_view.person.clone(),
false,
),
&context,
)
.await?;
Ok(Json(BlockCommunityResponse {
blocked: data.block,
community_view,
})
}
}))
}

31
crates/api/src/community/hide.rs
View File

@ -1,9 +1,10 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_community_response,
community::{CommunityResponse, HideCommunity},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{is_admin, local_user_view_from_jwt, sanitize_html_opt},
};
use lemmy_db_schema::{
@ -15,16 +16,13 @@ use lemmy_db_schema::{
};
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl Perform for HideCommunity {
type Response = CommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let data: &HideCommunity = self;
#[tracing::instrument(skip(context))]
pub async fn hide_community(
data: Json<HideCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<CommunityResponse>, LemmyError> {
// Verify its a admin (only admin can hide or unhide it)
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
is_admin(&local_user_view)?;
let community_form = CommunityUpdateForm::builder()
@ -39,12 +37,17 @@ impl Perform for HideCommunity {
};
let community_id = data.community_id;
Community::update(&mut context.pool(), community_id, &community_form)
let community = Community::update(&mut context.pool(), community_id, &community_form)
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdateCommunityHiddenStatus)?;
ModHideCommunity::create(&mut context.pool(), &mod_hide_community_form).await?;
build_community_response(context, local_user_view, community_id).await
}
ActivityChannel::submit_activity(
SendActivityData::UpdateCommunity(local_user_view.person.clone(), community),
&context,
)
.await?;
build_community_response(&context, local_user_view, community_id).await
}

10
crates/api/src/community/mod.rs
View File

@ -1,6 +1,6 @@
mod add_mod;
mod ban;
mod block;
pub mod add_mod;
pub mod ban;
pub mod block;
pub mod follow;
mod hide;
mod transfer;
pub mod hide;
pub mod transfer;

44
crates/api/src/local_user/ban_person.rs
View File

@ -1,8 +1,9 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
person::{BanPerson, BanPersonResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{is_admin, local_user_view_from_jwt, remove_user_data, sanitize_html_opt},
};
use lemmy_db_schema::{
@ -17,30 +18,25 @@ use lemmy_utils::{
error::{LemmyError, LemmyErrorExt, LemmyErrorType},
utils::{time::naive_from_unix, validation::is_valid_body_field},
};
#[async_trait::async_trait(?Send)]
impl Perform for BanPerson {
type Response = BanPersonResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<BanPersonResponse, LemmyError> {
let data: &BanPerson = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn ban_from_site(
data: Json<BanPerson>,
context: Data<LemmyContext>,
) -> Result<Json<BanPersonResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
// Make sure user is an admin
is_admin(&local_user_view)?;
is_valid_body_field(&data.reason, false)?;
let ban = data.ban;
let banned_person_id = data.person_id;
let expires = data.expires.map(naive_from_unix);
let person = Person::update(
&mut context.pool(),
banned_person_id,
data.person_id,
&PersonUpdateForm::builder()
.banned(Some(ban))
.banned(Some(data.ban))
.ban_expires(Some(expires))
.build(),
)
@ -70,12 +66,20 @@ impl Perform for BanPerson {
ModBan::create(&mut context.pool(), &form).await?;
let person_id = data.person_id;
let person_view = PersonView::read(&mut context.pool(), person_id).await?;
let person_view = PersonView::read(&mut context.pool(), data.person_id).await?;
Ok(BanPersonResponse {
ActivityChannel::submit_activity(
SendActivityData::BanFromSite(
local_user_view.person,
person_view.person.clone(),
data.0.clone(),
),
&context,
)
.await?;
Ok(Json(BanPersonResponse {
person_view,
banned: data.ban,
})
}
}))
}

35
crates/api/src/post/feature.rs
View File

@ -1,9 +1,10 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_post_response,
context::LemmyContext,
post::{FeaturePost, PostResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{
check_community_ban,
check_community_deleted_or_removed,
@ -22,14 +23,12 @@ use lemmy_db_schema::{
};
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl Perform for FeaturePost {
type Response = PostResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &FeaturePost = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn feature_post(
data: Json<FeaturePost>,
context: Data<LemmyContext>,
) -> Result<Json<PostResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut context.pool(), post_id).await?;
@ -65,7 +64,7 @@ impl Perform for FeaturePost {
.featured_local(Some(data.featured))
.build()
};
Post::update(&mut context.pool(), post_id, &new_post).await?;
let post = Post::update(&mut context.pool(), post_id, &new_post).await?;
// Mod tables
let form = ModFeaturePostForm {
@ -77,12 +76,12 @@ impl Perform for FeaturePost {
ModFeaturePost::create(&mut context.pool(), &form).await?;
build_post_response(
context,
orig_post.community_id,
local_user_view.person.id,
post_id,
let person_id = local_user_view.person.id;
ActivityChannel::submit_activity(
SendActivityData::FeaturePost(post, local_user_view.person, data.featured),
&context,
)
.await
}
.await?;
build_post_response(&context, orig_post.community_id, person_id, post_id).await
}

4
crates/api/src/post/like.rs
View File

@ -80,13 +80,11 @@ pub async fn like_post(
)
.await?;
Ok(Json(
build_post_response(
context.deref(),
post.community_id,
local_user_view.person.id,
post_id,
)
.await?,
))
.await
}

35
crates/api/src/post/lock.rs
View File

@ -1,9 +1,10 @@
use crate::Perform;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_post_response,
context::LemmyContext,
post::{LockPost, PostResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{
check_community_ban,
check_community_deleted_or_removed,
@ -20,14 +21,12 @@ use lemmy_db_schema::{
};
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl Perform for LockPost {
type Response = PostResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &LockPost = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn lock_post(
data: Json<LockPost>,
context: Data<LemmyContext>,
) -> Result<Json<PostResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut context.pool(), post_id).await?;
@ -51,7 +50,7 @@ impl Perform for LockPost {
// Update the post
let post_id = data.post_id;
let locked = data.locked;
Post::update(
let post = Post::update(
&mut context.pool(),
post_id,
&PostUpdateForm::builder().locked(Some(locked)).build(),
@ -66,12 +65,12 @@ impl Perform for LockPost {
};
ModLockPost::create(&mut context.pool(), &form).await?;
build_post_response(
context,
orig_post.community_id,
local_user_view.person.id,
post_id,
let person_id = local_user_view.person.id;
ActivityChannel::submit_activity(
SendActivityData::LockPost(post, local_user_view.person, data.locked),
&context,
)
.await
}
.await?;
build_post_response(&context, orig_post.community_id, person_id, post_id).await
}

36
crates/api/src/post_report/create.rs
View File

@ -1,8 +1,10 @@
use crate::{check_report_reason, Perform};
use actix_web::web::Data;
use crate::check_report_reason;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
post::{CreatePostReport, PostReportResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{
check_community_ban,
local_user_view_from_jwt,
@ -21,17 +23,15 @@ use lemmy_db_views::structs::{PostReportView, PostView};
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
/// Creates a post report and notifies the moderators of the community
#[async_trait::async_trait(?Send)]
impl Perform for CreatePostReport {
type Response = PostReportResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> {
let data: &CreatePostReport = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn create_post_report(
data: Json<CreatePostReport>,
context: Data<LemmyContext>,
) -> Result<Json<PostReportResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
let reason = sanitize_html(self.reason.trim());
let reason = sanitize_html(data.reason.trim());
check_report_reason(&reason, &local_site)?;
let person_id = local_user_view.person.id;
@ -66,6 +66,16 @@ impl Perform for CreatePostReport {
.await?;
}
Ok(PostReportResponse { post_report_view })
}
ActivityChannel::submit_activity(
SendActivityData::CreateReport(
post_view.post.ap_id.inner().clone(),
local_user_view.person,
post_view.community,
data.reason.clone(),
),
&context,
)
.await?;
Ok(Json(PostReportResponse { post_report_view }))
}

6
crates/api/src/post_report/mod.rs
View File

@ -1,3 +1,3 @@
mod create;
mod list;
mod resolve;
pub mod create;
pub mod list;
pub mod resolve;

14
crates/api_common/src/build_response.rs
View File

@ -5,7 +5,7 @@ use crate::{
post::PostResponse,
utils::{check_person_block, get_interface_language, is_mod_or_admin, send_email_to_user},
};
use actix_web::web::Data;
use actix_web::web::Json;
use lemmy_db_schema::{
newtypes::{CommentId, CommunityId, LocalUserId, PersonId, PostId},
source::{
@ -39,10 +39,10 @@ pub async fn build_comment_response(
}
pub async fn build_community_response(
context: &Data<LemmyContext>,
context: &LemmyContext,
local_user_view: LocalUserView,
community_id: CommunityId,
) -> Result<CommunityResponse, LemmyError> {
) -> Result<Json<CommunityResponse>, LemmyError> {
let is_mod_or_admin =
is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id)
.await
@ -57,10 +57,10 @@ pub async fn build_community_response(
.await?;
let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
Ok(CommunityResponse {
Ok(Json(CommunityResponse {
community_view,
discussion_languages,
})
}))
}
pub async fn build_post_response(
@ -68,7 +68,7 @@ pub async fn build_post_response(
community_id: CommunityId,
person_id: PersonId,
post_id: PostId,
) -> Result<PostResponse, LemmyError> {
) -> Result<Json<PostResponse>, LemmyError> {
let is_mod_or_admin = is_mod_or_admin(&mut context.pool(), person_id, community_id)
.await
.is_ok();
@ -79,7 +79,7 @@ pub async fn build_post_response(
Some(is_mod_or_admin),
)
.await?;
Ok(PostResponse { post_view })
Ok(Json(PostResponse { post_view }))
}
// TODO: this function is a mess and should be split up to handle email seperately

36
crates/api_common/src/send_activity.rs
View File

@ -1,10 +1,22 @@
use crate::context::LemmyContext;
use crate::{
community::BanFromCommunity,
context::LemmyContext,
person::BanPerson,
post::{DeletePost, RemovePost},
};
use activitypub_federation::config::Data;
use futures::future::BoxFuture;
use lemmy_db_schema::{
newtypes::DbUrl,
source::{comment::Comment, community::Community, person::Person, post::Post},
newtypes::{CommunityId, DbUrl, PersonId},
source::{
comment::Comment,
community::Community,
person::Person,
post::Post,
private_message::PrivateMessage,
},
};
use lemmy_db_views::structs::PrivateMessageView;
use lemmy_utils::{error::LemmyResult, SYNCHRONOUS_FEDERATION};
use once_cell::sync::{Lazy, OnceCell};
use tokio::{
@ -15,6 +27,7 @@ use tokio::{
},
task::JoinHandle,
};
use url::Url;
type MatchOutgoingActivitiesBoxed =
Box<for<'a> fn(SendActivityData, &'a Data<LemmyContext>) -> BoxFuture<'a, LemmyResult<()>>>;
@ -26,12 +39,27 @@ pub static MATCH_OUTGOING_ACTIVITIES: OnceCell<MatchOutgoingActivitiesBoxed> = O
pub enum SendActivityData {
CreatePost(Post),
UpdatePost(Post),
DeletePost(Post, Person, DeletePost),
RemovePost(Post, Person, RemovePost),
LockPost(Post, Person, bool),
FeaturePost(Post, Person, bool),
CreateComment(Comment),
UpdateComment(Comment),
DeleteComment(Comment, Person, Community),
RemoveComment(Comment, Person, Community, Option<String>),
UpdateComment(Comment),
LikePostOrComment(DbUrl, Person, Community, i16),
FollowCommunity(Community, Person, bool),
UpdateCommunity(Person, Community),
DeleteCommunity(Person, Community, bool),
RemoveCommunity(Person, Community, Option<String>, bool),
AddModToCommunity(Person, CommunityId, PersonId, bool),
BanFromCommunity(Person, CommunityId, Person, BanFromCommunity),
BanFromSite(Person, Person, BanPerson),
CreatePrivateMessage(PrivateMessageView),
UpdatePrivateMessage(PrivateMessageView),
DeletePrivateMessage(Person, PrivateMessage, bool),
DeleteUser(Person),
CreateReport(Url, Person, Community, String),
}
// TODO: instead of static, move this into LemmyContext. make sure that stopping the process with

22
crates/api_crud/src/community/create.rs
View File

@ -1,6 +1,5 @@
use crate::PerformCrud;
use activitypub_federation::http_signatures::generate_actor_keypair;
use actix_web::web::Data;
use activitypub_federation::{config::Data, http_signatures::generate_actor_keypair};
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_community_response,
community::{CommunityResponse, CreateCommunity},
@ -42,14 +41,12 @@ use lemmy_utils::{
},
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for CreateCommunity {
type Response = CommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let data: &CreateCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn create_community(
data: Json<CreateCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<CommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let site_view = SiteView::read_local(&mut context.pool()).await?;
let local_site = site_view.local_site;
@ -143,6 +140,5 @@ impl PerformCrud for CreateCommunity {
CommunityLanguage::update(&mut context.pool(), languages, community_id).await?;
}
build_community_response(context, local_user_view, community_id).await
}
build_community_response(&context, local_user_view, community_id).await
}

30
crates/api_crud/src/community/delete.rs
View File

@ -1,9 +1,10 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_community_response,
community::{CommunityResponse, DeleteCommunity},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{is_top_mod, local_user_view_from_jwt},
};
use lemmy_db_schema::{
@ -13,14 +14,12 @@ use lemmy_db_schema::{
use lemmy_db_views_actor::structs::CommunityModeratorView;
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl PerformCrud for DeleteCommunity {
type Response = CommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let data: &DeleteCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn delete_community(
data: Json<DeleteCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<CommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
// Fetch the community mods
let community_id = data.community_id;
@ -33,7 +32,7 @@ impl PerformCrud for DeleteCommunity {
// Do the delete
let community_id = data.community_id;
let deleted = data.deleted;
Community::update(
let community = Community::update(
&mut context.pool(),
community_id,
&CommunityUpdateForm::builder()
@ -43,6 +42,11 @@ impl PerformCrud for DeleteCommunity {
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdateCommunity)?;
build_community_response(context, local_user_view, community_id).await
}
ActivityChannel::submit_activity(
SendActivityData::DeleteCommunity(local_user_view.person.clone(), community, data.deleted),
&context,
)
.await?;
build_community_response(&context, local_user_view, community_id).await
}

35
crates/api_crud/src/community/remove.rs
View File

@ -1,9 +1,10 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_community_response,
community::{CommunityResponse, RemoveCommunity},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{is_admin, local_user_view_from_jwt},
};
use lemmy_db_schema::{
@ -18,14 +19,12 @@ use lemmy_utils::{
utils::time::naive_from_unix,
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for RemoveCommunity {
type Response = CommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let data: &RemoveCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn remove_community(
data: Json<RemoveCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<CommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
// Verify its an admin (only an admin can remove a community)
is_admin(&local_user_view)?;
@ -33,7 +32,7 @@ impl PerformCrud for RemoveCommunity {
// Do the remove
let community_id = data.community_id;
let removed = data.removed;
Community::update(
let community = Community::update(
&mut context.pool(),
community_id,
&CommunityUpdateForm::builder()
@ -54,6 +53,16 @@ impl PerformCrud for RemoveCommunity {
};
ModRemoveCommunity::create(&mut context.pool(), &form).await?;
build_community_response(context, local_user_view, community_id).await
}
ActivityChannel::submit_activity(
SendActivityData::RemoveCommunity(
local_user_view.person.clone(),
community,
data.reason.clone(),
data.removed,
),
&context,
)
.await?;
build_community_response(&context, local_user_view, community_id).await
}

30
crates/api_crud/src/community/update.rs
View File

@ -1,9 +1,10 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_community_response,
community::{CommunityResponse, EditCommunity},
context::LemmyContext,
send_activity::{ActivityChannel, SendActivityData},
utils::{local_site_to_slur_regex, local_user_view_from_jwt, sanitize_html_opt},
};
use lemmy_db_schema::{
@ -22,14 +23,12 @@ use lemmy_utils::{
utils::{slurs::check_slurs_opt, validation::is_valid_body_field},
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for EditCommunity {
type Response = CommunityResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let data: &EditCommunity = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn update_community(
data: Json<EditCommunity>,
context: Data<LemmyContext>,
) -> Result<Json<CommunityResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
let slur_regex = local_site_to_slur_regex(&local_site);
@ -77,10 +76,15 @@ impl PerformCrud for EditCommunity {
.build();
let community_id = data.community_id;
Community::update(&mut context.pool(), community_id, &community_form)
let community = Community::update(&mut context.pool(), community_id, &community_form)
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdateCommunity)?;
build_community_response(context, local_user_view, community_id).await
}
ActivityChannel::submit_activity(
SendActivityData::UpdateCommunity(local_user_view.person.clone(), community),
&context,
)
.await?;
build_community_response(&context, local_user_view, community_id).await
}

21
crates/api_crud/src/custom_emoji/create.rs
View File

@ -1,5 +1,5 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
custom_emoji::{CreateCustomEmoji, CustomEmojiResponse},
@ -13,14 +13,12 @@ use lemmy_db_schema::source::{
use lemmy_db_views::structs::CustomEmojiView;
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl PerformCrud for CreateCustomEmoji {
type Response = CustomEmojiResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> {
let data: &CreateCustomEmoji = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn create_custom_emoji(
data: Json<CreateCustomEmoji>,
context: Data<LemmyContext>,
) -> Result<Json<CustomEmojiResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
// Make sure user is an admin
@ -48,6 +46,5 @@ impl PerformCrud for CreateCustomEmoji {
}
CustomEmojiKeyword::create(&mut context.pool(), keywords).await?;
let view = CustomEmojiView::get(&mut context.pool(), emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view })
}
Ok(Json(CustomEmojiResponse { custom_emoji: view }))
}

26
crates/api_crud/src/custom_emoji/delete.rs
View File

@ -1,5 +1,5 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
custom_emoji::{DeleteCustomEmoji, DeleteCustomEmojiResponse},
@ -8,24 +8,18 @@ use lemmy_api_common::{
use lemmy_db_schema::source::custom_emoji::CustomEmoji;
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl PerformCrud for DeleteCustomEmoji {
type Response = DeleteCustomEmojiResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<DeleteCustomEmojiResponse, LemmyError> {
let data: &DeleteCustomEmoji = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn delete_custom_emoji(
data: Json<DeleteCustomEmoji>,
context: Data<LemmyContext>,
) -> Result<Json<DeleteCustomEmojiResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
// Make sure user is an admin
is_admin(&local_user_view)?;
CustomEmoji::delete(&mut context.pool(), data.id).await?;
Ok(DeleteCustomEmojiResponse {
Ok(Json(DeleteCustomEmojiResponse {
id: data.id,
success: true,
})
}
}))
}

6
crates/api_crud/src/custom_emoji/mod.rs
View File

@ -1,3 +1,3 @@
mod create;
mod delete;
mod update;
pub mod create;
pub mod delete;
pub mod update;

21
crates/api_crud/src/custom_emoji/update.rs
View File

@ -1,5 +1,5 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
custom_emoji::{CustomEmojiResponse, EditCustomEmoji},
@ -13,14 +13,12 @@ use lemmy_db_schema::source::{
use lemmy_db_views::structs::CustomEmojiView;
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl PerformCrud for EditCustomEmoji {
type Response = CustomEmojiResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> {
let data: &EditCustomEmoji = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn update_custom_emoji(
data: Json<EditCustomEmoji>,
context: Data<LemmyContext>,
) -> Result<Json<CustomEmojiResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
// Make sure user is an admin
@ -47,6 +45,5 @@ impl PerformCrud for EditCustomEmoji {
}
CustomEmojiKeyword::create(&mut context.pool(), keywords).await?;
let view = CustomEmojiView::get(&mut context.pool(), emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view })
}
Ok(Json(CustomEmojiResponse { custom_emoji: view }))
}

11
crates/api_crud/src/lib.rs
View File

@ -1,7 +1,3 @@
use actix_web::web::Data;
use lemmy_api_common::context::LemmyContext;
use lemmy_utils::error::LemmyError;
pub mod comment;
pub mod community;
pub mod custom_emoji;
@ -9,10 +5,3 @@ pub mod post;
pub mod private_message;
pub mod site;
pub mod user;
#[async_trait::async_trait(?Send)]
pub trait PerformCrud {
type Response: serde::ser::Serialize + Send + Clone + Sync;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError>;
}

4
crates/api_crud/src/post/create.rs
View File

@ -194,7 +194,5 @@ pub async fn create_post(
}
};
Ok(Json(
build_post_response(&context, community_id, person_id, post_id).await?,
))
build_post_response(&context, community_id, person_id, post_id).await
}

43
crates/api_crud/src/post/delete.rs
View File

@ -1,9 +1,10 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_post_response,
context::LemmyContext,
post::{DeletePost, PostResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{check_community_ban, check_community_deleted_or_removed, local_user_view_from_jwt},
};
use lemmy_db_schema::{
@ -12,14 +13,12 @@ use lemmy_db_schema::{
};
use lemmy_utils::error::{LemmyError, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl PerformCrud for DeletePost {
type Response = PostResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &DeletePost = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn delete_post(
data: Json<DeletePost>,
context: Data<LemmyContext>,
) -> Result<Json<PostResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut context.pool(), post_id).await?;
@ -43,21 +42,21 @@ impl PerformCrud for DeletePost {
}
// Update the post
let post_id = data.post_id;
let deleted = data.deleted;
Post::update(
let post = Post::update(
&mut context.pool(),
post_id,
&PostUpdateForm::builder().deleted(Some(deleted)).build(),
data.post_id,
&PostUpdateForm::builder()
.deleted(Some(data.deleted))
.build(),
)
.await?;
build_post_response(
context,
orig_post.community_id,
local_user_view.person.id,
post_id,
let person_id = local_user_view.person.id;
ActivityChannel::submit_activity(
SendActivityData::DeletePost(post, local_user_view.person, data.0.clone()),
&context,
)
.await
}
.await?;
build_post_response(&context, orig_post.community_id, person_id, data.post_id).await
}

35
crates/api_crud/src/post/remove.rs
View File

@ -1,9 +1,10 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
build_response::build_post_response,
context::LemmyContext,
post::{PostResponse, RemovePost},
send_activity::{ActivityChannel, SendActivityData},
utils::{check_community_ban, is_mod_or_admin, local_user_view_from_jwt},
};
use lemmy_db_schema::{
@ -15,14 +16,12 @@ use lemmy_db_schema::{
};
use lemmy_utils::error::LemmyError;
#[async_trait::async_trait(?Send)]
impl PerformCrud for RemovePost {
type Response = PostResponse;
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &RemovePost = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn remove_post(
data: Json<RemovePost>,
context: Data<LemmyContext>,
) -> Result<Json<PostResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut context.pool(), post_id).await?;
@ -45,7 +44,7 @@ impl PerformCrud for RemovePost {
// Update the post
let post_id = data.post_id;
let removed = data.removed;
Post::update(
let post = Post::update(
&mut context.pool(),
post_id,
&PostUpdateForm::builder().removed(Some(removed)).build(),
@ -61,12 +60,12 @@ impl PerformCrud for RemovePost {
};
ModRemovePost::create(&mut context.pool(), &form).await?;
build_post_response(
context,
orig_post.community_id,
local_user_view.person.id,
post_id,
let person_id = local_user_view.person.id;
ActivityChannel::submit_activity(
SendActivityData::RemovePost(post, local_user_view.person, data.0),
&context,
)
.await
}
.await?;
build_post_response(&context, orig_post.community_id, person_id, post_id).await
}

4
crates/api_crud/src/post/update.rs
View File

@ -113,13 +113,11 @@ pub async fn update_post(
ActivityChannel::submit_activity(SendActivityData::UpdatePost(updated_post), &context).await?;
Ok(Json(
build_post_response(
context.deref(),
orig_post.community_id,
local_user_view.person.id,
post_id,
)
.await?,
))
.await
}

36
crates/api_crud/src/private_message/create.rs
View File

@ -1,8 +1,9 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
private_message::{CreatePrivateMessage, PrivateMessageResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{
check_person_block,
generate_local_apub_endpoint,
@ -27,17 +28,12 @@ use lemmy_utils::{
utils::{slurs::remove_slurs, validation::is_valid_body_field},
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for CreatePrivateMessage {
type Response = PrivateMessageResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> {
let data: &CreatePrivateMessage = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn create_private_message(
data: Json<CreatePrivateMessage>,
context: Data<LemmyContext>,
) -> Result<Json<PrivateMessageResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
let content = sanitize_html(&data.content);
@ -57,8 +53,7 @@ impl PerformCrud for CreatePrivateMessage {
.recipient_id(data.recipient_id)
.build();
let inserted_private_message =
PrivateMessage::create(&mut context.pool(), &private_message_form)
let inserted_private_message = PrivateMessage::create(&mut context.pool(), &private_message_form)
.await
.with_lemmy_type(LemmyErrorType::CouldntCreatePrivateMessage)?;
@ -97,8 +92,13 @@ impl PerformCrud for CreatePrivateMessage {
.await;
}
Ok(PrivateMessageResponse {
ActivityChannel::submit_activity(
SendActivityData::CreatePrivateMessage(view.clone()),
&context,
)
.await?;
Ok(Json(PrivateMessageResponse {
private_message_view: view,
})
}
}))
}

38
crates/api_crud/src/private_message/delete.rs
View File

@ -1,8 +1,9 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
private_message::{DeletePrivateMessage, PrivateMessageResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::local_user_view_from_jwt,
};
use lemmy_db_schema::{
@ -12,22 +13,16 @@ use lemmy_db_schema::{
use lemmy_db_views::structs::PrivateMessageView;
use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl PerformCrud for DeletePrivateMessage {
type Response = PrivateMessageResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> {
let data: &DeletePrivateMessage = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn delete_private_message(
data: Json<DeletePrivateMessage>,
context: Data<LemmyContext>,
) -> Result<Json<PrivateMessageResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message =
PrivateMessage::read(&mut context.pool(), private_message_id).await?;
let orig_private_message = PrivateMessage::read(&mut context.pool(), private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyErrorType::EditPrivateMessageNotAllowed)?;
}
@ -35,7 +30,7 @@ impl PerformCrud for DeletePrivateMessage {
// Doing the update
let private_message_id = data.private_message_id;
let deleted = data.deleted;
PrivateMessage::update(
let private_message = PrivateMessage::update(
&mut context.pool(),
private_message_id,
&PrivateMessageUpdateForm::builder()
@ -45,9 +40,14 @@ impl PerformCrud for DeletePrivateMessage {
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdatePrivateMessage)?;
ActivityChannel::submit_activity(
SendActivityData::DeletePrivateMessage(local_user_view.person, private_message, data.deleted),
&context,
)
.await?;
let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
Ok(PrivateMessageResponse {
Ok(Json(PrivateMessageResponse {
private_message_view: view,
})
}
}))
}

36
crates/api_crud/src/private_message/update.rs
View File

@ -1,8 +1,9 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
private_message::{EditPrivateMessage, PrivateMessageResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::{local_site_to_slur_regex, local_user_view_from_jwt, sanitize_html},
};
use lemmy_db_schema::{
@ -19,23 +20,17 @@ use lemmy_utils::{
utils::{slurs::remove_slurs, validation::is_valid_body_field},
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for EditPrivateMessage {
type Response = PrivateMessageResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(
&self,
context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> {
let data: &EditPrivateMessage = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
#[tracing::instrument(skip(context))]
pub async fn update_private_message(
data: Json<EditPrivateMessage>,
context: Data<LemmyContext>,
) -> Result<Json<PrivateMessageResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
let local_site = LocalSite::read(&mut context.pool()).await?;
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message =
PrivateMessage::read(&mut context.pool(), private_message_id).await?;
let orig_private_message = PrivateMessage::read(&mut context.pool(), private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyErrorType::EditPrivateMessageNotAllowed)?;
}
@ -59,8 +54,13 @@ impl PerformCrud for EditPrivateMessage {
let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
Ok(PrivateMessageResponse {
ActivityChannel::submit_activity(
SendActivityData::UpdatePrivateMessage(view.clone()),
&context,
)
.await?;
Ok(Json(PrivateMessageResponse {
private_message_view: view,
})
}
}))
}

21
crates/api_crud/src/user/create.rs
View File

@ -1,6 +1,5 @@
use crate::PerformCrud;
use activitypub_federation::http_signatures::generate_actor_keypair;
use actix_web::web::Data;
use activitypub_federation::{config::Data, http_signatures::generate_actor_keypair};
use actix_web::web::Json;
use lemmy_api_common::{
context::LemmyContext,
person::{LoginResponse, Register},
@ -38,14 +37,11 @@ use lemmy_utils::{
},
};
#[async_trait::async_trait(?Send)]
impl PerformCrud for Register {
type Response = LoginResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let data: &Register = self;
#[tracing::instrument(skip(context))]
pub async fn register(
data: Json<Register>,
context: Data<LemmyContext>,
) -> Result<Json<LoginResponse>, LemmyError> {
let site_view = SiteView::read_local(&mut context.pool()).await?;
let local_site = site_view.local_site;
let require_registration_application =
@ -209,6 +205,5 @@ impl PerformCrud for Register {
}
}
Ok(login_response)
}
Ok(Json(login_response))
}

28
crates/api_crud/src/user/delete.rs
View File

@ -1,21 +1,20 @@
use crate::PerformCrud;
use actix_web::web::Data;
use activitypub_federation::config::Data;
use actix_web::web::Json;
use bcrypt::verify;
use lemmy_api_common::{
context::LemmyContext,
person::{DeleteAccount, DeleteAccountResponse},
send_activity::{ActivityChannel, SendActivityData},
utils::local_user_view_from_jwt,
};
use lemmy_utils::error::{LemmyError, LemmyErrorType};
#[async_trait::async_trait(?Send)]
impl PerformCrud for DeleteAccount {
type Response = DeleteAccountResponse;
#[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let data = self;
let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), context).await?;
#[tracing::instrument(skip(context))]
pub async fn delete_account(
data: Json<DeleteAccount>,
context: Data<LemmyContext>,
) -> Result<Json<DeleteAccountResponse>, LemmyError> {
let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), &context).await?;
// Verify the password
let valid: bool = verify(
@ -27,6 +26,11 @@ impl PerformCrud for DeleteAccount {
return Err(LemmyErrorType::IncorrectLogin)?;
}
Ok(DeleteAccountResponse {})
}
ActivityChannel::submit_activity(
SendActivityData::DeleteUser(local_user_view.person),
&context,
)
.await?;
Ok(Json(DeleteAccountResponse {}))
}

4
crates/api_crud/src/user/mod.rs
View File

@ -1,2 +1,2 @@
mod create;
mod delete;
pub mod create;
pub mod delete;

103
crates/apub/src/activities/block/mod.rs
View File

@ -1,10 +1,9 @@
use crate::{
objects::{community::ApubCommunity, instance::ApubSite, person::ApubPerson},
objects::{community::ApubCommunity, instance::ApubSite},
protocol::{
activities::block::{block_user::BlockUser, undo_block_user::UndoBlockUser},
objects::{group::Group, instance::Instance},
},
SendActivity,
};
use activitypub_federation::{
config::Data,
@ -12,19 +11,18 @@ use activitypub_federation::{
traits::{Actor, Object},
};
use chrono::NaiveDateTime;
use lemmy_api_common::{
community::{BanFromCommunity, BanFromCommunityResponse},
context::LemmyContext,
person::{BanPerson, BanPersonResponse},
utils::local_user_view_from_jwt,
};
use lemmy_api_common::{community::BanFromCommunity, context::LemmyContext, person::BanPerson};
use lemmy_db_schema::{
newtypes::CommunityId,
source::{community::Community, person::Person, site::Site},
traits::Crud,
utils::DbPool,
};
use lemmy_db_views::structs::SiteView;
use lemmy_utils::{error::LemmyError, utils::time::naive_from_unix};
use lemmy_utils::{
error::{LemmyError, LemmyResult},
utils::time::naive_from_unix,
};
use serde::Deserialize;
use url::Url;
@ -132,87 +130,74 @@ async fn generate_cc(
})
}
#[async_trait::async_trait]
impl SendActivity for BanPerson {
type Response = BanPersonResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let person = Person::read(&mut context.pool(), request.person_id).await?;
pub(crate) async fn send_ban_from_site(
mod_: Person,
banned_user: Person,
data: BanPerson,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let site = SiteOrCommunity::Site(SiteView::read_local(&mut context.pool()).await?.site.into());
let expires = request.expires.map(naive_from_unix);
let expires = data.expires.map(naive_from_unix);
// if the action affects a local user, federate to other instances
if person.local {
if request.ban {
if banned_user.local {
if data.ban {
BlockUser::send(
&site,
&person.into(),
&local_user_view.person.into(),
request.remove_data.unwrap_or(false),
request.reason.clone(),
&banned_user.into(),
&mod_.into(),
data.remove_data.unwrap_or(false),
data.reason.clone(),
expires,
context,
&context,
)
.await
} else {
UndoBlockUser::send(
&site,
&person.into(),
&local_user_view.person.into(),
request.reason.clone(),
context,
&banned_user.into(),
&mod_.into(),
data.reason.clone(),
&context,
)
.await
}
} else {
Ok(())
}
}
}
#[async_trait::async_trait]
impl SendActivity for BanFromCommunity {
type Response = BanFromCommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity = Community::read(&mut context.pool(), request.community_id)
pub(crate) async fn send_ban_from_community(
mod_: Person,
community_id: CommunityId,
banned_person: Person,
data: BanFromCommunity,
context: Data<LemmyContext>,
) -> LemmyResult<()> {
let community: ApubCommunity = Community::read(&mut context.pool(), community_id)
.await?
.into();
let banned_person: ApubPerson = Person::read(&mut context.pool(), request.person_id)
.await?
.into();
let expires = request.expires.map(naive_from_unix);
let expires = data.expires.map(naive_from_unix);
if request.ban {
if data.ban {
BlockUser::send(
&SiteOrCommunity::Community(community),
&banned_person,
&local_user_view.person.clone().into(),
request.remove_data.unwrap_or(false),
request.reason.clone(),
&banned_person.into(),
&mod_.into(),
data.remove_data.unwrap_or(false),
data.reason.clone(),
expires,
context,
&context,
)
.await
} else {
UndoBlockUser::send(
&SiteOrCommunity::Community(community),
&banned_person,
&local_user_view.person.clone().into(),
request.reason.clone(),
context,
&banned_person.into(),
&mod_.into(),
data.reason.clone(),
&context,
)
.await
}
}
}

76
crates/apub/src/activities/community/collection_add.rs
View File

@ -13,7 +13,6 @@ use crate::{
activities::community::{collection_add::CollectionAdd, collection_remove::CollectionRemove},
InCommunity,
},
SendActivity,
};
use activitypub_federation::{
config::Data,
@ -22,13 +21,12 @@ use activitypub_federation::{
traits::{ActivityHandler, Actor},
};
use lemmy_api_common::{
community::{AddModToCommunity, AddModToCommunityResponse},
context::LemmyContext,
post::{FeaturePost, PostResponse},
utils::{generate_featured_url, generate_moderators_url, local_user_view_from_jwt},
utils::{generate_featured_url, generate_moderators_url},
};
use lemmy_db_schema::{
impls::community::CollectionType,
newtypes::{CommunityId, PersonId},
source::{
community::{Community, CommunityModerator, CommunityModeratorForm},
moderator::{ModAddCommunity, ModAddCommunityForm},
@ -165,61 +163,41 @@ impl ActivityHandler for CollectionAdd {
}
}
#[async_trait::async_trait]
impl SendActivity for AddModToCommunity {
type Response = AddModToCommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity = Community::read(&mut context.pool(), request.community_id)
pub(crate) async fn send_add_mod_to_community(
actor: Person,
community_id: CommunityId,
updated_mod_id: PersonId,
added: bool,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let actor: ApubPerson = actor.into();
let community: ApubCommunity = Community::read(&mut context.pool(), community_id)
.await?
.into();
let updated_mod: ApubPerson = Person::read(&mut context.pool(), request.person_id)
let updated_mod: ApubPerson = Person::read(&mut context.pool(), updated_mod_id)
.await?
.into();
if request.added {
CollectionAdd::send_add_mod(
&community,
&updated_mod,
&local_user_view.person.into(),
context,
)
.await
if added {
CollectionAdd::send_add_mod(&community, &updated_mod, &actor, &context).await
} else {
CollectionRemove::send_remove_mod(
&community,
&updated_mod,
&local_user_view.person.into(),
context,
)
.await
}
CollectionRemove::send_remove_mod(&community, &updated_mod, &actor, &context).await
}
}
#[async_trait::async_trait]
impl SendActivity for FeaturePost {
type Response = PostResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), response.post_view.community.id)
pub(crate) async fn send_feature_post(
post: Post,
actor: Person,
featured: bool,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let actor: ApubPerson = actor.into();
let post: ApubPost = post.into();
let community = Community::read(&mut context.pool(), post.community_id)
.await?
.into();
let post = response.post_view.post.clone().into();
let person = local_user_view.person.into();
if request.featured {
CollectionAdd::send_add_featured_post(&community, &post, &person, context).await
if featured {
CollectionAdd::send_add_featured_post(&community, &post, &actor, &context).await
} else {
CollectionRemove::send_remove_featured_post(&community, &post, &person, context).await
}
CollectionRemove::send_remove_featured_post(&community, &post, &actor, &context).await
}
}

52
crates/apub/src/activities/community/lock_page.rs
View File

@ -9,25 +9,23 @@ use crate::{
},
activity_lists::AnnouncableActivities,
insert_received_activity,
objects::community::ApubCommunity,
protocol::{
activities::community::lock_page::{LockPage, LockType, UndoLockPage},
InCommunity,
},
SendActivity,
};
use activitypub_federation::{
config::Data,
fetch::object_id::ObjectId,
kinds::{activity::UndoType, public},
traits::ActivityHandler,
};
use lemmy_api_common::{
context::LemmyContext,
post::{LockPost, PostResponse},
utils::local_user_view_from_jwt,
};
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::{
source::{
community::Community,
person::Person,
post::{Post, PostUpdateForm},
},
traits::Crud,
@ -102,32 +100,30 @@ impl ActivityHandler for UndoLockPage {
}
}
#[async_trait::async_trait]
impl SendActivity for LockPost {
type Response = PostResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
pub(crate) async fn send_lock_post(
post: Post,
actor: Person,
locked: bool,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let community: ApubCommunity = Community::read(&mut context.pool(), post.community_id)
.await?
.into();
let id = generate_activity_id(
LockType::Lock,
&context.settings().get_protocol_and_hostname(),
)?;
let community_id = response.post_view.community.actor_id.clone();
let actor = local_user_view.person.actor_id.clone().into();
let community_id = community.actor_id.inner().clone();
let lock = LockPage {
actor,
actor: actor.actor_id.clone().into(),
to: vec![public()],
object: response.post_view.post.ap_id.clone().into(),
cc: vec![community_id.clone().into()],
object: ObjectId::from(post.ap_id),
cc: vec![community_id.clone()],
kind: LockType::Lock,
id,
audience: Some(community_id.into()),
};
let activity = if request.locked {
let activity = if locked {
AnnouncableActivities::LockPost(lock)
} else {
let id = generate_activity_id(
@ -145,16 +141,6 @@ impl SendActivity for LockPost {
};
AnnouncableActivities::UndoLockPost(undo)
};
let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
send_activity_in_community(
activity,
&local_user_view.person.into(),
&community.into(),
vec![],
true,
context,
)
.await?;
send_activity_in_community(activity, &actor.into(), &community, vec![], true, &context).await?;
Ok(())
}
}

65
crates/apub/src/activities/community/report.rs
View File

@ -4,7 +4,6 @@ use crate::{
objects::{community::ApubCommunity, person::ApubPerson},
protocol::{activities::community::report::Report, InCommunity},
PostOrComment,
SendActivity,
};
use activitypub_federation::{
config::Data,
@ -12,15 +11,12 @@ use activitypub_federation::{
kinds::activity::FlagType,
traits::{ActivityHandler, Actor},
};
use lemmy_api_common::{
comment::{CommentReportResponse, CreateCommentReport},
context::LemmyContext,
post::{CreatePostReport, PostReportResponse},
utils::{local_user_view_from_jwt, sanitize_html},
};
use lemmy_api_common::{context::LemmyContext, utils::sanitize_html};
use lemmy_db_schema::{
source::{
comment_report::{CommentReport, CommentReportForm},
community::Community,
person::Person,
post_report::{PostReport, PostReportForm},
},
traits::Reportable,
@ -28,58 +24,17 @@ use lemmy_db_schema::{
use lemmy_utils::error::LemmyError;
use url::Url;
#[async_trait::async_trait]
impl SendActivity for CreatePostReport {
type Response = PostReportResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
Report::send(
ObjectId::from(response.post_report_view.post.ap_id.clone()),
&local_user_view.person.into(),
ObjectId::from(response.post_report_view.community.actor_id.clone()),
request.reason.to_string(),
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for CreateCommentReport {
type Response = CommentReportResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
Report::send(
ObjectId::from(response.comment_report_view.comment.ap_id.clone()),
&local_user_view.person.into(),
ObjectId::from(response.comment_report_view.community.actor_id.clone()),
request.reason.to_string(),
context,
)
.await
}
}
impl Report {
#[tracing::instrument(skip_all)]
async fn send(
pub(crate) async fn send(
object_id: ObjectId<PostOrComment>,
actor: &ApubPerson,
community_id: ObjectId<ApubCommunity>,
actor: Person,
community: Community,
reason: String,
context: &Data<LemmyContext>,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let community = community_id.dereference_local(context).await?;
let actor: ApubPerson = actor.into();
let community: ApubCommunity = community.into();
let kind = FlagType::Flag;
let id = generate_activity_id(
kind.clone(),
@ -96,7 +51,7 @@ impl Report {
};
let inbox = vec![community.shared_inbox_or_inbox()];
send_lemmy_activity(context, report, actor, inbox, false).await
send_lemmy_activity(&context, report, &actor, inbox, false).await
}
}

59
crates/apub/src/activities/community/update.rs
View File

@ -10,44 +10,27 @@ use crate::{
insert_received_activity,
objects::{community::ApubCommunity, person::ApubPerson},
protocol::{activities::community::update::UpdateCommunity, InCommunity},
SendActivity,
};
use activitypub_federation::{
config::Data,
kinds::{activity::UpdateType, public},
traits::{ActivityHandler, Actor, Object},
};
use lemmy_api_common::{
community::{CommunityResponse, EditCommunity, HideCommunity},
context::LemmyContext,
utils::local_user_view_from_jwt,
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::{
source::{community::Community, person::Person},
traits::Crud,
};
use lemmy_db_schema::{source::community::Community, traits::Crud};
use lemmy_utils::error::LemmyError;
use url::Url;
#[async_trait::async_trait]
impl SendActivity for EditCommunity {
type Response = CommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
}
}
impl UpdateCommunity {
#[tracing::instrument(skip_all)]
pub async fn send(
community: ApubCommunity,
actor: &ApubPerson,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
pub(crate) async fn send_update_community(
community: Community,
actor: Person,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let community: ApubCommunity = community.into();
let actor: ApubPerson = actor.into();
let id = generate_activity_id(
UpdateType::Update,
&context.settings().get_protocol_and_hostname(),
@ -55,7 +38,7 @@ impl UpdateCommunity {
let update = UpdateCommunity {
actor: actor.id().into(),
to: vec![public()],
object: Box::new(community.clone().into_json(context).await?),
object: Box::new(community.clone().into_json(&context).await?),
cc: vec![community.id()],
kind: UpdateType::Update,
id: id.clone(),
@ -63,8 +46,7 @@ impl UpdateCommunity {
};
let activity = AnnouncableActivities::UpdateCommunity(update);
send_activity_in_community(activity, actor, &community, vec![], true, context).await
}
send_activity_in_community(activity, &actor, &community, vec![], true, &context).await
}
#[async_trait::async_trait]
@ -101,18 +83,3 @@ impl ActivityHandler for UpdateCommunity {
Ok(())
}
}
#[async_trait::async_trait]
impl SendActivity for HideCommunity {
type Response = CommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
}
}

76
crates/apub/src/activities/create_or_update/private_message.rs
View File

@ -6,75 +6,24 @@ use crate::{
create_or_update::chat_message::CreateOrUpdateChatMessage,
CreateOrUpdateType,
},
SendActivity,
};
use activitypub_federation::{
config::Data,
protocol::verification::verify_domains_match,
traits::{ActivityHandler, Actor, Object},
};
use lemmy_api_common::{
context::LemmyContext,
private_message::{CreatePrivateMessage, EditPrivateMessage, PrivateMessageResponse},
};
use lemmy_db_schema::{
newtypes::PersonId,
source::{person::Person, private_message::PrivateMessage},
traits::Crud,
};
use lemmy_api_common::context::LemmyContext;
use lemmy_db_views::structs::PrivateMessageView;
use lemmy_utils::error::LemmyError;
use url::Url;
#[async_trait::async_trait]
impl SendActivity for CreatePrivateMessage {
type Response = PrivateMessageResponse;
async fn send_activity(
_request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
CreateOrUpdateChatMessage::send(
&response.private_message_view.private_message,
response.private_message_view.creator.id,
CreateOrUpdateType::Create,
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for EditPrivateMessage {
type Response = PrivateMessageResponse;
async fn send_activity(
_request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
CreateOrUpdateChatMessage::send(
&response.private_message_view.private_message,
response.private_message_view.creator.id,
CreateOrUpdateType::Update,
context,
)
.await
}
}
impl CreateOrUpdateChatMessage {
#[tracing::instrument(skip_all)]
async fn send(
private_message: &PrivateMessage,
sender_id: PersonId,
pub(crate) async fn send_create_or_update_pm(
pm_view: PrivateMessageView,
kind: CreateOrUpdateType,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let recipient_id = private_message.recipient_id;
let sender: ApubPerson = Person::read(&mut context.pool(), sender_id).await?.into();
let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
.await?
.into();
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let actor: ApubPerson = pm_view.creator.into();
let recipient: ApubPerson = pm_view.recipient.into();
let id = generate_activity_id(
kind.clone(),
@ -82,16 +31,15 @@ impl CreateOrUpdateChatMessage {
)?;
let create_or_update = CreateOrUpdateChatMessage {
id: id.clone(),
actor: sender.id().into(),
actor: actor.id().into(),
to: [recipient.id().into()],
object: ApubPrivateMessage(private_message.clone())
.into_json(context)
object: ApubPrivateMessage(pm_view.private_message.clone())
.into_json(&context)
.await?,
kind,
};
let inbox = vec![recipient.shared_inbox_or_inbox()];
send_lemmy_activity(context, create_or_update, &sender, inbox, true).await
}
send_lemmy_activity(&context, create_or_update, &actor, inbox, true).await
}
#[async_trait::async_trait]

24
crates/apub/src/activities/deletion/delete_user.rs
View File

@ -3,7 +3,6 @@ use crate::{
insert_received_activity,
objects::{instance::remote_instance_inboxes, person::ApubPerson},
protocol::activities::deletion::delete_user::DeleteUser,
SendActivity,
};
use activitypub_federation::{
config::Data,
@ -11,25 +10,13 @@ use activitypub_federation::{
protocol::verification::verify_urls_match,
traits::{ActivityHandler, Actor},
};
use lemmy_api_common::{
context::LemmyContext,
person::{DeleteAccount, DeleteAccountResponse},
utils::{delete_user_account, local_user_view_from_jwt},
};
use lemmy_api_common::{context::LemmyContext, utils::delete_user_account};
use lemmy_db_schema::source::person::Person;
use lemmy_utils::error::LemmyError;
use url::Url;
#[async_trait::async_trait]
impl SendActivity for DeleteAccount {
type Response = DeleteAccountResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let actor: ApubPerson = local_user_view.person.into();
pub async fn delete_user(person: Person, context: Data<LemmyContext>) -> Result<(), LemmyError> {
let actor: ApubPerson = person.into();
delete_user_account(
actor.id,
&mut context.pool(),
@ -52,9 +39,8 @@ impl SendActivity for DeleteAccount {
};
let inboxes = remote_instance_inboxes(&mut context.pool()).await?;
send_lemmy_activity(context, delete, &actor, inboxes, true).await?;
send_lemmy_activity(&context, delete, &actor, inboxes, true).await?;
Ok(())
}
}
/// This can be separate from Delete activity because it doesn't need to be handled in shared inbox

170
crates/apub/src/activities/deletion/mod.rs
View File

@ -19,7 +19,6 @@ use crate::{
activities::deletion::{delete::Delete, undo_delete::UndoDelete},
InCommunity,
},
SendActivity,
};
use activitypub_federation::{
config::Data,
@ -28,14 +27,9 @@ use activitypub_federation::{
protocol::verification::verify_domains_match,
traits::{Actor, Object},
};
use lemmy_api_common::{
community::{CommunityResponse, DeleteCommunity, RemoveCommunity},
context::LemmyContext,
post::{DeletePost, PostResponse, RemovePost},
private_message::{DeletePrivateMessage, PrivateMessageResponse},
utils::local_user_view_from_jwt,
};
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::{
newtypes::CommunityId,
source::{
comment::{Comment, CommentUpdateForm},
community::{Community, CommunityUpdateForm},
@ -53,122 +47,6 @@ pub mod delete;
pub mod delete_user;
pub mod undo_delete;
#[async_trait::async_trait]
impl SendActivity for DeletePost {
type Response = PostResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community(
local_user_view.person,
community,
deletable,
None,
request.deleted,
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for RemovePost {
type Response = PostResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community(
local_user_view.person,
community,
deletable,
request.reason.clone().or_else(|| Some(String::new())),
request.removed,
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for DeletePrivateMessage {
type Response = PrivateMessageResponse;
async fn send_activity(
request: &Self,
response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
send_apub_delete_private_message(
&local_user_view.person.into(),
response.private_message_view.private_message.clone(),
request.deleted,
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for DeleteCommunity {
type Response = CommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(
local_user_view.person,
community,
deletable,
None,
request.deleted,
context,
)
.await
}
}
#[async_trait::async_trait]
impl SendActivity for RemoveCommunity {
type Response = CommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(
local_user_view.person,
community,
deletable,
request.reason.clone().or_else(|| Some(String::new())),
request.removed,
context,
)
.await
}
}
/// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
/// action was done by a normal user.
#[tracing::instrument(skip_all)]
@ -200,12 +78,44 @@ pub(crate) async fn send_apub_delete_in_community(
.await
}
/// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
/// action was done by a normal user.
#[tracing::instrument(skip_all)]
async fn send_apub_delete_private_message(
pub(crate) async fn send_apub_delete_in_community_new(
actor: Person,
community_id: CommunityId,
object: DeletableObjects,
reason: Option<String>,
deleted: bool,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let community = Community::read(&mut context.pool(), community_id).await?;
let actor = ApubPerson::from(actor);
let is_mod_action = reason.is_some();
let activity = if deleted {
let delete = Delete::new(&actor, object, public(), Some(&community), reason, &context)?;
AnnouncableActivities::Delete(delete)
} else {
let undo = UndoDelete::new(&actor, object, public(), Some(&community), reason, &context)?;
AnnouncableActivities::UndoDelete(undo)
};
send_activity_in_community(
activity,
&actor,
&community.into(),
vec![],
is_mod_action,
&context,
)
.await
}
#[tracing::instrument(skip_all)]
pub(crate) async fn send_apub_delete_private_message(
actor: &ApubPerson,
pm: PrivateMessage,
deleted: bool,
context: &Data<LemmyContext>,
context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
let recipient_id = pm.recipient_id;
let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
@ -215,11 +125,11 @@ async fn send_apub_delete_private_message(
let deletable = DeletableObjects::PrivateMessage(pm.into());
let inbox = vec![recipient.shared_inbox_or_inbox()];
if deleted {
let delete = Delete::new(actor, deletable, recipient.id(), None, None, context)?;
send_lemmy_activity(context, delete, actor, inbox, true).await?;
let delete = Delete::new(actor, deletable, recipient.id(), None, None, &context)?;
send_lemmy_activity(&context, delete, actor, inbox, true).await?;
} else {
let undo = UndoDelete::new(actor, deletable, recipient.id(), None, None, context)?;
send_lemmy_activity(context, undo, actor, inbox, true).await?;
let undo = UndoDelete::new(actor, deletable, recipient.id(), None, None, &context)?;
send_lemmy_activity(&context, undo, actor, inbox, true).await?;
};
Ok(())
}

32
crates/apub/src/activities/following/follow.rs
View File

@ -8,12 +8,7 @@ use crate::{
fetcher::user_or_community::UserOrCommunity,
insert_received_activity,
objects::{community::ApubCommunity, person::ApubPerson},
protocol::activities::following::{
accept::AcceptFollow,
follow::Follow,
undo_follow::UndoFollow,
},
SendActivity,
protocol::activities::following::{accept::AcceptFollow, follow::Follow},
};
use activitypub_federation::{
config::Data,
@ -21,17 +16,13 @@ use activitypub_federation::{
protocol::verification::verify_urls_match,
traits::{ActivityHandler, Actor},
};
use lemmy_api_common::{
community::{BlockCommunity, BlockCommunityResponse},
context::LemmyContext,
utils::local_user_view_from_jwt,
};
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::{
source::{
community::{Community, CommunityFollower, CommunityFollowerForm},
community::{CommunityFollower, CommunityFollowerForm},
person::{PersonFollower, PersonFollowerForm},
},
traits::{Crud, Followable},
traits::Followable,
};
use lemmy_utils::error::LemmyError;
use url::Url;
@ -128,18 +119,3 @@ impl ActivityHandler for Follow {
AcceptFollow::send(self, context).await
}
}
#[async_trait::async_trait]
impl SendActivity for BlockCommunity {
type Response = BlockCommunityResponse;
async fn send_activity(
request: &Self,
_response: &Self::Response,
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut context.pool(), request.community_id).await?;
UndoFollow::send(&local_user_view.person.into(), &community.into(), context).await
}
}

91
crates/apub/src/activities/mod.rs
View File

@ -1,11 +1,25 @@
use self::following::send_follow_community;
use crate::{
activities::{
deletion::{send_apub_delete_in_community, DeletableObjects},
block::{send_ban_from_community, send_ban_from_site},
community::{
collection_add::{send_add_mod_to_community, send_feature_post},
lock_page::send_lock_post,
update::send_update_community,
},
create_or_update::private_message::send_create_or_update_pm,
deletion::{
delete_user::delete_user,
send_apub_delete_in_community,
send_apub_delete_in_community_new,
send_apub_delete_private_message,
DeletableObjects,
},
voting::send_like_activity,
},
objects::{community::ApubCommunity, person::ApubPerson},
protocol::activities::{
community::report::Report,
create_or_update::{note::CreateOrUpdateNote, page::CreateOrUpdatePage},
CreateOrUpdateType,
},
@ -229,14 +243,46 @@ pub async fn match_outgoing_activities(
let fed_task = async {
use SendActivityData::*;
match data {
CreatePost(post) | UpdatePost(post) => {
CreatePost(post) => {
let creator_id = post.creator_id;
CreateOrUpdatePage::send(post, creator_id, CreateOrUpdateType::Create, context).await
}
CreateComment(comment) | UpdateComment(comment) => {
UpdatePost(post) => {
let creator_id = post.creator_id;
CreateOrUpdatePage::send(post, creator_id, CreateOrUpdateType::Update, context).await
}
DeletePost(post, person, data) => {
send_apub_delete_in_community_new(
person,
post.community_id,
DeletableObjects::Post(post.into()),
None,
data.deleted,
context,
)
.await
}
RemovePost(post, person, data) => {
send_apub_delete_in_community_new(
person,
post.community_id,
DeletableObjects::Post(post.into()),
data.reason.or_else(|| Some(String::new())),
data.removed,
context,
)
.await
}
LockPost(post, actor, locked) => send_lock_post(post, actor, locked, context).await,
FeaturePost(post, actor, featured) => send_feature_post(post, actor, featured, context).await,
CreateComment(comment) => {
let creator_id = comment.creator_id;
CreateOrUpdateNote::send(comment, creator_id, CreateOrUpdateType::Create, context).await
}
UpdateComment(comment) => {
let creator_id = comment.creator_id;
CreateOrUpdateNote::send(comment, creator_id, CreateOrUpdateType::Update, context).await
}
DeleteComment(comment, actor, community) => {
let is_deleted = comment.deleted;
let deletable = DeletableObjects::Comment(comment.into());
@ -251,9 +297,46 @@ pub async fn match_outgoing_activities(
LikePostOrComment(object_id, person, community, score) => {
send_like_activity(object_id, person, community, score, context).await
}
SendActivityData::FollowCommunity(community, person, follow) => {
FollowCommunity(community, person, follow) => {
send_follow_community(community, person, follow, &context).await
}
UpdateCommunity(actor, community) => send_update_community(community, actor, context).await,
DeleteCommunity(actor, community, removed) => {
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(actor, community, deletable, None, removed, &context).await
}
RemoveCommunity(actor, community, reason, removed) => {
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(
actor,
community,
deletable,
reason.clone().or_else(|| Some(String::new())),
removed,
&context,
)
.await
}
AddModToCommunity(actor, community_id, updated_mod_id, added) => {
send_add_mod_to_community(actor, community_id, updated_mod_id, added, context).await
}
BanFromCommunity(mod_, community_id, target, data) => {
send_ban_from_community(mod_, community_id, target, data, context).await
}
BanFromSite(mod_, target, data) => send_ban_from_site(mod_, target, data, context).await,
CreatePrivateMessage(pm) => {
send_create_or_update_pm(pm, CreateOrUpdateType::Create, context).await
}
UpdatePrivateMessage(pm) => {
send_create_or_update_pm(pm, CreateOrUpdateType::Update, context).await
}
DeletePrivateMessage(person, pm, deleted) => {
send_apub_delete_private_message(&person.into(), pm, deleted, context).await
}
DeleteUser(person) => delete_user(person, context).await,
CreateReport(url, actor, community, reason) => {
Report::send(ObjectId::from(url), actor, community, reason, context).await
}
}
};
if *SYNCHRONOUS_FEDERATION {

183
src/api_routes_http.rs
View File

@ -1,33 +1,30 @@
use actix_web::{guard, web, Error, HttpResponse, Result};
use lemmy_api::{
comment::{distinguish::distinguish_comment, like::like_comment, save::save_comment},
comment_report::{list::list_comment_reports, resolve::resolve_comment_report},
community::follow::follow_community,
local_user::notifications::mark_reply_read::mark_reply_as_read,
post::like::like_post,
comment_report::{
create::create_comment_report,
list::list_comment_reports,
resolve::resolve_comment_report,
},
community::{
add_mod::add_mod_to_community,
ban::ban_from_community,
block::block_community,
follow::follow_community,
hide::hide_community,
},
local_user::{ban_person::ban_from_site, notifications::mark_reply_read::mark_reply_as_read},
post::{feature::feature_post, like::like_post, lock::lock_post},
post_report::create::create_post_report,
Perform,
};
use lemmy_api_common::{
comment::CreateCommentReport,
community::{
AddModToCommunity,
BanFromCommunity,
BlockCommunity,
CreateCommunity,
DeleteCommunity,
EditCommunity,
HideCommunity,
RemoveCommunity,
TransferCommunity,
},
community::TransferCommunity,
context::LemmyContext,
custom_emoji::{CreateCustomEmoji, DeleteCustomEmoji, EditCustomEmoji},
person::{
AddAdmin,
BanPerson,
BlockPerson,
ChangePassword,
DeleteAccount,
GetBannedPersons,
GetCaptcha,
GetPersonMentions,
@ -39,27 +36,12 @@ use lemmy_api_common::{
MarkPersonMentionAsRead,
PasswordChangeAfterReset,
PasswordReset,
Register,
SaveUserSettings,
VerifyEmail,
},
post::{
CreatePostReport,
DeletePost,
FeaturePost,
GetSiteMetadata,
ListPostReports,
LockPost,
MarkPostAsRead,
RemovePost,
ResolvePostReport,
SavePost,
},
post::{GetSiteMetadata, ListPostReports, MarkPostAsRead, ResolvePostReport, SavePost},
private_message::{
CreatePrivateMessage,
CreatePrivateMessageReport,
DeletePrivateMessage,
EditPrivateMessage,
ListPrivateMessageReports,
MarkPrivateMessageAsRead,
ResolvePrivateMessageReport,
@ -85,11 +67,33 @@ use lemmy_api_crud::{
remove::remove_comment,
update::update_comment,
},
community::list::list_communities,
post::{create::create_post, read::get_post, update::update_post},
private_message::read::get_private_message,
community::{
create::create_community,
delete::delete_community,
list::list_communities,
remove::remove_community,
update::update_community,
},
custom_emoji::{
create::create_custom_emoji,
delete::delete_custom_emoji,
update::update_custom_emoji,
},
post::{
create::create_post,
delete::delete_post,
read::get_post,
remove::remove_post,
update::update_post,
},
private_message::{
create::create_private_message,
delete::delete_private_message,
read::get_private_message,
update::update_private_message,
},
site::{create::create_site, read::get_site, update::update_site},
PerformCrud,
user::{create::register, delete::delete_account},
};
use lemmy_apub::{
api::{
@ -137,29 +141,23 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
web::resource("/community")
.guard(guard::Post())
.wrap(rate_limit.register())
.route(web::post().to(route_post_crud::<CreateCommunity>)),
.route(web::post().to(create_community)),
)
.service(
web::scope("/community")
.wrap(rate_limit.message())
.route("", web::get().to(get_community))
.route("", web::put().to(route_post_crud::<EditCommunity>))
.route("/hide", web::put().to(route_post::<HideCommunity>))
.route("", web::put().to(update_community))
.route("/hide", web::put().to(hide_community))
.route("/list", web::get().to(list_communities))
.route("/follow", web::post().to(follow_community))
.route("/block", web::post().to(route_post::<BlockCommunity>))
.route(
"/delete",
web::post().to(route_post_crud::<DeleteCommunity>),
)
.route("/block", web::post().to(block_community))
.route("/delete", web::post().to(delete_community))
// Mod Actions
.route(
"/remove",
web::post().to(route_post_crud::<RemoveCommunity>),
)
.route("/remove", web::post().to(remove_community))
.route("/transfer", web::post().to(route_post::<TransferCommunity>))
.route("/ban_user", web::post().to(route_post::<BanFromCommunity>))
.route("/mod", web::post().to(route_post::<AddModToCommunity>)),
.route("/ban_user", web::post().to(ban_from_community))
.route("/mod", web::post().to(add_mod_to_community)),
)
.service(
web::scope("/federated_instances")
@ -179,18 +177,18 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
.wrap(rate_limit.message())
.route("", web::get().to(get_post))
.route("", web::put().to(update_post))
.route("/delete", web::post().to(route_post_crud::<DeletePost>))
.route("/remove", web::post().to(route_post_crud::<RemovePost>))
.route("/delete", web::post().to(delete_post))
.route("/remove", web::post().to(remove_post))
.route(
"/mark_as_read",
web::post().to(route_post::<MarkPostAsRead>),
)
.route("/lock", web::post().to(route_post::<LockPost>))
.route("/feature", web::post().to(route_post::<FeaturePost>))
.route("/lock", web::post().to(lock_post))
.route("/feature", web::post().to(feature_post))
.route("/list", web::get().to(list_posts))
.route("/like", web::post().to(like_post))
.route("/save", web::put().to(route_post::<SavePost>))
.route("/report", web::post().to(route_post::<CreatePostReport>))
.route("/report", web::post().to(create_post_report))
.route(
"/report/resolve",
web::put().to(route_post::<ResolvePostReport>),
@ -221,7 +219,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
.route("/like", web::post().to(like_comment))
.route("/save", web::put().to(save_comment))
.route("/list", web::get().to(list_comments))
.route("/report", web::post().to(route_post::<CreateCommentReport>))
.route("/report", web::post().to(create_comment_report))
.route("/report/resolve", web::put().to(resolve_comment_report))
.route("/report/list", web::get().to(list_comment_reports)),
)
@ -230,12 +228,9 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
web::scope("/private_message")
.wrap(rate_limit.message())
.route("/list", web::get().to(get_private_message))
.route("", web::post().to(route_post_crud::<CreatePrivateMessage>))
.route("", web::put().to(route_post_crud::<EditPrivateMessage>))
.route(
"/delete",
web::post().to(route_post_crud::<DeletePrivateMessage>),
)
.route("", web::post().to(create_private_message))
.route("", web::put().to(update_private_message))
.route("/delete", web::post().to(delete_private_message))
.route(
"/mark_as_read",
web::post().to(route_post::<MarkPrivateMessageAsRead>),
@ -260,7 +255,7 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
web::resource("/user/register")
.guard(guard::Post())
.wrap(rate_limit.register())
.route(web::post().to(route_post_crud::<Register>)),
.route(web::post().to(register)),
)
.service(
// Handle captcha separately
@ -280,15 +275,12 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
)
.route("/replies", web::get().to(route_get::<GetReplies>))
// Admin action. I don't like that it's in /user
.route("/ban", web::post().to(route_post::<BanPerson>))
.route("/ban", web::post().to(ban_from_site))
.route("/banned", web::get().to(route_get::<GetBannedPersons>))
.route("/block", web::post().to(route_post::<BlockPerson>))
// Account actions. I don't like that they're in /user maybe /accounts
.route("/login", web::post().to(route_post::<Login>))
.route(
"/delete_account",
web::post().to(route_post_crud::<DeleteAccount>),
)
.route("/delete_account", web::post().to(delete_account))
.route(
"/password_reset",
web::post().to(route_post::<PasswordReset>),
@ -343,12 +335,9 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
.service(
web::scope("/custom_emoji")
.wrap(rate_limit.message())
.route("", web::post().to(route_post_crud::<CreateCustomEmoji>))
.route("", web::put().to(route_post_crud::<EditCustomEmoji>))
.route(
"/delete",
web::post().to(route_post_crud::<DeleteCustomEmoji>),
),
.route("", web::post().to(create_custom_emoji))
.route("", web::put().to(update_custom_emoji))
.route("/delete", web::post().to(delete_custom_emoji)),
),
);
}
@ -408,43 +397,3 @@ where
{
perform::<Data>(data.0, context, apub_data).await
}
async fn perform_crud<'a, Data>(
data: Data,
context: web::Data<LemmyContext>,
apub_data: activitypub_federation::config::Data<LemmyContext>,
) -> Result<HttpResponse, Error>
where
Data: PerformCrud
+ SendActivity<Response = <Data as PerformCrud>::Response>
+ Clone
+ Deserialize<'a>
+ Send
+ 'static,
{
let res = data.perform(&context).await?;
let res_clone = res.clone();
let fed_task = async move { SendActivity::send_activity(&data, &res_clone, &apub_data).await };
if *SYNCHRONOUS_FEDERATION {
fed_task.await?;
} else {
spawn_try_task(fed_task);
}
Ok(HttpResponse::Ok().json(&res))
}
async fn route_post_crud<'a, Data>(
data: web::Json<Data>,
context: web::Data<LemmyContext>,
apub_data: activitypub_federation::config::Data<LemmyContext>,
) -> Result<HttpResponse, Error>
where
Data: PerformCrud
+ SendActivity<Response = <Data as PerformCrud>::Response>
+ Clone
+ Deserialize<'a>
+ Send
+ 'static,
{
perform_crud::<Data>(data.0, context, apub_data).await
}