Use github.com/zmb3/spotify

auth.go

 type SessionData struct {
 	sid      string
 	username string
+	spotify  string
 	priority time.Time
 	index    int
 }
 	}
 
 	expiration := time.Now().Add(duration)
-	addSession(&SessionData{sid, username, expiration, 0})
+	addSession(&SessionData{sid, username, "", expiration, 0})
 
 	return loginCookie, nil
 }

bot.go

 	"flag"
 	"fmt"
 	"github.com/jasonlvhit/gocron"
-	"github.com/lamperi/e4bot/spotify"
+	"github.com/zmb3/spotify"
 	"io"
 	"log"
 	"os"
 )
 
 type App struct {
-	db            *DB
-	credentials   Credentials
-	spotifyClient *spotify.SpotifyClient
+	db          *DB
+	credentials Credentials
+	spotify     *AppSpotify
+}
+type AppSpotify struct {
+	auth   *spotify.Authenticator
+	client *spotify.Client
 }
 
 type Credentials struct {
 	ListenAddr          string
 }
 
-func (app *App) CreateSpotifyClient() *spotify.SpotifyClient {
-	spotifyClient := spotify.NewClient(app.credentials.SpotifyClientID, app.credentials.SpotifyClientSecret)
-	spotifyClient.SetupUserAuthenticate(app.credentials.SpotifyCallback)
-	return spotifyClient
+func (app *App) CreateSpotifyAuthenticator() *spotify.Authenticator {
+	auth := spotify.NewAuthenticator(app.credentials.SpotifyCallback, spotify.ScopePlaylistModifyPublic)
+	auth.SetAuthInfo(app.credentials.SpotifyClientID, app.credentials.SpotifyClientSecret)
+	return &auth
 }
 
 func (app *App) LaunchWeb() {
-	app.spotifyClient = app.CreateSpotifyClient()
+	app.spotify.auth = app.CreateSpotifyAuthenticator()
 	go func() {
-		webStart(app.credentials.ListenAddr, app.db, app.spotifyClient)
+		webStart(app.credentials.ListenAddr, app.db, app.spotify)
 	}()
 }
 
 	return strings.Join(changedLines, "\n")
 }
 
-func findPlaylist(wikiText string) (string, []string) {
+func findPlaylist(wikiText string) (spotify.ID, []spotify.ID) {
 	const SONG_MARK = "<!-- Kappale -->"
 	const SPOTIFY_MARK = "https://open.spotify.com/track/"
 	const SPOTIFY_PLAYLIST_MARK = "/playlist/"
 	const PLAYLIST_MARK = " Spotify-soittolista]"
 	lines := strings.Split(wikiText, "\n")
 
-	playlistId := ""
-	tracks := make([]string, 0)
+	var playlistId spotify.ID
+	tracks := make([]spotify.ID, 0)
 	for _, line := range lines {
 		if strings.Index(line, SONG_MARK) != -1 {
 			i := strings.Index(line, SPOTIFY_MARK)
 					j += i
 				}
 				trackId := line[i+len(SPOTIFY_MARK) : j]
-				tracks = append(tracks, trackId)
+				tracks = append(tracks, spotify.ID(trackId))
 			}
 		} else if strings.Index(line, SPOTIFY_PLAYLIST_MARK) != -1 && strings.Index(line, PLAYLIST_MARK) != -1 {
 			i := strings.Index(line, SPOTIFY_PLAYLIST_MARK)
 			j := strings.Index(line[i:], PLAYLIST_MARK)
 
-			playlistId = line[i+len(SPOTIFY_PLAYLIST_MARK) : i+j]
-			q := strings.Index(playlistId, "?")
+			playlist := line[i+len(SPOTIFY_PLAYLIST_MARK) : i+j]
+			q := strings.Index(playlist, "?")
 			if q != -1 {
-				playlistId = playlistId[:q]
+				playlist = playlist[:q]
 			}
+			playlistId = spotify.ID(playlist)
 		}
 	}
 	log.Printf("Found playlist %s and tracks %s\n", playlistId, tracks)
 
-	return playlistId, tracks
+	return spotify.ID(playlistId), tracks
 }
 
