Merge pull request #5 from defsub/singles

Singles

Author: defsub

client/client.go

@@ -99,9 +99,11 @@ func (c *Client) doGet(headers map[string]string, urlStr string) (*http.Response
 		}
 		if cachedResp != nil {
 			throttle = false
+			log.Printf("is cached\n")
 		}
 	}
 	if throttle {
+		log.Printf("rate limit\n")
 		RateLimit(url.Hostname())
 	}
 

config/config.go

@@ -92,6 +92,7 @@ type SearchConfig struct {
 type ServerConfig struct {
 	Listen string
 	WebDir string
+	URL    string
 }
 
 type ClientConfig struct {
@@ -147,9 +148,9 @@ func configDefaults() {
 	viper.SetDefault("Music.SimilarReleases", "8760h") // +/- 1 year
 	viper.SetDefault("Music.SimilarReleasesLimit", "10")
 
-	viper.SetDefault("Music.RadioLimit", "250")
+	viper.SetDefault("Music.RadioLimit", "25")
 	viper.SetDefault("Music.RadioSearchLimit", "1000")
-	viper.SetDefault("Music.ArtistRadioBreadth", "25")
+	viper.SetDefault("Music.ArtistRadioBreadth", "10")
 	viper.SetDefault("Music.ArtistRadioDepth", "10")
 
 	// see https://wiki.musicbrainz.org/Release_Country
@@ -195,6 +196,8 @@ func configDefaults() {
 		"r&b",
 		"rock",
 		"shoegaze",
+		"stoner metal",
+		"stoner rock",
 	})
 
 	viper.SetDefault("Music.Bucket.UseSSL", "true")
@@ -210,6 +213,7 @@ func configDefaults() {
 	viper.SetDefault("Search.BleveDir", ".")
 
 	viper.SetDefault("Server.WebDir", "web")
+	viper.SetDefault("Server.URL", "https://example.com") // w/o trailing slash
 
 	viper.SetDefault("Client.UseCache", "false")
 	viper.SetDefault("Client.MaxAge", 86400*30) // 30 days in seconds

music/api.go

@@ -26,17 +26,9 @@ import (
 	"net/http"
 	"regexp"
 	"strconv"
-	"time"
+	"strings"
 )
 
-type location struct {
-	ID           uint
-	Url          string
-	Size         int64
-	ETag         string
-	LastModified time.Time
-}
-
 type login struct {
 	User string
 	Pass string
@@ -223,9 +215,12 @@ func (handler *MusicHandler) apiStation(w http.ResponseWriter, r *http.Request,
 // GET /api/{res}/id/playlist > spiff.Playlist{}
 // 200: success
 func (handler *MusicHandler) apiRefPlaylist(w http.ResponseWriter, r *http.Request, m *Music,
-	title, ref string) {
+	creator, title, image, ref string) {
 	plist := spiff.NewPlaylist()
+	plist.Spiff.Location = fmt.Sprintf("%s%s", m.config.Server.URL, r.URL.Path)
+	plist.Spiff.Creator = creator
 	plist.Spiff.Title = title
+	plist.Spiff.Image = image
 	plist.Entries = []spiff.Entry{{Ref: ref}}
 	m.Resolve(handler.user, plist)
 	if plist.Entries == nil {
@@ -247,7 +242,9 @@ func (handler *MusicHandler) apiRefPlaylist(w http.ResponseWriter, r *http.Reque
 func (handler *MusicHandler) apiPlaylist(w http.ResponseWriter, r *http.Request, music *Music) {
 	p := music.lookupPlaylist(handler.user)
 	if p == nil {
-		data, _ := spiff.NewPlaylist().Marshal()
+		plist := spiff.NewPlaylist()
+		plist.Spiff.Location = fmt.Sprintf("%s/api/playlist", music.config.Server.URL)
+		data, _ := plist.Marshal()
 		p = &Playlist{User: handler.user.Name, Playlist: data}
 		err := music.createPlaylist(p)
 		if err != nil {
@@ -299,16 +296,40 @@ func (handler *MusicHandler) apiView(w http.ResponseWriter, r *http.Request, vie
 	enc.Encode(view)
 }
 
+func (handler *MusicHandler) apiSearch(w http.ResponseWriter, r *http.Request, music *Music) {
+	if v := r.URL.Query().Get("q"); v != "" {
+		// /api/search?q={pattern}
+		view := music.SearchView(strings.TrimSpace(v))
+		handler.apiView(w, r, view)
+	} else {
+		http.Error(w, "bummer", http.StatusNotFound)
+	}
+}
+
 // POST /api/login -> see apiLogin
+//
 // GET,PATCH /api/playlist -> see apiPlaylist
 //
+// GET /api/radio > RadioView{}
+// GET /api/radio/1 > spiff.Playlist{}
+// POST /api/radio
+// GET,PATH,DELETE /api/radio/1 >
+//
 // GET /api/home > HomeView{}
+// GET /api/search > SearchView{}
+//
+// GET /api/tracks/1/location -> Redirect
+//
 // GET /api/artists > ArtistsView{}
 // GET /api/artists/1 > ArtistView{}
+// GET /api/artists/1/popular > PopularView{}
+// GET /api/artists/1/singles > SinglesView{}
+// GET /api/artists/1/playlist > spiff.Playlist{}
+// GET /api/artists/1/radio > spiff.Playlist{}
+//
 // GET /api/releases/1 > ReleaseView{}
-// GET,POST /api/radio
-// GET,PATH,DELETE /api/radio/1 >
-// GET /api/tracks/1/location -> location{}
+// GET /api/releases/1/playlist > spiff.Playlist{}
+//
 // 200: success
 // 500: error
 func (handler *MusicHandler) apiHandler(w http.ResponseWriter, r *http.Request) {
@@ -336,6 +357,8 @@ func (handler *MusicHandler) apiHandler(w http.ResponseWriter, r *http.Request)
 			handler.apiView(w, r, music.HomeView())
 		case "/api/artists":
 			handler.apiView(w, r, music.ArtistsView())
+		case "/api/search":
+			handler.apiSearch(w, r, music)
 		default:
 			// id sub-resources
 			locationRegexp := regexp.MustCompile(`/api/tracks/([0-9]+)/location`)
@@ -345,35 +368,54 @@ func (handler *MusicHandler) apiHandler(w http.ResponseWriter, r *http.Request)
 				id, _ := strconv.Atoi(v)
 				track, _ := music.lookupTrack(id)
 				url := music.TrackURL(&track)
-				handler.apiView(w, r, location{
-					ID:           track.ID,
-					Url:          url.String(),
-					Size:         track.Size,
-					ETag:         track.ETag,
-					LastModified: track.LastModified,
-				})
+				// TODO use 307 instead?
+				http.Redirect(w, r, url.String(), http.StatusFound)
 				return
 			}
 
-			// resources with id and playlist
-			playlistRegexp := regexp.MustCompile(`/api/([a-z]+)/([0-9]+)/playlist`)
+			// resources with id and sub-resource
+			playlistRegexp := regexp.MustCompile(`/api/([a-z]+)/([0-9]+)/(playlist|popular|singles|radio)`)
 			matches = playlistRegexp.FindStringSubmatch(r.URL.Path)
 			if matches != nil {
 				v := matches[1]
 				id, _ := strconv.Atoi(matches[2])
+				res := matches[3]
 				switch v {
 				case "artists":
-					// /api/artists/1/playlist
 					artist, _ := music.lookupArtist(id)
-					handler.apiRefPlaylist(w, r, music,
-						fmt.Sprintf("%s", artist.Name),
-						fmt.Sprintf("/music/artists/%d/shuffle", id))
+					if res == "playlist" {
+						// /api/artists/1/playlist
+						handler.apiRefPlaylist(w, r, music,
+							artist.Name,
+							"Top Tracks",
+							"",
+							fmt.Sprintf("/music/artists/%d/popular", id))
+					} else if res == "radio" {
+						// /api/artists/1/radio
+						handler.apiRefPlaylist(w, r, music,
+							"Radio",
+							fmt.Sprintf("%s Radio", artist.Name),
+							"",
+							fmt.Sprintf("/music/artists/%d/similar", id))
+					} else if res == "popular" {
+						// /api/artists/1/popular
+						handler.apiView(w, r, music.PopularView(artist))
+					} else if res == "singles" {
+						// /api/artists/1/singles
+						handler.apiView(w, r, music.SinglesView(artist))
+					}
 				case "releases":
 					// /api/releases/1/playlist
-					release, _ := music.lookupRelease(id)
-					handler.apiRefPlaylist(w, r, music,
-						fmt.Sprintf("%s ~ %s", release.Artist, release.Name),
-						fmt.Sprintf("/music/releases/%d/tracks", id))
+					if res == "playlist" {
+						release, _ := music.lookupRelease(id)
+						handler.apiRefPlaylist(w, r, music,
+							release.Artist,
+							release.Name,
+							music.cover(release, "250"),
+							fmt.Sprintf("/music/releases/%d/tracks", id))
+					} else {
+						http.Error(w, "bummer", http.StatusNotFound)
+					}
 				default:
 					http.Error(w, "bummer", http.StatusNotFound)
 				}

music/credits.go

@@ -34,6 +34,7 @@ const (
 	FieldLength      = "length"
 	FieldMedia       = "media"
 	FieldMediaTitle  = "media_title"
+	FieldPopularity  = "popularity"
 	FieldRating      = "rating"
 	FieldRelease     = "release"
 	FieldReleaseDate = "release_date"

music/db.go

@@ -302,12 +302,11 @@ func (m *Music) trackRelease(t *Track) *Release {
 	return &releases[0]
 }
 
-// Find the first release date for the release(s) with` this track, including
+// Find the first release date for the release(s) with this track, including
 // an media specific release from a multi-disc set like: Eagles/Legacy or The
 // Beatles/The Beatles in Mono. These each have media with titles that
 // themselves were previous releases so check them too.
-func (m *Music) trackFirstReleaseDate(t *Track) time.Time {
-	result := time.Time{}
+func (m *Music) trackFirstReleaseDate(t *Track) (result time.Time, err error) {
 	var releases []Release
 	names := []string{t.Release}
 	if t.MediaTitle != "" {
@@ -321,6 +320,7 @@ func (m *Music) trackFirstReleaseDate(t *Track) time.Time {
 		Order("date").Find(&releases)
 	if len(releases) > 0 {
 		result = releases[0].Date
+		err = nil
 	} else {
 		// could be disambiguation like "Weezer (Blue Album)" so just
 		// use release date for now
@@ -329,7 +329,7 @@ func (m *Music) trackFirstReleaseDate(t *Track) time.Time {
 			result = r.Date
 		}
 	}
-	return result
+	return result, err
 }
 
 // When there's artwork but no front, other_cover will be the ID of the image

music/music.go

@@ -756,6 +756,17 @@ func (m *Music) releaseIndex(release Release) (search.IndexMap, error) {
 		}
 	}
 
+	// Popular artist tracks mapped to the first release where the tracks
+	// appeared. If this is that release, add popularty fields for those
+	// tracks below.
+	popularityMap := make(map[string]int)
+	a := m.artist(release.Artist)
+	if a != nil {
+		for rank, t := range m.artistPopularTracks(*a) {
+			popularityMap[t.Key] = rank+1
+		}
+	}
+
 	// update type field with single
 	singles := make(map[string]bool)
 	for _, t := range m.releaseSingles(release) {
@@ -777,13 +788,23 @@ func (m *Music) releaseIndex(release Release) (search.IndexMap, error) {
 		fields, ok := newIndex[k]
 		if ok {
 			addField(fields, FieldType, TypePopular)
+
+			rank, pop := popularityMap[k]
+			if pop {
+				// add popularity rank
+				log.Printf("popularity %s -> %d", k, rank)
+				addField(fields, FieldPopularity, rank)
+			}
 		}
 	}
 
 	// use first track release date for tracks index
 	for k, v := range newIndex {
 		tracks := m.tracksFor([]string{k})
-		date := m.trackFirstReleaseDate(&tracks[0])
+		date, err := m.trackFirstReleaseDate(&tracks[0])
+		if err != nil {
+			continue
+		}
 		s := fmt.Sprintf("%4d-%02d-%02d", date.Year(), date.Month(), date.Day())
 		addField(v, FieldDate, s)
 	}