cleanup

2019-05-17 13:14:51 +01:00
parent 7bbfef1638
commit 5c657d9630
13 changed files with 272 additions and 464 deletions
--- a/handler/handler_sub_by_folder.go
+++ b/handler/handler_sub_by_folder.go
@@ -1,8 +1,11 @@
 package handler

 import (
+	"fmt"
 	"net/http"

+	"github.com/jinzhu/gorm"
+
 	"github.com/sentriz/gonic/db"
 	"github.com/sentriz/gonic/subsonic"
 )
@@ -44,20 +47,17 @@ func (c *Controller) GetMusicDirectory(w http.ResponseWriter, r *http.Request) {
 		respondError(w, r, 10, "please provide an `id` parameter")
 		return
 	}
-	sub := subsonic.NewResponse()
+	childrenObj := []*subsonic.Child{}
 	var cFolder db.Folder
 	c.DB.First(&cFolder, id)
-	sub.Directory = &subsonic.Directory{
-		ID:     cFolder.ID,
-		Parent: cFolder.ParentID,
-		Name:   cFolder.Name,
-	}
+	//
+	// start looking for child folders in the current dir
 	var folders []*db.Folder
 	c.DB.
 		Where("parent_id = ?", id).
 		Find(&folders)
 	for _, folder := range folders {
-		sub.Directory.Children = append(sub.Directory.Children, &subsonic.Child{
+		childrenObj = append(childrenObj, &subsonic.Child{
 			Parent:  cFolder.ID,
 			ID:      folder.ID,
 			Title:   folder.Name,
@@ -65,30 +65,115 @@ func (c *Controller) GetMusicDirectory(w http.ResponseWriter, r *http.Request) {
 			CoverID: folder.CoverID,
 		})
 	}
+	//
+	// start looking for child tracks in the current dir
 	var tracks []*db.Track
 	c.DB.
 		Where("folder_id = ?", id).
 		Preload("Album").
+		Order("track_number").
 		Find(&tracks)
 	for _, track := range tracks {
-		sub.Directory.Children = append(sub.Directory.Children, &subsonic.Child{
-			Parent:      cFolder.ID,
-			IsDir:       false,
-			Title:       track.Title,
+		if getStrParam(r, "c") == "Jamstash" {
+			// jamstash thinks it can't play flacs
+			track.ContentType = "audio/mpeg"
+			track.Suffix = "mp3"
+		}
+		childrenObj = append(childrenObj, &subsonic.Child{
+			ID:          track.ID,
 			Album:       track.Album.Title,
 			Artist:      track.Artist,
-			Bitrate:     track.Bitrate,
 			ContentType: track.ContentType,
 			CoverID:     cFolder.CoverID,
 			Duration:    0,
+			IsDir:       false,
+			Parent:      cFolder.ID,
 			Path:        track.Path,
 			Size:        track.Size,
+			Suffix:      track.Suffix,
+			Title:       track.Title,
 			Track:       track.TrackNumber,
+			Type:        "music",
 		})
 	}
+	//
+	// respond section
+	sub := subsonic.NewResponse()
+	sub.Directory = &subsonic.Directory{
+		ID:       cFolder.ID,
+		Parent:   cFolder.ParentID,
+		Name:     cFolder.Name,
+		Children: childrenObj,
+	}
 	respond(w, r, sub)
 }

 // changes to this function should be reflected in in _by_tags.go's
 // getAlbumListTwo() function
-func (c *Controller) GetAlbumList(w http.ResponseWriter, r *http.Request) {}
+func (c *Controller) GetAlbumList(w http.ResponseWriter, r *http.Request) {
+	listType := getStrParam(r, "type")
+	if listType == "" {
+		respondError(w, r, 10, "please provide a `type` parameter")
+		return
+	}
+	q := c.DB
+	switch listType {
+	case "alphabeticalByArtist":
+		// not sure what it meant by "artist" since we're browsing by folder
+		// - so we'll consider the parent folder's name to be the "artist"
+		q = q.Joins(`
+			JOIN folders AS parent_folders
+			ON folders.parent_id = parent_folders.id`)
+		q = q.Order("parent_folders.name")
+	case "alphabeticalByName":
+		// not sure about "name" either, so lets use the folder's name
+		q = q.Order("name")
+	case "frequent":
+		user := r.Context().Value(contextUserKey).(*db.User)
+		q = q.Joins(`
+			JOIN plays
+			ON folders.id = plays.folder_id AND plays.user_id = ?`,
+			user.ID)
+		q = q.Order("plays.count DESC")
+	case "newest":
+		q = q.Order("updated_at DESC")
+	case "random":
+		q = q.Order(gorm.Expr("random()"))
+	case "recent":
+		user := r.Context().Value(contextUserKey).(*db.User)
+		q = q.Joins(`
+			JOIN plays
+			ON folders.id = plays.folder_id AND plays.user_id = ?`,
+			user.ID)
+		q = q.Order("plays.time DESC")
+	default:
+		respondError(w, r, 10, fmt.Sprintf(
+			"unknown value `%s` for parameter 'type'", listType,
+		))
+		return
+	}
+	var folders []*db.Folder
+	q.
+		Where("folders.has_tracks = 1").
+		Offset(getIntParamOr(r, "offset", 0)).
+		Limit(getIntParamOr(r, "size", 10)).
+		Preload("Parent").
+		Find(&folders)
+	listObj := []*subsonic.Album{}
+	for _, folder := range folders {
+		listObj = append(listObj, &subsonic.Album{
+			ID:       folder.ID,
+			Title:    folder.Name,
+			Album:    folder.Name,
+			CoverID:  folder.CoverID,
+			ParentID: folder.ParentID,
+			IsDir:    true,
+			Artist:   folder.Parent.Name,
+		})
+	}
+	sub := subsonic.NewResponse()
+	sub.Albums = &subsonic.Albums{
+		List: listObj,
+	}
+	respond(w, r, sub)
+}
--- a/handler/handler_sub_by_tags.go
+++ b/handler/handler_sub_by_tags.go
@@ -14,7 +14,7 @@ func (c *Controller) GetArtists(w http.ResponseWriter, r *http.Request) {
 	var artists []*db.AlbumArtist
 	c.DB.Find(&artists)
 	var indexMap = make(map[rune]*subsonic.Index)
-	var indexes []*subsonic.Index
+	var indexes subsonic.Artists
 	for _, artist := range artists {
 		i := indexOf(artist.Name)
 		index, ok := indexMap[i]
@@ -24,7 +24,7 @@ func (c *Controller) GetArtists(w http.ResponseWriter, r *http.Request) {
 				Artists: []*subsonic.Artist{},
 			}
 			indexMap[i] = index
-			indexes = append(indexes, index)
+			indexes.List = append(indexes.List, index)
 		}
 		index.Artists = append(index.Artists, &subsonic.Artist{
 			ID:   artist.ID,
@@ -32,7 +32,7 @@ func (c *Controller) GetArtists(w http.ResponseWriter, r *http.Request) {
 		})
 	}
 	sub := subsonic.NewResponse()
-	sub.Artists = indexes
+	sub.Artists = &indexes
 	respond(w, r, sub)
 }

@@ -46,13 +46,9 @@ func (c *Controller) GetArtist(w http.ResponseWriter, r *http.Request) {
 	c.DB.
 		Preload("Albums").
 		First(&artist, id)
-	sub := subsonic.NewResponse()
-	sub.Artist = &subsonic.Artist{
-		ID:   artist.ID,
-		Name: artist.Name,
-	}
+	albumsObj := []*subsonic.Album{}
 	for _, album := range artist.Albums {
-		sub.Artist.Albums = append(sub.Artist.Albums, &subsonic.Album{
+		albumsObj = append(albumsObj, &subsonic.Album{
 			ID:       album.ID,
 			Name:     album.Title,
 			Created:  album.CreatedAt,
@@ -61,6 +57,12 @@ func (c *Controller) GetArtist(w http.ResponseWriter, r *http.Request) {
 			CoverID:  album.CoverID,
 		})
 	}
+	sub := subsonic.NewResponse()
+	sub.Artist = &subsonic.Artist{
+		ID:     artist.ID,
+		Name:   artist.Name,
+		Albums: albumsObj,
+	}
 	respond(w, r, sub)
 }

@@ -75,16 +77,9 @@ func (c *Controller) GetAlbum(w http.ResponseWriter, r *http.Request) {
 		Preload("AlbumArtist").
 		Preload("Tracks").
 		First(&album, id)
-	sub := subsonic.NewResponse()
-	sub.Album = &subsonic.Album{
-		ID:      album.ID,
-		Name:    album.Title,
-		CoverID: album.CoverID,
-		Created: album.CreatedAt,
-		Artist:  album.AlbumArtist.Name,
-	}
+	tracksObj := []*subsonic.Track{}
 	for _, track := range album.Tracks {
-		sub.Album.Tracks = append(sub.Album.Tracks, &subsonic.Track{
+		tracksObj = append(tracksObj, &subsonic.Track{
 			ID:          track.ID,
 			Title:       track.Title,
 			Artist:      track.Artist, // track artist
@@ -101,6 +96,15 @@ func (c *Controller) GetAlbum(w http.ResponseWriter, r *http.Request) {
 			Type:        "music",
 		})
 	}
+	sub := subsonic.NewResponse()
+	sub.Album = &subsonic.Album{
+		ID:      album.ID,
+		Name:    album.Title,
+		CoverID: album.CoverID,
+		Created: album.CreatedAt,
+		Artist:  album.AlbumArtist.Name,
+		Tracks:  tracksObj,
+	}
 	respond(w, r, sub)
 }

@@ -112,51 +116,54 @@ func (c *Controller) GetAlbumListTwo(w http.ResponseWriter, r *http.Request) {
 		respondError(w, r, 10, "please provide a `type` parameter")
 		return
 	}
-	query := c.DB
+	q := c.DB
 	switch listType {
 	case "alphabeticalByArtist":
-		query = query.
-			Joins("JOIN album_artists ON albums.album_artist_id=album_artists.id").
-			Order("album_artists.name")
+		q = q.Joins(`
+			JOIN album_artists
+			ON albums.album_artist_id = album_artists.id`)
+		q = q.Order("album_artists.name")
 	case "alphabeticalByName":
-		query = query.Order("title")
+		q = q.Order("title")
 	case "byYear":
-		startYear := getIntParamOr(r, "fromYear", 1800)
-		endYear := getIntParamOr(r, "toYear", 2200)
-		query = query.
-			Where("year BETWEEN ? AND ?", startYear, endYear).
-			Order("year")
+		q = q.Where(
+			"year BETWEEN ? AND ?",
+			getIntParamOr(r, "fromYear", 1800),
+			getIntParamOr(r, "toYear", 2200))
+		q = q.Order("year")
 	case "frequent":
 		user := r.Context().Value(contextUserKey).(*db.User)
-		query = query.
-			Joins("JOIN plays ON albums.id=plays.album_id AND plays.user_id=?", user.ID).
-			Order("plays.count desc")
+		q = q.Joins(`
+			JOIN plays
+			ON albums.id = plays.album_id AND plays.user_id = ?`,
+			user.ID)
+		q = q.Order("plays.count DESC")
 	case "newest":
-		query = query.Order("updated_at desc")
+		q = q.Order("updated_at DESC")
 	case "random":
-		query = query.Order(gorm.Expr("random()"))
+		q = q.Order(gorm.Expr("random()"))
 	case "recent":
 		user := r.Context().Value(contextUserKey).(*db.User)
-		query = query.
-			Joins("JOIN plays ON albums.id=plays.album_id AND plays.user_id=?", user.ID).
-			Order("plays.time desc")
+		q = q.Joins(`
+			JOIN plays
+			ON albums.id = plays.album_id AND plays.user_id = ?`,
+			user.ID)
+		q = q.Order("plays.time DESC")
 	default:
 		respondError(w, r, 10, fmt.Sprintf(
 			"unknown value `%s` for parameter 'type'", listType,
 		))
 		return
 	}
-	offset := getIntParamOr(r, "offset", 0)
-	size := getIntParamOr(r, "size", 10)
 	var albums []*db.Album
-	query.
-		Offset(offset).
-		Limit(size).
+	q.
+		Offset(getIntParamOr(r, "offset", 0)).
+		Limit(getIntParamOr(r, "size", 10)).
 		Preload("AlbumArtist").
 		Find(&albums)
-	sub := subsonic.NewResponse()
+	listObj := []*subsonic.Album{}
 	for _, album := range albums {
-		sub.Albums = append(sub.Albums, &subsonic.Album{
+		listObj = append(listObj, &subsonic.Album{
 			ID:       album.ID,
 			Name:     album.Title,
 			Created:  album.CreatedAt,
@@ -165,5 +172,9 @@ func (c *Controller) GetAlbumListTwo(w http.ResponseWriter, r *http.Request) {
 			ArtistID: album.AlbumArtist.ID,
 		})
 	}
+	sub := subsonic.NewResponse()
+	sub.AlbumsTwo = &subsonic.Albums{
+		List: listObj,
+	}
 	respond(w, r, sub)
 }
--- a/handler/handler_sub_common.go
+++ b/handler/handler_sub_common.go
@@ -32,6 +32,7 @@ func (c *Controller) Stream(w http.ResponseWriter, r *http.Request) {
 	var track db.Track
 	c.DB.
 		Preload("Album").
+		Preload("Folder").
 		First(&track, id)
 	if track.Path == "" {
 		respondError(w, r, 70, fmt.Sprintf("media with id `%d` was not found", id))
@@ -48,8 +49,9 @@ func (c *Controller) Stream(w http.ResponseWriter, r *http.Request) {
 	// after we've served the file, mark the album as played
 	user := r.Context().Value(contextUserKey).(*db.User)
 	play := db.Play{
-		AlbumID: track.Album.ID,
-		UserID:  user.ID,
+		AlbumID:  track.Album.ID,
+		FolderID: track.Folder.ID,
+		UserID:   user.ID,
 	}
 	c.DB.Where(play).First(&play)
 	play.Time = time.Now() // for getAlbumList?type=recent
@@ -122,10 +124,12 @@ func (c *Controller) Scrobble(w http.ResponseWriter, r *http.Request) {
 }

 func (c *Controller) GetMusicFolders(w http.ResponseWriter, r *http.Request) {
-	sub := subsonic.NewResponse()
-	sub.MusicFolders = []*subsonic.MusicFolder{
+	folders := &subsonic.MusicFolders{}
+	folders.List = []*subsonic.MusicFolder{
 		{ID: 1, Name: "music"},
 	}
+	sub := subsonic.NewResponse()
+	sub.MusicFolders = folders
 	respond(w, r, sub)
 }