add another field in organisation_invite table, according to Kavika's feedback. Fix the backend accordingly.

Author: Peter Nguyen

backend/migrations/20251208090000_organisation_invites.sql

@@ -6,7 +6,10 @@ CREATE TABLE organisation_invites (
     expires_at TIMESTAMPTZ NOT NULL,
     used_at TIMESTAMPTZ,
     used_by BIGINT REFERENCES users(id) ON DELETE SET NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+    created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    invited_by_organisation_id BIGINT REFERENCES organisations(id) ON DELETE SET NULL
 );
 
-CREATE INDEX IDX_organisation_invites_org_email ON organisation_invites (organisation_id, email);
+CREATE INDEX IDX_organisation_invites_code ON organisation_invites (code);
+CREATE INDEX IDX_organisation_invites_organisation_id ON organisation_invites (organisation_id);
+CREATE INDEX IDX_organisation_invites_email ON organisation_invites (email);

backend/server/src/handler/invite.rs

@@ -1,79 +1,111 @@
+use crate::models::app::AppMessage;
+use crate::models::auth::AuthUser;
 use crate::models::error::ChaosError;
-use sqlx::Postgres;
-use chrono::Utc;
 use crate::models::invite::Invite;
+use crate::models::organisation::Organisation;
 use crate::models::transaction::DBTransaction;
