Merge pull request #11 from emanuelvsz/02-route-that-lists-artist-albums

Route that list artist albums

src/app/api/endpoints/handlers/dtos/response/album_response.go

@@ -2,20 +2,18 @@ package response
 
 import (
 	"time"
-
-	"github.com/google/uuid"
 )
 
 type AlbumDTO struct {
-	ID          uuid.UUID `json:"id"`
+	ID          string    `json:"id"`
 	Name        string    `json:"name"`
-	ArtistID    uuid.UUID `json:"artistId"`
+	ArtistID    string    `json:"artistId"`
 	ReleaseDate time.Time `json:"release_date"`
 	Description *string   `json:"description,omitempty"`
 	ImageURL    *string   `json:"image_url,omitempty"`
 }
 
-func NewAlbumDTO(id uuid.UUID, name string, artistID uuid.UUID, releaseDate time.Time, description *string, imageURL *string) *AlbumDTO {
+func NewAlbumDTO(id string, name string, artistID string, releaseDate time.Time, description *string, imageURL *string) *AlbumDTO {
 	return &AlbumDTO{
 		ID:          id,
 		Name:        name,

src/app/api/endpoints/handlers/user_handlers.go

@@ -142,6 +142,46 @@ func (h UserHandlers) GetAlbumTracks(context echo.Context) error {
 	return context.JSON(http.StatusOK, songs)
 }
 
+// GetAlbumByArtistID
+// @ID GetAlbumByArtistID
+// @Summary Buscar todas os álbuns de um artista pelo seu ID
+// @Tags Rotas do usuário
+// @Description Rota que permite que se busque todos os álbuns de um determinado artista
+// @Param artistID path string true "ID do Artista." default(5K4W6rqBFWDnAN6FQUkS6x)
+// @Produce json
+// @Success 200 {array} response.AlbumDTO "Requisição realizada com sucesso."
+// @Failure 401 {object} response.ErrorMessage "Usuário não autorizado."
+// @Failure 403 {object} response.ErrorMessage "Acesso negado."
+// @Failure 422 {object} response.ErrorMessage "Algum dado informado não pôde ser processado."
+// @Failure 500 {object} response.ErrorMessage "Ocorreu um erro inesperado."
+// @Failure 503 {object} response.ErrorMessage "A base de dados não está disponível."
+// @Router /user/artist/{artistID}/albums [get]
+func (h UserHandlers) GetArtistAlbums(context echo.Context) error {
+	artistID := context.Param(artistID)
+
+	albumsRows, fetchErr := h.service.FetchArtistAlbumsByID(artistID)
+	if fetchErr != nil {
+		return getHttpHandledErrorResponse(context, fetchErr)
+	}
+
+	albums := make([]response.AlbumDTO, 0)
+	for _, each := range albumsRows {
+		albumBuilder := response.NewAlbumDTO(
+			each.ID(),
+			each.Name(),
+			each.ArtistID(),
+			each.ReleaseDate(),
+			each.Description(),
+			each.ImageURL(),
+		)
+		albums = append(albums, *albumBuilder)
+
+	}
+
+	return context.JSON(http.StatusOK, albums)
+
+}
+
 // GetUserBasicInfo
 // @ID GetUserBasicInfo
 // @Summary Buscar alguns dados pessoais do usuario

src/app/api/endpoints/routes/user/user_routes.go

@@ -16,4 +16,5 @@ func LoadUserRoutes(group *echo.Group) {
 	userGroup.GET("/playlist/:playlistID", userHandlers.GetPlaylistByID)
 	userGroup.GET("/playlist/:playlistID/songs", userHandlers.GetSongsByPlaylistID)
 	userGroup.GET("/album/:albumID/songs", userHandlers.GetAlbumTracks)
+	userGroup.GET("/artist/:artistID/albums", userHandlers.GetArtistAlbums)
 }

src/app/api/utils/utils.go

@@ -1,11 +1,11 @@
 package utils
 
 import (
+	"echofy_backend/src/core"
+	"echofy_backend/src/core/domain/user"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"echofy_backend/src/core"
-	"echofy_backend/src/core/domain/user"
 	"os"
 	"strings"
 

src/core/domain/album/album.go

@@ -2,28 +2,26 @@ package album
 
 import (
 	"time"
-
-	"github.com/google/uuid"
 )
 
 type Album struct {
-	id          uuid.UUID
+	id          string
 	name        string
-	artistID    uuid.UUID
+	artistID    string
 	releaseDate time.Time
 	description *string
 	imageURL    string
 }
 
-func (a Album) ID() uuid.UUID {
+func (a Album) ID() string {
 	return a.id
 }
 
 func (a Album) Name() string {
 	return a.name
 }
 
-func (a Album) ArtistID() uuid.UUID {
+func (a Album) ArtistID() string {
 	return a.artistID
 }
 
@@ -35,6 +33,6 @@ func (a Album) Description() *string {
 	return a.description
 }
 
-func (a Album) ImageURL() string {
-	return a.imageURL
+func (a Album) ImageURL() *string {
+	return &a.imageURL
 }

src/core/domain/album/builder.go

@@ -5,17 +5,15 @@ import (
 	"echofy_backend/src/core/errors"
 	"echofy_backend/src/core/messages"
 	"time"
-
-	"github.com/google/uuid"
 )
 
 type Builder struct {
 	Album
 	invalidFields []errors.InvalidField
 }
 
-func (b *Builder) WithID(id uuid.UUID) *Builder {
-	if id == uuid.Nil {
+func (b *Builder) WithID(id string) *Builder {
+	if id == "" {
 		b.invalidFields = append(b.invalidFields, errors.InvalidField{
 			Name:        messages.AlbumID,
 			Description: messages.AlbumIDInvalidErrMsg,
@@ -36,8 +34,8 @@ func (b *Builder) WithName(name string) *Builder {
 	return b
 }
 
-func (b *Builder) WithArtistID(artistID uuid.UUID) *Builder {
-	if artistID == uuid.Nil {
+func (b *Builder) WithArtistID(artistID string) *Builder {
+	if artistID == "" {
 		b.invalidFields = append(b.invalidFields, errors.InvalidField{
 			Name:        messages.AlbumArtistID,
 			Description: messages.AlbumArtistIDInvalidErrMsg,

src/core/interfaces/primary/user_manager.go

@@ -1,6 +1,7 @@
 package primary
 
 import (
+	"echofy_backend/src/core/domain/album"
 	"echofy_backend/src/core/domain/playlist"
 	"echofy_backend/src/core/domain/song"
 	"echofy_backend/src/core/domain/user"
@@ -12,4 +13,5 @@ type UserManager interface {
 	FetchPlaylistByID(playlistID string) (*playlist.Playlist, errors.Error)
 	FetchSongsByAlbumID(albumID string) ([]song.Song, errors.Error)
 	FetchUserBasicInfo() (*user.User, errors.Error)
+	FetchArtistAlbumsByID(artistID string) ([]album.Album, errors.Error)
 }

src/core/interfaces/repository/user_loader.go

@@ -1,6 +1,7 @@
 package repository
 
 import (
+	"echofy_backend/src/core/domain/album"
 	"echofy_backend/src/core/domain/playlist"
 	"echofy_backend/src/core/domain/song"
 	"echofy_backend/src/core/domain/user"
@@ -12,4 +13,5 @@ type UserLoader interface {
 	FindPlaylistByID(playlistID string) (*playlist.Playlist, errors.Error)
 	FindSongsByAlbumID(albumID string) ([]song.Song, errors.Error)
 	FindUserBasicInfo() (*user.User, errors.Error)
+	FindArtistAlbumsByID(artistID string) ([]album.Album, errors.Error)
 }

src/core/services/user_services.go

@@ -1,6 +1,7 @@
 package services
 
 import (
+	"echofy_backend/src/core/domain/album"
 	"echofy_backend/src/core/domain/playlist"
 	"echofy_backend/src/core/domain/song"
 	"echofy_backend/src/core/domain/user"
@@ -52,6 +53,15 @@ func (u UserServices) FetchUserBasicInfo() (*user.User, errors.Error) {
 	return user, nil
 }
 
+func (u UserServices) FetchArtistAlbumsByID(artistID string) ([]album.Album, errors.Error) {
+	albumInstance, err := u.userRepository.FindArtistAlbumsByID(artistID)
+	if err != nil {
+		return nil, err
+	}
+
+	return albumInstance, nil
+}
+
 func NewUserServices(userRepository repository.UserLoader, logger logger.Logger) *UserServices {
 	return &UserServices{
 		userRepository: userRepository,

src/infra/spotify/user_spotify_repository.go

@@ -2,14 +2,15 @@ package spotifyrepo
 
 import (
 	"context"
+	"echofy_backend/src/core/domain/album"
 	"echofy_backend/src/core/domain/artist"
 	"echofy_backend/src/core/domain/playlist"
 	"echofy_backend/src/core/domain/song"
 	"echofy_backend/src/core/domain/user"
 	"echofy_backend/src/core/errors"
 	"echofy_backend/src/core/interfaces/repository"
 	"echofy_backend/src/core/messages"
-	"fmt"
+	"time"
 
 	"github.com/zmb3/spotify/v2"
 	spotifyauth "github.com/zmb3/spotify/v2/auth"
@@ -173,6 +174,44 @@ func (instance UserSpotifyRepository) FindUserBasicInfo() (*user.User, errors.Er
 	return user, nil
 }
 
+func (u UserSpotifyRepository) FindArtistAlbumsByID(artistID string) ([]album.Album, errors.Error) {
+	ctx := context.Background()
+	token := getConnection(ctx)
+
+	httpClient := spotifyauth.New().Client(ctx, token)
+	client := spotify.New(httpClient)
+	artist, err := client.GetArtistAlbums(ctx, spotify.ID(artistID), nil)
+	if err != nil {
+		return nil, errors.NewUnexpectedError(messages.UnexpectedErrorMessage, err)
+	}
+
+	albums := make([]album.Album, 0)
+	for _, singleAlbum := range artist.Albums {
+		albumID := singleAlbum.ID
+		albumName := singleAlbum.Name
+
+		albumRealeaseDate, err := time.Parse("2006-01-02", singleAlbum.ReleaseDate)
+		if err != nil {
+			return nil, errors.NewUnexpectedError(messages.UnexpectedErrorMessage, err)
+		}
+
+		albumImage := &singleAlbum.Images[0].URL
+
+		albumBuilder := album.NewBuilder()
+		albumBuilder.WithArtistID(artistID).WithID(albumID.String()).WithName(albumName).WithReleaseDate(albumRealeaseDate).WithImageURL(*albumImage)
+		albumBuilded, createdError := albumBuilder.Build()
+		if createdError != nil {
+			return nil, errors.NewUnexpectedError(messages.UnexpectedErrorMessage, createdError)
+		}
+
+		albums = append(albums, *albumBuilded)
+
+	}
+
+	return albums, nil
+
+}
+
 func NewUserSpotifyRepository() *UserSpotifyRepository {
 	return &UserSpotifyRepository{}
 }