Deploy files from GitHub repository

.env.example

@@ -12,10 +12,9 @@ XENDIT_API_KEY =
 XENDIT_CALLBACK_TOKEN =
 MAILGUN_API_KEY =
 MAILGUN_DOMAIN =
-MAILGUN_SENDER =
 MAILGUN_API_BASE_URL = https://api.mailgun.net
-SMTP_HOST = smtp.mailgun.org
-SMTP_PORT = 587
+SMTP_HOST = 
+SMTP_PORT = 
 SMTP_USERNAME =
 SMTP_PASSWORD =
 SMTP_SENDER =

Quzuu_API_Collection.postman_collection.json

@@ -629,6 +629,73 @@
           },
           "response": []
         },
+        {
+          "name": "Event Scoreboard",
+          "request": {
+            "method": "GET",
+            "header": [
+              {
+                "key": "Authorization",
+                "value": "Bearer {{access_token}}",
+                "type": "text"
+              }
+            ],
+            "url": {
+              "raw": "{{base_url}}/api/v1/events/:event_slug/scoreboard?limit=10&page=1&search=&sortBy=total_score&orderBy=desc",
+              "host": [
+                "{{base_url}}"
+              ],
+              "path": [
+                "api",
+                "v1",
+                "events",
+                ":event_slug",
+                "scoreboard"
+              ],
+              "query": [
+                {
+                  "key": "limit",
+                  "value": "10",
+                  "description": "Number of items per page (max 100)"
+                },
+                {
+                  "key": "page",
+                  "value": "1",
+                  "description": "Page number"
+                },
+                {
+                  "key": "search",
+                  "value": "",
+                  "description": "Search keyword"
+                },
+                {
+                  "key": "sortBy",
+                  "value": "total_score",
+                  "description": "Sort field: 'total_score' (default), 'score', 'username', or 'full_name'"
+                },
+                {
+                  "key": "orderBy",
+                  "value": "desc",
+                  "description": "Sort order: 'asc' or 'desc'"
+                },
+                {
+                  "key": "order",
+                  "value": "desc",
+                  "disabled": true,
+                  "description": "Alias for sort order (backward compatibility)"
+                }
+              ],
+              "variable": [
+                {
+                  "key": "event_slug",
+                  "value": ""
+                }
+              ]
+            },
+            "description": "Retrieve a paginated scoreboard of participants ranked by total score across all exams in an event"
+          },
+          "response": []
+        },
         {
           "name": "Exam Scoreboard",
           "request": {
@@ -641,7 +708,7 @@
               }
             ],
             "url": {
-              "raw": "{{base_url}}/api/v1/events/:event_slug/:exam_slug/scoreboard?limit=10&page=1&sortBy=score&order=desc",
+              "raw": "{{base_url}}/api/v1/events/:event_slug/:exam_slug/scoreboard?limit=10&page=1&search=&sortBy=score&orderBy=desc",
               "host": [
                 "{{base_url}}"
               ],
@@ -664,15 +731,26 @@
                   "value": "1",
                   "description": "Page number"
                 },
+                {
+                  "key": "search",
+                  "value": "",
+                  "description": "Search keyword"
+                },
                 {
                   "key": "sortBy",
                   "value": "score",
-                  "description": "Sort field: 'score' (default) or 'duration'"
+                  "description": "Sort field: 'score' (default), 'duration', 'username', or 'full_name'"
                 },
                 {
-                  "key": "order",
+                  "key": "orderBy",
                   "value": "desc",
                   "description": "Sort order: 'asc' or 'desc'"
+                },
+                {
+                  "key": "order",
+                  "value": "desc",
+                  "disabled": true,
+                  "description": "Alias for sort order (backward compatibility)"
                 }
               ],
               "variable": [

Quzuu_Dev_Environment.postman_environment.json

@@ -79,6 +79,12 @@
       "enabled": true,
       "type": "default"
     },
