feat/waitlist transition

.github/workflows/deploy-caddy.yml

@@ -0,0 +1,45 @@
+name: Deploy Caddy 
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  deploy:
+    name: Deploy to Production Server
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: SSH proxy command
+        uses: appleboy/ssh-action@v1
+        with:
+          host: ${{ secrets.API_HOST }}
+          username: root
+          password: ${{ secrets.API_PASSWORD }}
+          script: |
+            cd /root/core/infra
+            git fetch
+            git checkout dev
+            git reset --hard origin/dev
+            git pull
+
+            export INFISICAL_TOKEN=$(infisical login \
+              --method=universal-auth \
+              --client-id='${{ secrets.INFISICAL_CLIENT_ID }}' \
+              --client-secret='${{ secrets.INFISICAL_CLIENT_SECRET }}' \
+              --silent \
+              --plain)
+
+            infisical export \
+              --token=$INFISICAL_TOKEN \
+              --env=dev \
+              --format=dotenv \
+              --path="/api" \
+              --projectId='${{ secrets.INFISICAL_PROJECT_ID }}' \
+              > ./secrets/.env.dev.api
+
+            docker compose -f docker-compose.api.yml pull caddy
+            docker compose -f docker-compose.api.yml up -d --no-deps --force-recreate caddy

.github/workflows/dev-deploy-asynqmon.yml

@@ -0,0 +1,30 @@
+name: Deploy Asynqmon to Development
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  deploy:
+    name: Deploy to Development Server
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: SSH proxy commmand
+        uses: appleboy/ssh-action@v1
+        with:
+          host: ${{ secrets.API_HOST}}
+          username: root
+          password: ${{ secrets.API_PASSWORD}}
+          script: |
+            cd /root/core/infra
+            git fetch
+            git checkout dev
+            git reset --hard origin/dev
+            git pull
+
+            docker compose -f docker-compose.api.yml pull asynqmon-dev
+            docker compose -f docker-compose.api.yml up -d --no-deps --force-recreate asynqmon-dev

.github/workflows/prod-deploy-asynqmon.yml

@@ -0,0 +1,30 @@
+name: Deploy Asynqmon to Production
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  deploy:
+    name: Deploy to Production Server
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: SSH proxy commmand
+        uses: appleboy/ssh-action@v1
+        with:
+          host: ${{ secrets.API_HOST}}
+          username: root
+          password: ${{ secrets.API_PASSWORD}}
+          script: |
+            cd /root/core/infra
+            git fetch
+            git checkout dev
+            git reset --hard origin/dev
+            git pull
+
+            docker compose -f docker-compose.api.yml pull asynqmon
+            docker compose -f docker-compose.api.yml up -d --no-deps --force-recreate asynqmon

apps/api/.env.dev.example

@@ -3,6 +3,11 @@ DATABASE_URL_MIGRATION="postgres://postgres:postgres@localhost:5432/coredb"
 REDIS_URL="redis://redis:6379"
 ALLOWED_ORIGINS="" # URLs in comma seperated list
 
+# Application waitlist
+MAX_ACCEPTED_APPLICATIONS=500
+ACCEPT_FROM_WAITLIST_COUNT=50
+ACCEPT_FROM_WAITLIST_PERIOD="@every 72h"
+
 # For OAuth
 AUTH_DISCORD_CLIENT_ID=
 AUTH_DISCORD_CLIENT_SECRET=

apps/api/cmd/BAT_worker/main.go

@@ -56,6 +56,19 @@ func main() {
 		},
 	)
 
+	schedulerLocation, err := time.LoadLocation("America/New_York")
+	if err != nil {
+		panic(err)
+	}
+	scheduler := asynq.NewScheduler(
+		redisOpt,
+		&asynq.SchedulerOpts{
+			Location: schedulerLocation,
+		},
+	)
+
+	taskQueueClient := asynq.NewClient(redisOpt)
+
 	database := db.NewDB(cfg.DatabaseURL)
 	defer database.Close()
 
