Create playlists to Spotify automatically, WIP

bot.go

 	"io"
 	"log"
 	"os"
+	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
 )
 
 type App struct {
-	db          *DB
-	credentials Credentials
+	db            *DB
+	credentials   Credentials
+	spotifyClient *spotify.SpotifyClient
 }
 
 type Credentials struct {
 	Password            string
 	SpotifyClientID     string
 	SpotifyClientSecret string
+	SpotifyUser         string
 	ListenAddr          string
 }
 
 func (app *App) CreateSpotifyClient() *spotify.SpotifyClient {
 	spotifyClient := spotify.NewClient(app.credentials.SpotifyClientID, app.credentials.SpotifyClientSecret)
+	spotifyClient.SetupUserAuthenticate()
 	return spotifyClient
 }
 
 func (app *App) LaunchWeb() {
-	spotifyClient := app.CreateSpotifyClient()
+	app.spotifyClient = app.CreateSpotifyClient()
 	go func() {
-		webStart(app.credentials.ListenAddr, app.db, spotifyClient)
+		webStart(app.credentials.ListenAddr, app.db, app.spotifyClient)
 	}()
 }
 
 	return strings.Join(changedLines, "\n")
 }
 
-func (app *App) FixAverages(title string) error {
+func findPlaylist(wikiText string) (string, []string) {
+	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)
+	for _, line := range lines {
+		if strings.Index(line, SONG_MARK) != -1 {
+			i := strings.Index(line, SPOTIFY_MARK)
+			if i != -1 {
+				j := strings.Index(line[i:], " ")
+				if j != -1 {
+					j += i
+				}
+				trackId := line[i+len(SPOTIFY_MARK) : j]
+				tracks = append(tracks, 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, "?")
+			if q != -1 {
+				playlistId = playlistId[:q]
+			}
+		}
+	}
+	fmt.Printf("Found playlist %s and tracks %s\n", playlistId, tracks)
+
+	return playlistId, tracks
+}
+
+func appendPlaylist(wikiText string, playlist *spotify.PlaylistInfo) string {
+	changedText := wikiText + `
+	[` + playlist.ExternalUrls.Spotify + ` Spotify-soittolista]
+	`
+	return changedText
+}
+
+func (app *App) AutomateSection(title string) error {
 	wiki := app.wikiClient()
 
 	sections, err := wiki.GetWikiPageSections(title)
 			if weekNumber > currentWeek {
 				break
 			}
+			fmt.Println("Checking section", section.title)
 
 			wikiText, err := wiki.GetWikiPageSectionText(title, section.index)
 			if err != nil {
 				return err
 			}
+			message := ""
 			changedWikiText := appendAverages(wikiText)
 			if changedWikiText != wikiText {
-				//fmt.Println(wikiText)
-				//fmt.Println(changedWikiText)
+				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)) {
+
+					spotify := app.spotifyClient
+					if playlistId == "" {
+
+						info, err := spotify.NewPlaylist(title+" "+section.title, app.credentials.SpotifyUser)
+						if err != nil {
+							log.Println("Error creating playlist")
+							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
+					}
+				}
+
+			}
 
-				_, err := wiki.EditWikiPageSection(title, section.index, changedWikiText,
-					fmt.Sprintf("Calculate averages for week %d", weekNumber))
+			if message != "" {
+				fmt.Println(changedWikiText)
+
+				//_, err := wiki.EditWikiPageSection(title, section.index, changedWikiText,
+				//	fmt.Sprintf("Calculate averages for week %d", weekNumber))
+				err = nil
 				if err != nil {
 					return err
 				}
 	return nil
 }
 
-func (app *App) FixAveragesTask() {
-	err := app.FixAverages("Levyraati 2018")
+func (app *App) AutomateSectionTask() {
+	panels, err := app.db.FindAllPanels()
 	if err != nil {
-		fmt.Println("Error while calculating averages:", err)
+		fmt.Println("Error while checking db for panels:", err)
+		return
+	}
+	for _, panel := range panels {
+		fmt.Println("Checking panel", panel)
+		err := app.AutomateSection(panel)
+		if err != nil {
+			fmt.Println("Error while processing panel:", err)
+		}
 	}
+
 }
 
 func initCreds() (Credentials, error) {
 		panic(err)
 	}
 
-	a := App{InitDatabase(), creds}
+	a := App{InitDatabase(), creds, nil}
 	a.LaunchWeb()
 
-	gocron.Every(1).Hour().Do(a.FixAveragesTask)
+	gocron.Every(1).Hour().Do(a.AutomateSectionTask)
 	gocron.Every(1).Second().Do(a.SubmitSongs)
 	<-gocron.Start()
 

db.go

 	}
 	return true, nil
 }