+use axum::extract::Path;
 use axum::response::IntoResponse;
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+use sqlx::query;
+use std::ops::DerefMut;
 
 
 /// Handler for invite-related HTTP requests.
 pub struct InviteHandler;
 
 impl InviteHandler {
-    /// Validates whether an invite code is still valid (i.e. not expired).
+    /// Gets invite details for a given invite code.
     ///
     /// # Arguments
     ///
-    /// * `code` - The invite code to validate
-    /// * `transaction` - Database transaction to use
+    /// * `transaction` - Database transaction
+    /// * `code` - Invite code
     ///
     /// # Returns
     ///
-    /// * `Result<Invite, ChaosError>` - `Ok(invite)` if valid, `Err` if lookup fails
-    pub async fn validate_invite_is_valid(
-        code: &str,
-        transaction: &mut Transaction<'_, Postgres>,
-    ) -> Result<Invite, ChaosError> {
-        let invite = Invite::get(code, transaction).await?;
-        // check if the invite has already been used
-        if invite.used_at.is_some() {
-            return Err(ChaosError::BadRequestWithMessage(
-                "Invite already used".to_string(),
-            ));
-        }
-        // check if the invite has expired
-        if invite.expires_at <= Utc::now() {
-            return Err(ChaosError::BadRequestWithMessage(
-                "Invite expired".to_string(),
-            ));
-        }
-        Ok(invite)
+    /// * `Result<impl IntoResponse, ChaosError>` - Invite details or error
+    pub async fn get(
+        mut transaction: DBTransaction<'_>,
+        Path(code): Path<String>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let invite = Invite::get_by_code(&code, &mut transaction.tx).await?;
+        let org = query!(
+            "SELECT name FROM organisations WHERE id = $1",
+            invite.organisation_id
+        )
+        .fetch_one(transaction.tx.deref_mut())
+        .await?;
+
+        // Include derived booleans expected by the frontend.
+        let details = InviteDetails {
+            organisation_id: invite.organisation_id,
+            organisation_name: org.name,
+            email: invite.email,
+            expires_at: invite.expires_at,
+            used: invite.used_at.is_some(),
+            expired: invite.expires_at <= Utc::now(),
+            invited_by_organisation_id: invite.invited_by_organisation_id,
+        };
+
+        transaction.tx.commit().await?;
+        Ok(AppMessage::OkMessage(details))
     }
-    
 
-    /// Uses an invite code for a user.
+    /// Accepts an invite for the current authenticated user.
     ///
-    /// Validates the invite, marks it as used by the given user
+    /// Validates the invite is not expired/used, then marks it as used.
     ///
     /// # Arguments
     ///
-    /// * `code` - The invite code being redeemed
-    /// * `user_id` - The ID of the user redeeming the invite
-    /// * `transaction` - Database transaction to use
+    /// * `transaction` - Database transaction
+    /// * `code` - Invite code
+    /// * `user` - Authenticated user
     ///
     /// # Returns
     ///
-    /// * `Result<impl IntoResponse, ChaosError>` - `Ok(())` if the invite was used; `Err` if the invite is invalid
+    /// * `Result<impl IntoResponse, ChaosError>` - Success message or error
     pub async fn use_invite(
-        code: &str,
-        user_id: i64,
-        transaction: &mut Transaction<'_, Postgres>,
+        mut transaction: DBTransaction<'_>,
+        Path(code): Path<String>,
+        user: AuthUser,
     ) -> Result<impl IntoResponse, ChaosError> {
+        let invite = Invite::get_by_code(&code, &mut transaction.tx).await?;
 
-        let invite = Self::validate_invite_is_valid(code, transaction).await?;
+        // Validate the invite is not already used or expired.
+        if invite.used_at.is_some() {
+            return Err(ChaosError::BadRequestWithMessage("Invite already used".to_string()));
+        }
+        if invite.expires_at <= Utc::now() {
+            return Err(ChaosError::BadRequestWithMessage("Invite expired".to_string()));
+        }
 
-        Invite::save_used_by_person(user_id, &invite, transaction).await?;
+        // Add the user to the organisation.
+        Organisation::add_user(invite.organisation_id, user.user_id, &mut transaction.tx).await?;
 
-        transaction.tx.commit().await?;
+        // Mark the invite as used.
+        Invite::mark_used(&code, user.user_id, invite.invited_by_organisation_id, &mut transaction.tx).await?;
 
-        Ok((StatusCode::OK, AppMessage::OkMessage("Invite used successfully")))
+        transaction.tx.commit().await?;
+        Ok(AppMessage::OkMessage("Invite accepted successfully"))
     }
 
-    pub async fn get_code_by_id(
-        invite_id: i64,
-        transaction: &mut DBTransaction<'_>,
-    ) -> Result<String, ChaosError> {
-        let invite = Invite::get(invite_id, &mut transaction.tx).await?;
-        Ok(invite.code)
-    }
+    
+}
+
+/// Response payload for invite details expected by the frontend.
+#[derive(Serialize)]
+pub struct InviteDetails {
+    #[serde(serialize_with = "crate::models::serde_string::serialize")]
+    pub organisation_id: i64,
+    pub organisation_name: String,
+    pub email: String,
+    pub expires_at: DateTime<Utc>,
+    pub used: bool,
+    pub expired: bool,
+    /// ID of the organisation that invited the user
+    #[serde(serialize_with = "crate::models::serde_string::serialize_option")]
+    #[serde(deserialize_with = "crate::models::serde_string::deserialize_option")]
+    pub invited_by_organisation_id: Option<i64>
 }

backend/server/src/handler/mod.rs

@@ -11,6 +11,7 @@
 //! - `email_template`: Processes email template requests
 //! - `offer`: Handles offer-related requests
 //! - `organisation`: Processes organisation-related requests
+//! - `invite`: Handles invite-related requests
 //! - `question`: Handles question-related requests
 //! - `rating`: Processes rating-related requests
 //! - `role`: Handles role-related requests
@@ -23,6 +24,7 @@ pub mod campaign;
 pub mod email_template;
 pub mod offer;
 pub mod organisation;
+pub mod invite;
 pub mod question;
 pub mod rating;
 pub mod role;

backend/server/src/handler/organisation.rs

@@ -360,13 +360,20 @@ impl OrganisationHandler {
         mut transaction: DBTransaction<'_>,
         Path(id): Path<i64>,
         _admin: OrganisationAdmin,
-        State(state): State<AppState>,
+        State(mut state): State<AppState>,
         Json(request_body): Json<MemberToInvite>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        Organisation::invite_user(id, request_body.email, state.email_credentials, &mut transaction.tx).await?;
+        let invite_code = Organisation::invite_user(
+            id,
+            request_body.email,
+            state.email_credentials.clone(),
+            &mut state.snowflake_generator,
+            &mut transaction.tx,
+        )
+        .await?;
 
         transaction.tx.commit().await?;
-        Ok(AppMessage::OkMessage("Successfully invited user to organisation"))
+        Ok(AppMessage::OkMessage(invite_code))
     }
 
     /// Updates an organisation's logo.

backend/server/src/models/app.rs

@@ -428,28 +428,13 @@ pub async fn app() -> Result<Router, ChaosError> {
         )
 
         // Invite routes
+        // - GET  /api/v1/invite/:code  -> invite details
+        // - POST /api/v1/invite/:code  -> accept invite
         .route(
-            "/api/v1/invite/:invite_id",
-            get(InviteHandler::get),
-        )
-        .route(
-            "/api/v1/invite/:invite_id/delete",
-            delete(InviteHandler::delete),
-        )
-        .route(
-            "/api/v1/invite/:invite_id/create",
-            post(InviteHandler::create),
-        )
-
-        .route(
-            "/api/v1/invite/:invite_id/use",
-            post(InviteHandler::use_invite),
+            "/api/v1/invite/:code", get(InviteHandler::get).post(InviteHandler::use_invite)
         )
 
-        .route(
-            "/api/v1/invite/:invite_id/get_code",
-            get(InviteHandler::get_code_by_id),
-        )
+        
 
 
         .layer(cors)