Question & Answer CRUD

.github/workflows/rust.yml

@@ -30,7 +30,11 @@ jobs:
           echo "GOOGLE_CLIENT_ID=test" >> backend/.env
           echo "GOOGLE_CLIENT_SECRET=test" >> backend/.env
           echo "GOOGLE_REDIRECT_URI=http://localhost:3000/auth/callback" >> backend/.env
-          echo "ROCKET_DATABASES='{}'" >> backend/.env
+          echo "S3_BUCKET_NAME=chaos-storage" >> backend/.env
+          echo "S3_ACCESS_KEY=test_access_key" >> backend/.env
+          echo "S3_SECRET_KEY=test_secret_key" >> backend/.env
+          echo "S3_ENDPOINT=https://chaos-storage.s3.ap-southeast-1.amazonaws.com" >> backend/.env
+          echo "S3_REGION_NAME=ap-southeast-1" >> backend/.env
       # selecting a toolchain either by action or manual `rustup` calls should happen
       # before the plugin, as it uses the current rustc version as its cache key
       - uses: actions-rs/toolchain@v1

backend/migrations/20240406023149_create_users.sql

@@ -14,4 +14,4 @@ CREATE TABLE users (
     updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
-CREATE UNIQUE INDEX IDX_users_email_lower on users ((lower(email)));
+CREATE UNIQUE INDEX IDX_users_email_lower on users((lower(email)));

backend/migrations/20240406024211_create_organisations.sql

@@ -21,4 +21,4 @@ CREATE TABLE organisation_members (
 );
 
 
-CREATE INDEX IDX_organisation_admins_organisation on organisation_members (organisation_id);
+CREATE INDEX IDX_organisation_admins_organisation on organisation_members(organisation_id);

backend/migrations/20240406025537_create_campaigns.sql

@@ -32,4 +32,4 @@ CREATE TABLE campaign_roles (
             ON UPDATE CASCADE
 );
 
-CREATE INDEX IDX_campaign_roles_campaign on campaign_roles (campaign_id);
+CREATE INDEX IDX_campaign_roles_campaign on campaign_roles(campaign_id);

backend/migrations/20240406031400_create_questions.sql

@@ -5,7 +5,7 @@ CREATE TABLE questions (
     title TEXT NOT NULL,
     description TEXT,
     common BOOLEAN NOT NULL,
-    required BOOLEAN,
+    required BOOLEAN NOT NULL,
     question_type question_type NOT NULL,
     campaign_id BIGINT NOT NULL,
     created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
@@ -27,6 +27,30 @@ CREATE TABLE multi_option_question_options (
            REFERENCES questions(id)
            ON DELETE CASCADE
            ON UPDATE CASCADE
+       DEFERRABLE INITIALLY DEFERRED,
+    UNIQUE (question_id, display_order)
 );
 
-CREATE INDEX IDX_multi_option_question_options_questions on multi_option_question_options (question_id);
+CREATE INDEX IDX_multi_option_question_options_questions on multi_option_question_options(question_id);
+
+CREATE TABLE question_roles (
+    id BIGSERIAL PRIMARY KEY,
+    question_id BIGINT NOT NULL,
+    role_id BIGINT NOT NULL,
+    CONSTRAINT FK_question_roles_questions
+        FOREIGN KEY(question_id)
+            REFERENCES questions(id)
+            ON DELETE CASCADE
+            ON UPDATE CASCADE
+        DEFERRABLE INITIALLY DEFERRED,
+    CONSTRAINT FK_question_roles_roles
+        FOREIGN KEY(role_id)
+            REFERENCES campaign_roles(id)
+            ON DELETE CASCADE
+            ON UPDATE CASCADE
+            DEFERRABLE INITIALLY DEFERRED,
+    UNIQUE (question_id, role_id)
+);
+
+CREATE INDEX IDX_question_roles_questions on question_roles(question_id);
+CREATE INDEX IDX_question_roles_roles on question_roles(role_id);

backend/migrations/20240406031915_create_applications.sql

@@ -53,6 +53,7 @@ CREATE TABLE answers (
           REFERENCES questions(id)
           ON DELETE CASCADE
           ON UPDATE CASCADE
+      DEFERRABLE INITIALLY DEFERRED
 );
 
 CREATE INDEX IDX_answers_applications on answers (application_id);
@@ -79,7 +80,8 @@ CREATE TABLE multi_option_answer_options (
         FOREIGN KEY(option_id)
             REFERENCES multi_option_question_options(id)
             ON DELETE CASCADE
-            ON UPDATE CASCADE,
+            ON UPDATE CASCADE
+        DEFERRABLE INITIALLY DEFERRED,
     CONSTRAINT FK_multi_option_answer_options_answers
         FOREIGN KEY(answer_id)
             REFERENCES answers(id)
@@ -96,16 +98,17 @@ CREATE TABLE ranking_answer_rankings (
         FOREIGN KEY(option_id)
             REFERENCES multi_option_question_options(id)
             ON DELETE CASCADE
-            ON UPDATE CASCADE,
+            ON UPDATE CASCADE
+        DEFERRABLE INITIALLY DEFERRED,
     CONSTRAINT FK_ranking_answer_rankings_answers
         FOREIGN KEY(answer_id)
             REFERENCES answers(id)
             ON DELETE CASCADE
             ON UPDATE CASCADE
 );
 
-CREATE INDEX IDX_multi_option_answer_options_question_options on multi_option_answer_options (option_id);
-CREATE INDEX IDX_multi_option_answer_options_answers on multi_option_answer_options (answer_id);
+CREATE INDEX IDX_multi_option_answer_options_question_options on multi_option_answer_options(option_id);
+CREATE INDEX IDX_multi_option_answer_options_answers on multi_option_answer_options(answer_id);
 
 CREATE TABLE application_ratings (
     id BIGINT PRIMARY KEY,
@@ -127,5 +130,5 @@ CREATE TABLE application_ratings (
             ON UPDATE CASCADE
 );
 
-CREATE INDEX IDX_application_ratings_applications on application_ratings (application_id);
-CREATE INDEX IDX_application_ratings_users on application_ratings (rater_id);
+CREATE INDEX IDX_application_ratings_applications on application_ratings(application_id);
+CREATE INDEX IDX_application_ratings_users on application_ratings(rater_id);

backend/server/src/handler/answer.rs

@@ -0,0 +1,87 @@
+use crate::models::answer::{Answer, NewAnswer};
+use crate::models::app::AppState;
+use crate::models::auth::{AnswerOwner, ApplicationOwner, AuthUser};
+use crate::models::error::ChaosError;
+use crate::models::transaction::DBTransaction;
+use axum::extract::{Json, Path, State};
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use serde_json::json;
+
+pub struct AnswerHandler;
+
+impl AnswerHandler {
+    pub async fn create(
+        State(state): State<AppState>,
+        Path(path): Path<i64>,
+        user: AuthUser,
+        mut transaction: DBTransaction<'_>,
+        Json(data): Json<NewAnswer>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let id = Answer::create(
+            user.user_id,
+            data.application_id,
+            data.question_id,
+            data.answer_data,
+            state.snowflake_generator,
+            &mut transaction.tx,
+        )
+        .await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(json!({"id": id}))))
+    }
+
+    pub async fn get_all_common_by_application(
+        Path(application_id): Path<i64>,
+        _owner: ApplicationOwner,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let answers =
+            Answer::get_all_common_by_application(application_id, &mut transaction.tx).await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(answers)))
+    }
+
+    pub async fn get_all_by_application_and_role(
+        Path((application_id, role_id)): Path<(i64, i64)>,
+        _owner: ApplicationOwner,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let answers =
+            Answer::get_all_by_application_and_role(application_id, role_id, &mut transaction.tx)
+                .await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(answers)))
+    }
+
+    pub async fn update(
+        Path(answer_id): Path<i64>,
+        _owner: AnswerOwner,
+        mut transaction: DBTransaction<'_>,
+        Json(data): Json<NewAnswer>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Answer::update(answer_id, data.answer_data, &mut transaction.tx).await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, "Successfully updated answer"))
+    }
+
+    pub async fn delete(
+        Path(answer_id): Path<i64>,
+        _owner: AnswerOwner,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Answer::delete(answer_id, &mut transaction.tx).await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, "Successfully deleted answer"))
+    }
+}

