func (spotify *Spotify) artistAlbums(artist *sconsify.Artist) {
if simpleAlbumPage, err := spotify.client.GetArtistAlbums(webspotify.ID(artist.GetSpotifyID())); err == nil {
folder := sconsify.InitFolder(artist.URI, "*"+artist.Name, make([]*sconsify.Playlist, 0))
if fullTracks, err := spotify.client.GetArtistsTopTracks(webspotify.ID(artist.GetSpotifyID()), "GB"); err == nil {
tracks := make([]*sconsify.Track, len(fullTracks))
for i, track := range fullTracks {
tracks[i] = sconsify.InitWebApiTrack(string(track.URI), artist, track.Name, track.TimeDuration().String())
}
folder.AddPlaylist(sconsify.InitPlaylist(artist.URI, " "+artist.Name+" Top Tracks", tracks))
}
infrastructure.Debugf("# of albums %v", len(simpleAlbumPage.Albums))
for _, simpleAlbum := range simpleAlbumPage.Albums {
infrastructure.Debugf("AlbumsID %v = %v", simpleAlbum.URI, simpleAlbum.Name)
playlist := sconsify.InitOnDemandPlaylist(string(simpleAlbum.URI), " "+simpleAlbum.Name, true, func(playlist *sconsify.Playlist) {
infrastructure.Debugf("Album id %v", playlist.ToSpotifyID())
if simpleTrackPage, err := spotify.client.GetAlbumTracks(webspotify.ID(playlist.ToSpotifyID())); err == nil {
infrastructure.Debugf("# of tracks %v", len(simpleTrackPage.Tracks))
for _, track := range simpleTrackPage.Tracks {
playlist.AddTrack(sconsify.InitWebApiTrack(string(track.URI), artist, track.Name, track.TimeDuration().String()))
}
}
})
folder.AddPlaylist(playlist)
}
spotify.events.ArtistAlbums(folder)
}
}
func (spotify *Spotify) initTrack(playlistTrack *sp.PlaylistTrack) *sconsify.Track {
track := playlistTrack.Track()
track.Wait()
for i := 0; i < track.Artists(); i++ {
track.Artist(i).Wait()
}
infrastructure.Debugf("\tTrack '%v' (%v)", track.Link().String(), track.Name())
return sconsify.ToSconsifyTrack(track)
}
func (spotify *Spotify) search(query string) {
playlists := sconsify.InitPlaylists()
name := " " + query
playlist := sconsify.InitSearchPlaylist(name, name, func(playlist *sconsify.Playlist) {
options := createWebSpotifyOptions(50, playlist.Tracks())
if searchResult, err := spotify.getWebApiClient().SearchOpt(query, webspotify.SearchTypeTrack, options); err == nil {
numberOfTracks := len(searchResult.Tracks.Tracks)
infrastructure.Debugf("Search '%v' returned %v track(s)", query, numberOfTracks)
for _, track := range searchResult.Tracks.Tracks {
webArtist := track.Artists[0]
artist := sconsify.InitArtist(string(webArtist.URI), webArtist.Name)
playlist.AddTrack(sconsify.InitWebApiTrack(string(track.URI), artist, track.Name, track.TimeDuration().String()))
infrastructure.Debugf("\tTrack '%v' (%v)", track.URI, track.Name)
}
} else {
infrastructure.Debugf("Spotify search returning error: %v", err)
}
})
playlist.ExecuteLoad()
playlists.AddPlaylist(playlist)
spotify.events.NewPlaylist(playlists)
}
func (spotify *Spotify) initPlaylist() error {
playlists := sconsify.InitPlaylists()
allPlaylists, err := spotify.session.Playlists()
if err != nil {
return err
}
allPlaylists.Wait()
var folderPlaylists []*sconsify.Playlist
var folder *sp.PlaylistFolder
infrastructure.Debugf("# of playlists %v", allPlaylists.Playlists())
for i := 0; i < allPlaylists.Playlists(); i++ {
if allPlaylists.PlaylistType(i) == sp.PlaylistTypeStartFolder {
folder, _ = allPlaylists.Folder(i)
folderPlaylists = make([]*sconsify.Playlist, 0)
infrastructure.Debugf("Opening folder '%v' (%v)", folder.Id(), folder.Name())
} else if allPlaylists.PlaylistType(i) == sp.PlaylistTypeEndFolder {
if folder != nil {
playlists.AddPlaylist(sconsify.InitFolder(strconv.Itoa(int(folder.Id())), folder.Name(), folderPlaylists))
infrastructure.Debugf("Closing folder '%v' (%v)", folder.Id(), folder.Name())
} else {
infrastructure.Debug("Closing a null folder, this doesn't look right ")
}
folderPlaylists = nil
folder = nil
}
if allPlaylists.PlaylistType(i) != sp.PlaylistTypePlaylist {
continue
}
playlist := allPlaylists.Playlist(i)
playlist.Wait()
if spotify.canAddPlaylist(playlist, allPlaylists.PlaylistType(i)) {
id := playlist.Link().String()
infrastructure.Debugf("Playlist '%v' (%v)", id, playlist.Name())
tracks := make([]*sconsify.Track, playlist.Tracks())
infrastructure.Debugf("\t# of tracks %v", playlist.Tracks())
for i := 0; i < playlist.Tracks(); i++ {
tracks[i] = spotify.initTrack(playlist.Track(i))
}
if folderPlaylists == nil {
playlists.AddPlaylist(sconsify.InitPlaylist(id, playlist.Name(), tracks))
} else {
folderPlaylists = append(folderPlaylists, sconsify.InitSubPlaylist(id, playlist.Name(), tracks))
}
}
}
webApiCache := spotify.loadWebApiCacheIfNecessary()
if spotify.client != nil {
playlists.AddPlaylist(sconsify.InitOnDemandFolder("Albums", "*Albums", true, func(playlist *sconsify.Playlist) {
spotify.loadAlbums(playlist, webApiCache)
spotify.persistWebApiCache(webApiCache)
}))
playlists.AddPlaylist(sconsify.InitOnDemandPlaylist("Songs", "*Songs", false, func(playlist *sconsify.Playlist) {
spotify.loadSongs(playlist, webApiCache)
spotify.persistWebApiCache(webApiCache)
}))
playlists.AddPlaylist(sconsify.InitOnDemandFolder("New Releases", "*New Releases", true, func(playlist *sconsify.Playlist) {
spotify.loadNewReleases(playlist, webApiCache)
spotify.persistWebApiCache(webApiCache)
}))
} else {
if webApiCache.Albums != nil {
playlist := sconsify.InitOnDemandFolder("Albums", "*Albums", true, func(playlist *sconsify.Playlist) {
spotify.loadAlbums(playlist, webApiCache)
})
playlist.ExecuteLoad()
playlists.AddPlaylist(playlist)
}
if webApiCache.Songs != nil {
playlist := sconsify.InitOnDemandPlaylist("Songs", "*Songs", true, func(playlist *sconsify.Playlist) {
spotify.loadSongs(playlist, webApiCache)
})
playlist.ExecuteLoad()
playlists.AddPlaylist(playlist)
}
if webApiCache.NewReleases != nil {
playlist := sconsify.InitOnDemandFolder("New Releases", "*New Releases", true, func(playlist *sconsify.Playlist) {
spotify.loadNewReleases(playlist, webApiCache)
})
playlist.ExecuteLoad()
playlists.AddPlaylist(playlist)
}
}
spotify.events.NewPlaylist(playlists)
return nil
}
