Feat/saving bat results

apps/api/internal/api/api.go

@@ -150,6 +150,8 @@ func (api *API) setupRoutes(mw *mw.Middleware) {
 			r.With(ensureEventAdmin).Post("/roles", api.Handlers.Event.AssignEventRole)
 			r.With(ensureEventAdmin).Delete("/roles/{userId}", api.Handlers.Event.RevokeEventRole)
 			r.With(ensureEventAdmin).Post("/roles/batch", api.Handlers.Event.BatchAssignEventRoles)
+			r.With(ensureEventAdmin).Get("/bat-runs", api.Handlers.Bat.GetRunsByEventId)
+			r.With(ensureEventAdmin).Delete("/bat-runs", api.Handlers.Bat.GetRunsByEventId)
 
 			// Superuser-only
 			r.With(ensureSuperuser).Delete("/", api.Handlers.Event.DeleteEventById)

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

@@ -0,0 +1,106 @@
+package handlers
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog"
+	res "github.com/swamphacks/core/apps/api/internal/api/response"
+	"github.com/swamphacks/core/apps/api/internal/services"
+)
+
+type BatHandler struct {
+	BatService *services.BatService
+	logger     zerolog.Logger
+}
+
+func NewBatHandler(BatService *services.BatService, logger zerolog.Logger) *BatHandler {
+	return &BatHandler{
+		BatService: BatService,
+		logger:     logger.With().Str("handler", "BatRunHandler").Str("component", "event_interest").Logger(),
+	}
+}
+
+// Get BatRuns
+//
+//	@Summary		Get BatRuns
+//	@Description	Gets BatRuns.
+//	@Tags			Bat
+//	@Accept         json
+//	@Produce		json
+//	@Success		200		{array}	sqlc.GetBatRunsWithUserInfoRow	"OK: BatRuns returned"
+//	@Router			/events/{eventId}/bat-runs [get]
+func (h *BatHandler) GetRunsByEventId(w http.ResponseWriter, r *http.Request) {
+	eventIdStr := chi.URLParam(r, "eventId")
+	if eventIdStr == "" {
+		res.SendError(w, http.StatusBadRequest, res.NewError("missing_event_id", "The event ID is missing from the URL!"))
+		return
+	}
+	eventId, err := uuid.Parse(eventIdStr)
+
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_event_id", "The event ID is not a valid UUID"))
+		return
+	}
+
+	runs, err := h.BatService.GetRunsByEventId(r.Context(), eventId)
+	if errors.Is(err, services.ErrMissingFields) {
+		res.SendError(w, http.StatusBadRequest, res.NewError("missing_fields", "Missing/malformed query. Available parameters:  eventId"))
+		return
+	}
+
+	if errors.Is(err, services.ErrMissingPerms) {
+		res.SendError(w, http.StatusForbidden, res.NewError("forbidden", "You are forbidden from this resource."))
+		return
+	}
+
+	if err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Something went wrong encoding response"))
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	if err := json.NewEncoder(w).Encode(runs); err != nil {
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Something went wrong encoding response"))
+		return
+	}
+}
+
+// Delete an event
+//
+//	@Summary		Delete an event
+//	@Description	Delete an existing event
+//	@Tags			Bat
+//	@Accept			json
+//	@Produce		json
+//	@Param			eventId	path	string	true	"Run ID"	Format(uuid)
+//	@Success		204		"OK - Run deleted"
+//	@Failure		500		{object}	response.ErrorResponse	"Server Error: Something went terribly wrong on our end."
+//	@Router			/events/{eventId}/bat-runs [delete]
+func (h *BatHandler) DeleteRunById(w http.ResponseWriter, r *http.Request) {
+	eventIdStr := chi.URLParam(r, "eventId")
+	if eventIdStr == "" {
+		res.SendError(w, http.StatusBadRequest, res.NewError("missing_event_id", "The event ID is missing from the URL!"))
+		return
+	}
+	eventId, err := uuid.Parse(eventIdStr)
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("invalid_event_id", "The event ID is not a valid UUID"))
+		return
+	}
+	err = h.BatService.DeleteRunById(r.Context(), eventId)
+
+	if err != nil {
+		switch err {
+		case services.ErrFailedToDeleteRun:
+			res.SendError(w, http.StatusInternalServerError, res.NewError("delete_error", "Failed to delete event"))
+		default:
+			res.SendError(w, http.StatusInternalServerError, res.NewError("internal_err", "Something went wrong"))
+		}
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}

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

@@ -15,6 +15,7 @@ type Handlers struct {
 	Application   *ApplicationHandler
 	Teams         *TeamHandler
 	Admission     *AdmissionHandler
+	Bat           *BatHandler
 }
 
 func NewHandlers(
@@ -38,5 +39,6 @@ func NewHandlers(
 		Application:   NewApplicationHandler(appService),
 		Teams:         NewTeamHandler(teamService, logger),
 		Admission:     NewAdmissionHandler(batService),
+		Bat:           NewBatHandler(batService, logger),
 	}
 }

