use crate::{request::purge_image_from_pictrs, sensitive::Sensitive, site::FederatedInstances};
+use chrono::NaiveDateTime;
use lemmy_db_schema::{
+ impls::person::is_banned,
newtypes::{CommunityId, LocalUserId, PersonId, PostId},
source::{
comment::Comment,
ListingType,
};
use lemmy_db_views::{
- comment_view::CommentQueryBuilder,
+ comment_view::CommentQuery,
structs::{LocalUserSettingsView, LocalUserView},
};
use lemmy_db_views_actor::structs::{
pub async fn blocking<F, T>(pool: &DbPool, f: F) -> Result<T, LemmyError>
where
- F: FnOnce(&diesel::PgConnection) -> T + Send + 'static,
+ F: FnOnce(&mut diesel::PgConnection) -> T + Send + 'static,
T: Send + 'static,
{
let pool = pool.clone();
let blocking_span = tracing::info_span!("blocking operation");
- let res = actix_web::web::block(move || {
+ actix_web::web::block(move || {
let entered = blocking_span.enter();
- let conn = pool.get()?;
- let res = (f)(&conn);
+ let mut conn = pool.get()?;
+ let res = (f)(&mut conn);
drop(entered);
Ok(res) as Result<T, LemmyError>
})
- .await?;
-
- res
+ .await?
}
#[tracing::instrument(skip_all)]
let local_user_id = LocalUserId(claims.sub);
let local_user_view =
blocking(pool, move |conn| LocalUserView::read(conn, local_user_id)).await??;
- // Check for a site ban
- if local_user_view.person.is_banned() {
- return Err(LemmyError::from_message("site_ban"));
- }
-
- // Check for user deletion
- if local_user_view.person.deleted {
- return Err(LemmyError::from_message("deleted"));
- }
+ check_user_valid(
+ local_user_view.person.banned,
+ local_user_view.person.ban_expires,
+ local_user_view.person.deleted,
+ )?;
check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
/// Checks if user's token was issued before user's password reset.
pub fn check_validator_time(
- validator_time: &chrono::NaiveDateTime,
+ validator_time: &NaiveDateTime,
claims: &Claims,
) -> Result<(), LemmyError> {
let user_validation_time = validator_time.timestamp();
}
}
-#[tracing::instrument(skip_all)]
-pub async fn get_local_user_settings_view_from_jwt(
- jwt: &Sensitive<String>,
- pool: &DbPool,
- secret: &Secret,
-) -> Result<LocalUserSettingsView, LemmyError> {
- let claims = Claims::decode(jwt.as_ref(), &secret.jwt_secret)
- .map_err(|e| e.with_message("not_logged_in"))?
- .claims;
- let local_user_id = LocalUserId(claims.sub);
- let local_user_view = blocking(pool, move |conn| {
- LocalUserSettingsView::read(conn, local_user_id)
- })
- .await??;
- // Check for a site ban
- if local_user_view.person.is_banned() {
- return Err(LemmyError::from_message("site_ban"));
- }
-
- check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
-
- Ok(local_user_view)
-}
-
#[tracing::instrument(skip_all)]
pub async fn get_local_user_settings_view_from_jwt_opt(
jwt: Option<&Sensitive<String>>,
secret: &Secret,
) -> Result<Option<LocalUserSettingsView>, LemmyError> {
match jwt {
- Some(jwt) => Ok(Some(
- get_local_user_settings_view_from_jwt(jwt, pool, secret).await?,
- )),
+ Some(jwt) => {
+ let claims = Claims::decode(jwt.as_ref(), &secret.jwt_secret)
+ .map_err(|e| e.with_message("not_logged_in"))?
+ .claims;
+ let local_user_id = LocalUserId(claims.sub);
+ let local_user_view = blocking(pool, move |conn| {
+ LocalUserSettingsView::read(conn, local_user_id)
+ })
+ .await??;
+ check_user_valid(
+ local_user_view.person.banned,
+ local_user_view.person.ban_expires,
+ local_user_view.person.deleted,
+ )?;
+
+ check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
+
+ Ok(Some(local_user_view))
+ }
None => Ok(None),
}
}
+pub fn check_user_valid(
+ banned: bool,
+ ban_expires: Option<NaiveDateTime>,
+ deleted: bool,
+) -> Result<(), LemmyError> {
+ // Check for a site ban
+ if is_banned(banned, ban_expires) {
+ return Err(LemmyError::from_message("site_ban"));
+ }
+
+ // check for account deletion
+ if deleted {
+ return Err(LemmyError::from_message("deleted"));
+ }
+
+ Ok(())
+}
#[tracing::instrument(skip_all)]
pub async fn check_community_ban(
pool: &DbPool,
) -> Result<(), LemmyError> {
let is_banned =
- move |conn: &'_ _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
+ move |conn: &mut _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
if blocking(pool, is_banned).await? {
Err(LemmyError::from_message("community_ban"))
} else {
potential_blocker_id: PersonId,
pool: &DbPool,
) -> Result<(), LemmyError> {
- let is_blocked = move |conn: &'_ _| PersonBlock::read(conn, potential_blocker_id, my_id).is_ok();
+ let is_blocked = move |conn: &mut _| PersonBlock::read(conn, potential_blocker_id, my_id).is_ok();
if blocking(pool, is_blocked).await? {
Err(LemmyError::from_message("person_block"))
} else {
.await??;
let email = &user.local_user.email.to_owned().expect("email");
- let lang = get_user_lang(user);
+ let lang = get_interface_language(user);
let subject = &lang.password_reset_subject(&user.person.name);
let protocol_and_hostname = settings.get_protocol_and_hostname();
let reset_link = format!("{}/password_change/{}", protocol_and_hostname, &token);
);
blocking(pool, move |conn| EmailVerification::create(conn, &form)).await??;
- let lang = get_user_lang(user);
+ let lang = get_interface_language(user);
let subject = lang.verify_email_subject(&settings.hostname);
let body = lang.verify_email_body(&settings.hostname, &user.person.name, verify_link);
send_email(&subject, new_email, &user.person.name, &body, settings)?;
settings: &Settings,
) -> Result<(), LemmyError> {
let email = &user.local_user.email.to_owned().expect("email");
- let lang = get_user_lang(user);
+ let lang = get_interface_language(user);
let subject = &lang.email_verified_subject(&user.person.actor_id);
let body = &lang.email_verified_body();
send_email(subject, email, &user.person.name, body, settings)
}
-pub fn get_user_lang(user: &LocalUserView) -> Lang {
- let user_lang = LanguageId::new(user.local_user.lang.clone());
+pub fn get_interface_language(user: &LocalUserView) -> Lang {
+ let user_lang = LanguageId::new(user.local_user.interface_language.clone());
Lang::from_language_id(&user_lang).unwrap_or_else(|| {
let en = LanguageId::new("en");
Lang::from_language_id(&en).expect("default language")
settings: &Settings,
) -> Result<(), LemmyError> {
let email = &user.local_user.email.to_owned().expect("email");
- let lang = get_user_lang(user);
+ let lang = get_interface_language(user);
let subject = lang.registration_approved_subject(&user.person.actor_id);
let body = lang.registration_approved_body(&settings.hostname);
send_email(&subject, email, &user.person.name, &body, settings)
})
.await??;
if let Some(deny_reason) = registration.deny_reason {
- let lang = get_user_lang(local_user_view);
+ let lang = get_interface_language(local_user_view);
let registration_denied_message = format!("{}: {}", lang.registration_denied(), &deny_reason);
return Err(LemmyError::from_message(®istration_denied_message));
} else {
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
- let posts = blocking(pool, move |conn: &'_ _| {
+ let posts = blocking(pool, move |conn: &mut _| {
Post::fetch_pictrs_posts_for_creator(conn, banned_person_id)
})
.await??;
settings: &Settings,
client: &ClientWithMiddleware,
) -> Result<(), LemmyError> {
- let posts = blocking(pool, move |conn: &'_ _| {
+ let posts = blocking(pool, move |conn: &mut _| {
Post::fetch_pictrs_posts_for_community(conn, banned_community_id)
})
.await??;
.await??;
// Posts
- blocking(pool, move |conn: &'_ _| {
+ blocking(pool, move |conn: &mut _| {
Post::update_removed_for_creator(conn, banned_person_id, None, true)
})
.await??;
// Communities
// Remove all communities where they're the top mod
// for now, remove the communities manually
- let first_mod_communities = blocking(pool, move |conn: &'_ _| {
+ let first_mod_communities = blocking(pool, move |conn: &mut _| {
CommunityModeratorView::get_community_first_mods(conn)
})
.await??;
for first_mod_community in banned_user_first_communities {
let community_id = first_mod_community.community.id;
- blocking(pool, move |conn: &'_ _| {
+ blocking(pool, move |conn: &mut _| {
Community::update_removed(conn, community_id, true)
})
.await??;
}
// Comments
- blocking(pool, move |conn: &'_ _| {
+ blocking(pool, move |conn: &mut _| {
Comment::update_removed_for_creator(conn, banned_person_id, true)
})
.await??;
// Comments
// TODO Diesel doesn't allow updates with joins, so this has to be a loop
let comments = blocking(pool, move |conn| {
- CommentQueryBuilder::create(conn)
- .creator_id(banned_person_id)
- .community_id(community_id)
- .limit(std::i64::MAX)
+ CommentQuery::builder()
+ .conn(conn)
+ .creator_id(Some(banned_person_id))
+ .community_id(Some(community_id))
+ .limit(Some(i64::MAX))
+ .build()
.list()
})
.await??;
// No need to update avatar and banner, those are handled in Person::delete_account
// Comments
- let permadelete = move |conn: &'_ _| Comment::permadelete_for_creator(conn, person_id);
+ let permadelete = move |conn: &mut _| Comment::permadelete_for_creator(conn, person_id);
blocking(pool, permadelete)
.await?
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
// Posts
- let permadelete = move |conn: &'_ _| Post::permadelete_for_creator(conn, person_id);
+ let permadelete = move |conn: &mut _| Post::permadelete_for_creator(conn, person_id);
blocking(pool, permadelete)
.await?
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?;
projects / lemmy.git / blobdiff