Application answering page (#640)

* initial nextjs setup

* rename "Resume Application" -> "Continue Application"

* update frontend-nextjs/.gitignore

* Update bun.lock

* setup server-side auth functions

* basic sidebar

* setup i18n

* add common terms to dictionaries

* remove unused backend imports

* run rust build workflow on pulls to `CHAOS-571-integrate-be-fe`

* react query auth setup

* fetch user organisations for sidebar

* handle organisation change on dashboard

* setup basic dashboard campaigns page

* add data table to display campaigns

* dashboard campaign details page

* application review setup

* campaign details rearrange

* application review scaffold

* move application models

* application review component basics

* get, set and update application rating

* fix setting & updating application rating

* add `chaos.png`

* add buttons for publish & edit campaign questions

* Email templates UI (#608)

* initial devcontainer setup

* basic email template get, update and delete

* template creation ui

* remove error printing

* convert all plain text responses to `AppMessage`

* fix email template card margins

* wrap `params` prop type with `Promise<>`

* actions workflows for nextjs

* add @radix-ui/react-alert-dialog

* add @radix-ui/react-tabs

* only run workflows when relevant paths modified

* Update .gitignore

* Update .gitignore

* chopped drag and drop

* drag and drop less chopped

* less chopped drag and drop

* role tabs

* textbox

* refactor roleselector and switch to globals

* save role selection and fix frontend 404

* cleanups

* fix ranking(bit of vibe)

* fix role ordering

* run migration

* fix: make applicationanswer keep track of qanda states

* feat: refactor to prefetch answers

* feat: display questions inside card

* card submit

* fix: asterisk on required

* fix: get card to deactivate

* fix: shared answers now update in card

* feat: guard submitted applications from accessing the apply screen

* fix: do a pass to clean up some code

* feat: use dict across component

* fix: dropwdown clear works without bricking the backend on fetch, now need to refactor shortanswer and multiselect to simply delete answer

* style: fix no answer message

* feat: refactor empty question types to use delete answer

* fix: fix a few breaking changes caused by swapping over and in general

* fix: fix question type logic which broke when swapping over to the delete logic

* fix: bug fixes

* fix: role reordering behaviour

* fix: fix inconsistent redirect behaviour

* chore: regenerate bun thing

* merge: more merges + bug fixes

* feat: link answerpage component to campaign info component

* fix: wait for queries to be ready before repopulating qamap, (hopefully) avoiding races between updating shared questions and reviewcard

* chore: remove node_modules

* fix: cleanup file

* fix: stringify answers in application review page

Author: Plebbaroni

backend/migrations/20251218085416_max_roles_to_apply_for.sql

@@ -0,0 +1,3 @@
+-- Add migration script here
+ALTER TABLE campaigns
+ADD COLUMN max_roles_per_application integer;

backend/package-lock.json

@@ -87,6 +87,29 @@ impl ApplicationHandler {
     ) -> Result<impl IntoResponse, ChaosError> {
         let application = Application::get(application_id, admin.user_id, &mut transaction.tx).await?;
         transaction.tx.commit().await?;
+        Ok((StatusCode::OK, Json(application)))
+    }
+
+    /// Retrieves the details of a specific application regardless of submission status.
+    /// 
+    /// This handler allows regular applicants to view application details in the answer screen.
+    /// 
+    /// # Arguments
+    /// 
+    /// * `application_id` - The ID of the application to retrieve
+    /// * `_admin` - The authenticated user (must be an application admin)
+    /// * `transaction` - Database transaction
+    /// 
+    /// # Returns
+    /// 
+    /// * `Result<impl IntoResponse, ChaosError>` - Application details or error
+    pub async fn get_in_progress(
+        Path(application_id): Path<i64>,
+        user: AuthUser,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let application = Application::get_in_progress(application_id, user.user_id, &mut transaction.tx).await?;
+        transaction.tx.commit().await?;
         Ok(Json(application))
     }
 

backend/package.json

@@ -48,6 +48,24 @@ pub struct Answer {
     updated_at: DateTime<Utc>,
 }
 
+/// A view type which collects an answer in the system along with it's
+/// associated role.
+#[derive(Deserialize, Serialize)]
+pub struct AnswerWithRole {
+    #[serde(serialize_with = "crate::models::serde_string::serialize")]
+    id: i64,
+    /// ID of the question this answer is for
+    #[serde(serialize_with = "crate::models::serde_string::serialize")]
+    question_id: i64,
+
+    /// The actual answer data, flattened in serialization
+    #[serde(flatten)]
+    data: AnswerData,
+
+    // role ID
+    #[serde(serialize_with = "crate::models::serde_string::serialize")]
+    role_id: i64
+}
 /// Data structure for creating a new answer.
 /// 
 /// Contains the question ID and the answer data.
@@ -118,6 +136,16 @@ impl Answer {
     ) -> Result<i64, ChaosError> {
         data.validate()?;
 
+        sqlx::query!(
+            "
+                DELETE FROM answers
+                WHERE application_id = $1 AND question_id = $2
+            ",
+            application_id,
+            question_id
+        )
+        .execute(transaction.deref_mut())
+        .await?;
         let id = snowflake_generator.real_time_generate();
 
         sqlx::query!(
@@ -378,7 +406,9 @@ impl Answer {
         data: AnswerData,
         transaction: &mut Transaction<'_, Postgres>,
     ) -> Result<(), ChaosError> {
-        data.validate()?;
+        if !data.is_empty() {
+            data.validate()?;
+        }
 
         let answer = sqlx::query_as!(
             AnswerTypeApplicationId,
@@ -396,7 +426,9 @@ impl Answer {
         let old_data = AnswerData::from_question_type(&answer.question_type);
         old_data.delete_from_db(id, transaction).await?;
 
-        data.insert_into_db(id, transaction).await?;
+        if !data.is_empty() {
+            data.insert_into_db(id, transaction).await?;
+        }
 
         sqlx::query!(
             "UPDATE applications SET updated_at = $1 WHERE id = $2",
@@ -520,6 +552,15 @@ impl AnswerData {
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        match self {
+            AnswerData::ShortAnswer(text) => text.is_empty(),
+            AnswerData::MultiSelect(options) | AnswerData::Ranking(options) => options.is_empty(),
+            AnswerData::MultiChoice(option_id) => false,
+            AnswerData::DropDown(option_id) => *option_id == 0
+        }
+    }
+
     /// Validates the answer data.
     /// 
     /// # Returns

backend/server/src/handler/application.rs

@@ -277,20 +277,6 @@ pub async fn app() -> Result<Router, ChaosError> {
                 .delete(RatingHandler::delete)
                 .put(RatingHandler::update),
         )
-        .route(
-            "/api/v1/application/:application_id/rating",
-            get(ApplicationHandler::get_rating_by_current_user)
-                .post(ApplicationHandler::create_rating)
-                .put(ApplicationHandler::update_rating),
-        )
-        .route(
-            "/api/v1/application/:application_id/ratings",
-            get(ApplicationHandler::get_ratings),
-        )
-        .route(
-            "/api/v1/campaign/:campaign_id/avg_ratings",
-            get(ApplicationHandler::get_application_ratings_summary),
-        )
         .route(
             "/api/v1/campaign/:campaign_id/role",
             post(CampaignHandler::create_role),
@@ -381,6 +367,20 @@ pub async fn app() -> Result<Router, ChaosError> {
             "/api/v1/application/:application_id",
             get(ApplicationHandler::get),
         )
+        .route(
+            "/api/v1/application/:application_id/inprogress",
+            get(ApplicationHandler::get_in_progress),
+        )
+        .route(
+            "/api/v1/application/:application_id/rating",
+            get(ApplicationHandler::get_rating_by_current_user)
+                .post(ApplicationHandler::create_rating)
+                .put(ApplicationHandler::update_rating),
+        )
+        .route(
+            "/api/v1/application/:application_id/ratings",
+            get(ApplicationHandler::get_ratings),
+        )
         .route(
             "/api/v1/application/:application_id/status",
             patch(ApplicationHandler::set_status),

backend/server/src/models/answer.rs

@@ -71,6 +71,19 @@ pub struct ApplicationRole {
     pub preference: i32,
 }
 
+/// Data structure for creating a new application.
+///
+/// Contains a list of role ids and preferences
+#[derive(Deserialize)]
+pub struct UpdateRoleEntry {
+     /// ID of the campaign role being applied for
+    #[serde(serialize_with = "crate::models::serde_string::serialize")]
+    #[serde(deserialize_with = "crate::models::serde_string::deserialize")]
+    pub campaign_role_id: i64,
+    /// User's preference ranking for this role (lower number = higher preference)
+    pub preference: i32,
+}
+
 /// Data structure for creating a new application.
 /// 
 /// Contains the list of roles the user is applying for, with their preferences.
@@ -159,7 +172,8 @@ pub struct ApplicationAppliedRoleDetails {
 #[derive(Deserialize)]
 pub struct ApplicationRoleUpdate {
     /// Updated list of role preferences
-    pub roles: Vec<ApplicationRole>,
+   //pub roles: Vec<ApplicationRole>,
+   pub roles: Vec<UpdateRoleEntry>,
 }
 
 /// Possible statuses for an application.
@@ -402,6 +416,84 @@ impl Application {
         })
     }
 
+    /// Retrieves an application by its ID regardless of submission status.
+    /// This handler allows regular applicants to view application details in the answer screen.
+    /// # Arguments
+    /// 
+    /// * `id` - ID of the application to retrieve
+    /// * `transaction` - Database transaction to use
+    /// 
+    /// # Returns
+    /// 
+    /// * `Result<ApplicationDetails, ChaosError>` - Application details or error
+    pub async fn get_in_progress(
+        id: i64,
+        current_user: i64,
+        transaction: &mut Transaction<'_, Postgres>,
+    ) -> Result<ApplicationDetails, ChaosError> {
+        let application_data = match sqlx::query_as!(
+            ApplicationData,
+            "
+                SELECT a.id AS id, campaign_id, user_id, status AS \"status: ApplicationStatus\",
+                private_status AS \"private_status: ApplicationStatus\", u.email AS user_email,
+                u.zid AS user_zid, u.name AS user_name, u.gender AS user_gender,
+                u.pronouns AS user_pronouns, u.degree_name AS user_degree_name,
+                u.degree_starting_year AS user_degree_starting_year,
+                (ar.id IS NOT NULL) AS \"current_user_rated!: bool\"
+                FROM applications a
+                JOIN users u ON u.id = a.user_id
+                JOIN campaigns c ON c.id = a.campaign_id
+                LEFT JOIN application_ratings ar ON ar.application_id = a.id AND ar.application_id = $2
+                WHERE a.id = $1 AND a.submitted = false
+            ",
+            id,
+            current_user
+        )
+        .fetch_one(transaction.deref_mut())
+        .await {
+            Ok(application) => application,
+            Err(sqlx::Error::RowNotFound) => {
+                return Err(ChaosError::BadRequest);
+            },
+            Err(e) => return Err(e.into()),
+        };
+
+        let applied_roles = sqlx::query_as!(
+            ApplicationAppliedRoleDetails,
+            "
+                SELECT application_roles.campaign_role_id,
+                application_roles.preference, campaign_roles.name AS role_name
+                FROM application_roles
+                    JOIN campaign_roles
+                    ON application_roles.campaign_role_id = campaign_roles.id
+                WHERE application_id = $1
+                ORDER BY campaign_roles.id
+            ",
+            id
+        )
+        .fetch_all(transaction.deref_mut())
+        .await?;
+
+        Ok(ApplicationDetails {
+            id: application_data.id,
+            campaign_id: application_data.campaign_id,
+            status: application_data.status,
+            private_status: application_data.private_status,
+            applied_roles,
+            current_user_rated: application_data.current_user_rated,
+            user: UserDetails {
+                id: application_data.user_id,
+                email: application_data.user_email,
+                zid: application_data.user_zid,
+                name: application_data.user_name,
+                pronouns: application_data.user_pronouns,
+                gender: application_data.user_gender,
+                degree_name: application_data.user_degree_name,
+                degree_starting_year: application_data.user_degree_starting_year,
+            },
+        })
+    }
+
     /// Retrieves all applications for a specific role.
     /// 
     /// # Arguments
@@ -786,7 +878,7 @@ impl Application {
                 SELECT id, application_id, campaign_role_id, preference
                 FROM application_roles
                 WHERE application_id = $1
-                ORDER BY campaign_role_id
+                ORDER BY preference
             ",
             id
         )
@@ -809,7 +901,7 @@ impl Application {
     /// * `Result<(), ChaosError>` - Success or error
     pub async fn update_roles(
         id: i64,
-        roles: Vec<ApplicationRole>,
+        roles: Vec<UpdateRoleEntry>,
         transaction: &mut Transaction<'_, Postgres>,
     ) -> Result<(), ChaosError> {
         sqlx::query!(

backend/server/src/models/app.rs

@@ -64,6 +64,8 @@ pub struct Campaign {
     pub application_requirements: Option<String>,
     /// Whether the campaign is published
     pub published: bool,
+    /// Max amount of roles an applicant can apply for
+    pub max_roles_per_application: Option<i32>
 }
 
 /// Detailed view of a campaign.
@@ -109,6 +111,8 @@ pub struct CampaignDetails {
     pub application_requirements: Option<String>,
     /// Whether the campaign is published
     pub published: bool,
+    /// Max amount of roles an applicant can apply for
+    pub max_roles_per_application: Option<i32>
 }
 
 /// Simplified view of a campaign for organization listings.
@@ -322,7 +326,7 @@ impl Campaign {
                 o.slug AS organisation_slug, o.name as organisation_name, 
                 o.contact_email, o.website_url, c.cover_image,
                 c.description, c.starts_at, c.ends_at, c.published, c.interview_period_starts_at, 
-                c.interview_period_ends_at, c.interview_format, c.outcomes_released_at, 
+                c.interview_period_ends_at, c.interview_format, c.outcomes_released_at, c.max_roles_per_application,
                 c.application_requirements
                 FROM campaigns c
                 JOIN organisations o on c.organisation_id = o.id
@@ -399,7 +403,7 @@ impl Campaign {
                 SELECT c.id, c.slug AS campaign_slug, c.name, c.organisation_id,
                 o.slug AS organisation_slug, o.name as organisation_name, 
                 o.contact_email, o.website_url, c.cover_image, 
-                c.description, c.starts_at, c.ends_at, c.published, 
+                c.description, c.starts_at, c.ends_at, c.published, c.max_roles_per_application,
                 c.interview_period_starts_at, c.interview_period_ends_at, c.interview_format, 
                 c.outcomes_released_at, c.application_requirements
                 FROM campaigns c