fix: refactor code to get event role by discord and event id

Author: SobaSkee

apps/api/cmd/api/main.go

@@ -92,7 +92,7 @@ func main() {
 	applicationService := services.NewApplicationService(applicationRepo, eventService, emailService, txm, r2Client, &cfg.CoreBuckets, logger)
 	teamService := services.NewTeamService(teamRepo, teamMemberRepo, teamJoinRequestRepo, eventRepo, txm, logger)
 	batService := services.NewBatService(applicationRepo, eventRepo, userRepo, batRunsRepo, emailService, txm, taskQueueClient, logger)
-	discordService := services.NewDiscordService(accountRepo, eventRepo, logger)
+	discordService := services.NewDiscordService(eventRepo, logger)
 
 	// Injections into handlers
 	apiHandlers := handlers.NewHandlers(authService, userService, eventInterestService, eventService, emailService, applicationService, teamService, batService, discordService, cfg, logger)

apps/api/internal/api/api.go

@@ -123,7 +123,6 @@ func (api *API) setupRoutes(mw *mw.Middleware) {
 	// --- Discord routes (for Discord bot) ---
 	api.Router.Route("/discord", func(r chi.Router) {
 		r.Use(mw.Auth.RequireAuth)
-		r.Get("/user/{discord_id}/role", api.Handlers.Discord.GetUserEventRoleByDiscordID)
 		r.Get("/event/{event_id}/attendees", api.Handlers.Discord.GetEventAttendeesWithDiscord)
 	})
 
@@ -146,6 +145,7 @@ func (api *API) setupRoutes(mw *mw.Middleware) {
 
 			r.Get("/", api.Handlers.Event.GetEventByID)
 			r.Get("/role", api.Handlers.Event.GetEventRole)
+			r.Get("/discord/{discordId}", api.Handlers.Discord.GetUserEventRoleByDiscordIDAndEventId)
 
 			r.With(ensureEventStaff).Get("/overview", api.Handlers.Event.GetEventOverview)
 

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

@@ -22,44 +22,6 @@ func NewDiscordHandler(discordService *services.DiscordService, logger zerolog.L
 	}
 }
 
-// GetUserEventRoleByDiscordID
-//
-//	@Summary		Get user event role by Discord ID
-//	@Description	Get the event role for a user based on their Discord account ID
-//	@Tags			Discord
-//	@Param			discord_id	path		string	true	"Discord account ID"
-//	@Success		200			{object}	map[string]interface{}	"event_id and role"
-//	@Failure		404			{object}	response.ErrorResponse	"User or role not found"
-//	@Failure		500			{object}	response.ErrorResponse	"Internal server error"
-//	@Router			/discord/user/{discord_id}/role [get]
-
-func (h *DiscordHandler) GetUserEventRoleByDiscordID(w http.ResponseWriter, r *http.Request) {
-	discordID := chi.URLParam(r, "discord_id")
-	if discordID == "" {
-		res.SendError(w, http.StatusBadRequest, res.NewError("bad_request", "discord_id is required"))
-		return
-	}
-
-	eventID, role, err := h.discordService.GetUserEventRoleByDiscordID(r.Context(), discordID)
-	if err != nil {
-		if err == services.ErrDiscordAccountNotFound || err == services.ErrNoEventRole {
-            res.SendError(w, http.StatusNotFound, res.NewError("not_found", err.Error()))
-            return
-        }
-        h.logger.Err(err).Msg("failed to get user event role")
-        res.SendError(w, http.StatusInternalServerError, res.NewError("internal_error", "Failed to get user role"))
-        return
-	}
-
-	response := map[string]interface{}{
-		"event_id": eventID,
-		"role": role,
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(response)
-}
-
 // GetEventAttendeesWithDiscord
 //
 //	@Summary		Get event attendees with Discord IDs
@@ -96,4 +58,54 @@ func (h *DiscordHandler) GetEventAttendeesWithDiscord(w http.ResponseWriter, r *
 		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_error", "Failed to encode response"))
 		return
 	}
+}
+
+// GetUserEventRoleByDiscordIDAndEventId
+//
+//	@Summary		Get user event role by Discord ID and Event ID
+//	@Description	Get the event role for a user based on their Discord account ID and a specific event ID
+//	@Tags			Discord
+//	@Param			eventId		path		string	true	"Event ID (UUID)"
+//	@Param			discordId	path		string	true	"Discord account ID"
+//	@Success		200			{object}	map[string]interface{}	"role"
+//	@Failure		400			{object}	response.ErrorResponse	"Invalid event ID or discord ID"
+//	@Failure		404			{object}	response.ErrorResponse	"User or role not found"
+//	@Failure		500			{object}	response.ErrorResponse	"Internal server error"
+//	@Router			/events/{eventId}/discord/{discordId} [get]
+func (h *DiscordHandler) GetUserEventRoleByDiscordIDAndEventId(w http.ResponseWriter, r *http.Request) {
+	eventIDStr := chi.URLParam(r, "eventId")
+	if eventIDStr == "" {
+		res.SendError(w, http.StatusBadRequest, res.NewError("bad_request", "eventId is required"))
+		return
+	}
+
+	eventID, err := uuid.Parse(eventIDStr)
+	if err != nil {
+		res.SendError(w, http.StatusBadRequest, res.NewError("bad_request", "invalid event ID format"))
+		return
+	}
+
+	discordID := chi.URLParam(r, "discordId")
+	if discordID == "" {
+		res.SendError(w, http.StatusBadRequest, res.NewError("bad_request", "discordId is required"))
+		return
+	}
+
+	role, err := h.discordService.GetUserEventRoleByDiscordIDAndEventId(r.Context(), discordID, eventID)
+	if err != nil {
+		if err == services.ErrNoEventRole {
+			res.SendError(w, http.StatusNotFound, res.NewError("not_found", err.Error()))
+			return
+		}
+		h.logger.Err(err).Msg("failed to get user event role")
+		res.SendError(w, http.StatusInternalServerError, res.NewError("internal_error", "Failed to get user role"))
+		return
+	}
+
+	response := map[string]interface{}{
+		"role": role,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
 }

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

@@ -26,13 +26,6 @@ UPDATE event_roles
 SET role = $3
 WHERE event_id = $1 AND user_id = $2;
 
--- name: GetEventRoleByUserID :one
-SELECT event_id, role
-FROM event_roles
-WHERE user_id = $1
-ORDER BY assigned_at DESC
-LIMIT 1;
-
 -- name: GetEventAttendeesWithDiscord :many
 SELECT 
     a.account_id as discord_id,
@@ -44,4 +37,12 @@ JOIN event_roles er ON u.id = er.user_id
 JOIN auth.accounts a ON u.id = a.user_id
 WHERE er.event_id = $1
     AND er.role = 'attendee'
-    AND a.provider_id = 'discord';
+    AND a.provider_id = 'discord';
+
+-- name: GetEventRoleByDiscordIDAndEventId :one
+SELECT er.event_id, er.role
+FROM event_roles er
+JOIN auth.accounts a ON er.user_id = a.user_id
+WHERE a.provider_id = 'discord'
+    AND a.account_id = $1
+    AND er.event_id = $2;

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

@@ -160,21 +160,27 @@ func (r *EventRepository) GetSubmissionTimes(ctx context.Context, eventId uuid.U
 	return r.db.Query.GetSubmissionTimes(ctx, eventId)
 }
 
-func (r *EventRepository) GetEventRoleByUserID(ctx context.Context, userID uuid.UUID) (*sqlc.GetEventRoleByUserIDRow, error) {
-	eventRole, err := r.db.Query.GetEventRoleByUserID(ctx, userID)
+func (r *EventRepository) GetEventAttendeesWithDiscord(ctx context.Context, eventId uuid.UUID) (*[]sqlc.GetEventAttendeesWithDiscordRow, error) {
+	attendees, err := r.db.Query.GetEventAttendeesWithDiscord(ctx, eventId)
 	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return nil, ErrEventRoleNotFound
-		}
 		return nil, err
 	}
-	return &eventRole, nil
+	return &attendees, nil
 }
 
-func (r *EventRepository) GetEventAttendeesWithDiscord(ctx context.Context, eventId uuid.UUID) (*[]sqlc.GetEventAttendeesWithDiscordRow, error) {
-	attendees, err := r.db.Query.GetEventAttendeesWithDiscord(ctx, eventId)
+func (r *EventRepository) GetEventRoleByDiscordIDAndEventId(ctx context.Context, discordID string, eventID uuid.UUID) (*sqlc.GetEventRoleByDiscordIDAndEventIdRow, error) {
+	params := sqlc.GetEventRoleByDiscordIDAndEventIdParams{
+		AccountID: discordID,
+		EventID:   eventID,
+	}
+
+	eventRole, err := r.db.Query.GetEventRoleByDiscordIDAndEventId(ctx, params)
 	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrEventRoleNotFound
+		}
 		return nil, err
 	}
-	return &attendees, nil
+
+	return &eventRole, nil
 }

apps/api/internal/db/sqlc/event_roles.sql.go

@@ -11,48 +11,35 @@ import (
 )
 
 var (
-    ErrDiscordAccountNotFound = errors.New("discord account not found")
     ErrNoEventRole = errors.New("user has no event role")
 )
 
 type DiscordService struct {
-	accountRepo *repository.AccountRepository
 	eventRepo *repository.EventRepository
 	logger zerolog.Logger
 }
 
 func NewDiscordService(
-	accountRepo *repository.AccountRepository,
 	eventRepo *repository.EventRepository,
 	logger zerolog.Logger,
 ) *DiscordService {
 	return &DiscordService{
-		accountRepo: accountRepo,
 		eventRepo: eventRepo,
 		logger: logger.With().Str("service", "DiscordService").Str("component", "discord").Logger(),
 	}
 }
 
-func (s *DiscordService) GetUserEventRoleByDiscordID(ctx context.Context, discordID string) (*uuid.UUID, *sqlc.EventRoleType, error) {
-	userID, err := s.accountRepo.GetUserIDByDiscordAccountID(ctx, discordID)
-	if err != nil {
-		if err == repository.ErrAccountNotFound {
-			return nil, nil, ErrDiscordAccountNotFound
-		}
-		s.logger.Err(err).Msg("failed to get user ID from discord account")
-		return nil, nil, err
-	}
-
-	eventRole, err := s.eventRepo.GetEventRoleByUserID(ctx, *userID)
+func (s *DiscordService) GetUserEventRoleByDiscordIDAndEventId(ctx context.Context, discordID string, eventID uuid.UUID) (*sqlc.EventRoleType, error) {
+	eventRole, err := s.eventRepo.GetEventRoleByDiscordIDAndEventId(ctx, discordID, eventID)
 	if err != nil {
 		if err == repository.ErrEventRoleNotFound {
-			return nil, nil, ErrNoEventRole
+			return nil, ErrNoEventRole
 		}
-		s.logger.Err(err).Msg("failed to get event role")
-		return nil, nil, err
+		s.logger.Err(err).Msg("failed to get event role by discord ID and event ID")
+		return nil, err
 	}
 
-	return &eventRole.EventID, &eventRole.Role, nil
+	return &eventRole.Role, nil
 }
 
 func (s *DiscordService) GetEventAttendeesWithDiscord(ctx context.Context, eventID uuid.UUID) (*[]sqlc.GetEventAttendeesWithDiscordRow, error) {