-func appendPlaylist(wikiText string, playlist *spotify.PlaylistInfo) string {
+func appendPlaylist(wikiText string, playlist *spotify.FullPlaylist) string {
 	changedText := wikiText + `
-	[` + playlist.ExternalUrls.Spotify + ` Spotify-soittolista]
+	[` + playlist.ExternalURLs["spotify"] + ` Spotify-soittolista]
 	`
 	return changedText
 }
 
 	sections, err := wiki.GetWikiPageSections(title)
 	if err != nil {
+		log.Println("Error while reading page sections")
 		return err
 	}
 
 
 			wikiText, err := wiki.GetWikiPageSectionText(title, section.index)
 			if err != nil {
+				log.Println("Error reading text from wiki")
 				return err
 			}
 			message := ""
 				message = message + fmt.Sprintf("Calculate averages for week %d. ", weekNumber)
 			}
 
-			if app.spotifyClient.HasUserLogin() {
-				playlistId, tracks := findPlaylist(changedWikiText)
-				currentTracks, err := app.db.FindPlaylistBySection(section.title)
-				if len(tracks) > 0 && (err != nil || reflect.DeepEqual(currentTracks, tracks)) {
+			if app.spotify.client != nil {
+				token, err := app.spotify.client.Token()
+				if err != nil {
+					log.Println("No token available")
+				} else if token.Expiry.Before(time.Now()) {
+					log.Println("Token has expired")
+				} else {
+					log.Println("Checking if playlist needs updating")
+					playlistId, tracks := findPlaylist(changedWikiText)
+					currentTracks, err := app.db.FindPlaylistBySection(section.title)
+					if len(tracks) > 0 && (err != nil || reflect.DeepEqual(currentTracks, tracks)) {
+
+						if playlistId == "" {
+
+							info, err := app.spotify.client.CreatePlaylistForUser(app.credentials.SpotifyUser, title+" "+section.title, true)
+							if err != nil {
+								log.Println("Error creating playlist to Spotify")
+								return err
+							}
+							playlistId = info.ID
+							changedWikiText = appendPlaylist(changedWikiText, info)
+							message = message + fmt.Sprintf("Added link to Spotify playlist for week %d.", weekNumber)
+						}
+						err := app.spotify.client.ReplacePlaylistTracks(app.credentials.SpotifyUser, playlistId, tracks...)
+						if err != nil {
+							log.Println("Error updating playlist to Spotify")
+							return err
+						}
 
-					spotify := app.spotifyClient
-					if playlistId == "" {
+						stringTracks := make([]string, len(tracks))
+						for i, t := range tracks {
+							stringTracks[i] = string(t)
+						}
 
-						info, err := spotify.NewPlaylist(title+" "+section.title, app.credentials.SpotifyUser)
+						_, err = app.db.UpdatePlaylistBySection(section.title, stringTracks)
 						if err != nil {
-							log.Println("Error creating playlist")
+							log.Println("Error updating playlist to DB")
 							return err
 						}
-						playlistId = info.Id
-						changedWikiText = appendPlaylist(changedWikiText, info)
-						message = message + fmt.Sprintf("Added link to Spotify playlist for week %d.", weekNumber)
-					}
-					err := spotify.UpdatePlaylist(app.credentials.SpotifyUser, playlistId, tracks)
-					if err != nil {
-						log.Println("Error updating playlist")
-						return err
-					}
-					_, err = app.db.UpdatePlaylistBySection(section.title, tracks)
-					if err != nil {
-						return err
 					}
 				}
-
 			}
 
 			if message != "" {
 
 				_, err := wiki.EditWikiPageSection(title, section.index, changedWikiText,
 					fmt.Sprintf("Calculate averages for week %d", weekNumber))
-				err = nil
+				//err = errors.New("foo")
 				if err != nil {
 					return err
 				}
 		panic(err)
 	}
 
-	a := App{InitDatabase(), creds, nil}
+	a := App{InitDatabase(), creds, &AppSpotify{}}
 	a.LaunchWeb()
 
 	gocron.Every(1).Minute().Do(a.AutomateSectionTask)

spotify/spotify.go

 package spotify
 
 import (
+	"bytes"
 	"context"
 	"crypto/tls"
 	"encoding/json"
 	"golang.org/x/oauth2/clientcredentials"
 	spotifyAuth "golang.org/x/oauth2/spotify"
 	"io"
+	"log"
 	"net/http"
 	"net/url"
+	"reflect"
 	"strings"
 )
 
 	Total int    `json:"total"`
 }
 
+type SpotifyProfile struct {
+	Birthdate    string       `json:"birthdate"`
+	Country      string       `json:"country"`
+	DisplayName  string       `json:"display_name"`
+	Email        string       `json:"email"`
+	ExternalUrls ExternalUrls `json:"external_urls"`
+	Followers    Followers    `json:"followers"`
+	Id           string       `json:"id"`
+	Product      string       `json:"product"`
+	Type         string       `json:"type"`
+	Uri          string       `json:"uri"`
+}
+
 func NewClient(username, secret string) *SpotifyClient {
 	baseURL, _ := url.Parse("https://api.spotify.com")
 	httpClient := &http.Client{}
 	}
 	token, err := config.Token(context.Background())
 	if err != nil {
-		fmt.Println(err)
+		log.Println(err)
 		return err
 	}
 	s.bearerAuth = token.AccessToken
 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)
+	err := s.doRequest("GET", url, &trackInfo, nil, nil)
 	if err != nil {
 		return nil, err
 	} else {
 	values := &url.Values{}
 	values.Add("name", name)
 	url := s.urlFromBase(fmt.Sprintf("/v1/users/%s/playlists", userId))
-	err := s.doRequest("POST", url, &playlistInfo, values)
+	err := s.doRequest("POST", url, &playlistInfo, values, nil)
 	if err != nil {
 		return nil, err
 	} else {
 	}
 }
 
+type Playlist struct {
+	Uris []string `json:"uris"`
+}
+
 func (s *SpotifyClient) UpdatePlaylist(userId, playlistId string, tracks []string) error {
-	values := &url.Values{}
 	uris := make([]string, 0)
 	for _, track := range tracks {
 		uris = append(uris, "spotify:track:"+track)
 	}
+	//playlist := &Playlist{uris}
+	values := &url.Values{}
 	values.Add("uris", strings.Join(uris, ","))
 
+	result := struct {
+		SnapshotID string `json:"snapshot_id"`
+	}{}
+
 	url := s.urlFromBase(fmt.Sprintf("/v1/users/%s/playlists/%s", userId, playlistId))
-	err := s.doRequest("PUT", url, nil, values)
+	err := s.doRequest("PUT", url, &result, values, nil)
 	return err
 }
 
+func (s *SpotifyClient) GetMe() (*SpotifyProfile, error) {
+	var profile SpotifyProfile
+	url := s.urlFromBase(fmt.Sprintf("/v1/me"))
+	err := s.doRequest("GET", url, &profile, nil, nil)
+	if err != nil {
+		return nil, err
+	} else {
+		return &profile, 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 {
+func (s *SpotifyClient) doRequest(method string, url *url.URL, object interface{}, values *url.Values, inputBody interface{}) error {
 	var bodyReader io.Reader
-	if values != nil {
+	var contentType string
+	if inputBody != nil {
+
+		//pr, pw := io.Pipe()
+		//go func() {
+		//	err := json.NewEncoder(pw).Encode(&inputBody)
+		//	pw.Close()
+		//	if err != nil {
+		//		log.Printf("Spotify: Encoding body failed: %s\n", err.Error())
+		//	}
+		//}()
+
+		var buf bytes.Buffer
+		err := json.NewEncoder(&buf).Encode(&inputBody)
+		log.Printf("Spotify: Body is '%s'\n", buf.String())
+		if err != nil {
+			log.Printf("Spotify: Encoding body failed: %s\n", err.Error())
+			return err
+		}
+
+		bodyReader = &buf
+		contentType = "application/json"
+	} else if values != nil {
 		s := values.Encode()
 		bodyReader = strings.NewReader(s)
+		contentType = "application/x-www-form-urlencoded"
 	}
 
 	req, err := http.NewRequest(method, url.String(), bodyReader)
 	if err != nil {
 		return err
 	}
+	req.Header.Set("Content-Type", contentType)
 
 	if s.bearerAuth != "" {
 		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")
 
+	log.Printf("Spotify: %s %s\n", method, url.Path)
+
 	resp, err := s.httpClient.Do(req)
 	if err != nil {
 		return err
 		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
+	if object != nil {
+		log.Printf("Spotify: Trying to decode payload %s\n", reflect.TypeOf(object))
+		err = json.NewDecoder(resp.Body).Decode(object)
+		if err != nil {
+			return err
+		}
 	}
 	return nil
 
 		return err
 	}
 
-	fmt.Println("Got token from Spotify", token)
+	log.Println("Got token from Spotify", token)
 
 	client := s.config.Client(s.context, token)
 	s.httpClient = client

web.go

 package main
 
 import (
-	"github.com/lamperi/e4bot/spotify"
+	"github.com/zmb3/spotify"
 	"html/template"
 	"log"
 	"net/http"
 	"strings"
+	"time"
 )
 
 var (
 
 	data := struct {
 		Username string
+		Spotify  string
 		Songs    []*Song
 	}{
+		"",
 		"",
 		make([]*Song, 0),
 	}
 		}
 		data.Songs = songs
 		data.Username = session.username
+		data.Spotify = session.spotify
 	}
 
 	var templates = cachedTemplates
 	url := r.Form.Get("url")
 
 	if artist == "" && title == "" && url != "" {
-		log.Println("Resolving Spotify URL")
-		trackID := getTrackID(url)
-		err := s.spotifyClient.Authenticate()
+		if s.spotify.client == nil {
+			http.Error(w, "No Spotify token available", http.StatusInternalServerError)
+			return
+		}
+		token, err := s.spotify.client.Token()
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
+		} else if token.Expiry.Before(time.Now()) {
+			http.Error(w, "Spotify token expired", http.StatusInternalServerError)
+			return
 		}
-		track, err := s.spotifyClient.GetTrack(trackID)
+
+		log.Println("Resolving Spotify URL")
+		trackID := getTrackID(url)
+		track, err := s.spotify.client.GetTrack(spotify.ID(trackID))
 
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			}
 		}
 		title = track.Name
-		url = track.ExternalUrls.Spotify
+		url = track.ExternalURLs["spotify"]
 	}
 
 	updated, err := s.db.UpdateEntry(session.username, round, artist, title, url)
 }
 
 func (s *WebService) SpotifyHandler(w http.ResponseWriter, r *http.Request) {
-	url := s.spotifyClient.GetAuthUrl("foobar")
+	url := s.spotify.auth.AuthURL("foobar")
 	http.Redirect(w, r, url, http.StatusTemporaryRedirect)
 }
 
 func (s *WebService) CallbackHandler(w http.ResponseWriter, r *http.Request) {
 	state := "foobar"
-	err := s.spotifyClient.HandleToken(state, r)
+	token, err := s.spotify.auth.Token(state, r)
 	if err != nil {
 		http.Error(w, "Couldn't get token", http.StatusForbidden)
 		return
 	}
+	session, err := getSession(r)
+	if err != nil {
+		http.Error(w, "Couldn't get session", http.StatusInternalServerError)
+		return
+	}
+	client := s.spotify.auth.NewClient(token)
+	s.spotify.client = &client
+	profile, err := s.spotify.client.CurrentUser()
+	if err != nil {
+		http.Error(w, "Couldn't load profile from Spotify", http.StatusInternalServerError)
+		return
+	}
+	session.spotify = profile.ID
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
 type WebService struct {
-	db            *DB
-	spotifyClient *spotify.SpotifyClient
-	noCache       bool
+	db      *DB
+	spotify *AppSpotify
+	noCache bool
 }
 
-func webStart(listenAddr string, db *DB, spotifyClient *spotify.SpotifyClient) {
-	service := &WebService{db, spotifyClient, true}
+func webStart(listenAddr string, db *DB, spotify *AppSpotify) {
+	service := &WebService{db, spotify, true}
 
 	mux := http.NewServeMux()
 

web/index.html

 
     <div class="container">
         {{if .Username }}
+        {{if .Spotify}}
+        <p>You are logged to Spotify as <strong>{{ .Spotify }}</strong></p>
+        {{else}}
+        <a href="/spotify"><button style="margin-bottom: 1em">Login with Spotify</button></a>
+        {{end}}
         {{range .Songs }}
         <div class="row">
             <small style="width: 70px">{{ .RoundName }}</small>