Fixes the ugly Register User post handler.

backend-actix/src/main.rs

@@ -1,5 +1,6 @@
 pub mod request;
 pub mod schema;
+pub mod util;
 
 use actix_web::HttpServer;
 use actix_web::App;
@@ -13,7 +14,6 @@ pub(crate) type DbPool = Pool<ConnectionManager<PgConnection>>;
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-
     let url = "postgres://root:root@localhost/gamenight";
     let manager = ConnectionManager::<PgConnection>::new(url);
     // Refer to the `r2d2` documentation for more methods to use

backend-actix/src/request/gamenight_handlers.rs

@@ -1,10 +1,16 @@
 use actix_web::{get, web, Responder, http::header::ContentType, HttpResponse, post};
 use chrono::{DateTime, ParseError};
-
-use crate::{DbPool, request::{error::ApiError, responses::GameNightResponse, requests::{GamenightPost, GamenightGet}, util::GetPgConnection}, schema::{self, user::User}};
-
 use uuid::Uuid;
 
+use crate::schema::{self};
+use crate::schema::user::User;
+use crate::request::requests::GamenightGet;
+use crate::request::requests::GamenightPost;
+use crate::request::responses::GameNightResponse;
+use crate::request::error::ApiError;
+use crate::DbPool;
+use crate::util::GetConnection;
+
 impl GamenightPost {
     pub fn into_with_user(&self, user: User) -> Result<schema::gamenight::Gamenight, ParseError> {
         return Ok(schema::gamenight::Gamenight {

backend-actix/src/request/mod.rs

@@ -5,7 +5,6 @@ mod user_handlers;
 mod gamenight_handlers;
 mod error;
 mod authorization;
-mod util;
 
 pub use user_handlers::login;
 pub use user_handlers::register;

backend-actix/src/request/requests.rs

@@ -1,5 +1,8 @@
 use serde::{Serialize, Deserialize};
 use validator::Validate;
+use diesel::PgConnection;
+use diesel::r2d2::ConnectionManager;
+use diesel::r2d2::Pool;
 
 use crate::schema::user::{unique_email, unique_username};
 
@@ -13,12 +16,12 @@ pub struct Login {
 pub struct Register {
     #[validate(
         length(min = 1),
-        custom(function = "unique_username", arg = "&'v_a mut diesel::PgConnection")
+        custom(function = "unique_username", arg = "&'v_a Pool<ConnectionManager<PgConnection>>")
     )]
     pub username: String,
     #[validate(
         email,
-        custom(function = "unique_email", arg = "&'v_a mut diesel::PgConnection")
+        custom(function = "unique_email", arg = "&'v_a Pool<ConnectionManager<PgConnection>>")
     )]
     #[validate(email)]
     pub email: String,

backend-actix/src/request/user_handlers.rs

@@ -7,7 +7,7 @@ use crate::request::requests::{Login, Register};
 use crate::request::error::ApiError;
 use crate::request::responses::LoginResponse;
 use crate::request::authorization::get_token;
-use crate::request::util::GetPgConnection;
+use crate::util::GetConnection;
 use crate::schema::{self};
 use serde_json;
 
@@ -30,8 +30,6 @@ impl Into<schema::user::Register> for Register {
     }
 }
 
-
-
 #[get("/token")]
 pub async fn login(pool: web::Data<DbPool>, login_data: web::Json<Login>) -> Result<impl Responder, ApiError> {
     let data = login_data.into_inner();
@@ -57,19 +55,12 @@ pub async fn login(pool: web::Data<DbPool>, login_data: web::Json<Login>) -> Res
 
 #[post("/user")]
 pub async fn register(pool: web::Data<DbPool>, register_data: web::Json<Register>) -> Result<impl Responder, ApiError> {
-    let data1 = register_data.clone();
-    let data2 = register_data.clone();
-    let register_request = data2.into();
-    let mut conn1 = pool.get_conn();
-    let mut conn2 = pool.get_conn();
-
-    let _validation_result = web::block(move || {
-        data1.validate_args((&mut conn1, &mut conn2))
-    }).await??;
-
-    let mut conn3 = pool.get_conn();
-    let _register_result = web::block(move || {
-        schema::register(&mut conn3, register_request)
+    web::block(move || -> Result<(), ApiError> {
+        register_data.validate_args((&pool, &pool))?;
+        let register_request = register_data.into_inner().into();
+        let mut conn = pool.get_conn();
+        schema::register(&mut conn, register_request)?;
+        Ok(())
     }).await??;
 
     return Ok(HttpResponse::Ok())

backend-actix/src/request/util.rs

@@ -1,14 +0,0 @@
-use actix_web::web;
-use diesel::{r2d2::{PooledConnection, ConnectionManager}, PgConnection};
-
-use crate::DbPool;
-
-pub trait GetPgConnection {
-    fn get_conn(&self) -> PooledConnection<ConnectionManager<PgConnection>>;
-}
-
-impl GetPgConnection for web::Data<DbPool> {
-    fn get_conn(&self) -> PooledConnection<ConnectionManager<PgConnection>> {
-        self.get().expect("couldn't get db connection from pool")
-    }
-}

backend-actix/src/schema/user.rs

@@ -11,6 +11,9 @@ use argon2::{
     Argon2,
 };
 use validator::ValidationError;
+use crate::DbPool;
+use crate::util::GetConnection;
+
 use super::schema::{pwd, users};
 
 pub use super::error::DatabaseError;
@@ -89,11 +92,13 @@ pub fn get_user(conn: &mut PgConnection, id: Uuid) -> Result<User, DatabaseError
     Ok(users::table.find(id).first(conn)?)
 }
 
-pub fn unique_username(username: &String, conn: &mut PgConnection) -> Result<(), ValidationError> {
+pub fn unique_username(username: &String, pool: &DbPool) -> Result<(), ValidationError> {
+    let mut conn = pool.get().expect("Couldn't get db connection from pool");
+
     match users::table
         .count()
         .filter(users::username.eq(username))
-        .get_result(conn)
+        .get_result(&mut conn)
     {
         Ok(0) => Ok(()),
         Ok(_) => Err(ValidationError::new("User already exists")),
@@ -101,11 +106,13 @@ pub fn unique_username(username: &String, conn: &mut PgConnection) -> Result<(),
     }
 }
 
-pub fn unique_email(email: &String, conn: &mut PgConnection) -> Result<(), ValidationError> {
+pub fn unique_email(email: &String, pool: &DbPool) -> Result<(), ValidationError> {
+    let mut conn = pool.get_conn();
+
     match users::table
         .count()
         .filter(users::email.eq(email))
-        .get_result(conn)
+        .get_result(&mut conn)
     {
         Ok(0) => Ok(()),
         Ok(_) => Err(ValidationError::new("email already exists")),

backend-actix/src/util/mod.rs

@@ -0,0 +1,11 @@
+use diesel::{r2d2::{PooledConnection, ManageConnection, Pool}};
+
+pub trait GetConnection<T> where T: ManageConnection {
+    fn get_conn(&self) -> PooledConnection<T>;
+}
+
+impl<T: ManageConnection> GetConnection<T> for Pool<T> {
+    fn get_conn(&self) -> PooledConnection<T> {
+        self.get().expect("Couldn't get db connection from pool")
+    }
+}