X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapi_common%2Fsrc%2Futils.rs;h=f3cebebd24d4487029c6d33e9abdec268373525e;hb=70fae9d68d65b1e4d153e30d3c065cc315b75eaf;hp=3aaf1972940c2f57d9778166d26f71b27e9d7824;hpb=6f3bf4634b0e1cf529c4683d6ee971917e2bfa50;p=lemmy.git diff --git a/crates/api_common/src/utils.rs b/crates/api_common/src/utils.rs index 3aaf1972..f3cebebd 100644 --- a/crates/api_common/src/utils.rs +++ b/crates/api_common/src/utils.rs @@ -1,11 +1,17 @@ -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, CommentUpdateForm}, - community::{Community, CommunityUpdateForm}, + community::{Community, CommunityModerator, CommunityUpdateForm}, email_verification::{EmailVerification, EmailVerificationForm}, instance::Instance, local_site::LocalSite, @@ -15,16 +21,12 @@ use lemmy_db_schema::{ person_block::PersonBlock, post::{Post, PostRead, PostReadForm}, registration_application::RegistrationApplication, - secret::Secret, }, 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, @@ -33,81 +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::{build_slur_regex, 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; +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 = 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 { +pub async fn get_post(post_id: PostId, pool: &mut DbPool<'_>) -> Result { Post::read(pool, post_id) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post")) + .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 }; PostRead::mark_as_read(pool, &post_read_form) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read")) + .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 }; PostRead::mark_as_unread(pool, &post_read_form) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read")) + .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 = LocalUserView::read(pool, 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, @@ -119,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, @@ -126,50 +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 = LocalUserSettingsView::read(pool, 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, @@ -177,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(()) @@ -192,13 +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 = CommunityPersonBanView::get(pool, person_id, community_id) .await .is_ok(); if is_banned { - Err(LemmyError::from_message("community_ban")) + Err(LemmyErrorType::BannedFromCommunity)? } else { Ok(()) } @@ -207,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 = Community::read(pool, community_id) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?; + .with_lemmy_type(LemmyErrorType::CouldntFindCommunity)?; if community.deleted || community.removed { - Err(LemmyError::from_message("deleted")) + Err(LemmyErrorType::Deleted)? } else { Ok(()) } @@ -221,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(()) } @@ -231,13 +235,13 @@ 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 = PersonBlock::read(pool, potential_blocker_id, my_id) .await .is_ok(); if is_blocked { - Err(LemmyError::from_message("person_block")) + Err(LemmyErrorType::PersonIsBlocked)? } else { Ok(()) } @@ -246,7 +250,7 @@ pub async fn check_person_block( #[tracing::instrument(skip_all)] pub fn check_downvotes_enabled(score: i16, local_site: &LocalSite) -> Result<(), LemmyError> { if score == -1 && !local_site.enable_downvotes { - return Err(LemmyError::from_message("downvotes_disabled")); + Err(LemmyErrorType::DownvotesAreDisabled)?; } Ok(()) } @@ -257,7 +261,7 @@ pub fn check_private_instance( local_site: &LocalSite, ) -> Result<(), LemmyError> { if local_user_view.is_none() && local_site.private_instance { - return Err(LemmyError::from_message("instance_is_private")); + Err(LemmyErrorType::InstanceIsPrivate)?; } Ok(()) } @@ -265,17 +269,15 @@ pub fn check_private_instance( #[tracing::instrument(skip_all)] pub async fn build_federated_instances( local_site: &LocalSite, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result, LemmyError> { if local_site.federation_enabled { // TODO I hate that this requires 3 queries - let linked = Instance::linked(pool).await?; - let allowed = Instance::allowlist(pool).await?; - let blocked = Instance::blocklist(pool).await?; - - // These can return empty vectors, so convert them to options - let allowed = (!allowed.is_empty()).then_some(allowed); - let blocked = (!blocked.is_empty()).then_some(blocked); + let (linked, allowed, blocked) = lemmy_db_schema::try_join_with_pool!(pool => ( + Instance::linked, + Instance::allowlist, + Instance::blocklist + ))?; Ok(Some(FederatedInstances { linked, @@ -290,16 +292,7 @@ pub async fn build_federated_instances( /// Checks the password length pub fn password_length_check(pass: &str) -> Result<(), LemmyError> { if !(10..=60).contains(&pass.chars().count()) { - 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")) + Err(LemmyErrorType::InvalidPassword)? } else { Ok(()) } @@ -307,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, @@ -331,7 +324,9 @@ pub fn send_email_to_user( &local_user_view.person.name, body, settings, - ) { + ) + .await + { Ok(_o) => _o, Err(e) => warn!("{}", e), }; @@ -340,16 +335,15 @@ 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; - PasswordResetRequest::create_token(pool, local_user_id, &token2).await?; + PasswordResetRequest::create_token(pool, local_user_id, token.clone()).await?; let email = &user.local_user.email.clone().expect("email"); let lang = get_interface_language(user); @@ -357,20 +351,20 @@ pub async fn send_password_reset_email( 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/{}", @@ -382,27 +376,16 @@ pub async fn send_verification_email( 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.clone().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) } @@ -445,7 +428,14 @@ pub fn local_site_opt_to_slur_regex(local_site: &Option) -> 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> { @@ -453,17 +443,17 @@ pub fn send_application_approved_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 = LocalUserSettingsView::list_admins_with_emails(pool).await?; + let admins = LocalUserView::list_admins_with_emails(pool).await?; let applications_link = &format!( "{}/registration_applications", @@ -473,9 +463,31 @@ pub async fn send_new_applicant_email_to_admins( 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_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(()) } @@ -483,9 +495,10 @@ pub async fn send_new_applicant_email_to_admins( pub async fn check_registration_application( local_user_view: &LocalUserView, local_site: &LocalSite, - pool: &DbPool, + pool: &mut DbPool<'_>, ) -> Result<(), LemmyError> { - if local_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 { @@ -494,10 +507,12 @@ pub async fn check_registration_application( 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(()) @@ -507,16 +522,14 @@ pub fn check_private_instance_and_federation_enabled( local_site: &LocalSite, ) -> Result<(), LemmyError> { if local_site.private_instance && local_site.federation_enabled { - return Err(LemmyError::from_message( - "Cannot have both private instance and 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> { @@ -539,7 +552,7 @@ pub async fn purge_image_posts_for_person( pub async fn purge_image_posts_for_community( banned_community_id: CommunityId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { @@ -562,7 +575,7 @@ pub async fn purge_image_posts_for_community( pub async fn remove_user_data( banned_person_id: PersonId, - pool: &DbPool, + pool: &mut DbPool<'_>, settings: &Settings, client: &ClientWithMiddleware, ) -> Result<(), LemmyError> { @@ -646,21 +659,20 @@ 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 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 = CommentQuery::builder() - .pool(pool) - .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; @@ -677,7 +689,7 @@ 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> { @@ -698,33 +710,111 @@ pub async fn delete_user_account( // Comments Comment::permadelete_for_creator(pool, person_id) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?; + .with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?; // Posts Post::permadelete_for_creator(pool, person_id) .await - .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?; + .with_lemmy_type(LemmyErrorType::CouldntUpdatePost)?; // Purge image posts purge_image_posts_for_person(person_id, pool, settings, client).await?; + // Leave communities they mod + CommunityModerator::leave_all_communities(pool, person_id).await?; + Person::delete_account(pool, person_id).await?; Ok(()) } -pub fn listing_type_with_site_default( - listing_type: Option, - local_site: &LocalSite, -) -> Result { - Ok(listing_type.unwrap_or(ListingType::from_str( - &local_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 { - use crate::utils::password_length_check; + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + + use crate::utils::{honeypot_check, password_length_check, sanitize_html}; #[test] #[rustfmt::skip] @@ -734,4 +824,20 @@ mod tests { 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"); + } }