Merge pull request #708 from devsoc-unsw/CHAOS-702-create-offers-before-send-email

Chaos 702 create offers before send email

Author: Plebbaroni

backend/server/src/handler/campaign.rs

@@ -22,6 +22,8 @@ use crate::models::transaction::DBTransaction;
 use axum::extract::{Json, Path, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
+use chrono::{DateTime, Utc};
+use serde::Deserialize;
 
 /// Handler for campaign-related HTTP requests.
 pub struct CampaignHandler;

backend/server/src/handler/offer.rs

@@ -4,19 +4,50 @@
 //! - Creating and retrieving offers
 //! - Replying to offers
 //! - Previewing and sending offer emails
+//! - Queuing offer emails for the background worker (`EmailQueue`)
 
 use crate::models::app::{AppMessage, AppState};
-use crate::models::auth::{OfferAdmin, OfferRecipient};
+use crate::models::auth::{OfferAdmin, OfferRecipient, CampaignAdmin};
 use crate::models::error::ChaosError;
 use crate::models::offer::{Offer, OfferReply};
 use crate::models::transaction::DBTransaction;
 use axum::extract::{Json, Path, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
+use chrono::{DateTime, Utc};
+use serde::Deserialize;
+use crate::models::email::{EmailQueue, EmailType};
 
 /// Handler for offer-related HTTP requests.
 pub struct OfferHandler;
 
+/// One outcome email row (subject/body already resolved on the client).
+#[derive(Deserialize)]
+#[allow(dead_code)]
+pub struct QueueOutcomeEmailItem {
+    #[serde(default)]
+    pub id: Option<String>,
+    #[serde(deserialize_with = "crate::models::serde_string::deserialize")]
+    pub application_id: i64,
+    pub email: String,
+    pub name: String,
+    #[serde(default)]
+    pub role: Option<String>,
+    #[serde(deserialize_with = "crate::models::serde_string::deserialize")]
+    pub role_id: i64,
+    #[serde(deserialize_with = "crate::models::serde_string::deserialize")]
+    pub email_template_id: i64,
+    pub expiry: DateTime<Utc>,
+    pub subject: String,
+    pub body: String,
+    pub email_type: EmailType,
+}
+
+#[derive(Deserialize)]
+pub struct QueueOutcomeEmailsRequest {
+    pub emails: Vec<QueueOutcomeEmailItem>,
+}
+
 impl OfferHandler {
     /// Retrieves the details of a specific offer.
     /// 
@@ -141,4 +172,63 @@ impl OfferHandler {
 
         Ok(AppMessage::OkMessage("Successfully sent offer"))
     }
+
+    /// Queues outcome emails for the worker (`EmailQueue`, same pipeline as offer email queue).
+    ///
+    /// Auth matches viewing application ratings summary: org member for the campaign.
+    pub async fn queue_outcome_emails(
+        _user: CampaignAdmin,
+        Path(campaign_id): Path<i64>,
+        mut transaction: DBTransaction<'_>,
+        State(mut state): State<AppState>,
+        Json(body): Json<QueueOutcomeEmailsRequest>,
+    ) -> Result<impl IntoResponse, ChaosError> {
+        if body.emails.is_empty() {
+            return Err(ChaosError::BadRequestWithMessage(
+                "No emails to queue".to_string(),
+            ));
+        }
+
+        let count = body.emails.len();
+        for item in body.emails {
+            if matches!(item.email_type, EmailType::Accept) {
+                let offer_id = Offer::create(
+                    campaign_id,
+                    item.application_id,
+                    item.email_template_id,
+                    item.role_id,
+                    item.expiry,
+                    &mut transaction.tx,
+                    &mut state.snowflake_generator,
+                )
+                .await?;
+                if state.is_dev_env {
+                    let email = item.email;
+                    println!("need to call offers here, but sent to: {email}");
+                } else {
+                    Offer::send_offer(
+                        offer_id,
+                        &mut transaction.tx,
+                        state.email_credentials.clone(),
+                    ).await?;
+                }
+            } else {
+                if state.is_dev_env {
+                    let email = item.email;
+                    println!("Sending reject email to {email}");
+                } else {
+                    EmailQueue::add_to_queue(
+                        Some(item.name),
+                        item.email,
+                        item.subject,
+                        item.body,
+                        &mut transaction.tx,
+                    ).await?;
+                }
+            }
+        }
+
+        transaction.tx.commit().await?;
+        Ok(AppMessage::OkMessage(format!("Queued {count} email(s) for delivery")))
+    }
 }

backend/server/src/models/app.rs

@@ -2,7 +2,6 @@ use crate::handler::answer::AnswerHandler;
 use crate::handler::application::ApplicationHandler;
 use crate::handler::auth::{DevLoginHandler, google_auth_init, google_callback, logout};
 use crate::handler::campaign::CampaignHandler;
-use crate::handler::comment::CommentHandler;
 use crate::handler::email_template::EmailTemplateHandler;
 use crate::handler::offer::OfferHandler;
 use crate::handler::organisation::OrganisationHandler;
@@ -488,9 +487,10 @@ pub async fn app() -> Result<(Router, AppState), ChaosError> {
             "/api/v1/offer/:offer_id/send",
             post(OfferHandler::send_offer),
         )
+        // change below, needs to also create offers.
         .route(
-            "/api/v1/comment/create",
-            post(CommentHandler::create_comment),
+            "/api/v1/offer/:campaign_id/outcome-emails/queue",
+            post(OfferHandler::queue_outcome_emails),
         )
         // Invite routes
         // - GET  /api/v1/invite/:code  -> invite details
@@ -503,3 +503,4 @@ pub async fn app() -> Result<(Router, AppState), ChaosError> {
 
     Ok((router, state_clone))
 }
+

backend/server/src/models/email.rs

@@ -7,7 +7,7 @@
 use crate::models::error::ChaosError;
 use lettre::transport::smtp::authentication::Credentials;
 use lettre::{AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor};
-use serde::Serialize;
+use serde::{Serialize, Deserialize};
 use sqlx::{Postgres, Transaction};
 use std::env;
 use std::ops::DerefMut;
@@ -46,6 +46,17 @@ pub struct EmailParts {
     pub body: String,
 }
 
+/// Email Type
+/// 
+/// This enum represents the different types of email that can be sent(Interview, Accept, Reject)
+#[derive(Deserialize, Serialize, sqlx::Type, Clone, Debug)]
+#[sqlx(type_name = "email_type", rename_all = "PascalCase")]
+pub enum EmailType{
+    Interview,
+    Accept,
+    Reject,
+}
+
 impl ChaosEmail {
     /// Sets up email credentials from environment variables.
     /// 
@@ -197,7 +208,7 @@ impl EmailQueue {
             .fetch_optional(transaction.deref_mut())
             .await?;
 
-        if let Some(email) = email {            
+        if let Some(email) = email {
             ChaosEmail::send_message(
                 email.recepient_name,
                 email.recepient_email_address,

frontend-nextjs/src/app/[lang]/campaign/[orgSlug]/[campaignSlug]/offer/[offerId]/accept-offer.tsx

@@ -0,0 +1,79 @@
+"use client";
+
+import { useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { Button } from "@/components/ui/button";
+import { getOffer, OfferDetails, OfferReply, replyToOffer, OfferStatus } from "@/models/offer";
+import { dateToString } from "@/lib/utils";
+
+export default function AcceptOffer({offerId}:{offerId:string}) {
+  const { data: offerDetails } = useQuery({
+    queryKey: [`offer-${offerId}`],
+    queryFn: () => getOffer(offerId),
+  });
+
+  const [ answered, setAnswered ] = useState(offerDetails?.status !== "Draft");
+
+  const handleReply = async (reply:OfferReply) => {
+    await replyToOffer(offerId, reply)
+    setAnswered(true);
+  }
+
+  if (answered) {
+    return (
+         <div className="flex min-h-screen items-center justify-center">
+            <p>
+                Thank you for making a decision on this offer. You will be returned to the homepage shortly.
+            </p>
+        </div>
+    )
+  }
+  return (
+    <div className="flex min-h-screen items-center justify-center">
+        <div className="w-full max-w-xl space-y-4 rounded-lg border bg-background p-6 shadow-sm">
+            <div>
+                <h2 className="text-lg font-semibold">Congratulations!</h2>
+            </div>
+
+            <div className="space-y-3 text-sm">
+                {!answered && !offerDetails && <p>Loading offer...</p>}
+
+                {!answered && offerDetails && (
+                    <div className="space-y-2">
+                        <p>
+                            Dear {offerDetails.user_name}, congratulations! We are please to inform you that you have been successful in your application to {offerDetails.organisation_name}'s {offerDetails.campaign_name}!
+                            You have been accepted for the following role: {offerDetails.role_name}. Please accept this offer by {offerDetails.expiry}.
+                        </p>
+                        <p>
+                            You have been accepted for the following role: {offerDetails.role_name}.
+                        </p>
+                        <p>
+                            Please accept this offer by {dateToString(offerDetails.expiry)}.
+                        </p>
+                    </div>
+                )}
+            </div>
+
+            <div className="flex flex-wrap gap-2">
+                <Button
+                variant="destructive"
+                onClick={() => {
+                    handleReply({accept: false})
+                }}
+                disabled={!offerDetails || answered}
+                >
+                Reject
+                </Button>
+                <Button
+                onClick={() => {
+                    handleReply({accept: true})
+                }}
+                disabled={!offerDetails || answered}
+                >
+                Accept
+                </Button>
+            </div>
+        </div>
+    </div>
+  );
+}

frontend-nextjs/src/app/[lang]/campaign/[orgSlug]/[campaignSlug]/offer/[offerId]/page.tsx

@@ -0,0 +1,37 @@
+import { dehydrate, HydrationBoundary, QueryClient } from "@tanstack/react-query";
+import { getOffer } from "@/models/offer";
+import { redirect } from "next/navigation";
+import { OfferDetails } from "@/models/offer";
+import AcceptOffer from "./accept-offer";
+
+export default async function OfferPage({
+  params,
+}: {
+  params: Promise<{
+    lang: string;
+    orgSlug: string;
+    campaignSlug: string;
+    offerId: string;
+  }>;
+}) {
+  const { offerId } = await params;
+
+  const queryClient = new QueryClient();
+  await queryClient.prefetchQuery({
+    queryKey: [`offer-${offerId}`],
+    queryFn: () => getOffer(offerId),
+  });
+
+  const offer: OfferDetails | undefined = queryClient.getQueryData([`offer-${offerId}`]);
+
+  if (!offer) {
+    redirect(`/error`);
+  }
+
+  return (
+   <HydrationBoundary state={dehydrate(queryClient)}>
+     <AcceptOffer offerId={offerId} />
+    </HydrationBoundary>
+  );
+}
+

frontend-nextjs/src/app/[lang]/dashboard/organisation/[orgId]/campaigns/[campaignId]/applications/application-summary.tsx

@@ -66,6 +66,7 @@ function toApplicant(
         id: app.application_id,
         name: app.user_name,
         email: app.user_email,
+        roleIds: applied,
         roles: applied.map((rid) => roleIdsToNames[rid] ?? rid),
     };
 }