backend/server/src/handler/application.rs

@@ -1,6 +1,6 @@
 use crate::models::app::AppState;
 use crate::models::application::{Application, ApplicationStatus};
-use crate::models::auth::{AuthUser, ApplicationAdmin};
+use crate::models::auth::{ApplicationAdmin, AuthUser};
 use crate::models::error::ChaosError;
 use crate::models::transaction::DBTransaction;
 use axum::extract::{Json, Path, State};
@@ -48,4 +48,4 @@ impl ApplicationHandler {
         transaction.tx.commit().await?;
         Ok((StatusCode::OK, Json(applications)))
     }
-}
+}

backend/server/src/handler/campaign.rs

@@ -86,7 +86,14 @@ impl CampaignHandler {
         mut transaction: DBTransaction<'_>,
         Json(data): Json<NewApplication>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        Application::create(id, user.user_id, data, state.snowflake_generator, &mut transaction.tx).await?;
+        Application::create(
+            id,
+            user.user_id,
+            data,
+            state.snowflake_generator,
+            &mut transaction.tx,
+        )
+        .await?;
         transaction.tx.commit().await?;
         Ok((StatusCode::OK, "Successfully created application"))
     }

backend/server/src/handler/mod.rs

@@ -1,7 +1,9 @@
+pub mod answer;
+pub mod application;
 pub mod auth;
