Convert to postgresql backend

auth.go

 	"container/heap"
 	"crypto/rand"
 	"crypto/sha1"
-	"database/sql"
 	"encoding/base64"
 	"errors"
-	_ "github.com/lib/pq"
 	"golang.org/x/crypto/pbkdf2"
 	"log"
 	"net/http"
 var (
 	sessions     = make(map[string]*SessionData)
 	sessionQueue = make(SessionQueue, 0)
-	db           *sql.DB
 )
 
 func sessionExpirer() {
 
 func init() {
 	go sessionExpirer()
-
-	connStr := "user=levyraati dbname=levyraati sslmode=disable"
-	var err error
-	db, err = sql.Open("postgres", connStr)
-	if err != nil {
-		log.Fatal(err)
-	}
-	_, err = db.Query("SELECT 1")
-	if err != nil {
-		log.Fatal(err)
-	}
 }
 
 func addSession(data *SessionData) {
 
 func userOk(username, password string) (bool, error) {
 	var hash string
-	err := db.QueryRow("SELECT u.password FROM public.user u WHERE lower(u.username) = lower($1)", username).Scan(&hash)
+	err := getDb().QueryRow("SELECT u.password FROM public.user u WHERE lower(u.username) = lower($1)", username).Scan(&hash)
 	if err != nil {
 		if err.Error() == "sql: no rows in result set" {
 			return false, nil

bot.go

 package main
 
 import (
-	"container/heap"
 	"encoding/json"
 	"errors"
 	"fmt"
 	return strings.Join(changedLines, "\n")
 }
 
-func addSong(title string, week int, author string, song string) (bool, error) {
+func addSong(updateTitle, updateSection, author, song string) (bool, error) {
 	wiki := CreateWikiClient(credentials.APIURL, credentials.UserName, credentials.Password)
 
-	sections, err := wiki.GetWikiPageSections(title)
+	sections, err := wiki.GetWikiPageSections(updateTitle)
 	if err != nil {
 		return false, err
 	}
 
-	numberReg, _ := regexp.Compile("\\d+")
 	for _, section := range sections {
-		weekStr := numberReg.FindString(section.title)
-		if weekStr != "" {
-			weekNumber, _ := strconv.Atoi(weekStr)
-			if weekNumber == week {
-				wikiText, err := wiki.GetWikiPageSectionText(title, section.index)
-				if err != nil {
-					return false, err
-				}
-				changedWikiText := appendSong(wikiText, author, song)
+		if updateSection == section.title {
+			wikiText, err := wiki.GetWikiPageSectionText(updateTitle, section.index)
+			if err != nil {
+				return false, err
+			}
+			changedWikiText := appendSong(wikiText, author, song)
 
-				return wiki.EditWikiPageSection(title, section.index, changedWikiText,
-					fmt.Sprintf("Added week %d song for %s", week, author))
+			if false {
+				// Stub
+				fmt.Println("Pretend to update wiki text to ", updateTitle, section.index, changedWikiText,
+					fmt.Sprintf("Added %s song for %s", updateSection, author))
+				return true, nil
 			}
+
+			return wiki.EditWikiPageSection(updateTitle, section.index, changedWikiText,
+				fmt.Sprintf("Added %s song for %s", updateSection, author))
 		}
 	}
 	return false, errors.New("Could not find matching section")
 }
 
-func songSynced(syncedWeek int) error {
-	v, err := loadDb()
+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
 	}
 
-	synced := false
-	for _, song := range v.Songs {
-		if song.Week == syncedWeek {
-			song.Sync = true
-			synced = true
-			err := saveDb(v)
-			if err != nil {
-				return err
-			}
-		}
+	affected, err := res.RowsAffected()
+	if err != nil {
+		return err
 	}
-	if !synced {
-		return errors.New("No week matched from JSON for synced song")
+
+	if affected != 1 {
+		return errors.New("Unknown entry ID")
 	}
-	return errors.New("Week not found")
+	return nil
 }
 
-func getSongs() (SongPriorityQueue, error) {
-	dbSongs, err := loadDb()
+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)
 	if err != nil {
-		return nil, err
+		log.Println("Error while reading songs from database:", err)
+		return
 	}
-
-	songs := make(SongPriorityQueue, len(dbSongs.Songs))
-	for index, songObj := range dbSongs.Songs {
-		songs[index] = &Song{
-			time:  targetTime(songObj),
-			song:  songEntryWikiText(songObj),
-			week:  songObj.Week,
-			sync:  songObj.Sync,
-			index: index,
+	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
 		}
-	}
-	heap.Init(&songs)
-	for len(songs) > 0 && songs[0].sync {
-		heap.Pop(&songs)
-	}
-	return songs, nil
-}
+		song := songWikiText(spotifyURL, artist, title)
 
-func submitSong() {
-	now := time.Now()
-	if len(songs) > 0 && songs[0].time.Before(now) {
-		fmt.Println("Time has passed for " + songs[0].song)
-		success, err := addSong("Levyraati 2018", songs[0].week, "Lamperi", songs[0].song)
+		fmt.Println("Time has passed for " + song)
+
+		success, err := addSong(article, section, username, song)
 		if err != nil {
 			log.Println("Error while adding song:", err)
 		}
 		if success {
-			err := songSynced(songs[0].week)
-			if err == nil {
-				heap.Pop(&songs)
-			} else {
+			err = songSynced(userId, 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 nil
 }
 
-func targetTime(entry *SongEntry) time.Time {
-	yearStart, _ := time.Parse(time.RFC3339, "2018-01-01T00:00:00+02:00")
-	target := yearStart.AddDate(0, 0, (entry.Week-1)*7)
-	return target
-}
-
-func songEntryWikiText(entry *SongEntry) string {
-	return songWikiText(entry.URL, entry.Artist, entry.Title)
-}
-
 func songWikiText(url string, artist string, title string) string {
 	return "[" + url + " " + artist + " - " + title + "]"
 }
 	if err != nil {
 		panic(err)
 	}
-	songs, err = getSongs()
-	if err != nil {
-		panic(err)
-	}
-
-	modifiedSongChan := make(chan *SongEntry)
 
 	spotifyClient := spotify.NewClient(credentials.SpotifyClientID, credentials.SpotifyClientSecret)
 	go func() {
-
-		webStart(credentials.ListenAddr, modifiedSongChan, spotifyClient)
-	}()
-
-	go func() {
-		for {
-			newSong := <-modifiedSongChan
-			matched := false
-			for _, song := range songs {
-				if song.week == newSong.Week {
-					song.song = songEntryWikiText(newSong)
-					song.sync = newSong.Sync
-					matched = true
-					log.Printf("Updated song for week %d, artist: %s, title: %s, URL: %s, time: %v",
-						newSong.Week, newSong.Artist, newSong.Title, newSong.URL, song.time)
-				}
-			}
-			if !matched {
-				song := &Song{
-					time:  targetTime(newSong),
-					song:  songEntryWikiText(newSong),
-					week:  newSong.Week,
-					sync:  newSong.Sync,
-					index: len(songs),
-				}
-				heap.Push(&songs, song)
-				log.Printf("Added song for week %d, artist: %s, title: %s, URL: %s, time: %v",
-					newSong.Week, newSong.Artist, newSong.Title, newSong.URL, song.time)
-			}
-		}
+		webStart(credentials.ListenAddr, spotifyClient)
 	}()
 
 	gocron.Every(1).Hour().Do(fixAveragesTask)

db.go

 package main
 
 import (
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"os"
+	"database/sql"
+	_ "github.com/lib/pq"
+	"log"
 )
 
-type SongsFile struct {
-	Songs []*SongEntry
-}
-
-type SongEntry struct {
-	Week   int
-	Title  string
-	Artist string
-	URL    string
-	Sync   bool
-}
-
-func loadDb() (SongsFile, error) {
+var (
+	database *sql.DB
+)
 
-	var v SongsFile
-	f, err := os.Open("songs.json")
+func init() {
+	connStr := "user=levyraati dbname=levyraati sslmode=disable"
+	var err error
+	database, err = sql.Open("postgres", connStr)
 	if err != nil {
-		return v, err
+		log.Fatal(err)
 	}
-	defer f.Close()
-
+	_, err = database.Query("SELECT 1")
 	if err != nil {
-		return v, err
-	}
-	dec := json.NewDecoder(f)
-	dec.UseNumber()
-	for {
-		if err := dec.Decode(&v); err == io.EOF {
-			break
-		} else if err != nil {
-			return v, err
-		}
+		log.Fatal(err)
 	}
-	return v, nil
 }
 
-func saveDb(v SongsFile) error {
-	jsonValue, err := json.Marshal(v)
-	if err != nil {
-		return err
-	}
-	err = ioutil.WriteFile("songs.json", jsonValue, 0644)
-	return err
+func getDb() *sql.DB {
+	return database
 }

sql/database.sql

 
 CREATE UNIQUE INDEX user_lower_idx
     ON public."user"
-    (lower(username));
+    (lower(username));
+
+-- Table: public.panel
+
+-- DROP TABLE public.panel;
+
+CREATE TABLE public.panel
+(
+    id serial,
+    name text NOT NULL,
+    article text NOT NULL,
+    CONSTRAINT panel_pkey PRIMARY KEY (id)
+);
+
+-- Table: public.user_panel
+
+-- DROP TABLE public.user_panel;
+
+CREATE TABLE public.user_panel
+(
+    user_id integer NOT NULL,
+    panel_id integer NOT NULL,
+    CONSTRAINT user_panel_pkey PRIMARY KEY (user_id, panel_id),
+    CONSTRAINT panel_id FOREIGN KEY (user_id)
+        REFERENCES public.panel (id),
+    CONSTRAINT user_id FOREIGN KEY (user_id)
+        REFERENCES public."user" (id)
+);
+
+-- Table: public.round
+
+-- DROP TABLE public.round;
+
+CREATE TABLE public.round
+(
+    id serial,
+    start timestamp with time zone NOT NULL,
+    "end" timestamp with time zone NOT NULL,
+    panel_id integer NOT NULL,
+    section text NOT NULL,
+    CONSTRAINT round_pkey PRIMARY KEY (id),
+    CONSTRAINT panel_id FOREIGN KEY (panel_id)
+        REFERENCES public.panel (id)
+);
+
+-- Table: public.entry
+
+-- DROP TABLE public.entry;
+
+CREATE TABLE public.entry
+(
+    user_id integer NOT NULL,
+    round_id integer NOT NULL,
+    artist text,
+    title text,
+    spotify_url text,
+    synced boolean NOT NULL DEFAULT false,
+    CONSTRAINT entry_pkey PRIMARY KEY (user_id, round_id)
+);

web.go

 	"html/template"
 	"log"
 	"net/http"
-	"strconv"
 	"strings"
 )
 
 var (
 	cachedTemplates = template.Must(template.ParseFiles("web/index.html"))
-	songsChan       chan *SongEntry
 	spotifyClient   *spotify.SpotifyClient
 )
 
 		return
 	}
 
-	alsoEmptySongs := SongsFile{
-		Songs: make([]*SongEntry, 52),
-	}
-	for week := 1; week <= 52; week++ {
-		alsoEmptySongs.Songs[week-1] = &SongEntry{Week: week}
+	data := struct {
+		Username string
+		Songs    []*struct {
+			RoundID   int
+			RoundName string
+			Title     string
+			Artist    string
+			URL       string
+			Sync      bool
+		}
+	}{
+		"",
+		make([]*struct {
+			RoundID   int
+			RoundName string
+			Title     string
+			Artist    string
+			URL       string
+			Sync      bool
+		}, 0),
 	}
-	username := ""
+
 	session, err := getSession(r)
 	if session != nil {
-		songs, err := loadDb()
+		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)
 		if err != nil {
+			log.Println("Error while executing query", err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
-		for _, song := range songs.Songs {
-			alsoEmptySongs.Songs[song.Week-1] = song
+		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
+			}
 		}
-		username = session.username
+		data.Username = session.username
 	}
 
 	var templates = cachedTemplates
 		templates = template.Must(template.ParseFiles("web/index.html"))
 	}
 
-	data := struct {
-		Username string
-		Songs    []*SongEntry
-	}{
-		username,
-		alsoEmptySongs.Songs,
-	}
 	err = templates.ExecuteTemplate(w, "index.html", data)
 	if err != nil {
+		log.Println("Error while rendering template", err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
 }
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	week, err := strconv.Atoi(r.Form.Get("week"))
-	if err != nil {
-		http.Error(w, "week parameter not provided", http.StatusBadRequest)
-		return
-	}
+	round := r.Form.Get("round")
 	artist := r.Form.Get("artist")
 	title := r.Form.Get("title")
 	url := r.Form.Get("url")
-	sync := r.Form.Get("sync")
 
 	if artist == "" && title == "" && url != "" {
 		log.Println("Resolving Spotify URL")
 		url = track.ExternalUrls.Spotify
 	}
 
-	songs, err := loadDb()
+	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)
+
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-
-	matched := false
-	for _, song := range songs.Songs {
-		if song.Week == week {
-			song.Artist = artist
-			song.Title = title
-			song.URL = url
-			if song.Sync && sync != "on" {
-				song.Sync = false
-			}
-			songsChan <- song
-			matched = true
-		}
-	}
-	if !matched {
-		song := &SongEntry{
-			Artist: artist,
-			Title:  title,
-			URL:    url,
-			Week:   week,
-		}
-		songs.Songs = append(songs.Songs, song)
-		songsChan <- song
-	}
-
-	err = saveDb(songs)
+	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)
+		return
+	}
+
+	log.Printf("Updated song for round %s, artist: %s, title: %s, URL: %s",
+		round, artist, title, url)
+
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
 	http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
 }
 
-func webStart(listenAddr string, modifiedSongChan chan *SongEntry, spot *spotify.SpotifyClient) {
-	songsChan = modifiedSongChan
+func webStart(listenAddr string, spot *spotify.SpotifyClient) {
 	spotifyClient = spot
 
 	mux := http.NewServeMux()

web/index.html

         {{if .Username }}
         {{range .Songs }}
         <div class="row">
-            <small style="width: 70px">Week {{ .Week }}</small>
+            <small style="width: 70px">{{ .RoundName }}</small>
             <form class="form-inline" method="post" action="/update">
                 <label class="sr-only" for="artist">Artist</label>
                 <input class="form-control mb-2 mr-sm-2" name="artist" placeholder="Enter Artist"  value="{{ .Artist }}">
                     <label class="form-check-label" for="synced">Track is synced</label>
                 </div>
                 
-                <input type="hidden" name="week" value="{{ .Week }}">
+                <input type="hidden" name="round" value="{{ .RoundID }}">
                 <button type="submit" class="btn btn-primary mb-2">Update track</button>
             </form>