fix reregister

Author: cjustinobi

src/auth/service.rs

@@ -1,4 +1,4 @@
-use crate::error::AppError;
+use crate::{error::AppError, models::UpdateUser};
 use crate::schema::users;
 use crate::utils::enums::Role;
 use crate::utils::helpers::generate_numeric_code;
@@ -26,7 +26,7 @@ use diesel::pg::PgConnection;
 use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation, TokenData};
 use serde::{Serialize, Deserialize};
 use uuid::Uuid;
-use chrono::Utc;
+use chrono::{DateTime, Utc};
 use chrono::Duration;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,36 +37,58 @@ pub struct Claims {
 
 pub fn create_user(
     conn: &mut PgConnection,
-    email: &str,
-    password: &str,
-    role: Role,
+    user_email: &str,
+    raw_password: &str,
+    user_role: Role,
 ) -> Result<User> {
+    use diesel::prelude::*;
+    use crate::schema::users::dsl::*;
 
-    // ---- Hash password using Argon2 ----
+    // Find soft-deleted user
+    let deleted = users
+        .filter(email.eq(user_email))
+        .filter(deleted_at.is_not_null())
+        .first::<User>(conn)
+        .optional()?;
+
+    // ---- Hash password ----
     let argon2 = Argon2::default();
     let salt = SaltString::generate(&mut OsRng);
 
-    let password_hash = argon2
-        .hash_password(password.as_bytes(), &salt)
+    let hashed_password = argon2
+        .hash_password(raw_password.as_bytes(), &salt)
         .map_err(|e| anyhow!("failed to hash password: {}", e))?
         .to_string();
 
-    // ---- Prepare new user struct ----
+    // ---- Restore soft-deleted user ----
+    if let Some(deleted_user) = deleted {
+        let restored = diesel::update(users.find(deleted_user.id))
+            .set((
+                password_hash.eq(&hashed_password),
+                role.eq(user_role),
+                deleted_at.eq::<Option<DateTime<Utc>>>(None), // ✅ FORCE NULL
+            ))
+            .returning(User::as_returning())
+            .get_result::<User>(conn)?;
+
+        return Ok(restored);
+    }
+
+    // ---- Insert new user ----
     let new_user = NewUser {
         first_name: "",
         last_name: "",
-        email,
+        email: user_email,
         phone: None,
         gender: None,
         address: None,
         dob: None,
         image_url: None,
-        password_hash: &password_hash,
-        role,
+        password_hash: &hashed_password,
+        role: user_role,
     };
 
-    // ---- Insert and return the newly created user ----
-    let user = diesel::insert_into(users::table)
+    let user = diesel::insert_into(users)
         .values(&new_user)
         .returning(User::as_returning())
         .get_result::<User>(conn)?;

src/handlers/auth.rs

@@ -146,14 +146,52 @@ pub async fn register(
         .first::<User>(&mut conn)
         .optional()?;
 
-    if existing_user.is_some() {
-        return Err(AppError::UserAlreadyExists);
-    }
-
     let other_role = payload
     .role
     .parse::<Role>()?;
 
+    if let Some(user) = existing_user {
+        if user.deleted_at.is_some() {
+            if user.email_verified {
+                // Email already verified: send welcome back email instead
+                let mail_service = state.mail_service.clone();
+                let email_clone = user.email.clone();
+                tokio::spawn(async move {
+                    let _ = mail_service.send_notification(
+                        &email_clone,
+                        "Welcome back to HealthBridge",
+                        "<p>Welcome back! Your email is already verified.</p>",
+                        Some("Welcome back! Your email is already verified."),
+                    ).await;
+                });
+
+                let user = auth::create_user(
+                    &mut conn,
+                    &payload.email,
+                    &payload.password,
+                    other_role,
+                )?;
+
+                return Ok(ApiResponse::success_with_message(
+                    "Welcome back! Your email is already verified.",
+                    AuthResponse {
+                        token: "".to_string(),
+                        refresh_token: "".to_string(),
+                        user: user.into(),
+                    },
+                ));
+            } else {
+                return Err(AppError::UserAlreadyExists);
+            }
+        }
+    }
+
+    info!("User not deletedddd");
+
+    // let other_role = payload
+    // .role
+    // .parse::<Role>()?;
+
     let user = auth::create_user(
         &mut conn,
         &payload.email,

src/models.rs

@@ -76,6 +76,22 @@ pub struct NewUser<'a> {
     pub role: Role,
 }
 
+#[derive(AsChangeset)]
+#[diesel(table_name = users)]
+pub struct UpdateUser<'a> {
+    pub first_name: &'a str,
+    pub last_name: &'a str,
+    pub phone: Option<&'a str>,
+    pub gender: Option<Gender>,
+    pub address: Option<&'a str>,
+    pub dob: Option<NaiveDate>,
+    pub image_url: Option<&'a str>,
+    pub password_hash: &'a str,
+    pub role: Role,
+    pub deleted_at: Option<DateTime<Utc>>,
+}
+
+
 #[derive(Debug, Queryable, Selectable, Identifiable)]
 #[diesel(table_name = email_verification_tokens)]
 #[diesel(check_for_backend(diesel::pg::Pg))]