apps/api/internal/db/migrations/20251215225937_add_bat_runs_schema.sql

@@ -0,0 +1,21 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TYPE bat_run_status AS ENUM ('running','completed','failed');
+
+CREATE TABLE bat_runs (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    event_id UUID NOT NULL REFERENCES events(id) ON DELETE CASCADE,
+    accepted_applicants UUID[] DEFAULT '{}',
+    rejected_applicants UUID[] DEFAULT '{}',
+    status bat_run_status DEFAULT 'running',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    completed_at TIMESTAMPTZ
+);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS bat_runs;
+DROP TYPE IF EXISTS bat_run_status;
+-- +goose StatementEnd
+

apps/api/internal/db/queries/bat_runs.sql

@@ -0,0 +1,44 @@
+-- name: AddRun :one
+INSERT INTO bat_runs (
+    event_id
+) VALUES (
+    $1
+) RETURNING *;
+
+-- name: GetRunByEventId :one
+SELECT
+    id,
+    accepted_applicants,
+    rejected_applicants,
+    status,
+    created_at,
+    completed_at
+FROM bat_runs
+WHERE event_id = $1;
+
+-- name: GetRunsByEventId :many
+SELECT
+    id,
+    accepted_applicants,
+    rejected_applicants,
+    status,
+    created_at,
+    completed_at
+FROM bat_runs
+WHERE event_id = $1
+ORDER BY created_at DESC;
+
+-- name: UpdateRunById :exec
+UPDATE bat_runs
+SET
+    accepted_applicants = CASE WHEN @accepted_applicants_do_update::boolean THEN @accepted_applicants ELSE accepted_applicants END,
+    rejected_applicants = CASE WHEN @rejected_applicants_do_update::boolean THEN @rejected_applicants ELSE rejected_applicants END,
+    status = CASE WHEN @status_do_update::boolean THEN @status ELSE status END,
+    created_at = CASE WHEN @created_at_do_update::boolean THEN @created_at ELSE created_at END
+WHERE
+    id = @id::uuid
+RETURNING *;
+
+-- name: DeleteRunById :execrows
+DELETE FROM bat_runs
+WHERE id = $1;

apps/api/internal/db/repository/bat_runs.go

@@ -0,0 +1,75 @@
+package repository
+
+import (
+	"context"
+	"errors"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/swamphacks/core/apps/api/internal/db"
+	"github.com/swamphacks/core/apps/api/internal/db/sqlc"
+)
+
+var (
+	ErrDuplicateRun        = errors.New("Run already exists in the database")
+	ErrRunNotFound         = errors.New("Run not found")
+	ErrNoRunsDeleted       = errors.New("No Runs deleted")
+	ErrMultipleRunsDeleted = errors.New("Multiple Runs affected by delete query expecting to delete one")
+)
+
+type BatRunsRepository struct {
+	db *db.DB
+}
+
+func NewBatRunsRepository(db *db.DB) *BatRunsRepository {
+	return &BatRunsRepository{
+		db: db,
+	}
+}
+
+func (r *BatRunsRepository) AddRun(ctx context.Context, eventId uuid.UUID) (*sqlc.BatRun, error) {
+	run, err := r.db.Query.AddRun(ctx, eventId)
+	if err != nil {
+		if db.IsUniqueViolation(err) {
+			return nil, ErrDuplicateRun
+		}
+		return nil, err
+	}
+	return &run, nil
+}
+
+func (r *BatRunsRepository) GetRunByEventId(ctx context.Context, eventId uuid.UUID) (*sqlc.GetRunByEventIdRow, error) {
+	run, err := r.db.Query.GetRunByEventId(ctx, eventId)
+	return &run, err
+}
+
+func (r *BatRunsRepository) GetRunsByEventId(ctx context.Context, eventId uuid.UUID) (*[]sqlc.GetRunsByEventIdRow, error) {
+	runs, err := r.db.Query.GetRunsByEventId(ctx, eventId)
+	return &runs, err
+}
+
+func (r *BatRunsRepository) UpdateRunById(ctx context.Context, params sqlc.UpdateRunByIdParams) error {
+	err := r.db.Query.UpdateRunById(ctx, params)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrEventNotFound
+		}
+	}
+	return err
+}
+
+func (r *BatRunsRepository) DeletRunById(ctx context.Context, id uuid.UUID) error {
+	affectedRows, err := r.db.Query.DeleteRunById(ctx, id)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrRunNotFound
+		}
+	}
+	if affectedRows == 0 {
+		return ErrNoRunsDeleted
+	} else if affectedRows > 1 {
+		return ErrMultipleRunsDeleted
+	}
+
+	return err
+}