Added code

src/callers/register.rs

@@ -1,6 +1,5 @@
 use axum::{Json, http::StatusCode};
 
-use crate::models;
 use crate::repo;
 
 pub mod request {
@@ -26,12 +25,10 @@ pub mod request {
 pub mod response {
     use serde::{Deserialize, Serialize};
 
-    use crate::models;
-
     #[derive(Deserialize, Serialize)]
     pub struct Response {
         pub message: String,
-        pub data: Vec<models::common::User>,
+        pub data: Vec<icarus_models::user::User>,
     }
 }
 
@@ -39,10 +36,18 @@ pub async fn register_user(
     axum::Extension(pool): axum::Extension<sqlx::PgPool>,
     Json(payload): Json<request::Request>,
 ) -> (StatusCode, Json<response::Response>) {
-    let mut user = models::common::User {
+    let mut user = icarus_models::user::User {
         id: uuid::Uuid::nil(),
         username: payload.username.clone(),
         password: payload.password.clone(),
+        email: payload.email.clone(),
+        phone: payload.phone.clone(),
+        firstname: payload.firstname.clone(),
+        lastname: payload.lastname.clone(),
+        status: String::from("Active"),
+        email_verified: true,
+        date_created: String::from("2025-01-01 12:00:00"),
+        last_login: String::from("nil"),
     };
 
     match repo::user::insert(&pool, &user).await {

src/repo/mod.rs

@@ -1,20 +1,64 @@
 pub mod user {
-    use crate::models;
+    // use crate::models;
+    // use serde::Serialize;
+
+    #[derive(Debug, serde::Serialize, sqlx::FromRow)]
+    pub struct InsertedData {
+        pub id: uuid::Uuid,
+        pub date_created: Option<time::OffsetDateTime>,
+        // pub email: String,
+    }
 
     pub async fn insert(
         pool: &sqlx::PgPool,
-        user: &models::common::User,
+        user: &icarus_models::user::User,
     ) -> Result<uuid::Uuid, sqlx::Error> {
-        let insert_sql = "INSERT INTO \"user\" (username, password) VALUES ($1, $2) RETURNING id";
+        let result = sqlx::query_as!(
+            InsertedData,
+            r#"
+                INSERT INTO "user" (username, password, email, phone, firstname, lastname, email_verified, status, date_created) 
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW())
+                RETURNING id, date_created;
+            "#,
+            &user.username, // Bind the input message securely
+            &user.password,
+            &user.email,
+            &user.phone,
+            &user.firstname,
+            &user.lastname,
+            user.email_verified,
+            user.status
+        )
+        .fetch_one(pool)
+        .await
+        .map_err(|e| {
+            eprintln!("Error inserting item: {}", e);
+            e
+        });
+
+        match result {
+            Ok(id) => Ok(id.id),
+            Err(err) => Err(err),
+        }
+
+        /*
+        let insert_sql = "INSERT INTO \"user\" (username, password, email, phone, firstname, lastname, email_verified, status) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id";
 
         match sqlx::query_scalar(insert_sql)
             .bind(&user.username) // Bind the input message securely
             .bind(&user.password)
+            .bind(&user.email)
+            .bind(&user.phone)
+            .bind(&user.firstname)
+            .bind(&user.lastname)
+            .bind(user.email_verified)
+            .bind(&user.status)
             .fetch_one(pool) // Execute and expect exactly ONE row with ONE column back
             .await
         {
             Ok(o) => Ok(o),
             Err(err) => Err(err), // _ => uuid::Uuid::nil(),
         }
+        */
     }
 }