Get rid of repetitive &mut *context.conn().await?

This commit is contained in:
dull b 2023-06-30 06:50:11 +00:00
parent 9d54354af4
commit d2c6263ea1
134 changed files with 820 additions and 1017 deletions

View file

@ -18,22 +18,24 @@ impl Perform for DistinguishComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DistinguishComment = self; let data: &DistinguishComment = self;
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?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let orig_comment = CommentView::read(&mut conn, comment_id, None).await?;
check_community_ban( check_community_ban(
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
&mut *context.conn().await?, &mut conn,
) )
.await?; .await?;
// Verify that only a mod or admin can distinguish a comment // Verify that only a mod or admin can distinguish a comment
is_mod_or_admin( is_mod_or_admin(
&mut *context.conn().await?, &mut conn,
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
) )
@ -44,14 +46,13 @@ impl Perform for DistinguishComment {
let form = CommentUpdateForm::builder() let form = CommentUpdateForm::builder()
.distinguished(Some(data.distinguished)) .distinguished(Some(data.distinguished))
.build(); .build();
Comment::update(&mut *context.conn().await?, comment_id, &form) Comment::update(&mut conn, comment_id, &form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let comment_view = let comment_view = CommentView::read(&mut conn, comment_id, Some(person_id)).await?;
CommentView::read(&mut *context.conn().await?, comment_id, Some(person_id)).await?;
Ok(CommentResponse { Ok(CommentResponse {
comment_view, comment_view,

View file

@ -24,8 +24,10 @@ impl Perform for CreateCommentLike {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateCommentLike = self; let data: &CreateCommentLike = self;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
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?;
let mut recipient_ids = Vec::<LocalUserId>::new(); let mut recipient_ids = Vec::<LocalUserId>::new();
@ -34,23 +36,20 @@ impl Perform for CreateCommentLike {
check_downvotes_enabled(data.score, &local_site)?; check_downvotes_enabled(data.score, &local_site)?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let orig_comment = CommentView::read(&mut conn, comment_id, None).await?;
check_community_ban( check_community_ban(
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
&mut *context.conn().await?, &mut conn,
) )
.await?; .await?;
// Add parent poster or commenter to recipients // Add parent poster or commenter to recipients
let comment_reply = let comment_reply = CommentReply::read_by_comment(&mut conn, comment_id).await;
CommentReply::read_by_comment(&mut *context.conn().await?, comment_id).await;
if let Ok(reply) = comment_reply { if let Ok(reply) = comment_reply {
let recipient_id = reply.recipient_id; let recipient_id = reply.recipient_id;
if let Ok(local_recipient) = if let Ok(local_recipient) = LocalUserView::read_person(&mut conn, recipient_id).await {
LocalUserView::read_person(&mut *context.conn().await?, recipient_id).await
{
recipient_ids.push(local_recipient.local_user.id); recipient_ids.push(local_recipient.local_user.id);
} }
} }
@ -65,12 +64,12 @@ impl Perform for CreateCommentLike {
// Remove any likes first // Remove any likes first
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
CommentLike::remove(&mut *context.conn().await?, person_id, comment_id).await?; CommentLike::remove(&mut conn, person_id, comment_id).await?;
// Only add the like if the score isnt 0 // Only add the like if the score isnt 0
let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1); let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
if do_add { if do_add {
CommentLike::like(&mut *context.conn().await?, &like_form) CommentLike::like(&mut conn, &like_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?;
} }

View file

@ -18,6 +18,7 @@ impl Perform for SaveComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &SaveComment = self; let data: &SaveComment = self;
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?;
@ -27,19 +28,18 @@ impl Perform for SaveComment {
}; };
if data.save { if data.save {
CommentSaved::save(&mut *context.conn().await?, &comment_saved_form) CommentSaved::save(&mut conn, &comment_saved_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
} else { } else {
CommentSaved::unsave(&mut *context.conn().await?, &comment_saved_form) CommentSaved::unsave(&mut conn, &comment_saved_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
} }
let comment_id = data.comment_id; let comment_id = data.comment_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let comment_view = let comment_view = CommentView::read(&mut conn, comment_id, Some(person_id)).await?;
CommentView::read(&mut *context.conn().await?, comment_id, Some(person_id)).await?;
Ok(CommentResponse { Ok(CommentResponse {
comment_view, comment_view,

View file

@ -25,23 +25,19 @@ impl Perform for CreateCommentReport {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<CommentReportResponse, LemmyError> { ) -> Result<CommentReportResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateCommentReport = self; let data: &CreateCommentReport = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let reason = self.reason.trim(); let reason = self.reason.trim();
check_report_reason(reason, &local_site)?; check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let comment_view = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let comment_view = CommentView::read(&mut conn, comment_id, None).await?;
check_community_ban( check_community_ban(person_id, comment_view.community.id, &mut conn).await?;
person_id,
comment_view.community.id,
&mut *context.conn().await?,
)
.await?;
let report_form = CommentReportForm { let report_form = CommentReportForm {
creator_id: person_id, creator_id: person_id,
@ -50,19 +46,18 @@ impl Perform for CreateCommentReport {
reason: reason.to_owned(), reason: reason.to_owned(),
}; };
let report = CommentReport::report(&mut *context.conn().await?, &report_form) let report = CommentReport::report(&mut conn, &report_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let comment_report_view = let comment_report_view = CommentReportView::read(&mut conn, report.id, person_id).await?;
CommentReportView::read(&mut *context.conn().await?, report.id, person_id).await?;
// Email the admins // Email the admins
if local_site.reports_email_admins { if local_site.reports_email_admins {
send_new_report_email_to_admins( send_new_report_email_to_admins(
&comment_report_view.creator.name, &comment_report_view.creator.name,
&comment_report_view.comment_creator.name, &comment_report_view.comment_creator.name,
&mut *context.conn().await?, &mut conn,
context.settings(), context.settings(),
) )
.await?; .await?;

View file

@ -30,6 +30,7 @@ impl Perform for ListCommentReports {
let page = data.page; let page = data.page;
let limit = data.limit; let limit = data.limit;
let mut conn = context.conn().await?; let mut conn = context.conn().await?;
let comment_reports = CommentReportQuery::builder() let comment_reports = CommentReportQuery::builder()
.conn(&mut conn) .conn(&mut conn)
.my_person_id(person_id) .my_person_id(person_id)

View file

@ -19,29 +19,29 @@ impl Perform for ResolveCommentReport {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<CommentReportResponse, LemmyError> { ) -> Result<CommentReportResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &ResolveCommentReport = self; let data: &ResolveCommentReport = self;
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?;
let report_id = data.report_id; let report_id = data.report_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let report = CommentReportView::read(&mut *context.conn().await?, report_id, person_id).await?; let report = CommentReportView::read(&mut conn, report_id, person_id).await?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
is_mod_or_admin(&mut *context.conn().await?, person_id, report.community.id).await?; is_mod_or_admin(&mut conn, person_id, report.community.id).await?;
if data.resolved { if data.resolved {
CommentReport::resolve(&mut *context.conn().await?, report_id, person_id) CommentReport::resolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} else { } else {
CommentReport::unresolve(&mut *context.conn().await?, report_id, person_id) CommentReport::unresolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} }
let report_id = data.report_id; let report_id = data.report_id;
let comment_report_view = let comment_report_view = CommentReportView::read(&mut conn, report_id, person_id).await?;
CommentReportView::read(&mut *context.conn().await?, report_id, person_id).await?;
Ok(CommentReportResponse { Ok(CommentReportResponse {
comment_report_view, comment_report_view,

View file

@ -24,19 +24,15 @@ impl Perform for AddModToCommunity {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<AddModToCommunityResponse, LemmyError> { ) -> Result<AddModToCommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &AddModToCommunity = self; let data: &AddModToCommunity = self;
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?;
let community_id = data.community_id; let community_id = data.community_id;
// Verify that only mods or admins can add mod // Verify that only mods or admins can add mod
is_mod_or_admin( is_mod_or_admin(&mut conn, local_user_view.person.id, community_id).await?;
&mut *context.conn().await?, let community = Community::read(&mut conn, community_id).await?;
local_user_view.person.id,
community_id,
)
.await?;
let community = Community::read(&mut *context.conn().await?, community_id).await?;
if local_user_view.person.admin && !community.local { if local_user_view.person.admin && !community.local {
return Err(LemmyError::from_message("not_a_moderator")); return Err(LemmyError::from_message("not_a_moderator"));
} }
@ -47,11 +43,11 @@ impl Perform for AddModToCommunity {
person_id: data.person_id, person_id: data.person_id,
}; };
if data.added { if data.added {
CommunityModerator::join(&mut *context.conn().await?, &community_moderator_form) CommunityModerator::join(&mut conn, &community_moderator_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
} else { } else {
CommunityModerator::leave(&mut *context.conn().await?, &community_moderator_form) CommunityModerator::leave(&mut conn, &community_moderator_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
} }
@ -64,13 +60,12 @@ impl Perform for AddModToCommunity {
removed: Some(!data.added), removed: Some(!data.added),
}; };
ModAddCommunity::create(&mut *context.conn().await?, &form).await?; ModAddCommunity::create(&mut conn, &form).await?;
// Note: in case a remote mod is added, this returns the old moderators list, it will only get // 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`) // updated once we receive an activity from the community (like `Announce/Add/Moderator`)
let community_id = data.community_id; let community_id = data.community_id;
let moderators = let moderators = CommunityModeratorView::for_community(&mut conn, community_id).await?;
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
Ok(AddModToCommunityResponse { moderators }) Ok(AddModToCommunityResponse { moderators })
} }

View file

@ -32,6 +32,7 @@ impl Perform for BanFromCommunity {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<BanFromCommunityResponse, LemmyError> { ) -> Result<BanFromCommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &BanFromCommunity = self; let data: &BanFromCommunity = self;
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?;
@ -41,12 +42,7 @@ impl Perform for BanFromCommunity {
let expires = data.expires.map(naive_from_unix); let expires = data.expires.map(naive_from_unix);
// Verify that only mods or admins can ban // Verify that only mods or admins can ban
is_mod_or_admin( is_mod_or_admin(&mut conn, local_user_view.person.id, community_id).await?;
&mut *context.conn().await?,
local_user_view.person.id,
community_id,
)
.await?;
is_valid_body_field(&data.reason, false)?; is_valid_body_field(&data.reason, false)?;
let community_user_ban_form = CommunityPersonBanForm { let community_user_ban_form = CommunityPersonBanForm {
@ -56,7 +52,7 @@ impl Perform for BanFromCommunity {
}; };
if data.ban { if data.ban {
CommunityPersonBan::ban(&mut *context.conn().await?, &community_user_ban_form) CommunityPersonBan::ban(&mut conn, &community_user_ban_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?; .map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
@ -67,19 +63,18 @@ impl Perform for BanFromCommunity {
pending: false, pending: false,
}; };
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::unfollow(&mut conn, &community_follower_form)
.await .await
.ok(); .ok();
} else { } else {
CommunityPersonBan::unban(&mut *context.conn().await?, &community_user_ban_form) CommunityPersonBan::unban(&mut conn, &community_user_ban_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?; .map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
} }
// Remove/Restore their data if that's desired // Remove/Restore their data if that's desired
if remove_data { if remove_data {
remove_user_data_in_community(community_id, banned_person_id, &mut *context.conn().await?) remove_user_data_in_community(community_id, banned_person_id, &mut conn).await?;
.await?;
} }
// Mod tables // Mod tables
@ -92,10 +87,10 @@ impl Perform for BanFromCommunity {
expires, expires,
}; };
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?; ModBanFromCommunity::create(&mut conn, &form).await?;
let person_id = data.person_id; let person_id = data.person_id;
let person_view = PersonView::read(&mut *context.conn().await?, person_id).await?; let person_view = PersonView::read(&mut conn, person_id).await?;
Ok(BanFromCommunityResponse { Ok(BanFromCommunityResponse {
person_view, person_view,

View file

@ -24,6 +24,7 @@ impl Perform for BlockCommunity {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<BlockCommunityResponse, LemmyError> { ) -> Result<BlockCommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &BlockCommunity = self; let data: &BlockCommunity = self;
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?;
@ -35,7 +36,7 @@ impl Perform for BlockCommunity {
}; };
if data.block { if data.block {
CommunityBlock::block(&mut *context.conn().await?, &community_block_form) CommunityBlock::block(&mut conn, &community_block_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
@ -46,22 +47,17 @@ impl Perform for BlockCommunity {
pending: false, pending: false,
}; };
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::unfollow(&mut conn, &community_follower_form)
.await .await
.ok(); .ok();
} else { } else {
CommunityBlock::unblock(&mut *context.conn().await?, &community_block_form) CommunityBlock::unblock(&mut conn, &community_block_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
} }
let community_view = CommunityView::read( let community_view =
&mut *context.conn().await?, CommunityView::read(&mut conn, community_id, Some(person_id), None).await?;
community_id,
Some(person_id),
None,
)
.await?;
Ok(BlockCommunityResponse { Ok(BlockCommunityResponse {
blocked: data.block, blocked: data.block,

View file

@ -21,11 +21,12 @@ impl Perform for FollowCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &FollowCommunity = self; let data: &FollowCommunity = self;
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?;
let community_id = data.community_id; let community_id = data.community_id;
let community = Community::read(&mut *context.conn().await?, community_id).await?; let community = Community::read(&mut conn, community_id).await?;
let community_follower_form = CommunityFollowerForm { let community_follower_form = CommunityFollowerForm {
community_id: data.community_id, community_id: data.community_id,
person_id: local_user_view.person.id, person_id: local_user_view.person.id,
@ -33,35 +34,24 @@ impl Perform for FollowCommunity {
}; };
if community.local && data.follow { if community.local && data.follow {
check_community_ban( check_community_ban(local_user_view.person.id, community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(community_id, &mut conn).await?;
community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(community_id, &mut *context.conn().await?).await?;
CommunityFollower::follow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::follow(&mut conn, &community_follower_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
} }
if !data.follow { if !data.follow {
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::unfollow(&mut conn, &community_follower_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
} }
let community_id = data.community_id; let community_id = data.community_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let community_view = CommunityView::read( let community_view =
&mut *context.conn().await?, CommunityView::read(&mut conn, community_id, Some(person_id), None).await?;
community_id, let discussion_languages = CommunityLanguage::read(&mut conn, community_id).await?;
Some(person_id),
None,
)
.await?;
let discussion_languages =
CommunityLanguage::read(&mut *context.conn().await?, community_id).await?;
Ok(Self::Response { Ok(Self::Response {
community_view, community_view,

View file

@ -21,6 +21,7 @@ impl Perform for HideCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &HideCommunity = self; let data: &HideCommunity = self;
// Verify its a admin (only admin can hide or unhide it) // Verify its a admin (only admin can hide or unhide it)
@ -39,11 +40,11 @@ impl Perform for HideCommunity {
}; };
let community_id = data.community_id; let community_id = data.community_id;
Community::update(&mut *context.conn().await?, community_id, &community_form) Community::update(&mut conn, community_id, &community_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community_hidden_status"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community_hidden_status"))?;
ModHideCommunity::create(&mut *context.conn().await?, &mod_hide_community_form).await?; ModHideCommunity::create(&mut conn, &mod_hide_community_form).await?;
build_community_response(context, local_user_view, community_id).await build_community_response(context, local_user_view, community_id).await
} }

View file

@ -27,13 +27,13 @@ impl Perform for TransferCommunity {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<GetCommunityResponse, LemmyError> { ) -> Result<GetCommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &TransferCommunity = self; let data: &TransferCommunity = self;
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?;
// Fetch the community mods // Fetch the community mods
let community_id = data.community_id; let community_id = data.community_id;
let mut community_mods = let mut community_mods = CommunityModeratorView::for_community(&mut conn, community_id).await?;
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
// Make sure transferrer is either the top community mod, or an admin // Make sure transferrer is either the top community mod, or an admin
if !(is_top_mod(&local_user_view, &community_mods).is_ok() if !(is_top_mod(&local_user_view, &community_mods).is_ok()
@ -54,7 +54,7 @@ impl Perform for TransferCommunity {
// Delete all the mods // Delete all the mods
let community_id = data.community_id; let community_id = data.community_id;
CommunityModerator::delete_for_community(&mut *context.conn().await?, community_id).await?; CommunityModerator::delete_for_community(&mut conn, community_id).await?;
// TODO: this should probably be a bulk operation // TODO: this should probably be a bulk operation
// Re-add the mods, in the new order // Re-add the mods, in the new order
@ -64,7 +64,7 @@ impl Perform for TransferCommunity {
person_id: cmod.moderator.id, person_id: cmod.moderator.id,
}; };
CommunityModerator::join(&mut *context.conn().await?, &community_moderator_form) CommunityModerator::join(&mut conn, &community_moderator_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
} }
@ -76,22 +76,16 @@ impl Perform for TransferCommunity {
community_id: data.community_id, community_id: data.community_id,
}; };
ModTransferCommunity::create(&mut *context.conn().await?, &form).await?; ModTransferCommunity::create(&mut conn, &form).await?;
let community_id = data.community_id; let community_id = data.community_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let community_view = CommunityView::read( let community_view = CommunityView::read(&mut conn, community_id, Some(person_id), None)
&mut *context.conn().await?,
community_id,
Some(person_id),
None,
)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
let community_id = data.community_id; let community_id = data.community_id;
let moderators = let moderators = CommunityModeratorView::for_community(&mut conn, community_id)
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;

View file

@ -21,6 +21,7 @@ impl Perform for AddAdmin {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<AddAdminResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<AddAdminResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &AddAdmin = self; let data: &AddAdmin = self;
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?;
@ -30,7 +31,7 @@ impl Perform for AddAdmin {
let added = data.added; let added = data.added;
let added_person_id = data.person_id; let added_person_id = data.person_id;
let added_admin = Person::update( let added_admin = Person::update(
&mut *context.conn().await?, &mut conn,
added_person_id, added_person_id,
&PersonUpdateForm::builder().admin(Some(added)).build(), &PersonUpdateForm::builder().admin(Some(added)).build(),
) )
@ -44,9 +45,9 @@ impl Perform for AddAdmin {
removed: Some(!data.added), removed: Some(!data.added),
}; };
ModAdd::create(&mut *context.conn().await?, &form).await?; ModAdd::create(&mut conn, &form).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?; let admins = PersonView::admins(&mut conn).await?;
Ok(AddAdminResponse { admins }) Ok(AddAdminResponse { admins })
} }

View file

@ -24,6 +24,7 @@ impl Perform for BanPerson {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<BanPersonResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<BanPersonResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &BanPerson = self; let data: &BanPerson = self;
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?;
@ -37,7 +38,7 @@ impl Perform for BanPerson {
let expires = data.expires.map(naive_from_unix); let expires = data.expires.map(naive_from_unix);
let person = Person::update( let person = Person::update(
&mut *context.conn().await?, &mut conn,
banned_person_id, banned_person_id,
&PersonUpdateForm::builder() &PersonUpdateForm::builder()
.banned(Some(ban)) .banned(Some(ban))
@ -50,13 +51,7 @@ impl Perform for BanPerson {
// Remove their data if that's desired // Remove their data if that's desired
let remove_data = data.remove_data.unwrap_or(false); let remove_data = data.remove_data.unwrap_or(false);
if remove_data { if remove_data {
remove_user_data( remove_user_data(person.id, &mut conn, context.settings(), context.client()).await?;
person.id,
&mut *context.conn().await?,
context.settings(),
context.client(),
)
.await?;
} }
// Mod tables // Mod tables
@ -68,10 +63,10 @@ impl Perform for BanPerson {
expires, expires,
}; };
ModBan::create(&mut *context.conn().await?, &form).await?; ModBan::create(&mut conn, &form).await?;
let person_id = data.person_id; let person_id = data.person_id;
let person_view = PersonView::read(&mut *context.conn().await?, person_id).await?; let person_view = PersonView::read(&mut conn, person_id).await?;
Ok(BanPersonResponse { Ok(BanPersonResponse {
person_view, person_view,

View file

@ -18,6 +18,7 @@ impl Perform for BlockPerson {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<BlockPersonResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<BlockPersonResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &BlockPerson = self; let data: &BlockPerson = self;
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?;
@ -34,18 +35,18 @@ impl Perform for BlockPerson {
target_id, target_id,
}; };
let target_person_view = PersonView::read(&mut *context.conn().await?, target_id).await?; let target_person_view = PersonView::read(&mut conn, target_id).await?;
if target_person_view.person.admin { if target_person_view.person.admin {
return Err(LemmyError::from_message("cant_block_admin")); return Err(LemmyError::from_message("cant_block_admin"));
} }
if data.block { if data.block {
PersonBlock::block(&mut *context.conn().await?, &person_block_form) PersonBlock::block(&mut conn, &person_block_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
} else { } else {
PersonBlock::unblock(&mut *context.conn().await?, &person_block_form) PersonBlock::unblock(&mut conn, &person_block_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
} }

View file

@ -15,6 +15,7 @@ impl Perform for ChangePassword {
#[tracing::instrument(skip(self, context))] #[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &ChangePassword = self; let data: &ChangePassword = self;
let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), context).await?; let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), context).await?;
@ -38,7 +39,7 @@ impl Perform for ChangePassword {
let local_user_id = local_user_view.local_user.id; let local_user_id = local_user_view.local_user.id;
let new_password = data.new_password.clone(); let new_password = data.new_password.clone();
let updated_local_user = let updated_local_user =
LocalUser::update_password(&mut *context.conn().await?, local_user_id, &new_password).await?; LocalUser::update_password(&mut conn, local_user_id, &new_password).await?;
// Return the jwt // Return the jwt
Ok(LoginResponse { Ok(LoginResponse {

View file

@ -18,11 +18,12 @@ impl Perform for PasswordChangeAfterReset {
#[tracing::instrument(skip(self, context))] #[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &PasswordChangeAfterReset = self; let data: &PasswordChangeAfterReset = self;
// Fetch the user_id from the token // Fetch the user_id from the token
let token = data.token.clone(); let token = data.token.clone();
let local_user_id = PasswordResetRequest::read_from_token(&mut *context.conn().await?, &token) let local_user_id = PasswordResetRequest::read_from_token(&mut conn, &token)
.await .await
.map(|p| p.local_user_id)?; .map(|p| p.local_user_id)?;
@ -35,13 +36,12 @@ impl Perform for PasswordChangeAfterReset {
// Update the user with the new password // Update the user with the new password
let password = data.password.clone(); let password = data.password.clone();
let updated_local_user = let updated_local_user = LocalUser::update_password(&mut conn, local_user_id, &password)
LocalUser::update_password(&mut *context.conn().await?, local_user_id, &password)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_user"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_user"))?;
// Return the jwt if login is allowed // Return the jwt if login is allowed
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let jwt = if site_view.local_site.registration_mode == RegistrationMode::RequireApplication let jwt = if site_view.local_site.registration_mode == RegistrationMode::RequireApplication
&& !updated_local_user.accepted_application && !updated_local_user.accepted_application
{ {

View file

@ -17,7 +17,8 @@ impl Perform for GetCaptcha {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let mut conn = context.conn().await?;
let local_site = LocalSite::read(&mut conn).await?;
if !local_site.captcha_enabled { if !local_site.captcha_enabled {
return Ok(GetCaptchaResponse { ok: None }); return Ok(GetCaptchaResponse { ok: None });

View file

@ -13,13 +13,14 @@ impl Perform for GetBannedPersons {
type Response = BannedPersonsResponse; type Response = BannedPersonsResponse;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetBannedPersons = self; let data: &GetBannedPersons = self;
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?;
// Make sure user is an admin // Make sure user is an admin
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
let banned = PersonView::banned(&mut *context.conn().await?).await?; let banned = PersonView::banned(&mut conn).await?;
Ok(Self::Response { banned }) Ok(Self::Response { banned })
} }

View file

@ -15,14 +15,14 @@ impl Perform for Login {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &Login = self; let data: &Login = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
// Fetch that username / email // Fetch that username / email
let username_or_email = data.username_or_email.clone(); let username_or_email = data.username_or_email.clone();
let local_user_view = let local_user_view = LocalUserView::find_by_email_or_name(&mut conn, &username_or_email)
LocalUserView::find_by_email_or_name(&mut *context.conn().await?, &username_or_email)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;
@ -50,12 +50,7 @@ impl Perform for Login {
return Err(LemmyError::from_message("email_not_verified")); return Err(LemmyError::from_message("email_not_verified"));
} }
check_registration_application( check_registration_application(&local_user_view, &site_view.local_site, &mut conn).await?;
&local_user_view,
&site_view.local_site,
&mut *context.conn().await?,
)
.await?;
// Check the totp // Check the totp
check_totp_2fa_valid( check_totp_2fa_valid(

View file

@ -18,22 +18,23 @@ impl Perform for MarkAllAsRead {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetRepliesResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetRepliesResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &MarkAllAsRead = self; let data: &MarkAllAsRead = self;
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?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
// Mark all comment_replies as read // Mark all comment_replies as read
CommentReply::mark_all_as_read(&mut *context.conn().await?, person_id) CommentReply::mark_all_as_read(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Mark all user mentions as read // Mark all user mentions as read
PersonMention::mark_all_as_read(&mut *context.conn().await?, person_id) PersonMention::mark_all_as_read(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Mark all private_messages as read // Mark all private_messages as read
PrivateMessage::mark_all_as_read(&mut *context.conn().await?, person_id) PrivateMessage::mark_all_as_read(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;

View file

@ -21,12 +21,12 @@ impl Perform for MarkPersonMentionAsRead {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PersonMentionResponse, LemmyError> { ) -> Result<PersonMentionResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &MarkPersonMentionAsRead = self; let data: &MarkPersonMentionAsRead = self;
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?;
let person_mention_id = data.person_mention_id; let person_mention_id = data.person_mention_id;
let read_person_mention = let read_person_mention = PersonMention::read(&mut conn, person_mention_id).await?;
PersonMention::read(&mut *context.conn().await?, person_mention_id).await?;
if local_user_view.person.id != read_person_mention.recipient_id { if local_user_view.person.id != read_person_mention.recipient_id {
return Err(LemmyError::from_message("couldnt_update_comment")); return Err(LemmyError::from_message("couldnt_update_comment"));
@ -35,7 +35,7 @@ impl Perform for MarkPersonMentionAsRead {
let person_mention_id = read_person_mention.id; let person_mention_id = read_person_mention.id;
let read = Some(data.read); let read = Some(data.read);
PersonMention::update( PersonMention::update(
&mut *context.conn().await?, &mut conn,
person_mention_id, person_mention_id,
&PersonMentionUpdateForm { read }, &PersonMentionUpdateForm { read },
) )
@ -44,12 +44,8 @@ impl Perform for MarkPersonMentionAsRead {
let person_mention_id = read_person_mention.id; let person_mention_id = read_person_mention.id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let person_mention_view = PersonMentionView::read( let person_mention_view =
&mut *context.conn().await?, PersonMentionView::read(&mut conn, person_mention_id, Some(person_id)).await?;
person_mention_id,
Some(person_id),
)
.await?;
Ok(PersonMentionResponse { Ok(PersonMentionResponse {
person_mention_view, person_mention_view,

View file

@ -21,12 +21,12 @@ impl Perform for MarkCommentReplyAsRead {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<CommentReplyResponse, LemmyError> { ) -> Result<CommentReplyResponse, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
let comment_reply_id = data.comment_reply_id; let comment_reply_id = data.comment_reply_id;
let read_comment_reply = let read_comment_reply = CommentReply::read(&mut conn, comment_reply_id).await?;
CommentReply::read(&mut *context.conn().await?, comment_reply_id).await?;
if local_user_view.person.id != read_comment_reply.recipient_id { if local_user_view.person.id != read_comment_reply.recipient_id {
return Err(LemmyError::from_message("couldnt_update_comment")); return Err(LemmyError::from_message("couldnt_update_comment"));
@ -36,7 +36,7 @@ impl Perform for MarkCommentReplyAsRead {
let read = Some(data.read); let read = Some(data.read);
CommentReply::update( CommentReply::update(
&mut *context.conn().await?, &mut conn,
comment_reply_id, comment_reply_id,
&CommentReplyUpdateForm { read }, &CommentReplyUpdateForm { read },
) )
@ -45,12 +45,8 @@ impl Perform for MarkCommentReplyAsRead {
let comment_reply_id = read_comment_reply.id; let comment_reply_id = read_comment_reply.id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let comment_reply_view = CommentReplyView::read( let comment_reply_view =
&mut *context.conn().await?, CommentReplyView::read(&mut conn, comment_reply_id, Some(person_id)).await?;
comment_reply_id,
Some(person_id),
)
.await?;
Ok(CommentReplyResponse { comment_reply_view }) Ok(CommentReplyResponse { comment_reply_view })
} }

View file

@ -15,19 +15,17 @@ impl Perform for GetUnreadCount {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let replies = let replies = CommentReplyView::get_unread_replies(&mut conn, person_id).await?;
CommentReplyView::get_unread_replies(&mut *context.conn().await?, person_id).await?;
let mentions = let mentions = PersonMentionView::get_unread_mentions(&mut conn, person_id).await?;
PersonMentionView::get_unread_mentions(&mut *context.conn().await?, person_id).await?;
let private_messages = let private_messages = PrivateMessageView::get_unread_messages(&mut conn, person_id).await?;
PrivateMessageView::get_unread_messages(&mut *context.conn().await?, person_id).await?;
Ok(Self::Response { Ok(Self::Response {
replies, replies,

View file

@ -17,6 +17,7 @@ impl Perform for GetReportCount {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<GetReportCountResponse, LemmyError> { ) -> Result<GetReportCountResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetReportCount = self; let data: &GetReportCount = self;
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?;
@ -24,20 +25,14 @@ impl Perform for GetReportCount {
let admin = local_user_view.person.admin; let admin = local_user_view.person.admin;
let community_id = data.community_id; let community_id = data.community_id;
let comment_reports = CommentReportView::get_report_count( let comment_reports =
&mut *context.conn().await?, CommentReportView::get_report_count(&mut conn, person_id, admin, community_id).await?;
person_id,
admin,
community_id,
)
.await?;
let post_reports = let post_reports =
PostReportView::get_report_count(&mut *context.conn().await?, person_id, admin, community_id) PostReportView::get_report_count(&mut conn, person_id, admin, community_id).await?;
.await?;
let private_message_reports = if admin && community_id.is_none() { let private_message_reports = if admin && community_id.is_none() {
Some(PrivateMessageReportView::get_report_count(&mut *context.conn().await?).await?) Some(PrivateMessageReportView::get_report_count(&mut conn).await?)
} else { } else {
None None
}; };

View file

@ -18,17 +18,18 @@ impl Perform for PasswordReset {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PasswordResetResponse, LemmyError> { ) -> Result<PasswordResetResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &PasswordReset = self; let data: &PasswordReset = self;
// Fetch that email // Fetch that email
let email = data.email.to_lowercase(); let email = data.email.to_lowercase();
let local_user_view = LocalUserView::find_by_email(&mut *context.conn().await?, &email) let local_user_view = LocalUserView::find_by_email(&mut conn, &email)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;
// Check for too many attempts (to limit potential abuse) // Check for too many attempts (to limit potential abuse)
let recent_resets_count = PasswordResetRequest::get_recent_password_resets_count( let recent_resets_count = PasswordResetRequest::get_recent_password_resets_count(
&mut *context.conn().await?, &mut conn,
local_user_view.local_user.id, local_user_view.local_user.id,
) )
.await?; .await?;
@ -37,12 +38,7 @@ impl Perform for PasswordReset {
} }
// Email the pure token to the user. // Email the pure token to the user.
send_password_reset_email( send_password_reset_email(&local_user_view, &mut conn, context.settings()).await?;
&local_user_view,
&mut *context.conn().await?,
context.settings(),
)
.await?;
Ok(PasswordResetResponse {}) Ok(PasswordResetResponse {})
} }
} }

View file

@ -33,9 +33,10 @@ impl Perform for SaveUserSettings {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &SaveUserSettings = self; let data: &SaveUserSettings = self;
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?;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let avatar = diesel_option_overwrite_to_url(&data.avatar)?; let avatar = diesel_option_overwrite_to_url(&data.avatar)?;
let banner = diesel_option_overwrite_to_url(&data.banner)?; let banner = diesel_option_overwrite_to_url(&data.banner)?;
@ -49,13 +50,7 @@ impl Perform for SaveUserSettings {
let previous_email = local_user_view.local_user.email.clone().unwrap_or_default(); let previous_email = local_user_view.local_user.email.clone().unwrap_or_default();
// Only send the verification email if there was an email change // Only send the verification email if there was an email change
if previous_email.ne(email) { if previous_email.ne(email) {
send_verification_email( send_verification_email(&local_user_view, email, &mut conn, context.settings()).await?;
&local_user_view,
email,
&mut *context.conn().await?,
context.settings(),
)
.await?;
} }
} }
@ -95,17 +90,12 @@ impl Perform for SaveUserSettings {
.banner(banner) .banner(banner)
.build(); .build();
Person::update(&mut *context.conn().await?, person_id, &person_form) Person::update(&mut conn, person_id, &person_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
if let Some(discussion_languages) = data.discussion_languages.clone() { if let Some(discussion_languages) = data.discussion_languages.clone() {
LocalUserLanguage::update( LocalUserLanguage::update(&mut conn, discussion_languages, local_user_id).await?;
&mut *context.conn().await?,
discussion_languages,
local_user_id,
)
.await?;
} }
// If generate_totp is Some(false), this will clear it out from the database. // If generate_totp is Some(false), this will clear it out from the database.
@ -139,8 +129,7 @@ impl Perform for SaveUserSettings {
.totp_2fa_url(totp_2fa_url) .totp_2fa_url(totp_2fa_url)
.build(); .build();
let local_user_res = let local_user_res = LocalUser::update(&mut conn, local_user_id, &local_user_form).await;
LocalUser::update(&mut *context.conn().await?, local_user_id, &local_user_form).await;
let updated_local_user = match local_user_res { let updated_local_user = match local_user_res {
Ok(u) => u, Ok(u) => u,
Err(e) => { Err(e) => {

View file

@ -18,8 +18,9 @@ impl Perform for VerifyEmail {
type Response = VerifyEmailResponse; type Response = VerifyEmailResponse;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let token = self.token.clone(); let token = self.token.clone();
let verification = EmailVerification::read_for_token(&mut *context.conn().await?, &token) let verification = EmailVerification::read_for_token(&mut conn, &token)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "token_not_found"))?; .map_err(|e| LemmyError::from_error_message(e, "token_not_found"))?;
@ -31,10 +32,9 @@ impl Perform for VerifyEmail {
.build(); .build();
let local_user_id = verification.local_user_id; let local_user_id = verification.local_user_id;
LocalUser::update(&mut *context.conn().await?, local_user_id, &form).await?; LocalUser::update(&mut conn, local_user_id, &form).await?;
EmailVerification::delete_old_tokens_for_local_user(&mut *context.conn().await?, local_user_id) EmailVerification::delete_old_tokens_for_local_user(&mut conn, local_user_id).await?;
.await?;
Ok(VerifyEmailResponse {}) Ok(VerifyEmailResponse {})
} }

View file

@ -28,28 +28,19 @@ impl Perform for FeaturePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &FeaturePost = self; let data: &FeaturePost = self;
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?;
let post_id = data.post_id; let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?; let orig_post = Post::read(&mut conn, post_id).await?;
check_community_ban( check_community_ban(local_user_view.person.id, orig_post.community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(orig_post.community_id, &mut conn).await?;
orig_post.community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(orig_post.community_id, &mut *context.conn().await?).await?;
if data.feature_type == PostFeatureType::Community { if data.feature_type == PostFeatureType::Community {
// Verify that only the mods can feature in community // Verify that only the mods can feature in community
is_mod_or_admin( is_mod_or_admin(&mut conn, local_user_view.person.id, orig_post.community_id).await?;
&mut *context.conn().await?,
local_user_view.person.id,
orig_post.community_id,
)
.await?;
} else { } else {
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
} }
@ -65,7 +56,7 @@ impl Perform for FeaturePost {
.featured_local(Some(data.featured)) .featured_local(Some(data.featured))
.build() .build()
}; };
Post::update(&mut *context.conn().await?, post_id, &new_post).await?; Post::update(&mut conn, post_id, &new_post).await?;
// Mod tables // Mod tables
let form = ModFeaturePostForm { let form = ModFeaturePostForm {
@ -75,7 +66,7 @@ impl Perform for FeaturePost {
is_featured_community: data.feature_type == PostFeatureType::Community, is_featured_community: data.feature_type == PostFeatureType::Community,
}; };
ModFeaturePost::create(&mut *context.conn().await?, &form).await?; ModFeaturePost::create(&mut conn, &form).await?;
build_post_response( build_post_response(
context, context,

View file

@ -27,24 +27,20 @@ impl Perform for CreatePostLike {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreatePostLike = self; let data: &CreatePostLike = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Don't do a downvote if site has downvotes disabled // Don't do a downvote if site has downvotes disabled
check_downvotes_enabled(data.score, &local_site)?; check_downvotes_enabled(data.score, &local_site)?;
// Check for a community ban // Check for a community ban
let post_id = data.post_id; let post_id = data.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
check_community_ban( check_community_ban(local_user_view.person.id, post.community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(post.community_id, &mut conn).await?;
post.community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(post.community_id, &mut *context.conn().await?).await?;
let like_form = PostLikeForm { let like_form = PostLikeForm {
post_id: data.post_id, post_id: data.post_id,
@ -55,18 +51,18 @@ impl Perform for CreatePostLike {
// Remove any likes first // Remove any likes first
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
PostLike::remove(&mut *context.conn().await?, person_id, post_id).await?; PostLike::remove(&mut conn, person_id, post_id).await?;
// Only add the like if the score isnt 0 // Only add the like if the score isnt 0
let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1); let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
if do_add { if do_add {
PostLike::like(&mut *context.conn().await?, &like_form) PostLike::like(&mut conn, &like_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?;
} }
// Mark the post as read // Mark the post as read
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_read(person_id, post_id, &mut conn).await?;
build_post_response( build_post_response(
context, context,

View file

@ -26,33 +26,24 @@ impl Perform for LockPost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &LockPost = self; let data: &LockPost = self;
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?;
let post_id = data.post_id; let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?; let orig_post = Post::read(&mut conn, post_id).await?;
check_community_ban( check_community_ban(local_user_view.person.id, orig_post.community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(orig_post.community_id, &mut conn).await?;
orig_post.community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(orig_post.community_id, &mut *context.conn().await?).await?;
// Verify that only the mods can lock // Verify that only the mods can lock
is_mod_or_admin( is_mod_or_admin(&mut conn, local_user_view.person.id, orig_post.community_id).await?;
&mut *context.conn().await?,
local_user_view.person.id,
orig_post.community_id,
)
.await?;
// Update the post // Update the post
let post_id = data.post_id; let post_id = data.post_id;
let locked = data.locked; let locked = data.locked;
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post_id, post_id,
&PostUpdateForm::builder().locked(Some(locked)).build(), &PostUpdateForm::builder().locked(Some(locked)).build(),
) )
@ -64,7 +55,7 @@ impl Perform for LockPost {
post_id: data.post_id, post_id: data.post_id,
locked: Some(locked), locked: Some(locked),
}; };
ModLockPost::create(&mut *context.conn().await?, &form).await?; ModLockPost::create(&mut conn, &form).await?;
build_post_response( build_post_response(
context, context,

View file

@ -14,6 +14,7 @@ impl Perform for MarkPostAsRead {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
@ -22,14 +23,13 @@ impl Perform for MarkPostAsRead {
// Mark the post as read / unread // Mark the post as read / unread
if data.read { if data.read {
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_read(person_id, post_id, &mut conn).await?;
} else { } else {
mark_post_as_unread(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_unread(person_id, post_id, &mut conn).await?;
} }
// Fetch it // Fetch it
let post_view = let post_view = PostView::read(&mut conn, post_id, Some(person_id), None).await?;
PostView::read(&mut *context.conn().await?, post_id, Some(person_id), None).await?;
Ok(Self::Response { post_view }) Ok(Self::Response { post_view })
} }

View file

@ -18,6 +18,7 @@ impl Perform for SavePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &SavePost = self; let data: &SavePost = self;
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?;
@ -27,22 +28,21 @@ impl Perform for SavePost {
}; };
if data.save { if data.save {
PostSaved::save(&mut *context.conn().await?, &post_saved_form) PostSaved::save(&mut conn, &post_saved_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
} else { } else {
PostSaved::unsave(&mut *context.conn().await?, &post_saved_form) PostSaved::unsave(&mut conn, &post_saved_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
} }
let post_id = data.post_id; let post_id = data.post_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let post_view = let post_view = PostView::read(&mut conn, post_id, Some(person_id), None).await?;
PostView::read(&mut *context.conn().await?, post_id, Some(person_id), None).await?;
// Mark the post as read // Mark the post as read
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_read(person_id, post_id, &mut conn).await?;
Ok(PostResponse { post_view }) Ok(PostResponse { post_view })
} }

View file

@ -22,23 +22,19 @@ impl Perform for CreatePostReport {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreatePostReport = self; let data: &CreatePostReport = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let reason = self.reason.trim(); let reason = self.reason.trim();
check_report_reason(reason, &local_site)?; check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let post_id = data.post_id; let post_id = data.post_id;
let post_view = PostView::read(&mut *context.conn().await?, post_id, None, None).await?; let post_view = PostView::read(&mut conn, post_id, None, None).await?;
check_community_ban( check_community_ban(person_id, post_view.community.id, &mut conn).await?;
person_id,
post_view.community.id,
&mut *context.conn().await?,
)
.await?;
let report_form = PostReportForm { let report_form = PostReportForm {
creator_id: person_id, creator_id: person_id,
@ -49,19 +45,18 @@ impl Perform for CreatePostReport {
reason: reason.to_owned(), reason: reason.to_owned(),
}; };
let report = PostReport::report(&mut *context.conn().await?, &report_form) let report = PostReport::report(&mut conn, &report_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let post_report_view = let post_report_view = PostReportView::read(&mut conn, report.id, person_id).await?;
PostReportView::read(&mut *context.conn().await?, report.id, person_id).await?;
// Email the admins // Email the admins
if local_site.reports_email_admins { if local_site.reports_email_admins {
send_new_report_email_to_admins( send_new_report_email_to_admins(
&post_report_view.creator.name, &post_report_view.creator.name,
&post_report_view.post_creator.name, &post_report_view.post_creator.name,
&mut *context.conn().await?, &mut conn,
context.settings(), context.settings(),
) )
.await?; .await?;

View file

@ -16,28 +16,28 @@ impl Perform for ResolvePostReport {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &ResolvePostReport = self; let data: &ResolvePostReport = self;
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?;
let report_id = data.report_id; let report_id = data.report_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let report = PostReportView::read(&mut *context.conn().await?, report_id, person_id).await?; let report = PostReportView::read(&mut conn, report_id, person_id).await?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
is_mod_or_admin(&mut *context.conn().await?, person_id, report.community.id).await?; is_mod_or_admin(&mut conn, person_id, report.community.id).await?;
if data.resolved { if data.resolved {
PostReport::resolve(&mut *context.conn().await?, report_id, person_id) PostReport::resolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} else { } else {
PostReport::unresolve(&mut *context.conn().await?, report_id, person_id) PostReport::unresolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} }
let post_report_view = let post_report_view = PostReportView::read(&mut conn, report_id, person_id).await?;
PostReportView::read(&mut *context.conn().await?, report_id, person_id).await?;
Ok(PostReportResponse { post_report_view }) Ok(PostReportResponse { post_report_view })
} }

View file

@ -21,13 +21,13 @@ impl Perform for MarkPrivateMessageAsRead {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> { ) -> Result<PrivateMessageResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &MarkPrivateMessageAsRead = self; let data: &MarkPrivateMessageAsRead = self;
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?;
// Checking permissions // Checking permissions
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
let orig_private_message = let orig_private_message = PrivateMessage::read(&mut conn, private_message_id).await?;
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.recipient_id { if local_user_view.person.id != orig_private_message.recipient_id {
return Err(LemmyError::from_message("couldnt_update_private_message")); return Err(LemmyError::from_message("couldnt_update_private_message"));
} }
@ -36,14 +36,14 @@ impl Perform for MarkPrivateMessageAsRead {
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
let read = data.read; let read = data.read;
PrivateMessage::update( PrivateMessage::update(
&mut *context.conn().await?, &mut conn,
private_message_id, private_message_id,
&PrivateMessageUpdateForm::builder().read(Some(read)).build(), &PrivateMessageUpdateForm::builder().read(Some(read)).build(),
) )
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
let view = PrivateMessageView::read(&mut *context.conn().await?, private_message_id).await?; let view = PrivateMessageView::read(&mut conn, private_message_id).await?;
Ok(PrivateMessageResponse { Ok(PrivateMessageResponse {
private_message_view: view, private_message_view: view,
}) })

View file

@ -22,16 +22,16 @@ impl Perform for CreatePrivateMessageReport {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&self.auth, context).await?; let local_user_view = local_user_view_from_jwt(&self.auth, context).await?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let reason = self.reason.trim(); let reason = self.reason.trim();
check_report_reason(reason, &local_site)?; check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let private_message_id = self.private_message_id; let private_message_id = self.private_message_id;
let private_message = let private_message = PrivateMessage::read(&mut conn, private_message_id).await?;
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
let report_form = PrivateMessageReportForm { let report_form = PrivateMessageReportForm {
creator_id: person_id, creator_id: person_id,
@ -40,19 +40,18 @@ impl Perform for CreatePrivateMessageReport {
reason: reason.to_owned(), reason: reason.to_owned(),
}; };
let report = PrivateMessageReport::report(&mut *context.conn().await?, &report_form) let report = PrivateMessageReport::report(&mut conn, &report_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let private_message_report_view = let private_message_report_view = PrivateMessageReportView::read(&mut conn, report.id).await?;
PrivateMessageReportView::read(&mut *context.conn().await?, report.id).await?;
// Email the admins // Email the admins
if local_site.reports_email_admins { if local_site.reports_email_admins {
send_new_report_email_to_admins( send_new_report_email_to_admins(
&private_message_report_view.creator.name, &private_message_report_view.creator.name,
&private_message_report_view.private_message_creator.name, &private_message_report_view.private_message_creator.name,
&mut *context.conn().await?, &mut conn,
context.settings(), context.settings(),
) )
.await?; .await?;

View file

@ -15,6 +15,7 @@ impl Perform for ResolvePrivateMessageReport {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&self.auth, context).await?; let local_user_view = local_user_view_from_jwt(&self.auth, context).await?;
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
@ -22,17 +23,16 @@ impl Perform for ResolvePrivateMessageReport {
let report_id = self.report_id; let report_id = self.report_id;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
if self.resolved { if self.resolved {
PrivateMessageReport::resolve(&mut *context.conn().await?, report_id, person_id) PrivateMessageReport::resolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} else { } else {
PrivateMessageReport::unresolve(&mut *context.conn().await?, report_id, person_id) PrivateMessageReport::unresolve(&mut conn, report_id, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} }
let private_message_report_view = let private_message_report_view = PrivateMessageReportView::read(&mut conn, report_id).await?;
PrivateMessageReportView::read(&mut *context.conn().await?, report_id).await?;
Ok(PrivateMessageReportResponse { Ok(PrivateMessageReportResponse {
private_message_report_view, private_message_report_view,

View file

@ -14,7 +14,8 @@ impl Perform for GetFederatedInstances {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let mut conn = context.conn().await?;
let site_view = SiteView::read_local(&mut conn).await?;
let federated_instances = let federated_instances =
build_federated_instances(&site_view.local_site, context.pool()).await?; build_federated_instances(&site_view.local_site, context.pool()).await?;

View file

@ -25,20 +25,21 @@ impl Perform for LeaveAdmin {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &LeaveAdmin = self; let data: &LeaveAdmin = self;
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)?; is_admin(&local_user_view)?;
// Make sure there isn't just one admin (so if one leaves, there will still be one left) // Make sure there isn't just one admin (so if one leaves, there will still be one left)
let admins = PersonView::admins(&mut *context.conn().await?).await?; let admins = PersonView::admins(&mut conn).await?;
if admins.len() == 1 { if admins.len() == 1 {
return Err(LemmyError::from_message("cannot_leave_admin")); return Err(LemmyError::from_message("cannot_leave_admin"));
} }
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
Person::update( Person::update(
&mut *context.conn().await?, &mut conn,
person_id, person_id,
&PersonUpdateForm::builder().admin(Some(false)).build(), &PersonUpdateForm::builder().admin(Some(false)).build(),
) )
@ -51,17 +52,16 @@ impl Perform for LeaveAdmin {
removed: Some(true), removed: Some(true),
}; };
ModAdd::create(&mut *context.conn().await?, &form).await?; ModAdd::create(&mut conn, &form).await?;
// Reread site and admins // Reread site and admins
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?; let admins = PersonView::admins(&mut conn).await?;
let all_languages = Language::read_all(&mut *context.conn().await?).await?; let all_languages = Language::read_all(&mut conn).await?;
let discussion_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?; let discussion_languages = SiteLanguage::read_local_raw(&mut conn).await?;
let taglines = Tagline::get_all(&mut *context.conn().await?, site_view.local_site.id).await?; let taglines = Tagline::get_all(&mut conn, site_view.local_site.id).await?;
let custom_emojis = let custom_emojis = CustomEmojiView::get_all(&mut conn, site_view.local_site.id).await?;
CustomEmojiView::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
Ok(GetSiteResponse { Ok(GetSiteResponse {
site_view, site_view,

View file

@ -37,10 +37,11 @@ impl Perform for GetModlog {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetModlogResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetModlogResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetModlog = self; let data: &GetModlog = self;
let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await; let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
check_private_instance(&local_user_view, &local_site)?; check_private_instance(&local_user_view, &local_site)?;
@ -56,11 +57,7 @@ impl Perform for GetModlog {
None => CommunityId(-1), None => CommunityId(-1),
}; };
let is_mod_of_community = data.community_id.is_some() let is_mod_of_community = data.community_id.is_some()
&& is_mod_or_admin( && is_mod_or_admin(&mut conn, local_person_id, community_id_value)
&mut *context.conn().await?,
local_person_id,
community_id_value,
)
.await .await
.is_ok(); .is_ok();
let hide_modlog_names = local_site.hide_modlog_mod_names && !is_mod_of_community && !is_admin; let hide_modlog_names = local_site.hide_modlog_mod_names && !is_mod_of_community && !is_admin;
@ -80,51 +77,43 @@ impl Perform for GetModlog {
hide_modlog_names, hide_modlog_names,
}; };
let removed_posts = match type_ { let removed_posts = match type_ {
All | ModRemovePost => ModRemovePostView::list(&mut *context.conn().await?, params).await?, All | ModRemovePost => ModRemovePostView::list(&mut conn, params).await?,
_ => Default::default(), _ => Default::default(),
}; };
let locked_posts = match type_ { let locked_posts = match type_ {
All | ModLockPost => ModLockPostView::list(&mut *context.conn().await?, params).await?, All | ModLockPost => ModLockPostView::list(&mut conn, params).await?,
_ => Default::default(), _ => Default::default(),
}; };
let featured_posts = match type_ { let featured_posts = match type_ {
All | ModFeaturePost => ModFeaturePostView::list(&mut *context.conn().await?, params).await?, All | ModFeaturePost => ModFeaturePostView::list(&mut conn, params).await?,
_ => Default::default(), _ => Default::default(),
}; };
let removed_comments = match type_ { let removed_comments = match type_ {
All | ModRemoveComment => { All | ModRemoveComment => ModRemoveCommentView::list(&mut conn, params).await?,
ModRemoveCommentView::list(&mut *context.conn().await?, params).await?
}
_ => Default::default(), _ => Default::default(),
}; };
let banned_from_community = match type_ { let banned_from_community = match type_ {
All | ModBanFromCommunity => { All | ModBanFromCommunity => ModBanFromCommunityView::list(&mut conn, params).await?,
ModBanFromCommunityView::list(&mut *context.conn().await?, params).await?
}
_ => Default::default(), _ => Default::default(),
}; };
let added_to_community = match type_ { let added_to_community = match type_ {
All | ModAddCommunity => { All | ModAddCommunity => ModAddCommunityView::list(&mut conn, params).await?,
ModAddCommunityView::list(&mut *context.conn().await?, params).await?
}
_ => Default::default(), _ => Default::default(),
}; };
let transferred_to_community = match type_ { let transferred_to_community = match type_ {
All | ModTransferCommunity => { All | ModTransferCommunity => ModTransferCommunityView::list(&mut conn, params).await?,
ModTransferCommunityView::list(&mut *context.conn().await?, params).await?
}
_ => Default::default(), _ => Default::default(),
}; };
let hidden_communities = match type_ { let hidden_communities = match type_ {
All | ModHideCommunity if other_person_id.is_none() => { All | ModHideCommunity if other_person_id.is_none() => {
ModHideCommunityView::list(&mut *context.conn().await?, params).await? ModHideCommunityView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}; };
@ -141,40 +130,40 @@ impl Perform for GetModlog {
) = if data.community_id.is_none() { ) = if data.community_id.is_none() {
( (
match type_ { match type_ {
All | ModBan => ModBanView::list(&mut *context.conn().await?, params).await?, All | ModBan => ModBanView::list(&mut conn, params).await?,
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | ModAdd => ModAddView::list(&mut *context.conn().await?, params).await?, All | ModAdd => ModAddView::list(&mut conn, params).await?,
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | ModRemoveCommunity if other_person_id.is_none() => { All | ModRemoveCommunity if other_person_id.is_none() => {
ModRemoveCommunityView::list(&mut *context.conn().await?, params).await? ModRemoveCommunityView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | AdminPurgePerson if other_person_id.is_none() => { All | AdminPurgePerson if other_person_id.is_none() => {
AdminPurgePersonView::list(&mut *context.conn().await?, params).await? AdminPurgePersonView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | AdminPurgeCommunity if other_person_id.is_none() => { All | AdminPurgeCommunity if other_person_id.is_none() => {
AdminPurgeCommunityView::list(&mut *context.conn().await?, params).await? AdminPurgeCommunityView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | AdminPurgePost if other_person_id.is_none() => { All | AdminPurgePost if other_person_id.is_none() => {
AdminPurgePostView::list(&mut *context.conn().await?, params).await? AdminPurgePostView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}, },
match type_ { match type_ {
All | AdminPurgeComment if other_person_id.is_none() => { All | AdminPurgeComment if other_person_id.is_none() => {
AdminPurgeCommentView::list(&mut *context.conn().await?, params).await? AdminPurgeCommentView::list(&mut conn, params).await?
} }
_ => Default::default(), _ => Default::default(),
}, },

View file

@ -20,6 +20,7 @@ impl Perform for PurgeComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data: &Self = self; let data: &Self = self;
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?;
@ -29,13 +30,13 @@ impl Perform for PurgeComment {
let comment_id = data.comment_id; let comment_id = data.comment_id;
// Read the comment to get the post_id // Read the comment to get the post_id
let comment = Comment::read(&mut *context.conn().await?, comment_id).await?; let comment = Comment::read(&mut conn, comment_id).await?;
let post_id = comment.post_id; let post_id = comment.post_id;
// TODO read comments for pictrs images and purge them // TODO read comments for pictrs images and purge them
Comment::delete(&mut *context.conn().await?, comment_id).await?; Comment::delete(&mut conn, comment_id).await?;
// Mod tables // Mod tables
let reason = data.reason.clone(); let reason = data.reason.clone();
@ -45,7 +46,7 @@ impl Perform for PurgeComment {
post_id, post_id,
}; };
AdminPurgeComment::create(&mut *context.conn().await?, &form).await?; AdminPurgeComment::create(&mut conn, &form).await?;
Ok(PurgeItemResponse { success: true }) Ok(PurgeItemResponse { success: true })
} }

View file

@ -21,6 +21,7 @@ impl Perform for PurgeCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data: &Self = self; let data: &Self = self;
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?;
@ -30,7 +31,7 @@ impl Perform for PurgeCommunity {
let community_id = data.community_id; let community_id = data.community_id;
// Read the community to get its images // Read the community to get its images
let community = Community::read(&mut *context.conn().await?, community_id).await?; let community = Community::read(&mut conn, community_id).await?;
if let Some(banner) = community.banner { if let Some(banner) = community.banner {
purge_image_from_pictrs(context.client(), context.settings(), &banner) purge_image_from_pictrs(context.client(), context.settings(), &banner)
@ -46,13 +47,13 @@ impl Perform for PurgeCommunity {
purge_image_posts_for_community( purge_image_posts_for_community(
community_id, community_id,
&mut *context.conn().await?, &mut conn,
context.settings(), context.settings(),
context.client(), context.client(),
) )
.await?; .await?;
Community::delete(&mut *context.conn().await?, community_id).await?; Community::delete(&mut conn, community_id).await?;
// Mod tables // Mod tables
let reason = data.reason.clone(); let reason = data.reason.clone();
@ -61,7 +62,7 @@ impl Perform for PurgeCommunity {
reason, reason,
}; };
AdminPurgeCommunity::create(&mut *context.conn().await?, &form).await?; AdminPurgeCommunity::create(&mut conn, &form).await?;
Ok(PurgeItemResponse { success: true }) Ok(PurgeItemResponse { success: true })
} }

View file

@ -21,6 +21,7 @@ impl Perform for PurgePerson {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data: &Self = self; let data: &Self = self;
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?;
@ -29,7 +30,7 @@ impl Perform for PurgePerson {
// Read the person to get their images // Read the person to get their images
let person_id = data.person_id; let person_id = data.person_id;
let person = Person::read(&mut *context.conn().await?, person_id).await?; let person = Person::read(&mut conn, person_id).await?;
if let Some(banner) = person.banner { if let Some(banner) = person.banner {
purge_image_from_pictrs(context.client(), context.settings(), &banner) purge_image_from_pictrs(context.client(), context.settings(), &banner)
@ -43,15 +44,10 @@ impl Perform for PurgePerson {
.ok(); .ok();
} }
purge_image_posts_for_person( purge_image_posts_for_person(person_id, &mut conn, context.settings(), context.client())
person_id,
&mut *context.conn().await?,
context.settings(),
context.client(),
)
.await?; .await?;
Person::delete(&mut *context.conn().await?, person_id).await?; Person::delete(&mut conn, person_id).await?;
// Mod tables // Mod tables
let reason = data.reason.clone(); let reason = data.reason.clone();
@ -60,7 +56,7 @@ impl Perform for PurgePerson {
reason, reason,
}; };
AdminPurgePerson::create(&mut *context.conn().await?, &form).await?; AdminPurgePerson::create(&mut conn, &form).await?;
Ok(PurgeItemResponse { success: true }) Ok(PurgeItemResponse { success: true })
} }

View file

@ -21,6 +21,7 @@ impl Perform for PurgePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data: &Self = self; let data: &Self = self;
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?;
@ -30,7 +31,7 @@ impl Perform for PurgePost {
let post_id = data.post_id; let post_id = data.post_id;
// Read the post to get the community_id // Read the post to get the community_id
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
// Purge image // Purge image
if let Some(url) = post.url { if let Some(url) = post.url {
@ -47,7 +48,7 @@ impl Perform for PurgePost {
let community_id = post.community_id; let community_id = post.community_id;
Post::delete(&mut *context.conn().await?, post_id).await?; Post::delete(&mut conn, post_id).await?;
// Mod tables // Mod tables
let reason = data.reason.clone(); let reason = data.reason.clone();
@ -57,7 +58,7 @@ impl Perform for PurgePost {
community_id, community_id,
}; };
AdminPurgePost::create(&mut *context.conn().await?, &form).await?; AdminPurgePost::create(&mut conn, &form).await?;
Ok(PurgeItemResponse { success: true }) Ok(PurgeItemResponse { success: true })
} }

View file

@ -21,6 +21,7 @@ impl Perform for ApproveRegistrationApplication {
type Response = RegistrationApplicationResponse; type Response = RegistrationApplicationResponse;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
@ -37,7 +38,7 @@ impl Perform for ApproveRegistrationApplication {
}; };
let registration_application = let registration_application =
RegistrationApplication::update(&mut *context.conn().await?, app_id, &app_form).await?; RegistrationApplication::update(&mut conn, app_id, &app_form).await?;
// Update the local_user row // Update the local_user row
let local_user_form = LocalUserUpdateForm::builder() let local_user_form = LocalUserUpdateForm::builder()
@ -45,16 +46,10 @@ impl Perform for ApproveRegistrationApplication {
.build(); .build();
let approved_user_id = registration_application.local_user_id; let approved_user_id = registration_application.local_user_id;
LocalUser::update( LocalUser::update(&mut conn, approved_user_id, &local_user_form).await?;
&mut *context.conn().await?,
approved_user_id,
&local_user_form,
)
.await?;
if data.approve { if data.approve {
let approved_local_user_view = let approved_local_user_view = LocalUserView::read(&mut conn, approved_user_id).await?;
LocalUserView::read(&mut *context.conn().await?, approved_user_id).await?;
if approved_local_user_view.local_user.email.is_some() { if approved_local_user_view.local_user.email.is_some() {
send_application_approved_email(&approved_local_user_view, context.settings())?; send_application_approved_email(&approved_local_user_view, context.settings())?;
@ -62,8 +57,7 @@ impl Perform for ApproveRegistrationApplication {
} }
// Read the view // Read the view
let registration_application = let registration_application = RegistrationApplicationView::read(&mut conn, app_id).await?;
RegistrationApplicationView::read(&mut *context.conn().await?, app_id).await?;
Ok(Self::Response { Ok(Self::Response {
registration_application, registration_application,

View file

@ -15,9 +15,10 @@ impl Perform for ListRegistrationApplications {
type Response = ListRegistrationApplicationsResponse; type Response = ListRegistrationApplicationsResponse;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Make sure user is an admin // Make sure user is an admin
is_admin(&local_user_view)?; is_admin(&local_user_view)?;

View file

@ -14,20 +14,18 @@ impl Perform for GetUnreadRegistrationApplicationCount {
type Response = GetUnreadRegistrationApplicationCountResponse; type Response = GetUnreadRegistrationApplicationCountResponse;
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Only let admins do this // Only let admins do this
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
let verified_email_only = local_site.require_email_verification; let verified_email_only = local_site.require_email_verification;
let registration_applications = RegistrationApplicationView::get_unread_count( let registration_applications =
&mut *context.conn().await?, RegistrationApplicationView::get_unread_count(&mut conn, verified_email_only).await?;
verified_email_only,
)
.await?;
Ok(Self::Response { Ok(Self::Response {
registration_applications, registration_applications,

View file

@ -29,8 +29,10 @@ pub async fn build_comment_response(
form_id: Option<String>, form_id: Option<String>,
recipient_ids: Vec<LocalUserId>, recipient_ids: Vec<LocalUserId>,
) -> Result<CommentResponse, LemmyError> { ) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let person_id = local_user_view.map(|l| l.person.id); let person_id = local_user_view.map(|l| l.person.id);
let comment_view = CommentView::read(&mut *context.conn().await?, comment_id, person_id).await?; let comment_view = CommentView::read(&mut conn, comment_id, person_id).await?;
Ok(CommentResponse { Ok(CommentResponse {
comment_view, comment_view,
recipient_ids, recipient_ids,
@ -43,23 +45,20 @@ pub async fn build_community_response(
local_user_view: LocalUserView, local_user_view: LocalUserView,
community_id: CommunityId, community_id: CommunityId,
) -> Result<CommunityResponse, LemmyError> { ) -> Result<CommunityResponse, LemmyError> {
let is_mod_or_admin = is_mod_or_admin( let mut conn = context.conn().await?;
&mut *context.conn().await?,
local_user_view.person.id, let is_mod_or_admin = is_mod_or_admin(&mut conn, local_user_view.person.id, community_id)
community_id,
)
.await .await
.is_ok(); .is_ok();
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let community_view = CommunityView::read( let community_view = CommunityView::read(
&mut *context.conn().await?, &mut conn,
community_id, community_id,
Some(person_id), Some(person_id),
Some(is_mod_or_admin), Some(is_mod_or_admin),
) )
.await?; .await?;
let discussion_languages = let discussion_languages = CommunityLanguage::read(&mut conn, community_id).await?;
CommunityLanguage::read(&mut *context.conn().await?, community_id).await?;
Ok(CommunityResponse { Ok(CommunityResponse {
community_view, community_view,
@ -73,16 +72,13 @@ pub async fn build_post_response(
person_id: PersonId, person_id: PersonId,
post_id: PostId, post_id: PostId,
) -> Result<PostResponse, LemmyError> { ) -> Result<PostResponse, LemmyError> {
let is_mod_or_admin = is_mod_or_admin(&mut *context.conn().await?, person_id, community_id) let mut conn = context.conn().await?;
let is_mod_or_admin = is_mod_or_admin(&mut conn, person_id, community_id)
.await .await
.is_ok(); .is_ok();
let post_view = PostView::read( let post_view =
&mut *context.conn().await?, PostView::read(&mut conn, post_id, Some(person_id), Some(is_mod_or_admin)).await?;
post_id,
Some(person_id),
Some(is_mod_or_admin),
)
.await?;
Ok(PostResponse { post_view }) Ok(PostResponse { post_view })
} }
@ -96,6 +92,8 @@ pub async fn send_local_notifs(
do_send_email: bool, do_send_email: bool,
context: &LemmyContext, context: &LemmyContext,
) -> Result<Vec<LocalUserId>, LemmyError> { ) -> Result<Vec<LocalUserId>, LemmyError> {
let mut conn = context.conn().await?;
let mut recipient_ids = Vec::new(); let mut recipient_ids = Vec::new();
let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname()); let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
@ -105,7 +103,7 @@ pub async fn send_local_notifs(
.filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name)) .filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name))
{ {
let mention_name = mention.name.clone(); let mention_name = mention.name.clone();
let user_view = LocalUserView::read_from_name(&mut *context.conn().await?, &mention_name).await; let user_view = LocalUserView::read_from_name(&mut conn, &mention_name).await;
if let Ok(mention_user_view) = user_view { if let Ok(mention_user_view) = user_view {
// TODO // TODO
// At some point, make it so you can't tag the parent creator either // At some point, make it so you can't tag the parent creator either
@ -120,7 +118,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it // Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail // Let the uniqueness handle this fail
PersonMention::create(&mut *context.conn().await?, &user_mention_form) PersonMention::create(&mut conn, &user_mention_form)
.await .await
.ok(); .ok();
@ -139,21 +137,19 @@ pub async fn send_local_notifs(
// Send comment_reply to the parent commenter / poster // Send comment_reply to the parent commenter / poster
if let Some(parent_comment_id) = comment.parent_comment_id() { if let Some(parent_comment_id) = comment.parent_comment_id() {
let parent_comment = Comment::read(&mut *context.conn().await?, parent_comment_id).await?; let parent_comment = Comment::read(&mut conn, parent_comment_id).await?;
// Get the parent commenter local_user // Get the parent commenter local_user
let parent_creator_id = parent_comment.creator_id; let parent_creator_id = parent_comment.creator_id;
// Only add to recipients if that person isn't blocked // Only add to recipients if that person isn't blocked
let creator_blocked = let creator_blocked = check_person_block(person.id, parent_creator_id, &mut conn)
check_person_block(person.id, parent_creator_id, &mut *context.conn().await?)
.await .await
.is_err(); .is_err();
// Don't send a notif to yourself // Don't send a notif to yourself
if parent_comment.creator_id != person.id && !creator_blocked { if parent_comment.creator_id != person.id && !creator_blocked {
let user_view = let user_view = LocalUserView::read_person(&mut conn, parent_creator_id).await;
LocalUserView::read_person(&mut *context.conn().await?, parent_creator_id).await;
if let Ok(parent_user_view) = user_view { if let Ok(parent_user_view) = user_view {
recipient_ids.push(parent_user_view.local_user.id); recipient_ids.push(parent_user_view.local_user.id);
@ -165,7 +161,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it // Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail // Let the uniqueness handle this fail
CommentReply::create(&mut *context.conn().await?, &comment_reply_form) CommentReply::create(&mut conn, &comment_reply_form)
.await .await
.ok(); .ok();
@ -183,14 +179,13 @@ pub async fn send_local_notifs(
} else { } else {
// If there's no parent, its the post creator // If there's no parent, its the post creator
// Only add to recipients if that person isn't blocked // Only add to recipients if that person isn't blocked
let creator_blocked = let creator_blocked = check_person_block(person.id, post.creator_id, &mut conn)
check_person_block(person.id, post.creator_id, &mut *context.conn().await?)
.await .await
.is_err(); .is_err();
if post.creator_id != person.id && !creator_blocked { if post.creator_id != person.id && !creator_blocked {
let creator_id = post.creator_id; let creator_id = post.creator_id;
let parent_user = LocalUserView::read_person(&mut *context.conn().await?, creator_id).await; let parent_user = LocalUserView::read_person(&mut conn, creator_id).await;
if let Ok(parent_user_view) = parent_user { if let Ok(parent_user_view) = parent_user {
recipient_ids.push(parent_user_view.local_user.id); recipient_ids.push(parent_user_view.local_user.id);
@ -202,7 +197,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it // Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail // Let the uniqueness handle this fail
CommentReply::create(&mut *context.conn().await?, &comment_reply_form) CommentReply::create(&mut conn, &comment_reply_form)
.await .await
.ok(); .ok();

View file

@ -138,11 +138,12 @@ pub async fn local_user_view_from_jwt(
jwt: &str, jwt: &str,
context: &LemmyContext, context: &LemmyContext,
) -> Result<LocalUserView, LemmyError> { ) -> Result<LocalUserView, LemmyError> {
let mut conn = context.conn().await?;
let claims = Claims::decode(jwt, &context.secret().jwt_secret) let claims = Claims::decode(jwt, &context.secret().jwt_secret)
.map_err(|e| e.with_message("not_logged_in"))? .map_err(|e| e.with_message("not_logged_in"))?
.claims; .claims;
let local_user_id = LocalUserId(claims.sub); let local_user_id = LocalUserId(claims.sub);
let local_user_view = LocalUserView::read(&mut *context.conn().await?, local_user_id).await?; let local_user_view = LocalUserView::read(&mut conn, local_user_id).await?;
check_user_valid( check_user_valid(
local_user_view.person.banned, local_user_view.person.banned,
local_user_view.person.ban_expires, local_user_view.person.ban_expires,

View file

@ -41,9 +41,10 @@ impl PerformCrud for CreateComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateComment = self; let data: &CreateComment = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let content_slurs_removed = remove_slurs( let content_slurs_removed = remove_slurs(
&data.content.clone(), &data.content.clone(),
@ -53,16 +54,11 @@ impl PerformCrud for CreateComment {
// Check for a community ban // Check for a community ban
let post_id = data.post_id; let post_id = data.post_id;
let post = get_post(post_id, &mut *context.conn().await?).await?; let post = get_post(post_id, &mut conn).await?;
let community_id = post.community_id; let community_id = post.community_id;
check_community_ban( check_community_ban(local_user_view.person.id, community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(community_id, &mut conn).await?;
community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(community_id, &mut *context.conn().await?).await?;
check_post_deleted_or_removed(&post)?; check_post_deleted_or_removed(&post)?;
// Check if post is locked, no new comments // Check if post is locked, no new comments
@ -72,9 +68,7 @@ impl PerformCrud for CreateComment {
// Fetch the parent, if it exists // Fetch the parent, if it exists
let parent_opt = if let Some(parent_id) = data.parent_id { let parent_opt = if let Some(parent_id) = data.parent_id {
Comment::read(&mut *context.conn().await?, parent_id) Comment::read(&mut conn, parent_id).await.ok()
.await
.ok()
} else { } else {
None None
}; };
@ -95,11 +89,7 @@ impl PerformCrud for CreateComment {
.unwrap_or(post.language_id); .unwrap_or(post.language_id);
let language_id = data.language_id.unwrap_or(parent_language); let language_id = data.language_id.unwrap_or(parent_language);
CommunityLanguage::is_allowed_community_language( CommunityLanguage::is_allowed_community_language(&mut conn, Some(language_id), community_id)
&mut *context.conn().await?,
Some(language_id),
community_id,
)
.await?; .await?;
let comment_form = CommentInsertForm::builder() let comment_form = CommentInsertForm::builder()
@ -111,11 +101,7 @@ impl PerformCrud for CreateComment {
// Create the comment // Create the comment
let parent_path = parent_opt.clone().map(|t| t.path); let parent_path = parent_opt.clone().map(|t| t.path);
let inserted_comment = Comment::create( let inserted_comment = Comment::create(&mut conn, &comment_form, parent_path.as_ref())
&mut *context.conn().await?,
&comment_form,
parent_path.as_ref(),
)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_comment"))?;
@ -129,7 +115,7 @@ impl PerformCrud for CreateComment {
&protocol_and_hostname, &protocol_and_hostname,
)?; )?;
let updated_comment = Comment::update( let updated_comment = Comment::update(
&mut *context.conn().await?, &mut conn,
inserted_comment_id, inserted_comment_id,
&CommentUpdateForm::builder().ap_id(Some(apub_id)).build(), &CommentUpdateForm::builder().ap_id(Some(apub_id)).build(),
) )
@ -156,18 +142,17 @@ impl PerformCrud for CreateComment {
score: 1, score: 1,
}; };
CommentLike::like(&mut *context.conn().await?, &like_form) CommentLike::like(&mut conn, &like_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?;
// If its a reply, mark the parent as read // If its a reply, mark the parent as read
if let Some(parent) = parent_opt { if let Some(parent) = parent_opt {
let parent_id = parent.id; let parent_id = parent.id;
let comment_reply = let comment_reply = CommentReply::read_by_comment(&mut conn, parent_id).await;
CommentReply::read_by_comment(&mut *context.conn().await?, parent_id).await;
if let Ok(reply) = comment_reply { if let Ok(reply) = comment_reply {
CommentReply::update( CommentReply::update(
&mut *context.conn().await?, &mut conn,
reply.id, reply.id,
&CommentReplyUpdateForm { read: Some(true) }, &CommentReplyUpdateForm { read: Some(true) },
) )
@ -177,15 +162,11 @@ impl PerformCrud for CreateComment {
// If the parent has PersonMentions mark them as read too // If the parent has PersonMentions mark them as read too
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let person_mention = PersonMention::read_by_comment_and_person( let person_mention =
&mut *context.conn().await?, PersonMention::read_by_comment_and_person(&mut conn, parent_id, person_id).await;
parent_id,
person_id,
)
.await;
if let Ok(mention) = person_mention { if let Ok(mention) = person_mention {
PersonMention::update( PersonMention::update(
&mut *context.conn().await?, &mut conn,
mention.id, mention.id,
&PersonMentionUpdateForm { read: Some(true) }, &PersonMentionUpdateForm { read: Some(true) },
) )

View file

@ -22,11 +22,12 @@ impl PerformCrud for DeleteComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DeleteComment = self; let data: &DeleteComment = self;
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?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let orig_comment = CommentView::read(&mut conn, comment_id, None).await?;
// Dont delete it if its already been deleted. // Dont delete it if its already been deleted.
if orig_comment.comment.deleted == data.deleted { if orig_comment.comment.deleted == data.deleted {
@ -36,7 +37,7 @@ impl PerformCrud for DeleteComment {
check_community_ban( check_community_ban(
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
&mut *context.conn().await?, &mut conn,
) )
.await?; .await?;
@ -48,7 +49,7 @@ impl PerformCrud for DeleteComment {
// Do the delete // Do the delete
let deleted = data.deleted; let deleted = data.deleted;
let updated_comment = Comment::update( let updated_comment = Comment::update(
&mut *context.conn().await?, &mut conn,
comment_id, comment_id,
&CommentUpdateForm::builder().deleted(Some(deleted)).build(), &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
) )
@ -56,7 +57,7 @@ impl PerformCrud for DeleteComment {
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
let post_id = updated_comment.post_id; let post_id = updated_comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
let recipient_ids = send_local_notifs( let recipient_ids = send_local_notifs(
vec![], vec![],
&updated_comment, &updated_comment,

View file

@ -15,9 +15,10 @@ impl PerformCrud for GetComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let mut conn = context.conn().await?;
let data = self; let data = self;
let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await; let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
check_private_instance(&local_user_view, &local_site)?; check_private_instance(&local_user_view, &local_site)?;

View file

@ -23,22 +23,23 @@ impl PerformCrud for RemoveComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &RemoveComment = self; let data: &RemoveComment = self;
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?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let orig_comment = CommentView::read(&mut conn, comment_id, None).await?;
check_community_ban( check_community_ban(
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
&mut *context.conn().await?, &mut conn,
) )
.await?; .await?;
// Verify that only a mod or admin can remove // Verify that only a mod or admin can remove
is_mod_or_admin( is_mod_or_admin(
&mut *context.conn().await?, &mut conn,
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
) )
@ -47,7 +48,7 @@ impl PerformCrud for RemoveComment {
// Do the remove // Do the remove
let removed = data.removed; let removed = data.removed;
let updated_comment = Comment::update( let updated_comment = Comment::update(
&mut *context.conn().await?, &mut conn,
comment_id, comment_id,
&CommentUpdateForm::builder().removed(Some(removed)).build(), &CommentUpdateForm::builder().removed(Some(removed)).build(),
) )
@ -61,10 +62,10 @@ impl PerformCrud for RemoveComment {
removed: Some(removed), removed: Some(removed),
reason: data.reason.clone(), reason: data.reason.clone(),
}; };
ModRemoveComment::create(&mut *context.conn().await?, &form).await?; ModRemoveComment::create(&mut conn, &form).await?;
let post_id = updated_comment.post_id; let post_id = updated_comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
let recipient_ids = send_local_notifs( let recipient_ids = send_local_notifs(
vec![], vec![],
&updated_comment, &updated_comment,

View file

@ -31,17 +31,18 @@ impl PerformCrud for EditComment {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditComment = self; let data: &EditComment = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let comment_id = data.comment_id; let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?; let orig_comment = CommentView::read(&mut conn, comment_id, None).await?;
check_community_ban( check_community_ban(
local_user_view.person.id, local_user_view.person.id,
orig_comment.community.id, orig_comment.community.id,
&mut *context.conn().await?, &mut conn,
) )
.await?; .await?;
@ -52,7 +53,7 @@ impl PerformCrud for EditComment {
let language_id = self.language_id; let language_id = self.language_id;
CommunityLanguage::is_allowed_community_language( CommunityLanguage::is_allowed_community_language(
&mut *context.conn().await?, &mut conn,
language_id, language_id,
orig_comment.community.id, orig_comment.community.id,
) )
@ -72,7 +73,7 @@ impl PerformCrud for EditComment {
.language_id(data.language_id) .language_id(data.language_id)
.updated(Some(Some(naive_now()))) .updated(Some(Some(naive_now())))
.build(); .build();
let updated_comment = Comment::update(&mut *context.conn().await?, comment_id, &form) let updated_comment = Comment::update(&mut conn, comment_id, &form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;

View file

@ -46,9 +46,10 @@ impl PerformCrud for CreateCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateCommunity = self; let data: &CreateCommunity = self;
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?;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let local_site = site_view.local_site; let local_site = site_view.local_site;
if local_site.community_creation_admin_only && is_admin(&local_user_view).is_err() { if local_site.community_creation_admin_only && is_admin(&local_user_view).is_err() {
@ -75,8 +76,7 @@ impl PerformCrud for CreateCommunity {
&data.name, &data.name,
&context.settings().get_protocol_and_hostname(), &context.settings().get_protocol_and_hostname(),
)?; )?;
let community_dupe = let community_dupe = Community::read_from_apub_id(&mut conn, &community_actor_id).await?;
Community::read_from_apub_id(&mut *context.conn().await?, &community_actor_id).await?;
if community_dupe.is_some() { if community_dupe.is_some() {
return Err(LemmyError::from_message("community_already_exists")); return Err(LemmyError::from_message("community_already_exists"));
} }
@ -101,7 +101,7 @@ impl PerformCrud for CreateCommunity {
.instance_id(site_view.site.instance_id) .instance_id(site_view.site.instance_id)
.build(); .build();
let inserted_community = Community::create(&mut *context.conn().await?, &community_form) let inserted_community = Community::create(&mut conn, &community_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_already_exists"))?;
@ -111,7 +111,7 @@ impl PerformCrud for CreateCommunity {
person_id: local_user_view.person.id, person_id: local_user_view.person.id,
}; };
CommunityModerator::join(&mut *context.conn().await?, &community_moderator_form) CommunityModerator::join(&mut conn, &community_moderator_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
@ -122,21 +122,21 @@ impl PerformCrud for CreateCommunity {
pending: false, pending: false,
}; };
CommunityFollower::follow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::follow(&mut conn, &community_follower_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
// Update the discussion_languages if that's provided // Update the discussion_languages if that's provided
let community_id = inserted_community.id; let community_id = inserted_community.id;
if let Some(languages) = data.discussion_languages.clone() { if let Some(languages) = data.discussion_languages.clone() {
let site_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?; let site_languages = SiteLanguage::read_local_raw(&mut conn).await?;
// check that community languages are a subset of site languages // check that community languages are a subset of site languages
// https://stackoverflow.com/a/64227550 // https://stackoverflow.com/a/64227550
let is_subset = languages.iter().all(|item| site_languages.contains(item)); let is_subset = languages.iter().all(|item| site_languages.contains(item));
if !is_subset { if !is_subset {
return Err(LemmyError::from_message("language_not_allowed")); return Err(LemmyError::from_message("language_not_allowed"));
} }
CommunityLanguage::update(&mut *context.conn().await?, languages, community_id).await?; CommunityLanguage::update(&mut conn, languages, community_id).await?;
} }
build_community_response(context, local_user_view, community_id).await build_community_response(context, local_user_view, community_id).await

View file

@ -19,13 +19,13 @@ impl PerformCrud for DeleteCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DeleteCommunity = self; let data: &DeleteCommunity = self;
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?;
// Fetch the community mods // Fetch the community mods
let community_id = data.community_id; let community_id = data.community_id;
let community_mods = let community_mods = CommunityModeratorView::for_community(&mut conn, community_id).await?;
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
// Make sure deleter is the top mod // Make sure deleter is the top mod
is_top_mod(&local_user_view, &community_mods)?; is_top_mod(&local_user_view, &community_mods)?;
@ -34,7 +34,7 @@ impl PerformCrud for DeleteCommunity {
let community_id = data.community_id; let community_id = data.community_id;
let deleted = data.deleted; let deleted = data.deleted;
Community::update( Community::update(
&mut *context.conn().await?, &mut conn,
community_id, community_id,
&CommunityUpdateForm::builder() &CommunityUpdateForm::builder()
.deleted(Some(deleted)) .deleted(Some(deleted))

View file

@ -18,9 +18,10 @@ impl PerformCrud for ListCommunities {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<ListCommunitiesResponse, LemmyError> { ) -> Result<ListCommunitiesResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &ListCommunities = self; let data: &ListCommunities = self;
let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await; let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok()); let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
check_private_instance(&local_user_view, &local_site)?; check_private_instance(&local_user_view, &local_site)?;

View file

@ -21,6 +21,7 @@ impl PerformCrud for RemoveCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &RemoveCommunity = self; let data: &RemoveCommunity = self;
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?;
@ -31,7 +32,7 @@ impl PerformCrud for RemoveCommunity {
let community_id = data.community_id; let community_id = data.community_id;
let removed = data.removed; let removed = data.removed;
Community::update( Community::update(
&mut *context.conn().await?, &mut conn,
community_id, community_id,
&CommunityUpdateForm::builder() &CommunityUpdateForm::builder()
.removed(Some(removed)) .removed(Some(removed))
@ -49,7 +50,7 @@ impl PerformCrud for RemoveCommunity {
reason: data.reason.clone(), reason: data.reason.clone(),
expires, expires,
}; };
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?; ModRemoveCommunity::create(&mut conn, &form).await?;
build_community_response(context, local_user_view, community_id).await build_community_response(context, local_user_view, community_id).await
} }

View file

@ -28,9 +28,10 @@ impl PerformCrud for EditCommunity {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommunityResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditCommunity = self; let data: &EditCommunity = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let icon = diesel_option_overwrite_to_url(&data.icon)?; let icon = diesel_option_overwrite_to_url(&data.icon)?;
let banner = diesel_option_overwrite_to_url(&data.banner)?; let banner = diesel_option_overwrite_to_url(&data.banner)?;
@ -43,8 +44,7 @@ impl PerformCrud for EditCommunity {
// Verify its a mod (only mods can edit it) // Verify its a mod (only mods can edit it)
let community_id = data.community_id; let community_id = data.community_id;
let mods: Vec<PersonId> = let mods: Vec<PersonId> = CommunityModeratorView::for_community(&mut conn, community_id)
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id)
.await .await
.map(|v| v.into_iter().map(|m| m.moderator.id).collect())?; .map(|v| v.into_iter().map(|m| m.moderator.id).collect())?;
if !mods.contains(&local_user_view.person.id) { if !mods.contains(&local_user_view.person.id) {
@ -53,14 +53,14 @@ impl PerformCrud for EditCommunity {
let community_id = data.community_id; let community_id = data.community_id;
if let Some(languages) = data.discussion_languages.clone() { if let Some(languages) = data.discussion_languages.clone() {
let site_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?; let site_languages = SiteLanguage::read_local_raw(&mut conn).await?;
// check that community languages are a subset of site languages // check that community languages are a subset of site languages
// https://stackoverflow.com/a/64227550 // https://stackoverflow.com/a/64227550
let is_subset = languages.iter().all(|item| site_languages.contains(item)); let is_subset = languages.iter().all(|item| site_languages.contains(item));
if !is_subset { if !is_subset {
return Err(LemmyError::from_message("language_not_allowed")); return Err(LemmyError::from_message("language_not_allowed"));
} }
CommunityLanguage::update(&mut *context.conn().await?, languages, community_id).await?; CommunityLanguage::update(&mut conn, languages, community_id).await?;
} }
let community_form = CommunityUpdateForm::builder() let community_form = CommunityUpdateForm::builder()
@ -74,7 +74,7 @@ impl PerformCrud for EditCommunity {
.build(); .build();
let community_id = data.community_id; let community_id = data.community_id;
Community::update(&mut *context.conn().await?, community_id, &community_form) Community::update(&mut conn, community_id, &community_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community"))?;

View file

@ -19,10 +19,11 @@ impl PerformCrud for CreateCustomEmoji {
#[tracing::instrument(skip(self, context))] #[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateCustomEmoji = self; let data: &CreateCustomEmoji = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Make sure user is an admin // Make sure user is an admin
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
@ -33,7 +34,7 @@ impl PerformCrud for CreateCustomEmoji {
.category(data.category.to_string()) .category(data.category.to_string())
.image_url(data.clone().image_url.into()) .image_url(data.clone().image_url.into())
.build(); .build();
let emoji = CustomEmoji::create(&mut *context.conn().await?, &emoji_form).await?; let emoji = CustomEmoji::create(&mut conn, &emoji_form).await?;
let mut keywords = vec![]; let mut keywords = vec![];
for keyword in &data.keywords { for keyword in &data.keywords {
let keyword_form = CustomEmojiKeywordInsertForm::builder() let keyword_form = CustomEmojiKeywordInsertForm::builder()
@ -42,8 +43,8 @@ impl PerformCrud for CreateCustomEmoji {
.build(); .build();
keywords.push(keyword_form); keywords.push(keyword_form);
} }
CustomEmojiKeyword::create(&mut *context.conn().await?, keywords).await?; CustomEmojiKeyword::create(&mut conn, keywords).await?;
let view = CustomEmojiView::get(&mut *context.conn().await?, emoji.id).await?; let view = CustomEmojiView::get(&mut conn, emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view }) Ok(CustomEmojiResponse { custom_emoji: view })
} }
} }

View file

@ -17,12 +17,13 @@ impl PerformCrud for DeleteCustomEmoji {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<DeleteCustomEmojiResponse, LemmyError> { ) -> Result<DeleteCustomEmojiResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DeleteCustomEmoji = self; let data: &DeleteCustomEmoji = self;
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?;
// Make sure user is an admin // Make sure user is an admin
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
CustomEmoji::delete(&mut *context.conn().await?, data.id).await?; CustomEmoji::delete(&mut conn, data.id).await?;
Ok(DeleteCustomEmojiResponse { Ok(DeleteCustomEmojiResponse {
id: data.id, id: data.id,
success: true, success: true,

View file

@ -19,10 +19,11 @@ impl PerformCrud for EditCustomEmoji {
#[tracing::instrument(skip(self, context))] #[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<CustomEmojiResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditCustomEmoji = self; let data: &EditCustomEmoji = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Make sure user is an admin // Make sure user is an admin
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
@ -32,8 +33,8 @@ impl PerformCrud for EditCustomEmoji {
.category(data.category.to_string()) .category(data.category.to_string())
.image_url(data.clone().image_url.into()) .image_url(data.clone().image_url.into())
.build(); .build();
let emoji = CustomEmoji::update(&mut *context.conn().await?, data.id, &emoji_form).await?; let emoji = CustomEmoji::update(&mut conn, data.id, &emoji_form).await?;
CustomEmojiKeyword::delete(&mut *context.conn().await?, data.id).await?; CustomEmojiKeyword::delete(&mut conn, data.id).await?;
let mut keywords = vec![]; let mut keywords = vec![];
for keyword in &data.keywords { for keyword in &data.keywords {
let keyword_form = CustomEmojiKeywordInsertForm::builder() let keyword_form = CustomEmojiKeywordInsertForm::builder()
@ -42,8 +43,8 @@ impl PerformCrud for EditCustomEmoji {
.build(); .build();
keywords.push(keyword_form); keywords.push(keyword_form);
} }
CustomEmojiKeyword::create(&mut *context.conn().await?, keywords).await?; CustomEmojiKeyword::create(&mut conn, keywords).await?;
let view = CustomEmojiView::get(&mut *context.conn().await?, emoji.id).await?; let view = CustomEmojiView::get(&mut conn, emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view }) Ok(CustomEmojiResponse { custom_emoji: view })
} }
} }

View file

@ -44,9 +44,10 @@ impl PerformCrud for CreatePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreatePost = self; let data: &CreatePost = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let slur_regex = local_site_to_slur_regex(&local_site); let slur_regex = local_site_to_slur_regex(&local_site);
check_slurs(&data.name, &slur_regex)?; check_slurs(&data.name, &slur_regex)?;
@ -59,20 +60,15 @@ impl PerformCrud for CreatePost {
is_valid_post_title(&data.name)?; is_valid_post_title(&data.name)?;
is_valid_body_field(&data.body, true)?; is_valid_body_field(&data.body, true)?;
check_community_ban( check_community_ban(local_user_view.person.id, data.community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(data.community_id, &mut conn).await?;
data.community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(data.community_id, &mut *context.conn().await?).await?;
let community_id = data.community_id; let community_id = data.community_id;
let community = Community::read(&mut *context.conn().await?, community_id).await?; let community = Community::read(&mut conn, community_id).await?;
if community.posting_restricted_to_mods { if community.posting_restricted_to_mods {
let community_id = data.community_id; let community_id = data.community_id;
let is_mod = CommunityView::is_mod_or_admin( let is_mod = CommunityView::is_mod_or_admin(
&mut *context.conn().await?, &mut conn,
local_user_view.local_user.person_id, local_user_view.local_user.person_id,
community_id, community_id,
) )
@ -91,21 +87,9 @@ impl PerformCrud for CreatePost {
let language_id = match data.language_id { let language_id = match data.language_id {
Some(lid) => Some(lid), Some(lid) => Some(lid),
None => { None => default_post_language(&mut conn, community_id, local_user_view.local_user.id).await?,
default_post_language(
&mut *context.conn().await?,
community_id,
local_user_view.local_user.id,
)
.await?
}
}; };
CommunityLanguage::is_allowed_community_language( CommunityLanguage::is_allowed_community_language(&mut conn, language_id, community_id).await?;
&mut *context.conn().await?,
language_id,
community_id,
)
.await?;
let post_form = PostInsertForm::builder() let post_form = PostInsertForm::builder()
.name(data.name.trim().to_owned()) .name(data.name.trim().to_owned())
@ -121,7 +105,7 @@ impl PerformCrud for CreatePost {
.thumbnail_url(thumbnail_url) .thumbnail_url(thumbnail_url)
.build(); .build();
let inserted_post = match Post::create(&mut *context.conn().await?, &post_form).await { let inserted_post = match Post::create(&mut conn, &post_form).await {
Ok(post) => post, Ok(post) => post,
Err(e) => { Err(e) => {
let err_type = if e.to_string() == "value too long for type character varying(200)" { let err_type = if e.to_string() == "value too long for type character varying(200)" {
@ -142,7 +126,7 @@ impl PerformCrud for CreatePost {
&protocol_and_hostname, &protocol_and_hostname,
)?; )?;
let updated_post = Post::update( let updated_post = Post::update(
&mut *context.conn().await?, &mut conn,
inserted_post_id, inserted_post_id,
&PostUpdateForm::builder().ap_id(Some(apub_id)).build(), &PostUpdateForm::builder().ap_id(Some(apub_id)).build(),
) )
@ -158,12 +142,12 @@ impl PerformCrud for CreatePost {
score: 1, score: 1,
}; };
PostLike::like(&mut *context.conn().await?, &like_form) PostLike::like(&mut conn, &like_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?;
// Mark the post as read // Mark the post as read
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_read(person_id, post_id, &mut conn).await?;
if let Some(url) = &updated_post.url { if let Some(url) = &updated_post.url {
let mut webmention = let mut webmention =

View file

@ -18,24 +18,20 @@ impl PerformCrud for DeletePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DeletePost = self; let data: &DeletePost = self;
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?;
let post_id = data.post_id; let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?; let orig_post = Post::read(&mut conn, post_id).await?;
// Dont delete it if its already been deleted. // Dont delete it if its already been deleted.
if orig_post.deleted == data.deleted { if orig_post.deleted == data.deleted {
return Err(LemmyError::from_message("couldnt_update_post")); return Err(LemmyError::from_message("couldnt_update_post"));
} }
check_community_ban( check_community_ban(local_user_view.person.id, orig_post.community_id, &mut conn).await?;
local_user_view.person.id, check_community_deleted_or_removed(orig_post.community_id, &mut conn).await?;
orig_post.community_id,
&mut *context.conn().await?,
)
.await?;
check_community_deleted_or_removed(orig_post.community_id, &mut *context.conn().await?).await?;
// Verify that only the creator can delete // Verify that only the creator can delete
if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) { if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) {
@ -46,7 +42,7 @@ impl PerformCrud for DeletePost {
let post_id = data.post_id; let post_id = data.post_id;
let deleted = data.deleted; let deleted = data.deleted;
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post_id, post_id,
&PostUpdateForm::builder().deleted(Some(deleted)).build(), &PostUpdateForm::builder().deleted(Some(deleted)).build(),
) )

View file

@ -25,9 +25,10 @@ impl PerformCrud for GetPost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetPostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetPostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetPost = self; let data: &GetPost = self;
let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await; let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
check_private_instance(&local_user_view, &local_site)?; check_private_instance(&local_user_view, &local_site)?;
@ -37,7 +38,7 @@ impl PerformCrud for GetPost {
let post_id = if let Some(id) = data.id { let post_id = if let Some(id) = data.id {
id id
} else if let Some(comment_id) = data.comment_id { } else if let Some(comment_id) = data.comment_id {
Comment::read(&mut *context.conn().await?, comment_id) Comment::read(&mut conn, comment_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))? .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?
.post_id .post_id
@ -46,39 +47,25 @@ impl PerformCrud for GetPost {
}; };
// Check to see if the person is a mod or admin, to show deleted / removed // Check to see if the person is a mod or admin, to show deleted / removed
let community_id = Post::read(&mut *context.conn().await?, post_id) let community_id = Post::read(&mut conn, post_id).await?.community_id;
.await? let is_mod_or_admin =
.community_id; is_mod_or_admin_opt(&mut conn, local_user_view.as_ref(), Some(community_id))
let is_mod_or_admin = is_mod_or_admin_opt(
&mut *context.conn().await?,
local_user_view.as_ref(),
Some(community_id),
)
.await .await
.is_ok(); .is_ok();
let post_view = PostView::read( let post_view = PostView::read(&mut conn, post_id, person_id, Some(is_mod_or_admin))
&mut *context.conn().await?,
post_id,
person_id,
Some(is_mod_or_admin),
)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
// Mark the post as read // Mark the post as read
let post_id = post_view.post.id; let post_id = post_view.post.id;
if let Some(person_id) = person_id { if let Some(person_id) = person_id {
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?; mark_post_as_read(person_id, post_id, &mut conn).await?;
} }
// Necessary for the sidebar subscribed // Necessary for the sidebar subscribed
let community_view = CommunityView::read( let community_view =
&mut *context.conn().await?, CommunityView::read(&mut conn, community_id, person_id, Some(is_mod_or_admin))
community_id,
person_id,
Some(is_mod_or_admin),
)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
@ -92,18 +79,17 @@ impl PerformCrud for GetPost {
read_comments, read_comments,
..PersonPostAggregatesForm::default() ..PersonPostAggregatesForm::default()
}; };
PersonPostAggregates::upsert(&mut *context.conn().await?, &person_post_agg_form) PersonPostAggregates::upsert(&mut conn, &person_post_agg_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
} }
let moderators = let moderators = CommunityModeratorView::for_community(&mut conn, community_id).await?;
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
// Fetch the cross_posts // Fetch the cross_posts
let cross_posts = if let Some(url) = &post_view.post.url { let cross_posts = if let Some(url) = &post_view.post.url {
let mut x_posts = PostQuery::builder() let mut x_posts = PostQuery::builder()
.conn(&mut *context.conn().await?) .conn(&mut conn)
.url_search(Some(url.inner().as_str().into())) .url_search(Some(url.inner().as_str().into()))
.build() .build()
.list() .list()

View file

@ -21,32 +21,23 @@ impl PerformCrud for RemovePost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &RemovePost = self; let data: &RemovePost = self;
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?;
let post_id = data.post_id; let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?; let orig_post = Post::read(&mut conn, post_id).await?;
check_community_ban( check_community_ban(local_user_view.person.id, orig_post.community_id, &mut conn).await?;
local_user_view.person.id,
orig_post.community_id,
&mut *context.conn().await?,
)
.await?;
// Verify that only the mods can remove // Verify that only the mods can remove
is_mod_or_admin( is_mod_or_admin(&mut conn, local_user_view.person.id, orig_post.community_id).await?;
&mut *context.conn().await?,
local_user_view.person.id,
orig_post.community_id,
)
.await?;
// Update the post // Update the post
let post_id = data.post_id; let post_id = data.post_id;
let removed = data.removed; let removed = data.removed;
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post_id, post_id,
&PostUpdateForm::builder().removed(Some(removed)).build(), &PostUpdateForm::builder().removed(Some(removed)).build(),
) )
@ -59,7 +50,7 @@ impl PerformCrud for RemovePost {
removed: Some(removed), removed: Some(removed),
reason: data.reason.clone(), reason: data.reason.clone(),
}; };
ModRemovePost::create(&mut *context.conn().await?, &form).await?; ModRemovePost::create(&mut conn, &form).await?;
build_post_response( build_post_response(
context, context,

View file

@ -30,9 +30,10 @@ impl PerformCrud for EditPost {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditPost = self; let data: &EditPost = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let data_url = data.url.as_ref(); let data_url = data.url.as_ref();
@ -52,14 +53,9 @@ impl PerformCrud for EditPost {
is_valid_body_field(&data.body, true)?; is_valid_body_field(&data.body, true)?;
let post_id = data.post_id; let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?; let orig_post = Post::read(&mut conn, post_id).await?;
check_community_ban( check_community_ban(local_user_view.person.id, orig_post.community_id, &mut conn).await?;
local_user_view.person.id,
orig_post.community_id,
&mut *context.conn().await?,
)
.await?;
// Verify that only the creator can edit // Verify that only the creator can edit
if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) { if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) {
@ -76,7 +72,7 @@ impl PerformCrud for EditPost {
let language_id = self.language_id; let language_id = self.language_id;
CommunityLanguage::is_allowed_community_language( CommunityLanguage::is_allowed_community_language(
&mut *context.conn().await?, &mut conn,
language_id, language_id,
orig_post.community_id, orig_post.community_id,
) )
@ -96,7 +92,7 @@ impl PerformCrud for EditPost {
.build(); .build();
let post_id = data.post_id; let post_id = data.post_id;
let res = Post::update(&mut *context.conn().await?, post_id, &post_form).await; let res = Post::update(&mut conn, post_id, &post_form).await;
if let Err(e) = res { if let Err(e) = res {
let err_type = if e.to_string() == "value too long for type character varying(200)" { let err_type = if e.to_string() == "value too long for type character varying(200)" {
"post_title_too_long" "post_title_too_long"

View file

@ -35,9 +35,10 @@ impl PerformCrud for CreatePrivateMessage {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> { ) -> Result<PrivateMessageResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreatePrivateMessage = self; let data: &CreatePrivateMessage = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
let content_slurs_removed = remove_slurs( let content_slurs_removed = remove_slurs(
&data.content.clone(), &data.content.clone(),
@ -45,12 +46,7 @@ impl PerformCrud for CreatePrivateMessage {
); );
is_valid_body_field(&Some(content_slurs_removed.clone()), false)?; is_valid_body_field(&Some(content_slurs_removed.clone()), false)?;
check_person_block( check_person_block(local_user_view.person.id, data.recipient_id, &mut conn).await?;
local_user_view.person.id,
data.recipient_id,
&mut *context.conn().await?,
)
.await?;
let private_message_form = PrivateMessageInsertForm::builder() let private_message_form = PrivateMessageInsertForm::builder()
.content(content_slurs_removed.clone()) .content(content_slurs_removed.clone())
@ -59,7 +55,7 @@ impl PerformCrud for CreatePrivateMessage {
.build(); .build();
let inserted_private_message = let inserted_private_message =
match PrivateMessage::create(&mut *context.conn().await?, &private_message_form).await { match PrivateMessage::create(&mut conn, &private_message_form).await {
Ok(private_message) => private_message, Ok(private_message) => private_message,
Err(e) => { Err(e) => {
return Err(LemmyError::from_error_message( return Err(LemmyError::from_error_message(
@ -77,7 +73,7 @@ impl PerformCrud for CreatePrivateMessage {
&protocol_and_hostname, &protocol_and_hostname,
)?; )?;
PrivateMessage::update( PrivateMessage::update(
&mut *context.conn().await?, &mut conn,
inserted_private_message.id, inserted_private_message.id,
&PrivateMessageUpdateForm::builder() &PrivateMessageUpdateForm::builder()
.ap_id(Some(apub_id)) .ap_id(Some(apub_id))
@ -86,14 +82,12 @@ impl PerformCrud for CreatePrivateMessage {
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_private_message"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_create_private_message"))?;
let view = let view = PrivateMessageView::read(&mut conn, inserted_private_message.id).await?;
PrivateMessageView::read(&mut *context.conn().await?, inserted_private_message.id).await?;
// Send email to the local recipient, if one exists // Send email to the local recipient, if one exists
if view.recipient.local { if view.recipient.local {
let recipient_id = data.recipient_id; let recipient_id = data.recipient_id;
let local_recipient = let local_recipient = LocalUserView::read_person(&mut conn, recipient_id).await?;
LocalUserView::read_person(&mut *context.conn().await?, recipient_id).await?;
let lang = get_interface_language(&local_recipient); let lang = get_interface_language(&local_recipient);
let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname()); let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
let sender_name = &local_user_view.person.name; let sender_name = &local_user_view.person.name;

View file

@ -21,13 +21,13 @@ impl PerformCrud for DeletePrivateMessage {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> { ) -> Result<PrivateMessageResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &DeletePrivateMessage = self; let data: &DeletePrivateMessage = self;
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?;
// Checking permissions // Checking permissions
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
let orig_private_message = let orig_private_message = PrivateMessage::read(&mut conn, private_message_id).await?;
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id { if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyError::from_message("no_private_message_edit_allowed")); return Err(LemmyError::from_message("no_private_message_edit_allowed"));
} }
@ -36,7 +36,7 @@ impl PerformCrud for DeletePrivateMessage {
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
let deleted = data.deleted; let deleted = data.deleted;
PrivateMessage::update( PrivateMessage::update(
&mut *context.conn().await?, &mut conn,
private_message_id, private_message_id,
&PrivateMessageUpdateForm::builder() &PrivateMessageUpdateForm::builder()
.deleted(Some(deleted)) .deleted(Some(deleted))
@ -45,7 +45,7 @@ impl PerformCrud for DeletePrivateMessage {
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
let view = PrivateMessageView::read(&mut *context.conn().await?, private_message_id).await?; let view = PrivateMessageView::read(&mut conn, private_message_id).await?;
Ok(PrivateMessageResponse { Ok(PrivateMessageResponse {
private_message_view: view, private_message_view: view,
}) })

View file

@ -17,6 +17,7 @@ impl PerformCrud for GetPrivateMessages {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PrivateMessagesResponse, LemmyError> { ) -> Result<PrivateMessagesResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetPrivateMessages = self; let data: &GetPrivateMessages = self;
let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), context).await?; let local_user_view = local_user_view_from_jwt(data.auth.as_ref(), context).await?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
@ -25,7 +26,7 @@ impl PerformCrud for GetPrivateMessages {
let limit = data.limit; let limit = data.limit;
let unread_only = data.unread_only; let unread_only = data.unread_only;
let mut messages = PrivateMessageQuery::builder() let mut messages = PrivateMessageQuery::builder()
.conn(&mut *context.conn().await?) .conn(&mut conn)
.recipient_id(person_id) .recipient_id(person_id)
.page(page) .page(page)
.limit(limit) .limit(limit)

View file

@ -28,14 +28,14 @@ impl PerformCrud for EditPrivateMessage {
&self, &self,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<PrivateMessageResponse, LemmyError> { ) -> Result<PrivateMessageResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditPrivateMessage = self; let data: &EditPrivateMessage = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Checking permissions // Checking permissions
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
let orig_private_message = let orig_private_message = PrivateMessage::read(&mut conn, private_message_id).await?;
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id { if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyError::from_message("no_private_message_edit_allowed")); return Err(LemmyError::from_message("no_private_message_edit_allowed"));
} }
@ -46,7 +46,7 @@ impl PerformCrud for EditPrivateMessage {
let private_message_id = data.private_message_id; let private_message_id = data.private_message_id;
PrivateMessage::update( PrivateMessage::update(
&mut *context.conn().await?, &mut conn,
private_message_id, private_message_id,
&PrivateMessageUpdateForm::builder() &PrivateMessageUpdateForm::builder()
.content(Some(content_slurs_removed)) .content(Some(content_slurs_removed))
@ -56,7 +56,7 @@ impl PerformCrud for EditPrivateMessage {
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;
let view = PrivateMessageView::read(&mut *context.conn().await?, private_message_id).await?; let view = PrivateMessageView::read(&mut conn, private_message_id).await?;
Ok(PrivateMessageResponse { Ok(PrivateMessageResponse {
private_message_view: view, private_message_view: view,

View file

@ -47,10 +47,11 @@ impl PerformCrud for CreateSite {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &CreateSite = self; let data: &CreateSite = self;
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?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
// Make sure user is an admin; other types of users should not create site data... // Make sure user is an admin; other types of users should not create site data...
is_admin(&local_user_view)?; is_admin(&local_user_view)?;
@ -75,7 +76,7 @@ impl PerformCrud for CreateSite {
let site_id = local_site.site_id; let site_id = local_site.site_id;
Site::update(&mut *context.conn().await?, site_id, &site_form).await?; Site::update(&mut conn, site_id, &site_form).await?;
let local_site_form = LocalSiteUpdateForm::builder() let local_site_form = LocalSiteUpdateForm::builder()
// Set the site setup to true // Set the site setup to true
@ -100,7 +101,7 @@ impl PerformCrud for CreateSite {
.captcha_difficulty(data.captcha_difficulty.clone()) .captcha_difficulty(data.captcha_difficulty.clone())
.build(); .build();
LocalSite::update(&mut *context.conn().await?, &local_site_form).await?; LocalSite::update(&mut conn, &local_site_form).await?;
let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder() let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder()
.message(data.rate_limit_message) .message(data.rate_limit_message)
@ -117,13 +118,12 @@ impl PerformCrud for CreateSite {
.search_per_second(data.rate_limit_search_per_second) .search_per_second(data.rate_limit_search_per_second)
.build(); .build();
LocalSiteRateLimit::update(&mut *context.conn().await?, &local_site_rate_limit_form).await?; LocalSiteRateLimit::update(&mut conn, &local_site_rate_limit_form).await?;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let new_taglines = data.taglines.clone(); let new_taglines = data.taglines.clone();
let taglines = let taglines = Tagline::replace(&mut conn, local_site.id, new_taglines).await?;
Tagline::replace(&mut *context.conn().await?, local_site.id, new_taglines).await?;
let rate_limit_config = let rate_limit_config =
local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit); local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit);

View file

@ -30,11 +30,12 @@ impl PerformCrud for GetSite {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetSite = self; let data: &GetSite = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?; let admins = PersonView::admins(&mut conn).await?;
// Build the local user // Build the local user
let my_user = if let Some(local_user_view) = let my_user = if let Some(local_user_view) =
@ -43,26 +44,25 @@ impl PerformCrud for GetSite {
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let local_user_id = local_user_view.local_user.id; let local_user_id = local_user_view.local_user.id;
let follows = CommunityFollowerView::for_person(&mut *context.conn().await?, person_id) let follows = CommunityFollowerView::for_person(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?; .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let community_blocks = CommunityBlockView::for_person(&mut *context.conn().await?, person_id) let community_blocks = CommunityBlockView::for_person(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?; .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let person_id = local_user_view.person.id; let person_id = local_user_view.person.id;
let person_blocks = PersonBlockView::for_person(&mut *context.conn().await?, person_id) let person_blocks = PersonBlockView::for_person(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?; .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let moderates = CommunityModeratorView::for_person(&mut *context.conn().await?, person_id) let moderates = CommunityModeratorView::for_person(&mut conn, person_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?; .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let discussion_languages = let discussion_languages = LocalUserLanguage::read(&mut conn, local_user_id)
LocalUserLanguage::read(&mut *context.conn().await?, local_user_id)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?; .map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
@ -78,11 +78,10 @@ impl PerformCrud for GetSite {
None None
}; };
let all_languages = Language::read_all(&mut *context.conn().await?).await?; let all_languages = Language::read_all(&mut conn).await?;
let discussion_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?; let discussion_languages = SiteLanguage::read_local_raw(&mut conn).await?;
let taglines = Tagline::get_all(&mut *context.conn().await?, site_view.local_site.id).await?; let taglines = Tagline::get_all(&mut conn, site_view.local_site.id).await?;
let custom_emojis = let custom_emojis = CustomEmojiView::get_all(&mut conn, site_view.local_site.id).await?;
CustomEmojiView::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
Ok(GetSiteResponse { Ok(GetSiteResponse {
site_view, site_view,

View file

@ -44,9 +44,10 @@ impl PerformCrud for EditSite {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<SiteResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &EditSite = self; let data: &EditSite = self;
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?;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let local_site = site_view.local_site; let local_site = site_view.local_site;
let site = site_view.site; let site = site_view.site;
@ -56,12 +57,7 @@ impl PerformCrud for EditSite {
validate_update_payload(&local_site, data)?; validate_update_payload(&local_site, data)?;
if let Some(discussion_languages) = data.discussion_languages.clone() { if let Some(discussion_languages) = data.discussion_languages.clone() {
SiteLanguage::update( SiteLanguage::update(&mut conn, discussion_languages.clone(), &site).await?;
&mut *context.conn().await?,
discussion_languages.clone(),
&site,
)
.await?;
} }
let site_form = SiteUpdateForm::builder() let site_form = SiteUpdateForm::builder()
@ -73,7 +69,7 @@ impl PerformCrud for EditSite {
.updated(Some(Some(naive_now()))) .updated(Some(Some(naive_now())))
.build(); .build();
Site::update(&mut *context.conn().await?, site.id, &site_form) Site::update(&mut conn, site.id, &site_form)
.await .await
// Ignore errors for all these, so as to not throw errors if no update occurs // Ignore errors for all these, so as to not throw errors if no update occurs
// Diesel will throw an error for empty update forms // Diesel will throw an error for empty update forms
@ -101,9 +97,7 @@ impl PerformCrud for EditSite {
.reports_email_admins(data.reports_email_admins) .reports_email_admins(data.reports_email_admins)
.build(); .build();
let update_local_site = LocalSite::update(&mut *context.conn().await?, &local_site_form) let update_local_site = LocalSite::update(&mut conn, &local_site_form).await.ok();
.await
.ok();
let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder() let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder()
.message(data.rate_limit_message) .message(data.rate_limit_message)
@ -120,15 +114,15 @@ impl PerformCrud for EditSite {
.search_per_second(data.rate_limit_search_per_second) .search_per_second(data.rate_limit_search_per_second)
.build(); .build();
LocalSiteRateLimit::update(&mut *context.conn().await?, &local_site_rate_limit_form) LocalSiteRateLimit::update(&mut conn, &local_site_rate_limit_form)
.await .await
.ok(); .ok();
// Replace the blocked and allowed instances // Replace the blocked and allowed instances
let allowed = data.allowed_instances.clone(); let allowed = data.allowed_instances.clone();
FederationAllowList::replace(&mut *context.conn().await?, allowed).await?; FederationAllowList::replace(&mut conn, allowed).await?;
let blocked = data.blocked_instances.clone(); let blocked = data.blocked_instances.clone();
FederationBlockList::replace(&mut *context.conn().await?, blocked).await?; FederationBlockList::replace(&mut conn, blocked).await?;
// TODO can't think of a better way to do this. // TODO can't think of a better way to do this.
// If the server suddenly requires email verification, or required applications, no old users // If the server suddenly requires email verification, or required applications, no old users
@ -142,7 +136,7 @@ impl PerformCrud for EditSite {
.map(|ols| ols.registration_mode == RegistrationMode::RequireApplication) .map(|ols| ols.registration_mode == RegistrationMode::RequireApplication)
.unwrap_or(false); .unwrap_or(false);
if !old_require_application && new_require_application { if !old_require_application && new_require_application {
LocalUser::set_all_users_registration_applications_accepted(&mut *context.conn().await?) LocalUser::set_all_users_registration_applications_accepted(&mut conn)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_registrations_accepted"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_registrations_accepted"))?;
} }
@ -152,16 +146,15 @@ impl PerformCrud for EditSite {
.map(|ols| ols.require_email_verification) .map(|ols| ols.require_email_verification)
.unwrap_or(false); .unwrap_or(false);
if !local_site.require_email_verification && new_require_email_verification { if !local_site.require_email_verification && new_require_email_verification {
LocalUser::set_all_users_email_verified(&mut *context.conn().await?) LocalUser::set_all_users_email_verified(&mut conn)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_email_verified"))?; .map_err(|e| LemmyError::from_error_message(e, "couldnt_set_all_email_verified"))?;
} }
let new_taglines = data.taglines.clone(); let new_taglines = data.taglines.clone();
let taglines = let taglines = Tagline::replace(&mut conn, local_site.id, new_taglines).await?;
Tagline::replace(&mut *context.conn().await?, local_site.id, new_taglines).await?;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let rate_limit_config = let rate_limit_config =
local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit); local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit);

View file

@ -43,9 +43,10 @@ impl PerformCrud for Register {
#[tracing::instrument(skip(self, context))] #[tracing::instrument(skip(self, context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &Register = self; let data: &Register = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?; let site_view = SiteView::read_local(&mut conn).await?;
let local_site = site_view.local_site; let local_site = site_view.local_site;
let require_registration_application = let require_registration_application =
local_site.registration_mode == RegistrationMode::RequireApplication; local_site.registration_mode == RegistrationMode::RequireApplication;
@ -104,7 +105,7 @@ impl PerformCrud for Register {
)?; )?;
if let Some(email) = &data.email { if let Some(email) = &data.email {
if LocalUser::is_email_taken(&mut *context.conn().await?, email).await? { if LocalUser::is_email_taken(&mut conn, email).await? {
return Err(LemmyError::from_message("email_already_exists")); return Err(LemmyError::from_message("email_already_exists"));
} }
} }
@ -125,7 +126,7 @@ impl PerformCrud for Register {
.build(); .build();
// insert the person // insert the person
let inserted_person = Person::create(&mut *context.conn().await?, &person_form) let inserted_person = Person::create(&mut conn, &person_form)
.await .await
.map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?; .map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
@ -142,8 +143,7 @@ impl PerformCrud for Register {
.accepted_application(accepted_application) .accepted_application(accepted_application)
.build(); .build();
let inserted_local_user = let inserted_local_user = LocalUser::create(&mut conn, &local_user_form).await?;
LocalUser::create(&mut *context.conn().await?, &local_user_form).await?;
if local_site.site_setup && require_registration_application { if local_site.site_setup && require_registration_application {
// Create the registration application // Create the registration application
@ -153,17 +153,12 @@ impl PerformCrud for Register {
answer: data.answer.clone().expect("must have an answer"), answer: data.answer.clone().expect("must have an answer"),
}; };
RegistrationApplication::create(&mut *context.conn().await?, &form).await?; RegistrationApplication::create(&mut conn, &form).await?;
} }
// Email the admins // Email the admins
if local_site.application_email_admins { if local_site.application_email_admins {
send_new_applicant_email_to_admins( send_new_applicant_email_to_admins(&data.username, &mut conn, context.settings()).await?;
&data.username,
&mut *context.conn().await?,
context.settings(),
)
.await?;
} }
let mut login_response = LoginResponse { let mut login_response = LoginResponse {
@ -198,13 +193,7 @@ impl PerformCrud for Register {
.clone() .clone()
.expect("email was provided"); .expect("email was provided");
send_verification_email( send_verification_email(&local_user_view, &email, &mut conn, context.settings()).await?;
&local_user_view,
&email,
&mut *context.conn().await?,
context.settings(),
)
.await?;
login_response.verify_email_sent = true; login_response.verify_email_sent = true;
} }

View file

@ -51,6 +51,8 @@ impl BlockUser {
expires: Option<NaiveDateTime>, expires: Option<NaiveDateTime>,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<BlockUser, LemmyError> { ) -> Result<BlockUser, LemmyError> {
let mut conn = context.conn().await?;
let audience = if let SiteOrCommunity::Community(c) = target { let audience = if let SiteOrCommunity::Community(c) = target {
Some(c.id().into()) Some(c.id().into())
} else { } else {
@ -60,7 +62,7 @@ impl BlockUser {
actor: mod_.id().into(), actor: mod_.id().into(),
to: vec![public()], to: vec![public()],
object: user.id().into(), object: user.id().into(),
cc: generate_cc(target, &mut *context.conn().await?).await?, cc: generate_cc(target, &mut conn).await?,
target: target.id(), target: target.id(),
kind: BlockType::Block, kind: BlockType::Block,
remove_data, remove_data,
@ -84,6 +86,8 @@ impl BlockUser {
expires: Option<NaiveDateTime>, expires: Option<NaiveDateTime>,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let block = BlockUser::new( let block = BlockUser::new(
target, target,
user, user,
@ -97,7 +101,7 @@ impl BlockUser {
match target { match target {
SiteOrCommunity::Site(_) => { SiteOrCommunity::Site(_) => {
let inboxes = remote_instance_inboxes(&mut *context.conn().await?).await?; let inboxes = remote_instance_inboxes(&mut conn).await?;
send_lemmy_activity(context, block, mod_, inboxes, false).await send_lemmy_activity(context, block, mod_, inboxes, false).await
} }
SiteOrCommunity::Community(c) => { SiteOrCommunity::Community(c) => {
@ -147,6 +151,7 @@ impl ActivityHandler for BlockUser {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let expires = self.expires.map(|u| u.naive_local()); let expires = self.expires.map(|u| u.naive_local());
let mod_person = self.actor.dereference(context).await?; let mod_person = self.actor.dereference(context).await?;
@ -155,7 +160,7 @@ impl ActivityHandler for BlockUser {
match target { match target {
SiteOrCommunity::Site(_site) => { SiteOrCommunity::Site(_site) => {
let blocked_person = Person::update( let blocked_person = Person::update(
&mut *context.conn().await?, &mut conn,
blocked_person.id, blocked_person.id,
&PersonUpdateForm::builder() &PersonUpdateForm::builder()
.banned(Some(true)) .banned(Some(true))
@ -166,7 +171,7 @@ impl ActivityHandler for BlockUser {
if self.remove_data.unwrap_or(false) { if self.remove_data.unwrap_or(false) {
remove_user_data( remove_user_data(
blocked_person.id, blocked_person.id,
&mut *context.conn().await?, &mut conn,
context.settings(), context.settings(),
context.client(), context.client(),
) )
@ -181,7 +186,7 @@ impl ActivityHandler for BlockUser {
banned: Some(true), banned: Some(true),
expires, expires,
}; };
ModBan::create(&mut *context.conn().await?, &form).await?; ModBan::create(&mut conn, &form).await?;
} }
SiteOrCommunity::Community(community) => { SiteOrCommunity::Community(community) => {
let community_user_ban_form = CommunityPersonBanForm { let community_user_ban_form = CommunityPersonBanForm {
@ -189,7 +194,7 @@ impl ActivityHandler for BlockUser {
person_id: blocked_person.id, person_id: blocked_person.id,
expires: Some(expires), expires: Some(expires),
}; };
CommunityPersonBan::ban(&mut *context.conn().await?, &community_user_ban_form).await?; CommunityPersonBan::ban(&mut conn, &community_user_ban_form).await?;
// Also unsubscribe them from the community, if they are subscribed // Also unsubscribe them from the community, if they are subscribed
let community_follower_form = CommunityFollowerForm { let community_follower_form = CommunityFollowerForm {
@ -197,17 +202,12 @@ impl ActivityHandler for BlockUser {
person_id: blocked_person.id, person_id: blocked_person.id,
pending: false, pending: false,
}; };
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::unfollow(&mut conn, &community_follower_form)
.await .await
.ok(); .ok();
if self.remove_data.unwrap_or(false) { if self.remove_data.unwrap_or(false) {
remove_user_data_in_community( remove_user_data_in_community(community.id, blocked_person.id, &mut conn).await?;
community.id,
blocked_person.id,
&mut *context.conn().await?,
)
.await?;
} }
// write to mod log // write to mod log
@ -219,7 +219,7 @@ impl ActivityHandler for BlockUser {
banned: Some(true), banned: Some(true),
expires, expires,
}; };
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?; ModBanFromCommunity::create(&mut conn, &form).await?;
} }
} }

View file

@ -138,14 +138,10 @@ impl SendActivity for BanPerson {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let person = Person::read(&mut *context.conn().await?, request.person_id).await?; let person = Person::read(&mut conn, request.person_id).await?;
let site = SiteOrCommunity::Site( let site = SiteOrCommunity::Site(SiteView::read_local(&mut conn).await?.site.into());
SiteView::read_local(&mut *context.conn().await?)
.await?
.site
.into(),
);
let expires = request.expires.map(naive_from_unix); let expires = request.expires.map(naive_from_unix);
// if the action affects a local user, federate to other instances // if the action affects a local user, federate to other instances
@ -186,14 +182,12 @@ impl SendActivity for BanFromCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity = let community: ApubCommunity = Community::read(&mut conn, request.community_id)
Community::read(&mut *context.conn().await?, request.community_id)
.await?
.into();
let banned_person: ApubPerson = Person::read(&mut *context.conn().await?, request.person_id)
.await? .await?
.into(); .into();
let banned_person: ApubPerson = Person::read(&mut conn, request.person_id).await?.into();
let expires = request.expires.map(naive_from_unix); let expires = request.expires.map(naive_from_unix);
if request.ban { if request.ban {

View file

@ -38,6 +38,7 @@ impl UndoBlockUser {
reason: Option<String>, reason: Option<String>,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let block = BlockUser::new(target, user, mod_, None, reason, None, context).await?; let block = BlockUser::new(target, user, mod_, None, reason, None, context).await?;
let audience = if let SiteOrCommunity::Community(c) = target { let audience = if let SiteOrCommunity::Community(c) = target {
Some(c.id().into()) Some(c.id().into())
@ -53,7 +54,7 @@ impl UndoBlockUser {
actor: mod_.id().into(), actor: mod_.id().into(),
to: vec![public()], to: vec![public()],
object: block, object: block,
cc: generate_cc(target, &mut *context.conn().await?).await?, cc: generate_cc(target, &mut conn).await?,
kind: UndoType::Undo, kind: UndoType::Undo,
id: id.clone(), id: id.clone(),
audience, audience,
@ -62,7 +63,7 @@ impl UndoBlockUser {
let mut inboxes = vec![user.shared_inbox_or_inbox()]; let mut inboxes = vec![user.shared_inbox_or_inbox()];
match target { match target {
SiteOrCommunity::Site(_) => { SiteOrCommunity::Site(_) => {
inboxes.append(&mut remote_instance_inboxes(&mut *context.conn().await?).await?); inboxes.append(&mut remote_instance_inboxes(&mut conn).await?);
send_lemmy_activity(context, undo, mod_, inboxes, false).await send_lemmy_activity(context, undo, mod_, inboxes, false).await
} }
SiteOrCommunity::Community(c) => { SiteOrCommunity::Community(c) => {
@ -96,6 +97,7 @@ impl ActivityHandler for UndoBlockUser {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let expires = self.object.expires.map(|u| u.naive_local()); let expires = self.object.expires.map(|u| u.naive_local());
let mod_person = self.actor.dereference(context).await?; let mod_person = self.actor.dereference(context).await?;
@ -103,7 +105,7 @@ impl ActivityHandler for UndoBlockUser {
match self.object.target.dereference(context).await? { match self.object.target.dereference(context).await? {
SiteOrCommunity::Site(_site) => { SiteOrCommunity::Site(_site) => {
let blocked_person = Person::update( let blocked_person = Person::update(
&mut *context.conn().await?, &mut conn,
blocked_person.id, blocked_person.id,
&PersonUpdateForm::builder() &PersonUpdateForm::builder()
.banned(Some(false)) .banned(Some(false))
@ -120,7 +122,7 @@ impl ActivityHandler for UndoBlockUser {
banned: Some(false), banned: Some(false),
expires, expires,
}; };
ModBan::create(&mut *context.conn().await?, &form).await?; ModBan::create(&mut conn, &form).await?;
} }
SiteOrCommunity::Community(community) => { SiteOrCommunity::Community(community) => {
let community_user_ban_form = CommunityPersonBanForm { let community_user_ban_form = CommunityPersonBanForm {
@ -128,7 +130,7 @@ impl ActivityHandler for UndoBlockUser {
person_id: blocked_person.id, person_id: blocked_person.id,
expires: None, expires: None,
}; };
CommunityPersonBan::unban(&mut *context.conn().await?, &community_user_ban_form).await?; CommunityPersonBan::unban(&mut conn, &community_user_ban_form).await?;
// write to mod log // write to mod log
let form = ModBanFromCommunityForm { let form = ModBanFromCommunityForm {
@ -139,7 +141,7 @@ impl ActivityHandler for UndoBlockUser {
banned: Some(false), banned: Some(false),
expires, expires,
}; };
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?; ModBanFromCommunity::create(&mut conn, &form).await?;
} }
} }

View file

@ -117,9 +117,10 @@ impl ActivityHandler for CollectionAdd {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let (community, collection_type) = let (community, collection_type) =
Community::get_by_collection_url(&mut *context.conn().await?, &self.target.into()).await?; Community::get_by_collection_url(&mut conn, &self.target.into()).await?;
match collection_type { match collection_type {
CollectionType::Moderators => { CollectionType::Moderators => {
let new_mod = ObjectId::<ApubPerson>::from(self.object) let new_mod = ObjectId::<ApubPerson>::from(self.object)
@ -129,17 +130,14 @@ impl ActivityHandler for CollectionAdd {
// If we had to refetch the community while parsing the activity, then the new mod has already // If we had to refetch the community while parsing the activity, then the new mod has already
// been added. Skip it here as it would result in a duplicate key error. // been added. Skip it here as it would result in a duplicate key error.
let new_mod_id = new_mod.id; let new_mod_id = new_mod.id;
let moderated_communities = CommunityModerator::get_person_moderated_communities( let moderated_communities =
&mut *context.conn().await?, CommunityModerator::get_person_moderated_communities(&mut conn, new_mod_id).await?;
new_mod_id,
)
.await?;
if !moderated_communities.contains(&community.id) { if !moderated_communities.contains(&community.id) {
let form = CommunityModeratorForm { let form = CommunityModeratorForm {
community_id: community.id, community_id: community.id,
person_id: new_mod.id, person_id: new_mod.id,
}; };
CommunityModerator::join(&mut *context.conn().await?, &form).await?; CommunityModerator::join(&mut conn, &form).await?;
// write mod log // write mod log
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
@ -149,7 +147,7 @@ impl ActivityHandler for CollectionAdd {
community_id: community.id, community_id: community.id,
removed: Some(false), removed: Some(false),
}; };
ModAddCommunity::create(&mut *context.conn().await?, &form).await?; ModAddCommunity::create(&mut conn, &form).await?;
} }
// TODO: send websocket notification about added mod // TODO: send websocket notification about added mod
} }
@ -160,7 +158,7 @@ impl ActivityHandler for CollectionAdd {
let form = PostUpdateForm::builder() let form = PostUpdateForm::builder()
.featured_community(Some(true)) .featured_community(Some(true))
.build(); .build();
Post::update(&mut *context.conn().await?, post.id, &form).await?; Post::update(&mut conn, post.id, &form).await?;
} }
} }
Ok(()) Ok(())
@ -176,14 +174,12 @@ impl SendActivity for AddModToCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity = let community: ApubCommunity = Community::read(&mut conn, request.community_id)
Community::read(&mut *context.conn().await?, request.community_id)
.await?
.into();
let updated_mod: ApubPerson = Person::read(&mut *context.conn().await?, request.person_id)
.await? .await?
.into(); .into();
let updated_mod: ApubPerson = Person::read(&mut conn, request.person_id).await?.into();
if request.added { if request.added {
CollectionAdd::send_add_mod( CollectionAdd::send_add_mod(
&community, &community,
@ -213,8 +209,9 @@ impl SendActivity for FeaturePost {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, response.post_view.community.id) let community = Community::read(&mut conn, response.post_view.community.id)
.await? .await?
.into(); .into();
let post = response.post_view.post.clone().into(); let post = response.post_view.post.clone().into();

View file

@ -110,9 +110,10 @@ impl ActivityHandler for CollectionRemove {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let (community, collection_type) = let (community, collection_type) =
Community::get_by_collection_url(&mut *context.conn().await?, &self.target.into()).await?; Community::get_by_collection_url(&mut conn, &self.target.into()).await?;
match collection_type { match collection_type {
CollectionType::Moderators => { CollectionType::Moderators => {
let remove_mod = ObjectId::<ApubPerson>::from(self.object) let remove_mod = ObjectId::<ApubPerson>::from(self.object)
@ -123,7 +124,7 @@ impl ActivityHandler for CollectionRemove {
community_id: community.id, community_id: community.id,
person_id: remove_mod.id, person_id: remove_mod.id,
}; };
CommunityModerator::leave(&mut *context.conn().await?, &form).await?; CommunityModerator::leave(&mut conn, &form).await?;
// write mod log // write mod log
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
@ -133,7 +134,7 @@ impl ActivityHandler for CollectionRemove {
community_id: community.id, community_id: community.id,
removed: Some(true), removed: Some(true),
}; };
ModAddCommunity::create(&mut *context.conn().await?, &form).await?; ModAddCommunity::create(&mut conn, &form).await?;
// TODO: send websocket notification about removed mod // TODO: send websocket notification about removed mod
} }
@ -144,7 +145,7 @@ impl ActivityHandler for CollectionRemove {
let form = PostUpdateForm::builder() let form = PostUpdateForm::builder()
.featured_community(Some(false)) .featured_community(Some(false))
.build(); .build();
Post::update(&mut *context.conn().await?, post.id, &form).await?; Post::update(&mut conn, post.id, &form).await?;
} }
} }
Ok(()) Ok(())

View file

@ -58,9 +58,10 @@ impl ActivityHandler for LockPage {
} }
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
let mut conn = context.conn().await?;
let form = PostUpdateForm::builder().locked(Some(true)).build(); let form = PostUpdateForm::builder().locked(Some(true)).build();
let post = self.object.dereference(context).await?; let post = self.object.dereference(context).await?;
Post::update(&mut *context.conn().await?, post.id, &form).await?; Post::update(&mut conn, post.id, &form).await?;
Ok(()) Ok(())
} }
} }
@ -94,10 +95,11 @@ impl ActivityHandler for UndoLockPage {
} }
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let form = PostUpdateForm::builder().locked(Some(false)).build(); let form = PostUpdateForm::builder().locked(Some(false)).build();
let post = self.object.object.dereference(context).await?; let post = self.object.object.dereference(context).await?;
Post::update(&mut *context.conn().await?, post.id, &form).await?; Post::update(&mut conn, post.id, &form).await?;
Ok(()) Ok(())
} }
} }
@ -111,6 +113,7 @@ impl SendActivity for LockPost {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let id = generate_activity_id( let id = generate_activity_id(
LockType::Lock, LockType::Lock,
@ -145,8 +148,7 @@ impl SendActivity for LockPost {
}; };
AnnouncableActivities::UndoLockPost(undo) AnnouncableActivities::UndoLockPost(undo)
}; };
let community = let community = Community::read(&mut conn, response.post_view.community.id).await?;
Community::read(&mut *context.conn().await?, response.post_view.community.id).await?;
send_activity_in_community( send_activity_in_community(
activity, activity,
&local_user_view.person.into(), &local_user_view.person.into(),

View file

@ -38,13 +38,13 @@ pub(crate) async fn send_activity_in_community(
is_mod_action: bool, is_mod_action: bool,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
// send to any users which are mentioned or affected directly let mut conn = context.conn().await?; // send to any users which are mentioned or affected directly
let mut inboxes = extra_inboxes; let mut inboxes = extra_inboxes;
// send to user followers // send to user followers
if !is_mod_action { if !is_mod_action {
inboxes.extend( inboxes.extend(
&mut PersonFollower::list_followers(&mut *context.conn().await?, actor.id) &mut PersonFollower::list_followers(&mut conn, actor.id)
.await? .await?
.into_iter() .into_iter()
.map(|p| ApubPerson(p).shared_inbox_or_inbox()), .map(|p| ApubPerson(p).shared_inbox_or_inbox()),

View file

@ -122,6 +122,7 @@ impl ActivityHandler for Report {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, true, context).await?; insert_activity(&self.id, &self, false, true, context).await?;
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
match self.object.dereference(context).await? { match self.object.dereference(context).await? {
@ -134,7 +135,7 @@ impl ActivityHandler for Report {
reason: self.summary, reason: self.summary,
original_post_body: post.body.clone(), original_post_body: post.body.clone(),
}; };
PostReport::report(&mut *context.conn().await?, &report_form).await?; PostReport::report(&mut conn, &report_form).await?;
} }
PostOrComment::Comment(comment) => { PostOrComment::Comment(comment) => {
let report_form = CommentReportForm { let report_form = CommentReportForm {
@ -143,7 +144,7 @@ impl ActivityHandler for Report {
original_comment_text: comment.content.clone(), original_comment_text: comment.content.clone(),
reason: self.summary, reason: self.summary,
}; };
CommentReport::report(&mut *context.conn().await?, &report_form).await?; CommentReport::report(&mut conn, &report_form).await?;
} }
}; };
Ok(()) Ok(())

View file

@ -35,8 +35,9 @@ impl SendActivity for EditCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, request.community_id).await?; let community = Community::read(&mut conn, request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
} }
} }
@ -92,17 +93,13 @@ impl ActivityHandler for UpdateCommunity {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let community = self.community(context).await?; let community = self.community(context).await?;
let community_update_form = self.object.into_update_form(); let community_update_form = self.object.into_update_form();
Community::update( Community::update(&mut conn, community.id, &community_update_form).await?;
&mut *context.conn().await?,
community.id,
&community_update_form,
)
.await?;
Ok(()) Ok(())
} }
} }
@ -116,8 +113,9 @@ impl SendActivity for HideCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, request.community_id).await?; let community = Community::read(&mut conn, request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
} }
} }

View file

@ -89,16 +89,12 @@ impl CreateOrUpdateNote {
kind: CreateOrUpdateType, kind: CreateOrUpdateType,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
// TODO: might be helpful to add a comment method to retrieve community directly let mut conn = context.conn().await?; // TODO: might be helpful to add a comment method to retrieve community directly
let post_id = comment.post_id; let post_id = comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
let community_id = post.community_id; let community_id = post.community_id;
let person: ApubPerson = Person::read(&mut *context.conn().await?, person_id) let person: ApubPerson = Person::read(&mut conn, person_id).await?.into();
.await? let community: ApubCommunity = Community::read(&mut conn, community_id).await?.into();
.into();
let community: ApubCommunity = Community::read(&mut *context.conn().await?, community_id)
.await?
.into();
let id = generate_activity_id( let id = generate_activity_id(
kind.clone(), kind.clone(),
@ -171,6 +167,7 @@ impl ActivityHandler for CreateOrUpdateNote {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
// Need to do this check here instead of Note::from_json because we need the person who // Need to do this check here instead of Note::from_json because we need the person who
// send the activity, not the comment author. // send the activity, not the comment author.
@ -181,7 +178,7 @@ impl ActivityHandler for CreateOrUpdateNote {
if distinguished != existing_comment.distinguished { if distinguished != existing_comment.distinguished {
let creator = self.actor.dereference(context).await?; let creator = self.actor.dereference(context).await?;
let (post, _) = self.object.get_parents(context).await?; let (post, _) = self.object.get_parents(context).await?;
is_mod_or_admin(&mut *context.conn().await?, creator.id, post.community_id).await?; is_mod_or_admin(&mut conn, creator.id, post.community_id).await?;
} }
} }
@ -194,14 +191,14 @@ impl ActivityHandler for CreateOrUpdateNote {
person_id: comment.creator_id, person_id: comment.creator_id,
score: 1, score: 1,
}; };
CommentLike::like(&mut *context.conn().await?, &like_form).await?; CommentLike::like(&mut conn, &like_form).await?;
// Calculate initial hot_rank // Calculate initial hot_rank
CommentAggregates::update_hot_rank(&mut *context.conn().await?, comment.id).await?; CommentAggregates::update_hot_rank(&mut conn, comment.id).await?;
let do_send_email = self.kind == CreateOrUpdateType::Create; let do_send_email = self.kind == CreateOrUpdateType::Create;
let post_id = comment.post_id; let post_id = comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?; let post = Post::read(&mut conn, post_id).await?;
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
// Note: // Note:

View file

@ -107,14 +107,11 @@ impl CreateOrUpdatePage {
kind: CreateOrUpdateType, kind: CreateOrUpdateType,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let post = ApubPost(post.clone()); let post = ApubPost(post.clone());
let community_id = post.community_id; let community_id = post.community_id;
let person: ApubPerson = Person::read(&mut *context.conn().await?, person_id) let person: ApubPerson = Person::read(&mut conn, person_id).await?.into();
.await? let community: ApubCommunity = Community::read(&mut conn, community_id).await?.into();
.into();
let community: ApubCommunity = Community::read(&mut *context.conn().await?, community_id)
.await?
.into();
let create_or_update = let create_or_update =
CreateOrUpdatePage::new(post, &person, &community, kind, context).await?; CreateOrUpdatePage::new(post, &person, &community, kind, context).await?;
@ -182,6 +179,7 @@ impl ActivityHandler for CreateOrUpdatePage {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let post = ApubPost::from_json(self.object, context).await?; let post = ApubPost::from_json(self.object, context).await?;
@ -191,10 +189,10 @@ impl ActivityHandler for CreateOrUpdatePage {
person_id: post.creator_id, person_id: post.creator_id,
score: 1, score: 1,
}; };
PostLike::like(&mut *context.conn().await?, &like_form).await?; PostLike::like(&mut conn, &like_form).await?;
// Calculate initial hot_rank for post // Calculate initial hot_rank for post
PostAggregates::update_hot_rank(&mut *context.conn().await?, post.id).await?; PostAggregates::update_hot_rank(&mut conn, post.id).await?;
Ok(()) Ok(())
} }

View file

@ -70,13 +70,10 @@ impl CreateOrUpdateChatMessage {
kind: CreateOrUpdateType, kind: CreateOrUpdateType,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let recipient_id = private_message.recipient_id; let recipient_id = private_message.recipient_id;
let sender: ApubPerson = Person::read(&mut *context.conn().await?, sender_id) let sender: ApubPerson = Person::read(&mut conn, sender_id).await?.into();
.await? let recipient: ApubPerson = Person::read(&mut conn, recipient_id).await?.into();
.into();
let recipient: ApubPerson = Person::read(&mut *context.conn().await?, recipient_id)
.await?
.into();
let id = generate_activity_id( let id = generate_activity_id(
kind.clone(), kind.clone(),

View file

@ -105,6 +105,7 @@ pub(in crate::activities) async fn receive_remove_action(
reason: Option<String>, reason: Option<String>,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
match DeletableObjects::read_from_db(object, context).await? { match DeletableObjects::read_from_db(object, context).await? {
DeletableObjects::Community(community) => { DeletableObjects::Community(community) => {
if community.local { if community.local {
@ -119,9 +120,9 @@ pub(in crate::activities) async fn receive_remove_action(
reason, reason,
expires: None, expires: None,
}; };
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?; ModRemoveCommunity::create(&mut conn, &form).await?;
Community::update( Community::update(
&mut *context.conn().await?, &mut conn,
community.id, community.id,
&CommunityUpdateForm::builder().removed(Some(true)).build(), &CommunityUpdateForm::builder().removed(Some(true)).build(),
) )
@ -134,9 +135,9 @@ pub(in crate::activities) async fn receive_remove_action(
removed: Some(true), removed: Some(true),
reason, reason,
}; };
ModRemovePost::create(&mut *context.conn().await?, &form).await?; ModRemovePost::create(&mut conn, &form).await?;
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post.id, post.id,
&PostUpdateForm::builder().removed(Some(true)).build(), &PostUpdateForm::builder().removed(Some(true)).build(),
) )
@ -149,9 +150,9 @@ pub(in crate::activities) async fn receive_remove_action(
removed: Some(true), removed: Some(true),
reason, reason,
}; };
ModRemoveComment::create(&mut *context.conn().await?, &form).await?; ModRemoveComment::create(&mut conn, &form).await?;
Comment::update( Comment::update(
&mut *context.conn().await?, &mut conn,
comment.id, comment.id,
&CommentUpdateForm::builder().removed(Some(true)).build(), &CommentUpdateForm::builder().removed(Some(true)).build(),
) )

View file

@ -28,15 +28,10 @@ impl SendActivity for DeleteAccount {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let actor: ApubPerson = local_user_view.person.into(); let actor: ApubPerson = local_user_view.person.into();
delete_user_account( delete_user_account(actor.id, &mut conn, context.settings(), context.client()).await?;
actor.id,
&mut *context.conn().await?,
context.settings(),
context.client(),
)
.await?;
let id = generate_activity_id( let id = generate_activity_id(
DeleteType::Delete, DeleteType::Delete,
@ -51,7 +46,7 @@ impl SendActivity for DeleteAccount {
cc: vec![], cc: vec![],
}; };
let inboxes = remote_instance_inboxes(&mut *context.conn().await?).await?; let inboxes = remote_instance_inboxes(&mut conn).await?;
send_lemmy_activity(context, delete, &actor, inboxes, true).await?; send_lemmy_activity(context, delete, &actor, inboxes, true).await?;
Ok(()) Ok(())
} }
@ -80,15 +75,10 @@ impl ActivityHandler for DeleteUser {
} }
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, false, context).await?; insert_activity(&self.id, &self, false, false, context).await?;
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
delete_user_account( delete_user_account(actor.id, &mut conn, context.settings(), context.client()).await?;
actor.id,
&mut *context.conn().await?,
context.settings(),
context.client(),
)
.await?;
Ok(()) Ok(())
} }
} }

View file

@ -63,9 +63,9 @@ impl SendActivity for DeletePost {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = let community = Community::read(&mut conn, response.post_view.community.id).await?;
Community::read(&mut *context.conn().await?, response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into()); let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community( send_apub_delete_in_community(
local_user_view.person, local_user_view.person,
@ -88,9 +88,9 @@ impl SendActivity for RemovePost {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = let community = Community::read(&mut conn, response.post_view.community.id).await?;
Community::read(&mut *context.conn().await?, response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into()); let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community( send_apub_delete_in_community(
local_user_view.person, local_user_view.person,
@ -113,13 +113,10 @@ impl SendActivity for DeleteComment {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let community_id = response.comment_view.community.id; let community_id = response.comment_view.community.id;
let community = Community::read(&mut *context.conn().await?, community_id).await?; let community = Community::read(&mut conn, community_id).await?;
let person = Person::read( let person = Person::read(&mut conn, response.comment_view.creator.id).await?;
&mut *context.conn().await?,
response.comment_view.creator.id,
)
.await?;
let deletable = DeletableObjects::Comment(response.comment_view.comment.clone().into()); let deletable = DeletableObjects::Comment(response.comment_view.comment.clone().into());
send_apub_delete_in_community(person, community, deletable, None, request.deleted, context) send_apub_delete_in_community(person, community, deletable, None, request.deleted, context)
.await .await
@ -135,13 +132,10 @@ impl SendActivity for RemoveComment {
response: &Self::Response, response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let comment = Comment::read(&mut *context.conn().await?, request.comment_id).await?; let comment = Comment::read(&mut conn, request.comment_id).await?;
let community = Community::read( let community = Community::read(&mut conn, response.comment_view.community.id).await?;
&mut *context.conn().await?,
response.comment_view.community.id,
)
.await?;
let deletable = DeletableObjects::Comment(comment.into()); let deletable = DeletableObjects::Comment(comment.into());
send_apub_delete_in_community( send_apub_delete_in_community(
local_user_view.person, local_user_view.person,
@ -184,8 +178,9 @@ impl SendActivity for DeleteCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, request.community_id).await?; let community = Community::read(&mut conn, request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into()); let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community( send_apub_delete_in_community(
local_user_view.person, local_user_view.person,
@ -208,8 +203,9 @@ impl SendActivity for RemoveCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, request.community_id).await?; let community = Community::read(&mut conn, request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into()); let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community( send_apub_delete_in_community(
local_user_view.person, local_user_view.person,
@ -261,10 +257,9 @@ async fn send_apub_delete_private_message(
deleted: bool, deleted: bool,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let recipient_id = pm.recipient_id; let recipient_id = pm.recipient_id;
let recipient: ApubPerson = Person::read(&mut *context.conn().await?, recipient_id) let recipient: ApubPerson = Person::read(&mut conn, recipient_id).await?.into();
.await?
.into();
let deletable = DeletableObjects::PrivateMessage(pm.into()); let deletable = DeletableObjects::PrivateMessage(pm.into());
let inbox = vec![recipient.shared_inbox_or_inbox()]; let inbox = vec![recipient.shared_inbox_or_inbox()];
@ -390,6 +385,7 @@ async fn receive_delete_action(
deleted: bool, deleted: bool,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
match DeletableObjects::read_from_db(object, context).await? { match DeletableObjects::read_from_db(object, context).await? {
DeletableObjects::Community(community) => { DeletableObjects::Community(community) => {
if community.local { if community.local {
@ -400,7 +396,7 @@ async fn receive_delete_action(
} }
Community::update( Community::update(
&mut *context.conn().await?, &mut conn,
community.id, community.id,
&CommunityUpdateForm::builder() &CommunityUpdateForm::builder()
.deleted(Some(deleted)) .deleted(Some(deleted))
@ -411,7 +407,7 @@ async fn receive_delete_action(
DeletableObjects::Post(post) => { DeletableObjects::Post(post) => {
if deleted != post.deleted { if deleted != post.deleted {
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post.id, post.id,
&PostUpdateForm::builder().deleted(Some(deleted)).build(), &PostUpdateForm::builder().deleted(Some(deleted)).build(),
) )
@ -421,7 +417,7 @@ async fn receive_delete_action(
DeletableObjects::Comment(comment) => { DeletableObjects::Comment(comment) => {
if deleted != comment.deleted { if deleted != comment.deleted {
Comment::update( Comment::update(
&mut *context.conn().await?, &mut conn,
comment.id, comment.id,
&CommentUpdateForm::builder().deleted(Some(deleted)).build(), &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
) )
@ -430,7 +426,7 @@ async fn receive_delete_action(
} }
DeletableObjects::PrivateMessage(pm) => { DeletableObjects::PrivateMessage(pm) => {
PrivateMessage::update( PrivateMessage::update(
&mut *context.conn().await?, &mut conn,
pm.id, pm.id,
&PrivateMessageUpdateForm::builder() &PrivateMessageUpdateForm::builder()
.deleted(Some(deleted)) .deleted(Some(deleted))

View file

@ -97,6 +97,7 @@ impl UndoDelete {
object: &Url, object: &Url,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
match DeletableObjects::read_from_db(object, context).await? { match DeletableObjects::read_from_db(object, context).await? {
DeletableObjects::Community(community) => { DeletableObjects::Community(community) => {
if community.local { if community.local {
@ -111,9 +112,9 @@ impl UndoDelete {
reason: None, reason: None,
expires: None, expires: None,
}; };
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?; ModRemoveCommunity::create(&mut conn, &form).await?;
Community::update( Community::update(
&mut *context.conn().await?, &mut conn,
community.id, community.id,
&CommunityUpdateForm::builder().removed(Some(false)).build(), &CommunityUpdateForm::builder().removed(Some(false)).build(),
) )
@ -126,9 +127,9 @@ impl UndoDelete {
removed: Some(false), removed: Some(false),
reason: None, reason: None,
}; };
ModRemovePost::create(&mut *context.conn().await?, &form).await?; ModRemovePost::create(&mut conn, &form).await?;
Post::update( Post::update(
&mut *context.conn().await?, &mut conn,
post.id, post.id,
&PostUpdateForm::builder().removed(Some(false)).build(), &PostUpdateForm::builder().removed(Some(false)).build(),
) )
@ -141,9 +142,9 @@ impl UndoDelete {
removed: Some(false), removed: Some(false),
reason: None, reason: None,
}; };
ModRemoveComment::create(&mut *context.conn().await?, &form).await?; ModRemoveComment::create(&mut conn, &form).await?;
Comment::update( Comment::update(
&mut *context.conn().await?, &mut conn,
comment.id, comment.id,
&CommentUpdateForm::builder().removed(Some(false)).build(), &CommentUpdateForm::builder().removed(Some(false)).build(),
) )

View file

@ -60,14 +60,14 @@ impl ActivityHandler for AcceptFollow {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, true, context).await?; insert_activity(&self.id, &self, false, true, context).await?;
let community = self.actor.dereference(context).await?; let community = self.actor.dereference(context).await?;
let person = self.object.actor.dereference(context).await?; let person = self.object.actor.dereference(context).await?;
// This will throw an error if no follow was requested // This will throw an error if no follow was requested
let community_id = community.id; let community_id = community.id;
let person_id = person.id; let person_id = person.id;
CommunityFollower::follow_accepted(&mut *context.conn().await?, community_id, person_id) CommunityFollower::follow_accepted(&mut conn, community_id, person_id).await?;
.await?;
Ok(()) Ok(())
} }

View file

@ -60,12 +60,13 @@ impl Follow {
community: &ApubCommunity, community: &ApubCommunity,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let community_follower_form = CommunityFollowerForm { let community_follower_form = CommunityFollowerForm {
community_id: community.id, community_id: community.id,
person_id: actor.id, person_id: actor.id,
pending: true, pending: true,
}; };
CommunityFollower::follow(&mut *context.conn().await?, &community_follower_form) CommunityFollower::follow(&mut conn, &community_follower_form)
.await .await
.ok(); .ok();
@ -103,6 +104,7 @@ impl ActivityHandler for Follow {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, true, context).await?; insert_activity(&self.id, &self, false, true, context).await?;
let actor = self.actor.dereference(context).await?; let actor = self.actor.dereference(context).await?;
let object = self.object.dereference(context).await?; let object = self.object.dereference(context).await?;
@ -113,7 +115,7 @@ impl ActivityHandler for Follow {
follower_id: actor.id, follower_id: actor.id,
pending: false, pending: false,
}; };
PersonFollower::follow(&mut *context.conn().await?, &form).await?; PersonFollower::follow(&mut conn, &form).await?;
} }
UserOrCommunity::Community(c) => { UserOrCommunity::Community(c) => {
let form = CommunityFollowerForm { let form = CommunityFollowerForm {
@ -121,7 +123,7 @@ impl ActivityHandler for Follow {
person_id: actor.id, person_id: actor.id,
pending: false, pending: false,
}; };
CommunityFollower::follow(&mut *context.conn().await?, &form).await?; CommunityFollower::follow(&mut conn, &form).await?;
} }
} }
@ -138,8 +140,9 @@ impl SendActivity for BlockCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community = Community::read(&mut *context.conn().await?, request.community_id).await?; let community = Community::read(&mut conn, request.community_id).await?;
UndoFollow::send(&local_user_view.person.into(), &community.into(), context).await UndoFollow::send(&local_user_view.person.into(), &community.into(), context).await
} }
} }

View file

@ -25,10 +25,10 @@ impl SendActivity for FollowCommunity {
_response: &Self::Response, _response: &Self::Response,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?; let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let person = local_user_view.person.clone().into(); let person = local_user_view.person.clone().into();
let community: ApubCommunity = let community: ApubCommunity = Community::read(&mut conn, request.community_id)
Community::read(&mut *context.conn().await?, request.community_id)
.await? .await?
.into(); .into();
if community.local { if community.local {

View file

@ -71,6 +71,7 @@ impl ActivityHandler for UndoFollow {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
insert_activity(&self.id, &self, false, true, context).await?; insert_activity(&self.id, &self, false, true, context).await?;
let person = self.actor.dereference(context).await?; let person = self.actor.dereference(context).await?;
let object = self.object.object.dereference(context).await?; let object = self.object.object.dereference(context).await?;
@ -82,7 +83,7 @@ impl ActivityHandler for UndoFollow {
follower_id: person.id, follower_id: person.id,
pending: false, pending: false,
}; };
PersonFollower::unfollow(&mut *context.conn().await?, &form).await?; PersonFollower::unfollow(&mut conn, &form).await?;
} }
UserOrCommunity::Community(c) => { UserOrCommunity::Community(c) => {
let form = CommunityFollowerForm { let form = CommunityFollowerForm {
@ -90,7 +91,7 @@ impl ActivityHandler for UndoFollow {
person_id: person.id, person_id: person.id,
pending: false, pending: false,
}; };
CommunityFollower::unfollow(&mut *context.conn().await?, &form).await?; CommunityFollower::unfollow(&mut conn, &form).await?;
} }
} }

View file

@ -53,13 +53,14 @@ pub(crate) async fn verify_person_in_community(
community: &ApubCommunity, community: &ApubCommunity,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let person = person_id.dereference(context).await?; let person = person_id.dereference(context).await?;
if person.banned { if person.banned {
return Err(LemmyError::from_message("Person is banned from site")); return Err(LemmyError::from_message("Person is banned from site"));
} }
let person_id = person.id; let person_id = person.id;
let community_id = community.id; let community_id = community.id;
let is_banned = CommunityPersonBanView::get(&mut *context.conn().await?, person_id, community_id) let is_banned = CommunityPersonBanView::get(&mut conn, person_id, community_id)
.await .await
.is_ok(); .is_ok();
if is_banned { if is_banned {
@ -81,10 +82,10 @@ pub(crate) async fn verify_mod_action(
community_id: CommunityId, community_id: CommunityId,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let mod_ = mod_id.dereference(context).await?; let mod_ = mod_id.dereference(context).await?;
let is_mod_or_admin = let is_mod_or_admin = CommunityView::is_mod_or_admin(&mut conn, mod_.id, community_id).await?;
CommunityView::is_mod_or_admin(&mut *context.conn().await?, mod_.id, community_id).await?;
if is_mod_or_admin { if is_mod_or_admin {
return Ok(()); return Ok(());
} }

View file

@ -83,11 +83,10 @@ async fn send_activity(
jwt: &Sensitive<String>, jwt: &Sensitive<String>,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let community = Community::read(&mut *context.conn().await?, community_id) let mut conn = context.conn().await?;
.await? let community = Community::read(&mut conn, community_id).await?.into();
.into();
let local_user_view = local_user_view_from_jwt(jwt, context).await?; let local_user_view = local_user_view_from_jwt(jwt, context).await?;
let actor = Person::read(&mut *context.conn().await?, local_user_view.person.id) let actor = Person::read(&mut conn, local_user_view.person.id)
.await? .await?
.into(); .into();
@ -112,6 +111,7 @@ async fn vote_comment(
comment: &ApubComment, comment: &ApubComment,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let comment_id = comment.id; let comment_id = comment.id;
let like_form = CommentLikeForm { let like_form = CommentLikeForm {
comment_id, comment_id,
@ -120,8 +120,8 @@ async fn vote_comment(
score: vote_type.into(), score: vote_type.into(),
}; };
let person_id = actor.id; let person_id = actor.id;
CommentLike::remove(&mut *context.conn().await?, person_id, comment_id).await?; CommentLike::remove(&mut conn, person_id, comment_id).await?;
CommentLike::like(&mut *context.conn().await?, &like_form).await?; CommentLike::like(&mut conn, &like_form).await?;
Ok(()) Ok(())
} }
@ -132,6 +132,7 @@ async fn vote_post(
post: &ApubPost, post: &ApubPost,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let post_id = post.id; let post_id = post.id;
let like_form = PostLikeForm { let like_form = PostLikeForm {
post_id: post.id, post_id: post.id,
@ -139,8 +140,8 @@ async fn vote_post(
score: vote_type.into(), score: vote_type.into(),
}; };
let person_id = actor.id; let person_id = actor.id;
PostLike::remove(&mut *context.conn().await?, person_id, post_id).await?; PostLike::remove(&mut conn, person_id, post_id).await?;
PostLike::like(&mut *context.conn().await?, &like_form).await?; PostLike::like(&mut conn, &like_form).await?;
Ok(()) Ok(())
} }
@ -150,9 +151,10 @@ async fn undo_vote_comment(
comment: &ApubComment, comment: &ApubComment,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let comment_id = comment.id; let comment_id = comment.id;
let person_id = actor.id; let person_id = actor.id;
CommentLike::remove(&mut *context.conn().await?, person_id, comment_id).await?; CommentLike::remove(&mut conn, person_id, comment_id).await?;
Ok(()) Ok(())
} }
@ -162,8 +164,9 @@ async fn undo_vote_post(
post: &ApubPost, post: &ApubPost,
context: &Data<LemmyContext>, context: &Data<LemmyContext>,
) -> Result<(), LemmyError> { ) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let post_id = post.id; let post_id = post.id;
let person_id = actor.id; let person_id = actor.id;
PostLike::remove(&mut *context.conn().await?, person_id, post_id).await?; PostLike::remove(&mut conn, person_id, post_id).await?;
Ok(()) Ok(())
} }

View file

@ -56,9 +56,11 @@ impl ActivityHandler for Vote {
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all)]
async fn verify(&self, context: &Data<LemmyContext>) -> Result<(), LemmyError> { async fn verify(&self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
let mut conn = context.conn().await?;
let community = self.community(context).await?; let community = self.community(context).await?;
verify_person_in_community(&self.actor, &community, context).await?; verify_person_in_community(&self.actor, &community, context).await?;
let enable_downvotes = LocalSite::read(&mut *context.conn().await?) let enable_downvotes = LocalSite::read(&mut conn)
.await .await
.map(|l| l.enable_downvotes) .map(|l| l.enable_downvotes)
.unwrap_or(true); .unwrap_or(true);

View file

@ -22,9 +22,10 @@ impl PerformApub for GetComments {
#[tracing::instrument(skip(context))] #[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetCommentsResponse, LemmyError> { async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetCommentsResponse, LemmyError> {
let mut conn = context.conn().await?;
let data: &GetComments = self; let data: &GetComments = self;
let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await; let local_user_view = local_user_view_from_jwt_opt(data.auth.as_ref(), context).await;
let local_site = LocalSite::read(&mut *context.conn().await?).await?; let local_site = LocalSite::read(&mut conn).await?;
check_private_instance(&local_user_view, &local_site)?; check_private_instance(&local_user_view, &local_site)?;
let community_id = if let Some(name) = &data.community_name { let community_id = if let Some(name) = &data.community_name {
@ -46,11 +47,7 @@ impl PerformApub for GetComments {
// If a parent_id is given, fetch the comment to get the path // If a parent_id is given, fetch the comment to get the path
let parent_path = if let Some(parent_id) = parent_id { let parent_path = if let Some(parent_id) = parent_id {
Some( Some(Comment::read(&mut conn, parent_id).await?.path)
Comment::read(&mut *context.conn().await?, parent_id)
.await?
.path,
)
} else { } else {
None None
}; };

Some files were not shown because too many files have changed in this diff Show more