Implements integration with Spotify

bot.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/jasonlvhit/gocron"
+	"github.com/lamperi/e4bot/spotify"
 	"io"
 	"log"
 	"os"
@@ -18,9 +19,11 @@ import (
 var songs SongPriorityQueue
 
 var credentials struct {
-	APIURL   string
-	UserName string
-	Password string
+	APIURL              string
+	UserName            string
+	Password            string
+	SpotifyClientID     string
+	SpotifyClientSecret string
 }
 
 func appendSong(wikiText string, author string, newSong string) string {
@@ -317,8 +320,10 @@ func main() {
 
 	modifiedSongChan := make(chan *SongEntry)
 
+	spotifyClient := spotify.NewClient(credentials.SpotifyClientID, credentials.SpotifyClientSecret)
 	go func() {
-		webStart(modifiedSongChan)
+
+		webStart(modifiedSongChan, spotifyClient)
 	}()
 
 	go func() {

spotify/spotify.go

@@ -0,0 +1,177 @@
+package spotify
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"golang.org/x/oauth2/clientcredentials"
+	spotifyAuth "golang.org/x/oauth2/spotify"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type SpotifyClient struct {
+	clientID     string
+	clientSecret string
+	bearerAuth   string
+	baseURL      *url.URL
+	httpClient   *http.Client
+}
+
+type TrackInfo struct {
+	Album        AlbumInfo    `json:"album"`
+	Artists      []ArtistInfo `json:"artists"`
+	DiskNumber   int          `json:"disc_number"`
+	DurationMS   int          `json:"duration_ms"`
+	Explicit     bool         `json:"explicit"`
+	ExternalIds  ExternalIds  `json:"external_ids"`
+	ExternalUrls ExternalUrls `json:"external_urls"`
+	Href         string       `json:"href"`
+	ID           string       `json:"id"`
+	IsPlayable   bool         `json:"is_playable"`
+	Name         string       `json:"name"`
+	Popularity   int          `json:"popularity"`
+	PreviewUrl   string       `json:"preview_url"`
+	TrackNumber  int          `json:"track_number"`
+	Type         string       `json:"type"`
+	Uri          string       `json:"uri"`
+}
+
+type AlbumInfo struct {
+	AlbumType    string       `json:"album_type"`
+	Artists      []ArtistInfo `json:"artists"`
+	ExternalUrls ExternalUrls `json:"external_urls"`
+	Href         string       `json:"href"`
+	ID           string       `json:"id"`
+	Images       []ImageInfo  `json:"images"`
+	Name         string       `json:"name"`
+	Type         string       `json:"type"`
+	Uri          string       `json:"uri"`
+}
+
+type ArtistInfo struct {
+	ExternalUrls ExternalUrls `json:"external_urls"`
+	Href         string       `json:"href"`
+	ID           string       `json:"id"`
+	Name         string       `json:"name"`
+	Type         string       `json:"type"`
+	Uri          string       `json:"uri"`
+}
+
+type ImageInfo struct {
+	Height int    `json:"height"`
+	URL    string `json:url`
+	Width  int    `json:"width"`
+}
+
+type ExternalIds struct {
+	ISRC string `json:"isrc"`
+}
+type ExternalUrls struct {
+	Spotify string `json:"spotify"`
+}
+
+type TokenInfo struct {
+	AccessToken string `json:"access_token"`
+	TokenType   string `json:"token_type"`
+	ExpiresIn   int    `json:"expires_in"`
+}
+
+type AuthErrorResponse struct {
+	Error            string `json:"error"`
+	ErrorDescription string `json:"error_description"`
+}
+
+type ErrorResponse struct {
+	Error ErrorInfo `json:"error"`
+}
+
+type ErrorInfo struct {
+	Status  int    `json:"status"`
+	Message string `json:"message"`
+}
+
+func NewClient(username, secret string) *SpotifyClient {
+	baseURL, _ := url.Parse("https://api.spotify.com")
+	httpClient := &http.Client{}
+	return &SpotifyClient{
+		clientID:     username,
+		clientSecret: secret,
+		baseURL:      baseURL,
+		httpClient:   httpClient,
+	}
+}
+
+func (s *SpotifyClient) Authenticate() error {
+	config := &clientcredentials.Config{
+		ClientID:     s.clientID,
+		ClientSecret: s.clientSecret,
+		TokenURL:     spotifyAuth.Endpoint.TokenURL,
+	}
+	token, err := config.Token(context.Background())
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	s.bearerAuth = token.AccessToken
+	return nil
+}
+
+func (s *SpotifyClient) GetTrack(trackId string) (*TrackInfo, error) {
+	var trackInfo TrackInfo
+	url := s.urlFromBase(fmt.Sprintf("/v1/tracks/%s", trackId))
+	err := s.doRequest("GET", url, &trackInfo, nil)
+	if err != nil {
+		return nil, err
+	} else {
+		return &trackInfo, nil
+	}
+}
+
+func (s *SpotifyClient) urlFromBase(path string) *url.URL {
+	endpoint := &url.URL{Path: path}
+	return s.baseURL.ResolveReference(endpoint)
+}
+
+func (s *SpotifyClient) doRequest(method string, url *url.URL, object interface{}, values *url.Values) error {
+	var bodyReader io.Reader
+	if values != nil {
+		s := values.Encode()
+		bodyReader = strings.NewReader(s)
+	}
+
+	req, err := http.NewRequest(method, url.String(), bodyReader)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", s.bearerAuth))
+
+	if values != nil {
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "github.com/lamperi/e4bot/spotify")
+
+	resp, err := s.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		var errorResp ErrorResponse
+		err = json.NewDecoder(resp.Body).Decode(&errorResp)
+		return errors.New(fmt.Sprintf("Spotify API returned: %d: %s", resp.StatusCode, errorResp.Error.Message))
+	}
+
+	err = json.NewDecoder(resp.Body).Decode(object)
+	if err != nil {
+		return err
+	}
+	return nil
+
+}

spotify/spotify_test.go

@@ -0,0 +1,49 @@
+package spotify
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func getAuthorization() (string, string) {
+	envVars := os.Environ()
+	for _, envVar := range envVars {
+		key_val := strings.Split(envVar, "=")
+		if key_val[0] == "SPOTIFY_TOKEN" {
+			username_secret := strings.Split(key_val[1], ":")
+			return username_secret[0], username_secret[1]
+		}
+	}
+	return "", ""
+}
+
+func createClient(t *testing.T) *SpotifyClient {
+	username, secret := getAuthorization()
+	if username == "" {
+		t.Fatal("Spotify authorization token not available, please use it as env variable SPOTIFY_TOKEN")
+	}
+	client := NewClient(username, secret)
+	err := client.Authenticate()
+	if err != nil {
+		t.Fatal("Spotify authentication failed", err)
+	}
+	return client
+}
+
+func TestGetTrackInfo(t *testing.T) {
+	client := createClient(t)
+	track, err := client.GetTrack("5fLiaYOzIAk0PpwJ2VQUpT")
+	if err != nil {
+		t.Error("Error while reading Track", err)
+	}
+	if track.Artists[0].Name != "Vesala" {
+		t.Error("Expected track artist to be 'Vesala'")
+	}
+	if track.Name != "Rakkaus ja maailmanloppu" {
+		t.Error("Expected track artist to be 'Rakkaus ja maailmanloppu'")
+	}
+	if track.ExternalUrls.Spotify != "https://open.spotify.com/track/5fLiaYOzIAk0PpwJ2VQUpT" {
+		t.Error("Expected track artist to be 'https://open.spotify.com/track/5fLiaYOzIAk0PpwJ2VQUpT'")
+	}
+}

web.go

@@ -1,14 +1,18 @@
 package main
 
 import (
+	"github.com/lamperi/e4bot/spotify"
 	"html/template"
+	"log"
 	"net/http"
 	"strconv"
+	"strings"
 )
 
 var (
 	cachedTemplates = template.Must(template.ParseFiles("web/index.html"))
 	songsChan       chan *SongEntry
+	spotifyClient   *spotify.SpotifyClient
 )
 
 func indexHandler(w http.ResponseWriter, r *http.Request) {
@@ -55,13 +59,29 @@ func indexHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func getTrackID(url string) string {
+	const externalURLPrefix = "https://open.spotify.com/track/"
+	const trackURIPrefix = "spotify:track:"
+	if strings.HasPrefix(url, externalURLPrefix) {
+		return strings.Split(url, externalURLPrefix)[1]
+	} else if strings.HasPrefix(url, trackURIPrefix) {
+		return strings.Split(url, trackURIPrefix)[1]
+	}
+	return url
+}
+
 func updateHandler(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Path != "/update" {
 		http.Error(w, "Forbidden", http.StatusForbidden)
 		return
 	}
+	session, err := getSession(r)
+	if session == nil {
+		http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
+		return
+	}
 
-	err := r.ParseForm()
+	err = r.ParseForm()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -76,6 +96,33 @@ func updateHandler(w http.ResponseWriter, r *http.Request) {
 	url := r.Form.Get("url")
 	sync := r.Form.Get("sync")
 
+	if artist == "" && title == "" && url != "" {
+		log.Println("Resolving Spotify URL")
+		trackID := getTrackID(url)
+		err := spotifyClient.Authenticate()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		track, err := spotifyClient.GetTrack(trackID)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		log.Printf("Found Track with name %v and artists %v\n", track.Name, track.Artists)
+		for index, trackArtist := range track.Artists {
+			if index == 0 {
+				artist = trackArtist.Name
+			} else if index == 1 {
+				artist = artist + " feat. " + trackArtist.Name
+			} else {
+				artist = artist + ", " + trackArtist.Name
+			}
+		}
+		title = track.Name
+	}
+
 	songs, err := loadDb()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -136,8 +183,9 @@ func loginHandler(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
-func webStart(modifiedSongChan chan *SongEntry) {
+func webStart(modifiedSongChan chan *SongEntry, spot *spotify.SpotifyClient) {
 	songsChan = modifiedSongChan
+	spotifyClient = spot
 
 	mux := http.NewServeMux()