+
+func (db *DB) FindAllPanels() ([]string, error) {
+	query := `
+	SELECT name FROM public.panel`
+	rows, err := db.database.Query(query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	names := make([]string, 0)
+	for i := 0; rows.Next(); i++ {
+		var name string
+		err := rows.Scan(&name)
+		if err != nil {
+			return nil, err
+		}
+		names = append(names, name)
+	}
+	return names, nil
+}
+
+func (db *DB) FindPlaylistBySection(sectionName string) ([]string, error) {
+	query := `
+	SELECT pl.tracks FROM public.round_playlist pl 
+	JOIN public.round r ON pl.round_id = r.id
+	WHERE r.section = $1`
+	row := db.database.QueryRow(query, sectionName)
+	var tracks []string
+	err := row.Scan(&tracks)
+	if err != nil {
+		return nil, err
+	}
+	return tracks, nil
+}
+
+func (db *DB) UpdatePlaylistBySection(sectionName string, tracks []string) (bool, error) {
+	query := `
+	INSERT INTO public.round_playlist pl
+	SELECT r.id, $2
+	FROM public.round r 
+	WHERE r.section = $1
+	ON CONFLICT (pl.round_id) DO UPDATE SET tracks = EXCLUDED.tracks`
+	res, err := db.database.Exec(query, sectionName, tracks)
+
+	if err != nil {
+		return false, err
+	}
+	affected, err := res.RowsAffected()
+	if err != nil {
+		return false, err
+	}
+	if affected != 1 {
+		return false, nil
+	}
+	return true, nil
+}

songs.json

-{"Songs":[{"Week":1,"Title":"Party (papiidipaadi)","Artist":"Antti Tuisku feat. Nikke Ankara","URL":"https://open.spotify.com/album/4T5cveHFQ5qZkRfZAJPcP7?si=ll_ktjrpQeW-U9KBOAcgvQ","Sync":true},
-    {"Week":2,"Title":"Poro","Artist":"Eläkeläiset","URL":"https://open.spotify.com/track/7BGxxc7n5rGkFhiV50pVC6","Sync":true},
-    {"Week":26,"Title":"Summer of '69","Artist":"Bryan Adams","URL":"https://open.spotify.com/track/3bYCGWnZdLQjndiKogqA3G","Sync":false}]}

spotify/spotify.go

 
 import (
 	"context"
+	"crypto/tls"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"golang.org/x/oauth2"
 	"golang.org/x/oauth2/clientcredentials"
 	spotifyAuth "golang.org/x/oauth2/spotify"
 	"io"
 	bearerAuth   string
 	baseURL      *url.URL
 	httpClient   *http.Client
+	config       *oauth2.Config
+	context      context.Context
 }
 
 type TrackInfo struct {
 	Message string `json:"message"`
 }
 
+type PlaylistInfo struct {
+	Collaborative bool         `json:"collaborative"`
+	Description   string       `json:"description"`
+	ExternalUrls  ExternalUrls `json:"external_urls"`
+	Followers     Followers    `json:"followers"`
+	Href          string       `json:"href"`
+	Id            string       `json:"id"`
+	// TODO images
+	Name string `json:"name"`
+	// TODO owner
+	Public     bool       `json:"public"`
+	SnapshotId string     `json:"snapshot_id"`
+	Tracks     TracksInfo `json:"tracks"`
+	Type       string     `json:"type"`
+	Uri        string     `json:"uri"`
+}
+
+type TracksInfo struct {
+	Href     string          `json:"href"`
+	Items    []PlaylistTrack `json:"items"`
+	Limit    int             `json:"limit"`
+	Next     string          `json:"next"`
+	Offset   int             `json:"offset"`
+	Type     string          `json:"type"`
+	Previous string          `json:"string"`
+	Total    int             `json:"total"`
+}
+
+type PlaylistTrack struct {
+	AddedAt string    `json:"added_at"`
+	AddedBy string    `json:"added_by"`
+	IsLocal bool      `json:"is_local"`
+	Track   TrackInfo `json":track"`
+}
+
+type Followers struct {
+	Href  string `json:"href"`
+	Total int    `json:"total"`
+}
+
 func NewClient(username, secret string) *SpotifyClient {
 	baseURL, _ := url.Parse("https://api.spotify.com")
 	httpClient := &http.Client{}
 	return nil
 }
 
+func (s *SpotifyClient) SetupUserAuthenticate() error {
+	s.config = &oauth2.Config{
+		ClientID:     s.clientID,
+		ClientSecret: s.clientSecret,
+		RedirectURL:  "http://localhost:8080/callback",
+		Scopes:       []string{"playlist-modify-public"},
+		Endpoint:     spotifyAuth.Endpoint,
+	}
+	tr := &http.Transport{
+		TLSNextProto: map[string]func(authority string, c *tls.Conn) http.RoundTripper{},
+	}
+	s.context = context.WithValue(context.Background(), oauth2.HTTPClient, &http.Client{Transport: tr})
+	return nil
+}
+
 func (s *SpotifyClient) GetTrack(trackId string) (*TrackInfo, error) {
 	var trackInfo TrackInfo
 	url := s.urlFromBase(fmt.Sprintf("/v1/tracks/%s", trackId))
 	}
 }
 
