X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapi_crud%2Fsrc%2Fuser%2Fcreate.rs;h=f2af6940e05867d6c92f846876401fc58c5c06b5;hb=3471f3533cb724b2cf6953d563aadfcc9f66c1d2;hp=0554da0557a9ccbf142451eb5f1f82e26151612b;hpb=63f54a3103684fd375428331f730b9a104add3a9;p=lemmy.git diff --git a/crates/api_crud/src/user/create.rs b/crates/api_crud/src/user/create.rs index 0554da05..f2af6940 100644 --- a/crates/api_crud/src/user/create.rs +++ b/crates/api_crud/src/user/create.rs @@ -11,105 +11,109 @@ use lemmy_api_common::{ honeypot_check, local_site_to_slur_regex, password_length_check, + sanitize_html, send_new_applicant_email_to_admins, send_verification_email, EndpointType, }, - websocket::handlers::captcha::CheckCaptcha, }; use lemmy_db_schema::{ aggregates::structs::PersonAggregates, source::{ - local_site::RegistrationMode, + captcha_answer::{CaptchaAnswer, CheckCaptchaAnswer}, local_user::{LocalUser, LocalUserInsertForm}, person::{Person, PersonInsertForm}, registration_application::{RegistrationApplication, RegistrationApplicationInsertForm}, }, traits::Crud, + RegistrationMode, }; use lemmy_db_views::structs::{LocalUserView, SiteView}; use lemmy_utils::{ claims::Claims, - error::LemmyError, + error::{LemmyError, LemmyErrorExt, LemmyErrorType}, utils::{ slurs::{check_slurs, check_slurs_opt}, validation::is_valid_actor_name, }, - ConnectionId, }; #[async_trait::async_trait(?Send)] impl PerformCrud for Register { type Response = LoginResponse; - #[tracing::instrument(skip(self, context, _websocket_id))] - async fn perform( - &self, - context: &Data, - _websocket_id: Option, - ) -> Result { + #[tracing::instrument(skip(self, context))] + async fn perform(&self, context: &Data) -> Result { let data: &Register = self; - let site_view = SiteView::read_local(context.pool()).await?; + let site_view = SiteView::read_local(&mut context.pool()).await?; let local_site = site_view.local_site; let require_registration_application = local_site.registration_mode == RegistrationMode::RequireApplication; if local_site.registration_mode == RegistrationMode::Closed { - return Err(LemmyError::from_message("registration_closed")); + return Err(LemmyErrorType::RegistrationClosed)?; } password_length_check(&data.password)?; honeypot_check(&data.honeypot)?; if local_site.require_email_verification && data.email.is_none() { - return Err(LemmyError::from_message("email_required")); + return Err(LemmyErrorType::EmailRequired)?; } if local_site.site_setup && require_registration_application && data.answer.is_none() { - return Err(LemmyError::from_message( - "registration_application_answer_required", - )); + return Err(LemmyErrorType::RegistrationApplicationAnswerRequired)?; } // Make sure passwords match if data.password != data.password_verify { - return Err(LemmyError::from_message("passwords_dont_match")); + return Err(LemmyErrorType::PasswordsDoNotMatch)?; } - // If the site is set up, check the captcha if local_site.site_setup && local_site.captcha_enabled { - let check = context - .chat_server() - .send(CheckCaptcha { - uuid: data.captcha_uuid.clone().unwrap_or_default(), - answer: data.captcha_answer.clone().unwrap_or_default(), - }) + if let Some(captcha_uuid) = &data.captcha_uuid { + let uuid = uuid::Uuid::parse_str(captcha_uuid)?; + let check = CaptchaAnswer::check_captcha( + &mut context.pool(), + CheckCaptchaAnswer { + uuid, + answer: data.captcha_answer.clone().unwrap_or_default(), + }, + ) .await?; - if !check { - return Err(LemmyError::from_message("captcha_incorrect")); + if !check { + return Err(LemmyErrorType::CaptchaIncorrect)?; + } + } else { + return Err(LemmyErrorType::CaptchaIncorrect)?; } } let slur_regex = local_site_to_slur_regex(&local_site); check_slurs(&data.username, &slur_regex)?; check_slurs_opt(&data.answer, &slur_regex)?; + let username = sanitize_html(&data.username); let actor_keypair = generate_actor_keypair()?; - if !is_valid_actor_name(&data.username, local_site.actor_name_max_length as usize) { - return Err(LemmyError::from_message("invalid_username")); - } + is_valid_actor_name(&data.username, local_site.actor_name_max_length as usize)?; let actor_id = generate_local_apub_endpoint( EndpointType::Person, &data.username, &context.settings().get_protocol_and_hostname(), )?; + if let Some(email) = &data.email { + if LocalUser::is_email_taken(&mut context.pool(), email).await? { + return Err(LemmyErrorType::EmailAlreadyExists)?; + } + } + // We have to create both a person, and local_user // Register the new person let person_form = PersonInsertForm::builder() - .name(data.username.clone()) + .name(username) .actor_id(Some(actor_id.clone())) .private_key(Some(actor_keypair.private_key)) .public_key(actor_keypair.public_key) @@ -121,9 +125,13 @@ impl PerformCrud for Register { .build(); // insert the person - let inserted_person = Person::create(context.pool(), &person_form) + let inserted_person = Person::create(&mut context.pool(), &person_form) .await - .map_err(|e| LemmyError::from_error_message(e, "user_already_exists"))?; + .with_lemmy_type(LemmyErrorType::UserAlreadyExists)?; + + // Automatically set their application as accepted, if they created this with open registration. + // Also fixes a bug which allows users to log in when registrations are changed to closed. + let accepted_application = Some(!require_registration_application); // Create the local user let local_user_form = LocalUserInsertForm::builder() @@ -131,25 +139,11 @@ impl PerformCrud for Register { .email(data.email.as_deref().map(str::to_lowercase)) .password_encrypted(data.password.to_string()) .show_nsfw(Some(data.show_nsfw)) + .accepted_application(accepted_application) + .default_listing_type(Some(local_site.default_post_listing_type)) .build(); - let inserted_local_user = match LocalUser::create(context.pool(), &local_user_form).await { - Ok(lu) => lu, - Err(e) => { - let err_type = if e.to_string() - == "duplicate key value violates unique constraint \"local_user_email_key\"" - { - "email_already_exists" - } else { - "user_already_exists" - }; - - // If the local user creation errored, then delete that person - Person::delete(context.pool(), inserted_person.id).await?; - - return Err(LemmyError::from_error_message(e, err_type)); - } - }; + let inserted_local_user = LocalUser::create(&mut context.pool(), &local_user_form).await?; if local_site.site_setup && require_registration_application { // Create the registration application @@ -159,12 +153,12 @@ impl PerformCrud for Register { answer: data.answer.clone().expect("must have an answer"), }; - RegistrationApplication::create(context.pool(), &form).await?; + RegistrationApplication::create(&mut context.pool(), &form).await?; } // Email the admins if local_site.application_email_admins { - send_new_applicant_email_to_admins(&data.username, context.pool(), context.settings()) + send_new_applicant_email_to_admins(&data.username, &mut context.pool(), context.settings()) .await?; } @@ -200,8 +194,13 @@ impl PerformCrud for Register { .clone() .expect("email was provided"); - send_verification_email(&local_user_view, &email, context.pool(), context.settings()) - .await?; + send_verification_email( + &local_user_view, + &email, + &mut context.pool(), + context.settings(), + ) + .await?; login_response.verify_email_sent = true; }