132 lines
3.4 KiB
Rust
132 lines
3.4 KiB
Rust
use std::{sync::mpsc::Sender, time::SystemTime};
|
|
|
|
use crate::{
|
|
db::{insert_new_user, DbPool, NewUserEntity, UserEntity},
|
|
models::{ApiResponse, AppError, Session},
|
|
requests::AppState,
|
|
services::{
|
|
self, auth_token::generate_new_user_token, hash_password, CachePool,
|
|
UserConfirmationMessage,
|
|
},
|
|
};
|
|
use axum::{
|
|
debug_handler,
|
|
extract::State,
|
|
response::{IntoResponse, Response},
|
|
Json,
|
|
};
|
|
use http::StatusCode;
|
|
use pasetors::{keys::SymmetricKey, version4::V4};
|
|
use tracing::debug;
|
|
|
|
use super::models::{UserRegistrationRequest, UserRegistrationResponse};
|
|
|
|
#[debug_handler]
|
|
pub async fn user_registration_post_handler(
|
|
State(state): State<AppState>,
|
|
Json(request): Json<UserRegistrationRequest>,
|
|
) -> Result<Response, AppError> {
|
|
let config = state.config();
|
|
let mail_sender = state.mail_sender();
|
|
|
|
register_new_user_request(
|
|
request,
|
|
state.db_pool(),
|
|
state.cache_pool(),
|
|
config.secrets().token_key(),
|
|
config.mail().send_verification_email,
|
|
mail_sender,
|
|
)
|
|
.await
|
|
}
|
|
|
|
async fn register_new_user_request(
|
|
body: UserRegistrationRequest,
|
|
db_pool: &DbPool,
|
|
cache_pool: &CachePool,
|
|
signing_key: &SymmetricKey<V4>,
|
|
send_verification_email: bool,
|
|
email_sender: &Sender<UserConfirmationMessage>,
|
|
) -> Result<Response, AppError> {
|
|
debug!(?body, send_verification_email);
|
|
|
|
let UserRegistrationRequest {
|
|
email,
|
|
password,
|
|
name,
|
|
} = body;
|
|
|
|
let hashed_password = hash_password(password);
|
|
|
|
let new_user = NewUserEntity {
|
|
email,
|
|
password: hashed_password.to_string(),
|
|
name,
|
|
};
|
|
|
|
let UserEntity {
|
|
id: user_id,
|
|
name,
|
|
email,
|
|
..
|
|
} = insert_new_user(db_pool, new_user).await.map_err(|err| {
|
|
if err.is_duplicate_record() {
|
|
AppError::duplicate_record(
|
|
"There is already an account associated with this email address.",
|
|
)
|
|
} else {
|
|
err
|
|
}
|
|
})?;
|
|
|
|
let (verification_token, token_id, expires_at) = generate_new_user_token(signing_key, user_id);
|
|
|
|
let new_user_session = Session {
|
|
user_id,
|
|
created_at: SystemTime::now(),
|
|
expires_at,
|
|
};
|
|
|
|
let expires_in = expires_at.duration_since(SystemTime::now()).unwrap();
|
|
services::user_session::store_user_session(
|
|
cache_pool,
|
|
token_id,
|
|
new_user_session,
|
|
Some(expires_in),
|
|
)
|
|
.await?;
|
|
|
|
let response_body = if send_verification_email {
|
|
let new_user_confirmation_message = UserConfirmationMessage {
|
|
email,
|
|
name,
|
|
user_id,
|
|
verification_token: verification_token.clone(),
|
|
};
|
|
|
|
let _ = email_sender
|
|
.send(new_user_confirmation_message)
|
|
.inspect_err(|err| {
|
|
eprintln!("Got the rollowing error while sending across the channel: {err}");
|
|
});
|
|
|
|
UserRegistrationResponse {
|
|
user_id,
|
|
expires_at: None,
|
|
session_token: None,
|
|
}
|
|
} else {
|
|
UserRegistrationResponse {
|
|
user_id,
|
|
expires_at: Some(expires_at),
|
|
session_token: Some(verification_token),
|
|
}
|
|
};
|
|
|
|
let response = (
|
|
StatusCode::CREATED,
|
|
ApiResponse::new(response_body).into_json_response(),
|
|
);
|
|
|
|
Ok(response.into_response())
|
|
}
|