+func (s *SpotifyClient) NewPlaylist(name, userId string) (*PlaylistInfo, error) {
+	var playlistInfo PlaylistInfo
+	values := &url.Values{}
+	values.Add("name", name)
+	url := s.urlFromBase(fmt.Sprintf("/v1/users/%s/playlists", userId))
+	err := s.doRequest("POST", url, &playlistInfo, values)
+	if err != nil {
+		return nil, err
+	} else {
+		return &playlistInfo, nil
+	}
+}
+
+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)
+	}
+	values.Add("uris", strings.Join(uris, ","))
+
+	url := s.urlFromBase(fmt.Sprintf("/v1/users/%s/playlists/%s", userId, playlistId))
+	err := s.doRequest("PUT", url, nil, values)
+	return err
+}
+
 func (s *SpotifyClient) urlFromBase(path string) *url.URL {
 	endpoint := &url.URL{Path: path}
 	return s.baseURL.ResolveReference(endpoint)
 	if err != nil {
 		return err
 	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", s.bearerAuth))
+
+	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")
 	return nil
 
 }
+
+func (s *SpotifyClient) GetAuthUrl(state string) string {
+	return s.config.AuthCodeURL(state)
+}
+
+func (s *SpotifyClient) HandleToken(state string, r *http.Request) error {
+	values := r.URL.Query()
+	if e := values.Get("error"); e != "" {
+		return errors.New("spotify: auth failed - " + e)
+	}
+	code := values.Get("code")
+	if code == "" {
+		return errors.New("spotify: didn't get access code")
+	}
+	actualState := values.Get("state")
+	if actualState != state {
+		return errors.New("spotify: redirect state parameter doesn't match")
+	}
+	token, err := s.config.Exchange(s.context, code)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Got token from Spotify", token)
+
+	client := s.config.Client(s.context, token)
+	s.httpClient = client
+	return nil
+}
+
+func (s *SpotifyClient) HasUserLogin() bool {
+	return s.httpClient != nil && s.config != nil && s.context != nil
+}

sql/database.sql

     synced boolean NOT NULL DEFAULT false,
     CONSTRAINT entry_pkey PRIMARY KEY (user_id, round_id)
 );
+
+
+-- Table: public.round_playlist
+
+-- DROP TABLE public.round_playlist;
+
+CREATE TABLE public.round_playlist
+(
+    round_id int,
+    tracks text[],
+    CONSTRAINT round_id FOREIGN KEY (round_id)
+        REFERENCES public.round (id)
+);

web.go

 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
+func (s *WebService) SpotifyHandler(w http.ResponseWriter, r *http.Request) {
+	url := s.spotifyClient.GetAuthUrl("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)
+	if err != nil {
+		http.Error(w, "Couldn't get token", http.StatusForbidden)
+		return
+	}
+	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
+}
+
 type WebService struct {
 	db            *DB
 	spotifyClient *spotify.SpotifyClient
 	mux.HandleFunc("/", service.IndexHandler)
 	mux.HandleFunc("/update", service.UpdateHandler)
 	mux.HandleFunc("/login", service.LoginHandler)
+	mux.HandleFunc("/spotify", service.SpotifyHandler)
+	mux.HandleFunc("/callback", service.CallbackHandler)
 
 	http.ListenAndServe(listenAddr, mux)
 }