LemmyNet/lemmy
2
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy.git synced 2024-12-03 09:41:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

DbConn trait

Browse source
This commit is contained in:
dull b 2023-07-01 03:04:38 +00:00
parent 6846210074
commit 5db6b556cc
214 changed files with 2371 additions and 2024 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
crates/api/src/comment/distinguish.rs
View file

@ -22,7 +22,7 @@ impl Perform for DistinguishComment {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?;
let orig_comment = CommentView::read(context.conn().await?, comment_id, None).await?;
check_community_ban(
local_user_view.person.id,
@ -44,14 +44,14 @@ impl Perform for DistinguishComment {
let form = CommentUpdateForm::builder()
.distinguished(Some(data.distinguished))
.build();
Comment::update(&mut *context.conn().await?, comment_id, &form)
Comment::update(context.conn().await?, comment_id, &form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
let comment_id = data.comment_id;
let person_id = local_user_view.person.id;
let comment_view =
CommentView::read(&mut *context.conn().await?, comment_id, Some(person_id)).await?;
CommentView::read(context.conn().await?, comment_id, Some(person_id)).await?;
Ok(CommentResponse {
comment_view,

13
crates/api/src/comment/like.rs
View file

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

6
crates/api/src/comment/save.rs
View file

@ -27,11 +27,11 @@ impl Perform for SaveComment {
};
if data.save {
CommentSaved::save(&mut *context.conn().await?, &comment_saved_form)
CommentSaved::save(context.conn().await?, &comment_saved_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
} else {
CommentSaved::unsave(&mut *context.conn().await?, &comment_saved_form)
CommentSaved::unsave(context.conn().await?, &comment_saved_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_comment"))?;
}
@ -39,7 +39,7 @@ impl Perform for SaveComment {
let comment_id = data.comment_id;
let person_id = local_user_view.person.id;
let comment_view =
CommentView::read(&mut *context.conn().await?, comment_id, Some(person_id)).await?;
CommentView::read(context.conn().await?, comment_id, Some(person_id)).await?;
Ok(CommentResponse {
comment_view,

8
crates/api/src/comment_report/create.rs
View file

@ -27,14 +27,14 @@ impl Perform for CreateCommentReport {
) -> Result<CommentReportResponse, LemmyError> {
let data: &CreateCommentReport = self;
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(context.conn().await?).await?;
let reason = self.reason.trim();
check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.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(context.conn().await?, comment_id, None).await?;
check_community_ban(
person_id,
@ -50,12 +50,12 @@ impl Perform for CreateCommentReport {
reason: reason.to_owned(),
};
let report = CommentReport::report(&mut *context.conn().await?, &report_form)
let report = CommentReport::report(context.conn().await?, &report_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let comment_report_view =
CommentReportView::read(&mut *context.conn().await?, report.id, person_id).await?;
CommentReportView::read(context.conn().await?, report.id, person_id).await?;
// Email the admins
if local_site.reports_email_admins {

2
crates/api/src/comment_report/list.rs
View file

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

10
crates/api/src/comment_report/resolve.rs
View file

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

10
crates/api/src/community/add_mod.rs
View file

@ -36,7 +36,7 @@ impl Perform for AddModToCommunity {
community_id,
)
.await?;
let community = Community::read(&mut *context.conn().await?, community_id).await?;
let community = Community::read(context.conn().await?, community_id).await?;
if local_user_view.person.admin && !community.local {
return Err(LemmyError::from_message("not_a_moderator"));
}
@ -47,11 +47,11 @@ impl Perform for AddModToCommunity {
person_id: data.person_id,
};
if data.added {
CommunityModerator::join(&mut *context.conn().await?, &community_moderator_form)
CommunityModerator::join(context.conn().await?, &community_moderator_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
} else {
CommunityModerator::leave(&mut *context.conn().await?, &community_moderator_form)
CommunityModerator::leave(context.conn().await?, &community_moderator_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
}
@ -64,13 +64,13 @@ impl Perform for AddModToCommunity {
removed: Some(!data.added),
};
ModAddCommunity::create(&mut *context.conn().await?, &form).await?;
ModAddCommunity::create(context.conn().await?, &form).await?;
// Note: in case a remote mod is added, this returns the old moderators list, it will only get
// updated once we receive an activity from the community (like `Announce/Add/Moderator`)
let community_id = data.community_id;
let moderators =
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
CommunityModeratorView::for_community(context.conn().await?, community_id).await?;
Ok(AddModToCommunityResponse { moderators })
}

10
crates/api/src/community/ban.rs
View file

@ -56,7 +56,7 @@ impl Perform for BanFromCommunity {
};
if data.ban {
CommunityPersonBan::ban(&mut *context.conn().await?, &community_user_ban_form)
CommunityPersonBan::ban(context.conn().await?, &community_user_ban_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
@ -67,11 +67,11 @@ impl Perform for BanFromCommunity {
pending: false,
};
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::unfollow(context.conn().await?, &community_follower_form)
.await
.ok();
} else {
CommunityPersonBan::unban(&mut *context.conn().await?, &community_user_ban_form)
CommunityPersonBan::unban(context.conn().await?, &community_user_ban_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_user_already_banned"))?;
}
@ -92,10 +92,10 @@ impl Perform for BanFromCommunity {
expires,
};
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?;
ModBanFromCommunity::create(context.conn().await?, &form).await?;
let person_id = data.person_id;
let person_view = PersonView::read(&mut *context.conn().await?, person_id).await?;
let person_view = PersonView::read(context.conn().await?, person_id).await?;
Ok(BanFromCommunityResponse {
person_view,

6
crates/api/src/community/block.rs
View file

@ -35,7 +35,7 @@ impl Perform for BlockCommunity {
};
if data.block {
CommunityBlock::block(&mut *context.conn().await?, &community_block_form)
CommunityBlock::block(context.conn().await?, &community_block_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
@ -46,11 +46,11 @@ impl Perform for BlockCommunity {
pending: false,
};
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::unfollow(context.conn().await?, &community_follower_form)
.await
.ok();
} else {
CommunityBlock::unblock(&mut *context.conn().await?, &community_block_form)
CommunityBlock::unblock(context.conn().await?, &community_block_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
}

9
crates/api/src/community/follow.rs
View file

@ -25,7 +25,7 @@ impl Perform for FollowCommunity {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let community_id = data.community_id;
let community = Community::read(&mut *context.conn().await?, community_id).await?;
let community = Community::read(context.conn().await?, community_id).await?;
let community_follower_form = CommunityFollowerForm {
community_id: data.community_id,
person_id: local_user_view.person.id,
@ -41,12 +41,12 @@ impl Perform for FollowCommunity {
.await?;
check_community_deleted_or_removed(community_id, &mut *context.conn().await?).await?;
CommunityFollower::follow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::follow(context.conn().await?, &community_follower_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
}
if !data.follow {
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::unfollow(context.conn().await?, &community_follower_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_follower_already_exists"))?;
}
@ -60,8 +60,7 @@ impl Perform for FollowCommunity {
None,
)
.await?;
let discussion_languages =
CommunityLanguage::read(&mut *context.conn().await?, community_id).await?;
let discussion_languages = CommunityLanguage::read(context.conn().await?, community_id).await?;
Ok(Self::Response {
community_view,

4
crates/api/src/community/hide.rs
View file

@ -39,11 +39,11 @@ impl Perform for HideCommunity {
};
let community_id = data.community_id;
Community::update(&mut *context.conn().await?, community_id, &community_form)
Community::update(context.conn().await?, community_id, &community_form)
.await
.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(context.conn().await?, &mod_hide_community_form).await?;
build_community_response(context, local_user_view, community_id).await
}

15
crates/api/src/community/transfer.rs
View file

@ -33,7 +33,7 @@ impl Perform for TransferCommunity {
// Fetch the community mods
let community_id = data.community_id;
let mut community_mods =
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
CommunityModeratorView::for_community(context.conn().await?, community_id).await?;
// Make sure transferrer is either the top community mod, or an admin
if !(is_top_mod(&local_user_view, &community_mods).is_ok()
@ -54,7 +54,7 @@ impl Perform for TransferCommunity {
// Delete all the mods
let community_id = data.community_id;
CommunityModerator::delete_for_community(&mut *context.conn().await?, community_id).await?;
CommunityModerator::delete_for_community(context.conn().await?, community_id).await?;
// TODO: this should probably be a bulk operation
// Re-add the mods, in the new order
@ -64,7 +64,7 @@ impl Perform for TransferCommunity {
person_id: cmod.moderator.id,
};
CommunityModerator::join(&mut *context.conn().await?, &community_moderator_form)
CommunityModerator::join(context.conn().await?, &community_moderator_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "community_moderator_already_exists"))?;
}
@ -76,7 +76,7 @@ impl Perform for TransferCommunity {
community_id: data.community_id,
};
ModTransferCommunity::create(&mut *context.conn().await?, &form).await?;
ModTransferCommunity::create(context.conn().await?, &form).await?;
let community_id = data.community_id;
let person_id = local_user_view.person.id;
@ -90,10 +90,9 @@ impl Perform for TransferCommunity {
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
let community_id = data.community_id;
let moderators =
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
let moderators = CommunityModeratorView::for_community(context.conn().await?, community_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
// Return the jwt
Ok(GetCommunityResponse {

18
crates/api/src/lib.rs
View file

@ -94,11 +94,11 @@ mod tests {
#[tokio::test]
#[serial]
async fn test_should_not_validate_user_token_after_password_change() {
let conn = &mut build_db_conn_for_tests().await;
let secret = Secret::init(conn).await.unwrap();
let mut conn = build_db_conn_for_tests().await;
let secret = Secret::init(&mut *conn).await.unwrap();
let settings = &SETTINGS.to_owned();
let inserted_instance = Instance::read_or_create(conn, "my_domain.tld".to_string())
let inserted_instance = Instance::read_or_create(&mut *conn, "my_domain.tld".to_string())
.await
.unwrap();
@ -108,14 +108,16 @@ mod tests {
.instance_id(inserted_instance.id)
.build();
let inserted_person = Person::create(conn, &new_person).await.unwrap();
let inserted_person = Person::create(&mut *conn, &new_person).await.unwrap();
let local_user_form = LocalUserInsertForm::builder()
.person_id(inserted_person.id)
.password_encrypted("123456".to_string())
.build();
let inserted_local_user = LocalUser::create(conn, &local_user_form).await.unwrap();
let inserted_local_user = LocalUser::create(&mut *conn, &local_user_form)
.await
.unwrap();
let jwt = Claims::jwt(
inserted_local_user.id.0,
@ -129,13 +131,15 @@ mod tests {
// The check should fail, since the validator time is now newer than the jwt issue time
let updated_local_user =
LocalUser::update_password(conn, inserted_local_user.id, "password111")
LocalUser::update_password(&mut *conn, inserted_local_user.id, "password111")
.await
.unwrap();
let check_after = check_validator_time(&updated_local_user.validator_time, &claims);
assert!(check_after.is_err());
let num_deleted = Person::delete(conn, inserted_person.id).await.unwrap();
let num_deleted = Person::delete(&mut *conn, inserted_person.id)
.await
.unwrap();
assert_eq!(1, num_deleted);
}
}

4
crates/api/src/local_user/add_admin.rs
View file

@ -44,9 +44,9 @@ impl Perform for AddAdmin {
removed: Some(!data.added),
};
ModAdd::create(&mut *context.conn().await?, &form).await?;
ModAdd::create(context.conn().await?, &form).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?;
let admins = PersonView::admins(context.conn().await?).await?;
Ok(AddAdminResponse { admins })
}

4
crates/api/src/local_user/ban_person.rs
View file

@ -68,10 +68,10 @@ impl Perform for BanPerson {
expires,
};
ModBan::create(&mut *context.conn().await?, &form).await?;
ModBan::create(context.conn().await?, &form).await?;
let person_id = data.person_id;
let person_view = PersonView::read(&mut *context.conn().await?, person_id).await?;
let person_view = PersonView::read(context.conn().await?, person_id).await?;
Ok(BanPersonResponse {
person_view,

6
crates/api/src/local_user/block.rs
View file

@ -34,18 +34,18 @@ impl Perform for BlockPerson {
target_id,
};
let target_person_view = PersonView::read(&mut *context.conn().await?, target_id).await?;
let target_person_view = PersonView::read(context.conn().await?, target_id).await?;
if target_person_view.person.admin {
return Err(LemmyError::from_message("cant_block_admin"));
}
if data.block {
PersonBlock::block(&mut *context.conn().await?, &person_block_form)
PersonBlock::block(context.conn().await?, &person_block_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
} else {
PersonBlock::unblock(&mut *context.conn().await?, &person_block_form)
PersonBlock::unblock(context.conn().await?, &person_block_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "person_block_already_exists"))?;
}

2
crates/api/src/local_user/change_password.rs
View file

@ -38,7 +38,7 @@ impl Perform for ChangePassword {
let local_user_id = local_user_view.local_user.id;
let new_password = data.new_password.clone();
let updated_local_user =
LocalUser::update_password(&mut *context.conn().await?, local_user_id, &new_password).await?;
LocalUser::update_password(context.conn().await?, local_user_id, &new_password).await?;
// Return the jwt
Ok(LoginResponse {

6
crates/api/src/local_user/change_password_after_reset.rs
View file

@ -22,7 +22,7 @@ impl Perform for PasswordChangeAfterReset {
// Fetch the user_id from the token
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(context.conn().await?, &token)
.await
.map(|p| p.local_user_id)?;
@ -36,12 +36,12 @@ impl Perform for PasswordChangeAfterReset {
// Update the user with the new password
let password = data.password.clone();
let updated_local_user =
LocalUser::update_password(&mut *context.conn().await?, local_user_id, &password)
LocalUser::update_password(context.conn().await?, local_user_id, &password)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_user"))?;
// Return the jwt if login is allowed
let site_view = SiteView::read_local(&mut *context.conn().await?).await?;
let site_view = SiteView::read_local(context.conn().await?).await?;
let jwt = if site_view.local_site.registration_mode == RegistrationMode::RequireApplication
&& !updated_local_user.accepted_application
{

4
crates/api/src/local_user/get_captcha.rs
View file

@ -17,7 +17,7 @@ impl Perform for GetCaptcha {
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let local_site = LocalSite::read(&mut *context.conn().await?).await?;
let local_site = LocalSite::read(context.conn().await?).await?;
if !local_site.captcha_enabled {
return Ok(GetCaptchaResponse { ok: None });
@ -37,7 +37,7 @@ impl Perform for GetCaptcha {
let captcha_form: CaptchaAnswerForm = CaptchaAnswerForm { answer };
// Stores the captcha item in the db
let captcha = CaptchaAnswer::insert(&mut *context.conn().await?, &captcha_form).await?;
let captcha = CaptchaAnswer::insert(context.conn().await?, &captcha_form).await?;
Ok(GetCaptchaResponse {
ok: Some(CaptchaResponse {

2
crates/api/src/local_user/list_banned.rs
View file

@ -19,7 +19,7 @@ impl Perform for GetBannedPersons {
// Make sure user is an admin
is_admin(&local_user_view)?;
let banned = PersonView::banned(&mut *context.conn().await?).await?;
let banned = PersonView::banned(context.conn().await?).await?;
Ok(Self::Response { banned })
}

4
crates/api/src/local_user/login.rs
View file

@ -17,12 +17,12 @@ impl Perform for Login {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let data: &Login = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?;
let site_view = SiteView::read_local(context.conn().await?).await?;
// Fetch that username / email
let username_or_email = data.username_or_email.clone();
let local_user_view =
LocalUserView::find_by_email_or_name(&mut *context.conn().await?, &username_or_email)
LocalUserView::find_by_email_or_name(context.conn().await?, &username_or_email)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;

2
crates/api/src/local_user/notifications/list_mentions.rs
View file

@ -29,7 +29,7 @@ impl Perform for GetPersonMentions {
let mut conn = context.conn().await?;
let mentions = PersonMentionQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.recipient_id(person_id)
.my_person_id(person_id)
.sort(sort)

2
crates/api/src/local_user/notifications/list_replies.rs
View file

@ -26,7 +26,7 @@ impl Perform for GetReplies {
let mut conn = context.conn().await?;
let replies = CommentReplyQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.recipient_id(person_id)
.my_person_id(person_id)
.sort(sort)

6
crates/api/src/local_user/notifications/mark_all_read.rs
View file

@ -23,17 +23,17 @@ impl Perform for MarkAllAsRead {
let person_id = local_user_view.person.id;
// Mark all comment_replies as read
CommentReply::mark_all_as_read(&mut *context.conn().await?, person_id)
CommentReply::mark_all_as_read(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Mark all user mentions as read
PersonMention::mark_all_as_read(&mut *context.conn().await?, person_id)
PersonMention::mark_all_as_read(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Mark all private_messages as read
PrivateMessage::mark_all_as_read(&mut *context.conn().await?, person_id)
PrivateMessage::mark_all_as_read(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_private_message"))?;

3
crates/api/src/local_user/notifications/mark_mention_read.rs
View file

@ -25,8 +25,7 @@ impl Perform for MarkPersonMentionAsRead {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let person_mention_id = data.person_mention_id;
let read_person_mention =
PersonMention::read(&mut *context.conn().await?, person_mention_id).await?;
let read_person_mention = PersonMention::read(context.conn().await?, person_mention_id).await?;
if local_user_view.person.id != read_person_mention.recipient_id {
return Err(LemmyError::from_message("couldnt_update_comment"));

3
crates/api/src/local_user/notifications/mark_reply_read.rs
View file

@ -25,8 +25,7 @@ impl Perform for MarkCommentReplyAsRead {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let comment_reply_id = data.comment_reply_id;
let read_comment_reply =
CommentReply::read(&mut *context.conn().await?, comment_reply_id).await?;
let read_comment_reply = CommentReply::read(context.conn().await?, comment_reply_id).await?;
if local_user_view.person.id != read_comment_reply.recipient_id {
return Err(LemmyError::from_message("couldnt_update_comment"));

8
crates/api/src/local_user/notifications/unread_count.rs
View file

@ -20,14 +20,12 @@ impl Perform for GetUnreadCount {
let person_id = local_user_view.person.id;
let replies =
CommentReplyView::get_unread_replies(&mut *context.conn().await?, person_id).await?;
let replies = CommentReplyView::get_unread_replies(context.conn().await?, person_id).await?;
let mentions =
PersonMentionView::get_unread_mentions(&mut *context.conn().await?, person_id).await?;
let mentions = PersonMentionView::get_unread_mentions(context.conn().await?, person_id).await?;
let private_messages =
PrivateMessageView::get_unread_messages(&mut *context.conn().await?, person_id).await?;
PrivateMessageView::get_unread_messages(context.conn().await?, person_id).await?;
Ok(Self::Response {
replies,

4
crates/api/src/local_user/report_count.rs
View file

@ -33,11 +33,11 @@ impl Perform for GetReportCount {
.await?;
let post_reports =
PostReportView::get_report_count(&mut *context.conn().await?, person_id, admin, community_id)
PostReportView::get_report_count(context.conn().await?, person_id, admin, community_id)
.await?;
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(context.conn().await?).await?)
} else {
None
};

2
crates/api/src/local_user/reset_password.rs
View file

@ -22,7 +22,7 @@ impl Perform for PasswordReset {
// Fetch that email
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(context.conn().await?, &email)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_that_username_or_email"))?;

6
crates/api/src/local_user/save_settings.rs
View file

@ -35,7 +35,7 @@ impl Perform for SaveUserSettings {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let data: &SaveUserSettings = self;
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(context.conn().await?).await?;
let avatar = diesel_option_overwrite_to_url(&data.avatar)?;
let banner = diesel_option_overwrite_to_url(&data.banner)?;
@ -95,7 +95,7 @@ impl Perform for SaveUserSettings {
.banner(banner)
.build();
Person::update(&mut *context.conn().await?, person_id, &person_form)
Person::update(context.conn().await?, person_id, &person_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
@ -140,7 +140,7 @@ impl Perform for SaveUserSettings {
.build();
let local_user_res =
LocalUser::update(&mut *context.conn().await?, local_user_id, &local_user_form).await;
LocalUser::update(context.conn().await?, local_user_id, &local_user_form).await;
let updated_local_user = match local_user_res {
Ok(u) => u,
Err(e) => {

6
crates/api/src/local_user/verify_email.rs
View file

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

6
crates/api/src/post/feature.rs
View file

@ -32,7 +32,7 @@ impl Perform for FeaturePost {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?;
let orig_post = Post::read(context.conn().await?, post_id).await?;
check_community_ban(
local_user_view.person.id,
@ -65,7 +65,7 @@ impl Perform for FeaturePost {
.featured_local(Some(data.featured))
.build()
};
Post::update(&mut *context.conn().await?, post_id, &new_post).await?;
Post::update(context.conn().await?, post_id, &new_post).await?;
// Mod tables
let form = ModFeaturePostForm {
@ -75,7 +75,7 @@ impl Perform for FeaturePost {
is_featured_community: data.feature_type == PostFeatureType::Community,
};
ModFeaturePost::create(&mut *context.conn().await?, &form).await?;
ModFeaturePost::create(context.conn().await?, &form).await?;
build_post_response(
context,

8
crates/api/src/post/like.rs
View file

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

4
crates/api/src/post/lock.rs
View file

@ -30,7 +30,7 @@ impl Perform for LockPost {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?;
let orig_post = Post::read(context.conn().await?, post_id).await?;
check_community_ban(
local_user_view.person.id,
@ -64,7 +64,7 @@ impl Perform for LockPost {
post_id: data.post_id,
locked: Some(locked),
};
ModLockPost::create(&mut *context.conn().await?, &form).await?;
ModLockPost::create(context.conn().await?, &form).await?;
build_post_response(
context,

3
crates/api/src/post/mark_read.rs
View file

@ -28,8 +28,7 @@ impl Perform for MarkPostAsRead {
}
// Fetch it
let post_view =
PostView::read(&mut *context.conn().await?, post_id, Some(person_id), None).await?;
let post_view = PostView::read(context.conn().await?, post_id, Some(person_id), None).await?;
Ok(Self::Response { post_view })
}

7
crates/api/src/post/save.rs
View file

@ -27,19 +27,18 @@ impl Perform for SavePost {
};
if data.save {
PostSaved::save(&mut *context.conn().await?, &post_saved_form)
PostSaved::save(context.conn().await?, &post_saved_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
} else {
PostSaved::unsave(&mut *context.conn().await?, &post_saved_form)
PostSaved::unsave(context.conn().await?, &post_saved_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_save_post"))?;
}
let post_id = data.post_id;
let person_id = local_user_view.person.id;
let post_view =
PostView::read(&mut *context.conn().await?, post_id, Some(person_id), None).await?;
let post_view = PostView::read(context.conn().await?, post_id, Some(person_id), None).await?;
// Mark the post as read
mark_post_as_read(person_id, post_id, &mut *context.conn().await?).await?;

8
crates/api/src/post_report/create.rs
View file

@ -24,14 +24,14 @@ impl Perform for CreatePostReport {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostReportResponse, LemmyError> {
let data: &CreatePostReport = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?;
let local_site = LocalSite::read(context.conn().await?).await?;
let reason = self.reason.trim();
check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.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(context.conn().await?, post_id, None, None).await?;
check_community_ban(
person_id,
@ -49,12 +49,12 @@ impl Perform for CreatePostReport {
reason: reason.to_owned(),
};
let report = PostReport::report(&mut *context.conn().await?, &report_form)
let report = PostReport::report(context.conn().await?, &report_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let post_report_view =
PostReportView::read(&mut *context.conn().await?, report.id, person_id).await?;
PostReportView::read(context.conn().await?, report.id, person_id).await?;
// Email the admins
if local_site.reports_email_admins {

2
crates/api/src/post_report/list.rs
View file

@ -31,7 +31,7 @@ impl Perform for ListPostReports {
let limit = data.limit;
let mut conn = context.conn().await?;
let post_reports = PostReportQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.my_person_id(person_id)
.admin(admin)
.community_id(community_id)

10
crates/api/src/post_report/resolve.rs
View file

@ -21,23 +21,23 @@ impl Perform for ResolvePostReport {
let report_id = data.report_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(context.conn().await?, report_id, person_id).await?;
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(context.conn().await?, person_id, report.community.id).await?;
if data.resolved {
PostReport::resolve(&mut *context.conn().await?, report_id, person_id)
PostReport::resolve(context.conn().await?, report_id, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} else {
PostReport::unresolve(&mut *context.conn().await?, report_id, person_id)
PostReport::unresolve(context.conn().await?, report_id, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
}
let post_report_view =
PostReportView::read(&mut *context.conn().await?, report_id, person_id).await?;
PostReportView::read(context.conn().await?, report_id, person_id).await?;
Ok(PostReportResponse { post_report_view })
}

4
crates/api/src/private_message/mark_read.rs
View file

@ -27,7 +27,7 @@ impl Perform for MarkPrivateMessageAsRead {
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message =
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
PrivateMessage::read(context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.recipient_id {
return Err(LemmyError::from_message("couldnt_update_private_message"));
}
@ -43,7 +43,7 @@ impl Perform for MarkPrivateMessageAsRead {
.await
.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(context.conn().await?, private_message_id).await?;
Ok(PrivateMessageResponse {
private_message_view: view,
})

9
crates/api/src/private_message_report/create.rs
View file

@ -23,15 +23,14 @@ impl Perform for CreatePrivateMessageReport {
#[tracing::instrument(skip(context))]
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
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(context.conn().await?).await?;
let reason = self.reason.trim();
check_report_reason(reason, &local_site)?;
let person_id = local_user_view.person.id;
let private_message_id = self.private_message_id;
let private_message =
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
let private_message = PrivateMessage::read(context.conn().await?, private_message_id).await?;
let report_form = PrivateMessageReportForm {
creator_id: person_id,
@ -40,12 +39,12 @@ impl Perform for CreatePrivateMessageReport {
reason: reason.to_owned(),
};
let report = PrivateMessageReport::report(&mut *context.conn().await?, &report_form)
let report = PrivateMessageReport::report(context.conn().await?, &report_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_report"))?;
let private_message_report_view =
PrivateMessageReportView::read(&mut *context.conn().await?, report.id).await?;
PrivateMessageReportView::read(context.conn().await?, report.id).await?;
// Email the admins
if local_site.reports_email_admins {

2
crates/api/src/private_message_report/list.rs
View file

@ -23,7 +23,7 @@ impl Perform for ListPrivateMessageReports {
let limit = self.limit;
let mut conn = context.conn().await?;
let private_message_reports = PrivateMessageReportQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.unresolved_only(unresolved_only)
.page(page)
.limit(limit)

6
crates/api/src/private_message_report/resolve.rs
View file

@ -22,17 +22,17 @@ impl Perform for ResolvePrivateMessageReport {
let report_id = self.report_id;
let person_id = local_user_view.person.id;
if self.resolved {
PrivateMessageReport::resolve(&mut *context.conn().await?, report_id, person_id)
PrivateMessageReport::resolve(context.conn().await?, report_id, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
} else {
PrivateMessageReport::unresolve(&mut *context.conn().await?, report_id, person_id)
PrivateMessageReport::unresolve(context.conn().await?, report_id, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_resolve_report"))?;
}
let private_message_report_view =
PrivateMessageReportView::read(&mut *context.conn().await?, report_id).await?;
PrivateMessageReportView::read(context.conn().await?, report_id).await?;
Ok(PrivateMessageReportResponse {
private_message_report_view,

2
crates/api/src/site/federated_instances.rs
View file

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

16
crates/api/src/site/leave_admin.rs
View file

@ -31,7 +31,7 @@ impl Perform for LeaveAdmin {
is_admin(&local_user_view)?;
// 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(context.conn().await?).await?;
if admins.len() == 1 {
return Err(LemmyError::from_message("cannot_leave_admin"));
}
@ -51,17 +51,17 @@ impl Perform for LeaveAdmin {
removed: Some(true),
};
ModAdd::create(&mut *context.conn().await?, &form).await?;
ModAdd::create(context.conn().await?, &form).await?;
// Reread site and admins
let site_view = SiteView::read_local(&mut *context.conn().await?).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?;
let site_view = SiteView::read_local(context.conn().await?).await?;
let admins = PersonView::admins(context.conn().await?).await?;
let all_languages = Language::read_all(&mut *context.conn().await?).await?;
let discussion_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?;
let taglines = Tagline::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
let all_languages = Language::read_all(context.conn().await?).await?;
let discussion_languages = SiteLanguage::read_local_raw(context.conn().await?).await?;
let taglines = Tagline::get_all(context.conn().await?, site_view.local_site.id).await?;
let custom_emojis =
CustomEmojiView::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
CustomEmojiView::get_all(context.conn().await?, site_view.local_site.id).await?;
Ok(GetSiteResponse {
site_view,

36
crates/api/src/site/mod_log.rs
View file

@ -40,7 +40,7 @@ impl Perform for GetModlog {
let data: &GetModlog = self;
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(context.conn().await?).await?;
check_private_instance(&local_user_view, &local_site)?;
@ -80,51 +80,47 @@ impl Perform for GetModlog {
hide_modlog_names,
};
let removed_posts = match type_ {
All | ModRemovePost => ModRemovePostView::list(&mut *context.conn().await?, params).await?,
All | ModRemovePost => ModRemovePostView::list(context.conn().await?, params).await?,
_ => Default::default(),
};
let locked_posts = match type_ {
All | ModLockPost => ModLockPostView::list(&mut *context.conn().await?, params).await?,
All | ModLockPost => ModLockPostView::list(context.conn().await?, params).await?,
_ => Default::default(),
};
let featured_posts = match type_ {
All | ModFeaturePost => ModFeaturePostView::list(&mut *context.conn().await?, params).await?,
All | ModFeaturePost => ModFeaturePostView::list(context.conn().await?, params).await?,
_ => Default::default(),
};
let removed_comments = match type_ {
All | ModRemoveComment => {
ModRemoveCommentView::list(&mut *context.conn().await?, params).await?
}
All | ModRemoveComment => ModRemoveCommentView::list(context.conn().await?, params).await?,
_ => Default::default(),
};
let banned_from_community = match type_ {
All | ModBanFromCommunity => {
ModBanFromCommunityView::list(&mut *context.conn().await?, params).await?
ModBanFromCommunityView::list(context.conn().await?, params).await?
}
_ => Default::default(),
};
let added_to_community = match type_ {
All | ModAddCommunity => {
ModAddCommunityView::list(&mut *context.conn().await?, params).await?
}
All | ModAddCommunity => ModAddCommunityView::list(context.conn().await?, params).await?,
_ => Default::default(),
};
let transferred_to_community = match type_ {
All | ModTransferCommunity => {
ModTransferCommunityView::list(&mut *context.conn().await?, params).await?
ModTransferCommunityView::list(context.conn().await?, params).await?
}
_ => Default::default(),
};
let hidden_communities = match type_ {
All | ModHideCommunity if other_person_id.is_none() => {
ModHideCommunityView::list(&mut *context.conn().await?, params).await?
ModHideCommunityView::list(context.conn().await?, params).await?
}
_ => Default::default(),
};
@ -141,40 +137,40 @@ impl Perform for GetModlog {
) = if data.community_id.is_none() {
(
match type_ {
All | ModBan => ModBanView::list(&mut *context.conn().await?, params).await?,
All | ModBan => ModBanView::list(context.conn().await?, params).await?,
_ => Default::default(),
},
match type_ {
All | ModAdd => ModAddView::list(&mut *context.conn().await?, params).await?,
All | ModAdd => ModAddView::list(context.conn().await?, params).await?,
_ => Default::default(),
},
match type_ {
All | ModRemoveCommunity if other_person_id.is_none() => {
ModRemoveCommunityView::list(&mut *context.conn().await?, params).await?
ModRemoveCommunityView::list(context.conn().await?, params).await?
}
_ => Default::default(),
},
match type_ {
All | AdminPurgePerson if other_person_id.is_none() => {
AdminPurgePersonView::list(&mut *context.conn().await?, params).await?
AdminPurgePersonView::list(context.conn().await?, params).await?
}
_ => Default::default(),
},
match type_ {
All | AdminPurgeCommunity if other_person_id.is_none() => {
AdminPurgeCommunityView::list(&mut *context.conn().await?, params).await?
AdminPurgeCommunityView::list(context.conn().await?, params).await?
}
_ => Default::default(),
},
match type_ {
All | AdminPurgePost if other_person_id.is_none() => {
AdminPurgePostView::list(&mut *context.conn().await?, params).await?
AdminPurgePostView::list(context.conn().await?, params).await?
}
_ => Default::default(),
},
match type_ {
All | AdminPurgeComment if other_person_id.is_none() => {
AdminPurgeCommentView::list(&mut *context.conn().await?, params).await?
AdminPurgeCommentView::list(context.conn().await?, params).await?
}
_ => Default::default(),
},

6
crates/api/src/site/purge/comment.rs
View file

@ -29,13 +29,13 @@ impl Perform for PurgeComment {
let comment_id = data.comment_id;
// Read the comment to get the post_id
let comment = Comment::read(&mut *context.conn().await?, comment_id).await?;
let comment = Comment::read(context.conn().await?, comment_id).await?;
let post_id = comment.post_id;
// TODO read comments for pictrs images and purge them
Comment::delete(&mut *context.conn().await?, comment_id).await?;
Comment::delete(context.conn().await?, comment_id).await?;
// Mod tables
let reason = data.reason.clone();
@ -45,7 +45,7 @@ impl Perform for PurgeComment {
post_id,
};
AdminPurgeComment::create(&mut *context.conn().await?, &form).await?;
AdminPurgeComment::create(context.conn().await?, &form).await?;
Ok(PurgeItemResponse { success: true })
}

6
crates/api/src/site/purge/community.rs
View file

@ -30,7 +30,7 @@ impl Perform for PurgeCommunity {
let community_id = data.community_id;
// Read the community to get its images
let community = Community::read(&mut *context.conn().await?, community_id).await?;
let community = Community::read(context.conn().await?, community_id).await?;
if let Some(banner) = community.banner {
purge_image_from_pictrs(context.client(), context.settings(), &banner)
@ -52,7 +52,7 @@ impl Perform for PurgeCommunity {
)
.await?;
Community::delete(&mut *context.conn().await?, community_id).await?;
Community::delete(context.conn().await?, community_id).await?;
// Mod tables
let reason = data.reason.clone();
@ -61,7 +61,7 @@ impl Perform for PurgeCommunity {
reason,
};
AdminPurgeCommunity::create(&mut *context.conn().await?, &form).await?;
AdminPurgeCommunity::create(context.conn().await?, &form).await?;
Ok(PurgeItemResponse { success: true })
}

6
crates/api/src/site/purge/person.rs
View file

@ -29,7 +29,7 @@ impl Perform for PurgePerson {
// Read the person to get their images
let person_id = data.person_id;
let person = Person::read(&mut *context.conn().await?, person_id).await?;
let person = Person::read(context.conn().await?, person_id).await?;
if let Some(banner) = person.banner {
purge_image_from_pictrs(context.client(), context.settings(), &banner)
@ -51,7 +51,7 @@ impl Perform for PurgePerson {
)
.await?;
Person::delete(&mut *context.conn().await?, person_id).await?;
Person::delete(context.conn().await?, person_id).await?;
// Mod tables
let reason = data.reason.clone();
@ -60,7 +60,7 @@ impl Perform for PurgePerson {
reason,
};
AdminPurgePerson::create(&mut *context.conn().await?, &form).await?;
AdminPurgePerson::create(context.conn().await?, &form).await?;
Ok(PurgeItemResponse { success: true })
}

6
crates/api/src/site/purge/post.rs
View file

@ -30,7 +30,7 @@ impl Perform for PurgePost {
let post_id = data.post_id;
// Read the post to get the community_id
let post = Post::read(&mut *context.conn().await?, post_id).await?;
let post = Post::read(context.conn().await?, post_id).await?;
// Purge image
if let Some(url) = post.url {
@ -47,7 +47,7 @@ impl Perform for PurgePost {
let community_id = post.community_id;
Post::delete(&mut *context.conn().await?, post_id).await?;
Post::delete(context.conn().await?, post_id).await?;
// Mod tables
let reason = data.reason.clone();
@ -57,7 +57,7 @@ impl Perform for PurgePost {
community_id,
};
AdminPurgePost::create(&mut *context.conn().await?, &form).await?;
AdminPurgePost::create(context.conn().await?, &form).await?;
Ok(PurgeItemResponse { success: true })
}

6
crates/api/src/site/registration_applications/approve.rs
View file

@ -37,7 +37,7 @@ impl Perform for ApproveRegistrationApplication {
};
let registration_application =
RegistrationApplication::update(&mut *context.conn().await?, app_id, &app_form).await?;
RegistrationApplication::update(context.conn().await?, app_id, &app_form).await?;
// Update the local_user row
let local_user_form = LocalUserUpdateForm::builder()
@ -54,7 +54,7 @@ impl Perform for ApproveRegistrationApplication {
if data.approve {
let approved_local_user_view =
LocalUserView::read(&mut *context.conn().await?, approved_user_id).await?;
LocalUserView::read(context.conn().await?, approved_user_id).await?;
if approved_local_user_view.local_user.email.is_some() {
send_application_approved_email(&approved_local_user_view, context.settings())?;
@ -63,7 +63,7 @@ impl Perform for ApproveRegistrationApplication {
// Read the view
let registration_application =
RegistrationApplicationView::read(&mut *context.conn().await?, app_id).await?;
RegistrationApplicationView::read(context.conn().await?, app_id).await?;
Ok(Self::Response {
registration_application,

4
crates/api/src/site/registration_applications/list.rs
View file

@ -17,7 +17,7 @@ impl Perform for ListRegistrationApplications {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let data = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?;
let local_site = LocalSite::read(context.conn().await?).await?;
// Make sure user is an admin
is_admin(&local_user_view)?;
@ -29,7 +29,7 @@ impl Perform for ListRegistrationApplications {
let limit = data.limit;
let mut conn = context.conn().await?;
let registration_applications = RegistrationApplicationQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.unread_only(unread_only)
.verified_email_only(Some(verified_email_only))
.page(page)

2
crates/api/src/site/registration_applications/unread_count.rs
View file

@ -16,7 +16,7 @@ impl Perform for GetUnreadRegistrationApplicationCount {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let data = self;
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let local_site = LocalSite::read(&mut *context.conn().await?).await?;
let local_site = LocalSite::read(context.conn().await?).await?;
// Only let admins do this
is_admin(&local_user_view)?;

22
crates/api_common/src/build_response.rs
View file

@ -30,7 +30,7 @@ pub async fn build_comment_response(
recipient_ids: Vec<LocalUserId>,
) -> Result<CommentResponse, LemmyError> {
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(context.conn().await?, comment_id, person_id).await?;
Ok(CommentResponse {
comment_view,
recipient_ids,
@ -58,8 +58,7 @@ pub async fn build_community_response(
Some(is_mod_or_admin),
)
.await?;
let discussion_languages =
CommunityLanguage::read(&mut *context.conn().await?, community_id).await?;
let discussion_languages = CommunityLanguage::read(context.conn().await?, community_id).await?;
Ok(CommunityResponse {
community_view,
@ -73,7 +72,7 @@ pub async fn build_post_response(
person_id: PersonId,
post_id: PostId,
) -> Result<PostResponse, LemmyError> {
let is_mod_or_admin = is_mod_or_admin(&mut *context.conn().await?, person_id, community_id)
let is_mod_or_admin = is_mod_or_admin(context.conn().await?, person_id, community_id)
.await
.is_ok();
let post_view = PostView::read(
@ -105,7 +104,7 @@ pub async fn send_local_notifs(
.filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name))
{
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(context.conn().await?, &mention_name).await;
if let Ok(mention_user_view) = user_view {
// TODO
// At some point, make it so you can't tag the parent creator either
@ -120,7 +119,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail
PersonMention::create(&mut *context.conn().await?, &user_mention_form)
PersonMention::create(context.conn().await?, &user_mention_form)
.await
.ok();
@ -139,7 +138,7 @@ pub async fn send_local_notifs(
// Send comment_reply to the parent commenter / poster
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(context.conn().await?, parent_comment_id).await?;
// Get the parent commenter local_user
let parent_creator_id = parent_comment.creator_id;
@ -152,8 +151,7 @@ pub async fn send_local_notifs(
// Don't send a notif to yourself
if parent_comment.creator_id != person.id && !creator_blocked {
let user_view =
LocalUserView::read_person(&mut *context.conn().await?, parent_creator_id).await;
let user_view = LocalUserView::read_person(context.conn().await?, parent_creator_id).await;
if let Ok(parent_user_view) = user_view {
recipient_ids.push(parent_user_view.local_user.id);
@ -165,7 +163,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail
CommentReply::create(&mut *context.conn().await?, &comment_reply_form)
CommentReply::create(context.conn().await?, &comment_reply_form)
.await
.ok();
@ -190,7 +188,7 @@ pub async fn send_local_notifs(
if post.creator_id != person.id && !creator_blocked {
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(context.conn().await?, creator_id).await;
if let Ok(parent_user_view) = parent_user {
recipient_ids.push(parent_user_view.local_user.id);
@ -202,7 +200,7 @@ pub async fn send_local_notifs(
// Allow this to fail softly, since comment edits might re-update or replace it
// Let the uniqueness handle this fail
CommentReply::create(&mut *context.conn().await?, &comment_reply_form)
CommentReply::create(context.conn().await?, &comment_reply_form)
.await
.ok();

114
crates/api_common/src/utils.rs
View file

@ -50,11 +50,11 @@ use url::{ParseError, Url};
#[tracing::instrument(skip_all)]
pub async fn is_mod_or_admin(
conn: &mut DbConn,
mut conn: impl DbConn,
person_id: PersonId,
community_id: CommunityId,
) -> Result<(), LemmyError> {
let is_mod_or_admin = CommunityView::is_mod_or_admin(conn, person_id, community_id).await?;
let is_mod_or_admin = CommunityView::is_mod_or_admin(&mut *conn, person_id, community_id).await?;
if !is_mod_or_admin {
return Err(LemmyError::from_message("not_a_mod_or_admin"));
}
@ -63,13 +63,13 @@ pub async fn is_mod_or_admin(
#[tracing::instrument(skip_all)]
pub async fn is_mod_or_admin_opt(
conn: &mut DbConn,
mut conn: impl DbConn,
local_user_view: Option<&LocalUserView>,
community_id: Option<CommunityId>,
) -> Result<(), LemmyError> {
if let Some(local_user_view) = local_user_view {
if let Some(community_id) = community_id {
is_mod_or_admin(conn, local_user_view.person.id, community_id).await
is_mod_or_admin(&mut *conn, local_user_view.person.id, community_id).await
} else {
is_admin(local_user_view)
}
@ -101,8 +101,8 @@ pub fn is_top_mod(
}
#[tracing::instrument(skip_all)]
pub async fn get_post(post_id: PostId, conn: &mut DbConn) -> Result<Post, LemmyError> {
Post::read(conn, post_id)
pub async fn get_post(post_id: PostId, mut conn: impl DbConn) -> Result<Post, LemmyError> {
Post::read(&mut *conn, post_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))
}
@ -111,11 +111,11 @@ pub async fn get_post(post_id: PostId, conn: &mut DbConn) -> Result<Post, LemmyE
pub async fn mark_post_as_read(
person_id: PersonId,
post_id: PostId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<PostRead, LemmyError> {
let post_read_form = PostReadForm { post_id, person_id };
PostRead::mark_as_read(conn, &post_read_form)
PostRead::mark_as_read(&mut *conn, &post_read_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
}
@ -124,11 +124,11 @@ pub async fn mark_post_as_read(
pub async fn mark_post_as_unread(
person_id: PersonId,
post_id: PostId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<usize, LemmyError> {
let post_read_form = PostReadForm { post_id, person_id };
PostRead::mark_as_unread(conn, &post_read_form)
PostRead::mark_as_unread(&mut *conn, &post_read_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
}
@ -142,7 +142,7 @@ pub async fn local_user_view_from_jwt(
.map_err(|e| e.with_message("not_logged_in"))?
.claims;
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(context.conn().await?, local_user_id).await?;
check_user_valid(
local_user_view.person.banned,
local_user_view.person.ban_expires,
@ -197,9 +197,9 @@ pub fn check_user_valid(
pub async fn check_community_ban(
person_id: PersonId,
community_id: CommunityId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<(), LemmyError> {
let is_banned = CommunityPersonBanView::get(conn, person_id, community_id)
let is_banned = CommunityPersonBanView::get(&mut *conn, person_id, community_id)
.await
.is_ok();
if is_banned {
@ -212,9 +212,9 @@ pub async fn check_community_ban(
#[tracing::instrument(skip_all)]
pub async fn check_community_deleted_or_removed(
community_id: CommunityId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<(), LemmyError> {
let community = Community::read(conn, community_id)
let community = Community::read(&mut *conn, community_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
if community.deleted || community.removed {
@ -236,9 +236,9 @@ pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> {
pub async fn check_person_block(
my_id: PersonId,
potential_blocker_id: PersonId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<(), LemmyError> {
let is_blocked = PersonBlock::read(conn, potential_blocker_id, my_id)
let is_blocked = PersonBlock::read(&mut *conn, potential_blocker_id, my_id)
.await
.is_ok();
if is_blocked {
@ -279,9 +279,9 @@ pub async fn build_federated_instances(
if local_site.federation_enabled {
// TODO I hate that this requires 3 queries
let (linked, allowed, blocked) = try_join!(
Instance::linked(conn_0),
Instance::allowlist(conn_1),
Instance::blocklist(conn_2)
Instance::linked(&mut *conn_0),
Instance::allowlist(&mut *conn_1),
Instance::blocklist(&mut *conn_2)
)?;
Ok(Some(FederatedInstances {
@ -338,7 +338,7 @@ pub fn send_email_to_user(
pub async fn send_password_reset_email(
user: &LocalUserView,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
) -> Result<(), LemmyError> {
// Generate a random token
@ -347,7 +347,7 @@ pub async fn send_password_reset_email(
// Insert the row
let token2 = token.clone();
let local_user_id = user.local_user.id;
PasswordResetRequest::create_token(conn, local_user_id, &token2).await?;
PasswordResetRequest::create_token(&mut *conn, local_user_id, &token2).await?;
let email = &user.local_user.email.clone().expect("email");
let lang = get_interface_language(user);
@ -362,7 +362,7 @@ pub async fn send_password_reset_email(
pub async fn send_verification_email(
user: &LocalUserView,
new_email: &str,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
) -> Result<(), LemmyError> {
let form = EmailVerificationForm {
@ -375,7 +375,7 @@ pub async fn send_verification_email(
settings.get_protocol_and_hostname(),
&form.verification_token
);
EmailVerification::create(conn, &form).await?;
EmailVerification::create(&mut *conn, &form).await?;
let lang = get_interface_language(user);
let subject = lang.verify_email_subject(&settings.hostname);
@ -453,11 +453,11 @@ pub fn send_application_approved_email(
/// Send a new applicant email notification to all admins
pub async fn send_new_applicant_email_to_admins(
applicant_username: &str,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
) -> Result<(), LemmyError> {
// Collect the admins with emails
let admins = LocalUserView::list_admins_with_emails(conn).await?;
let admins = LocalUserView::list_admins_with_emails(&mut *conn).await?;
let applications_link = &format!(
"{}/registration_applications",
@ -478,11 +478,11 @@ pub async fn send_new_applicant_email_to_admins(
pub async fn send_new_report_email_to_admins(
reporter_username: &str,
reported_username: &str,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
) -> Result<(), LemmyError> {
// Collect the admins with emails
let admins = LocalUserView::list_admins_with_emails(conn).await?;
let admins = LocalUserView::list_admins_with_emails(&mut *conn).await?;
let reports_link = &format!("{}/reports", settings.get_protocol_and_hostname(),);
@ -499,7 +499,7 @@ pub async fn send_new_report_email_to_admins(
pub async fn check_registration_application(
local_user_view: &LocalUserView,
local_site: &LocalSite,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<(), LemmyError> {
if (local_site.registration_mode == RegistrationMode::RequireApplication
|| local_site.registration_mode == RegistrationMode::Closed)
@ -508,7 +508,8 @@ pub async fn check_registration_application(
{
// Fetch the registration, see if its denied
let local_user_id = local_user_view.local_user.id;
let registration = RegistrationApplication::find_by_local_user_id(conn, local_user_id).await?;
let registration =
RegistrationApplication::find_by_local_user_id(&mut *conn, local_user_id).await?;
if let Some(deny_reason) = registration.deny_reason {
let lang = get_interface_language(local_user_view);
let registration_denied_message = format!("{}: {}", lang.registration_denied(), &deny_reason);
@ -533,11 +534,11 @@ pub fn check_private_instance_and_federation_enabled(
pub async fn purge_image_posts_for_person(
banned_person_id: PersonId,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
let posts = Post::fetch_pictrs_posts_for_creator(conn, banned_person_id).await?;
let posts = Post::fetch_pictrs_posts_for_creator(&mut *conn, banned_person_id).await?;
for post in posts {
if let Some(url) = post.url {
purge_image_from_pictrs(client, settings, &url).await.ok();
@ -549,18 +550,18 @@ pub async fn purge_image_posts_for_person(
}
}
Post::remove_pictrs_post_images_and_thumbnails_for_creator(conn, banned_person_id).await?;
Post::remove_pictrs_post_images_and_thumbnails_for_creator(&mut *conn, banned_person_id).await?;
Ok(())
}
pub async fn purge_image_posts_for_community(
banned_community_id: CommunityId,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
let posts = Post::fetch_pictrs_posts_for_community(conn, banned_community_id).await?;
let posts = Post::fetch_pictrs_posts_for_community(&mut *conn, banned_community_id).await?;
for post in posts {
if let Some(url) = post.url {
purge_image_from_pictrs(client, settings, &url).await.ok();
@ -572,19 +573,20 @@ pub async fn purge_image_posts_for_community(
}
}
Post::remove_pictrs_post_images_and_thumbnails_for_community(conn, banned_community_id).await?;
Post::remove_pictrs_post_images_and_thumbnails_for_community(&mut *conn, banned_community_id)
.await?;
Ok(())
}
pub async fn remove_user_data(
banned_person_id: PersonId,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
// Purge user images
let person = Person::read(conn, banned_person_id).await?;
let person = Person::read(&mut *conn, banned_person_id).await?;
if let Some(avatar) = person.avatar {
purge_image_from_pictrs(client, settings, &avatar)
.await
@ -598,7 +600,7 @@ pub async fn remove_user_data(
// Update the fields to None
Person::update(
conn,
&mut *conn,
banned_person_id,
&PersonUpdateForm::builder()
.avatar(Some(None))
@ -608,15 +610,15 @@ pub async fn remove_user_data(
.await?;
// Posts
Post::update_removed_for_creator(conn, banned_person_id, None, true).await?;
Post::update_removed_for_creator(&mut *conn, banned_person_id, None, true).await?;
// Purge image posts
purge_image_posts_for_person(banned_person_id, conn, settings, client).await?;
purge_image_posts_for_person(banned_person_id, &mut *conn, settings, client).await?;
// Communities
// Remove all communities where they're the top mod
// for now, remove the communities manually
let first_mod_communities = CommunityModeratorView::get_community_first_mods(conn).await?;
let first_mod_communities = CommunityModeratorView::get_community_first_mods(&mut *conn).await?;
// Filter to only this banned users top communities
let banned_user_first_communities: Vec<CommunityModeratorView> = first_mod_communities
@ -627,7 +629,7 @@ pub async fn remove_user_data(
for first_mod_community in banned_user_first_communities {
let community_id = first_mod_community.community.id;
Community::update(
conn,
&mut *conn,
community_id,
&CommunityUpdateForm::builder().removed(Some(true)).build(),
)
@ -644,7 +646,7 @@ pub async fn remove_user_data(
}
// Update the fields to None
Community::update(
conn,
&mut *conn,
community_id,
&CommunityUpdateForm::builder()
.icon(Some(None))
@ -655,7 +657,7 @@ pub async fn remove_user_data(
}
// Comments
Comment::update_removed_for_creator(conn, banned_person_id, true).await?;
Comment::update_removed_for_creator(&mut *conn, banned_person_id, true).await?;
Ok(())
}
@ -663,15 +665,15 @@ pub async fn remove_user_data(
pub async fn remove_user_data_in_community(
community_id: CommunityId,
banned_person_id: PersonId,
conn: &mut DbConn,
mut conn: impl DbConn,
) -> Result<(), LemmyError> {
// Posts
Post::update_removed_for_creator(conn, banned_person_id, Some(community_id), true).await?;
Post::update_removed_for_creator(&mut *conn, banned_person_id, Some(community_id), true).await?;
// Comments
// TODO Diesel doesn't allow updates with joins, so this has to be a loop
let comments = CommentQuery::builder()
.conn(conn)
.conn(&mut *conn)
.creator_id(Some(banned_person_id))
.community_id(Some(community_id))
.limit(Some(i64::MAX))
@ -682,7 +684,7 @@ pub async fn remove_user_data_in_community(
for comment_view in &comments {
let comment_id = comment_view.comment.id;
Comment::update(
conn,
&mut *conn,
comment_id,
&CommentUpdateForm::builder().removed(Some(true)).build(),
)
@ -694,12 +696,12 @@ pub async fn remove_user_data_in_community(
pub async fn delete_user_account(
person_id: PersonId,
conn: &mut DbConn,
mut conn: impl DbConn,
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
// Delete their images
let person = Person::read(conn, person_id).await?;
let person = Person::read(&mut *conn, person_id).await?;
if let Some(avatar) = person.avatar {
purge_image_from_pictrs(client, settings, &avatar)
.await
@ -713,22 +715,22 @@ pub async fn delete_user_account(
// No need to update avatar and banner, those are handled in Person::delete_account
// Comments
Comment::permadelete_for_creator(conn, person_id)
Comment::permadelete_for_creator(&mut *conn, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Posts
Post::permadelete_for_creator(conn, person_id)
Post::permadelete_for_creator(&mut *conn, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?;
// Purge image posts
purge_image_posts_for_person(person_id, conn, settings, client).await?;
purge_image_posts_for_person(person_id, &mut *conn, settings, client).await?;
// Leave communities they mod
CommunityModerator::leave_all_communities(conn, person_id).await?;
CommunityModerator::leave_all_communities(&mut *conn, person_id).await?;
Person::delete_account(conn, person_id).await?;
Person::delete_account(&mut *conn, person_id).await?;
Ok(())
}

11
crates/api_crud/src/comment/create.rs
View file

@ -43,7 +43,7 @@ impl PerformCrud for CreateComment {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let data: &CreateComment = self;
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(context.conn().await?).await?;
let content_slurs_removed = remove_slurs(
&data.content.clone(),
@ -72,9 +72,7 @@ impl PerformCrud for CreateComment {
// Fetch the parent, if it exists
let parent_opt = if let Some(parent_id) = data.parent_id {
Comment::read(&mut *context.conn().await?, parent_id)
.await
.ok()
Comment::read(context.conn().await?, parent_id).await.ok()
} else {
None
};
@ -156,15 +154,14 @@ impl PerformCrud for CreateComment {
score: 1,
};
CommentLike::like(&mut *context.conn().await?, &like_form)
CommentLike::like(context.conn().await?, &like_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_comment"))?;
// If its a reply, mark the parent as read
if let Some(parent) = parent_opt {
let parent_id = parent.id;
let comment_reply =
CommentReply::read_by_comment(&mut *context.conn().await?, parent_id).await;
let comment_reply = CommentReply::read_by_comment(context.conn().await?, parent_id).await;
if let Ok(reply) = comment_reply {
CommentReply::update(
&mut *context.conn().await?,

4
crates/api_crud/src/comment/delete.rs
View file

@ -26,7 +26,7 @@ impl PerformCrud for DeleteComment {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?;
let orig_comment = CommentView::read(context.conn().await?, comment_id, None).await?;
// Dont delete it if its already been deleted.
if orig_comment.comment.deleted == data.deleted {
@ -56,7 +56,7 @@ impl PerformCrud for DeleteComment {
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
let post_id = updated_comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?;
let post = Post::read(context.conn().await?, post_id).await?;
let recipient_ids = send_local_notifs(
vec![],
&updated_comment,

2
crates/api_crud/src/comment/read.rs
View file

@ -17,7 +17,7 @@ impl PerformCrud for GetComment {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<Self::Response, LemmyError> {
let data = self;
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(context.conn().await?).await?;
check_private_instance(&local_user_view, &local_site)?;

6
crates/api_crud/src/comment/remove.rs
View file

@ -27,7 +27,7 @@ impl PerformCrud for RemoveComment {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?;
let orig_comment = CommentView::read(context.conn().await?, comment_id, None).await?;
check_community_ban(
local_user_view.person.id,
@ -61,10 +61,10 @@ impl PerformCrud for RemoveComment {
removed: Some(removed),
reason: data.reason.clone(),
};
ModRemoveComment::create(&mut *context.conn().await?, &form).await?;
ModRemoveComment::create(context.conn().await?, &form).await?;
let post_id = updated_comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?;
let post = Post::read(context.conn().await?, post_id).await?;
let recipient_ids = send_local_notifs(
vec![],
&updated_comment,

6
crates/api_crud/src/comment/update.rs
View file

@ -33,10 +33,10 @@ impl PerformCrud for EditComment {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
let data: &EditComment = self;
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(context.conn().await?).await?;
let comment_id = data.comment_id;
let orig_comment = CommentView::read(&mut *context.conn().await?, comment_id, None).await?;
let orig_comment = CommentView::read(context.conn().await?, comment_id, None).await?;
check_community_ban(
local_user_view.person.id,
@ -72,7 +72,7 @@ impl PerformCrud for EditComment {
.language_id(data.language_id)
.updated(Some(Some(naive_now())))
.build();
let updated_comment = Comment::update(&mut *context.conn().await?, comment_id, &form)
let updated_comment = Comment::update(context.conn().await?, comment_id, &form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;

14
crates/api_crud/src/community/create.rs
View file

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

2
crates/api_crud/src/community/delete.rs
View file

@ -25,7 +25,7 @@ impl PerformCrud for DeleteCommunity {
// Fetch the community mods
let community_id = data.community_id;
let community_mods =
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
CommunityModeratorView::for_community(context.conn().await?, community_id).await?;
// Make sure deleter is the top mod
is_top_mod(&local_user_view, &community_mods)?;

4
crates/api_crud/src/community/list.rs
View file

@ -20,7 +20,7 @@ impl PerformCrud for ListCommunities {
) -> Result<ListCommunitiesResponse, LemmyError> {
let data: &ListCommunities = self;
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(context.conn().await?).await?;
let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
check_private_instance(&local_user_view, &local_site)?;
@ -33,7 +33,7 @@ impl PerformCrud for ListCommunities {
let local_user = local_user_view.map(|l| l.local_user);
let mut conn = context.conn().await?;
let communities = CommunityQuery::builder()
.conn(&mut conn)
.conn(&mut *conn)
.listing_type(listing_type)
.show_nsfw(show_nsfw)
.sort(sort)

2
crates/api_crud/src/community/remove.rs
View file

@ -49,7 +49,7 @@ impl PerformCrud for RemoveCommunity {
reason: data.reason.clone(),
expires,
};
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?;
ModRemoveCommunity::create(context.conn().await?, &form).await?;
build_community_response(context, local_user_view, community_id).await
}

10
crates/api_crud/src/community/update.rs
View file

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

8
crates/api_crud/src/custom_emoji/create.rs
View file

@ -22,7 +22,7 @@ impl PerformCrud for CreateCustomEmoji {
let data: &CreateCustomEmoji = self;
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(context.conn().await?).await?;
// Make sure user is an admin
is_admin(&local_user_view)?;
@ -33,7 +33,7 @@ impl PerformCrud for CreateCustomEmoji {
.category(data.category.to_string())
.image_url(data.clone().image_url.into())
.build();
let emoji = CustomEmoji::create(&mut *context.conn().await?, &emoji_form).await?;
let emoji = CustomEmoji::create(context.conn().await?, &emoji_form).await?;
let mut keywords = vec![];
for keyword in &data.keywords {
let keyword_form = CustomEmojiKeywordInsertForm::builder()
@ -42,8 +42,8 @@ impl PerformCrud for CreateCustomEmoji {
.build();
keywords.push(keyword_form);
}
CustomEmojiKeyword::create(&mut *context.conn().await?, keywords).await?;
let view = CustomEmojiView::get(&mut *context.conn().await?, emoji.id).await?;
CustomEmojiKeyword::create(context.conn().await?, keywords).await?;
let view = CustomEmojiView::get(context.conn().await?, emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view })
}
}

2
crates/api_crud/src/custom_emoji/delete.rs
View file

@ -22,7 +22,7 @@ impl PerformCrud for DeleteCustomEmoji {
// Make sure user is an admin
is_admin(&local_user_view)?;
CustomEmoji::delete(&mut *context.conn().await?, data.id).await?;
CustomEmoji::delete(context.conn().await?, data.id).await?;
Ok(DeleteCustomEmojiResponse {
id: data.id,
success: true,

10
crates/api_crud/src/custom_emoji/update.rs
View file

@ -22,7 +22,7 @@ impl PerformCrud for EditCustomEmoji {
let data: &EditCustomEmoji = self;
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(context.conn().await?).await?;
// Make sure user is an admin
is_admin(&local_user_view)?;
@ -32,8 +32,8 @@ impl PerformCrud for EditCustomEmoji {
.category(data.category.to_string())
.image_url(data.clone().image_url.into())
.build();
let emoji = CustomEmoji::update(&mut *context.conn().await?, data.id, &emoji_form).await?;
CustomEmojiKeyword::delete(&mut *context.conn().await?, data.id).await?;
let emoji = CustomEmoji::update(context.conn().await?, data.id, &emoji_form).await?;
CustomEmojiKeyword::delete(context.conn().await?, data.id).await?;
let mut keywords = vec![];
for keyword in &data.keywords {
let keyword_form = CustomEmojiKeywordInsertForm::builder()
@ -42,8 +42,8 @@ impl PerformCrud for EditCustomEmoji {
.build();
keywords.push(keyword_form);
}
CustomEmojiKeyword::create(&mut *context.conn().await?, keywords).await?;
let view = CustomEmojiView::get(&mut *context.conn().await?, emoji.id).await?;
CustomEmojiKeyword::create(context.conn().await?, keywords).await?;
let view = CustomEmojiView::get(context.conn().await?, emoji.id).await?;
Ok(CustomEmojiResponse { custom_emoji: view })
}
}

8
crates/api_crud/src/post/create.rs
View file

@ -46,7 +46,7 @@ impl PerformCrud for CreatePost {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &CreatePost = self;
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(context.conn().await?).await?;
let slur_regex = local_site_to_slur_regex(&local_site);
check_slurs(&data.name, &slur_regex)?;
@ -68,7 +68,7 @@ impl PerformCrud for CreatePost {
check_community_deleted_or_removed(data.community_id, &mut *context.conn().await?).await?;
let community_id = data.community_id;
let community = Community::read(&mut *context.conn().await?, community_id).await?;
let community = Community::read(context.conn().await?, community_id).await?;
if community.posting_restricted_to_mods {
let community_id = data.community_id;
let is_mod = CommunityView::is_mod_or_admin(
@ -121,7 +121,7 @@ impl PerformCrud for CreatePost {
.thumbnail_url(thumbnail_url)
.build();
let inserted_post = match Post::create(&mut *context.conn().await?, &post_form).await {
let inserted_post = match Post::create(context.conn().await?, &post_form).await {
Ok(post) => post,
Err(e) => {
let err_type = if e.to_string() == "value too long for type character varying(200)" {
@ -158,7 +158,7 @@ impl PerformCrud for CreatePost {
score: 1,
};
PostLike::like(&mut *context.conn().await?, &like_form)
PostLike::like(context.conn().await?, &like_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_like_post"))?;

2
crates/api_crud/src/post/delete.rs
View file

@ -22,7 +22,7 @@ impl PerformCrud for DeletePost {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?;
let orig_post = Post::read(context.conn().await?, post_id).await?;
// Dont delete it if its already been deleted.
if orig_post.deleted == data.deleted {

12
crates/api_crud/src/post/read.rs
View file

@ -27,7 +27,7 @@ impl PerformCrud for GetPost {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetPostResponse, LemmyError> {
let data: &GetPost = self;
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(context.conn().await?).await?;
check_private_instance(&local_user_view, &local_site)?;
@ -37,7 +37,7 @@ impl PerformCrud for GetPost {
let post_id = if let Some(id) = data.id {
id
} else if let Some(comment_id) = data.comment_id {
Comment::read(&mut *context.conn().await?, comment_id)
Comment::read(context.conn().await?, comment_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?
.post_id
@ -46,7 +46,7 @@ impl PerformCrud for GetPost {
};
// 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(context.conn().await?, post_id)
.await?
.community_id;
let is_mod_or_admin = is_mod_or_admin_opt(
@ -92,18 +92,18 @@ impl PerformCrud for GetPost {
read_comments,
..PersonPostAggregatesForm::default()
};
PersonPostAggregates::upsert(&mut *context.conn().await?, &person_post_agg_form)
PersonPostAggregates::upsert(context.conn().await?, &person_post_agg_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))?;
}
let moderators =
CommunityModeratorView::for_community(&mut *context.conn().await?, community_id).await?;
CommunityModeratorView::for_community(context.conn().await?, community_id).await?;
// Fetch the cross_posts
let cross_posts = if let Some(url) = &post_view.post.url {
let mut x_posts = PostQuery::builder()
.conn(&mut *context.conn().await?)
.conn(context.conn().await?)
.url_search(Some(url.inner().as_str().into()))
.build()
.list()

4
crates/api_crud/src/post/remove.rs
View file

@ -25,7 +25,7 @@ impl PerformCrud for RemovePost {
let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?;
let orig_post = Post::read(context.conn().await?, post_id).await?;
check_community_ban(
local_user_view.person.id,
@ -59,7 +59,7 @@ impl PerformCrud for RemovePost {
removed: Some(removed),
reason: data.reason.clone(),
};
ModRemovePost::create(&mut *context.conn().await?, &form).await?;
ModRemovePost::create(context.conn().await?, &form).await?;
build_post_response(
context,

6
crates/api_crud/src/post/update.rs
View file

@ -32,7 +32,7 @@ impl PerformCrud for EditPost {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
let data: &EditPost = self;
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(context.conn().await?).await?;
let data_url = data.url.as_ref();
@ -52,7 +52,7 @@ impl PerformCrud for EditPost {
is_valid_body_field(&data.body, true)?;
let post_id = data.post_id;
let orig_post = Post::read(&mut *context.conn().await?, post_id).await?;
let orig_post = Post::read(context.conn().await?, post_id).await?;
check_community_ban(
local_user_view.person.id,
@ -96,7 +96,7 @@ impl PerformCrud for EditPost {
.build();
let post_id = data.post_id;
let res = Post::update(&mut *context.conn().await?, post_id, &post_form).await;
let res = Post::update(context.conn().await?, post_id, &post_form).await;
if let Err(e) = res {
let err_type = if e.to_string() == "value too long for type character varying(200)" {
"post_title_too_long"

10
crates/api_crud/src/private_message/create.rs
View file

@ -37,7 +37,7 @@ impl PerformCrud for CreatePrivateMessage {
) -> Result<PrivateMessageResponse, LemmyError> {
let data: &CreatePrivateMessage = self;
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(context.conn().await?).await?;
let content_slurs_removed = remove_slurs(
&data.content.clone(),
@ -59,7 +59,7 @@ impl PerformCrud for CreatePrivateMessage {
.build();
let inserted_private_message =
match PrivateMessage::create(&mut *context.conn().await?, &private_message_form).await {
match PrivateMessage::create(context.conn().await?, &private_message_form).await {
Ok(private_message) => private_message,
Err(e) => {
return Err(LemmyError::from_error_message(
@ -86,14 +86,12 @@ impl PerformCrud for CreatePrivateMessage {
.await
.map_err(|e| LemmyError::from_error_message(e, "couldnt_create_private_message"))?;
let view =
PrivateMessageView::read(&mut *context.conn().await?, inserted_private_message.id).await?;
let view = PrivateMessageView::read(context.conn().await?, inserted_private_message.id).await?;
// Send email to the local recipient, if one exists
if view.recipient.local {
let recipient_id = data.recipient_id;
let local_recipient =
LocalUserView::read_person(&mut *context.conn().await?, recipient_id).await?;
let local_recipient = LocalUserView::read_person(context.conn().await?, recipient_id).await?;
let lang = get_interface_language(&local_recipient);
let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
let sender_name = &local_user_view.person.name;

4
crates/api_crud/src/private_message/delete.rs
View file

@ -27,7 +27,7 @@ impl PerformCrud for DeletePrivateMessage {
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message =
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
PrivateMessage::read(context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyError::from_message("no_private_message_edit_allowed"));
}
@ -45,7 +45,7 @@ impl PerformCrud for DeletePrivateMessage {
.await
.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(context.conn().await?, private_message_id).await?;
Ok(PrivateMessageResponse {
private_message_view: view,
})

2
crates/api_crud/src/private_message/read.rs
View file

@ -25,7 +25,7 @@ impl PerformCrud for GetPrivateMessages {
let limit = data.limit;
let unread_only = data.unread_only;
let mut messages = PrivateMessageQuery::builder()
.conn(&mut *context.conn().await?)
.conn(context.conn().await?)
.recipient_id(person_id)
.page(page)
.limit(limit)

6
crates/api_crud/src/private_message/update.rs
View file

@ -30,12 +30,12 @@ impl PerformCrud for EditPrivateMessage {
) -> Result<PrivateMessageResponse, LemmyError> {
let data: &EditPrivateMessage = self;
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(context.conn().await?).await?;
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message =
PrivateMessage::read(&mut *context.conn().await?, private_message_id).await?;
PrivateMessage::read(context.conn().await?, private_message_id).await?;
if local_user_view.person.id != orig_private_message.creator_id {
return Err(LemmyError::from_message("no_private_message_edit_allowed"));
}
@ -56,7 +56,7 @@ impl PerformCrud for EditPrivateMessage {
.await
.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(context.conn().await?, private_message_id).await?;
Ok(PrivateMessageResponse {
private_message_view: view,

13
crates/api_crud/src/site/create.rs
View file

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

29
crates/api_crud/src/site/read.rs
View file

@ -32,9 +32,9 @@ impl PerformCrud for GetSite {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> {
let data: &GetSite = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?;
let site_view = SiteView::read_local(context.conn().await?).await?;
let admins = PersonView::admins(&mut *context.conn().await?).await?;
let admins = PersonView::admins(context.conn().await?).await?;
// Build the local user
let my_user = if let Some(local_user_view) =
@ -43,28 +43,27 @@ impl PerformCrud for GetSite {
let person_id = local_user_view.person.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(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
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(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
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(context.conn().await?, person_id)
.await
.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(context.conn().await?, person_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let discussion_languages =
LocalUserLanguage::read(&mut *context.conn().await?, local_user_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
let discussion_languages = LocalUserLanguage::read(context.conn().await?, local_user_id)
.await
.map_err(|e| LemmyError::from_error_message(e, "system_err_login"))?;
Some(MyUserInfo {
local_user_view,
@ -78,11 +77,11 @@ impl PerformCrud for GetSite {
None
};
let all_languages = Language::read_all(&mut *context.conn().await?).await?;
let discussion_languages = SiteLanguage::read_local_raw(&mut *context.conn().await?).await?;
let taglines = Tagline::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
let all_languages = Language::read_all(context.conn().await?).await?;
let discussion_languages = SiteLanguage::read_local_raw(context.conn().await?).await?;
let taglines = Tagline::get_all(context.conn().await?, site_view.local_site.id).await?;
let custom_emojis =
CustomEmojiView::get_all(&mut *context.conn().await?, site_view.local_site.id).await?;
CustomEmojiView::get_all(context.conn().await?, site_view.local_site.id).await?;
Ok(GetSiteResponse {
site_view,
@ -108,7 +107,7 @@ async fn local_user_settings_view_from_jwt_opt(
.ok()?
.claims;
let local_user_id = LocalUserId(claims.sub);
let local_user_view = LocalUserView::read(&mut *context.conn().await.ok()?, local_user_id)
let local_user_view = LocalUserView::read(context.conn().await.ok()?, local_user_id)
.await
.ok()?;
check_user_valid(

21
crates/api_crud/src/site/update.rs
View file

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

11
crates/api_crud/src/user/create.rs
View file

@ -45,7 +45,7 @@ impl PerformCrud for Register {
async fn perform(&self, context: &Data<LemmyContext>) -> Result<LoginResponse, LemmyError> {
let data: &Register = self;
let site_view = SiteView::read_local(&mut *context.conn().await?).await?;
let site_view = SiteView::read_local(context.conn().await?).await?;
let local_site = site_view.local_site;
let require_registration_application =
local_site.registration_mode == RegistrationMode::RequireApplication;
@ -104,7 +104,7 @@ impl PerformCrud for Register {
)?;
if let Some(email) = &data.email {
if LocalUser::is_email_taken(&mut *context.conn().await?, email).await? {
if LocalUser::is_email_taken(context.conn().await?, email).await? {
return Err(LemmyError::from_message("email_already_exists"));
}
}
@ -125,7 +125,7 @@ impl PerformCrud for Register {
.build();
// insert the person
let inserted_person = Person::create(&mut *context.conn().await?, &person_form)
let inserted_person = Person::create(context.conn().await?, &person_form)
.await
.map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?;
@ -142,8 +142,7 @@ impl PerformCrud for Register {
.accepted_application(accepted_application)
.build();
let inserted_local_user =
LocalUser::create(&mut *context.conn().await?, &local_user_form).await?;
let inserted_local_user = LocalUser::create(context.conn().await?, &local_user_form).await?;
if local_site.site_setup && require_registration_application {
// Create the registration application
@ -153,7 +152,7 @@ impl PerformCrud for Register {
answer: data.answer.clone().expect("must have an answer"),
};
RegistrationApplication::create(&mut *context.conn().await?, &form).await?;
RegistrationApplication::create(context.conn().await?, &form).await?;
}
// Email the admins

10
crates/apub/src/activities/block/block_user.rs
View file

@ -97,7 +97,7 @@ impl BlockUser {
match target {
SiteOrCommunity::Site(_) => {
let inboxes = remote_instance_inboxes(&mut *context.conn().await?).await?;
let inboxes = remote_instance_inboxes(context.conn().await?).await?;
send_lemmy_activity(context, block, mod_, inboxes, false).await
}
SiteOrCommunity::Community(c) => {
@ -181,7 +181,7 @@ impl ActivityHandler for BlockUser {
banned: Some(true),
expires,
};
ModBan::create(&mut *context.conn().await?, &form).await?;
ModBan::create(context.conn().await?, &form).await?;
}
SiteOrCommunity::Community(community) => {
let community_user_ban_form = CommunityPersonBanForm {
@ -189,7 +189,7 @@ impl ActivityHandler for BlockUser {
person_id: blocked_person.id,
expires: Some(expires),
};
CommunityPersonBan::ban(&mut *context.conn().await?, &community_user_ban_form).await?;
CommunityPersonBan::ban(context.conn().await?, &community_user_ban_form).await?;
// Also unsubscribe them from the community, if they are subscribed
let community_follower_form = CommunityFollowerForm {
@ -197,7 +197,7 @@ impl ActivityHandler for BlockUser {
person_id: blocked_person.id,
pending: false,
};
CommunityFollower::unfollow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::unfollow(context.conn().await?, &community_follower_form)
.await
.ok();
@ -219,7 +219,7 @@ impl ActivityHandler for BlockUser {
banned: Some(true),
expires,
};
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?;
ModBanFromCommunity::create(context.conn().await?, &form).await?;
}
}

20
crates/apub/src/activities/block/mod.rs
View file

@ -118,9 +118,12 @@ impl SiteOrCommunity {
}
}
async fn generate_cc(target: &SiteOrCommunity, conn: &mut DbConn) -> Result<Vec<Url>, LemmyError> {
async fn generate_cc(
target: &SiteOrCommunity,
mut conn: impl DbConn,
) -> Result<Vec<Url>, LemmyError> {
Ok(match target {
SiteOrCommunity::Site(_) => Site::read_remote_sites(conn)
SiteOrCommunity::Site(_) => Site::read_remote_sites(&mut *conn)
.await?
.into_iter()
.map(|s| s.actor_id.into())
@ -139,9 +142,9 @@ impl SendActivity for BanPerson {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.person_id).await?;
let site = SiteOrCommunity::Site(
SiteView::read_local(&mut *context.conn().await?)
SiteView::read_local(context.conn().await?)
.await?
.site
.into(),
@ -187,11 +190,10 @@ impl SendActivity for BanFromCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity =
Community::read(&mut *context.conn().await?, request.community_id)
.await?
.into();
let banned_person: ApubPerson = Person::read(&mut *context.conn().await?, request.person_id)
let community: ApubCommunity = Community::read(context.conn().await?, request.community_id)
.await?
.into();
let banned_person: ApubPerson = Person::read(context.conn().await?, request.person_id)
.await?
.into();
let expires = request.expires.map(naive_from_unix);

8
crates/apub/src/activities/block/undo_block_user.rs
View file

@ -62,7 +62,7 @@ impl UndoBlockUser {
let mut inboxes = vec![user.shared_inbox_or_inbox()];
match target {
SiteOrCommunity::Site(_) => {
inboxes.append(&mut remote_instance_inboxes(&mut *context.conn().await?).await?);
inboxes.append(&mut remote_instance_inboxes(context.conn().await?).await?);
send_lemmy_activity(context, undo, mod_, inboxes, false).await
}
SiteOrCommunity::Community(c) => {
@ -120,7 +120,7 @@ impl ActivityHandler for UndoBlockUser {
banned: Some(false),
expires,
};
ModBan::create(&mut *context.conn().await?, &form).await?;
ModBan::create(context.conn().await?, &form).await?;
}
SiteOrCommunity::Community(community) => {
let community_user_ban_form = CommunityPersonBanForm {
@ -128,7 +128,7 @@ impl ActivityHandler for UndoBlockUser {
person_id: blocked_person.id,
expires: None,
};
CommunityPersonBan::unban(&mut *context.conn().await?, &community_user_ban_form).await?;
CommunityPersonBan::unban(context.conn().await?, &community_user_ban_form).await?;
// write to mod log
let form = ModBanFromCommunityForm {
@ -139,7 +139,7 @@ impl ActivityHandler for UndoBlockUser {
banned: Some(false),
expires,
};
ModBanFromCommunity::create(&mut *context.conn().await?, &form).await?;
ModBanFromCommunity::create(context.conn().await?, &form).await?;
}
}

19
crates/apub/src/activities/community/collection_add.rs
View file

@ -119,7 +119,7 @@ impl ActivityHandler for CollectionAdd {
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
insert_activity(&self.id, &self, false, false, context).await?;
let (community, collection_type) =
Community::get_by_collection_url(&mut *context.conn().await?, &self.target.into()).await?;
Community::get_by_collection_url(context.conn().await?, &self.target.into()).await?;
match collection_type {
CollectionType::Moderators => {
let new_mod = ObjectId::<ApubPerson>::from(self.object)
@ -139,7 +139,7 @@ impl ActivityHandler for CollectionAdd {
community_id: community.id,
person_id: new_mod.id,
};
CommunityModerator::join(&mut *context.conn().await?, &form).await?;
CommunityModerator::join(context.conn().await?, &form).await?;
// write mod log
let actor = self.actor.dereference(context).await?;
@ -149,7 +149,7 @@ impl ActivityHandler for CollectionAdd {
community_id: community.id,
removed: Some(false),
};
ModAddCommunity::create(&mut *context.conn().await?, &form).await?;
ModAddCommunity::create(context.conn().await?, &form).await?;
}
// TODO: send websocket notification about added mod
}
@ -160,7 +160,7 @@ impl ActivityHandler for CollectionAdd {
let form = PostUpdateForm::builder()
.featured_community(Some(true))
.build();
Post::update(&mut *context.conn().await?, post.id, &form).await?;
Post::update(context.conn().await?, post.id, &form).await?;
}
}
Ok(())
@ -177,11 +177,10 @@ impl SendActivity for AddModToCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let community: ApubCommunity =
Community::read(&mut *context.conn().await?, request.community_id)
.await?
.into();
let updated_mod: ApubPerson = Person::read(&mut *context.conn().await?, request.person_id)
let community: ApubCommunity = Community::read(context.conn().await?, request.community_id)
.await?
.into();
let updated_mod: ApubPerson = Person::read(context.conn().await?, request.person_id)
.await?
.into();
if request.added {
@ -214,7 +213,7 @@ impl SendActivity for FeaturePost {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, response.post_view.community.id)
.await?
.into();
let post = response.post_view.post.clone().into();

8
crates/apub/src/activities/community/collection_remove.rs
View file

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

7
crates/apub/src/activities/community/lock_page.rs
View file

@ -60,7 +60,7 @@ impl ActivityHandler for LockPage {
async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
let form = PostUpdateForm::builder().locked(Some(true)).build();
let post = self.object.dereference(context).await?;
Post::update(&mut *context.conn().await?, post.id, &form).await?;
Post::update(context.conn().await?, post.id, &form).await?;
Ok(())
}
}
@ -97,7 +97,7 @@ impl ActivityHandler for UndoLockPage {
insert_activity(&self.id, &self, false, false, context).await?;
let form = PostUpdateForm::builder().locked(Some(false)).build();
let post = self.object.object.dereference(context).await?;
Post::update(&mut *context.conn().await?, post.id, &form).await?;
Post::update(context.conn().await?, post.id, &form).await?;
Ok(())
}
}
@ -145,8 +145,7 @@ impl SendActivity for LockPost {
};
AnnouncableActivities::UndoLockPost(undo)
};
let community =
Community::read(&mut *context.conn().await?, response.post_view.community.id).await?;
let community = Community::read(context.conn().await?, response.post_view.community.id).await?;
send_activity_in_community(
activity,
&local_user_view.person.into(),

2
crates/apub/src/activities/community/mod.rs
View file

@ -44,7 +44,7 @@ pub(crate) async fn send_activity_in_community(
// send to user followers
if !is_mod_action {
inboxes.extend(
&mut PersonFollower::list_followers(&mut *context.conn().await?, actor.id)
&mut PersonFollower::list_followers(context.conn().await?, actor.id)
.await?
.into_iter()
.map(|p| ApubPerson(p).shared_inbox_or_inbox()),

4
crates/apub/src/activities/community/report.rs
View file

@ -134,7 +134,7 @@ impl ActivityHandler for Report {
reason: self.summary,
original_post_body: post.body.clone(),
};
PostReport::report(&mut *context.conn().await?, &report_form).await?;
PostReport::report(context.conn().await?, &report_form).await?;
}
PostOrComment::Comment(comment) => {
let report_form = CommentReportForm {
@ -143,7 +143,7 @@ impl ActivityHandler for Report {
original_comment_text: comment.content.clone(),
reason: self.summary,
};
CommentReport::report(&mut *context.conn().await?, &report_form).await?;
CommentReport::report(context.conn().await?, &report_form).await?;
}
};
Ok(())

4
crates/apub/src/activities/community/update.rs
View file

@ -36,7 +36,7 @@ impl SendActivity for EditCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
}
}
@ -117,7 +117,7 @@ impl SendActivity for HideCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.community_id).await?;
UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
}
}

16
crates/apub/src/activities/create_or_update/comment.rs
View file

@ -91,12 +91,10 @@ impl CreateOrUpdateNote {
) -> Result<(), LemmyError> {
// TODO: might be helpful to add a comment method to retrieve community directly
let post_id = comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?;
let post = Post::read(context.conn().await?, post_id).await?;
let community_id = post.community_id;
let person: ApubPerson = Person::read(&mut *context.conn().await?, person_id)
.await?
.into();
let community: ApubCommunity = Community::read(&mut *context.conn().await?, community_id)
let person: ApubPerson = Person::read(context.conn().await?, person_id).await?.into();
let community: ApubCommunity = Community::read(context.conn().await?, community_id)
.await?
.into();
@ -181,7 +179,7 @@ impl ActivityHandler for CreateOrUpdateNote {
if distinguished != existing_comment.distinguished {
let creator = self.actor.dereference(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(context.conn().await?, creator.id, post.community_id).await?;
}
}
@ -194,14 +192,14 @@ impl ActivityHandler for CreateOrUpdateNote {
person_id: comment.creator_id,
score: 1,
};
CommentLike::like(&mut *context.conn().await?, &like_form).await?;
CommentLike::like(context.conn().await?, &like_form).await?;
// Calculate initial hot_rank
CommentAggregates::update_hot_rank(&mut *context.conn().await?, comment.id).await?;
CommentAggregates::update_hot_rank(context.conn().await?, comment.id).await?;
let do_send_email = self.kind == CreateOrUpdateType::Create;
let post_id = comment.post_id;
let post = Post::read(&mut *context.conn().await?, post_id).await?;
let post = Post::read(context.conn().await?, post_id).await?;
let actor = self.actor.dereference(context).await?;
// Note:

10
crates/apub/src/activities/create_or_update/post.rs
View file

@ -109,10 +109,8 @@ impl CreateOrUpdatePage {
) -> Result<(), LemmyError> {
let post = ApubPost(post.clone());
let community_id = post.community_id;
let person: ApubPerson = Person::read(&mut *context.conn().await?, person_id)
.await?
.into();
let community: ApubCommunity = Community::read(&mut *context.conn().await?, community_id)
let person: ApubPerson = Person::read(context.conn().await?, person_id).await?.into();
let community: ApubCommunity = Community::read(context.conn().await?, community_id)
.await?
.into();
@ -191,10 +189,10 @@ impl ActivityHandler for CreateOrUpdatePage {
person_id: post.creator_id,
score: 1,
};
PostLike::like(&mut *context.conn().await?, &like_form).await?;
PostLike::like(context.conn().await?, &like_form).await?;
// Calculate initial hot_rank for post
PostAggregates::update_hot_rank(&mut *context.conn().await?, post.id).await?;
PostAggregates::update_hot_rank(context.conn().await?, post.id).await?;
Ok(())
}

6
crates/apub/src/activities/create_or_update/private_message.rs
View file

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

6
crates/apub/src/activities/deletion/delete.rs
View file

@ -119,7 +119,7 @@ pub(in crate::activities) async fn receive_remove_action(
reason,
expires: None,
};
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?;
ModRemoveCommunity::create(context.conn().await?, &form).await?;
Community::update(
&mut *context.conn().await?,
community.id,
@ -134,7 +134,7 @@ pub(in crate::activities) async fn receive_remove_action(
removed: Some(true),
reason,
};
ModRemovePost::create(&mut *context.conn().await?, &form).await?;
ModRemovePost::create(context.conn().await?, &form).await?;
Post::update(
&mut *context.conn().await?,
post.id,
@ -149,7 +149,7 @@ pub(in crate::activities) async fn receive_remove_action(
removed: Some(true),
reason,
};
ModRemoveComment::create(&mut *context.conn().await?, &form).await?;
ModRemoveComment::create(context.conn().await?, &form).await?;
Comment::update(
&mut *context.conn().await?,
comment.id,

2
crates/apub/src/activities/deletion/delete_user.rs
View file

@ -51,7 +51,7 @@ impl SendActivity for DeleteAccount {
cc: vec![],
};
let inboxes = remote_instance_inboxes(&mut *context.conn().await?).await?;
let inboxes = remote_instance_inboxes(context.conn().await?).await?;
send_lemmy_activity(context, delete, &actor, inboxes, true).await?;
Ok(())
}

16
crates/apub/src/activities/deletion/mod.rs
View file

@ -64,8 +64,7 @@ impl SendActivity for DeletePost {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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).await?;
let community = Community::read(context.conn().await?, response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community(
local_user_view.person,
@ -89,8 +88,7 @@ impl SendActivity for RemovePost {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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).await?;
let community = Community::read(context.conn().await?, response.post_view.community.id).await?;
let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
send_apub_delete_in_community(
local_user_view.person,
@ -114,7 +112,7 @@ impl SendActivity for DeleteComment {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let community_id = response.comment_view.community.id;
let community = Community::read(&mut *context.conn().await?, community_id).await?;
let community = Community::read(context.conn().await?, community_id).await?;
let person = Person::read(
&mut *context.conn().await?,
response.comment_view.creator.id,
@ -136,7 +134,7 @@ impl SendActivity for RemoveComment {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.comment_id).await?;
let community = Community::read(
&mut *context.conn().await?,
response.comment_view.community.id,
@ -185,7 +183,7 @@ impl SendActivity for DeleteCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(
local_user_view.person,
@ -209,7 +207,7 @@ impl SendActivity for RemoveCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.community_id).await?;
let deletable = DeletableObjects::Community(community.clone().into());
send_apub_delete_in_community(
local_user_view.person,
@ -262,7 +260,7 @@ async fn send_apub_delete_private_message(
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
let recipient_id = pm.recipient_id;
let recipient: ApubPerson = Person::read(&mut *context.conn().await?, recipient_id)
let recipient: ApubPerson = Person::read(context.conn().await?, recipient_id)
.await?
.into();

6
crates/apub/src/activities/deletion/undo_delete.rs
View file

@ -111,7 +111,7 @@ impl UndoDelete {
reason: None,
expires: None,
};
ModRemoveCommunity::create(&mut *context.conn().await?, &form).await?;
ModRemoveCommunity::create(context.conn().await?, &form).await?;
Community::update(
&mut *context.conn().await?,
community.id,
@ -126,7 +126,7 @@ impl UndoDelete {
removed: Some(false),
reason: None,
};
ModRemovePost::create(&mut *context.conn().await?, &form).await?;
ModRemovePost::create(context.conn().await?, &form).await?;
Post::update(
&mut *context.conn().await?,
post.id,
@ -141,7 +141,7 @@ impl UndoDelete {
removed: Some(false),
reason: None,
};
ModRemoveComment::create(&mut *context.conn().await?, &form).await?;
ModRemoveComment::create(context.conn().await?, &form).await?;
Comment::update(
&mut *context.conn().await?,
comment.id,

3
crates/apub/src/activities/following/accept.rs
View file

@ -66,8 +66,7 @@ impl ActivityHandler for AcceptFollow {
// This will throw an error if no follow was requested
let community_id = community.id;
let person_id = person.id;
CommunityFollower::follow_accepted(&mut *context.conn().await?, community_id, person_id)
.await?;
CommunityFollower::follow_accepted(context.conn().await?, community_id, person_id).await?;
Ok(())
}

8
crates/apub/src/activities/following/follow.rs
View file

@ -65,7 +65,7 @@ impl Follow {
person_id: actor.id,
pending: true,
};
CommunityFollower::follow(&mut *context.conn().await?, &community_follower_form)
CommunityFollower::follow(context.conn().await?, &community_follower_form)
.await
.ok();
@ -113,7 +113,7 @@ impl ActivityHandler for Follow {
follower_id: actor.id,
pending: false,
};
PersonFollower::follow(&mut *context.conn().await?, &form).await?;
PersonFollower::follow(context.conn().await?, &form).await?;
}
UserOrCommunity::Community(c) => {
let form = CommunityFollowerForm {
@ -121,7 +121,7 @@ impl ActivityHandler for Follow {
person_id: actor.id,
pending: false,
};
CommunityFollower::follow(&mut *context.conn().await?, &form).await?;
CommunityFollower::follow(context.conn().await?, &form).await?;
}
}
@ -139,7 +139,7 @@ impl SendActivity for BlockCommunity {
context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
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(context.conn().await?, request.community_id).await?;
UndoFollow::send(&local_user_view.person.into(), &community.into(), context).await
}
}

7
crates/apub/src/activities/following/mod.rs
View file

@ -27,10 +27,9 @@ impl SendActivity for FollowCommunity {
) -> Result<(), LemmyError> {
let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
let person = local_user_view.person.clone().into();
let community: ApubCommunity =
Community::read(&mut *context.conn().await?, request.community_id)
.await?
.into();
let community: ApubCommunity = Community::read(context.conn().await?, request.community_id)
.await?
.into();
if community.local {
Ok(())
} else if request.follow {

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