X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapi_common%2Fsrc%2Futils.rs;h=f3cebebd24d4487029c6d33e9abdec268373525e;hb=70fae9d68d65b1e4d153e30d3c065cc315b75eaf;hp=2a02b9a71d16c185d6cd2d468cf167d17e6c997e;hpb=2ef0f8f5f8c60d8c7632779ca16bac69daab1266;p=lemmy.git diff --git a/crates/api_common/src/utils.rs b/crates/api_common/src/utils.rs index 2a02b9a7..f3cebebd 100644 --- a/crates/api_common/src/utils.rs +++ b/crates/api_common/src/utils.rs @@ -1,28 +1,32 @@ -use crate::{request::purge_image_from_pictrs, sensitive::Sensitive, site::FederatedInstances}; +use crate::{ + context::LemmyContext, + request::purge_image_from_pictrs, + sensitive::Sensitive, + site::FederatedInstances, +}; +use anyhow::Context; use chrono::NaiveDateTime; use lemmy_db_schema::{ impls::person::is_banned, - newtypes::{CommunityId, LocalUserId, PersonId, PostId}, + newtypes::{CommunityId, DbUrl, LocalUserId, PersonId, PostId}, source::{ - comment::Comment, - community::Community, + comment::{Comment, CommentUpdateForm}, + community::{Community, CommunityModerator, CommunityUpdateForm}, email_verification::{EmailVerification, EmailVerificationForm}, + instance::Instance, + local_site::LocalSite, + local_site_rate_limit::LocalSiteRateLimit, password_reset_request::PasswordResetRequest, - person::Person, + person::{Person, PersonUpdateForm}, person_block::PersonBlock, post::{Post, PostRead, PostReadForm}, registration_application::RegistrationApplication, - secret::Secret, - site::Site, }, traits::{Crud, Readable}, utils::DbPool, - ListingType, -}; -use lemmy_db_views::{ - comment_view::CommentQuery, - structs::{LocalUserSettingsView, LocalUserView}, + RegistrationMode, }; +use lemmy_db_views::{comment_view::CommentQuery, structs::LocalUserView}; use lemmy_db_views_actor::structs::{ CommunityModeratorView, CommunityPersonBanView, @@ -31,104 +35,113 @@ use lemmy_db_views_actor::structs::{ use lemmy_utils::{ claims::Claims, email::{send_email, translations::Lang}, - error::LemmyError, + error::{LemmyError, LemmyErrorExt, LemmyErrorExt2, LemmyErrorType}, + location_info, + rate_limit::RateLimitConfig, settings::structs::Settings, - utils::generate_random_string, + utils::slurs::build_slur_regex, }; +use regex::Regex; use reqwest_middleware::ClientWithMiddleware; use rosetta_i18n::{Language, LanguageId}; -use std::str::FromStr; use tracing::warn; - -pub async fn blocking(pool: &DbPool, f: F) -> Result -where - F: FnOnce(&mut diesel::PgConnection) -> T + Send + 'static, - T: Send + 'static, -{ - let pool = pool.clone(); - let blocking_span = tracing::info_span!("blocking operation"); - actix_web::web::block(move || { - let entered = blocking_span.enter(); - let mut conn = pool.get()?; - let res = (f)(&mut conn); - drop(entered); - Ok(res) as Result - }) - .await? -} +use url::{ParseError, Url}; #[tracing::instrument(skip_all)] pub async fn is_mod_or_admin( - pool: &DbPool, + pool: &mut DbPool<'_>, person_id: PersonId, community_id: CommunityId, ) -> Result<(), LemmyError> { - let is_mod_or_admin = blocking(pool, move |conn| { - CommunityView::is_mod_or_admin(conn, person_id, community_id) - }) - .await?; + let is_mod_or_admin = CommunityView::is_mod_or_admin(pool, person_id, community_id).await?; if !is_mod_or_admin { - return Err(LemmyError::from_message("not_a_mod_or_admin")); + return Err(LemmyErrorType::NotAModOrAdmin)?; } Ok(()) } +#[tracing::instrument(skip_all)] +pub async fn is_mod_or_admin_opt( + pool: &mut DbPool<'_>, + local_user_view: Option<&LocalUserView>, + community_id: Option, +) -> Result<(), LemmyError> { + if let Some(local_user_view) = local_user_view { + if let Some(community_id) = community_id { + is_mod_or_admin(pool, local_user_view.person.id, community_id).await + } else { + is_admin(local_user_view) + } + } else { + Err(LemmyErrorType::NotAModOrAdmin)? + } +} + pub fn is_admin(local_user_view: &LocalUserView) -> Result<(), LemmyError> { if !local_user_view.person.admin { - return Err(LemmyError::from_message("not_an_admin")); + Err(LemmyErrorType::NotAnAdmin)?; + } + Ok(()) +} + +pub fn is_top_mod( + local_user_view: &LocalUserView, + community_mods: &[CommunityModeratorView], +) -> Result<(), LemmyError> { + if local_user_view.person.id + != community_mods + .first() + .map(|cm| cm.moderator.id) + .unwrap_or(PersonId(0)) + { + Err(LemmyErrorType::NotTopMod)?; } Ok(()) } #[tracing::instrument(skip_all)] -pub async fn get_post(post_id: PostId, pool: &DbPool) -> Result { - blocking(pool, move |conn| Post::read(conn, post_id)) - .await? - .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post")) +pub async fn get_post(post_id: PostId, pool: &mut DbPool<'_>) -> Result { + Post::read(pool, post_id) + .await + .with_lemmy_type(LemmyErrorType::CouldntFindPost) } #[tracing::instrument(skip_all)] pub async fn mark_post_as_read( person_id: PersonId, post_id: PostId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result { let post_read_form = PostReadForm { post_id, person_id }; - blocking(pool, move |conn| { - PostRead::mark_as_read(conn, &post_read_form) - }) - .await? - .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read")) + PostRead::mark_as_read(pool, &post_read_form) + .await + .with_lemmy_type(LemmyErrorType::CouldntMarkPostAsRead) } #[tracing::instrument(skip_all)] pub async fn mark_post_as_unread( person_id: PersonId, post_id: PostId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result { let post_read_form = PostReadForm { post_id, person_id }; - blocking(pool, move |conn| { - PostRead::mark_as_unread(conn, &post_read_form) - }) - .await? - .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read")) + PostRead::mark_as_unread(pool, &post_read_form) + .await + .with_lemmy_type(LemmyErrorType::CouldntMarkPostAsRead) } #[tracing::instrument(skip_all)] -pub async fn get_local_user_view_from_jwt( +pub async fn local_user_view_from_jwt( jwt: &str, - pool: &DbPool, - secret: &Secret, + context: &LemmyContext, ) -> Result { - let claims = Claims::decode(jwt, &secret.jwt_secret) - .map_err(|e| e.with_message("not_logged_in"))? + let claims = Claims::decode(jwt, &context.secret().jwt_secret) + .with_lemmy_type(LemmyErrorType::NotLoggedIn)? .claims; let local_user_id = LocalUserId(claims.sub); - let local_user_view = - blocking(pool, move |conn| LocalUserView::read(conn, local_user_id)).await??; + let local_user_view = LocalUserView::read(&mut context.pool(), local_user_id).await?; check_user_valid( local_user_view.person.banned, local_user_view.person.ban_expires, @@ -140,6 +153,14 @@ pub async fn get_local_user_view_from_jwt( Ok(local_user_view) } +#[tracing::instrument(skip_all)] +pub async fn local_user_view_from_jwt_opt( + jwt: Option<&Sensitive>, + context: &LemmyContext, +) -> Option { + local_user_view_from_jwt(jwt?, context).await.ok() +} + /// Checks if user's token was issued before user's password reset. pub fn check_validator_time( validator_time: &NaiveDateTime, @@ -147,53 +168,12 @@ pub fn check_validator_time( ) -> Result<(), LemmyError> { let user_validation_time = validator_time.timestamp(); if user_validation_time > claims.iat { - Err(LemmyError::from_message("not_logged_in")) + Err(LemmyErrorType::NotLoggedIn)? } else { Ok(()) } } -#[tracing::instrument(skip_all)] -pub async fn get_local_user_view_from_jwt_opt( - jwt: Option<&Sensitive>, - pool: &DbPool, - secret: &Secret, -) -> Result, LemmyError> { - match jwt { - Some(jwt) => Ok(Some(get_local_user_view_from_jwt(jwt, pool, secret).await?)), - None => Ok(None), - } -} - -#[tracing::instrument(skip_all)] -pub async fn get_local_user_settings_view_from_jwt_opt( - jwt: Option<&Sensitive>, - pool: &DbPool, - secret: &Secret, -) -> Result, LemmyError> { - match jwt { - 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, @@ -201,12 +181,12 @@ pub fn check_user_valid( ) -> Result<(), LemmyError> { // Check for a site ban if is_banned(banned, ban_expires) { - return Err(LemmyError::from_message("site_ban")); + Err(LemmyErrorType::SiteBan)?; } // check for account deletion if deleted { - return Err(LemmyError::from_message("deleted")); + Err(LemmyErrorType::Deleted)?; } Ok(()) @@ -216,12 +196,13 @@ pub fn check_user_valid( pub async fn check_community_ban( person_id: PersonId, community_id: CommunityId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { - let is_banned = - move |conn: &mut _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok(); - if blocking(pool, is_banned).await? { - Err(LemmyError::from_message("community_ban")) + let is_banned = CommunityPersonBanView::get(pool, person_id, community_id) + .await + .is_ok(); + if is_banned { + Err(LemmyErrorType::BannedFromCommunity)? } else { Ok(()) } @@ -230,13 +211,13 @@ pub async fn check_community_ban( #[tracing::instrument(skip_all)] pub async fn check_community_deleted_or_removed( community_id: CommunityId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { - let community = blocking(pool, move |conn| Community::read(conn, community_id)) - .await? - .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?; + let community = Community::read(pool, community_id) + .await + .with_lemmy_type(LemmyErrorType::CouldntFindCommunity)?; if community.deleted || community.removed { - Err(LemmyError::from_message("deleted")) + Err(LemmyErrorType::Deleted)? } else { Ok(()) } @@ -244,7 +225,7 @@ pub async fn check_community_deleted_or_removed( pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> { if post.deleted || post.removed { - Err(LemmyError::from_message("deleted")) + Err(LemmyErrorType::Deleted)? } else { Ok(()) } @@ -254,78 +235,49 @@ pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> { pub async fn check_person_block( my_id: PersonId, potential_blocker_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { - 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")) + let is_blocked = PersonBlock::read(pool, potential_blocker_id, my_id) + .await + .is_ok(); + if is_blocked { + Err(LemmyErrorType::PersonIsBlocked)? } else { Ok(()) } } #[tracing::instrument(skip_all)] -pub async fn check_downvotes_enabled(score: i16, pool: &DbPool) -> Result<(), LemmyError> { - if score == -1 { - let site = blocking(pool, Site::read_local).await??; - if !site.enable_downvotes { - return Err(LemmyError::from_message("downvotes_disabled")); - } +pub fn check_downvotes_enabled(score: i16, local_site: &LocalSite) -> Result<(), LemmyError> { + if score == -1 && !local_site.enable_downvotes { + Err(LemmyErrorType::DownvotesAreDisabled)?; } Ok(()) } #[tracing::instrument(skip_all)] -pub async fn check_private_instance( +pub fn check_private_instance( local_user_view: &Option, - pool: &DbPool, + local_site: &LocalSite, ) -> Result<(), LemmyError> { - if local_user_view.is_none() { - let site = blocking(pool, Site::read_local).await?; - - // The site might not be set up yet - if let Ok(site) = site { - if site.private_instance { - return Err(LemmyError::from_message("instance_is_private")); - } - } + if local_user_view.is_none() && local_site.private_instance { + Err(LemmyErrorType::InstanceIsPrivate)?; } Ok(()) } #[tracing::instrument(skip_all)] pub async fn build_federated_instances( - pool: &DbPool, - settings: &Settings, + local_site: &LocalSite, + pool: &mut DbPool<'_>, ) -> Result, LemmyError> { - let federation_config = &settings.federation; - let hostname = &settings.hostname; - let federation = federation_config.to_owned(); - if federation.enabled { - let distinct_communities = blocking(pool, move |conn| { - Community::distinct_federated_communities(conn) - }) - .await??; - - let allowed = federation.allowed_instances; - let blocked = federation.blocked_instances; - - let mut linked = distinct_communities - .iter() - .map(|actor_id| Ok(actor_id.host_str().unwrap_or("").to_string())) - .collect::, LemmyError>>()?; - - if let Some(allowed) = allowed.as_ref() { - linked.extend_from_slice(allowed); - } - - if let Some(blocked) = blocked.as_ref() { - linked.retain(|a| !blocked.contains(a) && !a.eq(hostname)); - } - - // Sort and remove dupes - linked.sort_unstable(); - linked.dedup(); + if local_site.federation_enabled { + // TODO I hate that this requires 3 queries + let (linked, allowed, blocked) = lemmy_db_schema::try_join_with_pool!(pool => ( + Instance::linked, + Instance::allowlist, + Instance::blocklist + ))?; Ok(Some(FederatedInstances { linked, @@ -339,17 +291,8 @@ pub async fn build_federated_instances( /// Checks the password length pub fn password_length_check(pass: &str) -> Result<(), LemmyError> { - if !(10..=60).contains(&pass.len()) { - Err(LemmyError::from_message("invalid_password")) - } else { - Ok(()) - } -} - -/// Checks the site description length -pub fn site_description_length_check(description: &str) -> Result<(), LemmyError> { - if description.len() > 150 { - Err(LemmyError::from_message("site_description_length_overflow")) + if !(10..=60).contains(&pass.chars().count()) { + Err(LemmyErrorType::InvalidPassword)? } else { Ok(()) } @@ -357,14 +300,14 @@ pub fn site_description_length_check(description: &str) -> Result<(), LemmyError /// Checks for a honeypot. If this field is filled, fail the rest of the function pub fn honeypot_check(honeypot: &Option) -> Result<(), LemmyError> { - if honeypot.is_some() { - Err(LemmyError::from_message("honeypot_fail")) + if honeypot.is_some() && honeypot != &Some(String::new()) { + Err(LemmyErrorType::HoneypotFailed)? } else { Ok(()) } } -pub fn send_email_to_user( +pub async fn send_email_to_user( local_user_view: &LocalUserView, subject: &str, body: &str, @@ -381,7 +324,9 @@ pub fn send_email_to_user( &local_user_view.person.name, body, settings, - ) { + ) + .await + { Ok(_o) => _o, Err(e) => warn!("{}", e), }; @@ -390,72 +335,57 @@ pub fn send_email_to_user( pub async fn send_password_reset_email( user: &LocalUserView, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, ) -> Result<(), LemmyError> { // Generate a random token - let token = generate_random_string(); + let token = uuid::Uuid::new_v4().to_string(); // Insert the row - let token2 = token.clone(); let local_user_id = user.local_user.id; - blocking(pool, move |conn| { - PasswordResetRequest::create_token(conn, local_user_id, &token2) - }) - .await??; + PasswordResetRequest::create_token(pool, local_user_id, token.clone()).await?; - let email = &user.local_user.email.to_owned().expect("email"); + let email = &user.local_user.email.clone().expect("email"); 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); let body = &lang.password_reset_body(reset_link, &user.person.name); - send_email(subject, email, &user.person.name, body, settings) + send_email(subject, email, &user.person.name, body, settings).await } /// Send a verification email pub async fn send_verification_email( user: &LocalUserView, new_email: &str, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, ) -> Result<(), LemmyError> { let form = EmailVerificationForm { local_user_id: user.local_user.id, email: new_email.to_string(), - verification_token: generate_random_string(), + verification_token: uuid::Uuid::new_v4().to_string(), }; let verify_link = format!( "{}/verify_email/{}", settings.get_protocol_and_hostname(), &form.verification_token ); - blocking(pool, move |conn| EmailVerification::create(conn, &form)).await??; + EmailVerification::create(pool, &form).await?; 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)?; + send_email(&subject, new_email, &user.person.name, &body, settings).await?; Ok(()) } -pub fn send_email_verification_success( - user: &LocalUserView, - settings: &Settings, -) -> Result<(), LemmyError> { - let email = &user.local_user.email.to_owned().expect("email"); - 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_interface_language(user: &LocalUserView) -> Lang { lang_str_to_lang(&user.local_user.interface_language) } -pub fn get_interface_language_from_settings(user: &LocalUserSettingsView) -> Lang { +pub fn get_interface_language_from_settings(user: &LocalUserView) -> Lang { lang_str_to_lang(&user.local_user.interface_language) } @@ -467,28 +397,63 @@ fn lang_str_to_lang(lang: &str) -> Lang { }) } -pub fn send_application_approved_email( +pub fn local_site_rate_limit_to_rate_limit_config( + local_site_rate_limit: &LocalSiteRateLimit, +) -> RateLimitConfig { + let l = local_site_rate_limit; + RateLimitConfig { + message: l.message, + message_per_second: l.message_per_second, + post: l.post, + post_per_second: l.post_per_second, + register: l.register, + register_per_second: l.register_per_second, + image: l.image, + image_per_second: l.image_per_second, + comment: l.comment, + comment_per_second: l.comment_per_second, + search: l.search, + search_per_second: l.search_per_second, + } +} + +pub fn local_site_to_slur_regex(local_site: &LocalSite) -> Option { + build_slur_regex(local_site.slur_filter_regex.as_deref()) +} + +pub fn local_site_opt_to_slur_regex(local_site: &Option) -> Option { + local_site + .as_ref() + .map(local_site_to_slur_regex) + .unwrap_or(None) +} + +pub fn local_site_opt_to_sensitive(local_site: &Option) -> bool { + local_site + .as_ref() + .map(|site| site.enable_nsfw) + .unwrap_or(false) +} + +pub async fn send_application_approved_email( user: &LocalUserView, settings: &Settings, ) -> Result<(), LemmyError> { - let email = &user.local_user.email.to_owned().expect("email"); + let email = &user.local_user.email.clone().expect("email"); 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) + send_email(&subject, email, &user.person.name, &body, settings).await } /// Send a new applicant email notification to all admins pub async fn send_new_applicant_email_to_admins( applicant_username: &str, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, ) -> Result<(), LemmyError> { // Collect the admins with emails - let admins = blocking(pool, move |conn| { - LocalUserSettingsView::list_admins_with_emails(conn) - }) - .await??; + let admins = LocalUserView::list_admins_with_emails(pool).await?; let applications_link = &format!( "{}/registration_applications", @@ -496,68 +461,79 @@ pub async fn send_new_applicant_email_to_admins( ); for admin in &admins { - let email = &admin.local_user.email.to_owned().expect("email"); + let email = &admin.local_user.email.clone().expect("email"); let lang = get_interface_language_from_settings(admin); - let subject = lang.new_application_subject(applicant_username, &settings.hostname); + let subject = lang.new_application_subject(&settings.hostname, applicant_username); let body = lang.new_application_body(applications_link); - send_email(&subject, email, &admin.person.name, &body, settings)?; + send_email(&subject, email, &admin.person.name, &body, settings).await?; + } + Ok(()) +} + +/// Send a report to all admins +pub async fn send_new_report_email_to_admins( + reporter_username: &str, + reported_username: &str, + pool: &mut DbPool<'_>, + settings: &Settings, +) -> Result<(), LemmyError> { + // Collect the admins with emails + let admins = LocalUserView::list_admins_with_emails(pool).await?; + + let reports_link = &format!("{}/reports", settings.get_protocol_and_hostname(),); + + for admin in &admins { + let email = &admin.local_user.email.clone().expect("email"); + let lang = get_interface_language_from_settings(admin); + let subject = lang.new_report_subject(&settings.hostname, reported_username, reporter_username); + let body = lang.new_report_body(reports_link); + send_email(&subject, email, &admin.person.name, &body, settings).await?; } Ok(()) } pub async fn check_registration_application( - site: &Site, local_user_view: &LocalUserView, - pool: &DbPool, + local_site: &LocalSite, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { - if site.require_application + if (local_site.registration_mode == RegistrationMode::RequireApplication + || local_site.registration_mode == RegistrationMode::Closed) && !local_user_view.local_user.accepted_application && !local_user_view.person.admin { // Fetch the registration, see if its denied let local_user_id = local_user_view.local_user.id; - let registration = blocking(pool, move |conn| { - RegistrationApplication::find_by_local_user_id(conn, local_user_id) - }) - .await??; + let registration = RegistrationApplication::find_by_local_user_id(pool, 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); - return Err(LemmyError::from_message(®istration_denied_message)); + let registration_denied_message = format!("{}: {}", lang.registration_denied(), deny_reason); + return Err(LemmyErrorType::RegistrationDenied( + registration_denied_message, + ))?; } else { - return Err(LemmyError::from_message("registration_application_pending")); + return Err(LemmyErrorType::RegistrationApplicationIsPending)?; } } Ok(()) } -/// TODO this check should be removed after https://github.com/LemmyNet/lemmy/issues/868 is done. -pub async fn check_private_instance_and_federation_enabled( - pool: &DbPool, - settings: &Settings, +pub fn check_private_instance_and_federation_enabled( + local_site: &LocalSite, ) -> Result<(), LemmyError> { - let site_opt = blocking(pool, Site::read_local).await?; - - if let Ok(site) = site_opt { - if site.private_instance && settings.federation.enabled { - return Err(LemmyError::from_message( - "Cannot have both private instance and federation enabled.", - )); - } + if local_site.private_instance && local_site.federation_enabled { + Err(LemmyErrorType::CantEnablePrivateInstanceAndFederationTogether)?; } Ok(()) } pub async fn purge_image_posts_for_person( banned_person_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { - let posts = blocking(pool, move |conn: &mut _| { - Post::fetch_pictrs_posts_for_creator(conn, banned_person_id) - }) - .await??; + let posts = Post::fetch_pictrs_posts_for_creator(pool, banned_person_id).await?; for post in posts { if let Some(url) = post.url { purge_image_from_pictrs(client, settings, &url).await.ok(); @@ -569,24 +545,18 @@ pub async fn purge_image_posts_for_person( } } - blocking(pool, move |conn| { - Post::remove_pictrs_post_images_and_thumbnails_for_creator(conn, banned_person_id) - }) - .await??; + Post::remove_pictrs_post_images_and_thumbnails_for_creator(pool, banned_person_id).await?; Ok(()) } pub async fn purge_image_posts_for_community( banned_community_id: CommunityId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { - let posts = blocking(pool, move |conn: &mut _| { - Post::fetch_pictrs_posts_for_community(conn, banned_community_id) - }) - .await??; + let posts = Post::fetch_pictrs_posts_for_community(pool, banned_community_id).await?; for post in posts { if let Some(url) = post.url { purge_image_from_pictrs(client, settings, &url).await.ok(); @@ -598,22 +568,19 @@ pub async fn purge_image_posts_for_community( } } - blocking(pool, move |conn| { - Post::remove_pictrs_post_images_and_thumbnails_for_community(conn, banned_community_id) - }) - .await??; + Post::remove_pictrs_post_images_and_thumbnails_for_community(pool, banned_community_id).await?; Ok(()) } pub async fn remove_user_data( banned_person_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { // Purge user images - let person = blocking(pool, move |conn| Person::read(conn, banned_person_id)).await??; + let person = Person::read(pool, banned_person_id).await?; if let Some(avatar) = person.avatar { purge_image_from_pictrs(client, settings, &avatar) .await @@ -626,16 +593,18 @@ pub async fn remove_user_data( } // Update the fields to None - blocking(pool, move |conn| { - Person::remove_avatar_and_banner(conn, banned_person_id) - }) - .await??; + Person::update( + pool, + banned_person_id, + &PersonUpdateForm::builder() + .avatar(Some(None)) + .banner(Some(None)) + .build(), + ) + .await?; // Posts - blocking(pool, move |conn: &mut _| { - Post::update_removed_for_creator(conn, banned_person_id, None, true) - }) - .await??; + Post::update_removed_for_creator(pool, banned_person_id, None, true).await?; // Purge image posts purge_image_posts_for_person(banned_person_id, pool, settings, client).await?; @@ -643,10 +612,7 @@ pub async fn remove_user_data( // Communities // Remove all communities where they're the top mod // for now, remove the communities manually - let first_mod_communities = blocking(pool, move |conn: &mut _| { - CommunityModeratorView::get_community_first_mods(conn) - }) - .await??; + let first_mod_communities = CommunityModeratorView::get_community_first_mods(pool).await?; // Filter to only this banned users top communities let banned_user_first_communities: Vec = first_mod_communities @@ -656,10 +622,12 @@ pub async fn remove_user_data( for first_mod_community in banned_user_first_communities { let community_id = first_mod_community.community.id; - blocking(pool, move |conn: &mut _| { - Community::update_removed(conn, community_id, true) - }) - .await??; + Community::update( + pool, + community_id, + &CommunityUpdateForm::builder().removed(Some(true)).build(), + ) + .await?; // Delete the community images if let Some(icon) = first_mod_community.community.icon { @@ -671,17 +639,19 @@ pub async fn remove_user_data( .ok(); } // Update the fields to None - blocking(pool, move |conn| { - Community::remove_avatar_and_banner(conn, community_id) - }) - .await??; + Community::update( + pool, + community_id, + &CommunityUpdateForm::builder() + .icon(Some(None)) + .banner(Some(None)) + .build(), + ) + .await?; } // Comments - blocking(pool, move |conn: &mut _| { - Comment::update_removed_for_creator(conn, banned_person_id, true) - }) - .await??; + Comment::update_removed_for_creator(pool, banned_person_id, true).await?; Ok(()) } @@ -689,33 +659,29 @@ pub async fn remove_user_data( pub async fn remove_user_data_in_community( community_id: CommunityId, banned_person_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { // Posts - blocking(pool, move |conn| { - Post::update_removed_for_creator(conn, banned_person_id, Some(community_id), true) - }) - .await??; + Post::update_removed_for_creator(pool, 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 = blocking(pool, move |conn| { - CommentQuery::builder() - .conn(conn) - .creator_id(Some(banned_person_id)) - .community_id(Some(community_id)) - .limit(Some(i64::MAX)) - .build() - .list() - }) - .await??; + let comments = CommentQuery { + creator_id: Some(banned_person_id), + community_id: Some(community_id), + ..Default::default() + } + .list(pool) + .await?; for comment_view in &comments { let comment_id = comment_view.comment.id; - blocking(pool, move |conn| { - Comment::update_removed(conn, comment_id, true) - }) - .await??; + Comment::update( + pool, + comment_id, + &CommentUpdateForm::builder().removed(Some(true)).build(), + ) + .await?; } Ok(()) @@ -723,12 +689,12 @@ pub async fn remove_user_data_in_community( pub async fn delete_user_account( person_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { // Delete their images - let person = blocking(pool, move |conn| Person::read(conn, person_id)).await??; + let person = Person::read(pool, person_id).await?; if let Some(avatar) = person.avatar { purge_image_from_pictrs(client, settings, &avatar) .await @@ -742,34 +708,136 @@ pub async fn delete_user_account( // No need to update avatar and banner, those are handled in Person::delete_account // Comments - 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"))?; + Comment::permadelete_for_creator(pool, person_id) + .await + .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?; // Posts - 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"))?; + Post::permadelete_for_creator(pool, person_id) + .await + .with_lemmy_type(LemmyErrorType::CouldntUpdatePost)?; // Purge image posts purge_image_posts_for_person(person_id, pool, settings, client).await?; - blocking(pool, move |conn| Person::delete_account(conn, person_id)).await??; + // Leave communities they mod + CommunityModerator::leave_all_communities(pool, person_id).await?; + + Person::delete_account(pool, person_id).await?; Ok(()) } -pub async fn listing_type_with_site_default( - listing_type: Option, - pool: &DbPool, -) -> Result { - Ok(match listing_type { - Some(l) => l, - None => { - let site = blocking(pool, Site::read_local).await??; - ListingType::from_str(&site.default_post_listing_type)? - } - }) +pub enum EndpointType { + Community, + Person, + Post, + Comment, + PrivateMessage, +} + +/// Generates an apub endpoint for a given domain, IE xyz.tld +pub fn generate_local_apub_endpoint( + endpoint_type: EndpointType, + name: &str, + domain: &str, +) -> Result { + let point = match endpoint_type { + EndpointType::Community => "c", + EndpointType::Person => "u", + EndpointType::Post => "post", + EndpointType::Comment => "comment", + EndpointType::PrivateMessage => "private_message", + }; + + Ok(Url::parse(&format!("{domain}/{point}/{name}"))?.into()) +} + +pub fn generate_followers_url(actor_id: &DbUrl) -> Result { + Ok(Url::parse(&format!("{actor_id}/followers"))?.into()) +} + +pub fn generate_inbox_url(actor_id: &DbUrl) -> Result { + Ok(Url::parse(&format!("{actor_id}/inbox"))?.into()) +} + +pub fn generate_site_inbox_url(actor_id: &DbUrl) -> Result { + let mut actor_id: Url = actor_id.clone().into(); + actor_id.set_path("site_inbox"); + Ok(actor_id.into()) +} + +pub fn generate_shared_inbox_url(actor_id: &DbUrl) -> Result { + let actor_id: Url = actor_id.clone().into(); + let url = format!( + "{}://{}{}/inbox", + &actor_id.scheme(), + &actor_id.host_str().context(location_info!())?, + if let Some(port) = actor_id.port() { + format!(":{port}") + } else { + String::new() + }, + ); + Ok(Url::parse(&url)?.into()) +} + +pub fn generate_outbox_url(actor_id: &DbUrl) -> Result { + Ok(Url::parse(&format!("{actor_id}/outbox"))?.into()) +} + +pub fn generate_featured_url(actor_id: &DbUrl) -> Result { + Ok(Url::parse(&format!("{actor_id}/featured"))?.into()) +} + +pub fn generate_moderators_url(community_id: &DbUrl) -> Result { + Ok(Url::parse(&format!("{community_id}/moderators"))?.into()) +} + +/// Sanitize HTML with default options. Additionally, dont allow bypassing markdown +/// links and images +pub fn sanitize_html(data: &str) -> String { + let sanitized = ammonia::Builder::default() + .rm_tags(&["a", "img"]) + .clean(data) + .to_string(); + // restore markdown quotes + sanitized.replace(">", ">") +} + +pub fn sanitize_html_opt(data: &Option) -> Option { + data.as_ref().map(|d| sanitize_html(d)) +} + +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + + use crate::utils::{honeypot_check, password_length_check, sanitize_html}; + + #[test] + #[rustfmt::skip] + fn password_length() { + assert!(password_length_check("Õ¼¾°3yË,o¸ãtÌÈú|ÇÁÙAøüÒI©·¤(T]/ð>æºWæ[C¤bªWöaÃÎñ·{=û³&§½K/c").is_ok()); + assert!(password_length_check("1234567890").is_ok()); + assert!(password_length_check("short").is_err()); + assert!(password_length_check("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooong").is_err()); + } + + #[test] + fn honeypot() { + assert!(honeypot_check(&None).is_ok()); + assert!(honeypot_check(&Some(String::new())).is_ok()); + assert!(honeypot_check(&Some("1".to_string())).is_err()); + assert!(honeypot_check(&Some("message".to_string())).is_err()); + } + + #[test] + fn test_sanitize_html() { + let sanitized = sanitize_html(" hello"); + assert_eq!(sanitized, " hello"); + let sanitized = sanitize_html(" test"); + assert_eq!(sanitized, " test"); + } }