@@ -64,16 +77,21 @@ func main() {
 	applicationRepo := repository.NewApplicationRepository(database)
 	eventRepo := repository.NewEventRespository(database)
 	userRepo := repository.NewUserRepository(database)
+	eventService := services.NewEventService(eventRepo, userRepo, nil, nil, logger)
 	batRunsRepo := repository.NewBatRunsRepository(database)
 
 	sesClient := email.NewSESClient(cfg.AWS.AccessKey, cfg.AWS.AccessKeySecret, cfg.AWS.Region, logger)
-	emailService := services.NewEmailService(nil, sesClient, logger)
-	batService := services.NewBatService(applicationRepo, eventRepo, userRepo, batRunsRepo, emailService, txm, nil, logger)
+	emailService := services.NewEmailService(taskQueueClient, sesClient, logger)
+	batService := services.NewBatService(applicationRepo, eventRepo, userRepo, batRunsRepo, emailService, txm, nil, scheduler, logger)
+	applicationService := services.NewApplicationService(applicationRepo, userRepo, eventService, emailService, txm, nil, nil, scheduler, logger)
 
-	BATWorker := workers.NewBATWorker(batService, logger)
+	BATWorker := workers.NewBATWorker(batService, applicationService, scheduler, taskQueueClient, logger)
 
 	mux := asynq.NewServeMux()
 	mux.HandleFunc(tasks.TypeCalculateAdmissions, BATWorker.HandleCalculateAdmissionsTask)
+	mux.HandleFunc(tasks.TypeTransitionWaitlist, BATWorker.HandleTransitionWaitlistTask)
+	mux.HandleFunc(tasks.TypeScheduleTransitionWaitlist, BATWorker.HandleScheduleTransitionWaitlistTask)
+	mux.HandleFunc(tasks.TypeShutdownScheduler, BATWorker.HandleShutdownScheduler)
 
 	if err := srv.Run(mux); err != nil {
 		logger.Fatal().Msg("Failed to run BAT worker")

apps/api/cmd/api/main.go

@@ -89,9 +89,9 @@ func main() {
 	eventInterestService := services.NewEventInterestService(eventInterestRepo, logger)
 	eventService := services.NewEventService(eventRepo, userRepo, r2Client, &cfg.CoreBuckets, logger)
 	emailService := services.NewEmailService(taskQueueClient, sesClient, logger)
-	applicationService := services.NewApplicationService(applicationRepo, eventService, emailService, txm, r2Client, &cfg.CoreBuckets, logger)
+	applicationService := services.NewApplicationService(applicationRepo, userRepo, eventService, emailService, txm, r2Client, &cfg.CoreBuckets, nil, logger)
 	teamService := services.NewTeamService(teamRepo, teamMemberRepo, teamJoinRequestRepo, eventRepo, txm, logger)
-	batService := services.NewBatService(applicationRepo, eventRepo, userRepo, batRunsRepo, emailService, txm, taskQueueClient, logger)
+	batService := services.NewBatService(applicationRepo, eventRepo, userRepo, batRunsRepo, emailService, txm, taskQueueClient, nil, logger)
 
 	// Injections into handlers
 	apiHandlers := handlers.NewHandlers(authService, userService, eventInterestService, eventService, emailService, applicationService, teamService, batService, cfg, logger)

apps/api/cmd/email_worker/main.go

@@ -46,7 +46,6 @@ func main() {
 
 	mux := asynq.NewServeMux()
 
-	mux.HandleFunc(tasks.TypeSendConfirmationEmail, emailWorker.HandleSendConfirmationEmailTask)
 	mux.HandleFunc(tasks.TypeSendHtmlEmail, emailWorker.HandleSendHtmlEmailTask)
 
 	wd, err := os.Getwd()

apps/api/internal/api/api.go

@@ -74,7 +74,7 @@
 			fmt.Printf("%v", err)
 		}
 
 		fmt.Fprintln(w, htmlContent)
 	})
 
 	// Health check
@@ -122,9 +122,6 @@
 
 	// --- Event routes ---
 	api.Router.Route("/events", func(r chi.Router) {
-		r.Post("/{eventId}/calc-admissions", api.Handlers.Admission.HandleCalculateAdmissionsRequest)
-		r.Post("/{eventId}/reviews/bat-runs/{runId}/release", api.Handlers.Admission.ReleaseDecisions)
-
 		// Superuser-only
 		r.With(mw.Auth.RequireAuth, ensureSuperuser).Post("/", api.Handlers.Event.CreateEvent)
 
@@ -143,6 +140,12 @@
 			r.With(ensureEventStaff).Get("/overview", api.Handlers.Event.GetEventOverview)
 
 			// Admin-only
+			r.With(ensureEventAdmin).Post("/queue-confirmation-email", api.Handlers.Email.QueueConfirmationEmail)
+			r.With(ensureEventAdmin).Post("/calc-admissions", api.Handlers.Admission.HandleCalculateAdmissionsRequest)
+			r.With(ensureEventAdmin).Patch("/transition-waitlisted-applications", api.Handlers.Application.TransitionWaitlistedApplications)
+			r.With(ensureEventAdmin).Post("/begin-waitlist-transition", api.Handlers.Bat.QueueScheduleWaitlistTransitionTask)
+			r.With(ensureEventAdmin).Post("/shutdown-waitlist-scheduler", api.Handlers.Bat.QueueShutdownWaitlistSchedulerTask)
+			r.With(ensureEventAdmin).Post("/reviews/bat-runs/{runId}/release", api.Handlers.Admission.ReleaseDecisions)
 			r.With(ensureEventAdmin).Patch("/", api.Handlers.Event.UpdateEventById)
 			r.With(ensureEventAdmin).Post("/banner", api.Handlers.Event.UploadEventBanner)
 			r.With(ensureEventAdmin).Delete("/banner", api.Handlers.Event.DeleteBanner)

apps/api/internal/api/handlers/application.go

@@ -184,7 +184,7 @@
 		return
 	}
 
 	defer resumeFile.Close()
 
 	resumeFileBuffer := bytes.NewBuffer(nil)
 
@@ -652,7 +652,7 @@
 //	@Tags			Application Event
 //
 //	@Param			eventId	path	string	true	"ID of the event to join the waitlist for"
-//	@Success		200		"Acceptance withdrawn joined successfully"
+//	@Success		200		"Acceptance successful"
 //	@Failure		400		{object}	res.ErrorResponse	"Bad request: invalid event ID"
 //	@Failure		500		{object}	res.ErrorResponse	"Server error: failed to accept"
 //	@Router			/events/{eventId}/application/accept-acceptance [patch]
@@ -672,3 +672,32 @@
 
 	w.WriteHeader(http.StatusOK)
 }
+
+//	 Transition waitlisted applications
+//
+//		@Summary		Sets application status from accepted to rejected
+//		@Description	Transitions all accepted users to waitlist, and accepts 50 from the waitlist.
+//		@Tags			Application Event
+//
+//		@Param			eventId	path	string	true	"ID of the event to join the waitlist for"
+//		@Success		200		"Transitioned application statuses successfully"
+//		@Failure		400		{object}	res.ErrorResponse	"Bad request: invalid event ID"
+//		@Failure		500		{object}	res.ErrorResponse	"Server error: failed to transition application statuses"
+//		@Router			/events/{eventId}/application/transition-waitlisted-applications [patch]
+func (h *ApplicationHandler) TransitionWaitlistedApplications(w http.ResponseWriter, r *http.Request) {
+	eventId, err := web.PathParamToUUID(r, "eventId")
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_event_id", "The event ID is not a valid."))
+		return
+	}
+
+	var acceptanceCount uint32 = 50
+	var acceptanceQuota uint32 = 500
+	err = h.appService.TransitionWaitlistedApplications(r.Context(), eventId, acceptanceCount, acceptanceQuota)
+	if err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("transition-waitlisted-applications-error", "Something went wrong while transitioning waitlisted applications."))
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}

