Adds some validation to new user registration.

backend/src/api.rs

@@ -1,3 +1,4 @@
+use validator::ValidateArgs;
 use crate::AppConfig;
 use rocket::request::Outcome;
 use jsonwebtoken::decode;
@@ -141,7 +142,17 @@ pub async fn gamenight_post_json(conn: DbConn, user: Option<schema::User>, gamen
 
 #[post("/register", format = "application/json", data = "<register_json>")]
 pub async fn register_post_json(conn: DbConn, register_json: Json<schema::Register>) -> ApiResponseVariant  {
-    match schema::insert_user(conn, register_json.into_inner()).await {
+
+    let register = register_json.into_inner();
+    let register_clone = register.clone();
+    match conn.run(move |c| {
+        register_clone.validate_args((c,c))
+    }).await {
+        Ok(()) => (),
+        Err(error) => return ApiResponseVariant::Value(json!(ApiResponse::error(error.to_string())))
+    }
+    
+    match schema::insert_user(conn, register).await {
         Ok(_) => ApiResponseVariant::Value(json!(ApiResponse::SUCCES)),
         Err(err) => ApiResponseVariant::Value(json!(ApiResponse::error(err.to_string())))
     }

backend/src/schema.rs

@@ -1,3 +1,5 @@
+use diesel::dsl::count;
+use std::ops::Deref;
 use argon2::PasswordVerifier;
 use argon2::PasswordHash;
 use diesel_derive_enum::DbEnum;
@@ -17,10 +19,19 @@ use argon2::{
     Argon2
 };
 use argon2::password_hash::SaltString;
+use validator::{Validate, ValidationError};
 
 #[database("gamenight_database")]
 pub struct DbConn(diesel::SqliteConnection);
 
+impl Deref for DbConn {
+    type Target = rocket_sync_db_pools::Connection<DbConn, diesel::SqliteConnection>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 table! {
     gamenight (id) {
         id -> Integer,
@@ -183,6 +194,28 @@ pub async fn get_user(conn: DbConn, id: i32) -> User {
     }).await
 }
 
+pub fn unique_username(username: &String, conn: &diesel::SqliteConnection) -> Result<(), ValidationError> {    
+    match user::table
+        .select(count(user::username))
+        .filter(user::username.eq(username))
+        .execute(conn) {
+            Ok(0) => Ok(()),
+            Ok(_) => Err(ValidationError::new("User already exists")),
+            Err(_) => Err(ValidationError::new("Database error while validating user"))
+        }
+}
+
+pub fn unique_email(email: &String, conn: &diesel::SqliteConnection) -> Result<(), ValidationError> {
+    match user::table
+        .select(count(user::email))
+        .filter(user::email.eq(email))
+        .execute(conn) {
+            Ok(0) => Ok(()),
+            Ok(_) => Err(ValidationError::new("email already exists")),
+            Err(_) => Err(ValidationError::new("Database error while validating email"))
+        }
+}
+
 pub async fn run_migrations(rocket: Rocket<Build>) -> Rocket<Build> {
     // This macro from `diesel_migrations` defines an `embedded_migrations`
     // module containing a function named `run`. This allows the example to be
@@ -236,10 +269,13 @@ pub struct GameNight {
     pub datetime : String, 
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Validate, Clone)]
 pub struct Register {
+    #[validate(length(min = 1), custom( function = "unique_username", arg = "&'v_a diesel::SqliteConnection"))]
     pub username: String,
+    #[validate(email, custom( function = "unique_email", arg = "&'v_a diesel::SqliteConnection"))]
     pub email: String,
+    #[validate(length(min = 10), must_match = "password_repeat")]
     pub password: String,
     pub password_repeat: String,
 }