Email Sending & Application Lockouts

backend/migrations/20240406031915_create_applications.sql

@@ -8,6 +8,7 @@ CREATE TABLE applications (
     private_status application_status NOT NULL DEFAULT 'Pending',
     created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    submitted BOOLEAN NOT NULL DEFAULT false,
     CONSTRAINT FK_applications_campaigns
         FOREIGN KEY(campaign_id)
             REFERENCES campaigns(id)
@@ -24,6 +25,7 @@ CREATE TABLE application_roles (
     id BIGSERIAL PRIMARY KEY,
     application_id BIGINT NOT NULL,
     campaign_role_id BIGINT NOT NULL,
+    preference INTEGER NOT NULL,
     CONSTRAINT FK_application_roles_applications
         FOREIGN KEY(application_id)
             REFERENCES applications(id)

backend/migrations/20241124054711_email_templates.sql

@@ -2,7 +2,8 @@ CREATE TABLE email_templates (
     id BIGINT PRIMARY KEY,
     organisation_id BIGINT NOT NULL,
     name TEXT NOT NULL,
-    template TEXT NOT NULL,
+    template_subject TEXT NOT NULL,
+    template_body TEXT NOT NULL,
     CONSTRAINT FK_email_templates_organisations
         FOREIGN KEY(organisation_id)
             REFERENCES organisations(id)

backend/server/Cargo.toml

@@ -27,3 +27,4 @@ rs-snowflake = "0.6"
 jsonwebtoken = "9.1"
 dotenvy = "0.15"
 handlebars = "6.2"
+lettre = { version = "0.11", default-features = false, features = ["tokio1-rustls-tls", "smtp-transport", "builder"] }

backend/server/src/handler/answer.rs

@@ -7,6 +7,7 @@ use axum::extract::{Json, Path, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use serde_json::json;
+use crate::models::application::{OpenApplicationByAnswerId, OpenApplicationByApplicationId};
 
 pub struct AnswerHandler;
 
@@ -15,6 +16,7 @@ impl AnswerHandler {
         State(state): State<AppState>,
         Path(application_id): Path<i64>,
         _user: ApplicationOwner,
+        _: OpenApplicationByApplicationId,
         mut transaction: DBTransaction<'_>,
         Json(data): Json<NewAnswer>,
     ) -> Result<impl IntoResponse, ChaosError> {
@@ -63,6 +65,7 @@ impl AnswerHandler {
     pub async fn update(
         Path(answer_id): Path<i64>,
         _owner: AnswerOwner,
+        _: OpenApplicationByAnswerId,
         mut transaction: DBTransaction<'_>,
         Json(data): Json<NewAnswer>,
     ) -> Result<impl IntoResponse, ChaosError> {
@@ -76,6 +79,7 @@ impl AnswerHandler {
     pub async fn delete(
         Path(answer_id): Path<i64>,
         _owner: AnswerOwner,
+        _: OpenApplicationByAnswerId,
         mut transaction: DBTransaction<'_>,
     ) -> Result<impl IntoResponse, ChaosError> {
         Answer::delete(answer_id, &mut transaction.tx).await?;

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::{ApplicationAdmin, AuthUser};
+use crate::models::application::{Application, ApplicationRoleUpdate, ApplicationStatus, OpenApplicationByApplicationId};
+use crate::models::auth::{ApplicationAdmin, ApplicationOwner, AuthUser};
 use crate::models::error::ChaosError;
 use crate::models::transaction::DBTransaction;
 use axum::extract::{Json, Path, State};
@@ -48,4 +48,26 @@ impl ApplicationHandler {
         transaction.tx.commit().await?;
         Ok((StatusCode::OK, Json(applications)))
     }
+
+    pub async fn update_roles(
+        _user: ApplicationOwner,
+        Path(application_id): Path<i64>,
+        mut transaction: DBTransaction<'_>,
+        Json(data): Json<ApplicationRoleUpdate>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Application::update_roles(application_id, data.roles, &mut transaction.tx).await?;
+        transaction.tx.commit().await?;
+        Ok((StatusCode::OK, "Successfully updated application roles"))
+    }
+
+    pub async fn submit(
+        _user: ApplicationOwner,
+        _: OpenApplicationByApplicationId,
+        Path(application_id): Path<i64>,
+        mut transaction: DBTransaction<'_>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        Application::submit(application_id, &mut transaction.tx).await?;
+        transaction.tx.commit().await?;
+        Ok((StatusCode::OK, "Successfully submitted application"))
+    }
 }

backend/server/src/handler/campaign.rs

@@ -4,7 +4,7 @@ use crate::models::application::Application;
 use crate::models::application::NewApplication;
 use crate::models::auth::AuthUser;
 use crate::models::auth::CampaignAdmin;
-use crate::models::campaign::Campaign;
+use crate::models::campaign::{Campaign, OpenCampaign};
 use crate::models::error::ChaosError;
 use crate::models::offer::Offer;
 use crate::models::role::{Role, RoleUpdate};
@@ -104,6 +104,7 @@ impl CampaignHandler {
         State(state): State<AppState>,
         Path(id): Path<i64>,
         user: AuthUser,
+        _: OpenCampaign,
         mut transaction: DBTransaction<'_>,
         Json(data): Json<NewApplication>,
     ) -> Result<impl IntoResponse, ChaosError> {

backend/server/src/handler/email_template.rs

@@ -25,7 +25,14 @@ impl EmailTemplateHandler {
         State(state): State<AppState>,
         Json(request_body): Json<EmailTemplate>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        EmailTemplate::update(id, request_body.name, request_body.template, &state.db).await?;
+        EmailTemplate::update(
+            id,
+            request_body.name,
+            request_body.template_subject,
+            request_body.template_body,
+            &state.db,
+        )
+        .await?;
 
         Ok((StatusCode::OK, "Successfully updated email template"))
     }

backend/server/src/handler/offer.rs

@@ -1,8 +1,9 @@
+use crate::models::app::AppState;
 use crate::models::auth::{OfferAdmin, OfferRecipient};
 use crate::models::error::ChaosError;
 use crate::models::offer::{Offer, OfferReply};
 use crate::models::transaction::DBTransaction;
-use axum::extract::{Json, Path};
+use axum::extract::{Json, Path, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 
@@ -47,18 +48,19 @@ impl OfferHandler {
         Path(id): Path<i64>,
         _user: OfferAdmin,
     ) -> Result<impl IntoResponse, ChaosError> {
-        let string = Offer::preview_email(id, &mut transaction.tx).await?;
+        let email_parts = Offer::preview_email(id, &mut transaction.tx).await?;
         transaction.tx.commit().await?;
 
-        Ok((StatusCode::OK, string))
+        Ok((StatusCode::OK, Json(email_parts)))
     }
 
     pub async fn send_offer(
         mut transaction: DBTransaction<'_>,
         Path(id): Path<i64>,
         _user: OfferAdmin,
+        State(state): State<AppState>,
     ) -> Result<impl IntoResponse, ChaosError> {
-        Offer::send_offer(id, &mut transaction.tx).await?;
+        Offer::send_offer(id, &mut transaction.tx, state.email_credentials).await?;
         transaction.tx.commit().await?;
 
         Ok((StatusCode::OK, "Successfully sent offer"))

backend/server/src/handler/organisation.rs

@@ -1,9 +1,8 @@
-use crate::models;
 use crate::models::app::AppState;
 use crate::models::auth::SuperUser;
 use crate::models::auth::{AuthUser, OrganisationAdmin};
-use crate::models::campaign::Campaign;
-use crate::models::email_template::EmailTemplate;
+use crate::models::campaign::{Campaign, NewCampaign};
+use crate::models::email_template::{EmailTemplate, NewEmailTemplate};
 use crate::models::error::ChaosError;
 use crate::models::organisation::{
     AdminToRemove, AdminUpdateList, NewOrganisation, Organisation, SlugCheck,
@@ -167,7 +166,7 @@ impl OrganisationHandler {
         Path(id): Path<i64>,
         State(state): State<AppState>,
         _admin: OrganisationAdmin,
-        Json(request_body): Json<Campaign>,
+        Json(request_body): Json<NewCampaign>,
     ) -> Result<impl IntoResponse, ChaosError> {
         Organisation::create_campaign(
             id,
@@ -199,12 +198,13 @@ impl OrganisationHandler {
         Path(id): Path<i64>,
         State(state): State<AppState>,
         _admin: OrganisationAdmin,
-        Json(request_body): Json<models::email_template::EmailTemplate>,
+        Json(request_body): Json<NewEmailTemplate>,
     ) -> Result<impl IntoResponse, ChaosError> {
         Organisation::create_email_template(
             id,
             request_body.name,
-            request_body.template,
+            request_body.template_subject,
+            request_body.template_body,
             &state.db,
             state.snowflake_generator,
         )

backend/server/src/models/answer.rs

@@ -35,7 +35,6 @@ pub struct Answer {
 
 #[derive(Deserialize)]
 pub struct NewAnswer {
-    pub application_id: i64,
     pub question_id: i64,
 
     #[serde(flatten)]
@@ -320,7 +319,7 @@ impl Answer {
         id: i64,
         transaction: &mut Transaction<'_, Postgres>,
     ) -> Result<(), ChaosError> {
-        sqlx::query!("DELETE FROM answers WHERE id = $1 RETURNING id", id)
+        let _ = sqlx::query!("DELETE FROM answers WHERE id = $1 RETURNING id", id)
             .fetch_one(transaction.deref_mut())
             .await?;
 
@@ -355,7 +354,7 @@ impl AnswerData {
         multi_option_answers: Option<Vec<i64>>,
         ranking_answers: Option<Vec<i64>>,
     ) -> Self {
-        return match question_type {
+        match question_type {
             QuestionType::ShortAnswer => {
                 let answer =
                     short_answer_answer.expect("Data should exist for ShortAnswer variant");
@@ -376,18 +375,18 @@ impl AnswerData {
                 let options = ranking_answers.expect("Data should exist for Ranking variant");
                 AnswerData::Ranking(options)
             }
-        };
+        }
     }
 
     pub fn validate(&self) -> Result<(), ChaosError> {
         match self {
             Self::ShortAnswer(text) => {
-                if text.len() == 0 {
+                if text.is_empty() {
                     return Err(ChaosError::BadRequest);
                 }
             }
             Self::MultiSelect(data) | Self::Ranking(data) => {
-                if data.len() == 0 {
+                if data.is_empty() {
                     return Err(ChaosError::BadRequest);
                 }
             }

backend/server/src/models/app.rs

@@ -9,6 +9,7 @@ use crate::handler::question::QuestionHandler;
 use crate::handler::rating::RatingHandler;
 use crate::handler::role::RoleHandler;
 use crate::handler::user::UserHandler;
+use crate::models::email::{ChaosEmail, EmailCredentials};
 use crate::models::error::ChaosError;
 use crate::models::storage::Storage;
 use axum::routing::{get, patch, post};
@@ -31,6 +32,7 @@ pub struct AppState {
     pub jwt_validator: Validation,
     pub snowflake_generator: SnowflakeIdGenerator,
     pub storage_bucket: Bucket,
+    pub email_credentials: EmailCredentials,
 }
 
 pub async fn app() -> Result<Router, ChaosError> {
@@ -65,6 +67,9 @@ pub async fn app() -> Result<Router, ChaosError> {
     // Initialise S3 bucket
     let storage_bucket = Storage::init_bucket();
 
+    // Initialise email credentials
+    let email_credentials = ChaosEmail::setup_credentials();
+
     // Add all data to AppState
     let state = AppState {
         db: pool,
@@ -75,6 +80,7 @@ pub async fn app() -> Result<Router, ChaosError> {
         jwt_validator,
         snowflake_generator,
         storage_bucket,
+        email_credentials,
     };
 
     Ok(Router::new()
@@ -242,6 +248,14 @@ pub async fn app() -> Result<Router, ChaosError> {
             "/api/v1/application/:application_id/answers/role/:role_id",
             get(AnswerHandler::get_all_by_application_and_role),
         )
+        .route(
+            "/api/v1/application/:application_id/roles",
+            patch(ApplicationHandler::update_roles)
+        )
+        .route(
+            "/api/v1/application/:application_id/submit",
+            post(ApplicationHandler::submit)
+        )
         .route(
             "/api/v1/answer/:answer_id",
             patch(AnswerHandler::update).delete(AnswerHandler::delete),