apps/api/internal/api/handlers/bat.go

@@ -10,6 +10,7 @@ import (
 	"github.com/rs/zerolog"
 	res "github.com/swamphacks/core/apps/api/internal/api/response"
 	"github.com/swamphacks/core/apps/api/internal/services"
+	"github.com/swamphacks/core/apps/api/internal/web"
 )
 
 type BatHandler struct {
@@ -116,10 +117,10 @@ func (h *BatHandler) CheckApplicationReviewsComplete(w http.ResponseWriter, r *h
 	}
 }
 
-// Delete an event
+// Delete a run
 //
-//	@Summary		Delete an event
-//	@Description	Delete an existing event
+//	@Summary		Delete a run
+//	@Description	Delete an existing BAT run
 //	@Tags			Bat
 //	@Accept			json
 //	@Produce		json
@@ -151,3 +152,47 @@ func (h *BatHandler) DeleteRunById(w http.ResponseWriter, r *http.Request) {
 
 	w.WriteHeader(http.StatusNoContent)
 }
+
+//	 Queue transition waitlist task
+//
+//		@Summary		Queues a waitlist transition task
+//		@Description	Queues an asynq task that transitions waitlisted applications, running every 3 days.
+//		@Tags
+//
+//		@Param			eventId	path	string	true	"ID of the event to join the waitlist for"
+//		@Success		200		"Transitioned application statuses successfully"
+//		@Failure		400		{object}	res.ErrorResponse	"Bad request: invalid event ID"
+//		@Failure		500		{object}	res.ErrorResponse	"Server error: failed to transition application statuses"
+//		@Router			/events/{eventId}/queue-transition-waitlist-task [post]
+func (h *BatHandler) QueueScheduleWaitlistTransitionTask(w http.ResponseWriter, r *http.Request) {
+	eventId, err := web.PathParamToUUID(r, "eventId")
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_event_id", "The event ID is not valid."))
+		return
+	}
+
+	err = h.BatService.QueueScheduleWaitlistTransitionTask(r.Context(), eventId)
+	if err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Failed to create ScheduleWaitlistTransition task."))
+	}
+
+	res.Send(w, http.StatusCreated, nil)
+}
+
+//	 Queue Shutdown scheduler task
+//
+//		@Summary		Shutsdown an asynq scheduler
+//		@Description	Shutsdown the scheduler used for the waitlist transition task. Error returned through logs if a scheduler is not active.
+//		@Tags
+//
+//		@Success		200		"Scheduler shutdown successfully"
+//		@Failure		500		{object}	res.ErrorResponse	"Server error: failed to shutdown scheduler"
+//		@Router			/events/{eventId}/queue-transition-waitlist-task [post]
+func (h *BatHandler) QueueShutdownWaitlistSchedulerTask(w http.ResponseWriter, r *http.Request) {
+	err := h.BatService.QueueShutdownWaitlistScheduler()
+	if err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Failed to shutdown scheduler."))
+	}
+
+	res.Send(w, http.StatusOK, nil)
+}

