Add endpoint to upload music artist song

Author: Swan

cache/cache_server.go

@@ -70,3 +70,7 @@ func RemoveCacheServerMusicArtistBanner(id int) error {
 func RemoveCacheServerMusicArtistAlbumCover(id int) error {
 	return RemoveCacheServerFile("music-artist-album-covers", id)
 }
+
+func RemoveCacheServerMusicArtistSong(id int) error {
+	return RemoveCacheServerFile("music-artist-songs", id)
+}

cmd/api/server.go

@@ -288,6 +288,9 @@ func initializeRoutes(engine *gin.Engine) {
 	engine.DELETE("/v2/artists/album/:id", middleware.RequireAuth, handlers.CreateHandler(handlers.DeleteMusicArtistAlbum))
 	engine.POST("/v2/artists/album/:id/cover", middleware.RequireAuth, handlers.CreateHandler(handlers.UploadMusicArtistAlbumCover))
 
+	// Songs
+	engine.POST("/v2/artists/album/:id/song", middleware.RequireAuth, handlers.CreateHandler(handlers.UploadMusicArtistSong))
+
 	engine.NoRoute(func(c *gin.Context) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
 		return

db/music_artists_albums.go

@@ -1,10 +1,11 @@
 package db
 
 type MusicArtistAlbum struct {
-	Id        int    `gorm:"column:id; PRIMARY_KEY" json:"id"`
-	ArtistId  int    `gorm:"column:artist_id" json:"artist_id"`
-	Name      string `gorm:"column:name" json:"name"`
-	SortOrder int    `gorm:"column:sort_order" json:"sort_order"`
+	Id        int                `gorm:"column:id; PRIMARY_KEY" json:"id"`
+	ArtistId  int                `gorm:"column:artist_id" json:"artist_id"`
+	Name      string             `gorm:"column:name" json:"name"`
+	SortOrder int                `gorm:"column:sort_order" json:"sort_order"`
+	Songs     []*MusicArtistSong `gorm:"-:all" json:"songs,omitempty"`
 }
 
 func (*MusicArtistAlbum) TableName() string {
@@ -28,6 +29,16 @@ func GetMusicArtistAlbums(artistId int) ([]*MusicArtistAlbum, error) {
 		return nil, result.Error
 	}
 
+	for _, album := range albums {
+		var err error
+
+		album.Songs, err = GetMusicArtistSongsInAlbum(album.Id)
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	return albums, nil
 }
 
@@ -43,6 +54,14 @@ func GetMusicArtistAlbumById(id int) (*MusicArtistAlbum, error) {
 		return nil, result.Error
 	}
 
+	var err error
+
+	album.Songs, err = GetMusicArtistSongsInAlbum(album.Id)
+
+	if err != nil {
+		return nil, err
+	}
+
 	return &album, nil
 }
 

db/music_artists_songs.go

@@ -12,3 +12,23 @@ type MusicArtistSong struct {
 func (*MusicArtistSong) TableName() string {
 	return "music_artists_songs"
 }
+
+func (song *MusicArtistSong) ID() int {
+	return song.Id
+}
+
+// GetMusicArtistSongsInAlbum Returns the songs in a music artist's album
+func GetMusicArtistSongsInAlbum(albumId int) ([]*MusicArtistSong, error) {
+	songs := make([]*MusicArtistSong, 0)
+
+	result := SQL.
+		Where("album_id = ?", albumId).
+		Order("sort_order ASC").
+		Find(&songs)
+
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	return songs, nil
+}

handlers/music_artists_songs.go

@@ -0,0 +1,113 @@
+package handlers
+
+import (
+	"fmt"
+	"github.com/Quaver/api2/azure"
+	"github.com/Quaver/api2/cache"
+	"github.com/Quaver/api2/db"
+	"github.com/gabriel-vasile/mimetype"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"net/http"
+	"strconv"
+)
+
+// UploadMusicArtistSong Uploads a new song for a music artist's album
+// Endpoint: POST /v2/artists/album/:id/song
+func UploadMusicArtistSong(c *gin.Context) *APIError {
+	user := getAuthedUser(c)
+
+	if user == nil {
+		return nil
+	}
+
+	if !canUserAccessAdminRoute(c) {
+		return nil
+	}
+
+	id, err := strconv.Atoi(c.Param("id"))
+
+	if err != nil {
+		return APIErrorBadRequest("Invalid id")
+	}
+
+	body := struct {
+		Name   string `form:"name" json:"name" binding:"required"`
+		BPM    int    `form:"bpm" json:"bpm" binding:"required"`
+		Length int    `form:"length" json:"length" binding:"required"`
+	}{}
+
+	if err := c.ShouldBind(&body); err != nil {
+		return APIErrorBadRequest("Invalid request body")
+	}
+
+	album, err := db.GetMusicArtistAlbumById(id)
+
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return APIErrorServerError("Error retrieving album from db", err)
+	}
+
+	if album == nil {
+		return APIErrorNotFound("Album")
+	}
+
+	fileBytes, apiErr := validateUploadedAudio(c)
+
+	if apiErr != nil {
+		return apiErr
+	}
+
+	song := db.MusicArtistSong{
+		AlbumId:   id,
+		Name:      body.Name,
+		Length:    body.Length,
+		BPM:       body.BPM,
+		SortOrder: len(album.Songs),
+	}
+
+	if err := db.SQL.Create(&song).Error; err != nil {
+		return APIErrorServerError("Error inserting song into db", err)
+	}
+
+	_ = cache.RemoveCacheServerMusicArtistSong(song.Id)
+
+	if err := azure.Client.UploadFile("music-artist-songs", fmt.Sprintf("%v.mp3", song.Id), fileBytes); err != nil {
+		return APIErrorServerError("Error uploading song to azure", err)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message": "Your song has been successfully uploaded.",
+		"song":    song,
+	})
+
+	return nil
+}
+
+// Validates an uploaded audio file and returns the file bytes
+func validateUploadedAudio(c *gin.Context) ([]byte, *APIError) {
+	fileHeader, _ := c.FormFile("audio")
+
+	if fileHeader == nil {
+		return nil, APIErrorBadRequest("You must provide a valid `audio` file.")
+	}
+
+	file, err := fileHeader.Open()
+
+	if err != nil {
+		return nil, APIErrorServerError("Error opening file", err)
+	}
+
+	defer file.Close()
+
+	var fileBytes = make([]byte, fileHeader.Size)
+
+	if _, err = file.Read(fileBytes); err != nil {
+		return nil, APIErrorServerError("Error reading file", err)
+	}
+
+	if mime := mimetype.Detect(fileBytes); mime == nil || mime.String() != "audio/mpeg" {
+		return nil, APIErrorBadRequest("The file you provided was not a valid .mp3 file.")
+	}
+
+	return fileBytes, nil
+}