Leaderboard and Room/Round Circular Dependency (#40)

* Support For Joining and Leaving Rooms (RTC Side)

* remove leaderboardKey

* add leaderboardKey

* GetLeaderboard()

* refactored JoinRoom

* fixed FindRoomEndpoint

* refactored LeaveRoom

* compressScoreAndTimeStamp

* inverted time

* deleteLeaderboard

* Organized functions

* Added comments

* Fixed rdb dependency in round_test

* typo

* Fix Some Room Edge Cases That Crash Server

* Moved CreateNewRound and StartRound to RoomController

* removed RoundController

* room cascade delete rounds

* append round to room on round create

* CreateNewRound by roomID path param

* GetLeaderboardEndpoint

* Deleted round-accessor

* Fixed InitiateRoundStart

* on room delete remove leaderboards

* Move request types to separate file. (#37)

* GetLeaderboard room.Rounds null check

* feat: added database relation

* feat: added implementation for round submission

* refactor: refactored auto migrate logic

* test: added unit test

* refactor: changed evaluation order

* feat: resolved remaining TODOs

Added check to prevent double counting AC submissions in a round.
Added check to prevent mismatch between problem and round's problemset.

* refactor: fixed unit test

* fix: added timestamp to submission

* GetLeaderboardByRoomID and GetLeaderboardByRoundID

* Remove test syntax errors

* Create Round Participant if Round is already started

* Leaderboard

add leaderboardKey

GetLeaderboard()

refactored JoinRoom

fixed FindRoomEndpoint

refactored LeaveRoom

compressScoreAndTimeStamp

inverted time

deleteLeaderboard

Organized functions

Added comments

Fixed rdb dependency in round_test

typo

* Moved CreateNewRound and StartRound to RoomController

removed RoundController

room cascade delete rounds

append round to room on round create

CreateNewRound by roomID path param

GetLeaderboardEndpoint

Deleted round-accessor

Fixed InitiateRoundStart

on room delete remove leaderboards

GetLeaderboard room.Rounds null check

GetLeaderboardByRoomID and GetLeaderboardByRoundID

Remove test syntax errors

Create Round Participant if Round is already started

* Merged RoundSubmissionService into RoundService

* fix: fixed test case

* Fixed RoundStart

* Round Start once check

* fix: fixed test case

* Mike Feedback

---------

Co-authored-by: Jude Joubert <[email protected]>
Co-authored-by: Jude Joubert <[email protected]>
Co-authored-by: Solomon Wakhungu <[email protected]>
Co-authored-by: Mike Nguyen <[email protected]>
Co-authored-by: Mike Nguyen <[email protected]>

Author: 4 people

central-service/controllers/room.go

@@ -28,8 +28,8 @@ func (controller *RoomController) CreateNewRoomEndpoint(c echo.Context) error {
 	newRoom, err := controller.roomService.CreateRoom(&roomDTO, userAuthID)
 	if err != nil {
 		log.Printf("User id: %s failed to create room object: %v\n", userAuthID, err)
-		if _, ok := err.(services.RoomServiceError); ok {
-			return echo.NewHTTPError(http.StatusBadRequest, "Failed to create room. " + err.Error())
+		if err, ok := err.(services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to create room. "+err.Error())
 		}
 		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create room. Please try again later")
 	}
@@ -44,10 +44,10 @@ func (controller *RoomController) FindRoomEndpoint(c echo.Context) error {
 	room, err := controller.roomService.FindRoomByID(targetRoomID)
 	if err != nil {
 		log.Printf("Failed to search for room with id %s: %v\n", targetRoomID, err)
-		return echo.NewHTTPError(http.StatusInternalServerError)
-	}
-	if room == nil {
-		return echo.NewHTTPError(http.StatusNotFound, "Room not found")
+		if err, ok := err.(services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Room not found")
+		}
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find room. Please try again later")
 	}
 	return c.JSON(http.StatusOK, map[string]models.Room{
 		"data": *room,
@@ -61,10 +61,10 @@ func (controller *RoomController) JoinRoomEndpoint(c echo.Context) error {
 	room, err := controller.roomService.JoinRoom(roomID, userAuthID)
 	if err != nil {
 		log.Printf("User id: %s failed to join room with id %s: %v\n", userAuthID, roomID, err)
-		if _, ok := err.(services.RoomServiceError); ok {
-			return echo.NewHTTPError(http.StatusBadRequest, "Failed to join room. " + err.Error())
+		if err, ok := err.(services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to join room. "+err.Error())
 		}
-		return echo.NewHTTPError(http.StatusInternalServerError)
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to join room. Please try again later")
 	}
 	return c.JSON(http.StatusOK, map[string]models.Room{
 		"data": *room,
@@ -78,19 +78,73 @@ func (controller *RoomController) LeaveRoomEndpoint(c echo.Context) error {
 	err := controller.roomService.LeaveRoom(roomID, userAuthID)
 	if err != nil {
 		log.Printf("User id: %s failed to leave room with id %s: %v\n", userAuthID, roomID, err)
-		if _, ok := err.(services.RoomServiceError); ok {
-			return echo.NewHTTPError(http.StatusBadRequest, "Failed to leave room. " + err.Error())
+		if err, ok := err.(services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to leave room. "+err.Error())
 		}
-		return echo.NewHTTPError(http.StatusInternalServerError)
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to leave room. Please try again later")
 	}
 	return c.JSON(http.StatusOK, map[string]string{
 		"message": "Successfully Left Room",
 	})
 }
 
+func (controller *RoomController) CreateNewRoundEndpoint(c echo.Context) error {
+	var roundCreationParams services.RoundCreationParameters
+	if err := c.Bind(&roundCreationParams); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid data. Please try again")
+	}
+	roomID := c.Param("roomID")
+	newRound, err := controller.roomService.CreateRound(&roundCreationParams, roomID)
+	if err != nil {
+		log.Printf("Failed to create new round: %v\n", err)
+		if err, ok := err.(*services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to create round. "+err.Message)
+		}
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create round. Please try again later")
+	}
+	return c.JSON(http.StatusCreated, map[string]models.Round{
+		"data": *newRound,
+	})
+}
+
+func (controller *RoomController) StartRoundEndpoint(c echo.Context) error {
+	targetRoomID := c.Param("roomID")
+	userAuthID := c.Get("authToken").(*auth.Token).UID
+	roundStartTime, err := controller.roomService.StartRoundByRoomID(targetRoomID, userAuthID)
+	if err != nil {
+		log.Printf("Failed to start round for room with id %s: %v\n", targetRoomID, err)
+		if err, ok := err.(*services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to start round. "+err.Message)
+		}
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to start round. Please try again later")
+	}
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"startTime": roundStartTime.Unix(),
+	})
+}
+
+func (controller *RoomController) GetLeaderboardEndpoint(c echo.Context) error {
+	roomID := c.Param("roomID")
+	leaderboard, err := controller.roomService.GetLeaderboard(roomID)
+	if err != nil {
+		log.Printf("Failed to get leaderboard for room with id %s: %v\n", roomID, err)
+		if err, ok := err.(services.BSGError); ok {
+			return echo.NewHTTPError(err.StatusCode, "Failed to get leaderboard. "+err.Message)
+		}
+		return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get leaderboard. Please try again later")
+	}
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"leaderboard": leaderboard,
+	})
+}
+
 func (controller *RoomController) InitializeRoutes(g *echo.Group) {
 	g.POST("/", controller.CreateNewRoomEndpoint)
-	g.GET("/:roomID", controller.FindRoomEndpoint)
 	g.POST("/:roomID/join", controller.JoinRoomEndpoint)
 	g.POST("/:roomID/leave", controller.LeaveRoomEndpoint)
-}
+	g.POST("/:roomID/rounds/create", controller.CreateNewRoundEndpoint)
+	g.POST("/:roomID/start", controller.StartRoundEndpoint)
+	g.GET("/:roomID", controller.FindRoomEndpoint)
+	g.GET("/:roomID/leaderboard", controller.GetLeaderboardEndpoint)
+	// TODO: add routes to submit problem to room
+}

central-service/controllers/round.go

@@ -49,7 +49,7 @@ func main() {
 		fmt.Printf("Error migrating Submission schema: %v\n", err)
 	}
 	if err := db.AutoMigrate(&models.RoundSubmission{}); err != nil {
-		fmt.Printf("Error migrating RoundSubmission schema: %v\n",err)
+		fmt.Printf("Error migrating RoundSubmission schema: %v\n", err)
 	}
 	e := echo.New()
 
@@ -59,27 +59,20 @@ func main() {
 	problemService := services.InitializeProblemService(db)
 	problemController := controllers.InitializeProblemController(&problemService)
 
-	roomService := services.InitializeRoomService(db, rdb, maxNumRoundsPerRoom)
-	roomController := controllers.InitializeRoomController(&roomService)
-	roomAccessor := services.NewRoomAccessor(&roomService)
 	problemAccessor := services.NewProblemAccessor(&problemService)
 	roundScheduler := tasks.New()
 	defer roundScheduler.Stop()
-	roundService := services.InitializeRoundService(db, rdb, &roomAccessor, roundScheduler, &problemAccessor)
-	roundAccessor := services.NewRoundAccessor(&roundService)
-	roundSubmissionService := services.InitializeRoundSubmissionService(db, &problemAccessor, &roundAccessor)
-	roundController := controllers.InitializeRoundController(&roundService, &userService, &roomService, &roundSubmissionService)
+	roundService := services.InitializeRoundService(db, rdb, roundScheduler, &problemAccessor)
 
-	// TODO: Initialize Kafka-related components
-	// TODO: Create a co-routine to listen for messages coming from Kafka and update database
+	roomService := services.InitializeRoomService(db, rdb, &roundService, maxNumRoundsPerRoom)
+	roomController := controllers.InitializeRoomController(&roomService)
 
 	e.Use(middleware.CORS())
 	e.Use(userController.ValidateUserRequest)
 
 	userController.InitializeRoutes(e.Group("/api/users"))
 	problemController.InitializeRoutes(e.Group("/api/problems"))
 	roomController.InitializeRoutes(e.Group("/api/rooms"))
-	roundController.InitializeRoutes(e.Group("/api/rounds"))
 
 	e.Logger.Fatal(e.Start(":5000"))
 }

central-service/main.go

@@ -6,5 +6,5 @@ type Room struct {
 	ID     uuid.UUID `gorm:"primaryKey" json:"id"`
 	Admin  string    `gorm:"not null" json:"adminId"`
 	Name   string    `json:"roomName"`
-	Rounds []Round   `gorm:"foreignKey:RoomID"`
+	Rounds []Round   `gorm:"constraint:OnUpdate:CASCADE,OnDelete:CASCADE;" json:"rounds"`
 }

central-service/models/room.go

@@ -0,0 +1,10 @@
+package services
+
+type BSGError struct {
+	StatusCode int
+	Message    string
+}
+
+func (e BSGError) Error() string {
+	return e.Message
+}

central-service/services/bsg-error.go

@@ -12,9 +12,9 @@ type ProblemService struct {
 }
 
 type DifficultyParameter struct {
-	NumEasyProblems int
+	NumEasyProblems   int
 	NumMediumProblems int
-	NumHardProblems int
+	NumHardProblems   int
 }
 
 func InitializeProblemService(db *gorm.DB) ProblemService {
@@ -78,24 +78,24 @@ func (service *ProblemService) GenerateProblemsetByDifficultyParameters(params D
 	err := service.db.Transaction(func(tx *gorm.DB) error {
 		if err := tx.Clauses(clause.OrderBy{
 			Expression: clause.Expr{
-				SQL: "RAND()",
+				SQL: "RANDOM()",
 			},
 		}).Where("difficulty = ?", constants.DIFFICULTY_EASY).Limit(params.NumEasyProblems).Find(&easyProblems).Error; err != nil {
 			return err
 		}
 		if err := tx.Clauses(clause.OrderBy{
 			Expression: clause.Expr{
-				SQL: "RAND()",
+				SQL: "RANDOM()",
 			},
 		}).Where("difficulty = ?", constants.DIFFICULTY_MEDIUM).Limit(params.NumMediumProblems).Find(&mediumProblems).Error; err != nil {
 			return err
 		}
 		if err := tx.Clauses(clause.OrderBy{
 			Expression: clause.Expr{
-				SQL: "RAND()",
+				SQL: "RANDOM()",
 			},
 		}).Where("difficulty = ?", constants.DIFFICULTY_HARD).Limit(params.NumHardProblems).Order(clause.Expr{
-			SQL: "RAND()",
+			SQL: "RANDOM()",
 		}).Find(&hardProblems).Error; err != nil {
 			return err
 		}
@@ -119,4 +119,4 @@ func (service *ProblemService) DetermineScoreForProblem(problem *models.Problem)
 	}
 
 	return 5
-}
+}