+    {
+      "key": "orderBy",
+      "value": "",
+      "enabled": true,
+      "type": "default"
+    },
     {
       "key": "log_id",
       "value": "",

controllers/event_exam_controller.go

@@ -1,15 +1,15 @@
 package controllers
 
-import (
-	"strconv"
-
-	"abdanhafidz.com/go-boilerplate/models/dto"
-	entity "abdanhafidz.com/go-boilerplate/models/entity"
-	http_error "abdanhafidz.com/go-boilerplate/models/error"
-	"abdanhafidz.com/go-boilerplate/services"
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
+import (
+	"strconv"
+
+	"abdanhafidz.com/go-boilerplate/models/dto"
+	entity "abdanhafidz.com/go-boilerplate/models/entity"
+	http_error "abdanhafidz.com/go-boilerplate/models/error"
+	"abdanhafidz.com/go-boilerplate/services"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
 
 type EventExamController interface {
 	Attempt(ctx *gin.Context)
@@ -17,6 +17,7 @@ type EventExamController interface {
 	Submit(ctx *gin.Context)
 	List(ctx *gin.Context)
 	Scoreboard(ctx *gin.Context)
+	EventScoreboard(ctx *gin.Context)
 }
 
 type eventExamController struct {
@@ -60,17 +61,17 @@ func (c *eventExamController) Attempt(ctx *gin.Context) {
 // @Success      200           {object}  dto.SuccessResponse[dto.AnswerEventExamRequest]
 // @Failure      400           {object}  dto.ErrorResponse
 // @Router       /api/v1/events/{event_slug}/exam/{attempt_id}/answer_question [post]
-func (c *eventExamController) Answer(ctx *gin.Context) {
-	eventSlug := ctx.Param("event_slug")
-	attemptId, err := uuid.Parse(ctx.Param("attempt_id"))
-	if err != nil {
-		ResponseJSON[any](ctx, gin.H{"attempt_id": ctx.Param("attempt_id")}, nil, http_error.INVALID_TOKEN)
-		return
-	}
-	req := RequestJSON[dto.AnswerEventExamRequest](ctx)
-	res, err := c.eventExamService.AnswerEventExam(ctx.Request.Context(), eventSlug, attemptId, req.QuestionId, req.Answer)
-	ResponseJSON(ctx, gin.H{"cp_grader_result": res}, req, err)
-}
+func (c *eventExamController) Answer(ctx *gin.Context) {
+	eventSlug := ctx.Param("event_slug")
+	attemptId, err := uuid.Parse(ctx.Param("attempt_id"))
+	if err != nil {
+		ResponseJSON[any](ctx, gin.H{"attempt_id": ctx.Param("attempt_id")}, nil, http_error.INVALID_TOKEN)
+		return
+	}
+	req := RequestJSON[dto.AnswerEventExamRequest](ctx)
+	res, err := c.eventExamService.AnswerEventExam(ctx.Request.Context(), eventSlug, attemptId, req.QuestionId, req.Answer)
+	ResponseJSON(ctx, gin.H{"cp_grader_result": res}, req, err)
+}
 
 // Submit Exam Event godoc
 // @Summary      Submit Exam Event
@@ -84,15 +85,15 @@ func (c *eventExamController) Answer(ctx *gin.Context) {
 // @Failure      400           {object}  dto.ErrorResponse
 // @Router       /api/v1/events/{event_slug}/exam/{attempt_id}/submit [post]
 
-func (c *eventExamController) Submit(ctx *gin.Context) {
-	attemptId, err := uuid.Parse(ctx.Param("attempt_id"))
-	if err != nil {
-		ResponseJSON[any](ctx, gin.H{"attempt_id": ctx.Param("attempt_id")}, nil, http_error.INVALID_TOKEN)
-		return
-	}
-	res, err := c.eventExamService.SubmitEventExam(ctx.Request.Context(), attemptId)
-	ResponseJSON(ctx, gin.H{}, res, err)
-}
+func (c *eventExamController) Submit(ctx *gin.Context) {
+	attemptId, err := uuid.Parse(ctx.Param("attempt_id"))
+	if err != nil {
+		ResponseJSON[any](ctx, gin.H{"attempt_id": ctx.Param("attempt_id")}, nil, http_error.INVALID_TOKEN)
+		return
+	}
+	res, err := c.eventExamService.SubmitEventExam(ctx.Request.Context(), attemptId)
+	ResponseJSON(ctx, gin.H{}, res, err)
+}
 
 // List Exam by Event godoc
 // @Summary      List Exams by Event
@@ -111,31 +112,15 @@ func (c *eventExamController) List(ctx *gin.Context) {
 	ResponseJSON(ctx, gin.H{}, res, err)
 }
 
-// Scoreboard godoc
-// @Summary      Exam Scoreboard
-// @Description  Retrieve a paginated scoreboard of participants ranked by their performance in a specific exam within an event
-// @Tags         Exam Event
-// @Accept       json
-// @Produce      json
-// @Param        event_slug  path      string  true   "Event Slug"
-// @Param        exam_slug   path      string  true   "Exam Slug"
-// @Param        limit       query     int     false  "Number of items per page"  default(10)
-// @Param        page        query     int     false  "Page number"               default(1)
-// @Param        sortBy      query     string  false  "Sort field: 'score' (default) or 'duration'"
-// @Param        order       query     string  false  "Sort order: 'asc' or 'desc'"
-// @Success      200         {object}  dto.SuccessResponse[[]dto.ExamScoreboardItem]
-// @Failure      400         {object}  dto.ErrorResponse
-// @Security     BearerAuth
-// @Router       /api/v1/events/{event_slug}/{exam_slug}/scoreboard [get]
-func (c *eventExamController) Scoreboard(ctx *gin.Context) {
-	eventSlug := ctx.Param("event_slug")
-	examSlug := ctx.Param("exam_slug")
-	accountId := ParseAccountId(ctx)
-
+func parseScoreboardPagination(ctx *gin.Context, defaultSort string, defaultOrder string) (int, int, entity.Pagination) {
 	limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
 	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
-	sortBy := ctx.DefaultQuery("sortBy", "score")
-	order := ctx.DefaultQuery("order", "desc")
+	search := ctx.DefaultQuery("search", "")
+	sortBy := ctx.DefaultQuery("sortBy", defaultSort)
+	order := ctx.DefaultQuery("orderBy", "")
+	if order == "" {
+		order = ctx.DefaultQuery("order", defaultOrder)
+	}
 
 	if limit < 1 {
 		limit = 10
@@ -147,29 +132,77 @@ func (c *eventExamController) Scoreboard(ctx *gin.Context) {
 	}
 
 	offset := (page - 1) * limit
-	p := entity.Pagination{Limit: limit, Offset: offset, SortBy: sortBy, Order: order}
-
-	list, total, err := c.eventExamService.Scoreboard(ctx.Request.Context(), eventSlug, examSlug, accountId, p)
+	return limit, page, entity.Pagination{Limit: limit, Offset: offset, Search: search, SortBy: sortBy, Order: order}
+}
 
-	var totalPages int
-	if total == 0 {
-		totalPages = 1
-	} else {
+func buildPaginationMeta(limit int, page int, total int64) gin.H {
+	totalPages := 1
+	if total > 0 {
 		totalPages = int((total + int64(limit) - 1) / int64(limit))
 	}
 
 	if page > totalPages {
 		page = totalPages
-		offset = (page - 1) * limit
-		p.Offset = offset
-		list, total, err = c.eventExamService.Scoreboard(ctx.Request.Context(), eventSlug, examSlug, accountId, p)
 	}
 
-	meta := gin.H{
+	return gin.H{
 		"totalItems":  total,
 		"totalPages":  totalPages,
 		"currentPage": page,
+		"limit":       limit,
 	}
+}
 
+// Scoreboard godoc
+// @Summary      Exam Scoreboard
+// @Description  Retrieve a paginated scoreboard of participants ranked by their performance in a specific exam within an event
+// @Tags         Exam Event
+// @Accept       json
+// @Produce      json
+// @Param        event_slug  path      string  true   "Event Slug"
+// @Param        exam_slug   path      string  true   "Exam Slug"
+// @Param        limit       query     int     false  "Number of items per page"  default(10)
+// @Param        page        query     int     false  "Page number"               default(1)
+// @Param        search      query     string  false  "Search keyword"
+// @Param        sortBy      query     string  false  "Sort field: 'score' (default) or 'duration'"
+// @Param        orderBy     query     string  false  "Sort order: 'asc' or 'desc'"
+// @Param        order       query     string  false  "Sort order alias: 'asc' or 'desc'"
+// @Success      200         {object}  dto.SuccessResponse[[]dto.ExamScoreboardItem]
+// @Failure      400         {object}  dto.ErrorResponse
+// @Security     BearerAuth
+// @Router       /api/v1/events/{event_slug}/{exam_slug}/scoreboard [get]
+func (c *eventExamController) Scoreboard(ctx *gin.Context) {
+	eventSlug := ctx.Param("event_slug")
+	examSlug := ctx.Param("exam_slug")
+	accountId := ParseAccountId(ctx)
+	limit, page, p := parseScoreboardPagination(ctx, "score", "desc")
+	list, total, err := c.eventExamService.Scoreboard(ctx.Request.Context(), eventSlug, examSlug, accountId, p)
+	meta := buildPaginationMeta(limit, page, total)
+	ResponseJSON(ctx, meta, list, err)
+}
+
+// Event Scoreboard godoc
+// @Summary      Event Scoreboard
+// @Description  Retrieve a paginated scoreboard of participants based on total score across all exams in an event
+// @Tags         Exam Event
+// @Accept       json
+// @Produce      json
+// @Param        event_slug  path      string  true   "Event Slug"
+// @Param        limit       query     int     false  "Number of items per page"  default(10)
+// @Param        page        query     int     false  "Page number"               default(1)
+// @Param        search      query     string  false  "Search keyword"
+// @Param        sortBy      query     string  false  "Sort field: 'total_score' (default), 'username', or 'full_name'"
+// @Param        orderBy     query     string  false  "Sort order: 'asc' or 'desc'"
+// @Param        order       query     string  false  "Sort order alias: 'asc' or 'desc'"
+// @Success      200         {object}  dto.SuccessResponse[[]dto.EventScoreboardItem]
+// @Failure      400         {object}  dto.ErrorResponse
+// @Security     BearerAuth
+// @Router       /api/v1/events/{event_slug}/scoreboard [get]
+func (c *eventExamController) EventScoreboard(ctx *gin.Context) {
+	eventSlug := ctx.Param("event_slug")
+	accountId := ParseAccountId(ctx)
+	limit, page, p := parseScoreboardPagination(ctx, "total_score", "desc")
+	list, total, err := c.eventExamService.EventScoreboard(ctx.Request.Context(), eventSlug, accountId, p)
+	meta := buildPaginationMeta(limit, page, total)
 	ResponseJSON(ctx, meta, list, err)
 }

models/dto/event_dto.go

@@ -21,23 +21,23 @@ type EventStatus struct {
 }
 
 type CreateEventRequest struct {
-	Title      string `json:"title" binding:"required"`
-	StartEvent string `json:"start_event" binding:"required"`
-	EndEvent   string `json:"end_event" binding:"required"`
-	Overview   string `json:"overview" binding:"required"`
-	ImgBanner  string `json:"img_banner" binding:"required"`
-	EventCode  string `json:"event_code"`
-	IsPublic   bool   `json:"is_public"`
+	Title      string  `json:"title" binding:"required"`
+	StartEvent string  `json:"start_event" binding:"required"`
+	EndEvent   string  `json:"end_event" binding:"required"`
+	Overview   string  `json:"overview" binding:"required"`
+	ImgBanner  string  `json:"img_banner" binding:"required"`
+	EventCode  string  `json:"event_code"`
+	IsPublic   bool    `json:"is_public"`
 	Price      float64 `json:"price"`
 }
 
 type UpdateEventRequest struct {
-	Title      string `json:"title"`
-	StartEvent string `json:"start_event"`
-	EndEvent   string `json:"end_event"`
-	Overview   string `json:"overview"`
-	ImgBanner  string `json:"img_banner"`
-	IsPublic   *bool  `json:"is_public"`
+	Title      string   `json:"title"`
+	StartEvent string   `json:"start_event"`
+	EndEvent   string   `json:"end_event"`
+	Overview   string   `json:"overview"`
+	ImgBanner  string   `json:"img_banner"`
+	IsPublic   *bool    `json:"is_public"`
 	Price      *float64 `json:"price"`
 }
 
@@ -59,6 +59,12 @@ type ExamScoreboardItem struct {
 	Duration string  `json:"duration"`
 }
 
+type EventScoreboardItem struct {
+	Username   string  `json:"username"`
+	FullName   string  `json:"full_name,omitempty"`
+	TotalScore float32 `json:"total_score"`
+}
+
 type AdminEventResponse struct {
 	entity.Events
 	ParticipantCount int64 `json:"participant_count"`

models/entity/entity.go

@@ -287,6 +287,13 @@ type ExamScoreboardEntry struct {
 	DurationSeconds int64
 }
 
+type EventScoreboardEntry struct {
+	AccountId  uuid.UUID
+	Username   string
+	FullName   string
+	TotalScore float32
+}
+
 type EventExamAttempt struct {
 	Id        uuid.UUID         `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id_attempt"`
 	AccountId uuid.UUID         `json:"id_account,omitempty"`

repositories/event_exam_attempt_repository.go

@@ -2,6 +2,7 @@ package repositories
 
 import (
 	"context"
+	"strings"
 
 	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	"github.com/google/uuid"
@@ -14,6 +15,7 @@ type EventExamAttemptRepository interface {
 	GetByEventExam(ctx context.Context, eventId uuid.UUID, examId uuid.UUID, accountId uuid.UUID) (entity.EventExamAttempt, error)
 	Update(ctx context.Context, a *entity.EventExamAttempt) error
 	GetScoreboard(ctx context.Context, eventId uuid.UUID, examId uuid.UUID, p entity.Pagination) ([]entity.ExamScoreboardEntry, int64, error)
+	GetEventScoreboard(ctx context.Context, eventId uuid.UUID, p entity.Pagination) ([]entity.EventScoreboardEntry, int64, error)
 }
 
 type eventExamAttemptRepository struct{ db *gorm.DB }
@@ -76,6 +78,12 @@ func (r *eventExamAttemptRepository) GetScoreboard(ctx context.Context, eventId
 	case "duration":
 		col = "duration_seconds"
 		ord = "ASC"
+	case "username":
+		col = "a.username"
+		ord = "ASC"
+	case "full_name":
+		col = "COALESCE(ad.full_name, '')"
+		ord = "ASC"
 	}
 
 	if p.Order == "asc" {
@@ -84,6 +92,16 @@ func (r *eventExamAttemptRepository) GetScoreboard(ctx context.Context, eventId
 		ord = "DESC"
 	}
 
+	whereSQL := "WHERE eea.event_id = ? AND eea.exam_id = ?"
+	args := []any{eventId, examId}
+
+	search := strings.TrimSpace(p.Search)
+	if search != "" {
+		like := "%" + search + "%"
+		whereSQL += " AND (a.username ILIKE ? OR COALESCE(ad.full_name, '') ILIKE ?)"
+		args = append(args, like, like)
+	}
+
 	rawSQL := `
 		SELECT
 			a.id                                                        AS account_id,
@@ -100,13 +118,14 @@ func (r *eventExamAttemptRepository) GetScoreboard(ctx context.Context, eventId
 		JOIN exam_event_attempt eea ON eea.id = r.attempt_id
 		JOIN account a ON a.id = eea.account_id
 		LEFT JOIN account_details ad ON ad.account_id = a.id
-		WHERE eea.event_id = ? AND eea.exam_id = ?
+		` + whereSQL + `
 		ORDER BY ` + col + ` ` + ord + `
 		LIMIT ? OFFSET ?
 	`
 
 	var rows []rawRow
-	if err := r.db.WithContext(ctx).Raw(rawSQL, eventId, examId, p.Limit, p.Offset).Scan(&rows).Error; err != nil {
+	args = append(args, p.Limit, p.Offset)
+	if err := r.db.WithContext(ctx).Raw(rawSQL, args...).Scan(&rows).Error; err != nil {
 		return nil, 0, err
 	}
 
@@ -129,3 +148,85 @@ func (r *eventExamAttemptRepository) GetScoreboard(ctx context.Context, eventId
 
 	return entries, total, nil
 }
+
+func (r *eventExamAttemptRepository) GetEventScoreboard(ctx context.Context, eventId uuid.UUID, p entity.Pagination) ([]entity.EventScoreboardEntry, int64, error) {
+	type rawRow struct {
+		AccountId  string
+		Username   string
+		FullName   string
+		TotalScore float32
+		TotalCount int64
+	}
+
+	col := "total_score"
+	ord := "DESC"
+
+	switch p.SortBy {
+	case "username":
+		col = "a.username"
+		ord = "ASC"
+	case "full_name":
+		col = "COALESCE(ad.full_name, '')"
+		ord = "ASC"
+	case "total_score", "score":
+		col = "total_score"
+		ord = "DESC"
+	}
+
+	if p.Order == "asc" {
+		ord = "ASC"
+	} else if p.Order == "desc" {
+		ord = "DESC"
+	}
+
+	whereSQL := "WHERE eea.event_id = ?"
+	args := []any{eventId}
+
+	search := strings.TrimSpace(p.Search)
+	if search != "" {
+		like := "%" + search + "%"
+		whereSQL += " AND (a.username ILIKE ? OR COALESCE(ad.full_name, '') ILIKE ?)"
+		args = append(args, like, like)
+	}
+
+	rawSQL := `
+		SELECT
+			a.id                           AS account_id,
+			a.username                     AS username,
+			COALESCE(ad.full_name, '')     AS full_name,
+			SUM(r.final_score)             AS total_score,
+			COUNT(*) OVER()                AS total_count
+		FROM result r
+		JOIN exam_event_attempt eea ON eea.id = r.attempt_id
+		JOIN account a ON a.id = eea.account_id
+		LEFT JOIN account_details ad ON ad.account_id = a.id
+		` + whereSQL + `
+		GROUP BY a.id, a.username, ad.full_name
+		ORDER BY ` + col + ` ` + ord + `
+		LIMIT ? OFFSET ?
+	`
+
+	var rows []rawRow
+	args = append(args, p.Limit, p.Offset)
+	if err := r.db.WithContext(ctx).Raw(rawSQL, args...).Scan(&rows).Error; err != nil {
+		return nil, 0, err
+	}
+
+	var total int64
+	if len(rows) > 0 {
+		total = rows[0].TotalCount
+	}
+
+	entries := make([]entity.EventScoreboardEntry, 0, len(rows))
+	for _, row := range rows {
+		id, _ := uuid.Parse(row.AccountId)
+		entries = append(entries, entity.EventScoreboardEntry{
+			AccountId:  id,
+			Username:   row.Username,
+			FullName:   row.FullName,
+			TotalScore: row.TotalScore,
+		})
+	}
+
+	return entries, total, nil
+}

router/event_exam_proctoring_router.go

@@ -10,7 +10,7 @@ func EventExamProctoringRouter(router *gin.Engine, middleware provider.Middlewar
 	auth := middleware.ProvideAuthenticationMiddleware()
 
 	// Group under api/v1/events to match existing event structure
-	routerGroup := router.Group("api/v1/proctoring")
+	routerGroup := router.Group("api/v1/events")
 	{
 		// :event_slug and :exam_slug are kept for context/consistency with other routes,
 		// even if not strictly used for lookup (IDs are in body/query).

router/event_exam_router.go

@@ -14,6 +14,7 @@ func EventExamRouter(router *gin.Engine, middleware provider.MiddlewareProvider,
 		routerGroup.GET("/:event_slug/exam/:exam_slug/attempt", auth.VerifyAccount, eventExamController.Attempt)
 		routerGroup.POST("/:event_slug/exam/:attempt_id/answer_question", auth.VerifyAccount, eventExamController.Answer)
 		routerGroup.POST("/:event_slug/exam/:attempt_id/submit", auth.VerifyAccount, eventExamController.Submit)
+		routerGroup.GET("/:event_slug/scoreboard", auth.VerifyAccount, eventExamController.EventScoreboard)
 		routerGroup.GET("/:event_slug/:exam_slug/scoreboard", auth.VerifyAccount, eventExamController.Scoreboard)
 	}
 }

services/event_exam_service.go

@@ -26,6 +26,7 @@ type EventExamService interface {
 	SubmitEventExam(ctx context.Context, attemptId uuid.UUID) (result entity.Result, err error)
 	AnswerEventExam(ctx context.Context, eventSlug string, attemptId uuid.UUID, questionId uuid.UUID, answer []string) (entity.CPQuestionVerdict, error)
 	Scoreboard(ctx context.Context, eventSlug string, examSlug string, accountId uuid.UUID, p entity.Pagination) ([]dto.ExamScoreboardItem, int64, error)
+	EventScoreboard(ctx context.Context, eventSlug string, accountId uuid.UUID, p entity.Pagination) ([]dto.EventScoreboardItem, int64, error)
 }
 
 type evaluator func(answer []string) (float32, entity.CPQuestionVerdict)
@@ -266,8 +267,6 @@ func (s *eventExamService) AttemptEventExam(ctx context.Context, eventSlug strin
 	}
 	attemptStatus, eventExamAttempt, err := s.GetEventExamAttempt(ctx, eventSlug, examSlug, accountId)
 
-	
-
 	if err != nil {
 		return entity.EventExamAttempt{}, err
 	}
@@ -507,3 +506,26 @@ func (s *eventExamService) Scoreboard(ctx context.Context, eventSlug string, exa
 
 	return items, total, nil
 }
+
+func (s *eventExamService) EventScoreboard(ctx context.Context, eventSlug string, accountId uuid.UUID, p entity.Pagination) ([]dto.EventScoreboardItem, int64, error) {
+	ev, err := s.eventService.DetailBySlug(ctx, eventSlug, accountId)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	entries, total, err := s.eventExamAttemptRepo.GetEventScoreboard(ctx, ev.Data.Id, p)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	items := make([]dto.EventScoreboardItem, 0, len(entries))
+	for _, entry := range entries {
+		items = append(items, dto.EventScoreboardItem{
+			Username:   entry.Username,
+			FullName:   entry.FullName,
+			TotalScore: entry.TotalScore,
+		})
+	}
+
+	return items, total, nil
+}