Refactor to use instances

auth.go

 	return pbkdf2.Key(password, salt, 4096, 32, sha1.New)
 }
 
-func userOk(username, password string) (bool, error) {
-	var hash string
-	err := getDb().QueryRow("SELECT u.password FROM public.user u WHERE lower(u.username) = lower($1)", username).Scan(&hash)
+func userOk(db *DB, username, password string) (bool, error) {
+	hash, err := db.FindHashForUser(username)
 	if err != nil {
 		if err.Error() == "sql: no rows in result set" {
 			return false, nil
 	return ok, nil
 }
 
-func tryLogin(username, password string, longerTime bool) (http.Cookie, error) {
-	if exists, err := userOk(username, password); !exists {
+func tryLogin(db *DB, username, password string, longerTime bool) (http.Cookie, error) {
+	if exists, err := userOk(db, username, password); !exists {
 		if err != nil {
 			return http.Cookie{}, err
 		}

bot.go

 import (
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"github.com/jasonlvhit/gocron"
 	"github.com/lamperi/e4bot/spotify"
 	"time"
 )
 
-var songs SongPriorityQueue
+type App struct {
+	db          *DB
+	credentials Credentials
+}
 
-var credentials struct {
+type Credentials struct {
 	APIURL              string
 	UserName            string
 	Password            string
 	ListenAddr          string
 }
 
+func (app *App) CreateSpotifyClient() *spotify.SpotifyClient {
+	spotifyClient := spotify.NewClient(app.credentials.SpotifyClientID, app.credentials.SpotifyClientSecret)
+	return spotifyClient
+}
+
+func (app *App) LaunchWeb() {
+	spotifyClient := app.CreateSpotifyClient()
+	go func() {
+		webStart(app.credentials.ListenAddr, app.db, spotifyClient)
+	}()
+}
+
 func appendSong(wikiText string, author string, newSong string) string {
 	const AUTHOR_MARK = "<!-- Lisääjä -->"
 	const SONG_MARK = "<!-- Kappale -->"
 	return strings.Join(changedLines, "\n")
 }
 
-func addSong(updateTitle, updateSection, author, song string) (bool, error) {
-	wiki := CreateWikiClient(credentials.APIURL, credentials.UserName, credentials.Password)
+func (app *App) wikiClient() *WikiClient {
+	wiki := CreateWikiClient(app.credentials.APIURL, app.credentials.UserName, app.credentials.Password)
+	return wiki
+}
+
+func (app *App) AddSong(updateTitle, updateSection, author, song string) (bool, error) {
+	wiki := app.wikiClient()
 
 	sections, err := wiki.GetWikiPageSections(updateTitle)
 	if err != nil {
 	return false, errors.New("Could not find matching section")
 }
 
-func songSynced(userId, roundId int) error {
-	query := `UPDATE public.entry SET synced = true WHERE user_id = $1 AND round_id = $2`
-	res, err := getDb().Exec(query, userId, roundId)
-
-	if err != nil {
-		return err
-	}
-
-	affected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if affected != 1 {
-		return errors.New("Unknown entry ID")
-	}
-	return nil
+func (app *App) SongSynced(userId, roundId int) error {
+	_, err := app.db.EntrySynced(userId, roundId)
+	return err
 }
 
-func submitSong() {
-	query := `
-	SELECT e.user_id, e.round_id, e.artist, e.title, e.spotify_url, p.article, u.username, r.section
-	FROM public.entry e 
-	JOIN public."user" u ON u.id = e.user_id
-	JOIN public.round r ON r.id = e.round_id
-	JOIN public.panel p ON p.id = r.panel_id
-	WHERE r.start < current_timestamp AND e.synced = false`
-	rows, err := getDb().Query(query)
+func (app *App) SubmitSongs() {
+	entries, err := app.db.FindEntriesToSync()
 	if err != nil {
-		log.Println("Error while reading songs from database:", err)
+		log.Println("Error while finding entries to sync:", err)
 		return
 	}
-	defer rows.Close()
-	for rows.Next() {
-		var (
-			userId, roundId                                       int
-			artist, title, spotifyURL, article, username, section string
-		)
-		err := rows.Scan(&userId, &roundId, &artist, &title, &spotifyURL, &article, &username, &section)
-		if err != nil {
-			log.Println("Error while scanning row:", err)
-			continue
-		}
-		song := songWikiText(spotifyURL, artist, title)
+
+	for _, entry := range entries {
+		song := songWikiText(entry.spotifyURL, entry.artist, entry.title)
 
 		fmt.Println("Time has passed for " + song)
 
-		success, err := addSong(article, section, username, song)
+		success, err := app.AddSong(entry.article, entry.section, entry.username, song)
 		if err != nil {
 			log.Println("Error while adding song:", err)
 		}
 		if success {
-			err = songSynced(userId, roundId)
+			err = app.SongSynced(entry.userId, entry.roundId)
 			if err != nil {
 				fmt.Println("Error received:", err)
 			}
 		}
 	}
-	err = rows.Err()
-	if err != nil {
-		log.Println("Error after reading cursor:", err)
-		return
-	}
 }
 
 func isCurrentAuthor(line, author string) bool {
 	return strings.Join(changedLines, "\n")
 }
 
-func fixAverages(title string) error {
-	wiki := CreateWikiClient(credentials.APIURL, credentials.UserName, credentials.Password)
+func (app *App) FixAverages(title string) error {
+	wiki := app.wikiClient()
 
 	sections, err := wiki.GetWikiPageSections(title)
 	if err != nil {
 	return nil
 }
 
-func fixAveragesTask() {
-	err := fixAverages("Levyraati 2018")
+func (app *App) FixAveragesTask() {
+	err := app.FixAverages("Levyraati 2018")
 	if err != nil {
 		fmt.Println("Error while calculating averages:", err)
 	}
 }
 
-func initCreds() error {
-	f, err := os.Open("credentials.json")
+func initCreds() (Credentials, error) {
+	var credsFile string
+	flag.StringVar(&credsFile, "credentials", "credentials.json", "JSON config to hold app credentials")
+	flag.Parse()
+
+	var credentials Credentials
+	f, err := os.Open(credsFile)
 	if err != nil {
-		return err
+		return credentials, err
 	}
 	defer f.Close()
 
 	if err != nil {
 		log.Fatal(err)
-		return err
+		return credentials, err
 	}
 	dec := json.NewDecoder(f)
 	for {
 			log.Fatal(err)
 		}
 	}
-	return nil
+	return credentials, nil
 }
 
 func songWikiText(url string, artist string, title string) string {
 }
 
 func main() {
-	err := initCreds()
+	creds, err := initCreds()
 	if err != nil {
 		panic(err)
 	}
 
-	spotifyClient := spotify.NewClient(credentials.SpotifyClientID, credentials.SpotifyClientSecret)
-	go func() {
-		webStart(credentials.ListenAddr, spotifyClient)
-	}()
-
-	gocron.Every(1).Hour().Do(fixAveragesTask)
+	a := App{InitDatabase(), creds}
+	a.LaunchWeb()
 
-	gocron.Every(1).Second().Do(submitSong)
+	gocron.Every(1).Hour().Do(a.FixAveragesTask)
+	gocron.Every(1).Second().Do(a.SubmitSongs)
 	<-gocron.Start()
 
 }

db.go

 
 import (
 	"database/sql"
+	"errors"
 	_ "github.com/lib/pq"
 	"log"
 )
 
-var (
+type DB struct {
 	database *sql.DB
-)
+}
 
-func init() {
+func InitDatabase() *DB {
 	connStr := "user=levyraati dbname=levyraati sslmode=disable"
 	var err error
-	database, err = sql.Open("postgres", connStr)
+	database, err := sql.Open("postgres", connStr)
 	if err != nil {
 		log.Fatal(err)
 	}
 	if err != nil {
 		log.Fatal(err)
 	}
+	return &DB{database}
+}
+
+func (db *DB) FindHashForUser(username string) (string, error) {
+	var hash string
+	err := db.database.QueryRow("SELECT u.password FROM public.user u WHERE lower(u.username) = lower($1)", username).Scan(&hash)
+	return hash, err
+}
+
+func (db *DB) EntrySynced(userId, roundId int) (bool, error) {
+	query := `UPDATE public.entry SET synced = true WHERE user_id = $1 AND round_id = $2`
+	res, err := db.database.Exec(query, userId, roundId)
+
+	if err != nil {
+		return false, err
+	}
+
+	affected, err := res.RowsAffected()
+	if err != nil {
+		return false, err
+	}
+
+	if affected != 1 {
+		return false, errors.New("Unknown entry ID")
+	}
+	return true, nil
+
+}
+
+func (db *DB) FindEntriesToSync() ([]*EntryToSync, error) {
+	query := `
+	SELECT e.user_id, e.round_id, e.artist, e.title, e.spotify_url, p.article, u.username, r.section
+	FROM public.entry e 
+	JOIN public."user" u ON u.id = e.user_id
+	JOIN public.round r ON r.id = e.round_id
+	JOIN public.panel p ON p.id = r.panel_id
+	WHERE r.start < current_timestamp AND e.synced = false`
+	rows, err := db.database.Query(query)
+
+	if err != nil {
+		log.Println("Error while reading songs from database:", err)
+		return nil, err
+	}
+	defer rows.Close()
+	var entries []*EntryToSync
+	for rows.Next() {
+		var (
+			userId, roundId                                       int
+			artist, title, spotifyURL, article, username, section string
+		)
+		err := rows.Scan(&userId, &roundId, &artist, &title, &spotifyURL, &article, &username, &section)
+		if err != nil {
+			log.Println("Error while scanning row:", err)
+			return nil, err
+		}
+		entries = append(entries, &EntryToSync{userId, roundId, artist, title, spotifyURL, article, username, section})
+	}
+	err = rows.Err()
+	if err != nil {
+		log.Println("Error after reading cursor:", err)
+		return nil, err
+	}
+	return entries, nil
+}
+
+type EntryToSync struct {
+	userId, roundId                                       int
+	artist, title, spotifyURL, article, username, section string
 }
 
-func getDb() *sql.DB {
-	return database
+func (db *DB) FindAllEntries(username string) ([]*Song, error) {
+	var songs []*Song
+	query := `
+		SELECT r.id, r.section, e.artist, e.title, e.spotify_url, e.synced
+		FROM public.round r
+		LEFT JOIN public.entry e ON r.id = e.round_id
+		LEFT JOIN public."user" u ON u.id = e.user_id AND lower(u.username) = lower($1)
+		ORDER BY r.start ASC`
+	rows, err := db.database.Query(query, username)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for i := 0; rows.Next(); i++ {
+		song := &Song{}
+		songs = append(songs, song)
+		var (
+			artist, title, url *string
+			sync               *bool
+		)
+		err = rows.Scan(&songs[i].RoundID, &songs[i].RoundName, &artist, &title, &url, &sync)
+		if err != nil {
+			return nil, err
+		}
+		if artist != nil {
+			song.Artist = *artist
+		}
+		if title != nil {
+			song.Title = *title
+		}
+		if url != nil {
+			song.URL = *url
+		}
+		if sync != nil {
+			song.Sync = *sync
+		}
+	}
+	return songs, nil
+}
+
+type Song struct {
+	RoundID   int
+	RoundName string
+	Title     string
+	Artist    string
+	URL       string
+	Sync      bool
+}
+
+func (db *DB) UpdateEntry(username, round, artist, title, url string) (bool, error) {
+	query := `
+	INSERT INTO public.entry
+	SELECT id, $2, $3, $4, $5, false
+	FROM public."user" u
+	WHERE lower(u.username) = lower($1)
+	ON CONFLICT (user_id, round_id) DO UPDATE SET artist = EXCLUDED.artist, title = EXCLUDED.title, spotify_url = EXCLUDED.spotify_url, synced = EXCLUDED.synced`
+	res, err := db.database.Exec(query, username, round, artist, title, url)
+
+	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.go

-package main
-
-import (
-	"time"
-)
-
-// From https://golang.org/pkg/container/heap/
-
-type Song struct {
-	time  time.Time
-	song  string
-	week  int
-	sync  bool
-	index int
-}
-
-type SongPriorityQueue []*Song
-
-func (pq SongPriorityQueue) Len() int {
-	return len(pq)
-}
-
-func (pq SongPriorityQueue) Less(i, j int) bool {
-	return pq[i].time.Before(pq[j].time)
-
-}
-func (pq SongPriorityQueue) Swap(i, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-	pq[i].index = i
-	pq[j].index = j
-}
-
-func (pq *SongPriorityQueue) Push(x interface{}) {
-	n := len(*pq)
-	item := x.(*Song)
-	item.index = n
-	*pq = append(*pq, item)
-}
-
-func (pq *SongPriorityQueue) Pop() interface{} {
-	old := *pq
-	n := len(old)
-	item := old[n-1]
-	item.index = -1 // for safety
-	*pq = old[0 : n-1]
-	return item
-}

web.go

 
 var (
 	cachedTemplates = template.Must(template.ParseFiles("web/index.html"))
-	spotifyClient   *spotify.SpotifyClient
 )
 
-func indexHandler(w http.ResponseWriter, r *http.Request) {
+func (s *WebService) IndexHandler(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Path != "/" {
 		http.Error(w, "Not Found", http.StatusNotFound)
 		return
 
 	data := struct {
 		Username string
-		Songs    []*struct {
-			RoundID   int
-			RoundName string
-			Title     string
-			Artist    string
-			URL       string
-			Sync      bool
-		}
+		Songs    []*Song
 	}{
 		"",
-		make([]*struct {
-			RoundID   int
-			RoundName string
-			Title     string
-			Artist    string
-			URL       string
-			Sync      bool
-		}, 0),
+		make([]*Song, 0),
 	}
 
 	session, err := getSession(r)
 	if session != nil {
-		query := `
-		SELECT r.id, r.section, e.artist, e.title, e.spotify_url, e.synced
-		FROM public.round r
-		LEFT JOIN public.entry e ON r.id = e.round_id
-		LEFT JOIN public."user" u ON u.id = e.user_id AND lower(u.username) = lower($1)
-		ORDER BY r.start ASC`
-		rows, err := getDb().Query(query, session.username)
+		songs, err := s.db.FindAllEntries(session.username)
 		if err != nil {
-			log.Println("Error while executing query", err)
+			log.Println("Error while reading entries from database", err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
-		defer rows.Close()
-		for i := 0; rows.Next(); i++ {
-			row := &struct {
-				RoundID   int
-				RoundName string
-				Title     string
-				Artist    string
-				URL       string
-				Sync      bool
-			}{}
-			data.Songs = append(data.Songs, row)
-			var (
-				artist, title, url *string
-				sync               *bool
-			)
-			err = rows.Scan(&data.Songs[i].RoundID, &data.Songs[i].RoundName, &artist, &title, &url, &sync)
-			if err != nil {
-				log.Println("Error while scanning cursor", err)
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-			if artist != nil {
-				row.Artist = *artist
-			}
-			if title != nil {
-				row.Title = *title
-			}
-			if url != nil {
-				row.URL = *url
-			}
-			if sync != nil {
-				row.Sync = *sync
-			}
-		}
+		data.Songs = songs
 		data.Username = session.username
 	}
 
 	var templates = cachedTemplates
-	if true {
+	if s.noCache {
 		templates = template.Must(template.ParseFiles("web/index.html"))
 	}
 
 	return url
 }
 
-func updateHandler(w http.ResponseWriter, r *http.Request) {
+func (s *WebService) UpdateHandler(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Path != "/update" {
 		http.Error(w, "Forbidden", http.StatusForbidden)
 		return
 	if artist == "" && title == "" && url != "" {
 		log.Println("Resolving Spotify URL")
 		trackID := getTrackID(url)
-		err := spotifyClient.Authenticate()
+		err := s.spotifyClient.Authenticate()
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
-		track, err := spotifyClient.GetTrack(trackID)
+		track, err := s.spotifyClient.GetTrack(trackID)
 
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 		url = track.ExternalUrls.Spotify
 	}
 
-	query := `
-	INSERT INTO public.entry
-	SELECT id, $2, $3, $4, $5, false
-	FROM public."user" u
-	WHERE lower(u.username) = lower($1)
-	ON CONFLICT (user_id, round_id) DO UPDATE SET artist = EXCLUDED.artist, title = EXCLUDED.title, spotify_url = EXCLUDED.spotify_url, synced = EXCLUDED.synced`
-	res, err := getDb().Exec(query, session.username, round, artist, title, url)
-
+	updated, err := s.db.UpdateEntry(session.username, round, artist, title, url)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	affected, err := res.RowsAffected()
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if affected != 1 {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+	if !updated {
+		http.Error(w, "No round in DB", http.StatusNotFound)
 		return
 	}
 
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
-func loginHandler(w http.ResponseWriter, r *http.Request) {
+func (s *WebService) LoginHandler(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 	remember := r.Form.Get("remember")
 	longer := remember == "remember-me"
 
-	cookie, err := tryLogin(username, password, longer)
+	cookie, err := tryLogin(s.db, username, password, longer)
 
 	if err != nil {
 		log.Println("Error while trying to login", err.Error())
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
-func webStart(listenAddr string, spot *spotify.SpotifyClient) {
-	spotifyClient = spot
+type WebService struct {
+	db            *DB
+	spotifyClient *spotify.SpotifyClient
+	noCache       bool
+}
+
+func webStart(listenAddr string, db *DB, spotifyClient *spotify.SpotifyClient) {
+	service := &WebService{db, spotifyClient, true}
 
 	mux := http.NewServeMux()
 
 	mux.Handle("/fonts/", fs)
 	mux.Handle("/js/", fs)
 	mux.Handle("/favicon.ico", fs)
-	mux.HandleFunc("/", indexHandler)
-	mux.HandleFunc("/update", updateHandler)
-	mux.HandleFunc("/login", loginHandler)
+	mux.HandleFunc("/", service.IndexHandler)
+	mux.HandleFunc("/update", service.UpdateHandler)
+	mux.HandleFunc("/login", service.LoginHandler)
 
 	http.ListenAndServe(listenAddr, mux)
 }