Implement Room listing

cmd/feelbeatserver/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/feelbeatapp/feelbeatserver/internal/infra/ws"
 	"github.com/feelbeatapp/feelbeatserver/internal/lib/component"
 	"github.com/feelbeatapp/feelbeatserver/internal/lib/roomrepository"
+	"github.com/feelbeatapp/feelbeatserver/internal/thirdparty/spotify"
 	"github.com/knadh/koanf/v2"
 )
 
@@ -41,7 +42,7 @@ func main() {
 		ws.ServeWebsockets(hub, w, r)
 	})
 
-	setupAPI(auth.AuthorizeThroughSpotify, roomrepository.NewInMemoryRoomRepository())
+	setupAPI(auth.AuthorizeThroughSpotify, roomrepository.NewInMemoryRoomRepository(spotify.SpotifyApi{}))
 
 	fblog.Info(component.FeelBeatServer, "Server started", "port", port)
 	log.Fatal(http.ListenAndServe(fmt.Sprintf("localhost:%d", port), nil))

cmd/feelbeatserver/setupapi.go

@@ -10,12 +10,10 @@ import (
 
 const baseUrl = "/api/v1"
 
-// TODO: Add contexts to api handler for graceful shutdown
-
 func setupAPI(authWrapper auth.AuthWrapper, roomRepo roomrepository.RoomRepository) {
 	roomApi := roomapi.NewRoomApi(roomRepo)
 
-	handlers := []func(string, auth.AuthWrapper){roomApi.ServeCreateGame}
+	handlers := []func(string, auth.AuthWrapper){roomApi.ServeCreateGame, roomApi.ServeFetchRooms}
 
 	fblog.Info(component.Api, "Setting up REST API", "handlers count", len(handlers))
 

internal/infra/api/roomapi/creategame.go

@@ -18,7 +18,7 @@ type createGameResponse struct {
 	RoomId string `json:"roomId"`
 }
 
-func (r RoomApi) createGameHandler(userId string, res http.ResponseWriter, req *http.Request) {
+func (r RoomApi) createGameHandler(user auth.User, res http.ResponseWriter, req *http.Request) {
 	var payload room.RoomSettings
 	err := api.ParseBody(req.Body, &payload)
 	if err != nil {
@@ -27,7 +27,7 @@ func (r RoomApi) createGameHandler(userId string, res http.ResponseWriter, req *
 		return
 	}
 
-	roomId, err := r.roomRepo.CreateRoom(userId, payload)
+	roomId, err := r.roomRepo.CreateRoom(user, payload)
 	if err != nil {
 		var fbError *feelbeaterror.FeelBeatError
 		if errors.As(err, &fbError) {
@@ -36,26 +36,26 @@ func (r RoomApi) createGameHandler(userId string, res http.ResponseWriter, req *
 			http.Error(res, feelbeaterror.Default, feelbeaterror.StatusCode(feelbeaterror.Default))
 		}
 
-		api.LogApiError("Create room failed", err, userId, req)
+		api.LogApiError("Create room failed", err, user.Profile.Id, req)
 		return
 	}
 
 	resJson, err := json.Marshal(createGameResponse{
 		RoomId: roomId,
 	})
 	if err != nil {
-		api.LogApiError("Couldn't encode response", err, userId, req)
+		api.LogApiError("Couldn't encode response", err, user.Profile.Id, req)
 		return
 	}
 
 	res.Header().Set("Content-Type", "application/json")
-	_, err = res.Write(resJson)
+	err = api.SendJsonResponse(&res, resJson)
 	if err != nil {
-		api.LogApiError("Couldn't write response", err, userId, req)
+		api.LogApiError("Couldn't write response", err, user.Profile.Id, req)
 		return
 	}
 
-	api.LogApiCall(userId, req)
+	api.LogApiCall(user.Profile.Id, req)
 }
 
 func (r RoomApi) ServeCreateGame(baseUrl string, authWrapper auth.AuthWrapper) {

internal/infra/api/roomapi/fetchgames.go

@@ -0,0 +1,56 @@
+package roomapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/feelbeatapp/feelbeatserver/internal/infra/api"
+	"github.com/feelbeatapp/feelbeatserver/internal/infra/auth"
+)
+
+type fetchGamesResponse struct {
+	Rooms []responseRoom `json:"rooms"`
+}
+
+type responseRoom struct {
+	Id         string `json:"id"`
+	Name       string `json:"name"`
+	Players    int    `json:"players"`
+	MaxPlayers int    `json:"maxPlayers"`
+	ImageUrl   string `json:"imageUrl"`
+}
+
+func (r RoomApi) fetchRoomsHandler(user auth.User, res http.ResponseWriter, req *http.Request) {
+	rooms := r.roomRepo.GetAllRooms()
+	formatted := fetchGamesResponse{
+		Rooms: make([]responseRoom, 0),
+	}
+
+	for _, room := range rooms {
+		formatted.Rooms = append(formatted.Rooms, responseRoom{
+			Id:         room.Id(),
+			Name:       room.Name(),
+			Players:    len(room.Players()),
+			MaxPlayers: room.Settings().MaxPlayers,
+			ImageUrl:   room.ImageUrl(),
+		})
+	}
+
+	resJson, err := json.Marshal(formatted)
+	if err != nil {
+		api.LogApiError("Couldn't encode response", err, user.Profile.Id, req)
+		return
+	}
+	err = api.SendJsonResponse(&res, resJson)
+	if err != nil {
+		api.LogApiError("Couldn't write response", err, user.Profile.Id, req)
+		return
+	}
+
+	api.LogApiCall(user.Profile.Id, req)
+}
+
+func (r RoomApi) ServeFetchRooms(baseUrl string, authWrapper auth.AuthWrapper) {
+	http.HandleFunc(fmt.Sprintf("%s/rooms", baseUrl), authWrapper(r.fetchRoomsHandler))
+}

internal/infra/api/setjsoncontenttype.go

@@ -0,0 +1,12 @@
+package api
+
+import (
+	"net/http"
+)
+
+func SendJsonResponse(res *http.ResponseWriter, bytes []byte) error {
+	(*res).Header().Set("Content-Type", "application/json")
+	_, err := (*res).Write(bytes)
+
+	return err
+}

internal/infra/auth/authorizethroughspotify.go

@@ -6,10 +6,11 @@ import (
 
 	"github.com/feelbeatapp/feelbeatserver/internal/infra/fblog"
 	"github.com/feelbeatapp/feelbeatserver/internal/lib/component"
+	"github.com/feelbeatapp/feelbeatserver/internal/lib/feelbeaterror"
 	"github.com/feelbeatapp/feelbeatserver/internal/thirdparty/spotify"
 )
 
-func AuthorizeThroughSpotify(handler func(string, http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
+func AuthorizeThroughSpotify(handler func(User, http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
 	return func(res http.ResponseWriter, req *http.Request) {
 		authHeader := req.Header.Get("Authorization")
 
@@ -21,13 +22,14 @@ func AuthorizeThroughSpotify(handler func(string, http.ResponseWriter, *http.Req
 		}
 		token := splits[1]
 
-		userId, err := spotify.GetUserId(token)
+		user, err := spotify.GetUserProfile(token)
+
 		if err != nil {
-			http.Error(res, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+			http.Error(res, feelbeaterror.AuthFailed, http.StatusForbidden)
 			fblog.Error(component.Auth, "Access denied", "reason", err)
 			return
 		}
 
-		handler(userId, res, req)
+		handler(User{Profile: user, Token: token}, res, req)
 	}
 }

internal/infra/auth/authwrapper.go

@@ -1,5 +1,14 @@
 package auth
 
-import "net/http"
+import (
+	"net/http"
 
-type AuthWrapper func(func(string, http.ResponseWriter, *http.Request)) func (http.ResponseWriter, *http.Request)
+	"github.com/feelbeatapp/feelbeatserver/internal/lib"
+)
+
+type User struct {
+	Profile lib.UserProfile
+	Token   string
+}
+
+type AuthWrapper func(func(User, http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request)

internal/lib/feelbeaterror/errorcode.go

@@ -5,7 +5,9 @@ import "net/http"
 type ErrorCode string
 
 const (
-	Default = "unexpected_error"
+	Default               = "Unexpected error occurred"
+	AuthFailed            = "Authorization failed"
+	LoadingPlaylistFailed = "Playlist loading failed"
 )
 
 func StatusCode(code ErrorCode) int {

internal/lib/room/room.go

@@ -1,19 +1,45 @@
 package room
 
+import (
+	"github.com/feelbeatapp/feelbeatserver/internal/lib"
+)
+
 type Room struct {
 	id       string
-	ownerId  string
+	playlist lib.PlaylistData
+	owner    lib.UserProfile
 	settings RoomSettings
+	players  []Player
+}
+
+type Player struct {
 }
 
-func NewRoom(id string, ownerId string, settings RoomSettings) Room {
+func NewRoom(id string, playlist lib.PlaylistData, owner lib.UserProfile, settings RoomSettings) Room {
 	return Room{
 		id:       id,
+		playlist: playlist,
+		owner:    owner,
 		settings: settings,
-		ownerId:  ownerId,
+		players:  make([]Player, 0),
 	}
 }
 
 func (r Room) Id() string {
 	return r.id
 }
+
+func (r Room) Name() string {
+	return r.playlist.Name
+}
+
+func (r Room) Players() []Player {
+	return r.players
+}
+
+func (r Room) ImageUrl() string {
+	return r.playlist.ImageUrl
+}
+func (r Room) Settings() RoomSettings {
+	return r.settings
+}

internal/lib/roomrepository/inmemoryroomrepository.go

@@ -3,32 +3,47 @@ package roomrepository
 import (
 	"fmt"
 
+	"github.com/feelbeatapp/feelbeatserver/internal/infra/auth"
+	"github.com/feelbeatapp/feelbeatserver/internal/lib"
 	"github.com/feelbeatapp/feelbeatserver/internal/lib/room"
-	"github.com/feelbeatapp/feelbeatserver/internal/lib/validation"
 	"github.com/google/uuid"
 )
 
+type SpotifyApi interface {
+	FetchPlaylistData(playlistId string, token string) (lib.PlaylistData, error)
+}
+
 type InMemoryRoomRepository struct {
-	rooms map[string]room.Room
+	spotify SpotifyApi
+	rooms   map[string]room.Room
 }
 
-func NewInMemoryRoomRepository() InMemoryRoomRepository {
+func NewInMemoryRoomRepository(spotify SpotifyApi) InMemoryRoomRepository {
 	return InMemoryRoomRepository{
-		rooms: make(map[string]room.Room),
+		spotify: spotify,
+		rooms:   make(map[string]room.Room),
 	}
 }
 
-// TODO: Implement fetching playlist details from spotify
-func (r InMemoryRoomRepository) CreateRoom(ownderId string, settings room.RoomSettings) (string, error) {
-	err := validation.ValidateRoomSettings(settings)
+func (r InMemoryRoomRepository) CreateRoom(user auth.User, settings room.RoomSettings) (string, error) {
+	playlistData, err := r.spotify.FetchPlaylistData(settings.PlaylistId, user.Token)
 	if err != nil {
 		return "", err
 	}
 
-	newRoom := room.NewRoom(uuid.NewString(), ownderId, settings)
+	newRoom := room.NewRoom(uuid.NewString(), playlistData, user.Profile, settings)
 	r.rooms[newRoom.Id()] = newRoom
 
-	fmt.Println(r.rooms)
+	fmt.Println(newRoom)
 
 	return newRoom.Id(), nil
 }
+
+func (r InMemoryRoomRepository) GetAllRooms() []room.Room {
+	result := make([]room.Room, 0)
+	for _, room := range r.rooms {
+		result = append(result, room)
+	}
+
+	return result
+}

internal/lib/roomrepository/roomrepository.go

@@ -1,7 +1,11 @@
 package roomrepository
 
-import "github.com/feelbeatapp/feelbeatserver/internal/lib/room"
+import (
+	"github.com/feelbeatapp/feelbeatserver/internal/infra/auth"
+	"github.com/feelbeatapp/feelbeatserver/internal/lib/room"
+)
 
 type RoomRepository interface {
-	CreateRoom(string, room.RoomSettings) (string, error)
+	CreateRoom(user auth.User, settings room.RoomSettings) (string, error)
+	GetAllRooms() []room.Room
 }

internal/lib/types.go

@@ -7,3 +7,20 @@ type SongDetails struct {
 	Artist   string
 	Duration time.Duration
 }
+
+type Song struct {
+	Id      string
+	Details SongDetails
+}
+
+type PlaylistData struct {
+	Name     string
+	ImageUrl string
+	Songs    []Song
+}
+
+type UserProfile struct {
+	Id       string
+	Name     string
+	ImageUrl string
+}