-pub mod user;
 pub mod campaign;
 pub mod organisation;
-pub mod ratings;
+pub mod question;
+pub mod rating;
 pub mod role;
-pub mod application;
+pub mod user;

backend/server/src/handler/organisation.rs

@@ -91,27 +91,29 @@ impl OrganisationHandler {
     }
 
     pub async fn remove_admin(
-        State(state): State<AppState>,
+        mut transaction: DBTransaction<'_>,
         Path(id): Path<i64>,
         _super_user: SuperUser,
         Json(request_body): Json<AdminToRemove>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        Organisation::remove_admin(id, request_body.user_id, &state.db).await?;
+        Organisation::remove_admin(id, request_body.user_id, &mut transaction.tx).await?;
 
+        transaction.tx.commit().await?;
         Ok((
             StatusCode::OK,
             "Successfully removed member from organisation",
         ))
     }
 
     pub async fn remove_member(
-        State(state): State<AppState>,
+        mut transaction: DBTransaction<'_>,
         Path(id): Path<i64>,
         _admin: OrganisationAdmin,
         Json(request_body): Json<AdminToRemove>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        Organisation::remove_member(id, request_body.user_id, &state.db).await?;
+        Organisation::remove_member(id, request_body.user_id, &mut transaction.tx).await?;
 
+        transaction.tx.commit().await?;
         Ok((
             StatusCode::OK,
             "Successfully removed member from organisation",

backend/server/src/handler/question.rs

@@ -0,0 +1,102 @@
+use crate::models::app::AppState;
+use crate::models::auth::{AuthUser, CampaignAdmin, QuestionAdmin};
+use crate::models::error::ChaosError;
+use crate::models::question::{NewQuestion, Question};
+use crate::models::transaction::DBTransaction;
+use axum::extract::{Json, Path, State};
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use serde_json::json;
+
+pub struct QuestionHandler;
+
+impl QuestionHandler {
+    pub async fn create(
+        State(state): State<AppState>,
+        Path(campaign_id): Path<i64>,
+        _admin: CampaignAdmin,
+        mut transaction: DBTransaction<'_>,
+        Json(data): Json<NewQuestion>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let id = Question::create(
+            campaign_id,
+            data.title,
+            data.description,
+            data.common,
+            data.roles,
+            data.required,
+            data.question_data,
+            state.snowflake_generator,
+            &mut transaction.tx,
+        )
+        .await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(json!({"id": id}))))
+    }
+
+    pub async fn get_all_by_campaign_and_role(
+        Path((campaign_id, role_id)): Path<(i64, i64)>,
+        _user: AuthUser,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let questions =
+            Question::get_all_by_campaign_and_role(campaign_id, role_id, &mut transaction.tx)
+                .await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(questions)))
+    }
+
+    pub async fn get_all_common_by_campaign(
+        Path(campaign_id): Path<i64>,
+        _user: AuthUser,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        let questions =
+            Question::get_all_common_by_campaign(campaign_id, &mut transaction.tx).await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, Json(questions)))
+    }
+
+    pub async fn update(
+        State(state): State<AppState>,
+        Path(question_id): Path<i64>,
+        _admin: QuestionAdmin,
+        mut transaction: DBTransaction<'_>,
+        Json(data): Json<NewQuestion>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Question::update(
+            question_id,
+            data.title,
+            data.description,
+            data.common,
+            data.roles,
+            data.required,
+            data.question_data,
+            &mut transaction.tx,
+            state.snowflake_generator,
+        )
+        .await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, "Successfully updated question"))
+    }
+
+    pub async fn delete(
+        Path(question_id): Path<i64>,
+        _admin: QuestionAdmin,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Question::delete(question_id, &mut transaction.tx).await?;
+
+        transaction.tx.commit().await?;
+
+        Ok((StatusCode::OK, "Successfully deleted question"))
+    }
+}