apps/api/internal/api/handlers/email.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 
+	"github.com/go-playground/validator/v10"
 	"github.com/rs/zerolog"
 	res "github.com/swamphacks/core/apps/api/internal/api/response"
 	"github.com/swamphacks/core/apps/api/internal/email"
@@ -27,10 +28,6 @@ type QueueTextEmailRequest struct {
 	Subject string   `json:"subject"`
 	Body    string   `json:"body"`
 }
-type QueueConfirmationEmailRequest struct {
-	To   string `json:"to"`
-	Name string `json:"name"`
-}
 
 // Queue an Email Request
 //
@@ -79,3 +76,30 @@ func (h *EmailHandler) QueueTextEmail(w http.ResponseWriter, r *http.Request) {
 
 	w.WriteHeader(http.StatusCreated)
 }
+
+type QueueConfirmationEmailFields struct {
+	Email     string `json:"email" validate:"required"`
+	FirstName string `json:"firstName" validate:"required"`
+}
+
+func (h *EmailHandler) QueueConfirmationEmail(w http.ResponseWriter, r *http.Request) {
+	var req QueueConfirmationEmailFields
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+	err := decoder.Decode(&req)
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_request", "Could not parse request body"))
+		return
+	}
+	validate := validator.New()
+	if err := validate.Struct(req); err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_request", err.Error()))
+	}
+
+	err = h.emailService.QueueConfirmationEmail(req.Email, req.FirstName)
+	if err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Confirmation email could not be queued."))
+	}
+
+	res.Send(w, http.StatusOK, nil)
+}

apps/api/internal/config/config.go

@@ -31,6 +31,7 @@ type CloudflareConfig struct {
 	AccessKeySecret string `env:"ACCESS_KEY_SECRET"`
 }
 
+// TODO: deprecate.
 type SmtpConfig struct {
 	Username    string `env:"USERNAME"`
 	Password    string `env:"PASSWORD"`
@@ -54,12 +55,15 @@ type CoreBuckets struct {
 }
 
 type Config struct {
-	DatabaseURL            string   `env:"DATABASE_URL"`
-	RedisURL               string   `env:"REDIS_URL"`
-	Port                   string   `env:"PORT" envDefault:"8080"`
-	AllowedOriginsString   string   `env:"ALLOWED_ORIGINS"`
-	EmailTemplateDirectory string   `env:"EMAIL_TEMPLATE_DIRECTORY"`
-	AllowedOrigins         []string ``
+	DatabaseURL              string   `env:"DATABASE_URL"`
+	RedisURL                 string   `env:"REDIS_URL"`
+	Port                     string   `env:"PORT" envDefault:"8080"`
+	AllowedOriginsString     string   `env:"ALLOWED_ORIGINS"`
+	EmailTemplateDirectory   string   `env:"EMAIL_TEMPLATE_DIRECTORY"`
+	AllowedOrigins           []string ``
+	MaxAcceptedApplications  uint32   `env:"MAX_ACCEPTED_APPLICATIONS"`
+	AcceptFromWaitlistCount  uint32   `env:"ACCEPT_FROM_WAITLIST_COUNT"`
+	AcceptFromWaitlistPeriod string   `env:"ACCEPT_FROM_WAITLIST_PERIOD"`
 
 	Auth      AuthConfig   `envPrefix:"AUTH_"`
 	Cookie    CookieConfig `envPrefix:"COOKIE_"`